Dario Sassi
c36ce0a26f
- prime sistemazioni per offset superfici trimesh tramite Zmap - eliminate funzioni exe/lua CreateVolZmapFromSurfTmOffset e CreateVolZmapFromSurfTmThickeningOffset.
703 lines
21 KiB
C++
703 lines
21 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : LUA_GdbModifySurf.cpp Data : 09.03.15 Versione : 1.6b6
|
|
// Contenuto : Funzioni di modifica delle superfici per LUA.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 09.03.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "LUA.h"
|
|
#include "EXE_Const.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EXeConst.h"
|
|
#include "/EgtDev/Include/EGkCurve.h"
|
|
#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
|
|
#include "/EgtDev/Include/EGkGdbConst.h"
|
|
#include "/EgtDev/Include/EGkLuaAux.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaInvertSurf( lua_State* L)
|
|
{
|
|
// 1 parametro : Id/s
|
|
INTVECTOR vId ;
|
|
LuaCheckParam( L, 1, vId)
|
|
LuaClearStack( L) ;
|
|
// eseguo inversione superfici
|
|
bool bOk = ExeInvertSurface( vId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaExplodeSurf( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// esplosione della superficie
|
|
int nCount ;
|
|
int nFirstId = ExeExplodeSurface( nId, &nCount) ;
|
|
if ( nFirstId != GDB_ID_NULL)
|
|
LuaSetParam( L, nFirstId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaApproxSurf( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : Id [, dLinTol [, dTriaMinSide]]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
double dLinTol = LIN_TOL_SRF ;
|
|
double dTriaMinSide = 100 * EPS_SMALL ;
|
|
if ( LuaGetParam( L, 2, dLinTol))
|
|
LuaGetParam( L, 3, dTriaMinSide) ;
|
|
LuaClearStack( L) ;
|
|
// approssimazione della superficie
|
|
bool bOk = ExeApproxSurface( nId, dLinTol, dTriaMinSide) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfFrAdd( lua_State* L)
|
|
{
|
|
// 2 parametro : Id1, Id2
|
|
int nId1 ;
|
|
LuaCheckParam( L, 1, nId1)
|
|
int nId2 ;
|
|
LuaCheckParam( L, 2, nId2)
|
|
LuaClearStack( L) ;
|
|
// unisco alla prima regione la seconda
|
|
bool bOk = ExeSurfFrAdd( nId1, nId2) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfFrSubtract( lua_State* L)
|
|
{
|
|
// 2 parametro : Id1, Id2
|
|
int nId1 ;
|
|
LuaCheckParam( L, 1, nId1)
|
|
int nId2 ;
|
|
LuaCheckParam( L, 2, nId2)
|
|
LuaClearStack( L) ;
|
|
// sottraggo dalla prima regione la seconda
|
|
bool bOk = ExeSurfFrSubtract( nId1, nId2) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfFrIntersect( lua_State* L)
|
|
{
|
|
// 2 parametro : Id1, Id2
|
|
int nId1 ;
|
|
LuaCheckParam( L, 1, nId1)
|
|
int nId2 ;
|
|
LuaCheckParam( L, 2, nId2)
|
|
LuaClearStack( L) ;
|
|
// interseco la prima regione con la seconda
|
|
bool bOk = ExeSurfFrIntersect( nId1, nId2) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfFrOffset( lua_State* L)
|
|
{
|
|
// 3 parametri : Id, dDist, nType
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
double dDist ;
|
|
LuaCheckParam( L, 2, dDist)
|
|
int nType = ICurve::OFF_FILLET ;
|
|
LuaGetParam( L, 3, nType) ;
|
|
LuaClearStack( L) ;
|
|
// eseguo l'offset della regione
|
|
bool bOk = ExeSurfFrOffset( nId, dDist, nType) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfFrOffsetAdv( lua_State* L)
|
|
{
|
|
// 3 parametri : Id, dDist, nType
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
double dDist ;
|
|
LuaCheckParam( L, 2, dDist)
|
|
int nType = ICurve::OFF_FILLET ;
|
|
LuaGetParam( L, 3, nType) ;
|
|
LuaClearStack( L) ;
|
|
// eseguo l'offset della regione
|
|
int nNewId = GDB_ID_NULL ;
|
|
bool bOk = ExeSurfFrOffsetAdv( nId, dDist, nType, nNewId) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, nNewId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfFrEraseChunk( lua_State* L)
|
|
{
|
|
// 2 parametri : Id, nChunk
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nChunk ;
|
|
LuaCheckParam( L, 2, nChunk)
|
|
LuaClearStack( L) ;
|
|
// eseguo l'offset della regione
|
|
bool bOk = ExeSurfFrEraseChunk( nId, nChunk) ;
|
|
LuaSetParam( L, bOk) ;
|
|
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmMoveVertex( lua_State* L)
|
|
{
|
|
// 3 o 4 o 5 parametri : nId, nVert, ptNewVert [, nRefId] [, bUpdate]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nVert ;
|
|
LuaCheckParam( L, 2, nVert)
|
|
Point3d ptNewVert ;
|
|
LuaCheckParam( L, 3, ptNewVert)
|
|
int nRefType = RTY_DEFAULT ;
|
|
bool bUpdate = true ;
|
|
if ( LuaGetParam( L, 4, nRefType))
|
|
LuaGetParam( L, 5, bUpdate) ;
|
|
else
|
|
LuaGetParam( L, 4, bUpdate) ;
|
|
LuaClearStack( L) ;
|
|
// sposto il vertice di indice dato della trimesh
|
|
bool bOk = ExeSurfTmMoveVertex( nId, nVert, ptNewVert, nRefType, bUpdate) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmMoveFacet( lua_State* L)
|
|
{
|
|
// 3 o 4 o 5 parametri : nId, nFacet, vtMove [, nRefId] [, bUpdate]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nFacet ;
|
|
LuaCheckParam( L, 2, nFacet)
|
|
Vector3d vtMove ;
|
|
LuaCheckParam( L, 3, vtMove)
|
|
int nRefType = RTY_DEFAULT ;
|
|
bool bUpdate = true ;
|
|
if ( LuaGetParam( L, 4, nRefType))
|
|
LuaGetParam( L, 5, bUpdate) ;
|
|
else
|
|
LuaGetParam( L, 4, bUpdate) ;
|
|
LuaClearStack( L) ;
|
|
// sposto la faccia di indice dato della trimesh
|
|
bool bOk = ExeSurfTmMoveFacet( nId, nFacet, vtMove, nRefType, bUpdate) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmToTriangles( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// esplosione della trimesh in triangoli
|
|
int nCount ;
|
|
int nFirstId = ExeSurfTmToTriangles( nId, &nCount) ;
|
|
if ( nFirstId != GDB_ID_NULL)
|
|
LuaSetParam( L, nFirstId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmRemoveFacet( lua_State* L)
|
|
{
|
|
// 2 parametri : nId, nFacet
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nFacet ;
|
|
LuaCheckParam( L, 2, nFacet)
|
|
LuaClearStack( L) ;
|
|
// eseguo rimozione della faccia dalla superficie
|
|
bool bOk = ExeSurfTmRemoveFacet( nId, nFacet) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmSwapFacets( lua_State* L)
|
|
{
|
|
// 3 parametri : nId, nFacet1, nFacet2
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nFacet1 ;
|
|
LuaCheckParam( L, 2, nFacet1)
|
|
int nFacet2 ;
|
|
LuaCheckParam( L, 3, nFacet2)
|
|
LuaClearStack( L) ;
|
|
// eseguo scambio facce della superficie
|
|
bool bOk = ExeSurfTmSwapFacets( nId, nFacet1, nFacet2) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmRemovePart( lua_State* L)
|
|
{
|
|
// 2 parametri : nId, nPart
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nPart ;
|
|
LuaCheckParam( L, 2, nPart)
|
|
LuaClearStack( L) ;
|
|
// eseguo rimozione della parte dalla superficie
|
|
bool bOk = ExeSurfTmRemovePart( nId, nPart) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCutSurfTmPlane( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : Id, ptOn, vtN, bSaveOnEq [, nRefType]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
Point3d ptOn ;
|
|
LuaCheckParam( L, 2, ptOn)
|
|
Vector3d vtN ;
|
|
LuaCheckParam( L, 3, vtN)
|
|
bool bSaveOnEq ;
|
|
LuaGetParam( L, 4, bSaveOnEq) ;
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// taglio la superficie con ilpiano
|
|
bool bOk = ExeCutSurfTmPlane( nId, ptOn, vtN, bSaveOnEq, nRefType) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCutSurfTmClosedCurve( lua_State* L)
|
|
{
|
|
// 3 parametri : SurfId, CurveId, bSaveOnEq
|
|
int nSurfId ;
|
|
LuaCheckParam( L, 1, nSurfId)
|
|
int nCurveId ;
|
|
LuaCheckParam( L, 2, nCurveId)
|
|
bool bSaveOnEq ;
|
|
LuaGetParam( L, 3, bSaveOnEq) ;
|
|
LuaClearStack( L) ;
|
|
// taglio la superficie con ilpiano
|
|
bool bOk = ExeCutSurfTmClosedCurve( nSurfId, nCurveId, bSaveOnEq) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmAdd( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : Id1, Id2 [, bTwoColors]
|
|
int nId1 ;
|
|
LuaCheckParam( L, 1, nId1)
|
|
int nId2 ;
|
|
LuaCheckParam( L, 2, nId2)
|
|
bool bTwoColors = false ;
|
|
LuaGetParam( L, 3, bTwoColors) ;
|
|
LuaClearStack( L) ;
|
|
// unisco alla prima superficie la seconda
|
|
bool bOk = ExeSurfTmAdd( nId1, nId2, bTwoColors) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmSubtract( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : Id1, Id2 [, bTwoColors]
|
|
int nId1 ;
|
|
LuaCheckParam( L, 1, nId1)
|
|
int nId2 ;
|
|
LuaCheckParam( L, 2, nId2)
|
|
bool bTwoColors = false ;
|
|
LuaGetParam( L, 3, bTwoColors) ;
|
|
LuaClearStack( L) ;
|
|
// sottraggo dalla prima superficie la seconda
|
|
bool bOk = ExeSurfTmSubtract( nId1, nId2, bTwoColors) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmIntersect( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : Id1, Id2 [, bTwoColors]
|
|
int nId1 ;
|
|
LuaCheckParam( L, 1, nId1)
|
|
int nId2 ;
|
|
LuaCheckParam( L, 2, nId2)
|
|
bool bTwoColors = false ;
|
|
LuaGetParam( L, 3, bTwoColors) ;
|
|
LuaClearStack( L) ;
|
|
// interseco la prima superficie con la seconda
|
|
bool bOk = ExeSurfTmIntersect( nId1, nId2, bTwoColors) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmSplit( lua_State* L)
|
|
{
|
|
// 2 parametri : nId, nSplitterId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nSplitterId ;
|
|
LuaCheckParam( L, 2, nSplitterId)
|
|
LuaClearStack( L) ;
|
|
// divido la prima superficie in base alla seconda
|
|
int nCount ;
|
|
int nFirstId = ExeSurfTmSplit( nId, nSplitterId, &nCount) ;
|
|
if ( nFirstId != GDB_ID_NULL)
|
|
LuaSetParam( L, nFirstId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L, nCount) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmCut( lua_State* L)
|
|
{
|
|
// 4 parametri : nId, nCutterId, bInVsOut, bOn
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nCutterId ;
|
|
LuaCheckParam( L, 2, nCutterId)
|
|
bool bInVsOut ;
|
|
LuaCheckParam( L, 3, bInVsOut)
|
|
bool bOn ;
|
|
LuaCheckParam( L, 4, bOn)
|
|
LuaClearStack( L) ;
|
|
// taglio la prima superficie in base alla seconda
|
|
bool bOk = ExeSurfTmCut( nId, nCutterId, bInVsOut, bOn) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmSubtractProjectedFacesOnFace( lua_State* L)
|
|
{
|
|
// 3 o 4 o 5 parametri : nSurfId, nFaceInd, nDestGrpId [, vSurfsId] [, bOCFlag]
|
|
int nSurfId ;
|
|
LuaCheckParam( L, 1, nSurfId) ;
|
|
int nFaceInd ;
|
|
LuaCheckParam( L, 2, nFaceInd) ;
|
|
int nDestGrpId ;
|
|
LuaCheckParam( L, 3, nDestGrpId) ;
|
|
INTVECTOR vSurfsId ;
|
|
bool bOCFlag = true ;
|
|
if ( LuaGetParam( L, 4, vSurfsId))
|
|
LuaGetParam( L, 5, bOCFlag) ;
|
|
else
|
|
LuaGetParam( L, 4, bOCFlag) ;
|
|
LuaClearStack( L) ;
|
|
// sottraggo alla faccia scelta la proiezione delle altre TriMesh
|
|
int nNewId = GDB_ID_NULL;
|
|
bool bExistProjection = false ;
|
|
int nNewFaceNbr = 0 ;
|
|
bool bOk = ExeSurfTmSubtractProjectedFacesOnFace( nSurfId, nFaceInd, nDestGrpId, vSurfsId,
|
|
bOCFlag, bExistProjection, nNewId, nNewFaceNbr) ;
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, bExistProjection) ;
|
|
if ( nNewId != GDB_ID_NULL)
|
|
LuaSetParam( L, nNewId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L, nNewFaceNbr) ;
|
|
return 4 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmSetFaceColor( lua_State* L)
|
|
{
|
|
// 3 parametri : Id, nFacet, nColor
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nFacet ;
|
|
LuaCheckParam( L, 2, nFacet)
|
|
int nColor ;
|
|
LuaCheckParam( L, 3, nColor)
|
|
LuaClearStack( L) ;
|
|
// imposto il colore alla faccia della superficie TM
|
|
bool bOk = ExeSurfTmSetFaceColor( nId, nFacet, nColor) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmGetTriaColor( lua_State* L)
|
|
{
|
|
// 2 parametri : Id, nTria
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nTria ;
|
|
LuaCheckParam( L, 2, nTria)
|
|
LuaClearStack( L) ;
|
|
// recupero il flag di colore del triangolo della superficie TM
|
|
int nColor ;
|
|
bool bOk = ExeSurfTmGetTriaColor( nId, nTria, nColor) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, nColor) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmResetTwoColors( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// eseguo reset TFlag per annullare due colori
|
|
bool bOk = ExeSurfTmResetTwoColors( nId) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmSetShowEdges( lua_State* L)
|
|
{
|
|
// 2 parametri : Id, bShow
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
bool bShow ;
|
|
LuaCheckParam( L, 2, bShow) ;
|
|
LuaClearStack( L) ;
|
|
// imposto flag visualizzazione spigoli vivi
|
|
bool bOk = ExeSurfTmSetShowEdges( nId, bShow) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmGetShowEdges( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero il flag di visualizzazione degli spigoli vivi della superficie TM
|
|
bool bShow ;
|
|
bool bOk = ExeSurfTmGetShowEdges( nId, bShow) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, bShow) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmSetSmoothAng( lua_State* L)
|
|
{
|
|
// 2 parametri : nId, nCutterId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
double dAngDeg ;
|
|
LuaCheckParam( L, 2, dAngDeg)
|
|
LuaClearStack( L) ;
|
|
// aggiorno lo smooth angle della superficie
|
|
bool bOk = ExeSurfTmSetSmoothAng( nId, dAngDeg) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmOffset( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, vIds, dOffs, dLinTol [, nType]
|
|
int nParentId ;
|
|
LuaGetParam( L, 1, nParentId) ;
|
|
INTVECTOR vIds ;
|
|
LuaCheckParam( L, 2, vIds)
|
|
double dOffs ;
|
|
LuaCheckParam( L, 3, dOffs)
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 4, dLinTol) ;
|
|
int nType = STMOFF_FILLET ;
|
|
LuaGetParam( L, 5, nType) ;
|
|
LuaClearStack( L) ;
|
|
// interseco la prima superficie con la seconda
|
|
int nId = ExeSurfTmOffset( nParentId, vIds, dOffs, dLinTol, nType) ;
|
|
LuaSetParam( L, nId) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfTmThickeningOffset( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : ParentId, vIds, dOffs, dLinTol [, nType]
|
|
int nParentId ;
|
|
LuaGetParam( L, 1, nParentId) ;
|
|
INTVECTOR vIds ;
|
|
LuaCheckParam( L, 2, vIds)
|
|
double dOffs ;
|
|
LuaCheckParam( L, 3, dOffs)
|
|
double dLinTol ;
|
|
LuaCheckParam( L, 4, dLinTol) ;
|
|
int nType = STMOFF_FILLET ;
|
|
LuaGetParam( L, 5, nType) ;
|
|
LuaClearStack( L) ;
|
|
// interseco la prima superficie con la seconda
|
|
int nId = ExeSurfTmThickeningOffset( nParentId, vIds, dOffs, dLinTol, nType) ;
|
|
LuaSetParam( L, nId) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static int
|
|
LuaCutSurfBzPlane( lua_State* L)
|
|
{
|
|
// 4 o 5 parametri : Id, ptOn, vtN, bSaveOnEq [, nRefType]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
Point3d ptOn ;
|
|
LuaCheckParam( L, 2, ptOn)
|
|
Vector3d vtN ;
|
|
LuaCheckParam( L, 3, vtN)
|
|
bool bSaveOnEq ;
|
|
LuaGetParam( L, 4, bSaveOnEq) ;
|
|
int nRefType = RTY_DEFAULT ;
|
|
LuaGetParam( L, 5, nRefType) ;
|
|
LuaClearStack( L) ;
|
|
// taglio la superficie con ilpiano
|
|
bool bOk = ExeCutSurfBzPlane( nId, ptOn, vtN, bSaveOnEq, nRefType) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSurfBzTrim( lua_State* L)
|
|
{
|
|
// 2 parametri : nId, nCutterId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nCutterId ;
|
|
LuaCheckParam( L, 2, nCutterId)
|
|
LuaClearStack( L) ;
|
|
// taglio la prima superficie in base alla seconda
|
|
bool bOk = ExeSurfBzTrim( nId, nCutterId) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
LuaInstallGdbModifySurf( LuaMgr& luaMgr)
|
|
{
|
|
bool bOk = ( &luaMgr != nullptr) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtInvertSurf", LuaInvertSurf) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtExplodeSurf", LuaExplodeSurf) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtApproxSurf", LuaApproxSurf) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrAdd", LuaSurfFrAdd) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrSubtract", LuaSurfFrSubtract) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrIntersect", LuaSurfFrIntersect) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrOffset", LuaSurfFrOffset) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrOffsetAdv", LuaSurfFrOffsetAdv) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfFrEraseChunk", LuaSurfFrEraseChunk) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmMoveVertex", LuaSurfTmMoveVertex) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmMoveFacet", LuaSurfTmMoveFacet) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmToTriangles", LuaSurfTmToTriangles) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRemoveFacet", LuaSurfTmRemoveFacet) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSwapFacets", LuaSurfTmSwapFacets) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmRemovePart", LuaSurfTmRemovePart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCutSurfTmPlane", LuaCutSurfTmPlane) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCutSurfTmClosedCurve", LuaCutSurfTmClosedCurve) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmAdd", LuaSurfTmAdd) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSubtract", LuaSurfTmSubtract) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmIntersect", LuaSurfTmIntersect) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSplit", LuaSurfTmSplit) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmCut", LuaSurfTmCut) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSubtractProjectedFacesOnFace", LuaSurfTmSubtractProjectedFacesOnFace) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetFaceColor", LuaSurfTmSetFaceColor) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetTriaColor", LuaSurfTmGetTriaColor) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmResetTwoColors", LuaSurfTmResetTwoColors) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetShowEdges", LuaSurfTmSetShowEdges) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmGetShowEdges", LuaSurfTmGetShowEdges) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmSetSmoothAng", LuaSurfTmSetSmoothAng) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmOffset", LuaSurfTmOffset) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfTmThickeningOffset", LuaSurfTmThickeningOffset) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCutSurfBzPlane", LuaCutSurfBzPlane) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSurfBzTrim", LuaSurfBzTrim) ;
|
|
return bOk ;
|
|
}
|