Egalware/StoneSolidGen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
28922eff891d687f1fc27cbedfc33e8a9f5e145e
StoneSolidGen/TopChicken.lua
T
Daniele Bariletti 28922eff89 - disattivata l'impostazione per l'esecuzione nel CAM5 per il CreateSolid 
- gestione dell'import di piani cucina con un loop interno
- gestione della creazione di un fondello con un pezzo unico o con un pezzo per lato
- correzioni al calcolo del draft angle, creazione del pezzo a partire da misure e angoli e calcolo delle misure del pezzo tenendo conto dei vicini.
2024-12-20 10:00:02 +01:00

490 lines
19 KiB
Lua
Raw Blame History

-- 2024/11/22
-- Template per la creazione di un cabinet
-- Intestazioni
require( 'EgtBase')
_ENV = EgtProtectGlobal()
EgtEnableDebug( false)
EgtAddToPackagePath(EgtGetSourceDir() .. 'LuaLibs\\?.lua')
require( 'EgtCompo')
-- Parametri : dichiarazione e valori standard
-- N.B.: le dimensioni sono comprese di spessori
local CMP = {}
CMP.N1 = 'Altezza alzatina' -- altezza
CMP.T1 = 3 -- 0=null, 1=bool, 2=int, 3=len, 4=num, 5=string
CMP.V1 = 40
CMP.N2 = 'Altezza frontalino' -- larghezza
CMP.T2 = 3
CMP.V2 = 60
CMP.N3 = 'Profondità lavello' -- profondità
CMP.T3 = 3
CMP.V3 = 300
CMP.N4 = 'Spessore Top' -- spessore top
CMP.T4 = 3
CMP.V4 = 20
CMP.N5 = 'Spessore Bottom' -- spessore bottom
CMP.T5 = 3
CMP.V5 = 10
CMP.N6 = 'Spessore Alzatine' -- spessore left
CMP.T6 = 3
CMP.V6 = 30
CMP.N7 = 'Spessore Frontalini' -- spessore right
CMP.T7 = 3
CMP.V7 = 5
CMP.N8 = 'Dimensione Foro' -- diametro del foro
CMP.T8 = 3
CMP.V8 = 5
CMP.N9 = 'Pendenza del fondo' -- angolo di pendenza del fondo
CMP.T9 = 3
CMP.V9 = 0.15
CMP.ResetView = false
CMP.DrawSolid = true
CMP.IsCabinet = true
CMP.Npar = 9
CMP.Nome = 'TopChicken'
_G.CMP = CMP
CMP.ERR = 0
CMP.MSG = ''
-- Aggiorno con ultimi valori salvati (se presenti)
CMP.DATA = EgtGetSourceDir() .. CMP.Nome ..'.dat'
LoadCompoData()
-- Percorso direttorio Vein3D
local sPath = ""
sPath = EgtGetStringFromIni( "Vein3D", "Vein3D_Dir", "", EgtGetIniFile())
EgtOutLog(' → '..sPath)
-- definzione delle variabile per le classi di paretine
local dAngAlzatina = 90
local dAngFrontalino = -90
-- Carico i dati letti da file .dat
local tbOrigVal={}
local function OrigData()
tbOrigVal.v1 = CMP.V1
tbOrigVal.v2 = CMP.V2
tbOrigVal.v3 = CMP.V3
tbOrigVal.v4 = CMP.V4
tbOrigVal.v5 = CMP.V5
tbOrigVal.v6 = CMP.V6
tbOrigVal.v7 = CMP.V7
tbOrigVal.v8 = CMP.V8
tbOrigVal.v9 = CMP.V9
end
---
local sUNICode = os.date( '%y%m%d%H%M%S', os.time()).."_"
-- Per disporre i pezzi in piano non sovrappposti (in assemblaggio non serve)
local HorizontalOffset = 0
-------------------------------------------------------------------------------------------------------------------------
-- COSTRUZIONE RIFERIMENTI INIZIO
-------------------------------------------------------------------------------------------------------------------------
local function SetReference()
-- Esempio Riferimento:
-- CreateReference( tbName[2], 'OutLoop', 'A2', 'R1', CMP.SL, '0,0,-x')
-- SetPairInfo( tbName[2], 'R1', tbName[1], 'R1', -1, 90, 1)
-- Esempio Punto per dimension:
-- CreatePointReference( tbName[1], 'OutLoop', 'A1', 'R4', 0, CMP.SB, '0,0,-x')
--SaveMePlease()
end
--
local function AddDimensions()
-- local GridFr = Frame3d(ORIG(),GDB_FR.FRONT)
-- --Esempio:
-- -- DrawLinearDimension( tbName[1], 'R4', tbName[4], 'R2', 'SUA ALTEZZA',GridFr, Point3d(-50,0,0))
-- EgtSetGridFrame(GLOB_FRM())
end
--
-------------------------------------------------------------------------------------------------------------------------
-- COSTRUZIONE RIFERIMENTI FINE
-------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------
-- CREAZIONE/IMPORTAZIONE Loop INIZIO
-------------------------------------------------------------------------------------------------------------------------
-- Importa un contorno chiuso da file nge
function ImportLoop( PartId, tbLayer, sNameFileNGE)
local OutLayer = tbLayer['OutLoop']
if not EgtInsertFile( sNameFileNGE) then
EgtOutLog(' IMPORTAZIONE FALLITA: '..sNameFileNGE)
end
-- recupero ultimo Part
local LastPart = EgtGetLastPart()
local FstLayerInLstPart = EgtGetFirstGroupInGroup( LastPart)
local IdLoop = EgtGetFirstInGroup( FstLayerInLstPart)
if not EgtRelocateGlob( IdLoop, OutLayer) then
EgtOutLog(' RELOCATE FALLITA MISERAMENTE: '..tostring(IdLoop)..';'..tostring(OutLayer))
end
local tbIdAllLoops = {}
local tbIdLoop = TOOL.ExplodeAndNameEdges( IdLoop)
table.insert(tbIdAllLoops, tbIdLoop)
EgtSetInfo(tbIdLoop[1],'AF',1)
EgtSetInfo(tbIdLoop[2],'AF',2)
EgtSetInfo(tbIdLoop[3],'AF',2)
EgtSetInfo(tbIdLoop[4],'AF',2)
EgtSetInfo(tbIdLoop[5],'AF',2)
EgtSetInfo(tbIdLoop[6],'AF',2)
EgtSetInfo(tbIdLoop[7],'AF',1)
-- controllo la presenza di eventuali inloop ( che mi aspetto essere CCW)
local IdInLoop = EgtGetFirstInGroup(FstLayerInLstPart)
if IdInLoop then
EgtInvertCurve(IdInLoop)
local InLoopLay = EgtGroup(PartId)
EgtSetName(InLoopLay, 'InLoop')
EgtRelocateGlob( IdInLoop, InLoopLay)
local tbIdInLoop = TOOL.ExplodeAndNameEdges( IdInLoop, true)
table.insert(tbIdAllLoops, tbIdInLoop)
EgtSetInfo(tbIdInLoop[1],'AF',2)
EgtSetInfo(tbIdInLoop[2],'AF',2)
EgtSetInfo(tbIdInLoop[3],'AF',2)
EgtSetInfo(tbIdInLoop[4],'AF',2)
end
-- cancello il part dell'importazione
EgtErase(LastPart)
return tbIdAllLoops
end
--
local function WriteDataToChildPart(nParent, nPart, nEdge, dLen, dAngDx, dAngSx, dH, dTh)
if not nPart then do return end end
if nParent then EgtSetInfo(nPart, 'Parent', nParent) end
if nEdge then EgtSetInfo(nPart, 'ParentEdge', nEdge) end
if dLen then EgtSetInfo(nPart, 'Len', dLen) end
if dAngDx then EgtSetInfo(nPart, 'dAngDx', dAngDx) end
if dAgnSx then EgtSetInfo(nPart, 'dAngSx', dAngSx) end
if dH then EgtSetInfo(nPart, 'dH', dH) end
if dTh then EgtSetInfo(nPart, 'dTh', dTh) end
end
-- sNamePartDest deve essere il pezzo al cui lato A1 si attacca il lato A4 del pezzo Bottom
local function CreateBottomPart( tbIdLoop, sNamePartDest, nParent)
-- creo il fondo del lavello
local tbPart = {}
local Pz_Bottom = TOOL.CreatePartLayer('Bottom', sUNICode)
tbPart.sName = 'Bottom'
tbPart.dTh = CMP.SB
tbPart.sDestRefOff = '0,0,-x'
tbPart.sRefOff = '0,0,0'
tbPart.dPairAng = 90
local tbLayerBottom = TOOL.FindLayers(Pz_Bottom)
local bInvert = true
local bInLoop = false
local tbOutLoop = TOOL.AddLoopToLayer(tbLayerBottom['OutLoop'], tbIdLoop, CMP.SWater, bInvert, bInLoop) -- il loop viene aggiunto ma nella posizione da inloop del piano cucina, non come nuovo pezzo messo nell'origine
TOOL.CreatePart(tbLayerBottom,tbPart.sName,tbOutLoop,tbPart.dTh,bInLoop)
-- creo il foro
local ptCenter = EgtGP( EgtGetFirstInGroup(tbLayerBottom['Region']), GDB_RT.GLOB)
TOOL.CreateCircularHole( Pz_Bottom, ptCenter, CMP.DiamBore)
--TOOL.CreatePart(tbLayerBottom,tbPart.sName,{HoleId},tbPart.dTh,true)
-- creo i riferimenti e salvo i parametri del part
TOOL.CreateReference( sUNICode, sNamePartDest, 'OutLoop', 'A1', 'R1', tbPart.dTh, tbPart.sDestRefOff)
TOOL.CreateReference(sUNICode, tbPart.sName, 'OutLoop', 'A4', 'R4', 0, tbPart.sRefOff)
TOOL.SetPairInfo(sUNICode, tbPart.sName, 'R4', sNamePartDest, 'R1', -1, tbPart.dPairAng, 4)
WriteDataToChildPart(nParent, Pz_Bottom, nEdge,tbPart.dLen,tbPart.dAngBR, tbPart.dAngBL, tbPart.dH, tbPart.dTh)
end
local function CreateSplitBottomPart( tbIdLoop, nParent, dOffset)
-- creo il fondo diviso in un numero di pezzi pari ai lati del loop passato
local nLay = EgtGetParent(tbIdLoop[1])
local nAuxLay = EgtGroup( nLay)
EgtSetName(nAuxLay, 'OutLoop')
local nLoop = EgtCurveCompoByChain(nAuxLay, tbIdLoop, EgtSP(tbIdLoop[1], GDB_RT.GLOB), false)
EgtOffsetCurve(nLoop, -dOffset, GDB_OT.EXTEND)
local ptCenter = EgtGP(nLoop, GDB_RT.GLOB)
local tbLoopOff = TOOL.ExplodeAndNameEdges( nLoop, false)
local nPrev = 0
local nFirst = 0
local tbSplitBottom = {}
-- creo i part con tutte le info
for i = 1, #tbLoopOff do
local tbPart = {}
local Pz_Bottom = TOOL.CreatePartLayer('BottomA'..tostring(i), sUNICode)
if i == 1 then nFirst = Pz_Bottom end
tbPart.sName = 'BottomA'..tostring(i)
tbPart.nId = Pz_Bottom
tbPart.nEdge = i
tbPart.dTh = CMP.SB
EgtSetInfo(Pz_Bottom, 'dTh', CMP.SB)
tbPart.sDestRefOff = '0,0,-x'
tbPart.sRefOff = '0,0,0'
tbPart.dPairAng = 90 - CMP.dSlopeAng
EgtSetInfo(Pz_Bottom, 'PairAng', tbPart.dPairAng)
tbPart.nJunctionType = 3
tbPart.bOnLoop = true
tbPart.dH = EgtPointCurveDist( ptCenter, tbLoopOff[i], GDB_RT.GLOB) - 15
tbPart.nPrev = nPrev
if i > 1 then tbSplitBottom[nPrev].nNext = Pz_Bottom end
tbSplitBottom[Pz_Bottom] = tbPart
nPrev = Pz_Bottom
end
tbSplitBottom[nPrev].nNext = nFirst
tbSplitBottom[nFirst].nPrev = nPrev
-- scorro i part e costruisco effettivamente i pezzi in funzione del precedente e del successivo
for nPart, tbPart in pairs(tbSplitBottom) do
local tbLayerBottom = TOOL.FindLayers(nPart)
local bInLoop = false
TOOL.CreateParetina( tbPart.nEdge, tbLoopOff, tbPart, 90)
-- tbPart.dLen = 300 + CMP.SWater * 2
-- tbPart.dAngBL = 46
-- tbPart.dAngBR = 46
local tbPartLoop = TOOL.CreateAdjustedPart( tbLayerBottom['OutLoop'],tbPart.dLen, tbPart.dH, tbPart.dAngBL, tbPart.dAngBR)
TOOL.CreatePart(tbLayerBottom,tbPart.sName,tbPartLoop,tbPart.dTh,bInLoop)
TOOL.SetMachiningInfo(tbLayerBottom['OutLoop'], false)
-- tbPart.dSideAngL = 8
-- tbPart.dSideAngR = 8
if tbPart.dSideAngL then TOOL.SetSideAng(tbLayerBottom['OutLoop'], 'A2', tbPart.dSideAngL) end
if tbPart.dSideAngR then TOOL.SetSideAng(tbLayerBottom['OutLoop'], 'A4', tbPart.dSideAngR) end
-- creo i riferimenti e salvo i parametri del part
local sNamePartDest = 'InPartA'..tostring(tbPart.nEdge)
TOOL.CreateReference( sUNICode, sNamePartDest, 'OutLoop', 'A1', 'R1', tbPart.dTh, tbPart.sDestRefOff)
TOOL.CreateReference(sUNICode, tbPart.sName, 'OutLoop', 'A1', 'R1', 0, tbPart.sRefOff)
TOOL.SetPairInfo(sUNICode, tbPart.sName, 'R1', sNamePartDest, 'R1', -1, tbPart.dPairAng, 4)
WriteDataToChildPart(nParent, nPart, nEdge,tbPart.dLen,tbPart.dAngBR, tbPart.dAngBL, tbPart.dH, tbPart.dTh)
end
EgtErase(nAuxLay)
return tbSplitBottom
end
-- Confronto i dati del file.dat con quelli letti da programma
local function IsDataChanged()
local bOk = false
if not tbOrigVal.v1 then return true end
if math.abs(CMP.V1 - tbOrigVal.v1) > 0.5 then bOk = bOk or true end
if math.abs(CMP.V2 - tbOrigVal.v2) > 0.5 then bOk = bOk or true end
if math.abs(CMP.V3 - tbOrigVal.v3) > 0.5 then bOk = bOk or true end
if math.abs(CMP.V4 - tbOrigVal.v4) > 0.5 then bOk = bOk or true end
if math.abs(CMP.V5 - tbOrigVal.v5) > 0.5 then bOk = bOk or true end
if math.abs(CMP.V6 - tbOrigVal.v6) > 0.5 then bOk = bOk or true end
if math.abs(CMP.V7 - tbOrigVal.v7) > 0.5 then bOk = bOk or true end
if math.abs(CMP.V8 - tbOrigVal.v8) > 0.5 then bOk = bOk or true end
if math.abs(CMP.V9 - tbOrigVal.v9) > 0.005 then bOk = bOk or true end
return bOk
end
-- EgtAddToPackagePath(sPath..'TemplateTool.lua')
-- require('TemplateTool')
local TOOL = dofile(sPath..'TemplateTool.lua')
function CMP_Draw(bPreview)
local bRedraw = IsDataChanged()
if bRedraw or not CMP.DrawSolid then
-- pulisco il file e leggo i dati
EgtNewFile()
HorizontalOffset = 0
CMP.HSplash = CMP.V1 -- altezza alzatina
CMP.HWater = CMP.V2 -- altezza frotalino
CMP.DSink = CMP.V3 -- profondità lavello
CMP.ST = CMP.V4 -- spessore top
CMP.SB = CMP.V5 -- spessore bottom
CMP.SSplash = CMP.V6 -- spessore alzatine
CMP.SWater = CMP.V7 -- spessore frontalini
CMP.DiamBore = CMP.V8 -- spessore back
CMP.dSlopeAng = CMP.V9 -- angolo di pendenza
-- PIANO POLLO
local Pz_Top = TOOL.CreatePartLayer( 'TopChicken', sUNICode)
-- Creo il contorno esterno (id degli edge esterni)
local tbLoopsTC = ImportLoop( Pz_Top, TOOL.FindLayers( Pz_Top), sPath .. 'TopChicken.nge')
local tbIdLoopTC = tbLoopsTC[1]
local tbIdInLoopTC = tbLoopsTC[2]
-- Creo il pezzo dato il contorno
local dTh_TC = CMP.ST
local tbTCLayer = TOOL.FindLayers( Pz_Top)
TOOL.CreatePart( tbTCLayer, 'TopChicken', tbIdLoopTC, dTh_TC, false)
if tbTCLayer['InLoop'] then
TOOL.CreatePart( tbTCLayer, 'TopChicken', tbIdInLoopTC, dTh_TC, true)
end
--INIZIO CREAZIONE PARETINE dell'OutLoop
-- tabella che contiene le tabelle con le info dei vari part
local tbPartsInfo = {}
local dThCurr = 20
local dHCurr = 100
local nPrev = 0
local nFirst = 0
for i=1, #tbIdLoopTC do
local tbInfo = {}
tbInfo.nEdge = i
tbInfo.nPrev = nPrev
local sNamePz = 'PartA'.. tostring(i)
tbInfo.sName = sUNICode..sNamePz
local Pz_A = TOOL.CreatePartLayer(sNamePz, sUNICode)
if nPrev ~= 0 then tbPartsInfo[nPrev].nNext = Pz_A end
if i == 1 then nFirst = Pz_A end
tbInfo.nId = Pz_A
tbInfo.sName = sNamePz
local nType = EgtGetInfo(tbIdLoopTC[i], 'AF', 'i') or 0
local dPairAng = 0
if nType == 1 then
dPairAng = dAngAlzatina
EgtSetInfo(Pz_A, 'dTh', CMP.SSplash)
EgtSetInfo(Pz_A, 'dH', CMP.HSplash)
elseif nType == 2 then
dPairAng = dAngFrontalino
EgtSetInfo(Pz_A, 'dTh', CMP.SWater)
EgtSetInfo(Pz_A, 'dH', CMP.HWater)
end
tbInfo.nType = nType
EgtSetInfo(Pz_A, 'PairAng', dPairAng)
nPrev = Pz_A
tbPartsInfo[tbInfo.nId] = tbInfo
end
tbPartsInfo[nFirst].nPrev = nPrev
tbPartsInfo[nPrev].nNext = nFirst
-- aggiungo le paretine dell'InLoop
nPrev = 0
nFirst = 0
for i=1, #tbIdInLoopTC do
local tbInfo = {}
tbInfo.nEdge = i
tbInfo.nPrev = nPrev
local sNamePz = 'InPartA'.. tostring(i)
tbInfo.sName = sUNICode..sNamePz
local Pz_A = TOOL.CreatePartLayer(sNamePz, sUNICode)
if nPrev ~= 0 then tbPartsInfo[nPrev].nNext = Pz_A end
if i == 1 then nFirst = Pz_A end
tbInfo.nId = Pz_A
tbInfo.sName = sNamePz
local nType = EgtGetInfo(tbIdInLoopTC[i], 'AF', 'i') or 0
local dPairAng = 0
if nType == 1 then
dPairAng = dAngAlzatina
elseif nType == 2 then
dPairAng = dAngFrontalino
end
tbInfo.nType = nType
EgtSetInfo(Pz_A, 'PairAng', dPairAng)
EgtSetInfo(Pz_A, 'dTh', CMP.SWater)
EgtSetInfo(Pz_A, 'dH', CMP.DSink)
nPrev = Pz_A
tbInfo.bInLoop = true
tbPartsInfo[tbInfo.nId] = tbInfo
end
tbPartsInfo[nFirst].nPrev = nPrev
tbPartsInfo[nPrev].nNext = nFirst
--local bOnLoop = false -- bool che indica se la faccia buona del part sta sull'edge del piano cucina o no
--local nJunctionType = 1 -- tipo di giunzione: 1 trim start, 2 trim end, 3 giunzione angolata
for nPart, tbInfo in pairs( tbPartsInfo) do
local nType = tbInfo.nType
local dH = EgtGetInfo(nPart, 'dH', 'd')
tbInfo.dH = dH
local dTh = EgtGetInfo(nPart, 'dTh', 'd')
local dPairAng = EgtGetInfo(nPart, 'PairAng', 'd')
if nType == 1 then
----- caratteristiche alzatina
tbInfo.dPairAng = dPairAng
tbInfo.dSideAngT = dPairAng - 90
tbInfo.dTh = dTh
tbInfo.dYOffset = dTh * tan(tbInfo.dSideAngT)
--nJunctionType = 2 -- trim end
--nJunctionType = 1 -- trim start
tbInfo.nJunctionType = 1 -- angle junction
tbInfo.bOnLoop = false
----- caratteristiche alzatina
elseif nType == 2 then
----- caratteristiche frontalino
tbInfo.dPairAng = dPairAng
tbInfo.dSideAngT = -( -dPairAng - 90)
tbInfo.dTh = dTh
tbInfo.dYOffset = dTh * tan(tbInfo.dSideAngT)
tbInfo.nJunctionType = 3 -- angle junction
tbInfo.bOnLoop = true
----- caratteristiche forntalino
end
if not tbInfo.bInLoop then
TOOL.CreateParetina( tbInfo.nEdge, tbIdLoopTC, tbInfo)
else
TOOL.CreateParetina( tbInfo.nEdge, tbIdInLoopTC, tbInfo)
end
-- setto l'offset dei riferimenti
if nType == 1 then
-- SPLASHTOP
tbInfo.sDestRefOff = '0,0,0'
tbInfo.sRefOff = tostring(tbInfo.dXOffset)..','..tostring(tbInfo.dYOffset)..',-x'
elseif nType == 2 then
-- WATERFALL
tbInfo.sDestRefOff = '0,0,-x'
tbInfo.sRefOff = '0,'..tostring(tbInfo.dYOffset)..',0'
end
end
-- creo tutte le paretine
for nPart, tbPart in pairs( tbPartsInfo) do
EgtOutLog(tostring(nPart))
local nNameChar = tbPart.bInLoop and 8 or 6
local nEdge = string.sub(tbPart.sName, nNameChar)
local tbLayer = TOOL.FindLayers(nPart)
local tbIdLoop = TOOL.CreateAdjustedPart( tbLayer['OutLoop'],tbPart.dLen, tbPart.dH, tbPart.dAngBL, tbPart.dAngBR)
TOOL.CreatePart(tbLayer,tbPart.sName,tbIdLoop,tbPart.dTh,false)
if not tbPart.bInLoop then
TOOL.CreateReference( sUNICode, 'TopChicken', 'OutLoop', 'A'..tostring(nEdge), 'R'..tostring(nEdge), dTh_TC, tbPart.sDestRefOff)
TOOL.CreateReference(sUNICode, tbPart.sName, 'OutLoop', 'A3', 'R3', tbPart.dTh, tbPart.sRefOff)
TOOL.SetPairInfo(sUNICode, tbPart.sName, 'R3', 'TopChicken', 'R'..tostring(nEdge), -1, tbPart.dPairAng, 2)
else
TOOL.CreateReference( sUNICode, 'TopChicken', 'InLoop', 'A'..tostring(nEdge), 'R'..tostring(nEdge+#tbIdLoopTC), dTh_TC, tbPart.sDestRefOff)
TOOL.CreateReference(sUNICode, tbPart.sName, 'OutLoop', 'A3', 'R3', tbPart.dTh, tbPart.sRefOff)
TOOL.SetPairInfo(sUNICode, tbPart.sName, 'R3', 'TopChicken', 'R'..tostring(nEdge+#tbIdLoopTC), -1, tbPart.dPairAng, 2)
end
if tbPart.dSideAngL then TOOL.SetSideAng(tbLayer['OutLoop'], 'A2', tbPart.dSideAngL) end
if tbPart.dSideAngR then TOOL.SetSideAng(tbLayer['OutLoop'], 'A4', tbPart.dSideAngR) end
if tbPart.dSideAngT then TOOL.SetSideAng(tbLayer['OutLoop'], 'A3', tbPart.dSideAngT) end
WriteDataToChildPart(Pz_Top, nPart, nEdge,tbPart.dLen,tbPart.dAngBR, tbPart.dAngBL, tbPart.dH, tbPart.dTh)
end
-- -- creo il fondo
--CreateBottomPart( tbIdInLoopTC, 'InPartA4')
CreateSplitBottomPart( tbIdInLoopTC, Pz_Top, CMP.SWater)
TOOL.SaveMePlease()
TOOL.CreateDimensionLayer()
SetReference()
if CMP.DrawSolid then
loadfile(sPath ..'\\'.. "CreateSOLID_FromPartsInPark.lua")({AutoRun=true})
TOOL.RelocateLabels()
loadfile(sPath ..'\\'.. "OperationOnSolid.lua")({AutoRun=true, nVeinCtx=EgtGetContext()})
AddDimensions()
end
-- Se non ci sono errori salvo i dati
if CMP.ERR == 0 then
-- scrivo i parametri nelle info del pezzo !! DA FARE !!
-- WriteCompoDataToPart( Pz, CMP.Nome, CMP.Npar)
-- salvo i parametri come nuovo default
SaveCompoData(CMP.Npar)
OrigData()
end
--EgtSaveFile(EgtGetStringFromIni( "Vein3D", "Vein3D_Dir", "", EgtGetIniFile()) ..'\\'.. "FOO.nge")
EgtSaveFile("D:\\Temp\\marmo\\Vein3D\\piano_assemblato.nge")
end
end
--CMP_Draw()
_G.CMP_Draw = CMP_Draw
Reference in New Issue View Git Blame Copy Permalink