Dario Sassi
e23999b6a3
- numerose modifiche e correzioni - aggiunta registrazione comandi in formato lua - aggiunto valutatore di espressioni.
632 lines
19 KiB
C++
632 lines
19 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2014-2014
|
|
//----------------------------------------------------------------------------
|
|
// File : LUA_GdbCreateCurve.cpp Data : 07.01.15 Versione : 1.6a1
|
|
// Contenuto : Funzioni di creazione curve per LUA.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 07.01.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "LUA.h"
|
|
#include "API.h"
|
|
#include "AuxTools.h"
|
|
#include "/EgtDev/Include/EInAPI.h"
|
|
#include "/EgtDev/Include/EgkPolyLine.h"
|
|
#include "/EgtDev/Include/EgnStringUtils.h"
|
|
#include "/EgtDev/Extern/Lua/Include/lua.hpp"
|
|
|
|
using namespace std ;
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveLine( lua_State* L)
|
|
{
|
|
// 3 parametri : ParentId, PtIni, PtFin
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
Point3d ptFin ;
|
|
LuaCheckParam( L, 3, ptFin)
|
|
LuaClearStack( L) ;
|
|
// creo il segmento di retta
|
|
int nId = EgtCreateCurveLine( nParentId, ptIni.v, ptFin.v) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveLineEx( lua_State* L)
|
|
{
|
|
// 7 parametri : ParentId, PtIni, sSepI, nIdI, PtFin, sSEpF, nIdF
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
string sSepI ;
|
|
LuaCheckParam( L, 3, sSepI)
|
|
int nIdI ;
|
|
LuaCheckParam( L, 4, nIdI)
|
|
Point3d ptFin ;
|
|
LuaCheckParam( L, 5, ptFin)
|
|
string sSepF ;
|
|
LuaCheckParam( L, 6, sSepF)
|
|
int nIdF ;
|
|
LuaCheckParam( L, 7, nIdF)
|
|
LuaClearStack( L) ;
|
|
// creo il segmento di retta
|
|
int nId = EgtCreateCurveLineEx( nParentId, ptIni.v, StringToSep( sSepI), nIdI, ptFin.v, StringToSep( sSepF), nIdF) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveLinePVL( lua_State* L)
|
|
{
|
|
// 4 parametri : ParentId, PtIni, VtDir, dLen
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
Vector3d vtDir ;
|
|
LuaCheckParam( L, 3, vtDir)
|
|
double dLen ;
|
|
LuaCheckParam( L, 4, dLen)
|
|
LuaClearStack( L) ;
|
|
// creo il segmento di retta
|
|
int nId = EgtCreateCurveLinePVL( nParentId, ptIni.v, vtDir.v, dLen) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveLineMinPointCurve( lua_State* L)
|
|
{
|
|
// 3 o 4 parametri : ParentId, PtIni, CrvId [, NearPar]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
int nCrvId ;
|
|
LuaCheckParam( L, 3, nCrvId)
|
|
double dNearPar = 0 ;
|
|
if ( lua_gettop( L) >= 4)
|
|
LuaCheckParam( L, 4, dNearPar) ;
|
|
LuaClearStack( L) ;
|
|
// creo il segmento di retta
|
|
int nId = EgtCreateCurveLineMinPointCurve( nParentId, ptIni.v, nCrvId, dNearPar) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCircle( lua_State* L)
|
|
{
|
|
// 4 parametri : ParentId, PtCen, VtN, Rad
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
Vector3d vtN ;
|
|
LuaCheckParam( L, 3, vtN)
|
|
double dRad ;
|
|
LuaCheckParam( L, 4, dRad)
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = EgtCreateCurveCircle( nParentId, ptCen.v, vtN.v, dRad) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCircleXY( lua_State* L)
|
|
{
|
|
// 3 parametri : ParentId, PtCen, Rad
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
double dRad ;
|
|
LuaCheckParam( L, 3, dRad)
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = EgtCreateCurveCircleXY( nParentId, ptCen.v, dRad) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCircleCPN( lua_State* L)
|
|
{
|
|
// 4 parametri : ParentId, PtCen, PtOn, VtN
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
Point3d ptOn ;
|
|
LuaCheckParam( L, 3, ptOn)
|
|
Vector3d vtN ;
|
|
LuaCheckParam( L, 4, vtN)
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = EgtCreateCurveCircleCPN( nParentId, ptCen.v, ptOn.v, vtN.v) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCircle3P( lua_State* L)
|
|
{
|
|
// 4 parametri : ParentId, PtP1, PtP2, PtP3
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptP1 ;
|
|
LuaCheckParam( L, 2, ptP1)
|
|
Point3d ptP2 ;
|
|
LuaCheckParam( L, 3, ptP2)
|
|
Point3d ptP3 ;
|
|
LuaCheckParam( L, 4, ptP3)
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = EgtCreateCurveCircle3P( nParentId, ptP1.v, ptP2.v, ptP3.v) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArc( lua_State* L)
|
|
{
|
|
// 7 parametri : ParentId, PtCen, VtN, Rad, VtS, AngCenDeg, DeltaN
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
Vector3d vtN ;
|
|
LuaCheckParam( L, 3, vtN)
|
|
double dRad ;
|
|
LuaCheckParam( L, 4, dRad)
|
|
Vector3d vtS ;
|
|
LuaCheckParam( L, 5, vtS)
|
|
double dAngCenDeg ;
|
|
LuaCheckParam( L, 6, dAngCenDeg)
|
|
double dDeltaN ;
|
|
LuaCheckParam( L, 7, dDeltaN)
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = EgtCreateCurveArc( nParentId, ptCen.v, vtN.v, dRad, vtS.v, dAngCenDeg, dDeltaN) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArcXY( lua_State* L)
|
|
{
|
|
// 6 parametri : ParentId, PtCen, Rad, AngStartDeg, AngCenDeg, DeltaN
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
double dRad ;
|
|
LuaCheckParam( L, 3, dRad)
|
|
double dAngStartDeg ;
|
|
LuaCheckParam( L, 4, dAngStartDeg)
|
|
double dAngCenDeg ;
|
|
LuaCheckParam( L, 5, dAngCenDeg)
|
|
double dDeltaZ ;
|
|
LuaCheckParam( L, 6, dDeltaZ)
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = EgtCreateCurveArcXY( nParentId, ptCen.v, dRad, dAngStartDeg, dAngCenDeg, dDeltaZ) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArcC2PN( lua_State* L)
|
|
{
|
|
// 5 parametri : ParentId, PtCen, PtStart, PtNearEnd, VtNorm
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptCen ;
|
|
LuaCheckParam( L, 2, ptCen)
|
|
Point3d ptStart ;
|
|
LuaCheckParam( L, 3, ptStart)
|
|
Point3d ptNearEnd ;
|
|
LuaCheckParam( L, 4, ptNearEnd)
|
|
Vector3d vtNorm ;
|
|
LuaCheckParam( L, 5, vtNorm)
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = EgtCreateCurveArcC2PN( nParentId, ptCen.v, ptStart.v, ptNearEnd.v, vtNorm.v) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArc3P( lua_State* L)
|
|
{
|
|
// 4 parametri : ParentId, PtP1, PtP2, PtP3
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptP1 ;
|
|
LuaCheckParam( L, 2, ptP1)
|
|
Point3d ptP2 ;
|
|
LuaCheckParam( L, 3, ptP2)
|
|
Point3d ptP3 ;
|
|
LuaCheckParam( L, 4, ptP3)
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = EgtCreateCurveArc3P( nParentId, ptP1.v, ptP2.v, ptP3.v) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveArc2PVN( lua_State* L)
|
|
{
|
|
// 5 parametri : ParentId, PtStart, PtEnd, VtDirS, VtNorm
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptStart ;
|
|
LuaCheckParam( L, 2, ptStart)
|
|
Point3d ptEnd ;
|
|
LuaCheckParam( L, 3, ptEnd)
|
|
Vector3d vtDirS ;
|
|
LuaCheckParam( L, 4, vtDirS)
|
|
Vector3d vtNorm ;
|
|
LuaCheckParam( L, 5, vtNorm)
|
|
LuaClearStack( L) ;
|
|
// creo l'arco
|
|
int nId = EgtCreateCurveArc2PVN( nParentId, ptStart.v, ptEnd.v, vtDirS.v, vtNorm.v) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveBezier( lua_State* L)
|
|
{
|
|
// 3 parametri : ParentId, Degree, CtrlPnts
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nDegree ;
|
|
LuaCheckParam( L, 2, nDegree)
|
|
PNTVECTOR vPnt ;
|
|
LuaCheckParam( L, 3, vPnt)
|
|
LuaClearStack( L) ;
|
|
// il numero dei punti deve essere pari al grado + 1
|
|
if ( vPnt.size() != nDegree + 1)
|
|
return luaL_error( L, "Wrong Control Points Number") ;
|
|
// creo la curva
|
|
int nId = EgtCreateCurveBezier( nParentId, nDegree, vPnt) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveBezierRational( lua_State* L)
|
|
{
|
|
// 3 parametri : ParentId, Degree, CtrlPntWs
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nDegree ;
|
|
LuaCheckParam( L, 2, nDegree)
|
|
PNTUVECTOR vPntW ;
|
|
LuaCheckParam( L, 3, vPntW)
|
|
LuaClearStack( L) ;
|
|
// il numero dei punti deve essere pari al grado + 1
|
|
if ( vPntW.size() != nDegree + 1)
|
|
return luaL_error( L, "Wrong Control Points Number") ;
|
|
// creo la curva
|
|
int nId = EgtCreateCurveBezierRational( nParentId, nDegree, vPntW) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveBezierFromArc( lua_State* L)
|
|
{
|
|
// 3 parametri : ParentId, ArcId[ , Erase]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nArcId ;
|
|
LuaCheckParam( L, 2, nArcId)
|
|
bool bErase = true ;
|
|
if ( lua_gettop( L) >= 3)
|
|
LuaCheckParam( L, 3, bErase) ;
|
|
LuaClearStack( L) ;
|
|
// creo la curva
|
|
int nId = EgtCreateCurveBezierFromArc( nParentId, nArcId, bErase) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompo( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : ParentId, nIds [, Erase]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
INTVECTOR vIds ;
|
|
LuaCheckParam( L, 2, vIds)
|
|
bool bErase = true ;
|
|
if ( lua_gettop( L) >= 3)
|
|
LuaCheckParam( L, 3, bErase) ;
|
|
LuaClearStack( L) ;
|
|
// creo la curva composita
|
|
int nId = EgtCreateCurveCompo( nParentId, vIds, ( bErase ? TRUE : FALSE)) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompoByChain( lua_State* L)
|
|
{
|
|
// 3 o 4 parametri : ParentId, nIds, PtNear [, Erase]
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
INTVECTOR vIds ;
|
|
LuaCheckParam( L, 2, vIds)
|
|
Point3d ptNear ;
|
|
LuaCheckParam( L, 3, ptNear)
|
|
bool bErase = true ;
|
|
if ( lua_gettop( L) >= 4)
|
|
LuaCheckParam( L, 4, bErase) ;
|
|
LuaClearStack( L) ;
|
|
// creo la curva composita
|
|
int nId = EgtCreateCurveCompoByChain( nParentId, vIds, ptNear, ( bErase ? TRUE : FALSE)) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompoFromPoints( lua_State* L)
|
|
{
|
|
// 2 parametri : ParentId, ptPs
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
PNTVECTOR vPnt ;
|
|
LuaCheckParam( L, 2, vPnt)
|
|
LuaClearStack( L) ;
|
|
PolyLine PL ;
|
|
for ( size_t i = 0 ; i < vPnt.size() ; ++ i)
|
|
PL.AddUPoint( 0, vPnt[i]) ;
|
|
// creo la curva composita
|
|
int nId = EgtCreateCurveCompoFromPoints( nParentId, PL) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompoFromPointBulges( lua_State* L)
|
|
{
|
|
// 2 parametri : ParentId, ptPBs
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
PNTUVECTOR vPntB ;
|
|
LuaCheckParam( L, 2, vPntB)
|
|
LuaClearStack( L) ;
|
|
PolyArc PA ;
|
|
for ( size_t i = 0 ; i < vPntB.size() ; ++ i)
|
|
PA.AddUPoint( 0, vPntB[i].first, vPntB[i].second) ;
|
|
// creo la curva composita
|
|
int nId = EgtCreateCurveCompoFromPointBulges( nParentId, PA) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateCurveCompoByApprox( lua_State* L)
|
|
{
|
|
// 4 parametri : ParentId, nSouId, sType, dLinTol
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nSouId ;
|
|
LuaCheckParam( L, 2, nSouId)
|
|
bool bArcsVsLines = true ;
|
|
string sTemp ;
|
|
LuaCheckParam( L, 3, sTemp)
|
|
ToUpper( sTemp) ;
|
|
if ( sTemp == "LINES")
|
|
bArcsVsLines = false ;
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 4, dLinTol)
|
|
LuaClearStack( L) ;
|
|
// creo la curva composita
|
|
int nId = EgtCreateCurveCompoByApprox( nParentId, nSouId, bArcsVsLines, dLinTol) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateRectangle3P( lua_State* L)
|
|
{
|
|
// 4 parametri : ParentId, PtIni, PtCross, PtDir
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 2, ptIni)
|
|
Point3d ptCross ;
|
|
LuaCheckParam( L, 3, ptCross)
|
|
Point3d ptDir ;
|
|
LuaCheckParam( L, 4, ptDir)
|
|
LuaClearStack( L) ;
|
|
// creo il poligono
|
|
int nId = EgtCreateRectangle3P( nParentId, ptIni.v, ptCross.v, ptDir.v) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreatePolygonFromSide( lua_State* L)
|
|
{
|
|
// 4 parametri : ParentId, nNumSides, PtIni, PtFin
|
|
int nParentId ;
|
|
LuaCheckParam( L, 1, nParentId)
|
|
int nNumSides ;
|
|
LuaCheckParam( L, 2, nNumSides)
|
|
Point3d ptIni ;
|
|
LuaCheckParam( L, 3, ptIni)
|
|
Point3d ptFin ;
|
|
LuaCheckParam( L, 4, ptFin)
|
|
LuaClearStack( L) ;
|
|
// creo il poligono
|
|
int nId = EgtCreatePolygonFromSide( nParentId, nNumSides, ptIni.v, ptFin.v) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetReturn( L, nId) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
LuaInstallGdbCreateCurve( lua_State* L)
|
|
{
|
|
try {
|
|
lua_register( L, "EgtLine", LuaCreateCurveLine) ;
|
|
lua_register( L, "EgtLineEx", LuaCreateCurveLineEx) ;
|
|
lua_register( L, "EgtLinePVL", LuaCreateCurveLinePVL) ;
|
|
lua_register( L, "EgtLineMinPointCurve", LuaCreateCurveLineMinPointCurve) ;
|
|
lua_register( L, "EgtCircle", LuaCreateCurveCircle) ;
|
|
lua_register( L, "EgtCircleXY", LuaCreateCurveCircleXY) ;
|
|
lua_register( L, "EgtCircleCPN", LuaCreateCurveCircleCPN) ;
|
|
lua_register( L, "EgtCircle3P", LuaCreateCurveCircle3P) ;
|
|
lua_register( L, "EgtArc", LuaCreateCurveArc) ;
|
|
lua_register( L, "EgtArcXY", LuaCreateCurveArcXY) ;
|
|
lua_register( L, "EgtArcC2PN", LuaCreateCurveArcC2PN) ;
|
|
lua_register( L, "EgtArc3P", LuaCreateCurveArc3P) ;
|
|
lua_register( L, "EgtArc2PVN", LuaCreateCurveArc2PVN) ;
|
|
lua_register( L, "EgtCurveBezier", LuaCreateCurveBezier) ;
|
|
lua_register( L, "EgtCurveBezierRat", LuaCreateCurveBezierRational) ;
|
|
lua_register( L, "EgtCurveBezierFromArc", LuaCreateCurveBezierFromArc) ;
|
|
lua_register( L, "EgtCurveCompo", LuaCreateCurveCompo) ;
|
|
lua_register( L, "EgtCurveCompoByChain", LuaCreateCurveCompoByChain) ;
|
|
lua_register( L, "EgtCurveCompoFromPoints", LuaCreateCurveCompoFromPoints) ;
|
|
lua_register( L, "EgtCurveCompoFromPointBulges", LuaCreateCurveCompoFromPointBulges) ;
|
|
lua_register( L, "EgtCurveCompoByApprox", LuaCreateCurveCompoByApprox) ;
|
|
lua_register( L, "EgtRectangle3P", LuaCreateRectangle3P) ;
|
|
lua_register( L, "EgtPolygonFromSide", LuaCreatePolygonFromSide) ;
|
|
}
|
|
catch ( ...) {
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|