lili/Hoops_Exchange
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Init

Browse Source
This commit is contained in:
ninja
2025-12-15 22:06:49 +08:00
commit 2b56cf87a8
225 changed files with 63711 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

312
exchange/exchangesource/Viewer/traverse/BrepTraverse.cpp Normal file
View File

@@ -0,0 +1,312 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
\file BrepTraverse.cpp
This file demonstrates how to programmatically traverse the Brep structure
***********************************************************************************************************************/
#include "../VisitorContainer.h"
#include "../BrepTraverse.h"
#include <map>
//////////////////////////////////////////////////////////////////////////////
// Traverse Brep
//////////////////////////////////////////////////////////////////////////////
A3DBrepDataConnector::A3DBrepDataConnector(const A3DTopoBrepData *pBrep) : A3DConnector(pBrep)
{
A3D_INITIALIZE_DATA(A3DTopoBrepDataData, m_sBrepData);
CALL_A3D_FCTION(A3DTopoBrepDataGet,(pBrep, &m_sBrepData));
}
A3DBrepDataConnector::~A3DBrepDataConnector()
{
CALL_A3D_FCTION(A3DTopoBrepDataGet,(NULL, &m_sBrepData));
}
A3DStatus A3DBrepDataConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
//TopoContext
A3DTopoBody *psTopoBody = (A3DTopoBody*)GetA3DEntity();
A3DTopoBodyData sA3DTopoBodyData;
A3D_INITIALIZE_DATA(A3DTopoBodyData, sA3DTopoBodyData);
CHECK_RET_CALL_A3D_FCTION(A3DTopoBodyGet,(psTopoBody, &sA3DTopoBodyData));
A3DTopoContext* psContext = sA3DTopoBodyData.m_pContext;
A3DTopoContextData sA3DTopoContextData;
A3D_INITIALIZE_DATA(A3DTopoContextData, sA3DTopoContextData);
CHECK_RET_CALL_A3D_FCTION(A3DTopoContextGet,(psContext, &sA3DTopoContextData));
//m_dScale = sA3DTopoContextData.m_dScale;
CHECK_RET(psVisitor->visitEnter(*this));
A3DUns32 uNbConnex = m_sBrepData.m_uiConnexSize;
for (A3DUns32 uI = 0; uI < uNbConnex; uI++)
{
A3DConnexConnector sConnecConnector(m_sBrepData.m_ppConnexes[uI]);
CHECK_RET(sConnecConnector.Traverse(psVisitor));
}
CHECK_RET(psVisitor->visitLeave(*this));
return A3D_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////////
// Connex
//////////////////////////////////////////////////////////////////////////////
A3DConnexConnector::A3DConnexConnector(const A3DTopoConnex *pConnex) : A3DConnector(pConnex)
{
A3D_INITIALIZE_DATA(A3DTopoConnexData, m_sConnexData);
CALL_A3D_FCTION(A3DTopoConnexGet,(pConnex, &m_sConnexData));
}
A3DConnexConnector::~A3DConnexConnector()
{
CALL_A3D_FCTION(A3DTopoConnexGet,(NULL, &m_sConnexData));
}
A3DStatus A3DConnexConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
unsigned uI, uNbShell = m_sConnexData.m_uiShellSize;
for (uI = 0; uI < uNbShell; uI++)
{
A3DShellConnector sShellConnector(m_sConnexData.m_ppShells[uI]);
CHECK_RET(sShellConnector.Traverse(psVisitor));
}
CHECK_RET(psVisitor->visitLeave(*this));
return A3D_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////////
// Shell
//////////////////////////////////////////////////////////////////////////////
A3DShellConnector::A3DShellConnector(const A3DTopoShell *pShell) : A3DConnector(pShell)
{
A3D_INITIALIZE_DATA(A3DTopoShellData, m_sShellData);
CALL_A3D_FCTION(A3DTopoShellGet,(pShell, &m_sShellData));
}
A3DShellConnector::~A3DShellConnector()
{
CALL_A3D_FCTION(A3DTopoShellGet,(NULL, &m_sShellData));
}
A3DStatus A3DShellConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
unsigned int uI, uFaceSize = m_sShellData.m_uiFaceSize;
for (uI = 0; uI < uFaceSize; uI++)
{
A3DFaceConnector sFaceConnector(m_sShellData.m_ppFaces[uI]);
CHECK_RET(sFaceConnector.Traverse(psVisitor));
}
CHECK_RET(psVisitor->visitLeave(*this));
return A3D_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////////
// Face
//////////////////////////////////////////////////////////////////////////////
A3DFaceConnector::A3DFaceConnector(const A3DTopoFace* pFace) : A3DConnector(pFace)
{
A3D_INITIALIZE_DATA(A3DTopoFaceData, m_sFaceData);
CALL_A3D_FCTION(A3DTopoFaceGet,(pFace, &m_sFaceData));
}
A3DFaceConnector::~A3DFaceConnector()
{
CALL_A3D_FCTION(A3DTopoFaceGet,(NULL, &m_sFaceData));
}
A3DStatus A3DFaceConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
unsigned int uI, uLoopSize = m_sFaceData.m_uiLoopSize;
for (uI = 0; uI < uLoopSize; uI++)
{
A3DLoopConnector sLoopConnector(m_sFaceData.m_ppLoops[uI]);
CHECK_RET(sLoopConnector.Traverse(psVisitor));
}
CHECK_RET(psVisitor->visitLeave(*this));
return A3D_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////////
// Loop
//////////////////////////////////////////////////////////////////////////////
A3DLoopConnector::A3DLoopConnector(const A3DTopoLoop *pLoop) : A3DConnector(pLoop)
{
A3D_INITIALIZE_DATA(A3DTopoLoopData, m_sLoopData);
CALL_A3D_FCTION(A3DTopoLoopGet,(pLoop, &m_sLoopData));
}
A3DLoopConnector::~A3DLoopConnector()
{
CALL_A3D_FCTION(A3DTopoLoopGet,(NULL, &m_sLoopData));
}
A3DStatus A3DLoopConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
unsigned uI, uCoEdgeSize = m_sLoopData.m_uiCoEdgeSize;
for (uI = 0; uI < uCoEdgeSize; uI++)
{
A3DCoEdgeConnector sCoEdgeConnector(m_sLoopData.m_ppCoEdges[uI]);
CHECK_RET(sCoEdgeConnector.Traverse(psVisitor));
}
CHECK_RET(psVisitor->visitLeave(*this));
return A3D_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////////
// CoEdge
//////////////////////////////////////////////////////////////////////////////
A3DCoEdgeConnector::A3DCoEdgeConnector(const A3DTopoCoEdge *pCoEdge) : A3DConnector(pCoEdge)
{
A3D_INITIALIZE_DATA(A3DTopoCoEdgeData, m_sCoEdgeData);
CALL_A3D_FCTION(A3DTopoCoEdgeGet,(pCoEdge, &m_sCoEdgeData));
}
A3DCoEdgeConnector::~A3DCoEdgeConnector()
{
CALL_A3D_FCTION(A3DTopoCoEdgeGet,(NULL, &m_sCoEdgeData));
}
A3DStatus A3DCoEdgeConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
if (!(psVisitor->FindInMap(m_sCoEdgeData.m_pEdge)))
{
psVisitor->SetInMap(m_sCoEdgeData.m_pEdge, (void*) this->GetA3DEntity());
A3DEdgeConnector sEdgeConnector(m_sCoEdgeData.m_pEdge);
CHECK_RET(sEdgeConnector.Traverse(psVisitor));
}
CHECK_RET(psVisitor->visitLeave(*this));
return A3D_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////////
// Edge
//////////////////////////////////////////////////////////////////////////////
A3DEdgeConnector::A3DEdgeConnector(const A3DTopoEdge *pEdge)
: A3DConnector(pEdge)
{
A3D_INITIALIZE_DATA(A3DTopoEdgeData, m_sEdgeData);
CALL_A3D_FCTION(A3DTopoEdgeGet,(pEdge, &m_sEdgeData));
}
A3DEdgeConnector::~A3DEdgeConnector()
{
CALL_A3D_FCTION(A3DTopoEdgeGet,(NULL, &m_sEdgeData));
}
A3DStatus A3DEdgeConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
A3DEEntityType eType;
//Start Vertex
if (m_sEdgeData.m_pStartVertex != NULL)
{
CHECK_RET_CALL_A3D_FCTION(A3DEntityGetType,(m_sEdgeData.m_pStartVertex,&eType));
if (eType == kA3DTypeTopoMultipleVertex)
{
A3DMultipleVertexConnector sStart(m_sEdgeData.m_pStartVertex);
sStart.Traverse(psVisitor);
}
else if (eType == kA3DTypeTopoUniqueVertex)
{
A3DUniqueVertexConnector sStart(m_sEdgeData.m_pStartVertex);
sStart.Traverse(psVisitor);
}
}
//End Vertex
if (m_sEdgeData.m_pEndVertex != NULL)
{
CHECK_RET_CALL_A3D_FCTION(A3DEntityGetType,(m_sEdgeData.m_pEndVertex,&eType));
if (eType == kA3DTypeTopoMultipleVertex)
{
A3DMultipleVertexConnector sStart(m_sEdgeData.m_pEndVertex);
sStart.Traverse(psVisitor);
}
else if (eType == kA3DTypeTopoUniqueVertex)
{
A3DUniqueVertexConnector sStart(m_sEdgeData.m_pEndVertex);
sStart.Traverse(psVisitor);
}
}
CHECK_RET(psVisitor->visitLeave(*this));
return A3D_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////////
// Vertex
//////////////////////////////////////////////////////////////////////////////
A3DUniqueVertexConnector::A3DUniqueVertexConnector(const A3DTopoVertex *pVertex)
: A3DConnector(pVertex)
{
A3D_INITIALIZE_DATA(A3DTopoUniqueVertexData, m_sVertexData);
CALL_A3D_FCTION(A3DTopoUniqueVertexGet,(pVertex, &m_sVertexData));
}
A3DUniqueVertexConnector::~A3DUniqueVertexConnector()
{
CALL_A3D_FCTION(A3DTopoUniqueVertexGet,(NULL, &m_sVertexData));
}
A3DStatus A3DUniqueVertexConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
return A3D_SUCCESS;
}
A3DMultipleVertexConnector::A3DMultipleVertexConnector(const A3DTopoVertex *pVertex) : A3DConnector(pVertex)
{
A3D_INITIALIZE_DATA(A3DTopoMultipleVertexData, m_sVertexData);
CALL_A3D_FCTION(A3DTopoMultipleVertexGet,(pVertex, &m_sVertexData));
}
A3DMultipleVertexConnector::~A3DMultipleVertexConnector()
{
CALL_A3D_FCTION(A3DTopoMultipleVertexGet,(NULL, &m_sVertexData));
}
A3DStatus A3DMultipleVertexConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
return A3D_SUCCESS;
}

213
exchange/exchangesource/Viewer/traverse/CascadedAttributeConnector.cpp Normal file
View File

@@ -0,0 +1,213 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
#include "../CascadedAttributeConnector.h"
#include "../Visitors.h"
ColorMaterialsConnector::ColorMaterialsConnector(A3DMiscCascadedAttributes* pAttr) : A3DConnector(pAttr)
{
A3D_INITIALIZE_DATA(A3DMiscCascadedAttributesData, m_sCascadedAttributeData);
CALL_A3D_FCTION(A3DMiscCascadedAttributesGet,(pAttr, &(m_sCascadedAttributeData)));
}
ColorMaterialsConnector::~ColorMaterialsConnector()
{
CALL_A3D_FCTION(A3DMiscCascadedAttributesGet,(NULL, &(m_sCascadedAttributeData)));
}
bool ColorMaterialsConnector::IsShow()
{
return m_sCascadedAttributeData.m_bShow ? true : false;
}
bool ColorMaterialsConnector::IsRemoved()
{
return m_sCascadedAttributeData.m_bRemoved ? true : false;
}
bool ColorMaterialsConnector::IsMaterial()
{
//Todo Test it's not a texture
return m_sCascadedAttributeData.m_sStyle.m_bMaterial ? true : false;
}
bool ColorMaterialsConnector::IsRGBColor()
{
return !(IsMaterial());
}
bool ColorMaterialsConnector::IsTranparent()
{
return m_sCascadedAttributeData.m_sStyle.m_bIsTransparencyDefined ? true : false;
}
A3DStatus ColorMaterialsConnector::GetRGB(double adRGB[3])//, char& cInheritance = 0)
{
A3DStatus iRet = A3D_SUCCESS;
A3DGraphRgbColorData sA3DGraphRgbColorData;
A3D_INITIALIZE_DATA(A3DGraphRgbColorData, sA3DGraphRgbColorData);
if(CALL_A3D_FCTION(A3DGlobalGetGraphRgbColorData,(m_sCascadedAttributeData.m_sStyle.m_uiRgbColorIndex, &sA3DGraphRgbColorData)) == A3D_DEFAULT_COLOR)
{
adRGB[0] = 192.0 / 255.0;
adRGB[1] = 192.0 / 255.0;
adRGB[2] = 192.0 / 255.0;
}
else
{
CHECK_RET(iRet);
adRGB[0] = sA3DGraphRgbColorData.m_dRed;
adRGB[1] = sA3DGraphRgbColorData.m_dGreen;
adRGB[2] = sA3DGraphRgbColorData.m_dBlue;
}
return A3D_SUCCESS;
}
A3DStatus ColorMaterialsConnector::Transparency(unsigned char& cTransparenty)
{
cTransparenty = m_sCascadedAttributeData.m_sStyle.m_ucTransparency;
return A3D_SUCCESS;
}
A3DStatus ColorMaterialsConnector::Compare(
ColorMaterialsConnector const & sOtherCascadedAttribute,
bool& bSameDispalyParameter,
bool& bSamebSameDispalyParameterOnFace)
{
if (
sOtherCascadedAttribute.m_sCascadedAttributeData.m_bShow != m_sCascadedAttributeData.m_bShow
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_bRemoved != m_sCascadedAttributeData.m_bRemoved
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_usLayer != m_sCascadedAttributeData.m_usLayer
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_dWidth != m_sCascadedAttributeData.m_sStyle.m_dWidth
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_bVPicture != m_sCascadedAttributeData.m_sStyle.m_bVPicture
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_uiLinePatternIndex != m_sCascadedAttributeData.m_sStyle.m_uiLinePatternIndex
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_bMaterial != m_sCascadedAttributeData.m_sStyle.m_bMaterial
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_uiRgbColorIndex != m_sCascadedAttributeData.m_sStyle.m_uiRgbColorIndex
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_bIsTransparencyDefined != m_sCascadedAttributeData.m_sStyle.m_bIsTransparencyDefined
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_ucTransparency != m_sCascadedAttributeData.m_sStyle.m_ucTransparency
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_bSpecialCulling != m_sCascadedAttributeData.m_sStyle.m_bSpecialCulling
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_bFrontCulling != m_sCascadedAttributeData.m_sStyle.m_bFrontCulling
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_bBackCulling != m_sCascadedAttributeData.m_sStyle.m_bBackCulling
|| sOtherCascadedAttribute.m_sCascadedAttributeData.m_sStyle.m_bNoLight != m_sCascadedAttributeData.m_sStyle.m_bNoLight)
bSameDispalyParameter = bSamebSameDispalyParameterOnFace = false;
else
bSameDispalyParameter = true;
return A3D_SUCCESS;
}
int ColorMaterialsConnector::GetMaterial(double dEmmisive[4],
double dDiffuse[4],
double dAmbient[4],
double dSpecular[4],
double& dShininess)
{
int iRet = eBAD_Diffuse + eBAD_Emissive + eBAD_Specular + eBAD_Ambient;
A3DStatus iErr = A3D_SUCCESS;
A3DGraphMaterialData sMaterialData;
memset(dEmmisive, 0, sizeof(double) * 4);
memset(dDiffuse, 0, sizeof(double) * 4);
memset(dAmbient, 0, sizeof(double) * 4);
memset(dSpecular, 0, sizeof(double) * 4);
dShininess = 0;
A3D_INITIALIZE_DATA(A3DGraphMaterialData, sMaterialData);
iErr = CALL_A3D_FCTION(A3DGlobalGetGraphMaterialData,(m_sCascadedAttributeData.m_sStyle.m_uiRgbColorIndex, &sMaterialData));
if (iErr == A3D_SUCCESS)
{
iRet = 0;
A3DGraphRgbColorData sColorData;
A3D_INITIALIZE_DATA(A3DGraphRgbColorData, sColorData);
if (sMaterialData.m_uiDiffuse != A3D_DEFAULT_COLOR_INDEX)
{
CALL_A3D_FCTION(A3DGlobalGetGraphRgbColorData,(sMaterialData.m_uiDiffuse, &sColorData));
dDiffuse[0] = sColorData.m_dRed;
dDiffuse[1] = sColorData.m_dGreen;
dDiffuse[2] = sColorData.m_dBlue;
if (m_sCascadedAttributeData.m_sStyle.m_bIsTransparencyDefined)
{
dDiffuse[3] = (double)(m_sCascadedAttributeData.m_sStyle.m_ucTransparency) / 255.0;
}
else
{
dDiffuse[3] = 1.0;
}
}
else
iRet |= eBAD_Diffuse;
if (sMaterialData.m_uiEmissive != A3D_DEFAULT_COLOR_INDEX)
{
CALL_A3D_FCTION(A3DGlobalGetGraphRgbColorData,(sMaterialData.m_uiEmissive, &sColorData));
dEmmisive[0] = sColorData.m_dRed;
dEmmisive[1] = sColorData.m_dGreen;
dEmmisive[2] = sColorData.m_dBlue;
if (m_sCascadedAttributeData.m_sStyle.m_bIsTransparencyDefined)
{
dEmmisive[3] = sMaterialData.m_dEmissiveAlpha;
}
else
{
dEmmisive[3] = 1.0;
}
}
else
iRet |= eBAD_Emissive;
dShininess = sMaterialData.m_dShininess;
if (sMaterialData.m_uiSpecular != A3D_DEFAULT_COLOR_INDEX)
{
CALL_A3D_FCTION(A3DGlobalGetGraphRgbColorData,(sMaterialData.m_uiSpecular, &sColorData));
dSpecular[0] = sColorData.m_dRed;
dSpecular[1] = sColorData.m_dGreen;
dSpecular[2] = sColorData.m_dBlue;
if (m_sCascadedAttributeData.m_sStyle.m_bIsTransparencyDefined)
{
dSpecular[3] = sMaterialData.m_dSpecularAlpha;
}
else
{
dSpecular[3] = 1.0;
}
}
else
iRet |= eBAD_Specular;
if (sMaterialData.m_uiAmbient != A3D_DEFAULT_COLOR_INDEX)
{
CALL_A3D_FCTION(A3DGlobalGetGraphRgbColorData,(sMaterialData.m_uiAmbient, &sColorData));
dAmbient[0] = sColorData.m_dRed;
dAmbient[1] = sColorData.m_dGreen;
dAmbient[2] = sColorData.m_dBlue;
if (m_sCascadedAttributeData.m_sStyle.m_bIsTransparencyDefined)
{
dAmbient[3] = sMaterialData.m_dAmbientAlpha;
}
else
{
dAmbient[3] = 1.0;
}
}
else
iRet |= eBAD_Ambient;
}
return iRet;
}

644
exchange/exchangesource/Viewer/traverse/MarkupTessConnector.cpp Normal file
View File

@@ -0,0 +1,644 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
\file MarkupConnector.cpp
This file provides tools to get the visual representation of markup
***********************************************************************************************************************/
#include "../MarkupTessConnector.h"
#include "../Visitors.h"
#include <algorithm>
#include "../Matrix.h"
#define DEFAULT_OFFSET {\
pData += *(puiStart+1); \
puiStart += (uiCount + 1); \
}
#define MAKE_OFFSET(CountInt, CountFloats) {\
pData += CountFloats; \
puiStart += (CountInt + 1); \
}
A3DMarkupTessDataConnectorCreator::A3DMarkupTessDataConnectorCreator(std::vector<A3DMarkupTessConnector*>& a_rvMkpTessConnector)
: m_bStartToDrawSet(false), m_bFaceViewActivated(false), m_bFramedrawActivated(false), m_bFixedSizeActivated(false),
m_rvMarkupTessData(a_rvMkpTessConnector)
{
m_rvMarkupTessData.push_back(new A3DMarkupTessConnector());
//Set Indentity On Matrix
memset(&m_adCurrentWorldMatrix[0], 0, sizeof(double) * 16);
m_adCurrentWorldMatrix[0] = m_adCurrentWorldMatrix[5] = m_adCurrentWorldMatrix[10] = m_adCurrentWorldMatrix[15] = 1;
m_adPushedWorldMatrices.resize(16);
memcpy(&m_adPushedWorldMatrices[0], m_adCurrentWorldMatrix, sizeof(double) * 16);
}
A3DMarkupTessDataConnectorCreator::~A3DMarkupTessDataConnectorCreator()
{
}
A3DStatus A3DMarkupTessDataConnectorCreator::pushMatrix(const double* a_pdLocalMatrix)
{
size_t uSize = m_adPushedWorldMatrices.size();
if (uSize < 16)
return A3D_ERROR;
m_adPushedWorldMatrices.resize(uSize + 16);
MultiplyMatrix(&m_adCurrentWorldMatrix[0], a_pdLocalMatrix, &m_adPushedWorldMatrices[uSize]);
memcpy(&m_adCurrentWorldMatrix[0], &m_adPushedWorldMatrices[uSize], sizeof(double) * 16);
return A3D_SUCCESS;
}
A3DStatus A3DMarkupTessDataConnectorCreator::popMatrix()
{
size_t uSize = m_adPushedWorldMatrices.size() - 16;
m_adPushedWorldMatrices.resize(uSize);
memcpy(&m_adCurrentWorldMatrix[0], &m_adPushedWorldMatrices[uSize - 16], sizeof(double) * 16);
return A3D_SUCCESS;
}
A3DMarkupTessConnector& A3DMarkupTessDataConnectorCreator::GetMarkupTessConnector(const double* pdMatrix)
{
bool bSameMatrix = true;
size_t uI, uSize = m_rvMarkupTessData.size();
for (uI = 0; uI < 16; uI++)
{
if (m_adCurrentWorldMatrix[uI] != pdMatrix[uI])
{
bSameMatrix = false;
break;
}
}
if (!bSameMatrix/* && m_bStartToDrawSet*/)
{
m_rvMarkupTessData.push_back(new A3DMarkupTessConnector(*m_rvMarkupTessData[uSize - 1]));
m_bStartToDrawSet = false;
uSize++;
}
return *m_rvMarkupTessData[uSize - 1];
}
A3DMarkupTessConnector& A3DMarkupTessDataConnectorCreator::GetMarkupTessConnector(unsigned uiExtraDataValue, bool& bCameraDependant)
{
size_t uSize = m_rvMarkupTessData.size();
bCameraDependant = false;
m_bStartToDrawSet = m_rvMarkupTessData.back()->HasAlreadySomethingToDisplay();
switch (uiExtraDataValue)
{
case A3D_DECODE_EXTRA_DATA(kA3DMarkupFaceViewMask): // 6 : Camera Dependant - Faceview
m_bFaceViewActivated = !m_bFaceViewActivated;
case A3D_DECODE_EXTRA_DATA(kA3DMarkupFrameDrawMask): // 7 : CameraDependant - Frame draw
m_bFramedrawActivated = !m_bFramedrawActivated;
case A3D_DECODE_EXTRA_DATA(kA3DMarkupFixedSizeMask): // 8 : CameraDependant - Fixedsize
m_bFixedSizeActivated = !m_bFixedSizeActivated;
case A3D_DECODE_EXTRA_DATA(kA3DMarkupSymbolMask): // 9 : Camera Dependant - Symbol
case A3D_DECODE_EXTRA_DATA(kA3DMarkupColorMask): // 11 : color
case A3D_DECODE_EXTRA_DATA(kA3DMarkupLineStippleMask): // 12 : line stipple
case A3D_DECODE_EXTRA_DATA(kA3DMarkupLineWidthMask): // 17 : line width
case 0: // polyline
case A3D_DECODE_EXTRA_DATA(kA3DMarkupTrianglesMask): // 2 : triangles
case A3D_DECODE_EXTRA_DATA(kA3DMarkupCylinderMask): // 10 : cylinder
case A3D_DECODE_EXTRA_DATA(kA3DMarkupFontMask): // 13 : font
case A3D_DECODE_EXTRA_DATA(kA3DMarkupTextMask): // 14 : text
case A3D_DECODE_EXTRA_DATA(kA3DMarkupPointsMask): // 15 : points
case A3D_DECODE_EXTRA_DATA(kA3DMarkupPolygonMask): // 16 : polygon
{
if (m_bStartToDrawSet)
{
A3DMarkupTessConnector *pNewConnector = new A3DMarkupTessConnector(*m_rvMarkupTessData[uSize - 1]);
m_rvMarkupTessData.push_back(pNewConnector);
uSize++;
m_bStartToDrawSet = false;
memcpy(&(pNewConnector->m_adWorldMatrix[0]),
&m_adCurrentWorldMatrix[0],
sizeof(double) * 16);
}
}
break;
}
if (m_bFaceViewActivated || m_bFramedrawActivated || m_bFixedSizeActivated)
bCameraDependant = true;
return *m_rvMarkupTessData[uSize - 1];
}
/********************************************************************************************************************
A3DMarkupTessConnector
*********************************************************************************************************************/
A3DMarkupTessConnector::A3DMarkupTessConnector() : m_bFaceView(false), m_bFrameDraw(false), m_bSymbol(false), m_bFixedSize(false),
m_bIsText(false), m_uiFixedSizePatternIndex(0), m_iGraphStyleIndexLinsStyle(-1), m_dLineWidth(1.0), m_iGraphVPicturePatternIndex(-1)
{
memset(m_adViewDependantParameter, 0, sizeof(m_adViewDependantParameter));
memset(m_adWorldMatrix, 0, sizeof(m_adWorldMatrix));
m_adWorldMatrix[0] = m_adWorldMatrix[5] = m_adWorldMatrix[10] = m_adWorldMatrix[15] = 1.;
memcpy(&m_adModelMatrix[0], &m_adWorldMatrix[0], sizeof(double) * 16);
memcpy(&m_adProjMatrix[0], &m_adWorldMatrix[0], sizeof(double) * 16);
m_adRGB[0] = m_adRGB[1] = m_adRGB[2] = -1.0;
}
A3DMarkupTessConnector::A3DMarkupTessConnector(A3DMarkupTessConnector& a_PreviousTessConnector)
{
m_bFaceView = a_PreviousTessConnector.m_bFaceView;
m_bFrameDraw = a_PreviousTessConnector.m_bFrameDraw;
m_bSymbol = a_PreviousTessConnector.m_bSymbol;
m_bFixedSize = a_PreviousTessConnector.m_bFixedSize;
m_bIsText = a_PreviousTessConnector.m_bIsText;
memcpy(m_adViewDependantParameter, a_PreviousTessConnector.m_adViewDependantParameter, sizeof(m_adViewDependantParameter));
m_uiFixedSizePatternIndex = a_PreviousTessConnector.m_uiFixedSizePatternIndex;
m_ucBehaviour = a_PreviousTessConnector.m_ucBehaviour;
//Graphic
memcpy(m_adRGB, a_PreviousTessConnector.m_adRGB, sizeof(m_adRGB));
m_dLineWidth = a_PreviousTessConnector.m_dLineWidth;
m_iGraphStyleIndexLinsStyle = a_PreviousTessConnector.m_iGraphStyleIndexLinsStyle;
m_iGraphVPicturePatternIndex = a_PreviousTessConnector.m_iGraphVPicturePatternIndex;
}
A3DMarkupTessConnector::~A3DMarkupTessConnector()
{
std::vector<A3DPMITextEntry*>::iterator itCur = m_apTexts.begin();
std::vector<A3DPMITextEntry*>::iterator itEnd = m_apTexts.end();
for (; itCur < itEnd; ++itCur)
{
delete *itCur;
}
}
#define SIZE_ARROW 15.0
A3DStatus A3DMarkupTessConnector::GetMarkupTessellation(const A3DTessBaseData& sTessBaseData,
const A3DTessMarkupData* pTessMarkupData,
const bool bIsText,
std::vector<A3DMarkupTessConnector*>& asMarkupTessDataConnector,
double a_dParallelToScreenPMIScale)
{
A3DMarkupTessDataConnectorCreator sMarkupTessDataConnectorCreator(asMarkupTessDataConnector);
A3DStatus iRet = A3D_SUCCESS;
float afDefaultcolor[3];
afDefaultcolor[0] = afDefaultcolor[1] = afDefaultcolor[2] = 0.;
bool bIsScreenMarkupZoomable = true;
unsigned int kSize;
unsigned int uiCount = 0;
A3DGraphRgbColorData sRgbColorData;
A3D_INITIALIZE_DATA(A3DGraphRgbColorData, sRgbColorData);
A3DGraphStyleData sGraphStyleData;
A3D_INITIALIZE_DATA(A3DGraphStyleData, sGraphStyleData);
A3DGraphPictureData sPictureData;
A3D_INITIALIZE_DATA(A3DGraphPictureData, sPictureData);
A3DFontKeyData sFontKeyData;
A3D_INITIALIZE_DATA(A3DFontKeyData, sFontKeyData);
bIsScreenMarkupZoomable = (pTessMarkupData->m_cBehaviour & kA3DMarkupIsZoomable) != 0;
const A3DDouble* pData = sTessBaseData.m_pdCoords;
const A3DUns32* puiStart = &pTessMarkupData->m_puiCodes[0];
const A3DUns32* puiEnd = &pTessMarkupData->m_puiCodes[pTessMarkupData->m_uiCodesSize - 1];
bool bShow = false;
if ((pData != NULL) && (puiStart != NULL) && (puiEnd != NULL)) for (; puiStart < puiEnd; puiStart++)
{
uiCount = *puiStart & kA3DMarkupIntegerMask;
bShow = true;
if (*puiStart & kA3DMarkupIsExtraData)
{
A3DUns32 uiExtraDataValue = A3D_DECODE_EXTRA_DATA(*puiStart);
bool bCameraDependant;
A3DMarkupTessConnector& sCurMarkupTessConnector =
sMarkupTessDataConnectorCreator.GetMarkupTessConnector(uiExtraDataValue, bCameraDependant);
sCurMarkupTessConnector.m_ucBehaviour = pTessMarkupData->m_cBehaviour;
switch (uiExtraDataValue)
{
case A3D_DECODE_EXTRA_DATA(kA3DMarkupTrianglesMask): // 2 : // triangles
{
kSize = *(puiStart + 1);// number of triangles * 9
unsigned int uI;
for (uI = 0; uI < kSize; uI++)
sCurMarkupTessConnector.m_adTriangleList.push_back(*(pData + uI));
DEFAULT_OFFSET;
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupFaceViewMask): // 6 : // Camera Dependant - Face view
// Using by circle center/fastener/measurement point/spot welding
// geometrical symbol zoomable
{
if (*(puiStart + 1) > 0)
{
sCurMarkupTessConnector.m_bFaceView = true;
sCurMarkupTessConnector.m_adViewDependantParameter[0] = *pData;
sCurMarkupTessConnector.m_adViewDependantParameter[1] = *(pData + 1);
sCurMarkupTessConnector.m_adViewDependantParameter[2] = *(pData + 2);
MAKE_OFFSET(0, 3)
}
else
{
if (!(sMarkupTessDataConnectorCreator.HasStartToDrawSet()))
sCurMarkupTessConnector.m_bFaceView = false;
MAKE_OFFSET(0, 0);
}
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupFrameDrawMask): // 7 : // CameraDependant - Frame draw
// Usually used for non-zoomable text, but it is possible to change to zoomable (option on CatiaV5)
{
if (*(puiStart + 1) > 0)
{
sCurMarkupTessConnector.m_bFrameDraw = true;
sCurMarkupTessConnector.m_adViewDependantParameter[0] = *pData;
sCurMarkupTessConnector.m_adViewDependantParameter[1] = *(pData + 1);
sCurMarkupTessConnector.m_adViewDependantParameter[2] = /*bIsText ? 0 : */*(pData + 2);
sCurMarkupTessConnector.m_bIsText = bIsText;
MAKE_OFFSET(0, 3)
}
else
{
if (!(sMarkupTessDataConnectorCreator.HasStartToDrawSet()))
sCurMarkupTessConnector.m_bFrameDraw = false;
MAKE_OFFSET(0, 0)
}
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupFixedSizeMask): // 8 : // CameraDependant - Fixedsize
{
if (*(puiStart + 1) > 0)
{
sCurMarkupTessConnector.m_bFixedSize = true;
sCurMarkupTessConnector.m_adViewDependantParameter[0] = *pData;
sCurMarkupTessConnector.m_adViewDependantParameter[1] = *(pData + 1);
sCurMarkupTessConnector.m_adViewDependantParameter[2] = /*bIsText ? 0 : */*(pData + 2);
sCurMarkupTessConnector.m_uiFixedSizePatternIndex = *(puiStart + 2);
MAKE_OFFSET(0, 3);
}
else
{
if (!(sMarkupTessDataConnectorCreator.HasStartToDrawSet()))
sCurMarkupTessConnector.m_bFixedSize = false;
MAKE_OFFSET(0, 0)
}
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupSymbolMask): // 9 : // Camera Dependant - Symbol
{
sCurMarkupTessConnector.m_bSymbol = true;
sCurMarkupTessConnector.m_adViewDependantParameter[0] = *pData;
sCurMarkupTessConnector.m_adViewDependantParameter[1] = *(pData + 1);
sCurMarkupTessConnector.m_adViewDependantParameter[2] = /*bIsText ? 0 : */*(pData + 2);
//unsigned int uiPatternIndex = *(puiStart+2);
DEFAULT_OFFSET
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupCylinderMask): // 10 : cylinder
{
double dRadiusBase = *pData;
double dRadiusTop = *(pData + 1);
double dHeight = *(pData + 2);
sCurMarkupTessConnector.m_adCylinder.push_back(dRadiusBase);
sCurMarkupTessConnector.m_adCylinder.push_back(dRadiusTop);
sCurMarkupTessConnector.m_adCylinder.push_back(dHeight);
DEFAULT_OFFSET
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupPolygonMask): // 16 : polylines
{
if (sCurMarkupTessConnector.m_adPolylineCoords.empty() == true)
{
sCurMarkupTessConnector.m_aiPolylineIndices.push_back(0);
}
kSize = *(puiStart + 1); // number of points
int iNbIndicesBefore = 0;
if (sCurMarkupTessConnector.m_aiPolylineIndices.size() > 0)
{
iNbIndicesBefore = sCurMarkupTessConnector.m_aiPolylineIndices.back();
}
unsigned int uI;
for (uI = 0; uI < kSize; uI++)
sCurMarkupTessConnector.m_adPolylineCoords.push_back(*(pData + uI));
sCurMarkupTessConnector.m_aiPolylineIndices.push_back(iNbIndicesBefore + (kSize / 3));
DEFAULT_OFFSET;
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupColorMask): // 11 : color
{
CHECK_RET_CALL_A3D_FCTION(A3DGlobalGetGraphRgbColorData,(*(puiStart+2), &sRgbColorData));
sCurMarkupTessConnector.m_adRGB[0] = sRgbColorData.m_dRed;
sCurMarkupTessConnector.m_adRGB[1] = sRgbColorData.m_dGreen;
sCurMarkupTessConnector.m_adRGB[2] = sRgbColorData.m_dBlue;
DEFAULT_OFFSET;
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupLineStippleMask): // 12 : line stipple
{
if (uiCount > 0)
{
sCurMarkupTessConnector.m_iGraphStyleIndexLinsStyle = *(puiStart + 2);
}
else
sCurMarkupTessConnector.m_iGraphStyleIndexLinsStyle = -1;
//glDisable(GL_LINE_STIPPLE);
DEFAULT_OFFSET;
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupLineWidthMask): // 17 : line width
// Linewidth are only used on markup arrow of drawings
{
if (*(puiStart + 1) > 0)
{
sCurMarkupTessConnector.m_dLineWidth = *pData;
}
else
{
sCurMarkupTessConnector.m_dLineWidth = 1;
}
DEFAULT_OFFSET;
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupPointsMask): // 15: points
{
kSize = *(puiStart + 1); // number of points
unsigned int uI;
for (uI = 0; uI < kSize; uI++)
{
sCurMarkupTessConnector.m_adPoints.push_back(*(pData + uI));
}
DEFAULT_OFFSET;
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupFontMask): // 13: font
{
sFontKeyData.m_iFontFamilyIndex = *(puiStart + 2);
sFontKeyData.m_iFontStyleIndex = (*(puiStart + 3) & kA3DFontKeyStyle) >> 24;
sFontKeyData.m_iFontSizeIndex = (*(puiStart + 3) & kA3DFontKeySize) >> 12;
sFontKeyData.m_cAttributes = (A3DInt8)(*(puiStart + 3) & kA3DFontKeyAttrib);
DEFAULT_OFFSET;
break;
}
case A3D_DECODE_EXTRA_DATA(kA3DMarkupTextMask): // 14: text
{
A3DDouble dTextWidth = *pData;
A3DDouble dTextHeight = *(pData + 1);
A3DUns32 uiTextIndex = *(puiStart + 2);
if (uiTextIndex < pTessMarkupData->m_uiTextsSize)
{
sCurMarkupTessConnector.m_apTexts.push_back(new A3DPMITextEntry(dTextWidth, dTextHeight,
sFontKeyData, pTessMarkupData->m_ppcTexts[uiTextIndex]));
}
DEFAULT_OFFSET;
break;
}
default:
DEFAULT_OFFSET;
}
}
else if (*puiStart & kA3DMarkupIsMatrix)
{
if (*(puiStart + 1) > 0) // if there are floats it is the beginning of a "matrix" mode
{
A3DMarkupTessConnector& sCurMarkupTessConnector = sMarkupTessDataConnectorCreator.GetMarkupTessConnector((const double*)pData);
sCurMarkupTessConnector.m_ucBehaviour = pTessMarkupData->m_cBehaviour;
CHECK_RET(sMarkupTessDataConnectorCreator.pushMatrix((const double*)pData));
memcpy(&(sCurMarkupTessConnector.m_adWorldMatrix[0]),
sMarkupTessDataConnectorCreator.GetCurrentWorldMatrix(),
sizeof(double) * 16);
//dScaleText=stGetScaleText(pData);
if (sCurMarkupTessConnector.IsFrameDraw())
{
sCurMarkupTessConnector.m_adWorldMatrix[0] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[1] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[2] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[4] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[5] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[6] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[7] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[8] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[9] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[11] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[12] *= a_dParallelToScreenPMIScale;
sCurMarkupTessConnector.m_adWorldMatrix[13] *= a_dParallelToScreenPMIScale;
}
MAKE_OFFSET(0, 16);
}
else // if there is no float, the matrix mode ends
{
sMarkupTessDataConnectorCreator.popMatrix();
MAKE_OFFSET(0, 0);
}
}
else // It's a polyline
{
bool bCameraDependant;
A3DMarkupTessConnector& sCurMarkupTessConnector =
sMarkupTessDataConnectorCreator.GetMarkupTessConnector(0, bCameraDependant);
if (sCurMarkupTessConnector.m_adPolylineCoords.empty() == true)
{
sCurMarkupTessConnector.m_aiPolylineIndices.push_back(0);
}
kSize = *(puiStart + 1); // Number of points
unsigned int i = 0;
for (i = 0; i < kSize; i++)
{
sCurMarkupTessConnector.m_adPolylineCoords.push_back(*(pData + i));
}
if (sCurMarkupTessConnector.IsFrameDraw())
{
std::vector<double>::iterator itRescaleCur = sCurMarkupTessConnector.m_adPolylineCoords.begin();
std::vector<double>::iterator itRescaleEnd = sCurMarkupTessConnector.m_adPolylineCoords.end();
for (; itRescaleCur != itRescaleEnd; ++itRescaleCur)
{
*itRescaleCur *= a_dParallelToScreenPMIScale;
}
}
sCurMarkupTessConnector.m_aiPolylineIndices.push_back(int(sCurMarkupTessConnector.m_adPolylineCoords.size()) / 3);
DEFAULT_OFFSET;
}
}
return iRet;
}
/// Is the order important? Like if FaceView set after Framedraw
A3DStatus A3DMarkupTessConnector::ComputeCameraDependantMatrix(
double const * pdProjMatrix,
int const * aiViewport,
long const * Rect, // TOP_LEFT(X,Y) BOTTOM_RIGHT(X,Y)
double* /*pdPerViewMatrix*/)
{
A3DStatus iRet = A3D_SUCCESS;
double dScaling = 1, dFixedSize = 1.0 * 15 / dScaling;
if (m_bFaceView) // faceview
// using for circlecenter/fastener/measurementpoint/spotwelding
// geometrical symbol zoomable
{
double sO[3]; sO[0] = 0; sO[1] = 0; sO[2] = 0;
double sX[3]; sX[0] = 1; sX[1] = 0; sX[2] = 0;
double sY[3]; sY[0] = 0; sY[1] = 1; sY[2] = 0;
double adP0[3], adP1[3], adP2[3];
UnProject(&sO[0], m_adModelMatrix, pdProjMatrix, aiViewport, &adP0[0]);
UnProject(&sX[0], m_adModelMatrix, pdProjMatrix, aiViewport, &adP1[0]);
UnProject(&sY[0], m_adModelMatrix, pdProjMatrix, aiViewport, &adP2[0]);
double adVectX[3];
adVectX[0] = adP1[0] - adP0[0];
adVectX[1] = adP1[1] - adP0[1];
adVectX[2] = adP1[2] - adP0[2];
double adVectY[3];
adVectY[0] = adP2[0] - adP0[0];
adVectY[1] = adP2[1] - adP0[1];
adVectY[2] = adP2[2] - adP0[2];
double adPlaneNormal[3];
//Cross Product
adPlaneNormal[0] = adVectX[1] * adVectY[2] - adVectX[2] * adVectY[1];
adPlaneNormal[0] = adVectX[2] * adVectY[0] - adVectX[0] * adVectY[2];
adPlaneNormal[0] = adVectX[0] * adVectY[1] - adVectX[1] * adVectY[0];
double adMat[16];
CHECK_RET(Calculate(&adVectX[0], &adVectY[0], &adPlaneNormal[0], &adMat[0]));
adMat[12] = m_adViewDependantParameter[0];
adMat[13] = m_adViewDependantParameter[1];
adMat[14] = m_adViewDependantParameter[2];
adMat[15] = 1.;
double adOldModelMatrix[16];
memcpy(&adOldModelMatrix[0], &m_adModelMatrix[0], sizeof(double) * 16);
CHECK_RET(MultiplyMatrix(&adOldModelMatrix[0], &adMat[0], &m_adModelMatrix[0]));
}
if (m_bFrameDraw) // Usually used for non-zoomable text, but it is possible to change to zoomable (option on CatiaV5)
{
double dXProj, dYProj, dZProj;
if (m_bIsText)
{
dXProj = m_adViewDependantParameter[0];
dYProj = m_adViewDependantParameter[1];
dZProj = 0.;
}
else
{
// if (GetMatrixOwnerGroup(sMatGroup))
// sMatGroup.TransformScaled(adViewDependantParameter[0], adViewDependantParameter[1], adViewDependantParameter[2]);
Project(m_adViewDependantParameter[0], m_adViewDependantParameter[1], m_adViewDependantParameter[2],
m_adModelMatrix, pdProjMatrix, aiViewport, &dXProj, &dYProj, &dZProj);
}
double adIentity[16];
Identity(&adIentity[0]);
double adOrthoMatrix[16];
Ortho(&adIentity[0],
0.0, (double)(Rect[3] - Rect[1]), // Right, Left
0.0, (double)(Rect[0] - Rect[2]), //Top, Bottom
-1.0, 1.0, //Near, Fast
&adOrthoMatrix[0]);
double adTranslat[16];
Identity(&adTranslat[0]);
adTranslat[3] = dXProj;
adTranslat[7] = dYProj;
adTranslat[11] = dZProj;
CHECK_RET(MultiplyMatrix(&adOrthoMatrix[0], &adTranslat[0], &m_adProjMatrix[0]));
if (IsZoomable())
{
double adScale[16];
Identity(&adScale[0]);
adScale[0] = adScale[5] = adScale[10] = adScale[15] = dFixedSize;
double adOldModelMatrix[16];
memcpy(&adOldModelMatrix[0], &m_adModelMatrix[0], sizeof(double) * 16);
CHECK_RET(MultiplyMatrix(&adOldModelMatrix[0], &adScale[0], &m_adModelMatrix[0]));
}
}
if (m_bFixedSize)
{
double adTranslat[16];
Identity(&adTranslat[0]);
adTranslat[3] = m_adViewDependantParameter[0];
adTranslat[7] = m_adViewDependantParameter[1];
adTranslat[11] = m_adViewDependantParameter[2];
double adScale[16];
Identity(&adScale[0]);
adScale[0] = adScale[5] = adScale[10] = adScale[15] = dFixedSize;
double adOldModelMatrix[16];
memcpy(&adOldModelMatrix[0], &m_adModelMatrix[0], sizeof(double) * 16);
CHECK_RET(MultiplyMatrix(&adOldModelMatrix[0], &adTranslat[0], &m_adModelMatrix[0]));
memcpy(&adOldModelMatrix[0], &m_adModelMatrix[0], sizeof(double) * 16);
CHECK_RET(MultiplyMatrix(&adOldModelMatrix[0], &adScale[0], &m_adModelMatrix[0]));
}
if (m_bSymbol)
{
double dXProj, dYProj, dZProj;
if (m_bIsText)
{
dXProj = m_adViewDependantParameter[0];
dYProj = m_adViewDependantParameter[1];
dZProj = 0.;
}
else
{
// if (GetMatrixOwnerGroup(sMatGroup))
// sMatGroup.TransformScaled(sPntFrame.x,sPntFrame.y,sPntFrame.z);
CHECK_RET(Project(m_adViewDependantParameter[0], m_adViewDependantParameter[1], m_adViewDependantParameter[2],
m_adModelMatrix, pdProjMatrix, aiViewport, &dXProj, &dYProj, &dZProj));
}
double adIentity[16];
Identity(&adIentity[0]);
double adOrthoMatrix[16];
CHECK_RET(Ortho(&adIentity[0],
0.0, (double)(Rect[3] - Rect[1]), // Right, Left
0.0, (double)(Rect[0] - Rect[2]), //Top, Bottom
-1.0, 1.0, //Near, Fast
&adOrthoMatrix[0]));
double adTranslat[16];
Identity(&adTranslat[0]);
adTranslat[3] = dXProj;
adTranslat[7] = dYProj;
adTranslat[11] = dZProj;
CHECK_RET(MultiplyMatrix(&adOrthoMatrix[0], &adTranslat[0], &m_adProjMatrix[0]));
//Pattern not used
}
return A3D_SUCCESS;
}

255
exchange/exchangesource/Viewer/traverse/MarkupTraverse.cpp Normal file
View File

@@ -0,0 +1,255 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
\file MarkupTraverse.cpp
This file contains functionalities to traverse a PRC Markup Tree
***********************************************************************************************************************/
#include "../VisitorContainer.h"
#include "../MarkupTraverse.h"
#include <A3DSDKTessellation.h>
#include <vector>
#include "../MarkupTessConnector.h"
//////////////////////////////////////////////////////////////////////////////
// Traverse Markup
//////////////////////////////////////////////////////////////////////////////
A3DStatus A3DMkpAnnotationEntityConnector::TraverseAnnotationEntity(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
A3DEEntityType eType = kA3DTypeUnknown;
A3DStatus iRet = CALL_A3D_FCTION(A3DEntityGetType,(m_pEntity,&eType));
CHECK_RET(iRet);
switch (eType)
{
case kA3DTypeMkpAnnotationSet:
{
A3DMkpAnnotationSetConnector sMkpAnnotationSetConnector((A3DMkpAnnotationSet*)m_pEntity);
iRet = sMkpAnnotationSetConnector.TraverseAnnotationSet(pVisitor);
break;
}
case kA3DTypeMkpAnnotationReference:
{
A3DMkpAnnotationReferenceConnector sMkpAnnotationReferenceConnector((A3DMkpAnnotationReference*)m_pEntity);
iRet = sMkpAnnotationReferenceConnector.TraverseAnnotationReference(pVisitor);
break;
}
case kA3DTypeMkpAnnotationItem:
{
A3DMkpAnnotationItemConnector sMkpAnnotationItemConnector((A3DMkpAnnotationItem*)m_pEntity);
iRet = sMkpAnnotationItemConnector.TraverseAnnotationItem(pVisitor);
break;
}
default:
iRet = A3D_ERROR;
break;
}
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DStatus A3DMkpAnnotationSetConnector::TraverseAnnotationSet(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
A3DUns32 uNbAnnotEntity = m_sAnnotSetData.m_uiAnnotationsSize;
for (A3DUns32 uI = 0; uI < uNbAnnotEntity; uI++)
{
A3DMkpAnnotationEntityConnector sMkpAnnotationEntityConnector(m_sAnnotSetData.m_ppAnnotations[uI]);
sMkpAnnotationEntityConnector.TraverseAnnotationEntity(pVisitor);
}
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DStatus A3DMkpAnnotationReferenceConnector::TraverseAnnotationReference(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DStatus A3DMkpAnnotationItemConnector::TraverseAnnotationItem(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
if (m_sAnnotItemData.m_pMarkup == NULL)
{
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DMarkupConnector sMarkupConnector((A3DMkpMarkup*)m_sAnnotItemData.m_pMarkup);
/////////////////////////////////////////////////
// Traverse Semantic
/////////////////////////////////////////////////
sMarkupConnector.TraverseMarkupSemantic(pVisitor);
/////////////////////////////////////////////////
// Traverse Graphicals information
/////////////////////////////////////////////////
std::vector<A3DMarkupTessConnector*> asMarkupTessConnector;
double a_dParallelToScreenPMIScale = 1;
sMarkupConnector.SplitMarkupTesselationByEntityWithSameGraphics(asMarkupTessConnector, a_dParallelToScreenPMIScale);
sMarkupConnector.TraverseMarkupTess(pVisitor, asMarkupTessConnector);
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DStatus A3DMarkupConnector::TraverseMarkupTess(A3DVisitorContainer* pVisitor, std::vector<A3DMarkupTessConnector*>& asMarkupTessConnector)
{
for (size_t ui = 0; ui < asMarkupTessConnector.size(); ui++)
asMarkupTessConnector[ui]->TraverseMarkupTessWithSameGraphicsAttributes(pVisitor);
return A3D_SUCCESS;
}
A3DStatus A3DMarkupTessConnector::TraverseMarkupTessWithSameGraphicsAttributes(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DStatus A3DMarkupConnector::SplitMarkupTesselationByEntityWithSameGraphics(std::vector<A3DMarkupTessConnector*>& asMarkupTessConnector,
double a_dParallelToScreenPMIScale)
{
A3DStatus iRet = A3D_SUCCESS;
A3DTessMarkupData sMarkupTessData;
A3D_INITIALIZE_DATA(A3DTessMarkupData, sMarkupTessData);
CHECK_RET_CALL_A3D_FCTION(A3DTessMarkupGet,(m_sMarkupData.m_pTessellation, &sMarkupTessData));
A3DTessBaseData sTessBaseData;
A3D_INITIALIZE_DATA(A3DTessBaseData, sTessBaseData);
CHECK_RET_CALL_A3D_FCTION(A3DTessBaseGet,(m_sMarkupData.m_pTessellation, &sTessBaseData));
bool bIsText = m_sMarkupData.m_eType == kA3DMarkupTypeText;
CHECK_RET(A3DMarkupTessConnector::GetMarkupTessellation(sTessBaseData, &sMarkupTessData, bIsText,
asMarkupTessConnector, a_dParallelToScreenPMIScale));
CHECK_RET_CALL_A3D_FCTION(A3DTessBaseGet,(NULL, &sTessBaseData));
CHECK_RET_CALL_A3D_FCTION(A3DTessMarkupGet,(NULL, &sMarkupTessData));
unsigned int uI, uJ;
for (uI = 0; uI < m_sMarkupData.m_uiLeadersSize; uI++)
{
A3DMkpLeader* psLeader = m_sMarkupData.m_ppLeaders[uI];
if (psLeader == NULL)
{
continue;
}
A3DMkpLeaderData sMarkupLeaderData;
A3D_INITIALIZE_DATA(A3DMkpLeaderData, sMarkupLeaderData);
CHECK_RET_CALL_A3D_FCTION(A3DMkpLeaderGet,(psLeader, &sMarkupLeaderData));
A3DTessMarkupData sMarkupLeaderTessData;
A3D_INITIALIZE_DATA(A3DTessMarkupData, sMarkupLeaderTessData);
CHECK_RET_CALL_A3D_FCTION(A3DTessMarkupGet,(sMarkupLeaderData.m_pTessellation, &sMarkupLeaderTessData));
A3DTessBaseData sLeaderTessBaseData;
A3D_INITIALIZE_DATA(A3DTessBaseData, sLeaderTessBaseData);
CHECK_RET_CALL_A3D_FCTION(A3DTessBaseGet,(sMarkupLeaderData.m_pTessellation, &sLeaderTessBaseData));
std::vector<A3DMarkupTessConnector*> asMarkupLeaderConnector;
CHECK_RET(A3DMarkupTessConnector::GetMarkupTessellation(sLeaderTessBaseData, &sMarkupLeaderTessData, bIsText,
asMarkupLeaderConnector, a_dParallelToScreenPMIScale));
for (uJ = 0; uJ < asMarkupLeaderConnector.size(); uJ++)
asMarkupTessConnector.push_back(asMarkupLeaderConnector[uJ]);
CHECK_RET_CALL_A3D_FCTION(A3DTessBaseGet,(NULL, &sLeaderTessBaseData));
CHECK_RET_CALL_A3D_FCTION(A3DTessMarkupGet,(NULL, &sMarkupLeaderTessData));
CHECK_RET_CALL_A3D_FCTION(A3DMkpLeaderGet,(NULL, &sMarkupLeaderData));
}
return A3D_SUCCESS;
}
A3DStatus A3DMarkupConnector::TraverseMarkupSemantic(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
A3DEEntityType eType = kA3DTypeUnknown;
A3DStatus iRet = CALL_A3D_FCTION(A3DEntityGetType,( this->GetA3DEntity(), &eType));
switch (eType)
{
case kA3DTypeMarkupText:
break;
case kA3DTypeMarkupRichText:
break;
case kA3DTypeMarkupCoordinate:
break;
case kA3DTypeMarkupBalloon:
break;
case kA3DTypeMarkupDatum:
{
A3DMarkupDatumConnector sMkpDatumConnector((A3DMkpMarkup*) this->GetA3DEntity());
iRet = sMkpDatumConnector.TraverseDatum(pVisitor);
}
break;
case kA3DTypeMarkupGDT:
{
A3DMarkupGDTConnector sMkpGDTConnector((A3DMkpMarkup*) this->GetA3DEntity());
iRet = sMkpGDTConnector.TraverseGDT(pVisitor);
}
break;
case kA3DTypeMarkupRoughness:
break;
case kA3DTypeMarkupDimension:
{
A3DMarkupDimensionConnector sMkpDimensionConnector((A3DMkpMarkup*) this->GetA3DEntity());
iRet = sMkpDimensionConnector.TraverseDimension(pVisitor);
}
break;
case kA3DTypeMarkupLocator:
break;
case kA3DTypeMarkupMeasurementPoint:
break;
case kA3DTypeMarkupFastener:
break;
case kA3DTypeMarkupSpotWelding:
break;
case kA3DTypeMarkupLineWelding:
break;
default:
break;
}
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DStatus A3DMarkupDimensionConnector::TraverseDimension(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DStatus A3DMarkupGDTConnector::TraverseGDT(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DStatus A3DMarkupDatumConnector::TraverseDatum(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}

1234
exchange/exchangesource/Viewer/traverse/TessConnector.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

117
exchange/exchangesource/Viewer/traverse/TransfoConnector.cpp Normal file
View File

@@ -0,0 +1,117 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
#include "../TransfoConnector.h"
#include "../Visitors.h"
#include "../Matrix.h"
static void stInitMatrixFromMiscTransformation(A3DMiscTransformation const * pMiscTransformation, A3DMatrix4x4 &sMatrix)
{
if (pMiscTransformation)
{
A3DStatus iRet = A3D_SUCCESS;
A3DEEntityType eType = kA3DTypeUnknown;
CALL_A3D_FCTION(A3DEntityGetType, (pMiscTransformation, &eType));
switch (eType)
{
case kA3DTypeMiscCartesianTransformation:
{
A3DMiscCartesianTransformationData sData;
A3D_INITIALIZE_DATA(A3DMiscCartesianTransformationData, sData);
iRet = CALL_A3D_FCTION(A3DMiscCartesianTransformationGet, (pMiscTransformation, &sData));
double dMirror = (sData.m_ucBehaviour & kA3DTransformationMirror) ? -1. : 1.;
A3DVector3dData sZVector;
memset(sMatrix.m_adM, 0, 16 * sizeof(double));
sZVector = CrossProduct(&(sData.m_sXVector), &(sData.m_sYVector));
sMatrix.m_adM[12] = sData.m_sOrigin.m_dX;
sMatrix.m_adM[13] = sData.m_sOrigin.m_dY;
sMatrix.m_adM[14] = sData.m_sOrigin.m_dZ;
sMatrix.m_adM[0] = sData.m_sXVector.m_dX*sData.m_sScale.m_dX;
sMatrix.m_adM[1] = sData.m_sXVector.m_dY*sData.m_sScale.m_dX;
sMatrix.m_adM[2] = sData.m_sXVector.m_dZ*sData.m_sScale.m_dX;
sMatrix.m_adM[4] = sData.m_sYVector.m_dX*sData.m_sScale.m_dY;
sMatrix.m_adM[5] = sData.m_sYVector.m_dY*sData.m_sScale.m_dY;
sMatrix.m_adM[6] = sData.m_sYVector.m_dZ*sData.m_sScale.m_dY;
sMatrix.m_adM[8] = dMirror*sZVector.m_dX*sData.m_sScale.m_dZ;
sMatrix.m_adM[9] = dMirror*sZVector.m_dY*sData.m_sScale.m_dZ;
sMatrix.m_adM[10] = dMirror*sZVector.m_dZ*sData.m_sScale.m_dZ;
sMatrix.m_adM[15] = 1.;
iRet = CALL_A3D_FCTION(A3DMiscCartesianTransformationGet, (NULL, &sData));
}
break;
case kA3DTypeMiscGeneralTransformation:
{
A3DMiscGeneralTransformationData sData;
A3D_INITIALIZE_DATA(A3DMiscGeneralTransformationData, sData);
iRet = CALL_A3D_FCTION(A3DMiscGeneralTransformationGet, (pMiscTransformation, &sData));
memcpy(&(sMatrix.m_adM[0]), sData.m_adCoeff, 16 * sizeof(double));
iRet = CALL_A3D_FCTION(A3DMiscGeneralTransformationGet, (NULL, &sData));
}
break;
default:
break;
}
}
}
A3DTransfoConnector::A3DTransfoConnector(const A3DMiscTransformation* pMiscTransformation)
: A3DConnector(pMiscTransformation)
{
if (pMiscTransformation)
{
stInitMatrixFromMiscTransformation(pMiscTransformation, m_sLocalMatrix);
}
else
m_sLocalMatrix = stIdentity;
}
void A3DTransfoConnector::ComputeGlobalMatrix(A3DMatrix4x4 const& rFatherWorldMatrix)
{
m_sWorldMatrix = rFatherWorldMatrix * m_sLocalMatrix;
}
void A3DTransfoConnector::SetGlobalMatrix(A3DMatrix4x4 const& rWorldMatrix)
{
m_sWorldMatrix = rWorldMatrix;
}
void A3DTransfoConnector::SetGlobalMatrix(A3DMiscTransformation const * pMiscTransformation)
{
stInitMatrixFromMiscTransformation(pMiscTransformation, m_sWorldMatrix);
}
A3DStatus A3DTransfoConnector::GetLocalMatrix(A3DMatrix4x4& rsMatrix)
{
rsMatrix = m_sLocalMatrix;
return A3D_SUCCESS;
}
A3DStatus A3DTransfoConnector::GetGlobalTransfo(A3DMatrix4x4& rsMatrix)
{
rsMatrix = m_sWorldMatrix;
return A3D_SUCCESS;
}

507
exchange/exchangesource/Viewer/traverse/TreeTraverse.cpp Normal file
View File

@@ -0,0 +1,507 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
\file TreeConnector.cpp
This file contains fuctionalities to traverse a Prc Model Tree
***********************************************************************************************************************/
#include "../TreeTraverse.h"
#include "../VisitorContainer.h"
#include "../callback_opengl.h"
/************************************************************************************
Traverse Model File
*************************************************************************************/
// Traverse all the model tree
A3DStatus A3DModelFileConnector::Traverse(A3DVisitorContainer* psVisitor, bool bVisitPrototype)
{
unsigned int uI;
psVisitor->visitEnter(*this);
for (uI = 0; uI < m_sModelFileData.m_uiPOccurrencesSize; uI++)
{
psVisitor->SetCurrentPoFather(NULL);
A3DProductOccurrenceConnector sTreeConnector(m_sModelFileData.m_ppPOccurrences[uI]);
if (sTreeConnector.TraversePO(m_sModelFileData.m_ppPOccurrences[uI], psVisitor, bVisitPrototype) != A3D_SUCCESS)
return A3D_ERROR;
}
psVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
// Traversing the assembly Structure
A3DStatus A3DProductOccurrenceConnector::TraversePO(const A3DAsmProductOccurrence* pOccurrence,
A3DVisitorContainer* psVisitor,
bool bVisitPrototype)
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
//Traverse AnnotationEntity
A3DUns32 uI;
#ifdef CONNECT_PMI
A3DUns32 uNbAnnotationEntity = m_sProductOccurrenceData.m_uiAnnotationsSize;
for (uI = 0; uI < uNbAnnotationEntity; uI++)
{
A3DMkpAnnotationEntityConnector sAnnotationEntityConnector(m_sProductOccurrenceData.m_ppAnnotations[uI]);
sAnnotationEntityConnector.TraverseAnnotationEntity(psVisitor);
}
if (!uNbAnnotationEntity && m_sProductOccurrenceData.m_pPrototype != NULL)
{
A3DAsmProductOccurrence* pProductPrototype = m_sProductOccurrenceData.m_pPrototype;
while (pProductPrototype)
{
A3DAsmProductOccurrenceData sProductPrototypeData;
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, sProductPrototypeData);
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(pProductPrototype, &sProductPrototypeData));
uNbAnnotationEntity = sProductPrototypeData.m_uiAnnotationsSize;
for (uI = 0; uI < uNbAnnotationEntity; uI++)
{
A3DMkpAnnotationEntityConnector sAnnotationEntityConnector(sProductPrototypeData.m_ppAnnotations[uI]);
sAnnotationEntityConnector.TraverseAnnotationEntity(psVisitor);
}
pProductPrototype = sProductPrototypeData.m_pPrototype;
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(NULL, &sProductPrototypeData));
}
}
#endif
#ifdef CONNECT_VIEWS
A3DUns32 uNbView = m_sProductOccurrenceData.m_uiViewsSize;
if (!uNbView && m_sProductOccurrenceData.m_pPrototype != NULL)
{
A3DAsmProductOccurrence* pProductPrototype = m_sProductOccurrenceData.m_pPrototype;
while (pProductPrototype)
{
A3DAsmProductOccurrenceData sProductPrototypeData;
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, sProductPrototypeData);
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(pProductPrototype, &sProductPrototypeData));
uNbView = sProductPrototypeData.m_uiViewsSize;
for (uI = 0; uI < uNbView; uI++)
{
A3DMkpViewConnector sMkpViewConnector(sProductPrototypeData.m_ppViews[uI]);
sMkpViewConnector.TraverseView(psVisitor);
}
pProductPrototype = sProductPrototypeData.m_pPrototype;
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(NULL, &sProductPrototypeData));
}
}
else if (uNbView)
{
for (uI = 0; uI < uNbView; uI++)
{
A3DMkpViewConnector sMkpViewConnector(m_sProductOccurrenceData.m_ppViews[uI]);
sMkpViewConnector.TraverseView(psVisitor);
}
}
#endif
A3DAsmPartDefinition* pPart = NULL;
if (!bVisitPrototype)
{
CHECK_RET(GetPart(pPart));
}
else
{
pPart = m_sProductOccurrenceData.m_pPart;
}
if (pPart)
{
void * pEntityInMap = psVisitor->FindInMap(pPart);
psVisitor->SetInMap(pPart, pPart);
A3DPartConnector sPartConnector(pPart);
psVisitor->SetCurrentPoFather(pOccurrence);
sPartConnector.SetProductOccurenceFather(pOccurrence);
// if we haven't found the part in the map or if we traverse the instance
if (pEntityInMap == NULL || psVisitor->TraverseInstances())
{
CHECK_RET(sPartConnector.TraversePart(psVisitor));
}
psVisitor->SetCurrentPoFather(NULL);
}
std::vector<A3DAsmProductOccurrence*> apSons;
if (!bVisitPrototype)
{
CollectSons(apSons);
}
else
{
if (m_sProductOccurrenceData.m_pPrototype)
{
if (psVisitor->FindInMap(m_sProductOccurrenceData.m_pPrototype) == NULL)
{
psVisitor->SetInMap(m_sProductOccurrenceData.m_pPrototype, m_sProductOccurrenceData.m_pPrototype);
A3DProductOccurrenceConnector sPrototypeConnector(m_sProductOccurrenceData.m_pPrototype);
sPrototypeConnector.SetPrototypeType(true);
sPrototypeConnector.TraversePO(m_sProductOccurrenceData.m_pPrototype, psVisitor, bVisitPrototype);
}
}
if (m_sProductOccurrenceData.m_pExternalData)
{
if (psVisitor->FindInMap(m_sProductOccurrenceData.m_pExternalData) == NULL)
{
psVisitor->SetInMap(m_sProductOccurrenceData.m_pExternalData, m_sProductOccurrenceData.m_pExternalData);
A3DProductOccurrenceConnector sExternalConnector(m_sProductOccurrenceData.m_pExternalData);
sExternalConnector.SetExternalType(true);
sExternalConnector.TraversePO(m_sProductOccurrenceData.m_pExternalData, psVisitor, bVisitPrototype);
}
}
unsigned int uSize = m_sProductOccurrenceData.m_uiPOccurrencesSize;
for (uI = 0; uI < uSize; uI++)
{
apSons.push_back(m_sProductOccurrenceData.m_ppPOccurrences[uI]);
}
}
for (uI = 0; uI < apSons.size(); uI++)
{
A3DProductOccurrenceConnector sPoConnector(apSons[uI]);
sPoConnector.SetProductOccurrenceFather(this->GetA3DEntity());
psVisitor->SetCurrentPoFather(pOccurrence);
CHECK_RET(sPoConnector.TraversePO(apSons[uI], psVisitor, bVisitPrototype));
psVisitor->SetCurrentPoFather(NULL);
}
CHECK_RET(psVisitor->visitLeave(*this));
return A3D_SUCCESS;
}
A3DStatus A3DProductOccurrenceConnector::CollectSons(
std::vector<A3DAsmProductOccurrence*>& apSons) const
{
//Get Children or children on Prototype's ....Prototype's
A3DAsmProductOccurrence* pPrototype = m_sProductOccurrenceData.m_pPrototype;
A3DAsmProductOccurrence** ppPo = m_sProductOccurrenceData.m_ppPOccurrences;
unsigned int uSize = m_sProductOccurrenceData.m_uiPOccurrencesSize;
A3DStatus iRet = A3D_SUCCESS;
while (uSize == 0 && pPrototype)
{
A3DAsmProductOccurrenceData sPrototypeData;
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, sPrototypeData);
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(pPrototype, &sPrototypeData));
pPrototype = sPrototypeData.m_pPrototype;
uSize = sPrototypeData.m_uiPOccurrencesSize;
ppPo = sPrototypeData.m_ppPOccurrences;
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(NULL, &sPrototypeData));
}
unsigned uI;
for (uI = 0; uI < uSize; uI++)
apSons.push_back(ppPo[uI]);
//Get Children on Externals
if (m_sProductOccurrenceData.m_pExternalData)
{
if (apSons.size() == 0)
{
A3DProductOccurrenceConnector sExternalConnector(m_sProductOccurrenceData.m_pExternalData);
CHECK_RET(sExternalConnector.CollectSons(apSons));
}
else
apSons.push_back(m_sProductOccurrenceData.m_pExternalData);
}
return A3D_SUCCESS;
}
A3DStatus A3DProductOccurrenceConnector::GetPart(
A3DAsmPartDefinition*& pPart) const
{
pPart = NULL;
A3DStatus iRet = A3D_SUCCESS;;
if(m_sProductOccurrenceData.m_pPart)
{
pPart = m_sProductOccurrenceData.m_pPart;
return A3D_SUCCESS;
}
// Search for first Part found, recursively
A3DAsmProductOccurrence* pProductPrototype = m_sProductOccurrenceData.m_pPrototype;
while(pProductPrototype)
{
A3DAsmProductOccurrenceData sProductPrototypeData;
A3D_INITIALIZE_DATA( A3DAsmProductOccurrenceData, sProductPrototypeData);
CHECK_RET(A3DAsmProductOccurrenceGet(pProductPrototype, &sProductPrototypeData));
if(sProductPrototypeData.m_pPart)
{
// take current part and return it
pPart = sProductPrototypeData.m_pPart;
CHECK_RET(A3DAsmProductOccurrenceGet(NULL, &sProductPrototypeData));
return A3D_SUCCESS;
}
else if (sProductPrototypeData.m_pPrototype)
{
// recurse in prototype if exist
pProductPrototype = sProductPrototypeData.m_pPrototype;
}
else if (sProductPrototypeData.m_pExternalData)
{
// recurse in external if exist
pProductPrototype = sProductPrototypeData.m_pExternalData;
}
else
{
// end recursion
pProductPrototype = NULL;
}
CHECK_RET(A3DAsmProductOccurrenceGet(NULL, &sProductPrototypeData));
}
if(m_sProductOccurrenceData.m_uiPOccurrencesSize == 0)
{
if(m_sProductOccurrenceData.m_pExternalData)
{
A3DProductOccurrenceConnector sExternalconnector(m_sProductOccurrenceData.m_pExternalData);
CHECK_RET(sExternalconnector.GetPart(pPart));
}
}
return A3D_SUCCESS;
}
A3DStatus A3DPartConnector::TraversePart(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
//Traverse AnnotationEntity
A3DUns32 uI;
#ifdef CONNECT_PMI
A3DUns32 uNbAnnotationEntity = m_sPartData.m_uiAnnotationsSize;
for (uI = 0; uI < uNbAnnotationEntity; uI++)
{
A3DMkpAnnotationEntityConnector sAnnotationEntityConnector(m_sPartData.m_ppAnnotations[uI]);
sAnnotationEntityConnector.TraverseAnnotationEntity(psVisitor);
}
#endif
#ifdef CONNECT_VIEWS
A3DUns32 uNbView = m_sPartData.m_uiViewsSize;
for (uI = 0; uI < uNbView; uI++)
{
A3DMkpViewConnector sMkpViewConnector(m_sPartData.m_ppViews[uI]);
sMkpViewConnector.TraverseView(psVisitor);
}
#endif
//Traverse RI
for (uI = 0; uI < m_sPartData.m_uiRepItemsSize; uI++)
{
A3DRiConnector sRiConnector(m_sPartData.m_ppRepItems[uI]);
sRiConnector.TraverseRi(psVisitor);
}
CHECK_RET(psVisitor->visitLeave(*this));
return A3D_SUCCESS;
}
A3DStatus A3DRiConnector::TraverseRi(A3DVisitorContainer* psVisitor)
{
A3DStatus iRet = A3D_SUCCESS;
psVisitor->visitEnter(*this);
const A3DEntity* pRi = GetA3DEntity();
A3DEEntityType eType = kA3DTypeUnknown;
CALL_A3D_FCTION(A3DEntityGetType,(pRi,&eType));
if (iRet == A3D_SUCCESS)
{
switch (eType)
{
case kA3DTypeRiBrepModel:
{
A3DRiBrepModelConnector sConnector((A3DRiBrepModel*)pRi);
CHECK_RET(sConnector.TraverseRiBrepModel(psVisitor));
break;
}
case kA3DTypeRiSet:
{
A3DRiSetConnector sConnector((A3DRiSet*)pRi);
CHECK_RET(sConnector.TraverseRiSet(psVisitor));
break;
}
case kA3DTypeRiCurve:
{
A3DRiCurveConnector sConnector((A3DRiCurve*)pRi);
CHECK_RET(sConnector.TraverseRiCurve(psVisitor));
break;
}
case kA3DTypeRiPointSet:
case kA3DTypeRiDirection:
case kA3DTypeRiCoordinateSystem:
case kA3DTypeRiPlane:
break;
case kA3DTypeRiPolyBrepModel:
{
A3DPolyRiBrepModelConnector sConnector((A3DRiPolyBrepModel*)pRi);
CHECK_RET(sConnector.TraverseRiPolyBrepModel(psVisitor));
break;
}
case kA3DTypeRiPolyWire:
{
A3DRiPolyWireConnector sConnector((A3DRiPolyWire*)pRi);
CHECK_RET(sConnector.TraverseRiPolyWire(psVisitor));
break;
}
default:
iRet = A3D_NOT_IMPLEMENTED;
break;
}
}
psVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
// RiBrepModel
A3DStatus A3DRiBrepModelConnector::TraverseRiBrepModel(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
//Traverse Mesh
#ifdef CONNECT_MESH
A3DRiRepresentationItemData sRidata;
A3D_INITIALIZE_DATA(A3DRiRepresentationItemData, sRidata);
CHECK_RET_CALL_A3D_FCTION(A3DRiRepresentationItemGet,(this->GetA3DEntity(), &sRidata));
A3DTessDataConnector sTessConnector((A3DTess3D*)sRidata.m_pTessBase);
if (!sRidata.m_pTessBase)
{
CHECK_RET(A3DRiRepresentationItemGet(NULL, &sRidata));
A3DRWParamsTessellationData sTessParams;
A3D_INITIALIZE_DATA(A3DRWParamsTessellationData, sTessParams);
sTessParams.m_eTessellationLevelOfDetail = kA3DTessLODMedium;
A3DRiRepresentationItemComputeTessellation((A3DRiRepresentationItem*)this->GetA3DEntity(), &sTessParams);
CHECK_RET(A3DRiRepresentationItemGet(this->GetA3DEntity(), &sRidata));
}
CHECK_RET(sTessConnector.Traverse(psVisitor));
CHECK_RET_CALL_A3D_FCTION(A3DRiRepresentationItemGet,(NULL, &sRidata));
#endif
//Traverse Brep Data
#ifdef CONNECT_BREP
A3DBrepDataConnector sTopoConnector(m_sRiBrepModelData.m_pBrepData);
CHECK_RET(sTopoConnector.Traverse(psVisitor));
#endif
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}
// RiSet
A3DStatus A3DRiSetConnector::TraverseRiSet(A3DVisitorContainer* psVisitor)
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
unsigned uI;
for (uI = 0; uI < m_sRiSetData.m_uiRepItemsSize; uI++)
{
A3DRiConnector sRiConnector(m_sRiSetData.m_ppRepItems[uI]);
sRiConnector.TraverseRi(psVisitor);
}
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}
// RiPolyBrepModel
A3DStatus A3DPolyRiBrepModelConnector::TraverseRiPolyBrepModel(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
A3DRiRepresentationItemData sRiData;
A3D_INITIALIZE_DATA(A3DRiRepresentationItemData, sRiData);
CHECK_RET_CALL_A3D_FCTION(A3DRiRepresentationItemGet,(this->GetA3DEntity(), &sRiData));
A3DTessDataConnector sTessConnector((A3DTess3D*)sRiData.m_pTessBase);
CHECK_RET(sTessConnector.Traverse(psVisitor));
CHECK_RET_CALL_A3D_FCTION(A3DRiRepresentationItemGet,(NULL, &sRiData));
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}
///////////////////////////////////////////////////////////////////////////////////////
// RiCurve
///////////////////////////////////////////////////////////////////////////////////////
A3DStatus A3DRiCurveConnector::TraverseRiCurve(A3DVisitorContainer* psVisitor)
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
#ifdef CONNECT_MESH
A3DRiRepresentationItemData sRidata;
A3D_INITIALIZE_DATA(A3DRiRepresentationItemData, sRidata);
CHECK_RET(A3DRiRepresentationItemGet(this->GetA3DEntity(), &sRidata));
if (!sRidata.m_pTessBase)
{
CHECK_RET(A3DRiRepresentationItemGet(NULL, &sRidata));
A3DRWParamsTessellationData sTessParams;
A3D_INITIALIZE_DATA(A3DRWParamsTessellationData, sTessParams);
sTessParams.m_eTessellationLevelOfDetail = kA3DTessLODMedium;
A3DRiRepresentationItemComputeTessellation((A3DRiRepresentationItem*)this->GetA3DEntity(), &sTessParams);
CHECK_RET(A3DRiRepresentationItemGet(this->GetA3DEntity(), &sRidata));
}
A3DWireTessDataConnector sWireTessConnector((A3DTess3DWire*)sRidata.m_pTessBase);
CHECK_RET(sWireTessConnector.Traverse(psVisitor));
CHECK_RET(A3DRiRepresentationItemGet(NULL, &sRidata));
#endif
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}
///////////////////////////////////////////////////////////////////////////////////////
// RiPolyWire
///////////////////////////////////////////////////////////////////////////////////////
A3DStatus A3DRiPolyWireConnector::TraverseRiPolyWire(A3DVisitorContainer* psVisitor)
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
#ifdef CONNECT_MESH
A3DRiRepresentationItemData sRidata;
A3D_INITIALIZE_DATA(A3DRiRepresentationItemData, sRidata);
CHECK_RET(A3DRiRepresentationItemGet(this->GetA3DEntity(), &sRidata));
A3DWireTessDataConnector sWireTessConnector((A3DTess3DWire*)sRidata.m_pTessBase);
CHECK_RET(sWireTessConnector.Traverse(psVisitor));
CHECK_RET(A3DRiRepresentationItemGet(NULL, &sRidata));
#endif
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}

38
exchange/exchangesource/Viewer/traverse/ViewTraverse.cpp Normal file
View File

@@ -0,0 +1,38 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
\file ViewTraverse.cpp
This file contains functionalities to traverse a PRC View
***********************************************************************************************************************/
#include "../VisitorContainer.h"
#include "../ViewTraverse.h"
class A3DVisitorContainer;
A3DStatus A3DMkpViewConnector::TraverseView(A3DVisitorContainer* pVisitor)
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(pVisitor->visitEnter(*this));
A3DUns32 uiI;
for (uiI = 0; uiI<m_sViewData.m_uiAnnotationsSize; uiI++)
{
A3DMkpAnnotationEntityConnector sAnnotationEntityConnector(m_sViewData.m_ppAnnotations[uiI]);
CHECK_RET(sAnnotationEntityConnector.TraverseAnnotationEntity(pVisitor));
}
CHECK_RET(pVisitor->visitLeave(*this));
return A3D_SUCCESS;
}

289
exchange/exchangesource/Viewer/traverse/VisitorCascadedAttribute.cpp Normal file
View File

@@ -0,0 +1,289 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
#include "../VisitorCascadedAttribute.h"
#include "../CascadedAttributeConnector.h"
#include "../VisitorTree.h"
#include "../VisitorContainer.h"
#include "../TransfoConnector.h"
#include "../callback_opengl.h"
A3DVisitorColorMaterials::A3DVisitorColorMaterials(A3DVisitorContainer* psContainer)
: A3DVisitor("CascadedAttribute", psContainer),
m_pCurrentRi(NULL)
{
}
A3DVisitorColorMaterials::~A3DVisitorColorMaterials()
{
std::vector<A3DMiscCascadedAttributes*>::iterator itCur = m_apsCascadedAttribute.begin();
std::vector<A3DMiscCascadedAttributes*>::iterator itEnd = m_apsCascadedAttribute.end();
for(; itCur < itEnd; ++itCur)
{
CALL_A3D_FCTION(A3DMiscCascadedAttributesDelete,(*itCur));
}
}
A3DStatus A3DVisitorColorMaterials::pushCascadedAttribute(const A3DConnector& sEntity)
{
unsigned int uSize = (unsigned int)m_apsCascadedAttribute.size();
if(!uSize)
{
A3DMiscCascadedAttributes* pAttr;
CALL_A3D_FCTION(A3DMiscCascadedAttributesCreate,(&pAttr));
m_apsCascadedAttribute.push_back(pAttr);
uSize++;
}
A3DMiscCascadedAttributes* pAttr;
CALL_A3D_FCTION(A3DMiscCascadedAttributesCreate,(&pAttr));
CALL_A3D_FCTION(A3DMiscCascadedAttributesPush,(pAttr, sEntity.GetA3DEntity(), m_apsCascadedAttribute[uSize-1]));
m_apsCascadedAttribute.push_back(pAttr);
return A3D_SUCCESS;
}
A3DStatus A3DVisitorColorMaterials::popCascadedAttribute(/*const A3DConnector& sEntity*/)
{
if(m_apsCascadedAttribute.size() > 0)
{
CALL_A3D_FCTION(A3DMiscCascadedAttributesDelete,(m_apsCascadedAttribute[m_apsCascadedAttribute.size() - 1]));
m_apsCascadedAttribute.pop_back();
}
return A3D_SUCCESS;
}
// Visit Product Occurrence
A3DStatus A3DVisitorColorMaterials::visitEnter(const A3DProductOccurrenceConnector& sEntity)
{
pushCascadedAttribute( (const A3DConnector&) sEntity);
return A3D_SUCCESS;
}
A3DStatus A3DVisitorColorMaterials::visitLeave(const A3DProductOccurrenceConnector& /*sEntity*/)
{
popCascadedAttribute();
return A3D_SUCCESS;
}
// Visit PartDefintion
A3DStatus A3DVisitorColorMaterials::visitEnter(const A3DPartConnector& sEntity)
{
pushCascadedAttribute((const A3DConnector& ) sEntity);
return A3D_SUCCESS;
}
A3DStatus A3DVisitorColorMaterials::visitLeave(const A3DPartConnector& /*sEntity*/)
{
popCascadedAttribute();
return A3D_SUCCESS;
}
// Visit Representation Item
A3DStatus A3DVisitorColorMaterials::visitEnter(const A3DRiConnector& sRi)
{
A3DStatus iRet = A3D_SUCCESS;
m_pCurrentRi = (A3DRiRepresentationItem*)sRi.GetA3DEntity();
CHECK_RET(pushCascadedAttribute((const A3DConnector&) sRi));
CHECK_RET(SetGlobalAttributeOnLeaf(m_apsCascadedAttribute[ m_apsCascadedAttribute.size() - 1]));
return iRet;
}
A3DStatus A3DVisitorColorMaterials::visitLeave(const A3DRiConnector& /*sRi*/)
{
A3DStatus iRet = A3D_SUCCESS;
m_pCurrentRi = NULL;
CHECK_RET(popCascadedAttribute());
return A3D_SUCCESS;
}
// Visit Face Tess Data
A3DStatus A3DVisitorColorMaterials::visitEnter(const A3DFaceTessDataConnector& sFaceTess)
{
A3DStatus iRet = A3D_SUCCESS;
A3DTessFaceData* pFaceTessData = (A3DTessFaceData*)sFaceTess.GetA3DEntity();
if(m_pCurrentRi && !pFaceTessData->m_bIsRGBA && pFaceTessData->m_uiStyleIndexesSize == 1)
{
// Push the Face Tess data
A3DMiscCascadedAttributes* pAttr;
CALL_A3D_FCTION(A3DMiscCascadedAttributesCreate,(&pAttr));
CALL_A3D_FCTION(A3DMiscCascadedAttributesPushTessFace,(pAttr,
m_pCurrentRi,
(A3DTess3D*)sFaceTess.GetTessDataConnector()->GetA3DEntity(),
(A3DTessFaceData*)sFaceTess.GetA3DEntity(),
sFaceTess.GetFaceIndex(),
m_apsCascadedAttribute[m_apsCascadedAttribute.size()-1]));
m_apsCascadedAttribute.push_back(pAttr);
CHECK_RET(SetGlobalAttributeOnLeaf(m_apsCascadedAttribute[ m_apsCascadedAttribute.size() - 1]));
}
//////////////////////////////////////////////////////////////
// Get Colors / Materials - PLEASE, ADD your sources HERE
//////////////////////////////////////////////////////////////
if(GetstbUseCallbacks())
{
A3DVisitorColorMaterials* pVisitorColorAndMaterials = (A3DVisitorColorMaterials *)m_psContainer->GetVisitor()[1];
ColorMaterialsConnector sColorMaterialConnec(pVisitorColorAndMaterials->GetLastCascadedAttributes());
pVisitorColorAndMaterials->GetColorMaterialConnector(sColorMaterialConnec, false);
if (sColorMaterialConnec.IsShow())
{
if(sColorMaterialConnec.IsRGBColor())
{
double adRGB[3];
sColorMaterialConnec.GetRGB(adRGB);
OpenGL_Material(kA3DDrawMaterialDiffuse, adRGB, 3);
}
else
{
double adEmisive[4], adDiffuse[4], adAmbient[4], adSpecular[4], dShininess;
sColorMaterialConnec.GetMaterial(adEmisive, adDiffuse, adAmbient, adSpecular, dShininess );
OpenGL_Material(kA3DDrawMaterialDiffuse, adDiffuse, 4);
OpenGL_Material(kA3DDrawMaterialAmbient, adAmbient, 4);
OpenGL_Material(kA3DDrawMaterialEmission, adEmisive, 4);
OpenGL_Material(kA3DDrawMaterialSpecular, adSpecular, 4);
OpenGL_Material(kA3DDrawMaterialShininess, &dShininess, 1);
}
}
}
///////////////////////////////////////////////////////////////////////////////
return iRet;
}
A3DStatus A3DVisitorColorMaterials::visitLeave(const A3DFaceTessDataConnector& sFaceTess)
{
A3DStatus iRet = A3D_SUCCESS;
A3DTessFaceData* pFaceTessData = (A3DTessFaceData*)sFaceTess.GetA3DEntity();
if(!pFaceTessData->m_bIsRGBA && pFaceTessData->m_uiStyleIndexesSize == 1)
{
CHECK_RET(popCascadedAttribute());
}
return A3D_SUCCESS;
}
A3DMiscCascadedAttributes* A3DVisitorColorMaterials::GetLastCascadedAttributes() const
{
size_t iSize = m_apsCascadedAttribute.size();
if(iSize == 0)
return NULL;
return m_apsCascadedAttribute[iSize-1];
}
A3DStatus A3DVisitorColorMaterials::GetColorMaterialConnector( ColorMaterialsConnector& rsColorConnector,
bool bUseInstances /*= false*/ )
{
A3DStatus iErr = A3D_SUCCESS;
size_t iSize = m_apsCascadedAttribute.size();
if(iSize == 0)
return A3D_ERROR;
A3DMiscCascadedAttributes* pCurrent = m_apsCascadedAttribute[iSize-1];
if(!bUseInstances)
{
A3DMiscEntityReference* pMER = NULL;
A3DStepEntityRefManager const * pSERM = m_psContainer->GetActiveStepEntityRefManager(NULL);
if (pSERM)
{
pMER = pSERM->m_pStepEntityRef;
}
A3DViewLinkedItemManager const* pVLIM = m_psContainer->GetActiveViewLinkedItemManager(NULL);
if (pVLIM)
{
pMER = pVLIM->m_pMarkupLinkedItem;
}
if (pMER)
{
A3DMiscEntityReferenceData sSERData;
A3D_INITIALIZE_DATA(A3DMiscEntityReferenceData, sSERData);
iErr = CALL_A3D_FCTION(A3DMiscEntityReferenceGet,(pMER, &sSERData));
if(iErr == A3D_SUCCESS)
{
A3DEEntityType eType;
CALL_A3D_FCTION(A3DEntityGetType,( pMER, &eType));
if(eType == kA3DTypeMiscEntityReference || eType==kA3DTypeMiscMarkupLinkedItem)
{
A3DMiscReferenceOnTopologyData sTopoRefData;
A3D_INITIALIZE_DATA(A3DMiscReferenceOnTopologyData,sTopoRefData);
iErr = CALL_A3D_FCTION(A3DMiscReferenceOnTopologyGet,(pMER, &sTopoRefData));
if(iErr == A3D_SUCCESS) // topo
{
switch(sTopoRefData.m_eTopoItemType)
{
case kA3DTypeTopoMultipleVertex:
case kA3DTypeTopoUniqueVertex:
case kA3DTypeTopoWireEdge:
case kA3DTypeTopoEdge:
case kA3DTypeTopoLoop:
break;
case kA3DTypeTopoFace:
{
A3DTopoBrepData* pBrepData = sTopoRefData.m_pBrepData;
A3DTopoBrepDataData sTopoBrepDataData;
A3D_INITIALIZE_DATA( A3DTopoBrepDataData,sTopoBrepDataData);
CALL_A3D_FCTION(A3DTopoBrepDataGet,(pBrepData,&sTopoBrepDataData));
CALL_A3D_FCTION(A3DTopoBrepDataGet,(NULL,&sTopoBrepDataData));
break;
}
case kA3DTypeTopoShell:
{
break;
}
case kA3DTypeTopoConnex:
{
break;
}
default:
{
break;
}
}
}
else // no topo -> global PO/Part/RI/RIBrepModel
{
A3DEEntityType eEType;
CALL_A3D_FCTION(A3DEntityGetType,( sSERData.m_pEntity, &eEType));
//A3DGraphStyleData
A3DMiscCascadedAttributes* pAttr = NULL;
CALL_A3D_FCTION(A3DMiscCascadedAttributesCreate,(&pAttr));
iErr = CALL_A3D_FCTION(A3DMiscCascadedAttributesPush,(pAttr, pMER, pCurrent));
A3DMiscCascadedAttributesData sCAData;
A3D_INITIALIZE_DATA(A3DMiscCascadedAttributesData, sCAData);
iErr = CALL_A3D_FCTION(A3DMiscCascadedAttributesGet,(pAttr, &sCAData));
rsColorConnector = ColorMaterialsConnector(pAttr);
}
CALL_A3D_FCTION(A3DMiscReferenceOnTopologyGet,(NULL,
&sTopoRefData));
}
CALL_A3D_FCTION(A3DMiscEntityReferenceGet,( NULL, &sSERData));
}
}
else
rsColorConnector = ColorMaterialsConnector(pCurrent);
}
return A3D_SUCCESS;
}

610
exchange/exchangesource/Viewer/traverse/VisitorContainer.cpp Normal file
View File

@@ -0,0 +1,610 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
#include "../VisitorContainer.h"
#include "../Visitors.h"
#ifdef CONNECT_BREP
#include "../VisitorBrep.h"
#endif
#ifdef CONNECT_TRANSFO
#include "../VisitorTransfo.h"
#endif
#ifdef CONNECT_COLORS
#include "../VisitorCascadedAttribute.h"
#endif
#ifdef CONNECT_ASSEMBLY_TREE
#include "../VisitorTree.h"
#endif
#ifdef CONNECT_MESH
#include "../VisitorTessellation.h"
#endif
#ifdef CONNECT_PMI
#include "../ViewTraverse.h"
#endif
#include <map>
#include <algorithm>
using namespace std;
#define VISITENTER \
{\
ActivateEntityReference(sConnector.GetA3DEntity()); \
for(unsigned uI = 0; uI < m_apVisitor.size(); uI++)\
m_apVisitor[uI]->visitEnter(sConnector);\
return A3D_SUCCESS;\
}
#define VISITLEAVE \
{\
DeactivateEntityReference(sConnector.GetA3DEntity()); \
for(unsigned uI = 0; uI < m_apVisitor.size(); uI++)\
m_apVisitor[uI]->visitLeave(sConnector);\
return A3D_SUCCESS;\
}
//Tree
#ifdef CONNECT_ASSEMBLY_TREE
static A3DStatus stCreateAndPushCascadedAttributes( const A3DRootBaseWithGraphics* pBase,
const A3DMiscCascadedAttributes* pFatherAttr,
A3DMiscCascadedAttributes** ppAttr,
A3DMiscCascadedAttributesData* psAttrData)
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(A3DMiscCascadedAttributesCreate(ppAttr));
CHECK_RET(A3DMiscCascadedAttributesPush(*ppAttr, pBase, pFatherAttr));
A3D_INITIALIZE_DATA(A3DMiscCascadedAttributesData, (*psAttrData));
CHECK_RET(A3DMiscCascadedAttributesGet(*ppAttr, psAttrData));
return iRet;
}
A3DStatus A3DVisitorContainer::visitEnter(const A3DModelFileConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DProductOccurrenceConnector& sConnector)
{
m_uiCurrentLevel++;
// Entity Reference
unsigned int uI, uNbRefEntity = sConnector.m_sProductOccurrenceData.m_uiEntityReferenceSize;
for(uI = 0; uI < uNbRefEntity; uI++)
{
A3DMiscEntityReferenceData sMiscRefData;
A3D_INITIALIZE_DATA(A3DMiscEntityReferenceData, sMiscRefData);
A3DMiscEntityReference* pEntityRef = sConnector.m_sProductOccurrenceData.m_ppEntityReferences[uI];
A3DMiscEntityReferenceGet(pEntityRef, &sMiscRefData);
A3DStepEntityRefManager sEntityManager;
sEntityManager.m_pStepEntityRef = pEntityRef;
sEntityManager.m_uiPOLevel = m_uiCurrentLevel;
A3DEEntityType sType;
A3DEntityGetType(sMiscRefData.m_pEntity, &sType);
if(sType == kA3DTypeMiscReferenceOnTopology)
{
A3DMiscReferenceOnTopologyData sTopoRefData;
A3D_INITIALIZE_DATA(A3DMiscReferenceOnTopologyData,sTopoRefData);
A3DMiscReferenceOnTopologyGet(pEntityRef, &sTopoRefData);
sEntityManager.m_pA3DEntityRef = sTopoRefData.m_pBrepData;
sEntityManager.m_bRefOnTopoItem = true;
A3DMiscReferenceOnTopologyGet(NULL, &sTopoRefData);
}
else if(sType == kA3DTypeMiscReferenceOnCsysItem)
{
A3DMiscReferenceOnCsysItemData sA3DMiscReferenceOnCSYSITemData;
A3D_INITIALIZE_DATA(A3DMiscReferenceOnCsysItemData, sA3DMiscReferenceOnCSYSITemData);
A3DMiscReferenceOnCsysItemGet(pEntityRef, &sA3DMiscReferenceOnCSYSITemData);
sEntityManager.m_pA3DEntityRef = sA3DMiscReferenceOnCSYSITemData.m_pCoordinateSystem;
A3DMiscReferenceOnCsysItemGet(NULL, &sA3DMiscReferenceOnCSYSITemData);
}
else
sEntityManager.m_pA3DEntityRef = sMiscRefData.m_pEntity;
A3DMiscEntityReferenceGet(NULL, &sMiscRefData);
m_asStepEntityRefManager.push_back(sEntityManager);
}
A3DStatus iRet = A3D_SUCCESS;
// Active View ...
if (m_psActivatedView)
{
A3DUns32 uNbView = sConnector.m_sProductOccurrenceData.m_uiViewsSize;
for (uI = 0; uI < uNbView; uI++)
{
if (sConnector.m_sProductOccurrenceData.m_ppViews[uI] != m_psActivatedView)
continue;
A3DMkpViewConnector sMkpViewConnector(sConnector.m_sProductOccurrenceData.m_ppViews[uI]);
sMkpViewConnector.TraverseView(this);
}
}
ActivateEntityReference(sConnector.GetA3DEntity());
for( uI = 0; uI < m_apVisitor.size(); uI++)
{
m_apVisitor[uI]->visitEnter(sConnector);
}
return iRet;
}
A3DStatus A3DVisitorContainer::visitEnter(const A3DPartConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DRiConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DRiBrepModelConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DRiSetConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DPolyRiBrepModelConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DModelFileConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DProductOccurrenceConnector& sConnector)
{
for(unsigned uI = 0; uI < m_apVisitor.size(); uI++)
{
m_apVisitor[uI]->visitLeave(sConnector);
}
unsigned int uI, uNbRefEntity = sConnector.m_sProductOccurrenceData.m_uiEntityReferenceSize;
for (uI = 0; uI < uNbRefEntity; uI++)
{
m_asStepEntityRefManager.pop_back();
}
if (m_psActivatedView != NULL)
{
A3DUns32 uNbView = sConnector.m_sProductOccurrenceData.m_uiViewsSize;
for (uI = 0; uI < uNbView; uI++)
{
if (sConnector.m_sProductOccurrenceData.m_ppViews[uI]!=m_psActivatedView)
continue;
A3DMkpViewConnector sViewConnector(m_psActivatedView);
unsigned int uJ;
uNbRefEntity = sViewConnector.GetViewData().m_uiLinkedItemsSize;
for (uJ = 0; uJ < uNbRefEntity; uJ++)
{
m_asViewLinkedItemManager.pop_back();
}
}
}
DeactivateEntityReference(sConnector.GetA3DEntity());
m_uiCurrentLevel--;
return A3D_SUCCESS;
}
A3DStatus A3DVisitorContainer::visitLeave(const A3DPartConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DRiConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DRiBrepModelConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DRiSetConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DPolyRiBrepModelConnector& sConnector)
VISITLEAVE
#endif
//Markup
#ifdef CONNECT_PMI
A3DStatus A3DVisitorContainer::visitEnter(const A3DMkpAnnotationEntityConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DMkpAnnotationSetConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DMkpAnnotationItemConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DMarkupConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DMarkupDimensionConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DMarkupGDTConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DMarkupDatumConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DMarkupTessConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DMkpAnnotationEntityConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DMkpAnnotationSetConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DMkpAnnotationItemConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DMarkupDimensionConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DMarkupConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DMarkupGDTConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DMarkupDatumConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DMarkupTessConnector& sConnector)
VISITLEAVE
#endif
//Brep
#ifdef CONNECT_BREP
A3DStatus A3DVisitorContainer::visitEnter(const A3DBrepDataConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DConnexConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DShellConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DFaceConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DLoopConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DCoEdgeConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DEdgeConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DUniqueVertexConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitEnter(const A3DMultipleVertexConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DBrepDataConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DConnexConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DShellConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DFaceConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DLoopConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DCoEdgeConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DEdgeConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DUniqueVertexConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitLeave(const A3DMultipleVertexConnector& sConnector)
VISITLEAVE
#endif
//Mesh
#ifdef CONNECT_MESH
A3DStatus A3DVisitorContainer::visitEnter(const A3DTessDataConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DTessDataConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitEnter(const A3DFaceTessDataConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DFaceTessDataConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitEnter(const A3DWireTessDataConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DWireTessDataConnector& sConnector)
VISITLEAVE
//VISIT(const A3DTessDataConnector&)
#endif
A3DVisitorContainer::A3DVisitorContainer(unsigned int uFlagElementToconnect)
: A3DVisitor("Container"),
m_pTreeVisitor(NULL),
m_pCurrentPOFather(NULL),
m_psActivatedView(NULL),
m_bTraverseActivatedViewOnly(true),
m_uiCurrentLevel(0)
{
#ifdef CONNECT_TRANSFO
if(uFlagElementToconnect&CONNECT_TRANSFO)
{
A3DVisitorTransfo* psVisistorTransfo = new A3DVisitorTransfo(this);
this->push( psVisistorTransfo);
}
#endif
#ifdef CONNECT_COLORS
if(uFlagElementToconnect&CONNECT_COLORS)
{
A3DVisitorColorMaterials* psVisitorcascadedAttribute = new A3DVisitorColorMaterials(this);
this->push( psVisitorcascadedAttribute);
}
#endif
#ifdef CONNECT_MESH
if(uFlagElementToconnect&CONNECT_MESH)
{
A3DVisitorTessellation* psVisitorTessellation = new A3DVisitorTessellation(this);
this->push( psVisitorTessellation);
}
#endif
#ifdef CONNECT_BREP
if(uFlagElementToconnect&CONNECT_BREP)
{
A3DVisitorBrep* psVisitorBrep = new A3DVisitorBrep(this);
this->push( psVisitorBrep);
}
#endif
#ifdef CONNECT_ASSEMBLY_TREE
if(uFlagElementToconnect&CONNECT_ASSEMBLY_TREE)
{
A3DTreeVisitor* psVisitorTree= new A3DTreeVisitor(this);
this->push( psVisitorTree);
}
#endif
#ifdef CONNECT_PMI
if(uFlagElementToconnect&CONNECT_PMI)
{
//A3DVisitorPMI* psVisitorPMI = new A3DVisitorPMI(this);
//this->push( psVisitorPMI );
}
#endif
#ifdef CONNECT_VIEWS
if(uFlagElementToconnect&CONNECT_VIEWS)
{
// Not yet Implemented
// A3DVisitorview* psVisitorViews = new A3DVisitorview(this);
// this->push( psVisitorViews);
}
m_bTraverseInstance = true;
#endif
}
#ifdef CONNECT_VIEWS
A3DStatus A3DVisitorContainer::visitEnter(const A3DMkpViewConnector& sConnector)
{
if ((m_psActivatedView == NULL) || (m_psActivatedView != sConnector.GetA3DEntity()))
{
if (!m_bTraverseActivatedViewOnly)
{
VISITENTER;
}
return A3D_SUCCESS;
}
// VISITENTER
ActivateEntityReference(sConnector.GetA3DEntity());
for (unsigned uI = 0; uI < m_apVisitor.size(); uI++)
{
m_apVisitor[uI]->visitEnter(sConnector);
}
unsigned int uI, uNbRefEntity = sConnector.GetViewData().m_uiLinkedItemsSize;
for (uI = 0; uI < uNbRefEntity; uI++)
{
A3DMiscMarkupLinkedItemData sMkpLinkedItemData;
A3D_INITIALIZE_DATA(A3DMiscMarkupLinkedItemData, sMkpLinkedItemData);
A3DMiscMarkupLinkedItem* pMkpLinkedItemEntityRef = sConnector.GetViewData().m_ppLinkedItems[uI];
A3DMiscMarkupLinkedItemGet(pMkpLinkedItemEntityRef, &sMkpLinkedItemData);
A3DViewLinkedItemManager sViewLinkedItemManager;
A3DMiscEntityReferenceData sMiscRefData;
A3D_INITIALIZE_DATA(A3DMiscEntityReferenceData, sMiscRefData);
A3DMiscEntityReferenceGet(pMkpLinkedItemEntityRef, &sMiscRefData);
sViewLinkedItemManager.m_pA3DEntityRef = sMiscRefData.m_pEntity;
sViewLinkedItemManager.m_POOwner = sMkpLinkedItemData.m_pTargetProductOccurrence;
sViewLinkedItemManager.m_pMarkupLinkedItem = pMkpLinkedItemEntityRef;
sViewLinkedItemManager.m_uiPOLevel = m_uiCurrentLevel;
A3DEEntityType sType;
A3DEntityGetType(sMiscRefData.m_pEntity, &sType);
if (sType == kA3DTypeMiscReferenceOnTopology)
{
A3DMiscReferenceOnTopologyData sTopoRefData;
A3D_INITIALIZE_DATA(A3DMiscReferenceOnTopologyData, sTopoRefData);
A3DMiscReferenceOnTopologyGet(sMiscRefData.m_pEntity, &sTopoRefData);
sViewLinkedItemManager.m_pA3DEntityRef = sTopoRefData.m_pBrepData;
sViewLinkedItemManager.m_bRefOnTopoItem = true;
A3DMiscReferenceOnTopologyGet(NULL, &sTopoRefData);
}
else if (sType == kA3DTypeMiscReferenceOnCsysItem)
{
A3DMiscReferenceOnCsysItemData sA3DMiscReferenceOnCSYSITemData;
A3D_INITIALIZE_DATA(A3DMiscReferenceOnCsysItemData, sA3DMiscReferenceOnCSYSITemData);
A3DMiscReferenceOnCsysItemGet(sMiscRefData.m_pEntity, &sA3DMiscReferenceOnCSYSITemData);
sViewLinkedItemManager.m_pA3DEntityRef = sA3DMiscReferenceOnCSYSITemData.m_pCoordinateSystem;
A3DMiscReferenceOnCsysItemGet(NULL, &sA3DMiscReferenceOnCSYSITemData);
}
else
sViewLinkedItemManager.m_pA3DEntityRef = sMiscRefData.m_pEntity;
A3DMiscEntityReferenceGet(NULL, &sMiscRefData);
m_asViewLinkedItemManager.push_back(sViewLinkedItemManager);
}
return A3D_SUCCESS;
}
A3DStatus A3DVisitorContainer::visitLeave(const A3DMkpViewConnector& sConnector)
{
if ((m_psActivatedView == NULL) || (m_psActivatedView != sConnector.GetA3DEntity()))
{
if (!m_bTraverseActivatedViewOnly)
VISITLEAVE;
return A3D_SUCCESS;
}
VISITLEAVE;
}
#endif
void A3DVisitorContainer::push( A3DVisitor* psVisitor )
{
// vector<A3DVisitor*>::iterator iter =
// search(m_apVisitor.begin(), m_apVisitor.end(), &psVisitor, &psVisitor+1);
// if(iter == m_apVisitor.end())
// {
// m_apVisitorExcludedForDelete.push_back(psVisitor);
// }
m_apVisitor.push_back(psVisitor);
if(!m_pTreeVisitor)
m_pTreeVisitor = (A3DVisitor*)dynamic_cast<A3DTreeVisitor*>(psVisitor);//dynamic_cast return null if failed.
}
A3DVisitorContainer::~A3DVisitorContainer()
{
size_t uI, uNbVisitor = m_apVisitor.size();
// vector<A3DVisitor*>::iterator iter;
for(uI = 0; uI < uNbVisitor; uI++)
// {
// iter = search( m_apVisitorExcludedForDelete.begin(),
// m_apVisitorExcludedForDelete.end(),
// &m_apVisitor[uI],
// &m_apVisitor[uI]+1);
// if(iter == m_apVisitorExcludedForDelete.end())
delete m_apVisitor[uI];
// }
}
void* A3DVisitorContainer::FindInMap(const A3DEntity* pA3DEntity)
{
map<const A3DEntity*, void*>::iterator my_mapIter;
my_mapIter = m_apA3DEntityYourEntityMap.find(pA3DEntity);
if(my_mapIter == m_apA3DEntityYourEntityMap.end())
return NULL;
return my_mapIter->second;
}
void A3DVisitorContainer::SetInMap(const A3DEntity* pA3DEntity, void* pYourEntity)
{
m_apA3DEntityYourEntityMap.insert(std::pair<const A3DEntity*, void*>(pA3DEntity, pYourEntity));
}
A3DVisitor* A3DVisitorContainer::GetVisitorByName( std::string strName )
{
vector<A3DVisitor*>::iterator iter = m_apVisitor.begin();
for( ; iter != m_apVisitor.end(); ++iter)
if(strName.compare((*iter)->GetName()) == 0)
return *iter;
return NULL;
}
A3DVisitor* A3DVisitorContainer::GetTreeVisitor() const
{
return m_pTreeVisitor;
}
void A3DVisitorContainer::ActivateEntityReference( A3DEntity const* pEntity )
{
// StepEntityReference
size_t uI, uNbPushStepEntityRef = m_asStepEntityRefManager.size();
for(uI = 0; uI < uNbPushStepEntityRef; uI++)
{
if(m_asStepEntityRefManager[uI].m_pA3DEntityRef == pEntity)
{
m_asStepEntityRefManager[uI].m_uiPushLevel = m_uiCurrentLevel;
}
}
// ViewLinkedItem
size_t uNbPushViewLMkpLinkedItem = m_asViewLinkedItemManager.size();
for (uI = 0; uI < uNbPushViewLMkpLinkedItem; uI++)
{
A3DViewLinkedItemManager *pCurManager = &m_asViewLinkedItemManager[uI];
if (pCurManager->m_pA3DEntityRef == pEntity &&
( pCurManager->m_POOwner == NULL ||
pCurManager->m_POOwner == pEntity ||
pCurManager->m_POOwner == m_pCurrentPOFather
)
)
{
pCurManager->m_uiPushLevel = m_uiCurrentLevel;
}
}
}
void A3DVisitorContainer::DeactivateEntityReference( A3DEntity const* pEntity )
{
// StepEntityReference
size_t uI, uNbPushStepEntityRef = m_asStepEntityRefManager.size();
for(uI = 0; uI < uNbPushStepEntityRef; uI++)
{
if(m_asStepEntityRefManager[uI].m_pA3DEntityRef == pEntity)
{
m_asStepEntityRefManager[uI].m_uiPushLevel = ~0U;
}
}
// ViewLinkedItem
size_t uNbPushViewLMkpLinkedItem = m_asViewLinkedItemManager.size();
for (uI = 0; uI < uNbPushViewLMkpLinkedItem; uI++)
{
A3DViewLinkedItemManager *pCurManager = &m_asViewLinkedItemManager[uI];
if (pCurManager->m_pA3DEntityRef == pEntity &&
( pCurManager->m_POOwner == NULL ||
pCurManager->m_POOwner == pEntity ||
pCurManager->m_POOwner == m_pCurrentPOFather
)
)
{
pCurManager->m_uiPushLevel = ~0U;
}
}
}
A3DStepEntityRefManager const* A3DVisitorContainer::GetActiveStepEntityRefManager(A3DEntity const * pEntity) const
{
A3DStepEntityRefManager const * psActivated = NULL;
size_t uI, uNbPushStepEntityRef = m_asStepEntityRefManager.size();
for(uI = 0; uI < uNbPushStepEntityRef; uI++)
{
A3DStepEntityRefManager const * psCurManager = &m_asStepEntityRefManager[uI];
if (psCurManager->m_uiPushLevel!=~0U && (pEntity==NULL || psCurManager->m_pA3DEntityRef==pEntity))
{
if (!psActivated)
psActivated = psCurManager;
else if (psCurManager->IsFirst(*psActivated))
psActivated = psCurManager;
}
}
return psActivated;
}
A3DViewLinkedItemManager const* A3DVisitorContainer::GetActiveViewLinkedItemManager(A3DEntity const * pEntity) const
{
A3DViewLinkedItemManager const * psActivated = NULL;
size_t uI, uNbPushViewMarkupLinkedItem = m_asViewLinkedItemManager.size();
for (uI = 0; uI < uNbPushViewMarkupLinkedItem; uI++)
{
A3DViewLinkedItemManager const * psCurManager = &m_asViewLinkedItemManager[uI];
if (psCurManager->m_uiPushLevel!=~0U && (pEntity==NULL || psCurManager->m_pA3DEntityRef==pEntity))
{
if (!psActivated)
psActivated = psCurManager;
else if (psCurManager->IsFirst(*psActivated))
psActivated = psCurManager;
}
}
return psActivated;
}

321
exchange/exchangesource/Viewer/traverse/VisitorTessellation.cpp Normal file
View File

@@ -0,0 +1,321 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
#include "../VisitorTessellation.h"
#include "../TessConnector.h"
#include "../VisitorCascadedAttribute.h"
#include "../VisitorTransfo.h"
#include "../VisitorContainer.h"
#include "../TransfoConnector.h"
#include "../CascadedAttributeConnector.h"
#include "../MarkupTessConnector.h"
#include "../callback_opengl.h"
A3DStatus A3DVisitorTessellation::visitEnter(const A3DFaceTessDataConnector& sFaceTessConnector)
{
const A3DTessDataConnector * psTessDataConnector = sFaceTessConnector.GetTessDataConnector();
A3DStatus iRet = A3D_SUCCESS;
unsigned int uPointSize, uNormalSize, uUVSize;
double* pdPoint, *pdNormal, *pdUV;
CHECK_RET(psTessDataConnector->Points(pdPoint, uPointSize));
CHECK_RET(psTessDataConnector->Normals(pdNormal, uNormalSize));
CHECK_RET(psTessDataConnector->UV(pdUV, uUVSize));
std::vector<unsigned> auTriangleWithPointNormalindices;
std::vector<unsigned> auTriangleWithPointNormalUVindices;
unsigned uTextureCount = 0;
CHECK_RET(psTessDataConnector->GetTextureCount(sFaceTessConnector.GetFaceIndex(), uTextureCount));
CHECK_RET(psTessDataConnector->IndicesPerFaceAsTriangle(sFaceTessConnector.GetFaceIndex(),
auTriangleWithPointNormalindices,
auTriangleWithPointNormalUVindices));
///////////////////////////////////////////////////////////////
// Draw the tessellation - PLEASE, ADD your sources HERE
///////////////////////////////////////////////////////////////
//manage the visibility of the items
if (m_bShow)
{
// Draw all the triangles of the model (we're not reading the UV for now)
if (auTriangleWithPointNormalindices.size() != 0)
OpenGL_Triangle(pdNormal, uNormalSize, pdPoint, uPointSize, auTriangleWithPointNormalindices, uTextureCount);
if (auTriangleWithPointNormalUVindices.size() != 0)
OpenGL_Triangle(pdNormal, uNormalSize, pdPoint, uPointSize, auTriangleWithPointNormalUVindices, uTextureCount);
}
///////////////////////////////////////////////////////////////
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitLeave(const A3DFaceTessDataConnector& /*sTessConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitEnter(const A3DTessDataConnector& sTessConnector)
{
///////////////////////////////////////////////////////////////
// Get the bounding box - PLEASE, ADD your sources HERE
///////////////////////////////////////////////////////////////
A3DStatus iRet = A3D_SUCCESS;
unsigned int uPointSize, uNormalSize, uUVSize, uFaceSize;
double* pdPoint, *pdNormal, *pdUV;
CHECK_RET(sTessConnector.Points(pdPoint, uPointSize));
CHECK_RET(sTessConnector.Normals(pdNormal, uNormalSize));
CHECK_RET(sTessConnector.UV(pdUV, uUVSize));
uFaceSize = sTessConnector.FacesSize();
///////////////////////////////////////////////////////////////
// Get the Bounding Box - PLEASE, ADD your sources HERE
///////////////////////////////////////////////////////////////
if(!GetstbUseCallbacks())
{
if (m_bShow)
{
A3DVisitorTransfo* psVisitorTransfo = (A3DVisitorTransfo*) m_psContainer->GetVisitor()[0];
A3DTransfoConnector* pConnector = psVisitorTransfo->GetTransfoConnector();
A3DMatrix4x4 sGlobalTransfo;
A3DMatrix4x4 sLocalTransfo;
pConnector->GetGlobalTransfo(sGlobalTransfo);
//pConnector->GetLocalMatrix(sLocalTransfo);
delete pConnector;
A3DVector3d sCurrentPt;
for(unsigned int uI = 0; uI < uPointSize/3; uI++)
{
sCurrentPt.set(pdPoint[uI*3], pdPoint[uI*3 + 1], pdPoint[uI*3+2]);
sCurrentPt = sGlobalTransfo * sCurrentPt;
stBoundingBoxAddPoint(GetstpsBoundingBox(), sCurrentPt.x, sCurrentPt.y, sCurrentPt.z);
}
}
}
else
{
A3DVisitorTransfo* psVisitorTransfo = (A3DVisitorTransfo*) m_psContainer->GetVisitor()[0];
A3DTransfoConnector* pConnector = psVisitorTransfo->GetTransfoConnector();
A3DMatrix4x4 sGlobalTransfo;
pConnector->GetGlobalTransfo(sGlobalTransfo);
delete pConnector;
OpenGL_PushMatrix();
OpenGL_MultMatrix(sGlobalTransfo.m_adM);
}
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitLeave(const A3DTessDataConnector& /*sTessConnector*/)
{
if(GetstbUseCallbacks())
OpenGL_PopMatrix();
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitEnter(const A3DRiConnector& /*sTessConnector*/)
{
A3DVisitorColorMaterials* pVisitorColorAndMaterials = (A3DVisitorColorMaterials *)m_psContainer->GetVisitor()[1];
ColorMaterialsConnector sColorMaterialConnec(pVisitorColorAndMaterials->GetLastCascadedAttributes());
if (sColorMaterialConnec.IsShow() && !sColorMaterialConnec.IsRemoved())
m_bShow = true;
else
m_bShow = false;
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitLeave(const A3DRiConnector& /*sTessConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitEnter(const A3DMarkupTessConnector& sMarkupTessConnector)
{
A3DVisitorColorMaterials* pVisitorColorAndMaterials = (A3DVisitorColorMaterials *)m_psContainer->GetVisitor()[1];
ColorMaterialsConnector sColorMaterialConnec(pVisitorColorAndMaterials->GetLastCascadedAttributes());
if (sColorMaterialConnec.IsShow() && !sColorMaterialConnec.IsRemoved())
m_bShow = true;
else
m_bShow = false;
if (GetstbDrawMarkups())
{
// Get the bounding box
if(!GetstbUseCallbacks())
{
A3DVisitorTransfo* psVisitorTransfo = (A3DVisitorTransfo*) m_psContainer->GetVisitor()[0];
A3DTransfoConnector* pConnector = psVisitorTransfo->GetTransfoConnector();
A3DMatrix4x4 sGlobalTransfo;
A3DMatrix4x4 sLocalTransfo;
pConnector->GetGlobalTransfo(sGlobalTransfo);
delete pConnector;
std::vector<double> adPolyline = sMarkupTessConnector.GetPolyLineCoords(); // Copy
A3DVector3d sCurrentPt;
size_t uI, uPolylineSize = adPolyline.size();
for(uI = 0; uI < uPolylineSize/3; uI++)
{
sCurrentPt.set(adPolyline[uI*3], adPolyline[uI*3 + 1], adPolyline[uI*3+2]);
sCurrentPt = sGlobalTransfo * sCurrentPt;
stBoundingBoxAddPoint(GetstpsBoundingBox(), sCurrentPt.x, sCurrentPt.y, sCurrentPt.z);
}
}
// Draw the markups
else
{
OpenGL_Begin(kA3DDrawBeginEndMarkup, NULL, 0);
if (m_bShow)
{
// Draw the global matrix
OpenGL_PushMatrix();
OpenGL_MultMatrix(sMarkupTessConnector.GetWorldMatrix());
// *** Draw the colors
double a_adRGB[3] = {0, 0, 0};
sMarkupTessConnector.GetColor(a_adRGB);
OpenGL_Color(a_adRGB);
// *** Draw the triangles
std::vector<double> triangles = sMarkupTessConnector.GetTriangles();
size_t uTrianglesSize = triangles.size();
double* adTriangle = new double[uTrianglesSize];
for (size_t ui=0; ui<uTrianglesSize; ++ui)
adTriangle[ui] = triangles[ui];
if (uTrianglesSize != 0)
{
OpenGL_MarkupTriangle(adTriangle, A3DUns32(uTrianglesSize)/3);
}
delete[] adTriangle;
// *** Draw text
std::vector<A3DPMITextEntry*> const& textEntries = sMarkupTessConnector.GetTextEntries();
for (size_t ui = 0; ui < textEntries.size(); ++ui)
{
A3DPMITextEntry mTextEntries = *textEntries[ui];
A3DFontKeyData sFontKeyData = mTextEntries.GetFontKeyData();
OpenGL_Font(&sFontKeyData);
A3DUTF8Char * m_ppcTexts = mTextEntries.GetText();
// Draw Text
A3DRiSet *pSet = NULL;
A3DDouble dLength = 0.;
if(A3DGlobalFontTextTessellationGet(&sFontKeyData, m_ppcTexts, &pSet, &dLength) == A3D_SUCCESS)
{
A3DRiConnector sRiSet(pSet);
sRiSet.TraverseRi(this->m_psContainer);
}
}
// *** Draw the polylines
std::vector<int> polylineindex = sMarkupTessConnector.GetPolyLineIndices();
std::vector<double> polylines = sMarkupTessConnector.GetPolyLineCoords();
double* adPolyline = new double[polylines.size()];
for (size_t ui=0; ui<polylines.size(); ++ui)
adPolyline[ui] = polylines[ui];
if (polylineindex.size() != 0)
{
size_t uPolylineIndicesSize = polylineindex.size();
for (size_t uI=0; uI < uPolylineIndicesSize-1; ++uI)
{
OpenGL_PolyLine(&adPolyline[polylineindex[uI]*3], polylineindex[uI+1] - polylineindex[uI]);
}
}
delete[] adPolyline;
OpenGL_PopMatrix();
stPopMatrix();
}
OpenGL_End(kA3DDrawBeginEndMarkup);
}
}
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitEnter(const A3DWireTessDataConnector& sWireTessConnector)
{
A3DStatus iRet = A3D_SUCCESS;
double* pPoint;
unsigned int uSize;
std::vector<int> auPolylineIndices;
// manage the visibility of the items
A3DVisitorColorMaterials* pVisitorColorAndMaterials = (A3DVisitorColorMaterials *)m_psContainer->GetVisitor()[1];
ColorMaterialsConnector sColorMaterialConnec(pVisitorColorAndMaterials->GetLastCascadedAttributes());
pVisitorColorAndMaterials->GetColorMaterialConnector(sColorMaterialConnec, false);
A3DVisitorTransfo* psVisitorTransfo = (A3DVisitorTransfo*)m_psContainer->GetVisitor()[0];
A3DTransfoConnector* pConnector = psVisitorTransfo->GetTransfoConnector();
A3DMatrix4x4 sGlobalTransfo;
pConnector->GetGlobalTransfo(sGlobalTransfo);
delete pConnector;
OpenGL_PushMatrix();
OpenGL_MultMatrix(sGlobalTransfo.m_adM);
if (sColorMaterialConnec.IsShow() && !sColorMaterialConnec.IsRemoved())
{
CHECK_RET(sWireTessConnector.Points(pPoint, uSize));
CHECK_RET(sWireTessConnector.Indices(auPolylineIndices));
size_t uI, uPolylineIndicesSize = auPolylineIndices.size();
// section case:
if (auPolylineIndices[0] > 0)
{
for (uI = 0; uI < uPolylineIndicesSize; uI++)
{
std::vector<A3DDouble> aPoints;
// kA3DTess3DWireDataIsContinuous && kA3DTess3DWireDataIsClosing to be treated
unsigned int uPolyLineSize = auPolylineIndices[uI] & ~(kA3DTess3DWireDataIsContinuous | kA3DTess3DWireDataIsClosing);
for (size_t uJ = uI + 1; uJ < uI + uPolyLineSize + 1; uJ++)
{
aPoints.push_back(pPoint[auPolylineIndices[uJ]]);
aPoints.push_back(pPoint[auPolylineIndices[uJ] + 1]);
aPoints.push_back(pPoint[auPolylineIndices[uJ] + 2]);
}
OpenGL_PolyLine(aPoints.data(), uPolyLineSize);
uI += uPolyLineSize;
}
}
else
{
for (uI = 0; uI + 1 < uPolylineIndicesSize; ++uI)
{
// manage the case of polywire
int test = auPolylineIndices[uI + 1] - auPolylineIndices[uI];
if (test > 0)
OpenGL_PolyLine(&pPoint[auPolylineIndices[uI] * 3], auPolylineIndices[uI + 1] - auPolylineIndices[uI]);
}
}
}
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitLeave(const A3DWireTessDataConnector& /*sWireTessConnector*/)
{
OpenGL_PopMatrix();
return A3D_SUCCESS;
}

321
exchange/exchangesource/Viewer/traverse/VisitorTransfo.cpp Normal file
View File

@@ -0,0 +1,321 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
#include "../VisitorTransfo.h"
#include "../VisitorContainer.h"
#include "../TransfoConnector.h"
A3DVisitorTransfo::A3DVisitorTransfo( bool bModelFileUnitFormCAD,
double dUnitModelFile,
A3DVisitorContainer* psContainer /*= NULL*/ )
: A3DVisitor("Transformation", psContainer),
m_dUnit(dUnitModelFile),
m_bUnitFormCad(bModelFileUnitFormCAD)
{
}
A3DVisitorTransfo::A3DVisitorTransfo( A3DVisitorContainer* psContainer /*= NULL*/ )
: A3DVisitor("Transformation", psContainer),
m_dUnit(-1),
m_bUnitFormCad(false)
{
}
A3DVisitorTransfo::~A3DVisitorTransfo()
{
}
A3DTransfoConnector* A3DVisitorTransfo::GetTransfoConnectorFromManager(A3DEntity const * pEntity)
{
if(m_psContainer)
{
A3DViewLinkedItemManager const* pVLIM = m_psContainer->GetActiveViewLinkedItemManager(pEntity);
if (pVLIM)
{
A3DMiscEntityReferenceData sSERData;
A3D_INITIALIZE_DATA(A3DMiscEntityReferenceData, sSERData);
A3DStatus iErr = A3DMiscEntityReferenceGet(pVLIM->m_pMarkupLinkedItem, &sSERData);
if (iErr == A3D_SUCCESS && sSERData.m_pCoordinateSystem)
{
A3DRiCoordinateSystemData sCSysData;
A3D_INITIALIZE_DATA(A3DRiCoordinateSystemData, sCSysData);
iErr = A3DRiCoordinateSystemGet(sSERData.m_pCoordinateSystem, &sCSysData);
A3DTransfoConnector* pConnector = new A3DTransfoConnector(NULL);
pConnector->SetGlobalMatrix(sCSysData.m_pTransformation);
return pConnector;
}
A3DMiscEntityReferenceGet(NULL, &sSERData);
}
A3DStepEntityRefManager const* pSERM = m_psContainer->GetActiveStepEntityRefManager(pEntity);
if(pSERM)
{
A3DMiscEntityReferenceData sSERData;
A3D_INITIALIZE_DATA(A3DMiscEntityReferenceData, sSERData);
A3DStatus iErr = A3DMiscEntityReferenceGet(pSERM->m_pStepEntityRef, &sSERData);
if(iErr == A3D_SUCCESS && sSERData.m_pCoordinateSystem)
{
A3DRiCoordinateSystemData sCSysData;
A3D_INITIALIZE_DATA(A3DRiCoordinateSystemData, sCSysData);
iErr = A3DRiCoordinateSystemGet(sSERData.m_pCoordinateSystem, &sCSysData);
A3DTransfoConnector* pConnector = new A3DTransfoConnector(NULL);
pConnector->SetGlobalMatrix(sCSysData.m_pTransformation);
return pConnector;
}
A3DMiscEntityReferenceGet(NULL, &sSERData);
}
}
return NULL;
}
A3DStatus A3DVisitorTransfo::visitEnter(const A3DRiConnector& sConnector)
{
A3DStatus iRet = A3D_SUCCESS;
A3DMatrix4x4 sTransfo;
size_t uSize = m_adPushTransfo.size();
// Use ItemReference transformation instead of local transformation
A3DTransfoConnector *pConnectorFromRef = this->GetTransfoConnectorFromManager(sConnector.GetA3DEntity());
if (pConnectorFromRef)
{
pConnectorFromRef->GetGlobalTransfo(sTransfo);
m_adPushTransfo.push_back(sTransfo);
delete pConnectorFromRef;
}
else if(sConnector.m_sRiData.m_pCoordinateSystem)
{
A3DRiCoordinateSystemData sA3DRiCoordinateSystemData;
A3D_INITIALIZE_DATA(A3DRiCoordinateSystemData, sA3DRiCoordinateSystemData);
CHECK_RET_CALL_A3D_FCTION(A3DRiCoordinateSystemGet,(sConnector.m_sRiData.m_pCoordinateSystem,&sA3DRiCoordinateSystemData));
A3DTransfoConnector sTransfoConnector(sA3DRiCoordinateSystemData.m_pTransformation);
sTransfoConnector.ComputeGlobalMatrix(uSize!= 0 ? m_adPushTransfo[uSize-1] : stIdentity);
//Local Matrix
A3DMatrix4x4 sThisMatrix;
CHECK_RET(sTransfoConnector.GetLocalMatrix(sThisMatrix));
CHECK_RET(SetLocalTransfo(sThisMatrix));
//GlobalMatrix
sTransfoConnector.GetGlobalTransfo(sTransfo);
m_adPushTransfo.push_back(sTransfo);
CHECK_RET_CALL_A3D_FCTION(A3DRiCoordinateSystemGet,(NULL, &sA3DRiCoordinateSystemData));
}
else
{
m_adPushTransfo.push_back(uSize!= 0 ? m_adPushTransfo[uSize-1] : stIdentity);
CHECK_RET(SetLocalTransfo(stIdentity));
}
CHECK_RET(SetGlobalTransfo(m_adPushTransfo[m_adPushTransfo.size() - 1]));
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTransfo::visitLeave(const A3DRiConnector& /*sConnector*/)
{
// End drawing the Representation Items
m_adPushTransfo.pop_back();
return A3D_SUCCESS;
}
static A3DStatus stProductOccurrenceGetLocation(const A3DAsmProductOccurrenceData* psPOccData,
A3DMiscCartesianTransformation** ppLocation)
{
if (psPOccData == NULL)
return A3D_ERROR;
A3DStatus iRet = A3D_SUCCESS;
A3DAsmProductOccurrence* pExternal = psPOccData->m_pExternalData;
if (pExternal != NULL)
{
A3DAsmProductOccurrenceData sExternalDataData;
A3D_INITIALIZE_DATA( A3DAsmProductOccurrenceData, sExternalDataData);
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(pExternal, &sExternalDataData));
CHECK_RET(stProductOccurrenceGetLocation( &sExternalDataData , ppLocation));
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(NULL, &sExternalDataData));
if(*ppLocation)
return A3D_SUCCESS;
}
if (psPOccData->m_pLocation == NULL && psPOccData->m_pPrototype != NULL)
{
A3DAsmProductOccurrenceData sPrototypeData;
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, sPrototypeData);
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(psPOccData->m_pPrototype, &sPrototypeData));
CHECK_RET(stProductOccurrenceGetLocation(&sPrototypeData, ppLocation));
CHECK_RET_CALL_A3D_FCTION(A3DAsmProductOccurrenceGet,(NULL, &sPrototypeData));
return A3D_SUCCESS;
}
*ppLocation = psPOccData->m_pLocation;
return iRet;
}
A3DStatus A3DVisitorTransfo::visitEnter(const A3DProductOccurrenceConnector& sConnector)
{
A3DStatus iRet = A3D_SUCCESS;
if(sConnector.m_sProductOccurrenceData.m_bUnitFromCAD && !m_bUnitFormCad)
{
m_bUnitFormCad = true;
m_dUnit = sConnector.m_sProductOccurrenceData.m_dUnit;
}
// Use ItemReference transformation instead of local transformation
A3DTransfoConnector *pConnectorFromRef = this->GetTransfoConnectorFromManager(sConnector.GetA3DEntity());
if (pConnectorFromRef)
{
A3DMatrix4x4 sTransfo;
pConnectorFromRef->GetGlobalTransfo(sTransfo);
m_adPushTransfo.push_back(sTransfo);
delete pConnectorFromRef;
}
else
{
A3DMiscCartesianTransformation* pLocation = NULL;
stProductOccurrenceGetLocation(&(sConnector.m_sProductOccurrenceData), &pLocation);
A3DMatrix4x4 sTransfo;
size_t uSize = m_adPushTransfo.size();
if(pLocation)
{
A3DTransfoConnector sTransfoConnector(pLocation);
//Local Transfo
A3DMatrix4x4 sThisMatrix;
CHECK_RET(sTransfoConnector.GetLocalMatrix(sThisMatrix));
CHECK_RET(SetLocalTransfo(sThisMatrix));
//Global Transfo
sTransfoConnector.ComputeGlobalMatrix( uSize != 0 ? m_adPushTransfo[uSize - 1]: stIdentity);
sTransfoConnector.GetGlobalTransfo(sTransfo);
m_adPushTransfo.push_back(sTransfo);
}
else
{
m_adPushTransfo.push_back(uSize != 0 ? m_adPushTransfo[uSize - 1] : stIdentity);
CHECK_RET(SetLocalTransfo(stIdentity));
}
}
CHECK_RET(SetGlobalTransfo(m_adPushTransfo[m_adPushTransfo.size() - 1]));
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTransfo::visitLeave(const A3DProductOccurrenceConnector& /*sConnector*/)
{
// End drawing the Product Occurrences
m_adPushTransfo.pop_back();
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTransfo::visitEnter(const A3DModelFileConnector& sConnector)
{
if(sConnector.m_sModelFileData.m_bUnitFromCAD && !m_bUnitFormCad)
{
m_bUnitFormCad = true;
m_dUnit = sConnector.m_sModelFileData.m_dUnit;
}
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTransfo::visitLeave(const A3DModelFileConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DTransfoConnector* A3DVisitorTransfo::GetTransfoConnector(bool bUseInstance /*= false*/ )
{
if(bUseInstance)
{
size_t iSize = m_adPushTransfo.size();
A3DMatrix4x4 rLastMatrix = iSize != 0 ? m_adPushTransfo[iSize-1] : stIdentity;
A3DMiscCartesianTransformation* pTransfo = CreateTransfo(m_adLocalMatrix);
A3DTransfoConnector* pConnector = new A3DTransfoConnector(pTransfo);
pConnector->SetGlobalMatrix(rLastMatrix);
CALL_A3D_FCTION(A3DEntityDelete,(pTransfo));
return pConnector;
}
else
{
//if(m_psContainer)
//{
// A3DTreeVisitor* pTreeVisitor = (A3DTreeVisitor*)m_psContainer->GetTreeVisitor();
// if(pTreeVisitor)
// {
// A3DStepEntityRefManager const* pSERM = pTreeVisitor->GetActiveStepEntityRefManager();
// if(pSERM)
// {
// A3DMiscEntityReferenceData sSERData;
// A3D_INITIALIZE_DATA(A3DMiscEntityReferenceData, sSERData);
// A3DStatus iErr = CALL_A3D_FCTION(A3DMiscEntityReferenceGet,(pSERM->m_pStepEntityRef, &sSERData));
// if(iErr == A3D_SUCCESS && sSERData.m_pCoordinateSystem)
// {
// A3DRiCoordinateSystemData sCSysData;
// A3D_INITIALIZE_DATA(A3DRiCoordinateSystemData, sCSysData);
// iErr = CALL_A3D_FCTION(A3DRiCoordinateSystemGet,(sSERData.m_pCoordinateSystem, &sCSysData));
// A3DTransfoConnector* pConnector = new A3DTransfoConnector(NULL);
// pConnector->SetGlobalMatrix(sCSysData.m_pTransformation);
// return pConnector;
// }
// CALL_A3D_FCTION(A3DMiscEntityReferenceGet,(NULL, &sSERData));
// }
//
// A3DViewLinkedItemManager const* pVLIM = pTreeVisitor->GetActiveViewLinkedItemManager();
// if (pVLIM)
// {
// A3DMiscEntityReferenceData sSERData;
// A3D_INITIALIZE_DATA(A3DMiscEntityReferenceData, sSERData);
// A3DStatus iErr = CALL_A3D_FCTION(A3DMiscEntityReferenceGet, (pVLIM->m_pMarkupLinkedItem, &sSERData));
// if (iErr == A3D_SUCCESS && sSERData.m_pCoordinateSystem)
// {
// A3DRiCoordinateSystemData sCSysData;
// A3D_INITIALIZE_DATA(A3DRiCoordinateSystemData, sCSysData);
// iErr = CALL_A3D_FCTION(A3DRiCoordinateSystemGet, (sSERData.m_pCoordinateSystem, &sCSysData));
// A3DTransfoConnector* pConnector = new A3DTransfoConnector(NULL);
// pConnector->SetGlobalMatrix(sCSysData.m_pTransformation);
// return pConnector;
// }
// CALL_A3D_FCTION(A3DMiscEntityReferenceGet, (NULL, &sSERData));
// }
// }
//}
size_t iSize = m_adPushTransfo.size();
A3DMatrix4x4 rLastMatrix = iSize != 0 ? m_adPushTransfo[iSize-1] : stIdentity;
A3DMiscCartesianTransformation* pTransfo = CreateTransfo(m_adLocalMatrix);
A3DTransfoConnector* pConnector = new A3DTransfoConnector(pTransfo);
pConnector->SetGlobalMatrix(rLastMatrix);
CALL_A3D_FCTION(A3DEntityDelete,(pTransfo));
return pConnector;
}
}
A3DMiscTransformation* A3DVisitorTransfo::CreateTransfo( A3DMatrix4x4 const & rMatrix )
{
A3DMiscGeneralTransformationData sData;
A3D_INITIALIZE_DATA( A3DMiscGeneralTransformationData, sData);
memcpy( sData.m_adCoeff ,rMatrix.m_adM, 16*sizeof(double));
A3DMiscGeneralTransformation* pTransfo = NULL;
CALL_A3D_FCTION(A3DMiscGeneralTransformationCreate,(&sData, &pTransfo));
return (A3DMiscTransformation*)pTransfo;
}

97
exchange/exchangesource/Viewer/traverse/VisitorTree.cpp Normal file
View File

@@ -0,0 +1,97 @@
/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
#include "../VisitorTree.h"
A3DStatus A3DTreeVisitor::visitEnter(const A3DRiBrepModelConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitLeave(const A3DRiBrepModelConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitEnter(const A3DRiSetConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitLeave(const A3DRiSetConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitEnter(const A3DRiConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitLeave(const A3DRiConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitEnter(const A3DPartConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitLeave(const A3DPartConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitEnter(const A3DProductOccurrenceConnector& sConnector)
{
if(m_uOption&NODE_INSTANCES)
{
m_pYourEntity = m_psContainer->FindInMap(sConnector.GetA3DEntity());
if(m_pYourEntity)
{
((A3DProductOccurrenceConnector*) &sConnector)->SetIsInstanciated(true);
}
}
m_psContainer->SetInMap(sConnector.GetA3DEntity(),(void*) sConnector.GetA3DEntity() );
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitLeave(const A3DProductOccurrenceConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitEnter(const A3DMkpViewConnector& sConnector)
{
m_psContainer->SetInMap(sConnector.GetA3DEntity(), (void*)sConnector.GetA3DEntity());//m_pYourEntity);
return A3D_SUCCESS;
}
A3DStatus A3DTreeVisitor::visitLeave(const A3DMkpViewConnector& /*sConnector*/)
{
return A3D_SUCCESS;
}
void A3DTreeVisitor::SetYourEntity(void* /*pYourEnity*/)
{
//std::vector<A3DStepEntityRefManager>::iterator sIter;
//for(sIter = m_asStepEntityRefManager.begin(); sIter != m_asStepEntityRefManager.end(); ++sIter)
//{
// if(sIter->m_bPushChildren == true)
// sIter->m_apYourEntity.push_back(pYourEnity);
//}
//
//return;
}

11
exchange/exchangesource/Viewer/traverse/visitor.cpp Normal file
View File

@@ -0,0 +1,11 @@
#include "VisitorsContainer.h"
void* A3DVisitorContainer::FindInMap(const A3DEntity* pA3DEntity)
{
return m_psContainer->FindInMap(pA3DEntity);
}
void A3DVisitorContainer::SetInMap(const A3DEntity* pA3DEntity, void* pYourEntity)
{
return SetInMap(pA3DEntity, pYourEntity);
}