//----------------------------------------------------------------------------
//  EgalTech 2018-2018
//----------------------------------------------------------------------------
// File : LUA_GeoInters.cpp       Data : 27.09.18        Versione : 1.9i4
// Contenuto : Funzioni di intersezione tra oggetti geometrici per LUA.
//
//
//
// Modifiche : 27.09.18 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

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

using namespace std ;

//----------------------------------------------------------------------------
static int
LuaLineCurveInters( lua_State* L)
{
  // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Vector3d vtDir ;
   LuaCheckParam( L, 2, vtDir)
   int nId ;
   LuaCheckParam( L, 3, nId)
   int nRefType = nId ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // recupero i punti di intersezione tra linea e curva
   INTDBLVECTOR vInters ;
   if ( ExeLineCurveInters( ptP, vtDir, nId, nRefType, vInters)) {
      LuaSetParam( L, true) ;
      INTVECTOR vType( vInters.size()) ;
      DBLVECTOR vPar( vInters.size()) ;
      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
         vType[i] = vInters[i].first ;
         vPar[i] = vInters[i].second ;
      }
      LuaSetParam( L, vType) ;
      LuaSetParam( L, vPar) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L) ;
      LuaSetParam( L) ;
   }
   return 3 ;
}

//----------------------------------------------------------------------------
static int
LuaLineBoxInters( lua_State* L)
{
  // 3 parametri : ptP, vtDir, b3Box
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Vector3d vtDir ;
   LuaCheckParam( L, 2, vtDir)
   BBox3d b3Box ;
   LuaCheckParam( L, 3, b3Box)
   LuaClearStack( L) ;
  // recupero i punti di intersezione tra linea e superficie trimesh
   INTDBLVECTOR vInters ;
   if ( ExeLineBoxInters( ptP, vtDir, b3Box, vInters)) {
      LuaSetParam( L, true) ;
      INTVECTOR vType( vInters.size()) ;
      DBLVECTOR vPar( vInters.size()) ;
      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
         vType[i] = vInters[i].first ;
         vPar[i] = vInters[i].second ;
      }
      LuaSetParam( L, vType) ;
      LuaSetParam( L, vPar) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L) ;
      LuaSetParam( L) ;
   }
   return 3 ;
}

//----------------------------------------------------------------------------
static int
LuaLineSurfTmInters( lua_State* L)
{
  // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Vector3d vtDir ;
   LuaCheckParam( L, 2, vtDir)
   int nId ;
   LuaCheckParam( L, 3, nId)
   int nRefType = nId ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // recupero i punti di intersezione tra linea e superficie trimesh
   INTDBLVECTOR vInters ;
   if ( ExeLineSurfTmInters( ptP, vtDir, nId, nRefType, vInters)) {
      LuaSetParam( L, true) ;
      INTVECTOR vType( vInters.size()) ;
      DBLVECTOR vPar( vInters.size()) ;
      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
         vType[i] = vInters[i].first ;
         vPar[i] = vInters[i].second ;
      }
      LuaSetParam( L, vType) ;
      LuaSetParam( L, vPar) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L) ;
      LuaSetParam( L) ;
   }
   return 3 ;
}

//----------------------------------------------------------------------------
static int
LuaLineSurfBzInters( lua_State* L)
{
   // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
      Vector3d vtDir ;
   LuaCheckParam( L, 2, vtDir)
      int nId ;
   LuaCheckParam( L, 3, nId)
      int nRefType = nId ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
   // recupero i punti di intersezione tra linea e superficie trimesh
   INTDBLVECTOR vInters ;
   if ( ExeLineSurfBzInters( ptP, vtDir, nId, nRefType, vInters)) {
      LuaSetParam( L, true) ;
      INTVECTOR vType( vInters.size()) ;
      DBLVECTOR vPar( vInters.size()) ;
      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
         vType[i] = vInters[i].first ;
         vPar[i] = vInters[i].second ;
      }
      LuaSetParam( L, vType) ;
      LuaSetParam( L, vPar) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L) ;
      LuaSetParam( L) ;
   }
   return 3 ;
}

//----------------------------------------------------------------------------
static int
LuaLineVolZmapInters( lua_State* L)
{
  // 3 o 4 parametri : ptP, vtDir, Id, [, nRefId]
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Vector3d vtDir ;
   LuaCheckParam( L, 2, vtDir)
   int nId ;
   LuaCheckParam( L, 3, nId)
   int nRefType = nId ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // eseguo calcolo intersezione
   INTDBLVECTOR vInters ;
   if ( ExeLineVolZmapInters( ptP, vtDir, nId, nRefType, vInters)) {
      LuaSetParam( L, true) ;
      INTVECTOR vType( vInters.size()) ;
      DBLVECTOR vPar( vInters.size()) ;
      for ( size_t i = 0 ; i < vInters.size() ; ++ i) {
         vType[i] = vInters[i].first ;
         vPar[i] = vInters[i].second ;
      }
      LuaSetParam( L, vType) ;
      LuaSetParam( L, vPar) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L) ;
      LuaSetParam( L) ;
   }
   return 3 ;
}

//----------------------------------------------------------------------------
static int
LuaPlaneCurveInters( lua_State* L)
{
  // 4 o 5 parametri : ptOn, vtN, nId, nDestGrpId [, nRefType] 
   Point3d ptOn ;
   LuaCheckParam( L, 1, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 2, vtN)
   int nId ;
   LuaCheckParam( L, 3, nId)
   int nDestGrpId ;
   LuaCheckParam( L, 4, nDestGrpId) ;
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 5, nRefType) ;
   LuaClearStack( L) ;
  // eseguo l'intersezione
   int nCount = 0 ;
   int nNewId = ExePlaneCurveInters( ptOn, vtN, nId, nDestGrpId, nRefType, &nCount) ;
  // restituisco il risultato
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nCount) ;
   return 2 ;
}

//----------------------------------------------------------------------------
static int
LuaPlaneBoxInters( lua_State* L)
{
  // 4 o 5 parametri : ptOn, vtN, b3Box, nDestGrpId [, nRefType]
   Point3d ptOn ;
   LuaCheckParam( L, 1, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 2, vtN)
   BBox3d b3Box ;
   LuaCheckParam( L, 3, b3Box)
   int nDestGrpId ;
   LuaCheckParam( L, 4, nDestGrpId) ;
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 5, nRefType) ;
   LuaClearStack( L) ;
  // eseguo l'intersezione
   int nPntCount = 0 ;
   int nCrvCount = 0 ;
   int nSrfCount = 0 ;
   int nNewId = ExePlaneBoxInters( ptOn, vtN, b3Box, nDestGrpId, nRefType, &nPntCount, &nCrvCount, &nSrfCount) ;
  // restituisco il risultato
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nPntCount) ;
   LuaSetParam( L, nCrvCount) ;
   LuaSetParam( L, nSrfCount) ;
   return 4 ;
}

//----------------------------------------------------------------------------
static int
LuaPlaneSurfTmInters( lua_State* L)
{
  // 4 o 5 o 6 parametri : ptOn, vtN, Id, nDestGrpId [, nRefType] [, dToler]
   Point3d ptOn ;
   LuaCheckParam( L, 1, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 2, vtN)
   int nId ;
   LuaCheckParam( L, 3, nId)
   int nDestGrpId ;
   LuaCheckParam( L, 4, nDestGrpId) ;
   int nRefType = RTY_DEFAULT ;
   double dToler = 20 * EPS_SMALL ;
   if ( LuaGetParam( L, 5, nRefType))
      LuaGetParam( L, 6, dToler) ;
   LuaClearStack( L) ;
  // eseguo l'intersezione
   int nPntCount = 0 ;
   int nCrvCount = 0 ;
   int nSrfCount = 0 ;
   int nNewId = ExePlaneSurfTmInters( ptOn, vtN, nId, nDestGrpId, nRefType, dToler, &nPntCount, &nCrvCount, &nSrfCount) ;
  // restituisco il risultato
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nPntCount) ;
   LuaSetParam( L, nCrvCount) ;
   LuaSetParam( L, nSrfCount) ;
   return 4 ;
}

//----------------------------------------------------------------------------
static int
LuaParPlanesSurfTmInters( lua_State* L)
{
  // 5 o 6 o 7 parametri : ptOn, vtN, vdDist, nId, nDestGrpId [, nRefType] [, dToler]
   Point3d ptOn ;
   LuaCheckParam( L, 1, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 2, vtN)
   DBLVECTOR vdDist ;
   LuaCheckParam( L, 3, vdDist)
   int nId ;
   LuaCheckParam( L, 4, nId)
   int nDestGrpId ;
   LuaCheckParam( L, 5, nDestGrpId) ;
   int nRefType = RTY_DEFAULT ;
   double dToler = 20 * EPS_SMALL ;
   if ( LuaGetParam( L, 6, nRefType))
      LuaGetParam( L, 7, dToler) ;
   LuaClearStack( L) ;
  // eseguo l'intersezione
   int nGrpCount = 0 ;
   int nNewId = ExeParPlanesSurfTmInters( ptOn, vtN, vdDist, nId, nDestGrpId, nRefType, dToler, &nGrpCount) ;
  // restituisco il risultato
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nGrpCount) ;
   return 2 ;
}

//----------------------------------------------------------------------------
static int
LuaPlaneVolZmapInters( lua_State* L)
{
  // 4 o 5 parametri : ptP, vtN, nId, nDestGrpId [, nRefType]
   Point3d ptP ;
   LuaCheckParam( L, 1, ptP)
   Vector3d vtN ;
   LuaCheckParam( L, 2, vtN)
   int nId ;
   LuaCheckParam( L, 3, nId)
   int nDestGrpId ;
   LuaCheckParam( L, 4, nDestGrpId)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 5, nRefType) ;
   LuaClearStack( L) ;
  // eseguo calcolo intersezione
   int nCount ;
   int nFirstId = ExePlaneVolZmapInters( ptP, vtN, nId, nDestGrpId, nRefType, &nCount) ;
  // restituisco il risultato
   if ( nFirstId != GDB_ID_NULL) {
      LuaSetParam( L, nFirstId) ;
      LuaSetParam( L, nCount) ;
   }
   else {
      LuaSetParam( L) ;
      LuaSetParam( L) ;
   }
   return 2 ;
}

//----------------------------------------------------------------------------
static int
LuaCurveCurveInters( lua_State* L)
{
  // 3 o 4 parametri : nId1, nId2, nDestGrpId [, bOnly3D]
   int nId1 ;
   LuaCheckParam( L, 1, nId1)
   int nId2 ;
   LuaCheckParam( L, 2, nId2)
   int nDestGrpId ;
   LuaCheckParam( L, 3, nDestGrpId) ;   
   bool bOnly3D = false ;
   LuaGetParam( L, 4, bOnly3D) ;
   LuaClearStack( L) ;
  // eseguo l'intersezione
   int nPntCount = 0 ;
   int nCrvCount = 0 ;
   int nNewId = ExeCurveCurveInters( nId1, nId2, nDestGrpId, &nPntCount, &nCrvCount, bOnly3D) ;
   // restituisco il risultato
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nPntCount) ;
   LuaSetParam( L, nCrvCount) ;
   return 3 ;
}

//----------------------------------------------------------------------------
static int
LuaCurveSurfTmInters( lua_State* L)
{
  // 3 parametri : nCrvId, nStmId, nDestGrpId
   int nCrvId ;
   LuaCheckParam( L, 1, nCrvId)
   int nStmId ;
   LuaCheckParam( L, 2, nStmId)
   int nDestGrpId ;
   LuaCheckParam( L, 3, nDestGrpId) ;   
   LuaClearStack( L) ;
  // eseguo l'intersezione
   int nPntCount = 0 ;
   int nCrvCount = 0 ;
   int nNewId = ExeCurveSurfTmInters( nCrvId, nStmId, nDestGrpId, &nPntCount, &nCrvCount) ;
   // restituisco il risultato
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nPntCount) ;
   LuaSetParam( L, nCrvCount) ;
   return 3 ;
}

//----------------------------------------------------------------------------
static int
LuaSurfTmSurfTmInters( lua_State* L)
{
  // 3 o 4 parametri : Id1, nId2, nDestGrpId [, dToler]
   int nId1 ;
   LuaCheckParam( L, 1, nId1)
   int nId2 ;
   LuaCheckParam( L, 2, nId2)
   int nDestGrpId ;
   LuaCheckParam( L, 3, nDestGrpId) ;
   double dToler = 20 * EPS_SMALL ;
   LuaGetParam( L, 4, dToler) ;
   LuaClearStack( L) ;
  // eseguo l'intersezione
   int nPntCount = 0 ;
   int nCrvCount = 0 ;
   int nSrfCount = 0 ;
   int nNewId = ExeSurfTmSurfTmInters( nId1, nId2, nDestGrpId, dToler, &nPntCount, &nCrvCount, &nSrfCount) ;
  // restituisco il risultato
   if ( nNewId != GDB_ID_NULL)
      LuaSetParam( L, nNewId) ;
   else
      LuaSetParam( L) ;
   LuaSetParam( L, nPntCount) ;
   LuaSetParam( L, nCrvCount) ;
   LuaSetParam( L, nSrfCount) ;
   return 4 ;
}

//----------------------------------------------------------------------------
static int
LuaBBoxOverlap( lua_State* L)
{
   // 4 parametri : BBoxA, frA, BBoxB, frB
   BBox3d bboxA ;
   LuaCheckParam( L, 1, bboxA)
   Frame3d frA ;
   LuaCheckParam( L, 2, frA)
   BBox3d bboxB ;
   LuaCheckParam( L, 3, bboxB) ;
   Frame3d frB ;
   LuaCheckParam( L, 4, frB) ;
   LuaClearStack( L) ;
   bool bRes = ExeBBoxOverlap( bboxA, frA, bboxB, frB) ;
  // restituisco il risultato
   LuaSetParam( L, bRes) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGeoInters( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineCurveInters", LuaLineCurveInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineBoxInters", LuaLineBoxInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineSurfTmInters", LuaLineSurfTmInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineSurfBzInters", LuaLineSurfBzInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtLineVolZmapInters", LuaLineVolZmapInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneCurveInters", LuaPlaneCurveInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneBoxInters", LuaPlaneBoxInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneSurfTmInters", LuaPlaneSurfTmInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtParPlanesSurfTmInters", LuaParPlanesSurfTmInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPlaneVolZmapInters", LuaPlaneVolZmapInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveCurveInters", LuaCurveCurveInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCurveSurfTmInters", LuaCurveSurfTmInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSurfTmInters", LuaSurfTmSurfTmInters) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxOverlap", LuaBBoxOverlap) ;
   return bOk ;
}