EgtInterface/LUA_GeoBase.cpp

//----------------------------------------------------------------------------
//  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 "API.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EgnStringUtils.h"
#include "/EgtDev/Extern/Lua/Include/lua.hpp"

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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, vtV) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, vtV) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, vtV) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, vtV) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, ptP) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, ptP) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, ptP) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, ptP) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)
  // calcolo il riferimento e restituisco il risultato : bOk, Frame
   Frame3d frTemp ;
   if ( frTemp.Set( ptOrig, ptOnX, ptNearY)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, frTemp) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, frTemp) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, frFrame) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, frFrame) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, frFrame) ;
      return 2 ;
   }
   else {
      LuaSetReturn( 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)) {
      LuaSetReturn( L, true) ;
      LuaSetReturn( L, frFrame) ;
      return 2 ;
   }
   else {
      LuaSetReturn( L, false) ;
      return 1 ;
   }
}

//-------------------------------------------------------------------------------
bool
LuaInstallGeoBase( lua_State* L)
{
   try {
      lua_register( L, "EgtVectorRotate", LuaVectorRotate) ;
      lua_register( L, "EgtVectorToGlob", LuaVectorToGlob) ;
      lua_register( L, "EgtVectorToLoc", LuaVectorToLoc) ;
      lua_register( L, "EgtVectorLocToLoc", LuaVectorLocToLoc) ;
      lua_register( L, "EgtPointRotate", LuaPointRotate) ;
      lua_register( L, "EgtPointToGlob", LuaPointToGlob) ;
      lua_register( L, "EgtPointToLoc", LuaPointToLoc) ;
      lua_register( L, "EgtPointLocToLoc", LuaPointLocToLoc) ;
      lua_register( L, "EgtFrameFrom3Points", LuaFrameFrom3Points) ;
      lua_register( L, "EgtFrameOCS", LuaFrameOCS) ;
      lua_register( L, "EgtFrameRotate", LuaFrameRotate) ;
      lua_register( L, "EgtFrameToGlob", LuaFrameToGlob) ;
      lua_register( L, "EgtFrameToLoc", LuaFrameToLoc) ;
      lua_register( L, "EgtFrameLocToLoc", LuaFrameLocToLoc) ;
   }
   catch ( ...) {
      return false ;
   }
   return true ;
}