//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : LUA_GeoBasel.cpp       Data : 20.12.14        Versione : 1.5l2
// Contenuto : Funzioni generali per LUA.
//
//
//
// Modifiche : 27.09.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "LUA.h"
#include "/EgtDev/Include/EGkLuaAux.h"

using namespace std ;

//-------------------------------------------------------------------------------
static int
LuaVectorRotate( lua_State* L)
{
  // 3 parametri : Vector, VtAsse, AngRot in gradi
   Vector3d vtV ;
   LuaCheckParam( L, 1, vtV)
   Vector3d vtAx ;
   LuaCheckParam( L, 2, vtAx)
   double dAngRotDeg ;
   LuaCheckParam( L, 3, dAngRotDeg)
   LuaClearStack( L) ;
  // eseguo la rotazione
   if ( vtV.Rotate( vtAx, dAngRotDeg)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, vtV) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaVectorMirror( lua_State* L)
{
  // 2 parametri : Vector, VtN
   Vector3d vtV ;
   LuaCheckParam( L, 1, vtV)
   Vector3d vtN ;
   LuaCheckParam( L, 2, vtN)
   LuaClearStack( L) ;
  // eseguo il mirror
   if ( vtV.Mirror( vtN)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, vtV) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaVectorToGlob( lua_State* L)
{
  // 2 parametri : Vector, frame di trasformazione
   Vector3d vtV ;
   LuaCheckParam( L, 1, vtV)
   Frame3d frTool ;
   LuaCheckParam( L, 2, frTool)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( vtV.ToGlob( frTool)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, vtV) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaVectorToLoc( lua_State* L)
{
  // 2 parametri : Vector, frame di trasformazione
   Vector3d vtV ;
   LuaCheckParam( L, 1, vtV)
   Frame3d frTool ;
   LuaCheckParam( L, 2, frTool)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( vtV.ToLoc( frTool)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, vtV) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaVectorLocToLoc( lua_State* L)
{
  // 3 parametri : Vector, frame origine, frame destinazione
   Vector3d vtV ;
   LuaCheckParam( L, 1, vtV)
   Frame3d frOri ;
   LuaCheckParam( L, 2, frOri)
   Frame3d frDest ;
   LuaCheckParam( L, 3, frDest)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( vtV.LocToLoc( frOri, frDest)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, vtV) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaPointRotate( lua_State* L)
{
  // 4 parametri : Point, PtAsse, VtAsse, AngRot in gradi
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Point3d ptAx ;
   LuaCheckParam( L, 2, ptAx)
   Vector3d vtAx ;
   LuaCheckParam( L, 3, vtAx)
   double dAngRotDeg ;
   LuaCheckParam( L, 4, dAngRotDeg)
   LuaClearStack( L) ;
  // eseguo la rotazione
   if ( ptP.Rotate( ptAx, vtAx, dAngRotDeg)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, ptP) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaPointMirror( lua_State* L)
{
  // 3 parametri : Point, PtOn, VtN
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 3, vtN)
   LuaClearStack( L) ;
  // eseguo il mirror
   if ( ptP.Mirror( ptOn, vtN)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, ptP) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaPointToGlob( lua_State* L)
{
  // 2 parametri : Point, frame di trasformazione
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Frame3d frTool ;
   LuaCheckParam( L, 2, frTool)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( ptP.ToGlob( frTool)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, ptP) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaPointToLoc( lua_State* L)
{
  // 2 parametri : Point, frame di trasformazione
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Frame3d frTool ;
   LuaCheckParam( L, 2, frTool)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( ptP.ToLoc( frTool)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, ptP) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaPointLocToLoc( lua_State* L)
{
  // 3 parametri : Point, frame origine, frame destinazione
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Frame3d frOri ;
   LuaCheckParam( L, 2, frOri)
   Frame3d frDest ;
   LuaCheckParam( L, 3, frDest)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( ptP.LocToLoc( frOri, frDest)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, ptP) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaFrameFrom3Points( lua_State* L)
{
  // 3 parametri : origine, punto su X, punto vicino a Y
   Point3d ptOrig ;
   LuaCheckParam( L, 1, ptOrig)
   Point3d ptOnX ;
   LuaCheckParam( L, 2, ptOnX)
   Point3d ptNearY ;
   LuaCheckParam( L, 3, ptNearY)
   LuaClearStack( L) ;
  // calcolo il riferimento e restituisco il risultato : bOk, Frame
   Frame3d frTemp ;
   if ( frTemp.Set( ptOrig, ptOnX, ptNearY)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, frTemp) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaFrameOCS( lua_State* L)
{
  // 2 parametri : origine, asse Z
   Point3d ptOrig ;
   LuaCheckParam( L, 1, ptOrig)
   Vector3d vtDirZ ;
   LuaCheckParam( L, 2, vtDirZ)
   LuaClearStack( L) ;
  // calcolo il riferimento e restituisco il risultato : bOk, Frame
   Frame3d frTemp ;
   if ( frTemp.Set( ptOrig, vtDirZ)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, frTemp) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaFrameRotate( lua_State* L)
{
  // 4 parametri : Frame, PtAsse, VtAsse, AngRot in gradi
   Frame3d frFrame ;
   LuaCheckParam( L, 1, frFrame)
   Point3d ptAx ;
   LuaCheckParam( L, 2, ptAx)
   Vector3d vtAx ;
   LuaCheckParam( L, 3, vtAx)
   double dAngRotDeg ;
   LuaCheckParam( L, 4, dAngRotDeg)
   LuaClearStack( L) ;
  // eseguo la rotazione
   if ( frFrame.Rotate( ptAx, vtAx, dAngRotDeg)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, frFrame) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaFrameToGlob( lua_State* L)
{
  // 2 parametri : frame, frame di trasformazione
   Frame3d frFrame ;
   LuaCheckParam( L, 1, frFrame)
   Frame3d frTool ;
   LuaCheckParam( L, 2, frTool)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( frFrame.ToGlob( frTool)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, frFrame) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaFrameToLoc( lua_State* L)
{
  // 2 parametri : frame, frame di trasformazione
   Frame3d frFrame ;
   LuaCheckParam( L, 1, frFrame)
   Frame3d frTool ;
   LuaCheckParam( L, 2, frTool)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( frFrame.ToLoc( frTool)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, frFrame) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaFrameLocToLoc( lua_State* L)
{
  // 3 parametri : frame, frame origine, frame destinazione
   Frame3d frFrame ;
   LuaCheckParam( L, 1, frFrame)
   Frame3d frOri ;
   LuaCheckParam( L, 2, frOri)
   Frame3d frDest ;
   LuaCheckParam( L, 3, frDest)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( frFrame.LocToLoc( frOri, frDest)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, frFrame) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaFrameGetRotationsCAC1( lua_State* L)
{
  // 1 parametro : frame
   Frame3d frFrame ;
   LuaCheckParam( L, 1, frFrame)
   LuaClearStack( L) ;
  // calcolo gli angoli di rotazione
   double dAngCDeg, dAngADeg, dAngC1Deg ;
   if ( frFrame.GetRotationsCAC1( dAngCDeg, dAngADeg, dAngC1Deg)) {
      LuaSetParam( L, dAngCDeg) ;
      LuaSetParam( L, dAngADeg) ;
      LuaSetParam( L, dAngC1Deg) ;
      return 3 ;
   }
   else {
      LuaSetParam( L) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaFrameGetFixedAxesRotationsABC( lua_State* L)
{
  // 1 parametro : frame
   Frame3d frFrame ;
   LuaCheckParam( L, 1, frFrame)
   LuaClearStack( L) ;
  // calcolo gli angoli di rotazione
   double dAngADeg, dAngBDeg, dAngCDeg ;
   if ( frFrame.GetFixedAxesRotationsABC( dAngADeg, dAngBDeg, dAngCDeg)) {
      LuaSetParam( L, dAngADeg) ;
      LuaSetParam( L, dAngBDeg) ;
      LuaSetParam( L, dAngCDeg) ;
      return 3 ;
   }
   else {
      LuaSetParam( L) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaBBoxRotate( lua_State* L)
{
  // 4 parametri : bbox, PtAsse, VtAsse, AngRot in gradi
   BBox3d b3Box ;
   LuaCheckParam( L, 1, b3Box)
   Point3d ptAx ;
   LuaCheckParam( L, 2, ptAx)
   Vector3d vtAx ;
   LuaCheckParam( L, 3, vtAx)
   double dAngRotDeg ;
   LuaCheckParam( L, 4, dAngRotDeg)
   LuaClearStack( L) ;
  // eseguo la rotazione
   if ( b3Box.Rotate( ptAx, vtAx, dAngRotDeg)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, b3Box) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaBBoxToGlob( lua_State* L)
{
  // 2 parametri : bbox, frame di trasformazione
   BBox3d b3Box ;
   LuaCheckParam( L, 1, b3Box)
   Frame3d frTool ;
   LuaCheckParam( L, 2, frTool)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( b3Box.ToGlob( frTool)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, b3Box) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaBBoxToLoc( lua_State* L)
{
  // 2 parametri : bbox, frame di trasformazione
   BBox3d b3Box ;
   LuaCheckParam( L, 1, b3Box)
   Frame3d frTool ;
   LuaCheckParam( L, 2, frTool)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( b3Box.ToLoc( frTool)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, b3Box) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaBBoxLocToLoc( lua_State* L)
{
  // 3 parametri : bbox, frame origine, frame destinazione
   BBox3d b3Box ;
   LuaCheckParam( L, 1, b3Box)
   Frame3d frOri ;
   LuaCheckParam( L, 2, frOri)
   Frame3d frDest ;
   LuaCheckParam( L, 3, frDest)
   LuaClearStack( L) ;
  // eseguo la trasformazione
   if ( b3Box.LocToLoc( frOri, frDest)) {
      LuaSetParam( L, true) ;
      LuaSetParam( L, b3Box) ;
      return 2 ;
   }
   else {
      LuaSetParam( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaQuaternionFromAxisAngle( lua_State* L)
{
  // 2 parametri : vtAx, dAngDeg
   Vector3d vtAx ;
   LuaCheckParam( L, 1, vtAx)
   double dAngDeg ;
   LuaCheckParam( L, 2, dAngDeg)
   LuaClearStack( L) ;
  // calcolo il quaternione che produce la rotazione equivalente
   Quaternion qtQ = FromAxisAngle( vtAx, dAngDeg) ;
   if ( ! qtQ.IsSmall())
      LuaSetParam( L, qtQ) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaQuaternionToAxisAngle( lua_State* L)
{
  // 1 parametro : Quaternion
   Quaternion qtQ ;
   LuaCheckParam( L, 1, qtQ)
   LuaClearStack( L) ;
  // calcolo l'asse e l'angolo di rotazione equivalenti
   Vector3d vtAx ;
   double dAngDeg ;
   bool bOk = ToAxisAngle( qtQ, vtAx, dAngDeg) ;
   if ( bOk) {
      LuaSetParam( L, vtAx) ;
      LuaSetParam( L, dAngDeg) ;
      return 2 ;
   }
   else {
      LuaSetParam( L) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
static int
LuaQuaternionFromFrame( lua_State* L)
{
  // 1 parametro : Frame
   Frame3d frFrame ;
   LuaCheckParam( L, 1, frFrame)
   LuaClearStack( L) ;
  // calcolo il quaternione che produce l'orientamento di questo frame tramite rotazione dal globale
   Quaternion qtQ = FromFrame( frFrame) ;
   if ( ! qtQ.IsSmall())
      LuaSetParam( L, qtQ) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaQuaternionToFrame( lua_State* L)
{
  // 1 parametro : Quaternion
   Quaternion qtQ ;
   LuaCheckParam( L, 1, qtQ)
   LuaClearStack( L) ;
  // calcolo il frame equivalente come orientamento a quello globale ruotato dal quaternione
   Frame3d frFrame ;
   bool bOk = ToFrame( qtQ, frFrame) ;
   if ( bOk)
      LuaSetParam( L, frFrame) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGeoBase( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVectorRotate", LuaVectorRotate) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVectorMirror", LuaVectorMirror) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVectorToGlob", LuaVectorToGlob) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVectorToLoc", LuaVectorToLoc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVectorLocToLoc", LuaVectorLocToLoc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPointRotate", LuaPointRotate) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPointMirror", LuaPointMirror) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPointToGlob", LuaPointToGlob) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPointToLoc", LuaPointToLoc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPointLocToLoc", LuaPointLocToLoc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFrameFrom3Points", LuaFrameFrom3Points) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFrameOCS", LuaFrameOCS) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFrameRotate", LuaFrameRotate) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFrameToGlob", LuaFrameToGlob) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFrameToLoc", LuaFrameToLoc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFrameLocToLoc", LuaFrameLocToLoc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFrameGetRotCAC1", LuaFrameGetRotationsCAC1) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFrameGetFixedAxesRotABC", LuaFrameGetFixedAxesRotationsABC) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxRotate", LuaBBoxRotate) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxToGlob", LuaBBoxToGlob) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxToLoc", LuaBBoxToLoc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxLocToLoc", LuaBBoxLocToLoc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionFromAxisAngle", LuaQuaternionFromAxisAngle) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionToAxisAngle", LuaQuaternionToAxisAngle) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionFromFrame", LuaQuaternionFromFrame) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionToFrame", LuaQuaternionToFrame) ;
   return bOk ;
}