Dario Sassi
643 lines
17 KiB
C++
643 lines
17 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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 "/EgtDev/Include/EGkLuaAux.h"
|
|
|
|
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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, vtV) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaVectorMirror( lua_State* L)
|
|
{
|
|
// 2 parametri : Vector, VtN
|
|
Vector3d vtV ;
|
|
LuaCheckParam( L, 1, vtV)
|
|
Vector3d vtN ;
|
|
LuaCheckParam( L, 2, vtN)
|
|
LuaClearStack( L) ;
|
|
// eseguo il mirror
|
|
if ( vtV.Mirror( vtN)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, vtV) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, vtV) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, vtV) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, vtV) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, ptP) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaPointMirror( lua_State* L)
|
|
{
|
|
// 3 parametri : Point, PtOn, VtN
|
|
Point3d ptP ;
|
|
LuaCheckParam( L, 1, ptP)
|
|
Point3d ptOn ;
|
|
LuaCheckParam( L, 2, ptOn)
|
|
Vector3d vtN ;
|
|
LuaCheckParam( L, 3, vtN)
|
|
LuaClearStack( L) ;
|
|
// eseguo il mirror
|
|
if ( ptP.Mirror( ptOn, vtN)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, ptP) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, ptP) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, ptP) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, ptP) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)
|
|
LuaClearStack( L) ;
|
|
// calcolo il riferimento e restituisco il risultato : bOk, Frame
|
|
Frame3d frTemp ;
|
|
if ( frTemp.Set( ptOrig, ptOnX, ptNearY)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, frTemp) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, frTemp) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, frFrame) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, frFrame) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, frFrame) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( 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)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, frFrame) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaFrameGetRotationsCAC1( lua_State* L)
|
|
{
|
|
// 1 parametro : frame
|
|
Frame3d frFrame ;
|
|
LuaCheckParam( L, 1, frFrame)
|
|
LuaClearStack( L) ;
|
|
// calcolo gli angoli di rotazione
|
|
double dAngCDeg, dAngADeg, dAngC1Deg ;
|
|
if ( frFrame.GetRotationsCAC1( dAngCDeg, dAngADeg, dAngC1Deg)) {
|
|
LuaSetParam( L, dAngCDeg) ;
|
|
LuaSetParam( L, dAngADeg) ;
|
|
LuaSetParam( L, dAngC1Deg) ;
|
|
return 3 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaFrameGetFixedAxesRotationsABC( lua_State* L)
|
|
{
|
|
// 1 parametro : frame
|
|
Frame3d frFrame ;
|
|
LuaCheckParam( L, 1, frFrame)
|
|
LuaClearStack( L) ;
|
|
// calcolo gli angoli di rotazione
|
|
double dAngADeg, dAngBDeg, dAngCDeg ;
|
|
if ( frFrame.GetFixedAxesRotationsABC( dAngADeg, dAngBDeg, dAngCDeg)) {
|
|
LuaSetParam( L, dAngADeg) ;
|
|
LuaSetParam( L, dAngBDeg) ;
|
|
LuaSetParam( L, dAngCDeg) ;
|
|
return 3 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaBBoxRotate( lua_State* L)
|
|
{
|
|
// 4 parametri : bbox, PtAsse, VtAsse, AngRot in gradi
|
|
BBox3d b3Box ;
|
|
LuaCheckParam( L, 1, b3Box)
|
|
Point3d ptAx ;
|
|
LuaCheckParam( L, 2, ptAx)
|
|
Vector3d vtAx ;
|
|
LuaCheckParam( L, 3, vtAx)
|
|
double dAngRotDeg ;
|
|
LuaCheckParam( L, 4, dAngRotDeg)
|
|
LuaClearStack( L) ;
|
|
// eseguo la rotazione
|
|
if ( b3Box.Rotate( ptAx, vtAx, dAngRotDeg)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, b3Box) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaBBoxToGlob( lua_State* L)
|
|
{
|
|
// 2 parametri : bbox, frame di trasformazione
|
|
BBox3d b3Box ;
|
|
LuaCheckParam( L, 1, b3Box)
|
|
Frame3d frTool ;
|
|
LuaCheckParam( L, 2, frTool)
|
|
LuaClearStack( L) ;
|
|
// eseguo la trasformazione
|
|
if ( b3Box.ToGlob( frTool)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, b3Box) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaBBoxToLoc( lua_State* L)
|
|
{
|
|
// 2 parametri : bbox, frame di trasformazione
|
|
BBox3d b3Box ;
|
|
LuaCheckParam( L, 1, b3Box)
|
|
Frame3d frTool ;
|
|
LuaCheckParam( L, 2, frTool)
|
|
LuaClearStack( L) ;
|
|
// eseguo la trasformazione
|
|
if ( b3Box.ToLoc( frTool)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, b3Box) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaBBoxLocToLoc( lua_State* L)
|
|
{
|
|
// 3 parametri : bbox, frame origine, frame destinazione
|
|
BBox3d b3Box ;
|
|
LuaCheckParam( L, 1, b3Box)
|
|
Frame3d frOri ;
|
|
LuaCheckParam( L, 2, frOri)
|
|
Frame3d frDest ;
|
|
LuaCheckParam( L, 3, frDest)
|
|
LuaClearStack( L) ;
|
|
// eseguo la trasformazione
|
|
if ( b3Box.LocToLoc( frOri, frDest)) {
|
|
LuaSetParam( L, true) ;
|
|
LuaSetParam( L, b3Box) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaQuaternionFromAxisAngle( lua_State* L)
|
|
{
|
|
// 2 parametri : vtAx, dAngDeg
|
|
Vector3d vtAx ;
|
|
LuaCheckParam( L, 1, vtAx)
|
|
double dAngDeg ;
|
|
LuaCheckParam( L, 2, dAngDeg)
|
|
LuaClearStack( L) ;
|
|
// calcolo il quaternione che produce la rotazione equivalente
|
|
Quaternion qtQ = FromAxisAngle( vtAx, dAngDeg) ;
|
|
if ( ! qtQ.IsSmall())
|
|
LuaSetParam( L, qtQ) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaQuaternionToAxisAngle( lua_State* L)
|
|
{
|
|
// 1 parametro : Quaternion
|
|
Quaternion qtQ ;
|
|
LuaCheckParam( L, 1, qtQ)
|
|
LuaClearStack( L) ;
|
|
// calcolo l'asse e l'angolo di rotazione equivalenti
|
|
Vector3d vtAx ;
|
|
double dAngDeg ;
|
|
bool bOk = ToAxisAngle( qtQ, vtAx, dAngDeg) ;
|
|
if ( bOk) {
|
|
LuaSetParam( L, vtAx) ;
|
|
LuaSetParam( L, dAngDeg) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaQuaternionFromFrame( lua_State* L)
|
|
{
|
|
// 1 parametro : Frame
|
|
Frame3d frFrame ;
|
|
LuaCheckParam( L, 1, frFrame)
|
|
LuaClearStack( L) ;
|
|
// calcolo il quaternione che produce l'orientamento di questo frame tramite rotazione dal globale
|
|
Quaternion qtQ = FromFrame( frFrame) ;
|
|
if ( ! qtQ.IsSmall())
|
|
LuaSetParam( L, qtQ) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaQuaternionToFrame( lua_State* L)
|
|
{
|
|
// 1 parametro : Quaternion
|
|
Quaternion qtQ ;
|
|
LuaCheckParam( L, 1, qtQ)
|
|
LuaClearStack( L) ;
|
|
// calcolo il frame equivalente come orientamento a quello globale ruotato dal quaternione
|
|
Frame3d frFrame ;
|
|
bool bOk = ToFrame( qtQ, frFrame) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, frFrame) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
LuaInstallGeoBase( LuaMgr& luaMgr)
|
|
{
|
|
bool bOk = ( &luaMgr != nullptr) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtVectorRotate", LuaVectorRotate) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtVectorMirror", LuaVectorMirror) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtVectorToGlob", LuaVectorToGlob) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtVectorToLoc", LuaVectorToLoc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtVectorLocToLoc", LuaVectorLocToLoc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtPointRotate", LuaPointRotate) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtPointMirror", LuaPointMirror) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtPointToGlob", LuaPointToGlob) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtPointToLoc", LuaPointToLoc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtPointLocToLoc", LuaPointLocToLoc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtFrameFrom3Points", LuaFrameFrom3Points) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtFrameOCS", LuaFrameOCS) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtFrameRotate", LuaFrameRotate) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtFrameToGlob", LuaFrameToGlob) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtFrameToLoc", LuaFrameToLoc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtFrameLocToLoc", LuaFrameLocToLoc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtFrameGetRotCAC1", LuaFrameGetRotationsCAC1) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtFrameGetFixedAxesRotABC", LuaFrameGetFixedAxesRotationsABC) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxRotate", LuaBBoxRotate) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxToGlob", LuaBBoxToGlob) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxToLoc", LuaBBoxToLoc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtBBoxLocToLoc", LuaBBoxLocToLoc) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionFromAxisAngle", LuaQuaternionFromAxisAngle) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionToAxisAngle", LuaQuaternionToAxisAngle) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionFromFrame", LuaQuaternionFromFrame) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtQuaternionToFrame", LuaQuaternionToFrame) ;
|
|
return bOk ;
|
|
}
|