EgtInterface/LUA_GeoTransform.cpp

//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : LUA_GeoTransform.cpp       Data : 29.09.14        Versione : 1.5i5
// Contenuto : Funzioni di trasformazione geometrica per LUA.
//
//
//
// Modifiche : 29.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
LuaMove( lua_State* L)
{
  // 2 parametri : Id/s, VtMove
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Vector3d vtMove ;
   LuaCheckParam( L, 2, vtMove)
   LuaClearStack( L) ;
  // eseguo traslazione
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtMove( vId[i], vtMove.v))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMoveGlob( lua_State* L)
{
  // 2 parametri : Id/s, VtMove
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Vector3d vtMove ;
   LuaCheckParam( L, 2, vtMove)
   LuaClearStack( L) ;
  // eseguo traslazione
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtMoveGlob( vId[i], vtMove.v))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMoveGroup( lua_State* L)
{
  // 2 parametri : Id/s, VtMove
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Vector3d vtMove ;
   LuaCheckParam( L, 2, vtMove)
   LuaClearStack( L) ;
  // eseguo traslazione
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtMoveGroup( vId[i], vtMove.v))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRotate( lua_State* L)
{
  // 4 parametri : Id/s, PtAx, VtAx, dAngRotDeg
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Point3d ptAx ;
   LuaCheckParam( L, 2, ptAx)
   Vector3d vtAx ;
   LuaCheckParam( L, 3, vtAx)
   double dAngRotDeg ;
   LuaCheckParam( L, 4, dAngRotDeg)
   LuaClearStack( L) ;
  // eseguo rotazione
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtRotate( vId[i], ptAx.v, vtAx.v, dAngRotDeg))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRotateGlob( lua_State* L)
{
  // 4 parametri : Id/s, PtAx, VtAx, dAngRotDeg
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Point3d ptAx ;
   LuaCheckParam( L, 2, ptAx)
   Vector3d vtAx ;
   LuaCheckParam( L, 3, vtAx)
   double dAngRotDeg ;
   LuaCheckParam( L, 4, dAngRotDeg)
   LuaClearStack( L) ;
  // eseguo rotazione
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtRotateGlob( vId[i], ptAx.v, vtAx.v, dAngRotDeg))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRotateGroup( lua_State* L)
{
  // 4 parametri : Id/s, PtAx, VtAx, dAngRotDeg
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Point3d ptAx ;
   LuaCheckParam( L, 2, ptAx)
   Vector3d vtAx ;
   LuaCheckParam( L, 3, vtAx)
   double dAngRotDeg ;
   LuaCheckParam( L, 4, dAngRotDeg)
   LuaClearStack( L) ;
  // eseguo rotazione
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtRotateGroup( vId[i], ptAx.v, vtAx.v, dAngRotDeg))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaScale( lua_State* L)
{
  // 5 parametri : Id/s, Frame, CoeffX, CoeffY, CoeffZ
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Frame3d frRef ;
   LuaCheckParam( L, 2, frRef)
   double dCoeffX ;
   LuaCheckParam( L, 3, dCoeffX)
   double dCoeffY ;
   LuaCheckParam( L, 4, dCoeffY)
   double dCoeffZ ;
   LuaCheckParam( L, 5, dCoeffZ)
   LuaClearStack( L) ;
  // eseguo scalatura
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtScale( vId[i], frRef.Orig().v,
                       frRef.VersX().v, frRef.VersY().v, frRef.VersZ().v,
                       dCoeffX, dCoeffY, dCoeffZ))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaScaleGlob( lua_State* L)
{
  // 5 parametri : Id/s, Frame, CoeffX, CoeffY, CoeffZ
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Frame3d frRef ;
   LuaCheckParam( L, 2, frRef)
   double dCoeffX ;
   LuaCheckParam( L, 3, dCoeffX)
   double dCoeffY ;
   LuaCheckParam( L, 4, dCoeffY)
   double dCoeffZ ;
   LuaCheckParam( L, 5, dCoeffZ)
   LuaClearStack( L) ;
  // eseguo scalatura
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtScaleGlob( vId[i], frRef.Orig().v,
                           frRef.VersX().v, frRef.VersY().v, frRef.VersZ().v,
                           dCoeffX, dCoeffY, dCoeffZ))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaScaleGroup( lua_State* L)
{
  // 5 parametri : Id/s, Frame, CoeffX, CoeffY, CoeffZ
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Frame3d frRef ;
   LuaCheckParam( L, 2, frRef)
   double dCoeffX ;
   LuaCheckParam( L, 3, dCoeffX)
   double dCoeffY ;
   LuaCheckParam( L, 4, dCoeffY)
   double dCoeffZ ;
   LuaCheckParam( L, 5, dCoeffZ)
   LuaClearStack( L) ;
  // eseguo scalatura
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtScaleGroup( vId[i], frRef.Orig().v,
                            frRef.VersX().v, frRef.VersY().v, frRef.VersZ().v,
                            dCoeffX, dCoeffY, dCoeffZ))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMirror( lua_State* L)
{
  // 3 parametri : Id/s, PtOn, VtN
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 3, vtN)
   LuaClearStack( L) ;
  // eseguo scalatura
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtMirror( vId[i], ptOn.v, vtN.v))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMirrorGlob( lua_State* L)
{
  // 3 parametri : Id/s, PtOn, VtN
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 3, vtN)
   LuaClearStack( L) ;
  // eseguo scalatura
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtMirrorGlob( vId[i], ptOn.v, vtN.v))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaMirrorGroup( lua_State* L)
{
  // 3 parametri : Id/s, PtOn, VtN
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 3, vtN)
   LuaClearStack( L) ;
  // eseguo scalatura
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtMirrorGroup( vId[i], ptOn.v, vtN.v))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaShear( lua_State* L)
{
  // 5 parametri : Id, PtOn, VtN, VtDir, Coeff
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 3, vtN)
   Vector3d vtDir ;
   LuaCheckParam( L, 4, vtDir)
   double dCoeff ;
   LuaCheckParam( L, 5, dCoeff)
   LuaClearStack( L) ;
  // eseguo scalatura
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtShear( vId[i], ptOn.v, vtN.v, vtDir.v, dCoeff))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaShearGlob( lua_State* L)
{
  // 5 parametri : Id, PtOn, VtN, VtDir, Coeff
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 3, vtN)
   Vector3d vtDir ;
   LuaCheckParam( L, 4, vtDir)
   double dCoeff ;
   LuaCheckParam( L, 5, dCoeff)
   LuaClearStack( L) ;
  // eseguo scalatura
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtShearGlob( vId[i], ptOn.v, vtN.v, vtDir.v, dCoeff))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaShearGroup( lua_State* L)
{
  // 5 parametri : Id, PtOn, VtN, VtDir, Coeff
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   Vector3d vtN ;
   LuaCheckParam( L, 3, vtN)
   Vector3d vtDir ;
   LuaCheckParam( L, 4, vtDir)
   double dCoeff ;
   LuaCheckParam( L, 5, dCoeff)
   LuaClearStack( L) ;
  // eseguo scalatura
   bool bOk = true ;
   for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
      if ( ! EgtShearGroup( vId[i], ptOn.v, vtN.v, vtDir.v, dCoeff))
         bOk = false ;
   }
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGeoTransform( lua_State* L)
{
   try {
      lua_register( L, "EgtMove", LuaMove) ;
      lua_register( L, "EgtMoveGlob", LuaMoveGlob) ;
      lua_register( L, "EgtMoveGroup", LuaMoveGroup) ;
      lua_register( L, "EgtRotate", LuaRotate) ;
      lua_register( L, "EgtRotateGlob", LuaRotateGlob) ;
      lua_register( L, "EgtRotateGroup", LuaRotateGroup) ;
      lua_register( L, "EgtScale", LuaScale) ;
      lua_register( L, "EgtScaleGlob", LuaScaleGlob) ;
      lua_register( L, "EgtScaleGroup", LuaScaleGroup) ;
      lua_register( L, "EgtMirror", LuaMirror) ;
      lua_register( L, "EgtMirrorGlob", LuaMirrorGlob) ;
      lua_register( L, "EgtMirrorGroup", LuaMirrorGroup) ;
      lua_register( L, "EgtShear", LuaShear) ;
      lua_register( L, "EgtShearGlob", LuaShearGlob) ;
      lua_register( L, "EgtShearGroup", LuaShearGroup) ;
   }
   catch ( ...) {
      return false ;
   }
   return true ;
}