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

425
exchange/exchangesource/Collision/Collision.cpp Normal file
View File

@@ -0,0 +1,425 @@
/***********************************************************************************************************************
*
* 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 Collision.cpp
This program demonstrates how to programmatically use the A3DCollisionCompute function.
This program reads a model file and outputs a text file. Specify these files on the command line (see 'Usage').
A sample file can be find in data directory : data\inventor\collision.iam
Usage:
Collision [INPUT] [OUTPUT] [UUIDs...]
INPUT The input CAD file. Default is '00242AC8'
OUTPUT The output result file. Default is 'CURRENT_DIR/Collision.txt'
UUID1 UUID2... Any number of space separated UUIDs of representation items to be checked to each other. If not set, two relevant UUIDs from the CAD file will be picked
***********************************************************************************************************************/
#ifdef _MSC_VER
# define SAMPLE_DEFAULT_CAD_FILE _T(SAMPLES_DATA_DIRECTORY"\\inventor\\collision.iam")
# define SAMPLE_DEFAULT_RESULT_FILE _T("Collision.txt")
#else
# define SAMPLE_DEFAULT_CAD_FILE SAMPLES_DATA_DIRECTORY"/inventor/collision.iam"
# define SAMPLE_DEFAULT_RESULT_FILE "Collision.txt"
#endif
#define INITIALIZE_A3D_API
#include <A3DSDKIncludes.h>
#include "../common.hpp"
#include "visitor/VisitorContainer.h"
#include "visitor/VisitorCascadedAttribute.h"
#include "visitor/VisitorTree.h"
#include "visitor/VisitorTransfo.h"
#include "visitor/CascadedAttributeConnector.h"
#include "visitor/TransfoConnector.h"
#include <cassert>
#ifdef _MSC_VER
# include <codecvt>
#endif
#include <iostream>
#include <locale>
#include <sstream>
#include <fstream>
using string_t = std::basic_string<MY_CHAR>;
// function declared in createssellatedbox.cpp
A3DStatus CreatePolyBrepModelFromABBox(A3DBoundingBoxData const & sABBox, A3DRiPolyBrepModel ** pRiPolyBrepModel);
//######################################################################################################################
struct A3DFlattenVisitor : public A3DTreeVisitor
{
std::vector<A3DRiRepresentationItem*> m_vA3DRiBrepModel;
std::vector<A3DMatrix4x4> m_vA3DMatrix4x4;
std::vector<A3DUTF8Char *> m_vProductIdentifier;
A3DUTF8Char * m_pcProductIdentifier = nullptr;
double m_dScaleToMm = 1.;
A3DFlattenVisitor(A3DVisitorContainer* psContainer = NULL) : A3DTreeVisitor(psContainer) { psContainer->SetTraverseInstance(true); }
~A3DFlattenVisitor()
{
for (A3DUTF8Char* p: m_vProductIdentifier)
free(p);
}
A3DStatus visitEnter(const A3DPartConnector& sConnector) override
{
A3DStatus iRet = A3DTreeVisitor::visitEnter(sConnector);
if (iRet == A3D_SUCCESS)
{
A3DAsmProductOccurrenceGetIdentifier(sConnector.GetProductOccurrenceFather(), &m_pcProductIdentifier);
}
return iRet;
}
A3DStatus visitLeave(const A3DPartConnector& sConnector) override
{
A3DStatus iRet = A3DTreeVisitor::visitLeave(sConnector);
if (m_pcProductIdentifier)
{
A3DAsmProductOccurrenceGetIdentifier(nullptr, &m_pcProductIdentifier);
}
return iRet;
}
virtual A3DStatus visitEnter(const A3DRiConnector& sConnector) override
{
A3DStatus iRet = A3DTreeVisitor::visitEnter(sConnector);
const A3DEntity* pRi = sConnector.GetA3DEntity();
A3DEEntityType eType = kA3DTypeUnknown;
iRet = A3DEntityGetType(pRi, &eType);
if ((iRet == A3D_SUCCESS) && (eType == kA3DTypeRiBrepModel || eType == kA3DTypeRiPolyBrepModel))
{
A3DVisitorColorMaterials *pA3DCascadedVisitor = static_cast<A3DVisitorColorMaterials*>(m_psContainer->GetVisitorByName("CascadedAttribute"));
if (pA3DCascadedVisitor)
{
ColorMaterialsConnector sColorConnector(nullptr);
pA3DCascadedVisitor->GetColorMaterialConnector(sColorConnector);
if (!sColorConnector.IsShow())
return A3D_SUCCESS;
}
m_vA3DRiBrepModel.push_back((A3DRiRepresentationItem*)sConnector.GetA3DEntity());
A3DVisitorTransfo* psVisitorTransfo = static_cast<A3DVisitorTransfo*>(m_psContainer->GetVisitorByName("Transformation"));
A3DTransfoConnector* pConnector = psVisitorTransfo->GetTransfoConnector();
A3DMatrix4x4 sTransfo;
pConnector->GetGlobalTransfo(sTransfo);
delete pConnector;
// Get global transfo
if (m_dScaleToMm != 1.)
{
A3DMatrix4x4 sScale;
sScale.ResetToIdentity();
sScale.m_adM[0] = m_dScaleToMm;
sScale.m_adM[5] = m_dScaleToMm;
sScale.m_adM[10] = m_dScaleToMm;
sScale.m_adM[15] = m_dScaleToMm;
A3DMatrix4x4 sScaledTransfo;
sScaledTransfo = sTransfo * sScale;
sScaledTransfo.m_adM[15] = 1.;
m_vA3DMatrix4x4.push_back(sScaledTransfo);
}
else
m_vA3DMatrix4x4.push_back(sTransfo);
// Get product occurence identifier ... assuming that there only on rep item by part
A3DUTF8Char * pcProductID = nullptr;
if (m_pcProductIdentifier != nullptr)
{
size_t iLen = strlen(m_pcProductIdentifier);
pcProductID = static_cast<A3DUTF8Char*>(malloc(sizeof(A3DUTF8Char)*(iLen + 1)));
strcpy(pcProductID, m_pcProductIdentifier);
}
m_vProductIdentifier.push_back(pcProductID);
}
return iRet;
}
};
//#####################################################################################################################
A3DStatus stGetFlattenRepItemInMmFromModelFile( A3DAsmModelFile * pModelFile,
std::vector<A3DTransfoRepresentationItemData> & apRepItem,
std::vector<string_t> & asIdentifiers)
{
A3DAsmModelFileData sMFData;
A3D_INITIALIZE_DATA(A3DAsmModelFileData, sMFData);
A3DAsmModelFileGet(pModelFile, &sMFData);
double dUnitInMm = sMFData.m_dUnit;
A3DAsmModelFileGet(NULL, &sMFData);
A3DVisitorContainer sA3DVisitorContainer(CONNECT_TRANSFO);
sA3DVisitorContainer.SetTraverseInstance(true);
A3DVisitorColorMaterials *pA3DCascadedVisitor = new A3DVisitorColorMaterials(&sA3DVisitorContainer);
sA3DVisitorContainer.push(pA3DCascadedVisitor);
A3DFlattenVisitor *pA3DFlattenVisitor = new A3DFlattenVisitor(&sA3DVisitorContainer);
sA3DVisitorContainer.push(pA3DFlattenVisitor);
pA3DFlattenVisitor->m_dScaleToMm = dUnitInMm;
A3DModelFileConnector sModelFileConnector(pModelFile);
A3DStatus sStatus = sModelFileConnector.Traverse(&sA3DVisitorContainer);
if (sStatus != A3D_SUCCESS)
return A3D_ERROR;
size_t uiRI, uiNbRepItem = pA3DFlattenVisitor->m_vA3DRiBrepModel.size();
if (uiNbRepItem == 0)
return A3D_MODELFILE_INCONSISTENT_EMPTY;
apRepItem.resize(uiNbRepItem);
asIdentifiers.resize(uiNbRepItem);
for (uiRI = 0; uiRI < uiNbRepItem; uiRI++)
{
A3DTransfoRepresentationItemData & sTransfRI = apRepItem[uiRI];
A3D_INITIALIZE_DATA(A3DTransfoRepresentationItemData, sTransfRI);
sTransfRI.m_pRepItem = pA3DFlattenVisitor->m_vA3DRiBrepModel[uiRI];
sTransfRI.m_pOptPlacement = new double[16];
memcpy( const_cast<double*>(sTransfRI.m_pOptPlacement), pA3DFlattenVisitor->m_vA3DMatrix4x4[uiRI].m_adM, 16 * sizeof(double));
if (A3DUTF8Char* psId = pA3DFlattenVisitor->m_vProductIdentifier[uiRI])
{
std::basic_ostringstream<MY_CHAR> stream;
stream << psId;
asIdentifiers[uiRI] = stream.str();
}
}
return A3D_SUCCESS;
}
void PrintUsage()
{
std::cout << "Usage:" << std::endl
<< "Collision [INPUT] [OUTPUT] [UUIDs...]" << std::endl
<< "\tINPUT The input CAD file. Default is '" << SAMPLE_DEFAULT_CAD_FILE << "'" << std::endl
<< "\tOUTPUT The output result file. Default is 'CURRENT_DIR/Collision.txt'" << std::endl
<< "\tUUID1 UUID2... Any number of space separated UUIDs of representation items to be checked to each other. If not set, two relevant UUIDs from the CAD file will be picked" << std::endl;
}
//######################################################################################################################
#ifdef _MSC_VER
int wmain(A3DInt32 iArgc, A3DUniChar** ppcArgv)
#else
int main(A3DInt32 iArgc, A3DUTF8Char** ppcArgv)
#endif
{
PrintUsage();
// INITIALIZE HOOPS EXCHANGE
A3DSDKHOOPSExchangeLoader sHoopsExchangeLoader(_T(HOOPS_BINARY_DIRECTORY));
CHECK_RET(sHoopsExchangeLoader.m_eSDKStatus);
CHECK_RET(A3DDllSetCallbacksMemory(CheckMalloc, CheckFree));
CHECK_RET(A3DDllSetCallbacksReport(PrintLogMessage, PrintLogWarning, PrintLogError));
// Parsing arguments
string_t acInputCADFile = SAMPLE_DEFAULT_CAD_FILE;
string_t acResultFile = SAMPLE_DEFAULT_RESULT_FILE;
std::vector<string_t> asInputUUID;
// Default Input CAD overridden by first argument
if (iArgc > 1)
{
acInputCADFile = ppcArgv[1];
}
// Default result file overridden by second argument
if (iArgc > 2)
{
acResultFile = ppcArgv[2];
}
// Get all UUIDs
for (A3DInt32 i = 3; i < iArgc; ++i)
{
asInputUUID.emplace_back(ppcArgv[i]);
}
//#####################################
// ### Import input XML file
//#####################################
A3DImport sImport(acInputCADFile.c_str());
A3DStatus iRet = A3D_ERROR;
const size_t uiSize = acInputCADFile.size();
if (uiSize >= 4)
{
const string_t sExtension = acInputCADFile.substr(uiSize - 4, 4);
#ifdef _MSC_VER
if (sExtension == _T(".xml") || sExtension == _T(".XML") || sExtension == _T(".Xml"))
{
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
const std::string aScrFileNameUTF8 = converter.to_bytes(acInputCADFile);
iRet = A3DAsmModelFileLoadFromXMLFile(aScrFileNameUTF8.c_str(), &sImport.m_sLoadData, &sHoopsExchangeLoader.m_psModelFile);
}
#else
if (sExtension == ".xml" || sExtension == ".XML" || sExtension == ".Xml")
iRet = A3DAsmModelFileLoadFromXMLFile(acInputCADFile.c_str(), &sImport.m_sLoadData, &sHoopsExchangeLoader.m_psModelFile);
#endif
else
iRet = sHoopsExchangeLoader.Import(sImport);
}
else
iRet = sHoopsExchangeLoader.Import(sImport);
if (iRet != A3D_SUCCESS && iRet != A3D_LOAD_MISSING_COMPONENTS)
CHECK_RET(iRet);
//#####################################
// ### Flatten Representation Items
//#####################################
std::vector<A3DTransfoRepresentationItemData> apRepItem;
std::vector<string_t> asIdentifier;
iRet = stGetFlattenRepItemInMmFromModelFile(sHoopsExchangeLoader.m_psModelFile, apRepItem, asIdentifier);
CHECK_RET(iRet);
//#####################################
// ### Some Checks
//#####################################
if (apRepItem.size() < 2)
{
std::cout << "Collision sample needs at least 2 representation items in the model file to process." << std::endl;
return A3D_ERROR;
}
assert(apRepItem.size() == asIdentifier.size());
// If no UUID given by the user, take the first available
if (asInputUUID.empty())
{
asInputUUID.push_back(asIdentifier.front());
}
////#####################################
//// ### Build collision group
////#####################################
std::vector<A3DTransfoRepresentationItemData> asGroup1, asGroup2;
std::vector<size_t> auiGroupIndex1, auiGroupIndex2;
for (size_t iIndex = 0; iIndex < apRepItem.size(); iIndex++)
{
bool bInSecondGroup = true;
string_t const & sCurID = asIdentifier[iIndex];
for (auto const & sInputID : asInputUUID)
{
if (sCurID.compare(sInputID) == 0)
{
asGroup1.push_back(apRepItem[iIndex]);
auiGroupIndex1.push_back(iIndex);
bInSecondGroup = false;
break;
}
}
if (bInSecondGroup)
{
asGroup2.push_back(apRepItem[iIndex]);
auiGroupIndex2.push_back(iIndex);
}
}
// fill first group structure
A3DCollisionGroupData sGroup1;
A3D_INITIALIZE_DATA(A3DCollisionGroupData, sGroup1);
sGroup1.m_uRepItemSize = (A3DUns32)asGroup1.size();
if (sGroup1.m_uRepItemSize)
sGroup1.m_apRepItems = &asGroup1[0];
else
{
printf("Invalid first group\n");
return -1;
}
// fill second group structure
A3DCollisionGroupData sGroup2;
A3D_INITIALIZE_DATA(A3DCollisionGroupData, sGroup2);
sGroup2.m_uRepItemSize = (A3DUns32)asGroup2.size();
if (sGroup2.m_uRepItemSize)
sGroup2.m_apRepItems = &asGroup2[0];
//#####################################
// ### Specify collision parameters
//#####################################
A3DCollisionParameterData sCollisionParameter;
A3D_INITIALIZE_DATA(A3DCollisionParameterData, sCollisionParameter);
sCollisionParameter.m_dContactLimit = 0.1;
sCollisionParameter.m_dSafetyDistance = 1.;
sCollisionParameter.m_dTessellationTolerance = 0.01;
//#####################################
// ### Compute
//#####################################
A3DUns32 uCollisionResultsSize = 0;
A3DCollisionResultData * apCollisionResults = nullptr;
iRet = A3DCollisionCompute(&sGroup1, sGroup2.m_uRepItemSize?&sGroup2:nullptr,
&sCollisionParameter,
&uCollisionResultsSize, &apCollisionResults);
CHECK_RET(iRet);
std::basic_ofstream<MY_CHAR> sOutput;
sOutput.open(acResultFile);
if (sOutput.is_open())
{
for (A3DUns32 uiRes = 0; uiRes < uCollisionResultsSize; uiRes++)
{
A3DCollisionResultData const & sCurResult = apCollisionResults[uiRes];
size_t iGlobalIndex1 = auiGroupIndex1[sCurResult.m_iRepItemIndex1];
size_t iGlobalIndex2 = (sGroup2.m_uRepItemSize != 0) ? auiGroupIndex2[sCurResult.m_iRepItemIndex2] : auiGroupIndex1[sCurResult.m_iRepItemIndex2];
sOutput << "Check " << asIdentifier[iGlobalIndex1] << " with " << asIdentifier[iGlobalIndex2] << " : ";
switch (sCurResult.m_eStatus)
{
case A3DCollision_Unknown: sOutput << "Unknown"; break;
case A3DCollision_NoCollision: sOutput << "No Collision"; break;
case A3DCollision_Clearance: sOutput << "Clearance"; break;
case A3DCollision_Contact: sOutput << "Contact"; break;
case A3DCollision_Collision: sOutput << "Collision"; break;
case A3DCollision_FirstInside: sOutput << "First is Inside"; break;
case A3DCollision_SecondInside: sOutput << "Second is Inside"; break;
}
sOutput << std::endl;
}
sOutput.close();
}
// Free memory
iRet = A3DCollisionCompute(nullptr, nullptr, nullptr, &uCollisionResultsSize, &apCollisionResults);
CHECK_RET(iRet);
for (auto & sTransfoRep : apRepItem)
{
delete [] sTransfoRep.m_pOptPlacement;
}
// Check memory allocations
return (int)ListLeaks();
}

199
exchange/exchangesource/Collision/Collision.vcxproj Normal file
View File

@@ -0,0 +1,199 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{EC2593D7-2AB1-4EFC-B412-9C5A70939DF9}</ProjectGuid>
<RootNamespace>Collisision</RootNamespace>
<Keyword>Win32Proj</Keyword>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v145</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v145</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v145</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v145</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(SolutionDir)\HOOPSExchangePublishSample.props" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(SolutionDir)\HOOPSExchangePublishSample.props" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(SolutionDir)\HOOPSExchangePublishSample.props" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="$(SolutionDir)\HOOPSExchangePublishSample.props" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>12.0.30501.0</_ProjectFileVersion>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>false</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<PrecompiledHeader />
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<SDLCheck>false</SDLCheck>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<TargetMachine>MachineX86</TargetMachine>
<AdditionalDependencies>legacy_stdio_float_rounding.obj;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>false</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<PrecompiledHeader />
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<SDLCheck>false</SDLCheck>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<TargetMachine>MachineX64</TargetMachine>
<AdditionalDependencies>legacy_stdio_float_rounding.obj;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking>
<PrecompiledHeader />
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<SDLCheck>false</SDLCheck>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<TargetMachine>MachineX86</TargetMachine>
<AdditionalDependencies>legacy_stdio_float_rounding.obj;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Midl>
<TargetEnvironment>X64</TargetEnvironment>
</Midl>
<ClCompile>
<Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking>
<PrecompiledHeader />
<WarningLevel>Level4</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<SDLCheck>false</SDLCheck>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<TargetMachine>MachineX64</TargetMachine>
<AdditionalDependencies>legacy_stdio_float_rounding.obj;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="Collision.cpp" />
<ClCompile Include="createtessellatedbox.cpp" />
<ClCompile Include="visitor\BrepTraverse.cpp" />
<ClCompile Include="visitor\CascadedAttributeConnector.cpp" />
<ClCompile Include="visitor\MarkupTessConnector.cpp" />
<ClCompile Include="visitor\MarkupTraverse.cpp" />
<ClCompile Include="visitor\Matrix.cpp" />
<ClCompile Include="visitor\TessConnector.cpp" />
<ClCompile Include="visitor\TransfoConnector.cpp" />
<ClCompile Include="visitor\TreeTraverse.cpp" />
<ClCompile Include="visitor\ViewTraverse.cpp" />
<ClCompile Include="visitor\VisitorCascadedAttribute.cpp" />
<ClCompile Include="visitor\VisitorContainer.cpp" />
<ClCompile Include="visitor\VisitorTessellation.cpp" />
<ClCompile Include="visitor\VisitorTransfo.cpp" />
<ClCompile Include="visitor\VisitorTree.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="visitor\A3DVector.h" />
<ClInclude Include="visitor\BrepTraverse.h" />
<ClInclude Include="visitor\CascadedAttributeConnector.h" />
<ClInclude Include="visitor\Connector.h" />
<ClInclude Include="visitor\MarkupTessConnector.h" />
<ClInclude Include="visitor\MarkupTraverse.h" />
<ClInclude Include="visitor\Matrix.h" />
<ClInclude Include="visitor\TessConnector.h" />
<ClInclude Include="visitor\TransfoConnector.h" />
<ClInclude Include="visitor\TreeTraverse.h" />
<ClInclude Include="visitor\ViewTraverse.h" />
<ClInclude Include="visitor\VisitorCascadedAttribute.h" />
<ClInclude Include="visitor\VisitorContainer.h" />
<ClInclude Include="visitor\Visitors.h" />
<ClInclude Include="visitor\VisitorTessellation.h" />
<ClInclude Include="visitor\VisitorTransfo.h" />
<ClInclude Include="visitor\VisitorTree.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

126
exchange/exchangesource/Collision/Collision.vcxproj.filters Normal file
View File

@@ -0,0 +1,126 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav</Extensions>
</Filter>
<Filter Include="Header Files\Visitors Headers">
<UniqueIdentifier>{7d804a86-38ae-4203-91de-03178fd72c1b}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Visitor">
<UniqueIdentifier>{9fc7e631-8e85-48c8-bf89-40c346f0dc9d}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="visitor\VisitorTessellation.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\VisitorTransfo.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\VisitorTree.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\BrepTraverse.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\CascadedAttributeConnector.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\MarkupTessConnector.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\MarkupTraverse.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\Matrix.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\TessConnector.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\TransfoConnector.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\TreeTraverse.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\ViewTraverse.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\VisitorCascadedAttribute.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="visitor\VisitorContainer.cpp">
<Filter>Source Files\Visitor</Filter>
</ClCompile>
<ClCompile Include="Collision.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="createtessellatedbox.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="visitor\VisitorCascadedAttribute.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\VisitorContainer.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\Visitors.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\VisitorTessellation.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\VisitorTransfo.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\VisitorTree.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\BrepTraverse.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\CascadedAttributeConnector.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\Connector.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\MarkupTessConnector.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\MarkupTraverse.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\Matrix.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\TessConnector.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\TransfoConnector.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\TreeTraverse.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\ViewTraverse.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
<ClInclude Include="visitor\A3DVector.h">
<Filter>Header Files\Visitors Headers</Filter>
</ClInclude>
</ItemGroup>
</Project>

175
exchange/exchangesource/Collision/createtessellatedbox.cpp Normal file
View File

@@ -0,0 +1,175 @@
/***********************************************************************************************************************
*
* 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 createtessellatedbox.cpp
This file demonstrates how to create a simple A3DPolyBrepModel with triangle only from a A3DBoundingBoxData.
It's based on the CreatePRCCubes samples
***********************************************************************************************************************/
#include <A3DSDKIncludes.h>
#include "../common.hpp"
static A3DDouble stCubeNormals[18] = {
1., 0., 0.,
-1., 0., 0.,
0., 1., 0.,
0., -1., 0.,
0., 0., 1.,
0., 0., -1.
};
static A3DUns32 stCubeFacesNormalPTriangles[48] =
{
// N, P, P, P, N, P, P, P
12, 0, 3, 6, 12, 6, 3, 9, // Face 0
6, 6, 9, 12, 6, 12, 9, 15, // Face 1
15, 12, 15, 18, 15, 18, 15, 21, // Face 2
9, 18, 21, 0, 9, 0, 21, 3, // Face 3
0, 3, 21, 9, 0, 9, 21, 15, // Face 4
3, 18, 0, 12, 3, 12, 0, 6, // Face 5
};
//#####################################################################################################################
static void freeTess3DData(A3DTess3DData& sTess3DData)
{
free(sTess3DData.m_pdNormals);
free(sTess3DData.m_puiTriangulatedIndexes);
for (A3DUns32 ui = 0; ui < sTess3DData.m_uiFaceTessSize; ++ui)
{
free(sTess3DData.m_psFaceTessData[ui].m_puiSizesTriangulated);
}
free(sTess3DData.m_psFaceTessData);
}
//#####################################################################################################################
// Create a A3DTess3D from a A3DBoundingBoxData with only triangles
static A3DStatus CreateA3DTess3DFromABBox(A3DBoundingBoxData const & sABBox, A3DTess3D ** ppTess3D)
{
A3DStatus iRet = A3D_SUCCESS;
A3DTess3DData sTess3DData;
A3D_INITIALIZE_DATA(A3DTess3DData, sTess3DData);
// Normal coordinates
sTess3DData.m_uiNormalSize = 18;
sTess3DData.m_pdNormals = static_cast<A3DDouble*>(malloc((size_t)sTess3DData.m_uiNormalSize * sizeof(A3DDouble)));
for (A3DUns32 ui = 0; ui < sTess3DData.m_uiNormalSize; ++ui)
sTess3DData.m_pdNormals[ui] = stCubeNormals[ui];
sTess3DData.m_uiTriangulatedIndexSize = 8 * 6;
sTess3DData.m_puiTriangulatedIndexes = (A3DUns32*)malloc((size_t)sTess3DData.m_uiTriangulatedIndexSize * sizeof(A3DUns32));
for (A3DUns32 ui = 0; ui < sTess3DData.m_uiTriangulatedIndexSize; ++ui)
{
sTess3DData.m_puiTriangulatedIndexes[ui] = stCubeFacesNormalPTriangles[ui];
}
// Faces
sTess3DData.m_bHasFaces = true;
sTess3DData.m_uiFaceTessSize = 6;
sTess3DData.m_psFaceTessData = static_cast<A3DTessFaceData*>(malloc((size_t)sTess3DData.m_uiFaceTessSize * sizeof(A3DTessFaceData)));
for (A3DUns32 ui = 0; ui < sTess3DData.m_uiFaceTessSize; ++ui)
{
A3DTessFaceData& sFace = sTess3DData.m_psFaceTessData[ui];
A3D_INITIALIZE_DATA(A3DTessFaceData, sFace);
sFace.m_usUsedEntitiesFlags = kA3DTessFaceDataTriangleOneNormal;
sFace.m_uiStartTriangulated = ui * 8;
sFace.m_uiSizesTriangulatedSize = 1; // size of the next array
sFace.m_puiSizesTriangulated = (A3DUns32*)malloc(sFace.m_uiSizesTriangulatedSize * A3DUns32(sizeof(A3DUns32)));
sFace.m_puiSizesTriangulated[0] = 2; // number of triangles for this face
}
iRet = A3DTess3DCreate(&sTess3DData, ppTess3D);
freeTess3DData(sTess3DData);
CHECK_RET(iRet);
A3DTessBaseData sTessBaseData;
A3D_INITIALIZE_DATA(A3DTessBaseData, sTessBaseData);
sTessBaseData.m_bIsCalculated = false;
// Point coordinates
sTessBaseData.m_uiCoordSize = 8 * 3;
sTessBaseData.m_pdCoords = static_cast<A3DDouble*>(malloc((size_t)sTessBaseData.m_uiCoordSize * sizeof(A3DDouble)));
sTessBaseData.m_pdCoords[0] = sABBox.m_sMin.m_dX;
sTessBaseData.m_pdCoords[1] = sABBox.m_sMin.m_dY;
sTessBaseData.m_pdCoords[2] = sABBox.m_sMax.m_dZ;
sTessBaseData.m_pdCoords[3] = sABBox.m_sMax.m_dX;
sTessBaseData.m_pdCoords[4] = sABBox.m_sMin.m_dY;
sTessBaseData.m_pdCoords[5] = sABBox.m_sMax.m_dZ;
sTessBaseData.m_pdCoords[6] = sABBox.m_sMin.m_dX;
sTessBaseData.m_pdCoords[7] = sABBox.m_sMax.m_dY;
sTessBaseData.m_pdCoords[8] = sABBox.m_sMax.m_dZ;
sTessBaseData.m_pdCoords[9] = sABBox.m_sMax.m_dX;
sTessBaseData.m_pdCoords[10] = sABBox.m_sMax.m_dY;
sTessBaseData.m_pdCoords[11] = sABBox.m_sMax.m_dZ;
sTessBaseData.m_pdCoords[12] = sABBox.m_sMin.m_dX;
sTessBaseData.m_pdCoords[13] = sABBox.m_sMax.m_dY;
sTessBaseData.m_pdCoords[14] = sABBox.m_sMin.m_dZ;
sTessBaseData.m_pdCoords[15] = sABBox.m_sMax.m_dX;
sTessBaseData.m_pdCoords[16] = sABBox.m_sMax.m_dY;
sTessBaseData.m_pdCoords[17] = sABBox.m_sMin.m_dZ;
sTessBaseData.m_pdCoords[18] = sABBox.m_sMin.m_dX;
sTessBaseData.m_pdCoords[19] = sABBox.m_sMin.m_dY;
sTessBaseData.m_pdCoords[20] = sABBox.m_sMin.m_dZ;
sTessBaseData.m_pdCoords[21] = sABBox.m_sMax.m_dX;
sTessBaseData.m_pdCoords[22] = sABBox.m_sMin.m_dY;
sTessBaseData.m_pdCoords[23] = sABBox.m_sMin.m_dZ;
iRet = A3DTessBaseSet(*ppTess3D, &sTessBaseData);
free(sTessBaseData.m_pdCoords);
return iRet;
}
//######################################################################################################################
static A3DStatus createPolyBrepModelFromA3DTess3D(A3DRiPolyBrepModel** ppPolyBREP, A3DTess3D* pTess3D)
{
A3DStatus iRet = A3D_SUCCESS;
A3DRiPolyBrepModelData sPolyBrepModelData;
A3D_INITIALIZE_DATA(A3DRiPolyBrepModelData, sPolyBrepModelData);
sPolyBrepModelData.m_bIsClosed = TRUE;
CHECK_RET(A3DRiPolyBrepModelCreate(&sPolyBrepModelData, ppPolyBREP));
// assign the cube tessellation to the PolyBrepModel
A3DRiRepresentationItemData sRiData;
A3D_INITIALIZE_DATA(A3DRiRepresentationItemData, sRiData);
sRiData.m_pTessBase = pTess3D;
sRiData.m_pCoordinateSystem = NULL;
CHECK_RET(A3DRiRepresentationItemSet(*ppPolyBREP, &sRiData));
return iRet;
}
//#####################################################################################################################
// Create a A3DRiPolyBrepModel from a A3DBoundingBoxData with only triangles
A3DStatus CreatePolyBrepModelFromABBox(A3DBoundingBoxData const & sABBox, A3DRiPolyBrepModel ** pRiPolyBrepModel)
{
A3DTess3D * pTess3D = nullptr;
CHECK_RET(CreateA3DTess3DFromABBox(sABBox, &pTess3D));
CHECK_RET(createPolyBrepModelFromA3DTess3D(pRiPolyBrepModel, pTess3D));
return A3D_SUCCESS;
}

121
exchange/exchangesource/Collision/visitor/A3DVector.h Normal file
View File

@@ -0,0 +1,121 @@
#ifndef A3DVECTOR_H
#define A3DVECTOR_H
#include <math.h>
#include <A3DSDK.h>
#include <A3DSDKTypes.h>
#include <A3DSDKErrorCodes.h>
#include <A3DSDKBase.h>
#include <A3DSDKRootEntities.h>
#include <A3DSDKGeometry.h>
class A3DVector3d
{
public:
double x;
double y;
double z;
A3DVector3d() {}
A3DVector3d(double dX, double dY, double dZ) : x(dX), y(dY), z(dZ) {}
A3DVector3d(const A3DVector3dData& sV) : x(sV.m_dX), y(sV.m_dY), z(sV.m_dZ) {}
inline void set(double dX, double dY, double dZ)
{ x = dX; y = dY; z = dZ; }
A3DVector3d(const A3DVector3d& toCopy) : x(toCopy.x), y(toCopy.y), z(toCopy.z) {}
inline double Length() const { return sqrt(x*x + y*y + z*z); }
inline double LenghtSquared() const{ return x*x + y*y + z*z; }
inline A3DStatus normalize()
{
double d = this->Length();
if(d == 0)
return A3D_ERROR;
x/=d;
y/=d;
z/=d;
return A3D_SUCCESS;
}
inline double Distance(const A3DVector3d& sOther) const
{
return sqrt(this->SquareDistance(sOther));
}
inline double SquareDistance(const A3DVector3d& sOther) const
{
double d=0,dd;
dd = x; dd -= sOther.x; dd *= dd; d += dd;
dd = y; dd -= sOther.y; dd *= dd; d += dd;
dd = z; dd -= sOther.z; dd *= dd; d += dd;
return d;
}
inline double Dot(const A3DVector3d& sOther) const
{
return x*sOther.x + y*sOther.y + z*sOther.z;
}
inline A3DVector3d Cross(const A3DVector3d& sOther)
{
return A3DVector3d(y*sOther.z - z*sOther.y, z*sOther.x - x*sOther.z, x*sOther.y - y*sOther.x);
}
// in-place vector algebra
inline A3DVector3d& operator += ( const A3DVector3d& sOther )
{
x+=sOther.x;
y+=sOther.y;
z+=sOther.z;
return *this;
}
inline A3DVector3d& operator -= ( const A3DVector3d& sOther )
{
x-=sOther.x;
y-=sOther.y;
z-=sOther.z;
return *this;
}
inline A3DVector3d operator + ( const A3DVector3d& sOther ) const
{
return A3DVector3d(x+sOther.x, y+sOther.y, z+sOther.z);
}
inline A3DVector3d operator - ( const A3DVector3d& sOther ) const
{
return A3DVector3d(x-sOther.x, y-sOther.y, z-sOther.z);
}
inline A3DVector3d& operator *= ( double dValue )
{
x*=dValue;
y*=dValue;
z*=dValue;
return *this;
}
inline A3DVector3d& operator /= ( double dValue )
{
x/=dValue;
y/=dValue;
z/=dValue;
return *this;
}
inline A3DVector3d operator * ( double dValue ) const
{
return A3DVector3d(x*dValue, y*dValue, z*dValue);
}
inline A3DVector3d operator / ( double dValue ) const
{
return A3DVector3d(x/dValue, y/dValue, z/dValue);
}
};
#endif

312
exchange/exchangesource/Collision/visitor/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);
A3DTopoBrepDataGet(pBrep, &m_sBrepData);
}
A3DBrepDataConnector::~A3DBrepDataConnector()
{
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(A3DTopoBodyGet(psTopoBody, &sA3DTopoBodyData));
A3DTopoContext* psContext = sA3DTopoBodyData.m_pContext;
A3DTopoContextData sA3DTopoContextData;
A3D_INITIALIZE_DATA( A3DTopoContextData, sA3DTopoContextData);
CHECK_RET(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);
A3DTopoConnexGet(pConnex, &m_sConnexData);
}
A3DConnexConnector::~A3DConnexConnector()
{
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);
A3DTopoShellGet(pShell, &m_sShellData);
}
A3DShellConnector::~A3DShellConnector()
{
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);
A3DTopoFaceGet(pFace, &m_sFaceData);
}
A3DFaceConnector::~A3DFaceConnector()
{
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);
A3DTopoLoopGet(pLoop, &m_sLoopData);
}
A3DLoopConnector::~A3DLoopConnector()
{
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);
A3DTopoCoEdgeGet(pCoEdge, &m_sCoEdgeData);
}
A3DCoEdgeConnector::~A3DCoEdgeConnector()
{
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);
A3DTopoEdgeGet(pEdge, &m_sEdgeData);
}
A3DEdgeConnector::~A3DEdgeConnector()
{
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(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(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);
A3DTopoUniqueVertexGet(pVertex, &m_sVertexData);
}
A3DUniqueVertexConnector::~A3DUniqueVertexConnector()
{
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);
A3DTopoMultipleVertexGet(pVertex, &m_sVertexData);
}
A3DMultipleVertexConnector::~A3DMultipleVertexConnector()
{
A3DTopoMultipleVertexGet(NULL, &m_sVertexData);
}
A3DStatus A3DMultipleVertexConnector::Traverse(A3DVisitorContainer* psVisitor) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
return A3D_SUCCESS;
}

146
exchange/exchangesource/Collision/visitor/BrepTraverse.h Normal file
View File

@@ -0,0 +1,146 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef TOPO_TRAVERSE
#define TOPO_TRAVERSE
#include "Connector.h"
class A3DVisitor;
////////////////////////////////////////////////
// Brep
////////////////////////////////////////////////
class A3DBrepDataConnector : public A3DConnector
{
public:
A3DTopoBrepDataData m_sBrepData;
A3DBrepDataConnector(const A3DTopoBrepData *pBrep);
~A3DBrepDataConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor) const;
};
////////////////////////////////////////////////
// connex
////////////////////////////////////////////////
class A3DConnexConnector : public A3DConnector
{
public:
A3DTopoConnexData m_sConnexData;
A3DConnexConnector(const A3DTopoConnex *pConnex);
~A3DConnexConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor) const;
};
////////////////////////////////////////////////
// Shell
////////////////////////////////////////////////
class A3DShellConnector : public A3DConnector
{
public:
A3DTopoShellData m_sShellData;
A3DShellConnector(const A3DTopoShell *pShell);
~A3DShellConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor) const;
};
////////////////////////////////////////////////
// Face
////////////////////////////////////////////////
class A3DFaceConnector : public A3DConnector
{
public:
A3DTopoFaceData m_sFaceData;
A3DFaceConnector(const A3DTopoFace *pFace);
~A3DFaceConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor) const;
};
////////////////////////////////////////////////
// Loop
////////////////////////////////////////////////
class A3DLoopConnector : public A3DConnector
{
public:
A3DTopoLoopData m_sLoopData;
A3DLoopConnector(const A3DTopoLoop *pLoop);
~A3DLoopConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor) const;
};
////////////////////////////////////////////////
// CoEdge
////////////////////////////////////////////////
class A3DCoEdgeConnector : public A3DConnector
{
public:
A3DTopoCoEdgeData m_sCoEdgeData;
A3DCoEdgeConnector(const A3DTopoCoEdge *pCoEdge);
~A3DCoEdgeConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor) const;
};
////////////////////////////////////////////////
// Edge
////////////////////////////////////////////////
class A3DEdgeConnector : public A3DConnector
{
public:
A3DTopoEdgeData m_sEdgeData;
A3DEdgeConnector(const A3DTopoEdge *pEdge);
~A3DEdgeConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor) const;
};
////////////////////////////////////////////////
// Vertex
////////////////////////////////////////////////
class A3DUniqueVertexConnector : public A3DConnector
{
public:
A3DTopoUniqueVertexData m_sVertexData;
A3DUniqueVertexConnector(const A3DTopoVertex *pVertex);
~A3DUniqueVertexConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor) const;
};
class A3DMultipleVertexConnector : public A3DConnector
{
public:
A3DTopoMultipleVertexData m_sVertexData;
A3DMultipleVertexConnector(const A3DTopoVertex *pVertex);
~A3DMultipleVertexConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor) const;
};
#endif

213
exchange/exchangesource/Collision/visitor/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);
A3DMiscCascadedAttributesGet(pAttr, &(m_sCascadedAttributeData));
}
ColorMaterialsConnector::~ColorMaterialsConnector()
{
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(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 = 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)
{
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)
{
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)
{
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)
{
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;
}

59
exchange/exchangesource/Collision/visitor/CascadedAttributeConnector.h Normal file
View File

@@ -0,0 +1,59 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_CASCADED_ATTRIBUTE_CLASS
#define A3D_CASCADED_ATTRIBUTE_CLASS
#include "Connector.h"
class ColorMaterialsConnector : public A3DConnector
{
public:
A3DMiscCascadedAttributesData m_sCascadedAttributeData;
ColorMaterialsConnector(A3DMiscCascadedAttributes* pAttr);
virtual ~ColorMaterialsConnector();
bool IsShow();
bool IsRemoved();
bool IsTexture();
bool IsMaterial();
//A3DStatus GetMaterial(A3DMaterial& sMaterial);
enum eMaterialState
{
eBAD_Emissive = 1,
eBAD_Diffuse = 2,
eBAD_Ambient = 4,
eBAD_Specular = 8
};
int GetMaterial(double dEmisive[4], double dDiffuse[4], double dAmbient[4], double dSpecular[4], double& dShininess);
bool IsRGBColor();
A3DStatus GetRGB(double adRG[4]);
//From 0 (transparent) to 255 (opaque).
bool IsTranparent();
A3DStatus Transparency(unsigned char& cTransparenty);
A3DStatus Compare(
ColorMaterialsConnector const & sOtherCascadedAttribute,
bool& bSameColor,
bool& bSameFaceColor);
};
#endif

35
exchange/exchangesource/Collision/visitor/Connector.h Normal file
View File

@@ -0,0 +1,35 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_CONNECTOR
#define A3D_CONNECTOR
#include <A3DSDKIncludes.h>
//#include <A3DInternalExports.h>
#ifndef WIN32
#define strcpy_s(dst, dst_size, src) strcpy((dst), (src))
#endif
class A3DConnector
{
protected:
const A3DEntity* m_pEntity;
A3DConnector(const A3DEntity* pEntity) : m_pEntity(pEntity) {}
A3DConnector() {};
public:
const A3DEntity* GetA3DEntity() const { return m_pEntity; }
virtual A3DEEntityType GetType() const { return kA3DTypeUnknown; }
};
#endif

653
exchange/exchangesource/Collision/visitor/MarkupTessConnector.cpp Normal file
View File

@@ -0,0 +1,653 @@
/***********************************************************************************************************************
*
* 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"
#include <assert.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();
assert(uSize > 0);
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();
assert(uSize > 0);
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;
//Geometrical data
//std::vector<double> m_adPoints;
//std::vector<int> m_aiPolylineIndices;
//std::vector<double> m_adPolylineCoords;
//std::vector<double> m_adTriangleList;
//std::vector<double> m_adCylinder; // n x (m_dRadiusBase, m_dRadiusTop, m_dHeight)
//Text
//std::vector<A3DPMITextEntry*> m_apTexts;
}
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 - Faceview
// 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
{
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
{
// Ex : turbine de N2688
// 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
{
// Ex : turbine de N2688
// 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;
}

216
exchange/exchangesource/Collision/visitor/MarkupTessConnector.h Normal file
View File

@@ -0,0 +1,216 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_MKP_CONNECTOR
#define A3D_MKP_CONNECTOR
#include <vector>
#include "Connector.h"
#include <assert.h>
#include <stdlib.h>
/*********************************************************************************************
A3DMarkupTessDataConnectorCreator is in charge of creating new A3DMarkupTessConnector
each time a graphical state change when traversing markup tessellation structure
At the end, A3DMarkupTessDataConnectorCreator ensure that
Tesselated data (point, polyline, triangles, Cone, text) that have the same Graphical data
(color, linestyle , pattern) and same local Matrix are group in the same MarkupTessConnector
**********************************************************************************************/
class A3DMarkupTessConnector;
class A3DMarkupTessDataConnectorCreator
{
public:
A3DMarkupTessDataConnectorCreator(std::vector<A3DMarkupTessConnector*>& a_rvMkpTessConnector);
~A3DMarkupTessDataConnectorCreator();
A3DStatus pushMatrix(const double* a_pdLocalMatrix);
A3DStatus popMatrix();
const double* GetCurrentWorldMatrix() { return &m_adCurrentWorldMatrix[0]; }
A3DMarkupTessConnector& GetMarkupTessConnector(const double* pdMatrix);
A3DMarkupTessConnector& GetMarkupTessConnector(unsigned uiExtraDataValue, bool& bCameraDependant);
bool HasStartToDrawSet() const { return m_bStartToDrawSet; }
private:
// assignement operator can't work because of the ref member (std::vector<A3DMarkupTessConnector*>&)
A3DMarkupTessDataConnectorCreator& operator= (const A3DMarkupTessDataConnectorCreator&) { assert(false); return *this; }
private:
bool m_bStartToDrawSet;
//Camera dependant Parameter:
bool m_bFaceViewActivated;
bool m_bFramedrawActivated;
bool m_bFixedSizeActivated;
std::vector<A3DMarkupTessConnector*>& m_rvMarkupTessData;
double m_adCurrentWorldMatrix[16];
std::vector<double> m_adPushedWorldMatrices;
};
/*********************************************************************************************
PMI Text entry
*********************************************************************************************/
class A3DPMITextEntry
{
public:
A3DPMITextEntry() : m_dTextWidth(0.0), m_dTextHeight(0.0f), m_apcText(NULL) {}
A3DPMITextEntry(A3DDouble a_dTextWidth, A3DDouble a_dTextHeight,
A3DFontKeyData const& a_rFontKeyData, A3DUTF8Char* a_apcText) :
m_dTextWidth(a_dTextWidth), m_dTextHeight(a_dTextHeight), m_oFontKeyData(a_rFontKeyData)
{
SetText(a_apcText);
}
~A3DPMITextEntry()
{
free(m_apcText);
}
void SetTextWidth(A3DDouble a_dValue) { m_dTextWidth = a_dValue; }
void SetTextHeight(A3DDouble a_dValue) { m_dTextHeight = a_dValue; }
A3DDouble GetTextWidth() const { return m_dTextWidth; }
A3DDouble GetTextHeight() const { return m_dTextHeight; }
void SetText(A3DUTF8Char const * a_apcText)
{
auto iSize = strlen(a_apcText);
m_apcText = (A3DUTF8Char*)malloc(iSize + 1);
strcpy_s(m_apcText, iSize + 1, a_apcText);
}
A3DUTF8Char* GetText() const { return m_apcText; }
A3DFontKeyData const& GetFontKeyData() { return m_oFontKeyData; }
private:
A3DDouble m_dTextWidth;
A3DDouble m_dTextHeight;
A3DFontKeyData m_oFontKeyData;
A3DUTF8Char* m_apcText;
};
/*********************************************************************************************
Markup Tessellation
**********************************************************************************************/
class A3DMarkupTessConnector : public A3DConnector
{
friend class A3DMarkupConnector;
friend class A3DMarkupTessDataConnectorCreator;
public:
A3DMarkupTessConnector();
A3DMarkupTessConnector(A3DMarkupTessConnector& a_PreviousTessConnector);
~A3DMarkupTessConnector();
bool HasAlreadySomethingToDisplay() const { return (m_adPoints.size() != 0) || (m_adPolylineCoords.size() != 0)
|| (m_aiPolylineIndices.size() != 0)
|| (m_adTriangleList.size() != 0) || (m_adCylinder.size() != 0)
|| (m_apTexts.size() != 0); }
// Geometrical Data
std::vector<double> const& GetPolyLineCoords() const { return m_adPolylineCoords; }
std::vector<int> const& GetPolyLineIndices() const { return m_aiPolylineIndices; }
std::vector<A3DPMITextEntry*> const& GetTextEntries() const { return m_apTexts; }
std::vector<double> const& GetTriangles() const { return m_adTriangleList; }
std::vector<double> const& GetCylinder() const { return m_adCylinder;}
std::vector<double> const& GetPoints() const { return m_adPoints;}
// Transfo
double const * GetWorldMatrix() const { return &m_adWorldMatrix[0]; }
void GetFrameDrawWorldOffset(double a_adOfs[3]) const
{ memcpy(a_adOfs, m_adViewDependantParameter, sizeof(m_adViewDependantParameter)); }
A3DStatus ComputeCameraDependantMatrix( double const * pdProjMatrix,
int const * aiViewport,
long const * Rect, // TOP_LEFT(X,Y) BOTTOM_RIGHT(X,Y)
double* m_adPerViewMatrix);
bool IsHidden() const { return (m_ucBehaviour&0x01) == 0 ? false : true; }
bool HasFrame() const { return (m_ucBehaviour&0x02) == 0 ? false : true; }
bool IsNotModifiable() const { return (m_ucBehaviour&0x04) == 0 ? false : true; }
bool IsZoomable() const { return (m_ucBehaviour&0x08) == 0 ? false : true; }
bool IsOnTop() const { return (m_ucBehaviour&0x10) == 0 ? false : true; }
bool IsFacingView() const { return m_bFaceView ; }
bool IsFrameDraw() const { return m_bFrameDraw ; }
bool HasColorSetup() const { return m_adRGB[0] >= 0.0; }
// Graphic
void GetColor(double a_adRGB[3]) const
{
memcpy(a_adRGB, m_adRGB, sizeof(m_adRGB));
}
double GetLineWidth() const { return m_dLineWidth;}
int GetStyleIndexLineStyle() const { return m_iGraphStyleIndexLinsStyle;}
int GetPicturePattennIndex() const { return m_iGraphVPicturePatternIndex;}
private:
static A3DStatus GetMarkupTessellation( const A3DTessBaseData& sTessBaseData,
const A3DTessMarkupData* pTessMarkupData,
const bool bIsText,
std::vector<A3DMarkupTessConnector*>& asMarkupTessDataConnector,
double a_dParallelToScreenPMIScale);
private:
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4251) // Suppress the warning C4251 because it leads to have that kind of warning : "warning
// C4251: 'A3DVisitorColorMaterials::m_apsCascadedAttribute' : class 'std::vector<_Ty>' needs to have dll-interface to
// be used by clients of class 'A3DVisitorColorMaterials"
// This is because of the "dllexport" on the visitor classes, as they use stl members and it seems that stl causes
// warning with dllexport with microsoft compiler
#endif // _MSC_VER
// Parameter useful to compute camera dependant Matrix
bool m_bFaceView;
bool m_bFrameDraw;
bool m_bSymbol;
bool m_bFixedSize;
bool m_bIsText;
double m_adViewDependantParameter[3];
unsigned m_uiFixedSizePatternIndex;
char m_ucBehaviour;
double m_adModelMatrix[16];
double m_adProjMatrix[16];
//Transfo
double m_adWorldMatrix[16];
//Graphic
double m_adRGB[3];
double m_dLineWidth;
int m_iGraphStyleIndexLinsStyle;
int m_iGraphVPicturePatternIndex;
//Geometrical data
std::vector<double> m_adPoints;
std::vector<int> m_aiPolylineIndices;
std::vector<double> m_adPolylineCoords;
std::vector<double> m_adTriangleList;
std::vector<double> m_adCylinder; // n x (m_dRadiusBase, m_dRadiusTop, m_dHeight)
//Text
std::vector<A3DPMITextEntry*> m_apTexts;
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
};
#endif

228
exchange/exchangesource/Collision/visitor/MarkupTraverse.cpp Normal file
View File

@@ -0,0 +1,228 @@
/***********************************************************************************************************************
*
* 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 = 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);
/*A3DStatus iRet=*/sMarkupConnector.TraverseMarkup(pVisitor);
pVisitor->visitLeave(*this);
return A3D_SUCCESS;
}
A3DStatus A3DMarkupConnector::TraverseMarkupTessellation(std::vector<A3DMarkupTessConnector*>& asMarkupTessConnector,
double a_dParallelToScreenPMIScale)
{
A3DStatus iRet = A3D_SUCCESS;
A3DTessMarkupData sMarkupTessData;
A3D_INITIALIZE_DATA(A3DTessMarkupData, sMarkupTessData);
CHECK_RET(A3DTessMarkupGet(m_sMarkupData.m_pTessellation, &sMarkupTessData));
A3DTessBaseData sTessBaseData;
A3D_INITIALIZE_DATA(A3DTessBaseData, sTessBaseData);
CHECK_RET(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(A3DTessBaseGet(NULL, &sTessBaseData));
CHECK_RET(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(A3DMkpLeaderGet(psLeader, &sMarkupLeaderData));
A3DTessMarkupData sMarkupLeaderTessData;
A3D_INITIALIZE_DATA(A3DTessMarkupData, sMarkupLeaderTessData);
CHECK_RET(A3DTessMarkupGet(sMarkupLeaderData.m_pTessellation, &sMarkupLeaderTessData));
A3DTessBaseData sLeaderTessBaseData;
A3D_INITIALIZE_DATA(A3DTessBaseData, sLeaderTessBaseData);
CHECK_RET(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(A3DTessBaseGet(NULL, &sLeaderTessBaseData));
CHECK_RET(A3DTessMarkupGet(NULL, &sMarkupLeaderTessData));
CHECK_RET(A3DMkpLeaderGet(NULL, &sMarkupLeaderData));
}
return A3D_SUCCESS;
}
A3DStatus A3DMarkupConnector::TraverseMarkup(A3DVisitorContainer* pVisitor)
{
pVisitor->visitEnter(*this);
A3DEEntityType eType = kA3DTypeUnknown;
A3DStatus iRet = 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;
}

198
exchange/exchangesource/Collision/visitor/MarkupTraverse.h Normal file
View File

@@ -0,0 +1,198 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_MARKUP_TRAVERSE
#define A3D_MARKUP_TRAVERSE
#include <vector>
#include "Connector.h"
/*########################################################################
Markup Hierarchy
##########################################################################*/
class A3DVisitorContainer;
class A3DMkpAnnotationEntityConnector : public A3DConnector
{
public:
A3DMkpAnnotationEntityConnector(const A3DMkpAnnotationEntity *pAnnotEntity)
: A3DConnector(pAnnotEntity) {}
~A3DMkpAnnotationEntityConnector(){}
A3DStatus TraverseAnnotationEntity(A3DVisitorContainer* psVisitor);
};
class A3DMkpAnnotationSetConnector : public A3DConnector
{
public:
A3DMkpAnnotationSetConnector(const A3DMkpAnnotationSet *pAnnotSet) : A3DConnector(pAnnotSet)
{
A3D_INITIALIZE_DATA( A3DMkpAnnotationSetData, m_sAnnotSetData);
A3DMkpAnnotationSetGet(pAnnotSet,&m_sAnnotSetData);
}
~A3DMkpAnnotationSetConnector()
{
A3DMkpAnnotationSetGet(NULL, &m_sAnnotSetData);
}
A3DStatus TraverseAnnotationSet(A3DVisitorContainer* pVisitor);
public :
A3DMkpAnnotationSetData m_sAnnotSetData;
};
class A3DMkpAnnotationReferenceConnector : public A3DConnector
{
public:
A3DMkpAnnotationReferenceConnector(const A3DMkpAnnotationReference *pAnnotReference) : A3DConnector(pAnnotReference)
{
A3D_INITIALIZE_DATA( A3DMkpAnnotationReferenceData, m_sAnnotReferenceData);
A3DMkpAnnotationReferenceGet(pAnnotReference,&m_sAnnotReferenceData);
}
~A3DMkpAnnotationReferenceConnector()
{
A3DMkpAnnotationReferenceGet(NULL, &m_sAnnotReferenceData);
}
A3DStatus TraverseAnnotationReference(A3DVisitorContainer* pVisitor);
public :
A3DMkpAnnotationReferenceData m_sAnnotReferenceData;
};
class A3DMkpAnnotationItemConnector : public A3DConnector
{
public:
A3DMkpAnnotationItemConnector(const A3DMkpAnnotationItem *pAnnotItem) : A3DConnector(pAnnotItem)
{
A3D_INITIALIZE_DATA( A3DMkpAnnotationItemData, m_sAnnotItemData);
A3DMkpAnnotationItemGet(pAnnotItem,&m_sAnnotItemData);
}
~A3DMkpAnnotationItemConnector()
{
A3DMkpAnnotationItemGet(NULL, &m_sAnnotItemData);
}
A3DStatus TraverseAnnotationItem(A3DVisitorContainer* pVisitor);
public:
A3DMkpAnnotationItemData m_sAnnotItemData;
};
class A3DMarkupTessConnector;
class A3DMarkupConnector : public A3DConnector
{
public:
A3DMarkupConnector(const A3DMkpMarkup *pMarkup) : A3DConnector(pMarkup)
{
A3D_INITIALIZE_DATA( A3DMkpMarkupData, m_sMarkupData);
A3DMkpMarkupGet(pMarkup,&m_sMarkupData);
}
~A3DMarkupConnector()
{
A3DMkpMarkupGet(NULL, &m_sMarkupData);
}
A3DStatus TraverseMarkup(A3DVisitorContainer* pVisitor);
A3DStatus TraverseMarkupTessellation(std::vector<A3DMarkupTessConnector*>& asMarkupTessConnector,
double a_dParallelToScreenPMIScale);
public:
A3DMkpMarkupData m_sMarkupData;
};
class A3DMarkupDimensionConnector : public A3DConnector
{
public:
A3DMarkupDimensionConnector(const A3DMarkupDimension *pMarkup) : A3DConnector(pMarkup)
{
A3D_INITIALIZE_DATA( A3DMarkupDimensionData, m_sDimensionData);
A3DMarkupDimensionGet(pMarkup,&m_sDimensionData);
}
~A3DMarkupDimensionConnector()
{
A3DMarkupDimensionGet(NULL, &m_sDimensionData);
}
A3DStatus TraverseDimension(A3DVisitorContainer* pVisitor);
public:
A3DMarkupDimensionData m_sDimensionData;
};
class A3DMarkupDatumConnector : public A3DConnector
{
public:
A3DMarkupDatumConnector(const A3DMarkupDatum *pMarkup) : A3DConnector(pMarkup)
{
A3D_INITIALIZE_DATA( A3DMarkupDatumData, m_sDatumData);
A3DMarkupDatumGet(pMarkup,&m_sDatumData);
}
~A3DMarkupDatumConnector()
{
A3DMarkupDatumGet(NULL, &m_sDatumData);
}
A3DStatus TraverseDatum(A3DVisitorContainer* pVisitor);
public:
A3DMarkupDatumData m_sDatumData;
};
class A3DMarkupGDTConnector : public A3DConnector
{
public:
A3DMarkupGDTConnector(const A3DMarkupGDT *pMarkup) : A3DConnector(pMarkup)
{
A3D_INITIALIZE_DATA( A3DMarkupGDTData, m_sGDTData);
A3DMarkupGDTGet(pMarkup,&m_sGDTData);
}
~A3DMarkupGDTConnector()
{
A3DMarkupGDTGet(NULL, &m_sGDTData);
}
A3DStatus TraverseGDT(A3DVisitorContainer* pVisitor);
public:
A3DMarkupGDTData m_sGDTData;
};
#endif //A3D_MARKUP_TRAVERSE

688
exchange/exchangesource/Collision/visitor/Matrix.cpp Normal file
View File

@@ -0,0 +1,688 @@
/***********************************************************************************************************************
*
* 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 "Matrix.h"
#include <math.h>
#include <float.h>
#include "A3DVector.h"
////////////////////////////////////////////////////////////////////////
// A3DMatrix4x4
///////////////////////////////////////////////////////////////////////
A3DStatus A3DMatrix4x4::CreateIdentity(A3DMatrix4x4*& psIdentity)
{
// by default A3DMatrix4x4() call a ResetToIdentity
psIdentity = new A3DMatrix4x4();
return A3D_SUCCESS;
}
A3DMatrix4x4 A3DMatrix4x4 :: operator * (const A3DMatrix4x4& matrix) const
{
A3DMatrix4x4 result;
for (int i=0;i<4;i++)
{
for (int j=0;j<4;j++)
{
result.m_adM[i+4*j] = 0.;
for (int k=0;k<4;k++)
result.m_adM[i+4*j] += m_adM[i+4*k] * matrix.m_adM[k+4*j];
}
}
return result;
}
A3DVector3d A3DMatrix4x4 :: operator * (const A3DVector3d& v) const
{
A3DVector3d Result;
Result.x = m_adM[0] * v.x + m_adM[4] * v.y + m_adM[8] * v.z + m_adM[12];
Result.y = m_adM[1] * v.x + m_adM[5] * v.y + m_adM[9] * v.z + m_adM[13];
Result.z = m_adM[2] * v.x + m_adM[6] * v.y + m_adM[10] * v.z + m_adM[14];
return Result;
}
A3DStatus A3DMatrix4x4::Invert(A3DMatrix4x4& sResult)
{
return Invert4x4(m_adM, sResult.m_adM);
}
A3DStatus A3DMatrix4x4::GetTranslation(A3DVector3d& sTranslation)
{
sTranslation.x = m_adM[12];
sTranslation.y = m_adM[13];
sTranslation.z = m_adM[14];
return A3D_SUCCESS;
}
void A3DMatrix4x4::ResetToIdentity()
{
memset(m_adM, 0, sizeof(double) * 16);
m_adM[0] = m_adM[5] = m_adM[10] = m_adM[15] = 1;
}
bool A3DMatrix4x4::IsIdentity() const
{
if((m_adM[0] != 1.0) || (m_adM[1] != 0.0) || (m_adM[2] != 0.0) || (m_adM[3] != 0.0)
|| (m_adM[4] != 0.0) || (m_adM[5] != 1.0) || (m_adM[6] != 0.0) || (m_adM[7] != 0.0)
|| (m_adM[8] != 0.0) || (m_adM[9] != 0.0) || (m_adM[10] != 1.0) || (m_adM[11] != 0.0)
|| (m_adM[12] != 0.0) || (m_adM[13] != 0.0) || (m_adM[14] != 0.0) || (m_adM[15] != 1.0))
{
return false;
}
return true;
}
void A3DMatrix4x4::GetTranslation( double& rdTX, double& rdTY, double& rdTZ ) const
{
rdTX = m_adM[12];
rdTY = m_adM[13];
rdTZ = m_adM[14];
}
void A3DMatrix4x4::GetScales( double& rdSX, double& rdSY, double& rdSZ ) const
{
rdSX = sqrt(m_adM[0]*m_adM[0] + m_adM[1]*m_adM[1] + m_adM[2]*m_adM[2]);
rdSY = sqrt(m_adM[4]*m_adM[4] + m_adM[5]*m_adM[5] + m_adM[6]*m_adM[6]);
rdSZ = sqrt(m_adM[8]*m_adM[8] + m_adM[9]*m_adM[9] + m_adM[10]*m_adM[10]);
}
void A3DMatrix4x4::GetXYZRadianAngles( double& rdXAngle, double& rdYAngle, double& rdZAngle ) const
{
//matrix3x3 of rotation without scale
double dSx, dSy, dSz;
GetScales(dSx, dSy, dSz);
double rot[9];
rot[0] = m_adM[0]/dSx; rot[3] = m_adM[4]/dSy; rot[6] = m_adM[8]/dSz;
rot[1] = m_adM[1]/dSx; rot[4] = m_adM[5]/dSy; rot[7] = m_adM[9]/dSz;
rot[2] = m_adM[2]/dSx; rot[5] = m_adM[6]/dSy; rot[8] = m_adM[10]/dSz;
// rdYAngle = asin(rot[2]); //attitude :
// if(rdYAngle < A3D_HALF_PI)
// if(rdYAngle > - A3D_HALF_PI)
// {
// rdXAngle = atan2(-rot[5], rot[8]);//bank : rotation along the "look at axis" (1 0 0)
// rdZAngle = atan2(-rot[1], rot[0]);//heading : rotation along up axis (0 0 1)
// }
// else
// {
// rdZAngle = 0.0; // multiple solutions
// rdXAngle = -atan2(rot[4], rot[5]);
// }
// else
// {
// rdZAngle = 0.0; // multiple solutions
// rdXAngle = atan2(rot[4], rot[5]);
// }
if(rot[1] > 0.998)
{
rdZAngle = atan2(rot[6], rot[8]);
rdYAngle = A3D_HALF_PI;
rdXAngle = 0.0;
}
else if(rot[1] < -.998)
{
rdZAngle = atan2(rot[6], rot[8]);
rdYAngle = -A3D_HALF_PI;
rdXAngle = 0.0;
}
else
{
rdZAngle = atan2(-rot[2], rot[0]);
rdYAngle = asin(rot[1]);
if(rot[7] == 0.0 && rot[4] == 0)
{
int sign = (rot[7] > 0) - (rot[7] < 0);
if(sign >= 0)
rdXAngle = A3D_HALF_PI;
else
rdXAngle = -A3D_HALF_PI;
}
else
rdXAngle = atan2(-rot[7], rot[4]);
}
//
// double cX = cos(rdXAngle);
// double sX = sin(rdXAngle);
// double cY = cos(rdYAngle);
// double sY = sin(rdYAngle);
// double cZ = cos(rdZAngle);
// double sZ = sin(rdZAngle);
//
// A3DMatrix4x4 testResult;
// testResult.m_adM[0] = cZ*cY; testResult.m_adM[4] = -cZ*sY*cX + sZ*sX; testResult.m_adM[8] = cZ*sY*sX + sZ*cX;
// testResult.m_adM[1] = sY; testResult.m_adM[5] = cY*cX; testResult.m_adM[9] = -cY*sX;
// testResult.m_adM[2] = -sZ*cY; testResult.m_adM[6] = sZ*sY*cX + cZ*sX; testResult.m_adM[10] = -sZ*sY*sX + cZ*cX;
// bool bRes = testResult.Compare(this);
}
void A3DMatrix4x4::setRotations(double const& dXAngle, double const& dYAngle, double const& dZAngle)
{
// Real fCos, fSin;
// fCos = Math::Cos(fYAngle);
// fSin = Math::Sin(fYAngle);
// Matrix3 kXMat(1.0,0.0,0.0,0.0,fCos,-fSin,0.0,fSin,fCos);
//
// fCos = Math::Cos(fPAngle);
// fSin = Math::Sin(fPAngle);
// Matrix3 kYMat(fCos,0.0,fSin,0.0,1.0,0.0,-fSin,0.0,fCos);
//
// fCos = Math::Cos(fRAngle);
// fSin = Math::Sin(fRAngle);
// Matrix3 kZMat(fCos,-fSin,0.0,fSin,fCos,0.0,0.0,0.0,1.0);
//
// *this = kXMat*(kYMat*kZMat);
double dCos, dSin;
dCos = cos(dXAngle);
dSin = sin(dXAngle);
A3DMatrix4x4 AX;
AX.m_adM[5] = dCos;
AX.m_adM[6] = -dSin;
AX.m_adM[9] = dSin;
AX.m_adM[10] = dCos;
dCos = cos(dYAngle);
dSin = sin(dYAngle);
A3DMatrix4x4 AY;
AY.m_adM[0] = dCos;
AY.m_adM[2] = dSin;
AY.m_adM[8] = -dSin;
AY.m_adM[10] = dCos;
dCos = cos(dZAngle);
dSin = sin(dZAngle);
A3DMatrix4x4 AZ;
AZ.m_adM[0] = dCos;
AZ.m_adM[1] = -dSin;
AZ.m_adM[4] = dSin;
AZ.m_adM[5] = dCos;
*this = AX * (AY * AZ);
}
bool A3DMatrix4x4::Compare( A3DMatrix4x4 const& rOther, double dTol ) const
{
if(dTol != 0.0)
{
for(int i =0; i < 16; i++)
{
if(m_adM[i] != rOther.m_adM[i])
return false;
}
}
else
{
for(int i =0; i < 16; i++)
{
if(fabs(m_adM[i] - rOther.m_adM[i]) < dTol)
return false;
}
}
return true;
}
static void MultMatrixVecd(const double matrix[16],
const double in[4],
double out[4])
{
int i;
for (i=0; i<4; i++) {
out[i] =
in[0] * matrix[0*4+i] +
in[1] * matrix[1*4+i] +
in[2] * matrix[2*4+i] +
in[3] * matrix[3*4+i];
}
}
/*
** Invert 4x4 matrix.
** Contributed by David Moore (See Mesa bug #6748)
*/
static bool InvertMatrixd(const double m[16], double invOut[16])
{
double inv[16], det;
int i;
inv[0] = m[5]*m[10]*m[15] - m[5]*m[11]*m[14] - m[9]*m[6]*m[15]
+ m[9]*m[7]*m[14] + m[13]*m[6]*m[11] - m[13]*m[7]*m[10];
inv[4] = -m[4]*m[10]*m[15] + m[4]*m[11]*m[14] + m[8]*m[6]*m[15]
- m[8]*m[7]*m[14] - m[12]*m[6]*m[11] + m[12]*m[7]*m[10];
inv[8] = m[4]*m[9]*m[15] - m[4]*m[11]*m[13] - m[8]*m[5]*m[15]
+ m[8]*m[7]*m[13] + m[12]*m[5]*m[11] - m[12]*m[7]*m[9];
inv[12] = -m[4]*m[9]*m[14] + m[4]*m[10]*m[13] + m[8]*m[5]*m[14]
- m[8]*m[6]*m[13] - m[12]*m[5]*m[10] + m[12]*m[6]*m[9];
inv[1] = -m[1]*m[10]*m[15] + m[1]*m[11]*m[14] + m[9]*m[2]*m[15]
- m[9]*m[3]*m[14] - m[13]*m[2]*m[11] + m[13]*m[3]*m[10];
inv[5] = m[0]*m[10]*m[15] - m[0]*m[11]*m[14] - m[8]*m[2]*m[15]
+ m[8]*m[3]*m[14] + m[12]*m[2]*m[11] - m[12]*m[3]*m[10];
inv[9] = -m[0]*m[9]*m[15] + m[0]*m[11]*m[13] + m[8]*m[1]*m[15]
- m[8]*m[3]*m[13] - m[12]*m[1]*m[11] + m[12]*m[3]*m[9];
inv[13] = m[0]*m[9]*m[14] - m[0]*m[10]*m[13] - m[8]*m[1]*m[14]
+ m[8]*m[2]*m[13] + m[12]*m[1]*m[10] - m[12]*m[2]*m[9];
inv[2] = m[1]*m[6]*m[15] - m[1]*m[7]*m[14] - m[5]*m[2]*m[15]
+ m[5]*m[3]*m[14] + m[13]*m[2]*m[7] - m[13]*m[3]*m[6];
inv[6] = -m[0]*m[6]*m[15] + m[0]*m[7]*m[14] + m[4]*m[2]*m[15]
- m[4]*m[3]*m[14] - m[12]*m[2]*m[7] + m[12]*m[3]*m[6];
inv[10] = m[0]*m[5]*m[15] - m[0]*m[7]*m[13] - m[4]*m[1]*m[15]
+ m[4]*m[3]*m[13] + m[12]*m[1]*m[7] - m[12]*m[3]*m[5];
inv[14] = -m[0]*m[5]*m[14] + m[0]*m[6]*m[13] + m[4]*m[1]*m[14]
- m[4]*m[2]*m[13] - m[12]*m[1]*m[6] + m[12]*m[2]*m[5];
inv[3] = -m[1]*m[6]*m[11] + m[1]*m[7]*m[10] + m[5]*m[2]*m[11]
- m[5]*m[3]*m[10] - m[9]*m[2]*m[7] + m[9]*m[3]*m[6];
inv[7] = m[0]*m[6]*m[11] - m[0]*m[7]*m[10] - m[4]*m[2]*m[11]
+ m[4]*m[3]*m[10] + m[8]*m[2]*m[7] - m[8]*m[3]*m[6];
inv[11] = -m[0]*m[5]*m[11] + m[0]*m[7]*m[9] + m[4]*m[1]*m[11]
- m[4]*m[3]*m[9] - m[8]*m[1]*m[7] + m[8]*m[3]*m[5];
inv[15] = m[0]*m[5]*m[10] - m[0]*m[6]*m[9] - m[4]*m[1]*m[10]
+ m[4]*m[2]*m[9] + m[8]*m[1]*m[6] - m[8]*m[2]*m[5];
det = m[0]*inv[0] + m[1]*inv[4] + m[2]*inv[8] + m[3]*inv[12];
if (det == 0)
return false;
det = 1.0 / det;
for (i = 0; i < 16; i++)
invOut[i] = inv[i] * det;
return true;
}
static void MultMatricesd(const double a[16], const double b[16],
double r[16])
{
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
r[i*4+j] =
a[i*4+0]*b[0*4+j] +
a[i*4+1]*b[1*4+j] +
a[i*4+2]*b[2*4+j] +
a[i*4+3]*b[3*4+j];
}
}
}
A3DStatus UnProject( double winx,
double winy,
double winz,
const double modelMatrix[16],
const double projMatrix[16],
const int viewport[4],
double *objx, double *objy, double *objz)
{
double finalMatrix[16];
double in[4];
double out[4];
MultMatricesd(modelMatrix, projMatrix, finalMatrix);
if (!InvertMatrixd(finalMatrix, finalMatrix))
return A3D_ERROR;
in[0]=winx;
in[1]=winy;
in[2]=winz;
in[3]=1.0;
/* Map x and y from window coordinates */
in[0] = (in[0] - viewport[0]) / viewport[2];
in[1] = (in[1] - viewport[1]) / viewport[3];
/* Map to range -1 to 1 */
in[0] = in[0] * 2 - 1;
in[1] = in[1] * 2 - 1;
in[2] = in[2] * 2 - 1;
MultMatrixVecd(finalMatrix, in, out);
if (out[3] == 0.0)
return A3D_ERROR;
out[0] /= out[3];
out[1] /= out[3];
out[2] /= out[3];
*objx = out[0];
*objy = out[1];
*objz = out[2];
return A3D_SUCCESS;
}
A3DStatus Project(double objx,
double objy,
double objz,
const double modelMatrix[16],
const double projMatrix[16],
const int viewport[4],
double *winx,
double *winy,
double *winz)
{
double in[4];
double out[4];
in[0]=objx;
in[1]=objy;
in[2]=objz;
in[3]=1.0;
MultMatrixVecd(modelMatrix, in, out);
MultMatrixVecd(projMatrix, out, in);
if (in[3] == 0.0) return A3D_ERROR;
in[0] /= in[3];
in[1] /= in[3];
in[2] /= in[3];
/* Map x, y and z to range 0-1 */
in[0] = in[0] * 0.5 + 0.5;
in[1] = in[1] * 0.5 + 0.5;
in[2] = in[2] * 0.5 + 0.5;
/* Map x,y to viewport */
in[0] = in[0] * viewport[2] + viewport[0];
in[1] = in[1] * viewport[3] + viewport[1];
*winx=in[0];
*winy=in[1];
*winz=in[2];
return A3D_SUCCESS;
}
/*******************************************************
Multiply Matrix
********************************************************/
A3DStatus MultiplyMatrix(const double* padFather, const double* pdThisMatrix, double* pdResult)
{
A3DStatus iRet = A3D_SUCCESS;
pdResult[0] = padFather[0] * pdThisMatrix[0] + padFather[4] * pdThisMatrix[1] + padFather[8] * pdThisMatrix[2] + padFather[12] * pdThisMatrix[3];
pdResult[1] = padFather[1] * pdThisMatrix[0] + padFather[5] * pdThisMatrix[1] + padFather[9] * pdThisMatrix[2] + padFather[13] * pdThisMatrix[3];
pdResult[2] = padFather[2] * pdThisMatrix[0] + padFather[6] * pdThisMatrix[1] + padFather[10] * pdThisMatrix[2] + padFather[14] * pdThisMatrix[3];
pdResult[3] = padFather[3] * pdThisMatrix[0] + padFather[7] * pdThisMatrix[1] + padFather[11] * pdThisMatrix[2] + padFather[15] * pdThisMatrix[3];
pdResult[4] = padFather[0] * pdThisMatrix[4] + padFather[4] * pdThisMatrix[5] + padFather[8] * pdThisMatrix[6] + padFather[12] * pdThisMatrix[7];
pdResult[5] = padFather[1] * pdThisMatrix[4] + padFather[5] * pdThisMatrix[5] + padFather[9] * pdThisMatrix[6] + padFather[13] * pdThisMatrix[7];
pdResult[6] = padFather[2] * pdThisMatrix[4] + padFather[6] * pdThisMatrix[5] + padFather[10] * pdThisMatrix[6] + padFather[14] * pdThisMatrix[7];
pdResult[7] = padFather[3] * pdThisMatrix[4] + padFather[7] * pdThisMatrix[5] + padFather[11] * pdThisMatrix[6] + padFather[15] * pdThisMatrix[7];
pdResult[8] = padFather[0] * pdThisMatrix[8] + padFather[4] * pdThisMatrix[9] + padFather[8] * pdThisMatrix[10] + padFather[12] * pdThisMatrix[11];
pdResult[9] = padFather[1] * pdThisMatrix[8] + padFather[5] * pdThisMatrix[9] + padFather[9] * pdThisMatrix[10] + padFather[13] * pdThisMatrix[11];
pdResult[10] = padFather[2] * pdThisMatrix[8] + padFather[6] * pdThisMatrix[9] + padFather[10] * pdThisMatrix[10] + padFather[14] * pdThisMatrix[11];
pdResult[11] = padFather[3] * pdThisMatrix[8] + padFather[7] * pdThisMatrix[9] + padFather[11] * pdThisMatrix[10] + padFather[15] * pdThisMatrix[11];
pdResult[12] = padFather[0] * pdThisMatrix[12] + padFather[4] * pdThisMatrix[13] + padFather[8] * pdThisMatrix[14] + padFather[12] * pdThisMatrix[15];
pdResult[13] = padFather[1] * pdThisMatrix[12] + padFather[5] * pdThisMatrix[13] + padFather[9] * pdThisMatrix[14] + padFather[13] * pdThisMatrix[15];
pdResult[14] = padFather[2] * pdThisMatrix[12] + padFather[6] * pdThisMatrix[13] + padFather[10] * pdThisMatrix[14] + padFather[14] * pdThisMatrix[15];
pdResult[15] = padFather[3] * pdThisMatrix[12] + padFather[7] * pdThisMatrix[13] + padFather[11] * pdThisMatrix[14] + padFather[15] * pdThisMatrix[15];
return iRet;
}
static void MatrixVectMultiply(const double* pdMatrix,
const double* pdVect,
double* pdresult)
{
unsigned int uI;
for (uI = 0; uI < 4; uI++)
{
pdresult[uI] =
pdVect[0] * pdMatrix[uI] +
pdVect[1] * pdMatrix[4+uI] +
pdVect[2] * pdMatrix[8+uI] +
pdVect[3] * pdMatrix[12+uI];
}
}
/*******************************************************
Invert Matrix
********************************************************/
A3DStatus Calculate(double* pdX, double* pdY, double* pdZ, double* pdMat)
{
double dLenght = sqrt(pdX[0] * pdX[0] + pdX[1] * pdX[1] + pdX[2] * pdX[2]);
if(dLenght < 1e-12)
return A3D_ERROR;
pdX[0] /= dLenght; pdX[1] /= dLenght; pdX[2] /= dLenght;
dLenght = sqrt(pdY[0] * pdY[0] + pdY[1] * pdY[1] + pdY[2] * pdY[2]);
if(dLenght < 1e-12)
return A3D_ERROR;
pdY[0] /= dLenght; pdY[1] /= dLenght; pdY[2] /= dLenght;
dLenght = sqrt(pdZ[0] * pdZ[0] + pdZ[1] * pdZ[1] + pdZ[2] * pdZ[2]);
if(dLenght < 1e-12)
return A3D_ERROR;
pdZ[0] /= dLenght; pdZ[1] /= dLenght; pdZ[2] /= dLenght;
pdMat[0] = pdX[0];
pdMat[1] = pdX[1];
pdMat[2] = pdX[2];
pdMat[4] = pdY[0];
pdMat[5] = pdY[1];
pdMat[6] = pdY[2];
pdMat[8] = pdZ[0];
pdMat[9] = pdZ[1];
pdMat[10]= pdZ[2];
pdMat[3] = pdMat[7] = pdMat[11] = pdMat[12] = pdMat[13] = pdMat[14] = pdMat[15] = 0;
return A3D_SUCCESS;
}
/*******************************************************
Invert Matrix
********************************************************/
double det2x2(double a, double b, double c, double d)
{
double det;
det = a * d - b * c;
return det;
}
double det3x3(double a1, double a2, double a3,
double b1, double b2, double b3,
double c1, double c2, double c3)
{
double det;
det = a1 * det2x2(b2, b3, c2, c3)
- b1 * det2x2(a2, a3, c2, c3)
+ c1 * det2x2(a2, a3, b2, b3);
return det;
}
void adjoint(double* pdMatrix)
{
double a1, a2, a3, a4, b1, b2, b3, b4;
double c1, c2, c3, c4, d1, d2, d3, d4;
a1 = pdMatrix[0]; b1 = pdMatrix[1];
c1 = pdMatrix[2]; d1 = pdMatrix[3];
a2 = pdMatrix[4]; b2 = pdMatrix[5];
c2 = pdMatrix[6]; d2 = pdMatrix[7];
a3 = pdMatrix[8]; b3 = pdMatrix[9];
c3 = pdMatrix[10]; d3 = pdMatrix[11];
a4 = pdMatrix[12]; b4 = pdMatrix[13];
c4 = pdMatrix[14]; d4 = pdMatrix[15];
pdMatrix[0] = det3x3( b2, b3, b4, c2, c3, c4, d2, d3, d4);
pdMatrix[4] = - det3x3( a2, a3, a4, c2, c3, c4, d2, d3, d4);
pdMatrix[8] = det3x3( a2, a3, a4, b2, b3, b4, d2, d3, d4);
pdMatrix[12] = - det3x3( a2, a3, a4, b2, b3, b4, c2, c3, c4);
pdMatrix[1] = - det3x3( b1, b3, b4, c1, c3, c4, d1, d3, d4);
pdMatrix[5] = det3x3( a1, a3, a4, c1, c3, c4, d1, d3, d4);
pdMatrix[9] = - det3x3( a1, a3, a4, b1, b3, b4, d1, d3, d4);
pdMatrix[13] = det3x3( a1, a3, a4, b1, b3, b4, c1, c3, c4);
pdMatrix[2] = det3x3( b1, b2, b4, c1, c2, c4, d1, d2, d4);
pdMatrix[6] = - det3x3( a1, a2, a4, c1, c2, c4, d1, d2, d4);
pdMatrix[10] = det3x3( a1, a2, a4, b1, b2, b4, d1, d2, d4);
pdMatrix[14] = - det3x3( a1, a2, a4, b1, b2, b4, c1, c2, c4);
pdMatrix[3] = - det3x3( b1, b2, b3, c1, c2, c3, d1, d2, d3);
pdMatrix[7] = det3x3( a1, a2, a3, c1, c2, c3, d1, d2, d3);
pdMatrix[11] = - det3x3( a1, a2, a3, b1, b2, b3, d1, d2, d3);
pdMatrix[15] = det3x3( a1, a2, a3, b1, b2, b3, c1, c2, c3);
}
A3DStatus Invert4x4(const double* pdMat, double* pdMatInv)
{
double det;
int i,j;
double scale = pdMat[15];
if (fabs(scale) < FLT_MIN)
{
/*"Matrice avec Scale == 0.: inversion impossible\n"*/
return A3D_ERROR;
}
for (i=0;i<4;i++)
for (j=0;j<4;j++)
pdMatInv[i*4 + j] = pdMat[i*4 + j];
adjoint(pdMatInv);
det = det3x3(pdMat[0], pdMat[4], pdMat[8],
pdMat[1], pdMat[5], pdMat[9],
pdMat[2], pdMat[6], pdMat[10]);
if (fabs(det) < FLT_MIN)
{
/*"Matrice non reguliere: inversion impossible\n"*/
return A3D_ERROR;
}
for (i=0;i<4;i++)
for (j=0;j<4;j++)
pdMatInv[i * 4 +j] /= (scale*det);
return A3D_SUCCESS;
}
A3DStatus UnProject(const double * pPt,
const double* pdModelMatrix,
const double* pdProjMatrix,
const int* viewport,
double* pPtresult)
{
double finalMatrix[16];
double in[4];
double out[4];
MultiplyMatrix(pdModelMatrix, pdProjMatrix, finalMatrix);
if (!Invert4x4(finalMatrix, finalMatrix))
return A3D_ERROR;
in[0]=pPt[0];
in[1]=pPt[1];
in[2]=pPt[2];
in[3]=1.0;
/* Map x and y from window coordinates */
in[0] = (in[0] - viewport[0]) / viewport[2];
in[1] = (in[1] - viewport[1]) / viewport[3];
/* Map to range -1 to 1 */
in[0] = in[0] * 2 - 1;
in[1] = in[1] * 2 - 1;
in[2] = in[2] * 2 - 1;
MatrixVectMultiply(finalMatrix, in, out);
if (out[3] == 0.0)
return A3D_ERROR;
out[0] /= out[3];
out[1] /= out[3];
out[2] /= out[3];
*(pPtresult) = out[0];
*(pPtresult+1) = out[1];
*(pPtresult+2) = out[2];
double objx, objy, objz;
UnProject(pPt[0], pPt[1], pPt[2],
pdModelMatrix,
pdProjMatrix,
viewport,
&objx, &objy, &objz);
if( fabs(pPtresult[0] - objx)> 1e-12
|| fabs(pPtresult[1] - objx)> 1e-12
|| fabs(pPtresult[2] - objx)> 1e-12)
return A3D_ERROR;
return A3D_SUCCESS;
}
A3DStatus Identity(double* pdIdentity)
{
memset(&pdIdentity[0], 0, 16 * sizeof(double));
pdIdentity[0] = pdIdentity[5] = pdIdentity[10] = pdIdentity[15] = 1;
return A3D_SUCCESS;
}
A3DStatus Ortho(const double* pdCurrentMatrix,
double dLeft,
double dRight,
double dTop,
double dBottom,
double dNear,
double dFar,
double* pdOutput)
{
double adOrthoMatrix[16];
double tx = - (dRight + dLeft)/(dRight - dLeft);
double ty = - (dTop + dBottom)/(dTop - dBottom);
double tz = - (dFar + dNear)/(dFar - dNear);
adOrthoMatrix[0] = 2/(dRight - dLeft);
adOrthoMatrix[1] = 0;
adOrthoMatrix[2] = 0;
adOrthoMatrix[3] = tx;
adOrthoMatrix[4] = 0;
adOrthoMatrix[5] = 2/(dTop - dBottom);
adOrthoMatrix[6] = 0;
adOrthoMatrix[7] = ty;
adOrthoMatrix[8] = 0;
adOrthoMatrix[9] = 0;
adOrthoMatrix[10] = ( -2)/(dFar - dNear);
adOrthoMatrix[11] = tz;
adOrthoMatrix[12] = 0;
adOrthoMatrix[13] = 0;
adOrthoMatrix[14] = 0;
adOrthoMatrix[15] = 1;
MatrixVectMultiply( pdCurrentMatrix,adOrthoMatrix,pdOutput);
return A3D_SUCCESS;
}
A3DVector3dData CrossProduct(const A3DVector3dData* X, const A3DVector3dData* Y)
{
A3DVector3dData Z;
Z.m_dX=X->m_dY*Y->m_dZ - X->m_dZ*Y->m_dY;
Z.m_dY=X->m_dZ*Y->m_dX - X->m_dX*Y->m_dZ;
Z.m_dZ=X->m_dX*Y->m_dY - X->m_dY*Y->m_dX;
return Z;
}

105
exchange/exchangesource/Collision/visitor/Matrix.h Normal file
View File

@@ -0,0 +1,105 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3DMATRIX_H
#define A3DMATRIX_H
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <A3DSDKErrorCodes.h>
#include "A3DVector.h"
#define A3D_PI 3.1415926535897932384626433832795028841971693993751
#define A3D_HALF_PI 1.5707963267948966192313216916397514420985846996875
class A3DMatrix4x4
{
public:
double m_adM[16];
//column first
//m_adM[0] = m00 m_adM[4] = m01 m_adM[8] = m02 m_adM[12] = m03
//m_adM[1] = m10 m_adM[5] = m11 m_adM[9] = m12 m_adM[13] = m13
//m_adM[2] = m20 m_adM[6] = m21 m_adM[10] = m22 m_adM[14] = m23
//m_adM[3] = m30 m_adM[7] = m31 m_adM[11] = m32 m_adM[15] = m33
A3DMatrix4x4(double* pdMat) { memcpy(&m_adM[0], pdMat, sizeof(double) * 16); }
A3DMatrix4x4() { ResetToIdentity(); }
static A3DStatus CreateIdentity(A3DMatrix4x4*& psIdentity);
A3DMatrix4x4 operator * (const A3DMatrix4x4& matrix) const;
A3DVector3d operator * (const A3DVector3d& pt) const;
A3DStatus Invert(A3DMatrix4x4& sResult);
A3DStatus GetTranslation(A3DVector3d& sTranslation);
void ResetToIdentity();
bool IsIdentity() const;
void GetScales(double& rdSX, double& rdSY, double& rdSZ) const;
void GetTranslation(double& rdTX, double& rdTY, double& rdTZ) const;
void GetXYZRadianAngles(double& rdXAngle, double& rdYAngle, double& rdZAngle) const;
double const& operator[](const unsigned& u) const { return m_adM[u]; }
void setRotations(double const& dXAngle, double const& dYAngle, double const& dZAngle);
A3DMatrix4x4& operator = (const A3DMatrix4x4& rFrom)
{
memcpy(m_adM, rFrom.m_adM, sizeof(double) * 16);
return *this;
}
bool Compare(A3DMatrix4x4 const& rOther, double dTol = 0.0) const;
};
A3DStatus MultiplyMatrix(const double* padFather, const double* pdThisMatrix, double* pdResult);
A3DStatus Invert4x4(const double* pdMat, double* pdMatInv);
A3DStatus Calculate(double* pdX, double* pdY, double* pdZ, double* pdMat);
A3DStatus UnProject( const double * pPt,
const double* pdModelMatrix,
const double* pdProjMatrix,
const int* viewport,
double* pPtresult);
A3DStatus Project(double objx,
double objy,
double objz,
const double pdModelMatrix[16],
const double pdProjMatrix[16],
const int viewport[4],
double *winx,
double *winy,
double *winz);
A3DStatus Ortho(const double* pdCurrentMatrix,
double dLeft,
double dRight,
double dTop,
double dBottom,
double dNear,
double dfar,
double* pdOutput);
A3DStatus Identity(double* pdIdentity);
A3DVector3dData CrossProduct(const A3DVector3dData* X, const A3DVector3dData* Y);
static const A3DMatrix4x4 stIdentity;
#endif

1431
exchange/exchangesource/Collision/visitor/TessConnector.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

147
exchange/exchangesource/Collision/visitor/TessConnector.h Normal file
View File

@@ -0,0 +1,147 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_TESS_CONNECTOR
#define A3D_TESS_CONNECTOR
#include <vector>
#include "Connector.h"
class A3DVisitorContainer;
class A3DTessDataConnector : public A3DConnector
{
A3DTess3DData m_sTessData;
A3DTessBaseData m_sBaseTessData;
public :
A3DTessDataConnector(const A3DTess3D* pTess3D);
~A3DTessDataConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor);
unsigned FacesSize() const
{
return m_sTessData.m_uiFaceTessSize;
}
A3DStatus Points(double*& pPoint, unsigned int& uSize) const;
A3DStatus Normals(double*& pNormal, unsigned int& uSize) const;
A3DStatus UV(double*& pUV, unsigned int& uSize) const;
A3DTessBaseData const* GetBaseTessData() const { return &m_sBaseTessData; }
A3DTess3DData const* GetTess3DData() const { return &m_sTessData; }
A3DStatus IndicesAsTriangle(
std::vector<unsigned>& auTriangleWithPoint_Normals_Indices, //normal, point,normal, point,..., point
std::vector<unsigned>& auTriangleWithPoint_Normals_UV_Indices //normal, point, UV, normal, point,UV, ..., normal,point, UV
) const;
A3DStatus IndicesPerFaceAsTriangle(
const unsigned& uFaceIndice,
std::vector<unsigned>& auTriangleWithPoint_Normals_Indices,
std::vector<unsigned>& auTriangleWithPoint_Normals_UV_Indices) const;
A3DStatus Indices(
std::vector<unsigned>& auTrianglesOneNormal, //(normal, point, point,..., point)
std::vector<unsigned>& auFanOneNormal,
std::vector<unsigned>& auStripeOneNormal,
std::vector<unsigned>& auTrianglesWithNormals, //normal, point, ... , normal, point
std::vector<unsigned>& auFanWithNormals,
std::vector<unsigned>& auStripeWithNormal,
std::vector<unsigned>& auTrianglesOneNormalTexture, //normal,{texture...},point,{texture...},point,{texture...},point
std::vector<unsigned>& auFanOneNormalTextured,
std::vector<unsigned>& auStripeOneNormalTextured,
std::vector<unsigned>& auTrianglesWithNormalsTextured, //normal,{texture...},point,...,normal,{texture...},point
std::vector<unsigned>& auFanWithNormalsTextured,
std::vector<unsigned>& auStripeWithNormalsTextured) const;
A3DStatus IndicesPerFace(
const unsigned& uFaceIndice,
std::vector<unsigned>& auTrianglesOneNormal, //(normal, point, point,..., point)
std::vector<unsigned>& auFanOneNormal,
std::vector<unsigned>& auStripeOneNormal,
std::vector<unsigned>& auTrianglesWithNormals, //normal, point, ... , normal, point
std::vector<unsigned>& auFanWithNormals,
std::vector<unsigned>& auStripeWithNormal,
std::vector<unsigned>& auTrianglesOneNormalTexture, //normal,{texture...},point,{texture...},point,{texture...},point
std::vector<unsigned>& auFanOneNormalTextured,
std::vector<unsigned>& auStripeOneNormalTextured,
std::vector<unsigned>& auTrianglesWithNormalsTextured,//normal,{texture...},point,...,normal,{texture...},point
std::vector<unsigned>& auFanWithNormalsTextured,
std::vector<unsigned>& auStripeWithNormalsTextured) const;
};
class A3DFaceTessDataConnector : public A3DConnector
{
const A3DTessDataConnector* m_pTessConnector;
unsigned m_uCurrentFaceIndex;
public :
A3DFaceTessDataConnector(const A3DTessFaceData* pFaceTess3D, unsigned uCurrentFaceIndex, const A3DTessDataConnector* pTessConnector);
~A3DFaceTessDataConnector();
const A3DTessDataConnector* GetTessDataConnector() const { return m_pTessConnector; }
unsigned GetFaceIndex() const { return m_uCurrentFaceIndex; }
unsigned GetFaceNumber() const { return m_pTessConnector != NULL ? m_pTessConnector->FacesSize() : 0; }
A3DStatus Traverse(A3DVisitorContainer* psVisitor);
A3DStatus IndicesAsTriangle(
std::vector<unsigned>& auTriangleWithPoint_Normals_Indices, //normal, point,normal, point,..., point
std::vector<unsigned>& auTriangleWithPoint_Normals_UV_Indices //normal, point, UV, normal, point,UV, ..., normal,point, UV
) const;
A3DStatus ColorsAsTriangle(std::vector<A3DUns8>& auTriangleWithPoint_Colors, bool &bIsRGBA) const;
A3DStatus Indices(
std::vector<unsigned>& auTrianglesOneNormal, //(normal, point, point,..., point)
std::vector<unsigned>& auFanOneNormal,
std::vector<unsigned>& auStripeOneNormal,
std::vector<unsigned>& auTrianglesWithNormals, //normal, point, ... , normal, point
std::vector<unsigned>& auFanWithNormals,
std::vector<unsigned>& auStripeWithNormal,
std::vector<unsigned>& auTrianglesOneNormalTexture, //normal,{texture...},point,{texture...},point,{texture...},point
std::vector<unsigned>& auFanOneNormalTextured,
std::vector<unsigned>& auStripeOneNormalTextured,
std::vector<unsigned>& auTrianglesWithNormalsTextured, //normal,{texture...},point,...,normal,{texture...},point
std::vector<unsigned>& auFanWithNormalsTextured,
std::vector<unsigned>& auStripeWithNormalsTextured) const;
unsigned GetWireNumber() const;
A3DStatus GetEdgeIndices(unsigned uEdgeIndice, std::vector<unsigned>& auEdgeIndice) const;
};
class A3DWireTessDataConnector : public A3DConnector
{
A3DTess3DWireData m_sWire3DTessData;
A3DTessBaseData m_sBaseTessData;
public:
A3DWireTessDataConnector(const A3DTess3DWire* psTessWire);
~A3DWireTessDataConnector();
A3DStatus Traverse(A3DVisitorContainer* psVisitor);
A3DStatus Points(double*& pPoint, unsigned int& uSize) const;
A3DStatus Indices(std::vector<unsigned>& auPolylineIndices) const;
};
#endif

117
exchange/exchangesource/Collision/visitor/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 "TreeTraverse.h"
#include "Matrix.h"
static void stInitMatrixFromMiscTransformation(A3DMiscTransformation const * pMiscTransformation, A3DMatrix4x4 &sMatrix)
{
if (pMiscTransformation)
{
A3DStatus iRet = A3D_SUCCESS;
A3DEEntityType eType = kA3DTypeUnknown;
A3DEntityGetType (pMiscTransformation, &eType);
switch (eType)
{
case kA3DTypeMiscCartesianTransformation:
{
A3DMiscCartesianTransformationData sData;
A3D_INITIALIZE_DATA(A3DMiscCartesianTransformationData, sData);
iRet = 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 = A3DMiscCartesianTransformationGet (NULL, &sData);
}
break;
case kA3DTypeMiscGeneralTransformation:
{
A3DMiscGeneralTransformationData sData;
A3D_INITIALIZE_DATA(A3DMiscGeneralTransformationData, sData);
iRet = A3DMiscGeneralTransformationGet (pMiscTransformation, &sData);
memcpy(&(sMatrix.m_adM[0]), sData.m_adCoeff, 16 * sizeof(double));
iRet = 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;
}

44
exchange/exchangesource/Collision/visitor/TransfoConnector.h Normal file
View File

@@ -0,0 +1,44 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_TRANSFO_CONNECTOR
#define A3D_TRANSFO_CONNECTOR
#include <vector>
#include "Connector.h"
#include "Matrix.h"
class A3DVisitor;
class A3DTransfoConnector : public A3DConnector
{
friend class A3DVisitorTransfo;
A3DMatrix4x4 m_sWorldMatrix;
A3DMatrix4x4 m_sLocalMatrix;
void SetGlobalMatrix(A3DMiscTransformation const * pMiscTransformation);
void SetGlobalMatrix(A3DMatrix4x4 const& rWorldMatrix);
void ComputeGlobalMatrix(A3DMatrix4x4 const& rFatherWorldMatrix);
A3DTransfoConnector(const A3DMiscTransformation* pMiscTransformation);
public :
~A3DTransfoConnector() {}
A3DStatus GetLocalMatrix(A3DMatrix4x4& rsMatrix);
A3DStatus GetGlobalTransfo(A3DMatrix4x4& rsMatrix);
};
#endif

701
exchange/exchangesource/Collision/visitor/TreeTraverse.cpp Normal file
View File

@@ -0,0 +1,701 @@
/***********************************************************************************************************************
*
* 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 <stdlib.h>
#include "TreeTraverse.h"
#include "VisitorContainer.h"
#include "MarkupTraverse.h"
#include "ViewTraverse.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
*************************************************************************************/
A3DProductOccurrenceConnector::A3DProductOccurrenceConnector(const A3DAsmProductOccurrence* pProductOccurrence)
: A3DConnector(pProductOccurrence),
m_pProductOccurrenceDataSLW(NULL),
m_pProductOccurrenceDataCat(NULL),
m_pProductOccurrenceDataCV5(NULL),
m_pProductOccurrenceDataUg(NULL),
m_pProductOccurrenceDataProe(NULL),
m_pProductOccurrenceDataInv(NULL),
m_pProductOccurrenceDataJT(NULL)
{
m_pFather = NULL;
m_bIsInstanciated = false;
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, m_sProductOccurrenceData);
A3DAsmProductOccurrenceGet (pProductOccurrence, &m_sProductOccurrenceData);
switch (m_sProductOccurrenceData.m_eModellerType)
{
case kA3DModellerSlw:
{
m_pProductOccurrenceDataSLW = (A3DAsmProductOccurrenceDataSLW*)malloc(sizeof(A3DAsmProductOccurrenceDataSLW));
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceDataSLW, *m_pProductOccurrenceDataSLW);
A3DAsmProductOccurrenceGetSLW (pProductOccurrence, m_pProductOccurrenceDataSLW);
break;
}
case kA3DModellerCatia:
{
m_pProductOccurrenceDataCat = (A3DAsmProductOccurrenceDataCat*)malloc(sizeof(A3DAsmProductOccurrenceDataCat));
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceDataCat, *m_pProductOccurrenceDataCat);
A3DAsmProductOccurrenceGetCat (pProductOccurrence, m_pProductOccurrenceDataCat);
break;
}
case kA3DModellerCatiaV5:
{
m_pProductOccurrenceDataCV5 = (A3DAsmProductOccurrenceDataCV5*)malloc(sizeof(A3DAsmProductOccurrenceDataCV5));
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceDataCV5, *m_pProductOccurrenceDataCV5);
A3DAsmProductOccurrenceGetCV5 (pProductOccurrence, m_pProductOccurrenceDataCV5);
break;
}
case kA3DModellerUnigraphics:
{
m_pProductOccurrenceDataUg = (A3DAsmProductOccurrenceDataUg*)malloc(sizeof(A3DAsmProductOccurrenceDataUg));
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceDataUg, *m_pProductOccurrenceDataUg);
A3DAsmProductOccurrenceGetUg (pProductOccurrence, m_pProductOccurrenceDataUg);
break;
}
case kA3DModellerProE:
{
m_pProductOccurrenceDataProe = (A3DAsmProductOccurrenceDataProe*)malloc(sizeof(A3DAsmProductOccurrenceDataProe));
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceDataProe, *m_pProductOccurrenceDataProe);
A3DAsmProductOccurrenceGetProe (pProductOccurrence, m_pProductOccurrenceDataProe);
break;
}
case kA3DModellerInventor:
{
m_pProductOccurrenceDataInv = (A3DAsmProductOccurrenceDataInv*)malloc(sizeof(A3DAsmProductOccurrenceDataInv));
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceDataInv, *m_pProductOccurrenceDataInv);
A3DAsmProductOccurrenceGetInv (pProductOccurrence, m_pProductOccurrenceDataInv);
break;
}
case kA3DModellerJt:
{
m_pProductOccurrenceDataJT = (A3DAsmProductOccurrenceDataJT*)malloc(sizeof(A3DAsmProductOccurrenceDataJT));
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceDataJT, *m_pProductOccurrenceDataJT);
A3DAsmProductOccurrenceGetJT (pProductOccurrence, m_pProductOccurrenceDataJT);
break;
}
default:
break;
}
m_bIsPrototype = false;
m_bIsExternal = false;
}
A3DProductOccurrenceConnector::~A3DProductOccurrenceConnector()
{
A3DAsmProductOccurrenceGet (NULL, &m_sProductOccurrenceData);
if (m_pProductOccurrenceDataSLW)
{
A3DAsmProductOccurrenceGetSLW (NULL, m_pProductOccurrenceDataSLW);
free(m_pProductOccurrenceDataSLW);
}
if (m_pProductOccurrenceDataCat)
{
A3DAsmProductOccurrenceGetCat (NULL, m_pProductOccurrenceDataCat);
free(m_pProductOccurrenceDataCat);
}
if (m_pProductOccurrenceDataCV5)
{
A3DAsmProductOccurrenceGetCV5 (NULL, m_pProductOccurrenceDataCV5);
free(m_pProductOccurrenceDataCV5);
}
if (m_pProductOccurrenceDataUg)
{
A3DAsmProductOccurrenceGetUg (NULL, m_pProductOccurrenceDataUg);
free(m_pProductOccurrenceDataUg);
}
if (m_pProductOccurrenceDataProe)
{
A3DAsmProductOccurrenceGetProe (NULL, m_pProductOccurrenceDataProe);
free(m_pProductOccurrenceDataProe);
}
if (m_pProductOccurrenceDataInv)
{
A3DAsmProductOccurrenceGetInv (NULL, m_pProductOccurrenceDataInv);
free(m_pProductOccurrenceDataInv);
}
if (m_pProductOccurrenceDataJT)
{
A3DAsmProductOccurrenceGetJT (NULL, m_pProductOccurrenceDataJT);
free(m_pProductOccurrenceDataJT);
}
}
// 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
if (psVisitor->GetFlagElementToConnect() & 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(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(A3DAsmProductOccurrenceGet (NULL, &sProductPrototypeData));
}
}
}
#endif
#ifdef CONNECT_VIEWS
if (psVisitor->GetFlagElementToConnect() & 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(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(A3DAsmProductOccurrenceGet (NULL, &sProductPrototypeData));
}
}
else if (uNbView)
{
for (uI = 0; uI < uNbView; uI++)
{
A3DMkpViewConnector sMkpViewConnector(m_sProductOccurrenceData.m_ppViews[uI]);
sMkpViewConnector.TraverseView(psVisitor);
}
}
}
#endif
#ifdef CONNECT_FEATURE
if (psVisitor->GetFlagElementToConnect() & CONNECT_FEATURE)
{
A3DUns32 uNbFeatureBasedEntity = m_sProductOccurrenceData.m_uiFeatureBasedEntitiesSize;
if (!uNbFeatureBasedEntity && m_sProductOccurrenceData.m_pPrototype != NULL)
{
A3DAsmProductOccurrence* pProductPrototype = m_sProductOccurrenceData.m_pPrototype;
while (pProductPrototype)
{
A3DAsmProductOccurrenceData sProductPrototypeData;
A3D_INITIALIZE_DATA(A3DAsmProductOccurrenceData, sProductPrototypeData);
CHECK_RET(A3DAsmProductOccurrenceGet(pProductPrototype, &sProductPrototypeData));
uNbFeatureBasedEntity = sProductPrototypeData.m_uiFeatureBasedEntitiesSize;
for (uI = 0; uI < uNbFeatureBasedEntity; uI++)
{
A3DFRMFeatureTreeConnector sConnector(sProductPrototypeData.m_ppFeatureBasedEntities[uI]);
sConnector.TraverseFeatureTree(psVisitor);
}
pProductPrototype = sProductPrototypeData.m_pPrototype;
CHECK_RET(A3DAsmProductOccurrenceGet(NULL, &sProductPrototypeData));
}
}
else if (uNbFeatureBasedEntity)
{
for (uI = 0; uI < uNbFeatureBasedEntity; uI++)
{
A3DFRMFeatureTreeConnector sConnector(m_sProductOccurrenceData.m_ppFeatureBasedEntities[uI]);
sConnector.TraverseFeatureTree(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.SetProductOccurrenceFather(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(A3DAsmProductOccurrenceGet(pPrototype, &sPrototypeData));
pPrototype =sPrototypeData.m_pPrototype;
uSize = sPrototypeData.m_uiPOccurrencesSize;
ppPo = sPrototypeData.m_ppPOccurrences;
//TODO : Management of prototype with external assembly
//Not sur this can append. we don't have test files for validation.
/*if (pPrototype==NULL && sPrototypeData.m_pExternalData)
{
pPrototype=sPrototypeData.m_pExternalData;
}*/
CHECK_RET(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
if (psVisitor->GetFlagElementToConnect() & 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
if (psVisitor->GetFlagElementToConnect() & 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;
A3DEntityGetType(pRi,&eType);
if (iRet==A3D_SUCCESS)
{
switch(eType)
{
case kA3DTypeRiBrepModel:
{
A3DRiBrepModelConnector sConnector( static_cast<A3DRiBrepModel const *>(pRi));
CHECK_RET(sConnector.TraverseRiBrepModel(psVisitor));
break;
}
case kA3DTypeRiSet:
{
A3DRiSetConnector sConnector(static_cast<A3DRiSet const *>(pRi));
CHECK_RET(sConnector.TraverseRiSet(psVisitor));
break;
}
case kA3DTypeRiPointSet:
case kA3DTypeRiDirection:
case kA3DTypeRiCurve:
case kA3DTypeRiCoordinateSystem:
case kA3DTypeRiPlane:
break;
case kA3DTypeRiPolyBrepModel:
{
A3DPolyRiBrepModelConnector sConnector(static_cast<A3DPolyRiBrepModelConnector const *>(pRi));
CHECK_RET(sConnector.TraverseRiPolyBrepModel(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
if (psVisitor->GetFlagElementToConnect() & CONNECT_MESH)
{
A3DRiRepresentationItemData sRidata;
A3D_INITIALIZE_DATA(A3DRiRepresentationItemData, sRidata);
CHECK_RET(A3DRiRepresentationItemGet (this->GetA3DEntity(), &sRidata));
A3DTessDataConnector sTessConnector(static_cast<A3DTess3D const *>(sRidata.m_pTessBase));
CHECK_RET(sTessConnector.Traverse(psVisitor));
CHECK_RET(A3DRiRepresentationItemGet (NULL, &sRidata));
}
#endif
//Traverse Brep Data
#ifdef CONNECT_BREP
if (psVisitor->GetFlagElementToConnect() & 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(A3DRiRepresentationItemGet(this->GetA3DEntity(), &sRiData));
A3DTessDataConnector sTessConnector(static_cast<A3DTess3D const *>(sRiData.m_pTessBase));
CHECK_RET(sTessConnector.Traverse(psVisitor));
CHECK_RET(A3DRiRepresentationItemGet(NULL, &sRiData));
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}
// A3DFRMParameter
A3DStatus A3DFRMFeatureConnector::TraverseFeature( A3DVisitorContainer* psVisitor ) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
unsigned uI;
for (uI = 0; uI < m_sData.m_uiConnectionSize; uI++)
{
A3DFRMFeatureLinkedItemConnector sFeatureLinkedItemConnector(m_sData.m_ppConnections[uI]);
sFeatureLinkedItemConnector.TraverseConnection(psVisitor);
}
for (uI = 0; uI < m_sData.m_uiParametersSize; uI++)
{
A3DFRMParameterConnector sParameterConnector(m_sData.m_ppParameters[uI]);
sParameterConnector.TraverseParameter(psVisitor);
}
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}
// A3DFRMParameter
A3DStatus A3DFRMFeatureLinkedItemConnector::TraverseConnection( A3DVisitorContainer* psVisitor ) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}
// A3DFRMParameter
A3DStatus A3DFRMParameterConnector::TraverseParameter( A3DVisitorContainer* psVisitor ) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
unsigned uI;
for (uI = 0; uI < m_sData.m_uiFeatureSize; uI++)
{
A3DFRMFeatureConnector sFeatureConnector(m_sData.m_ppFeatures[uI]);
sFeatureConnector.TraverseFeature(psVisitor);
}
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}
// FeatureTree
A3DStatus A3DFRMFeatureTreeConnector::TraverseFeatureTree( A3DVisitorContainer* psVisitor ) const
{
A3DStatus iRet = A3D_SUCCESS;
CHECK_RET(psVisitor->visitEnter(*this));
unsigned uI;
for (uI = 0; uI < m_sTreeData.m_uiIntermediateGeometriesSize; uI++)
{
A3DRiConnector sRiConnector( m_sTreeData.m_ppIntermediateGeometries[uI]);
sRiConnector.TraverseRi(psVisitor);
}
for (uI = 0; uI < m_sTreeData.m_uiParametersSize; uI++)
{
A3DFRMParameterConnector sParameterConnector( m_sTreeData.m_ppsParameters[uI]);
sParameterConnector.TraverseParameter(psVisitor);
}
CHECK_RET(psVisitor->visitLeave(*this));
return iRet;
}

318
exchange/exchangesource/Collision/visitor/TreeTraverse.h Normal file
View File

@@ -0,0 +1,318 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_TREE_CONNECTOR
#define A3D_TREE_CONNECTOR
#include <vector>
#include "Connector.h"
#include <A3DSDKStructure.h>
class A3DVisitorContainer;
class A3DModelFileConnector : public A3DConnector
{
public :
A3DModelFileConnector(const A3DAsmModelFile* pModelFile) : A3DConnector(pModelFile)
{
A3D_INITIALIZE_DATA( A3DAsmModelFileData, m_sModelFileData);
A3DAsmModelFileGet(pModelFile, &m_sModelFileData);
}
~A3DModelFileConnector() { A3DAsmModelFileGet(NULL, &m_sModelFileData); }
A3DStatus Traverse(A3DVisitorContainer* psVisitor, bool bVisitPrototype = false);
public :
A3DAsmModelFileData m_sModelFileData;
};
class A3DProductOccurrenceConnector : public A3DConnector
{
friend class A3DModelFileConnector;
const A3DAsmProductOccurrence* m_pFather;
bool m_bIsInstanciated;
bool m_bIsPrototype;
bool m_bIsExternal;
private :
A3DProductOccurrenceConnector(const A3DAsmProductOccurrence* pProductOccurrence);
~A3DProductOccurrenceConnector();
A3DStatus TraversePO(const A3DAsmProductOccurrence* pOccurrence, A3DVisitorContainer* psVisitor, bool bVisitPrototype = false);
void SetProductOccurrenceFather(const A3DAsmProductOccurrence* pFather) { m_pFather = pFather; }
public :
A3DStatus GetPart(A3DAsmPartDefinition*& pPart) const;
A3DStatus CollectSons(std::vector<A3DAsmProductOccurrence*>& apSons) const;
A3DAsmProductOccurrenceData m_sProductOccurrenceData;
A3DAsmProductOccurrenceDataSLW *m_pProductOccurrenceDataSLW;
A3DAsmProductOccurrenceDataCat *m_pProductOccurrenceDataCat;
A3DAsmProductOccurrenceDataCV5 *m_pProductOccurrenceDataCV5;
A3DAsmProductOccurrenceDataUg *m_pProductOccurrenceDataUg;
A3DAsmProductOccurrenceDataProe *m_pProductOccurrenceDataProe;
A3DAsmProductOccurrenceDataInv *m_pProductOccurrenceDataInv;
A3DAsmProductOccurrenceDataJT *m_pProductOccurrenceDataJT;
const A3DAsmProductOccurrence* GetProductOccurrenceFather() const { return m_pFather; }
void SetIsInstanciated(bool bIsInstanciated) { m_bIsInstanciated = bIsInstanciated; }
bool IsInstanciated() const { return m_bIsInstanciated; }
void SetPrototypeType(bool bIsPrototype) { m_bIsPrototype = bIsPrototype; }
bool IsProtoType() const { return m_bIsPrototype; }
void SetExternalType(bool bIsExternal) { m_bIsExternal = bIsExternal; }
bool IsExternal() const { return m_bIsExternal; }
};
class A3DPartConnector : public A3DConnector
{
friend class A3DProductOccurrenceConnector;
const A3DAsmProductOccurrence* m_pFather;
bool m_bIsInstanciated;
private:
A3DPartConnector(const A3DAsmPartDefinition *pPart) : A3DConnector(pPart)
{
m_pFather = NULL;
m_bIsInstanciated = false;
A3D_INITIALIZE_DATA(A3DAsmPartDefinitionData, m_sPartData);
A3DAsmPartDefinitionGet(pPart, &m_sPartData);
}
~A3DPartConnector()
{
A3DAsmPartDefinitionGet(NULL, &m_sPartData);
}
void SetProductOccurrenceFather(const A3DAsmProductOccurrence* pFather) { m_pFather = pFather; }
public :
A3DStatus TraversePart(A3DVisitorContainer* psVisitor) const;
A3DAsmPartDefinitionData m_sPartData;
const A3DAsmProductOccurrence* GetProductOccurrenceFather() const { return m_pFather; }
void SetIsInstanciated(bool bIsInstanciated) { m_bIsInstanciated = bIsInstanciated; }
bool IsInstanciated() { return m_bIsInstanciated; }
};
class A3DRiConnector : public A3DConnector
{
friend class A3DPartConnector;
friend class A3DRiSetConnector;
friend class A3DFRMFeatureTreeConnector;
bool m_bIsInstanciated;
private:
A3DRiConnector(const A3DRiRepresentationItem *pRi) : A3DConnector(pRi)
{
m_bIsInstanciated = false;
A3D_INITIALIZE_DATA(A3DRiRepresentationItemData, m_sRiData);
A3DRiRepresentationItemGet(pRi, &m_sRiData);
}
~A3DRiConnector()
{
A3DRiRepresentationItemGet(NULL, &m_sRiData);
}
A3DStatus TraverseRi(A3DVisitorContainer* psVisitor);
public :
A3DRiRepresentationItemData m_sRiData;
void SetIsInstanciated(bool bIsInstanciated) { m_bIsInstanciated = bIsInstanciated; }
bool IsInstanciated() { return m_bIsInstanciated; }
};
class A3DRiBrepModelConnector : public A3DConnector
{
friend class A3DRiConnector;
public :
A3DRiBrepModelConnector(const A3DRiBrepModel *pRi) : m_pRiBrepModel(pRi), A3DConnector(pRi)
{
A3D_INITIALIZE_DATA(A3DRiBrepModelData, m_sRiBrepModelData);
A3DRiBrepModelGet(m_pRiBrepModel, &m_sRiBrepModelData);
}
~A3DRiBrepModelConnector()
{
A3DRiBrepModelGet(NULL, &m_sRiBrepModelData);
}
A3DStatus TraverseRiBrepModel(A3DVisitorContainer* psVisitor) const;
public :
A3DRiBrepModel const* m_pRiBrepModel;
A3DRiBrepModelData m_sRiBrepModelData;
};
class A3DRiSetConnector : public A3DConnector
{
friend class A3DRiConnector;
private:
A3DRiSetConnector(const A3DRiSet *pRi) : A3DConnector(pRi)
{
A3D_INITIALIZE_DATA(A3DRiSetData, m_sRiSetData);
A3DRiSetGet(pRi, &m_sRiSetData);
}
~A3DRiSetConnector()
{
A3DRiSetGet(NULL, &m_sRiSetData);
}
A3DStatus TraverseRiSet(A3DVisitorContainer* psVisitor);
public :
A3DRiSetData m_sRiSetData;
};
class A3DPolyRiBrepModelConnector : public A3DConnector
{
friend class A3DRiConnector;
private:
A3DPolyRiBrepModelConnector(const A3DRiPolyBrepModel* pRi) : A3DConnector(pRi)
{
A3D_INITIALIZE_DATA(A3DRiPolyBrepModelData, m_sRiPolyBrepModelData);
A3DRiPolyBrepModelGet(pRi, &m_sRiPolyBrepModelData);
}
~A3DPolyRiBrepModelConnector()
{
A3DRiPolyBrepModelGet(NULL, &m_sRiPolyBrepModelData);
}
public:
A3DStatus TraverseRiPolyBrepModel(A3DVisitorContainer* psVisitor) const;
A3DRiPolyBrepModelData m_sRiPolyBrepModelData;
};
class A3DFRMParameterConnector : public A3DConnector
{
friend class A3DFRMFeatureTreeConnector;
friend class A3DFRMFeatureConnector;
private:
A3DFRMParameterConnector(const A3DFRMParameter *pParameter) : A3DConnector(pParameter)
{
A3D_INITIALIZE_DATA(A3DFRMParameterData, m_sData);
A3DFRMParameterGet (pParameter, &m_sData);
}
~A3DFRMParameterConnector()
{
A3DFRMParameterGet (NULL, &m_sData);
}
public:
A3DFRMParameterData m_sData;
A3DStatus TraverseParameter(A3DVisitorContainer* psVisitor) const;
};
class A3DFRMFeatureLinkedItemConnector : public A3DConnector
{
friend class A3DFRMFeatureConnector;
private:
A3DFRMFeatureLinkedItemConnector(const A3DFRMLinkedItem *pLinkedItem) : A3DConnector(pLinkedItem)
{
A3D_INITIALIZE_DATA(A3DFRMLinkedItemData, m_sData);
A3DFRMLinkedItemGet (pLinkedItem, &m_sData);
}
~A3DFRMFeatureLinkedItemConnector()
{
A3DFRMLinkedItemGet (NULL, &m_sData);
}
public:
A3DFRMLinkedItemData m_sData;
A3DStatus TraverseConnection(A3DVisitorContainer* psVisitor) const;
};
class A3DFRMFeatureConnector : public A3DConnector
{
friend class A3DFRMParameterConnector;
private:
A3DFRMFeatureConnector(const A3DFRMFeature *pFeature) : A3DConnector(pFeature)
{
A3D_INITIALIZE_DATA(A3DFRMFeatureData, m_sData);
A3DFRMFeatureGet (pFeature, &m_sData);
}
~A3DFRMFeatureConnector()
{
A3DFRMFeatureGet (NULL, &m_sData);
}
public:
A3DFRMFeatureData m_sData;
A3DStatus TraverseFeature(A3DVisitorContainer* psVisitor) const;
};
class A3DFRMFeatureTreeConnector : public A3DConnector
{
friend class A3DProductOccurrenceConnector;
protected:
A3DFRMFeatureTreeConnector(const A3DFRMTree *pTree) : A3DConnector(pTree)
{
A3D_INITIALIZE_DATA(A3DFRMTreeData, m_sTreeData);
A3DFRMTreeGet (pTree, &m_sTreeData);
}
~A3DFRMFeatureTreeConnector()
{
A3DFRMTreeGet (NULL, &m_sTreeData);
}
A3DStatus TraverseFeatureTree(A3DVisitorContainer* psVisitor) const;
public:
A3DFRMTreeData m_sTreeData;
};
#endif

38
exchange/exchangesource/Collision/visitor/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;
}

45
exchange/exchangesource/Collision/visitor/ViewTraverse.h Normal file
View File

@@ -0,0 +1,45 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_VIEW_TRAVERSE
#define A3D_VIEW_TRAVERSE
#include <vector>
#include "Connector.h"
class A3DVisitorContainer;
class A3DMkpViewConnector : public A3DConnector
{
public:
A3DMkpViewConnector(const A3DMkpView *pView) : A3DConnector(pView)
{
A3D_INITIALIZE_DATA( A3DMkpViewData, m_sViewData);
m_pView = pView;
A3DMkpViewGet(pView,&m_sViewData);
}
~A3DMkpViewConnector()
{
A3DMkpViewGet(NULL, &m_sViewData);
}
A3DStatus TraverseView(A3DVisitorContainer* pVisitor);
A3DMkpViewData const& GetViewData() const { return m_sViewData; }
A3DMkpView const* GetView() const { return m_pView; }
private:
A3DMkpViewData m_sViewData;
A3DMkpView const* m_pView;
};
#endif // A3D_VIEW_TRAVERSE

65
exchange/exchangesource/Collision/visitor/VisitorBrep.h Normal file
View File

@@ -0,0 +1,65 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef VISIT_BREP
#define VISIT_BREP
#include "Visitors.h"
#include "BrepTraverse.h"
#include <map>
class A3DVisitorBrep : public A3DVisitor
{
private:
std::map<A3DTopoEdge*,const A3DTopoCoEdge*> m_MapEdgeCoEdge;
double m_dScale;
public:
A3DVisitorBrep(A3DVisitorContainer* psContainer = NULL) : A3DVisitor("Brep", psContainer) { m_dScale = 1.0;}
virtual A3DStatus visitEnter(const A3DRiConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DRiConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DBrepDataConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DBrepDataConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DConnexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DConnexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DShellConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DShellConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DFaceConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DFaceConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DLoopConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DLoopConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DCoEdgeConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DCoEdgeConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DEdgeConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DEdgeConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DUniqueVertexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DUniqueVertexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DMultipleVertexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMultipleVertexConnector&) { return A3D_SUCCESS; }
double GetScale() const { return m_dScale;}
std::map<A3DTopoEdge*,const A3DTopoCoEdge*> & GetMapEdgeCoEdge() { return m_MapEdgeCoEdge;}
};
#endif //VISIT_TOPO

286
exchange/exchangesource/Collision/visitor/VisitorCascadedAttribute.cpp Normal file
View File

@@ -0,0 +1,286 @@
/***********************************************************************************************************************
*
* 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"
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)
{
A3DMiscCascadedAttributesDelete(*itCur);
}
}
A3DStatus A3DVisitorColorMaterials::pushCascadedAttribute(const A3DConnector& sEntity)
{
unsigned int uSize = (unsigned int)m_apsCascadedAttribute.size();
A3DInt32 iRet = A3D_SUCCESS;
if(!uSize)
{
A3DMiscCascadedAttributes* pAttr;
iRet = A3DMiscCascadedAttributesCreate(&pAttr);
m_apsCascadedAttribute.push_back(pAttr);
uSize++;
}
A3DMiscCascadedAttributes* pAttr;
iRet = A3DMiscCascadedAttributesCreate(&pAttr);
iRet = 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)
{
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);
/* A3DEEntityType eType;
A3DEntityGetType( sEntity.m_sProductOccurrenceData.m_ppEntityReferences[uI], &eType);
if(eType == kA3DTypeMiscEntityReference)
{
A3DMiscReferenceOnTopologyData sTopoRefData;
A3D_INITIALIZE_DATA(A3DMiscReferenceOnTopologyData,sTopoRefData);
A3DMiscReferenceOnTopologyGet(sEntity.m_sProductOccurrenceData.m_ppEntityReferences[uI],
&sTopoRefData);
// Get Entity Target: sTopoRefData.m_pBrepData, Edge, Face, Vertex
//Add also systematically the 3DTessData or Face Tess Data
//add in the Visitor container Map
// kA3DTypeTopoMultipleVertex
// kA3DTypeTopoUniqueVertex
// kA3DTypeTopoWireEdge
// kA3DTypeTopoEdge
// kA3DTypeTopoLoop
// kA3DTypeTopoFace
// kA3DTypeTopoShell
// kA3DTypeTopoConnex
A3DMiscReferenceOnTopologyGet(NUL,
&sTopoRefData));
A3DTopoBrepData* pBrepData = sTopoRefData.m_pBrepData;
A3DTopoBrepDataData sTopoBrepDataData;
A3D_INITIALIZE_DATA( A3DTopoBrepDataData,sTopoBrepDataData);
A3DTopoBrepDataGet(pBrepData,&sTopoBrepDataData);
unsigned int unbconnex = sTopoBrepDataData.m_uiConnexSize;
}
}*/
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)
{
//CHECK_RET(pushCascadedAttribute((const A3DConnector&) sRi));
//home made push for tess face
A3DMiscCascadedAttributes* pAttr;
iRet = A3DMiscCascadedAttributesCreate(&pAttr);
iRet = 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]));
}
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 = A3DMiscEntityReferenceGet(pMER, &sSERData);
if(iErr == A3D_SUCCESS)
{
A3DEEntityType eType;
A3DEntityGetType( pMER, &eType);
if(eType == kA3DTypeMiscEntityReference || eType==kA3DTypeMiscMarkupLinkedItem)
{
A3DMiscReferenceOnTopologyData sTopoRefData;
A3D_INITIALIZE_DATA(A3DMiscReferenceOnTopologyData,sTopoRefData);
iErr = 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);
A3DTopoBrepDataGet(pBrepData,&sTopoBrepDataData);
A3DTopoBrepDataGet(NULL,&sTopoBrepDataData);
break;
}
case kA3DTypeTopoShell:
{
break;
}
case kA3DTypeTopoConnex:
{
break;
}
default:
{
break;
}
}
}
else // no topo -> global PO/Part/RI/RIBrepModel
{
A3DEEntityType eLType;
A3DEntityGetType( sSERData.m_pEntity, &eLType);
//A3DGraphStyleData
A3DMiscCascadedAttributes* pAttr = NULL;
A3DMiscCascadedAttributesCreate(&pAttr);
iErr = A3DMiscCascadedAttributesPush(pAttr, pMER, pCurrent);
A3DMiscCascadedAttributesData sCAData;
A3D_INITIALIZE_DATA(A3DMiscCascadedAttributesData, sCAData);
iErr = A3DMiscCascadedAttributesGet(pAttr, &sCAData);
rsColorConnector = ColorMaterialsConnector(pAttr);
A3DMiscCascadedAttributesDelete (pAttr);
}
A3DMiscReferenceOnTopologyGet(NULL,&sTopoRefData);
}
A3DMiscEntityReferenceGet( NULL, &sSERData);
}
}
else
rsColorConnector = ColorMaterialsConnector(pCurrent);
}
return A3D_SUCCESS;
}

76
exchange/exchangesource/Collision/visitor/VisitorCascadedAttribute.h Normal file
View File

@@ -0,0 +1,76 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef VISITOR_CASCADED_ATTRIBUTE
#define VISITOR_CASCADED_ATTRIBUTE
#include "Visitors.h"
#include <map>
class A3DCascadedAttribute;
class ColorMaterialsConnector;
class A3DVisitorColorMaterials : public A3DVisitor
{
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4251) // Suppress the warning C4251 because it leads to have that kind of warning : "warning
// C4251: 'A3DVisitorColorMaterials::m_apsCascadedAttribute' : class 'std::vector<_Ty>' needs to have dll-interface to
// be used by clients of class 'A3DVisitorColorMaterials"
// This is because of the "dllexport" on the visitor classes, as they use stl members and it seems that stl causes
// warning with dllexport with microsoft compiler
#endif // _MSC_VER
//friend class A3DVisitorContainer;
std::vector<A3DMiscCascadedAttributes*> m_apsCascadedAttribute;
A3DRiRepresentationItem* m_pCurrentRi; //needed for FaceTessDataConnector
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
public:
A3DVisitorColorMaterials(A3DVisitorContainer* psContainer = NULL);
virtual ~A3DVisitorColorMaterials();
virtual A3DStatus pushCascadedAttribute(const A3DConnector& sEntity);
virtual A3DStatus visitEnter(const A3DProductOccurrenceConnector& sEntity);
virtual A3DStatus visitEnter(const A3DPartConnector& sEntity);
virtual A3DStatus visitEnter(const A3DRiConnector& sEntity);
virtual A3DStatus visitEnter(const A3DFaceTessDataConnector& sEntity);
virtual A3DStatus popCascadedAttribute(/*const A3DConnector& sEntity*/);
virtual A3DStatus visitLeave(const A3DProductOccurrenceConnector& sEntity);
virtual A3DStatus visitLeave(const A3DPartConnector& sEntity);
virtual A3DStatus visitLeave(const A3DRiConnector& sEntity);
virtual A3DStatus visitLeave(const A3DFaceTessDataConnector& sEntity);
std::vector<A3DMiscCascadedAttributes*> _Get() const { return m_apsCascadedAttribute; }
void _Set(std::vector<A3DMiscCascadedAttributes*> const & val) { m_apsCascadedAttribute = val; }
void _SetCurrentRi(A3DRiRepresentationItem* const val) { m_pCurrentRi = val; }
public:
///////////////////////////////////////////////////////////////////
// Please, redefined this function in a inherited class to connect
// the meshes provide by 3DX in your application
//////////////////////////////////////////////////////////////////
virtual A3DStatus SetGlobalAttributeOnLeaf(const A3DMiscCascadedAttributes* /*psCascadedAttribute*/) { return A3D_SUCCESS; }
A3DStatus GetColorMaterialConnector(ColorMaterialsConnector& rsColorConnector, bool bUseInstances = false);
A3DMiscCascadedAttributes* GetLastCascadedAttributes() const;
};
#endif

631
exchange/exchangesource/Collision/visitor/VisitorContainer.cpp Normal file
View File

@@ -0,0 +1,631 @@
/***********************************************************************************************************************
*
* 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 <VisitorPMI.h>
#endif
#ifdef CONNECT_PMI
#include "ViewTraverse.h"
#endif
#include <map>
#include <algorithm>
#include <iostream>
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::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
#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
//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),
m_uFlagElementToConnect(uFlagElementToconnect),
m_bTraverseInstance(false)
{
#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);
}
#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));
}
void A3DVisitorContainer::RemoveFromMap(const A3DEntity* pA3DEntity)
{
m_apA3DEntityYourEntityMap.erase(pA3DEntity);
}
A3DVisitor* A3DVisitorContainer::GetVisitorByName( std::string strName )
{
for(auto visitor : m_apVisitor)
{
if(visitor->GetName() == strName)
{
return visitor;
}
}
return nullptr;
}
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;
}
#ifdef CONNECT_FEATURE
A3DStatus A3DVisitorContainer::visitEnter(const A3DFRMFeatureConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DFRMFeatureConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitEnter(const A3DFRMParameterConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DFRMParameterConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitEnter(const A3DFRMFeatureTreeConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DFRMFeatureTreeConnector& sConnector)
VISITLEAVE
A3DStatus A3DVisitorContainer::visitEnter(const A3DFRMFeatureLinkedItemConnector& sConnector)
VISITENTER
A3DStatus A3DVisitorContainer::visitLeave(const A3DFRMFeatureLinkedItemConnector& sConnector)
VISITLEAVE
#endif

236
exchange/exchangesource/Collision/visitor/VisitorContainer.h Normal file
View File

@@ -0,0 +1,236 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3DVISITOR_CONTAINER
#define A3DVISITOR_CONTAINER
#include <map>
#include "Visitors.h"
//This class allow to use several vistor when traversing 3DX Tree.
//It allow also to exchange parameters between visitors
#define NODE_INSTANCES 0x0001
class A3DStepEntityRefManager
{
public:
unsigned int m_uiPOLevel; // Level of creation
unsigned int m_uiPushLevel; // if not ~0U , then is activated
bool m_bRefOnTopoItem;;
A3DMiscEntityReference* m_pStepEntityRef;
A3DEntity* m_pA3DEntityRef;
// std::vector<void*> m_apYourEntity;
A3DStepEntityRefManager() : m_uiPOLevel(~0U), m_uiPushLevel(~0U), m_pStepEntityRef(NULL), m_bRefOnTopoItem(false),
m_pA3DEntityRef(NULL){}
void GetMatrix();
bool IsFirst( A3DStepEntityRefManager const & sOther) const { return (m_uiPOLevel<sOther.m_uiPOLevel) || (m_uiPOLevel==sOther.m_uiPOLevel && m_uiPushLevel>sOther.m_uiPushLevel);}
};
class A3DViewLinkedItemManager
{
public:
unsigned int m_uiPOLevel;
unsigned int m_uiPushLevel; // if not ~0U , then is activated
bool m_bRefOnTopoItem;
A3DMiscMarkupLinkedItem * m_pMarkupLinkedItem;
A3DAsmProductOccurrence * m_POOwner;
A3DEntity * m_pA3DEntityRef;
// std::vector<void*> m_apYourEntity;
A3DViewLinkedItemManager() : m_uiPOLevel(~0U), m_uiPushLevel(~0U), m_pMarkupLinkedItem(NULL),m_bRefOnTopoItem(false),
m_pA3DEntityRef(NULL){}
void GetMatrix();
bool IsFirst( A3DViewLinkedItemManager const & sOther) const { return (m_uiPOLevel<sOther.m_uiPOLevel) || (m_uiPOLevel==sOther.m_uiPOLevel && m_uiPushLevel>sOther.m_uiPushLevel);}
};
class A3DVisitorContainer : public A3DVisitor
{
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4251) // Suppress the warning C4251 because it leads to have that kind of warning : "warning
// C4251: 'A3DVisitorColorMaterials::m_apsCascadedAttribute' : class 'std::vector<_Ty>' needs to have dll-interface to
// be used by clients of class 'A3DVisitorColorMaterials"
// This is because of the "dllexport" on the visitor classes, as they use stl members and it seems that stl causes
// warning with dllexport with microsoft compiler
#endif // _MSC_VER
std::map<const A3DEntity*, void*> m_apA3DEntityYourEntityMap;
std::vector<A3DVisitor*> m_apVisitor;
bool m_bTraverseInstance;
A3DVisitor* m_pTreeVisitor;
A3DAsmProductOccurrence const * m_pCurrentPOFather;
A3DMkpView const * m_psActivatedView;
bool m_bTraverseActivatedViewOnly;
std::vector<A3DStepEntityRefManager> m_asStepEntityRefManager;
std::vector<A3DViewLinkedItemManager> m_asViewLinkedItemManager;
unsigned int m_uiCurrentLevel;
unsigned int m_uFlagElementToConnect;
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
public:
A3DVisitorContainer(unsigned int uFlagElementToconnect =
CONNECT_TRANSFO | CONNECT_COLORS | CONNECT_MESH | CONNECT_ASSEMBLY_TREE | CONNECT_BREP | CONNECT_PMI | CONNECT_VIEWS| CONNECT_FEATURE);
virtual ~A3DVisitorContainer();
void push( A3DVisitor* psVisitor);
//A3DConnector
virtual A3DStatus visitEnter(const A3DConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DConnector& /*sConnector*/) { return A3D_SUCCESS; }
//Assmebly Tree
#ifdef CONNECT_ASSEMBLY_TREE
virtual A3DStatus visitEnter(const A3DModelFileConnector& sConnector);
virtual A3DStatus visitLeave(const A3DModelFileConnector& sConnector);
virtual A3DStatus visitEnter(const A3DProductOccurrenceConnector& sConnector);
virtual A3DStatus visitLeave(const A3DProductOccurrenceConnector& sConnector);
virtual A3DStatus visitEnter(const A3DPartConnector& sConnector);
virtual A3DStatus visitLeave(const A3DPartConnector& sConnector);
virtual A3DStatus visitEnter(const A3DRiConnector& sConnector);
virtual A3DStatus visitLeave(const A3DRiConnector& sConnector);
virtual A3DStatus visitEnter(const A3DRiBrepModelConnector& sConnector);
virtual A3DStatus visitLeave(const A3DRiBrepModelConnector& sConnector);
virtual A3DStatus visitEnter(const A3DRiSetConnector& sConnector);
virtual A3DStatus visitLeave(const A3DRiSetConnector& sConnector);
virtual A3DStatus visitEnter(const A3DPolyRiBrepModelConnector& sConnector);
virtual A3DStatus visitLeave(const A3DPolyRiBrepModelConnector& sConnector);
#endif
#ifdef CONNECT_PMI
//Markup Tree
virtual A3DStatus visitEnter(const A3DMkpAnnotationEntityConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMkpAnnotationEntityConnector& sConnector);
virtual A3DStatus visitEnter(const A3DMkpAnnotationSetConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMkpAnnotationSetConnector& sConnector);
virtual A3DStatus visitEnter(const A3DMkpAnnotationItemConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMkpAnnotationItemConnector& sConnector);
virtual A3DStatus visitEnter(const A3DMarkupConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMarkupConnector& sConnector);
virtual A3DStatus visitEnter(const A3DMarkupDimensionConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMarkupDimensionConnector& sConnector);
virtual A3DStatus visitEnter(const A3DMarkupGDTConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMarkupGDTConnector& sConnector);
#endif
#ifdef CONNECT_BREP
//Brep
virtual A3DStatus visitEnter(const A3DBrepDataConnector& sConnector);
virtual A3DStatus visitLeave(const A3DBrepDataConnector& sConnector);
virtual A3DStatus visitEnter(const A3DConnexConnector& sConnector);
virtual A3DStatus visitLeave(const A3DConnexConnector& sConnector);
virtual A3DStatus visitEnter(const A3DShellConnector& sConnector);
virtual A3DStatus visitLeave(const A3DShellConnector& sConnector);
virtual A3DStatus visitEnter(const A3DFaceConnector& sConnector);
virtual A3DStatus visitLeave(const A3DFaceConnector& sConnector);
virtual A3DStatus visitEnter(const A3DLoopConnector& sConnector);
virtual A3DStatus visitLeave(const A3DLoopConnector& sConnector);
virtual A3DStatus visitEnter(const A3DCoEdgeConnector& sConnector);
virtual A3DStatus visitLeave(const A3DCoEdgeConnector& sConnector);
virtual A3DStatus visitEnter(const A3DEdgeConnector& sConnector);
virtual A3DStatus visitLeave(const A3DEdgeConnector& sConnector);
virtual A3DStatus visitEnter(const A3DUniqueVertexConnector& sConnector);
virtual A3DStatus visitLeave(const A3DUniqueVertexConnector& sConnector);
virtual A3DStatus visitEnter(const A3DMultipleVertexConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMultipleVertexConnector& sConnector);
#endif
#ifdef CONNECT_MESH
//Mesh
virtual A3DStatus visitEnter(const A3DTessDataConnector& sConnector);
virtual A3DStatus visitLeave(const A3DTessDataConnector& sConnector);
virtual A3DStatus visitEnter(const A3DFaceTessDataConnector& sConnector);
virtual A3DStatus visitLeave(const A3DFaceTessDataConnector& sConnector);
virtual A3DStatus visitEnter(const A3DMarkupDatumConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMarkupDatumConnector& sConnector);
#endif
//Views
#ifdef CONNECT_VIEWS
virtual A3DStatus visitEnter(const A3DMkpViewConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMkpViewConnector& sConnector);
#endif
#ifdef CONNECT_FEATURE
virtual A3DStatus visitEnter(const A3DFRMFeatureConnector& sConnector);
virtual A3DStatus visitLeave(const A3DFRMFeatureConnector& sConnector);
virtual A3DStatus visitEnter(const A3DFRMParameterConnector& sConnector);
virtual A3DStatus visitLeave(const A3DFRMParameterConnector& sConnector);
virtual A3DStatus visitEnter(const A3DFRMFeatureTreeConnector& sConnector);
virtual A3DStatus visitLeave(const A3DFRMFeatureTreeConnector& sConnector);
virtual A3DStatus visitEnter(const A3DFRMFeatureLinkedItemConnector& sConnector);
virtual A3DStatus visitLeave(const A3DFRMFeatureLinkedItemConnector& sConnector);
#endif
void* FindInMap(const A3DEntity* pA3DEntity);
void SetInMap(const A3DEntity* pA3DEntity, void* pYourEntity);
void RemoveFromMap(const A3DEntity* pA3DEntity);
std::vector<A3DVisitor*>& GetVisitor() { return m_apVisitor; }
bool TraverseInstances() { return m_bTraverseInstance; }
void SetTraverseInstance(bool bTraverseInstance) { m_bTraverseInstance = bTraverseInstance; }
A3DVisitor* GetVisitorByName(std::string strName);
A3DVisitor* GetTreeVisitor() const;
void SetCurrentPoFather(A3DAsmProductOccurrence const * pCurrentPOFather) { m_pCurrentPOFather = pCurrentPOFather; }
A3DAsmProductOccurrence const * GetCurrentPoFather() { return m_pCurrentPOFather; }
void SetActivateView(A3DMkpView const * psActivatedView) { m_psActivatedView = psActivatedView; }
A3DMkpView const * GetActivatedView() { return m_psActivatedView; }
void SetTraverseActivatedViewOnly(bool bTraverseActivatedViewOnly) { m_bTraverseActivatedViewOnly = bTraverseActivatedViewOnly; }
// StepEntityReference and ViewLinkedItem treatment
A3DStepEntityRefManager const* GetActiveStepEntityRefManager(A3DEntity const * pEntity) const;
A3DViewLinkedItemManager const* GetActiveViewLinkedItemManager(A3DEntity const * pEntity) const;
void ActivateEntityReference( A3DEntity const* pEntity );
void DeactivateEntityReference(A3DEntity const* pEntity);
unsigned int GetFlagElementToConnect() const { return m_uFlagElementToConnect; }
};
#endif

90
exchange/exchangesource/Collision/visitor/VisitorTessellation.cpp Normal file
View File

@@ -0,0 +1,90 @@
/***********************************************************************************************************************
*
* 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 "VisitorTessellation.h"
#include "TessConnector.h"
A3DStatus A3DVisitorTessellation::visitEnter(const A3DTessDataConnector& sTessConnector)
{
m_uCurrentFaceIndice = 0;
//Get point Array
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();
unsigned int uIFaceCount;
for(uIFaceCount = 0; uIFaceCount<uFaceSize; uIFaceCount++)
{
std::vector<unsigned> auTriangleWithPointNormalInidces;
std::vector<unsigned> auTrinagleWithPointNromalUVindices;
CHECK_RET(sTessConnector.IndicesPerFaceAsTriangle(uIFaceCount,
auTriangleWithPointNormalInidces,
auTrinagleWithPointNromalUVindices));
/****************************************************************************
Please create Your mesh here
*****************************************************************************/
}
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitLeave(const A3DTessDataConnector& /*sTessConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitEnter(const A3DFaceTessDataConnector& /*sTessConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitLeave(const A3DFaceTessDataConnector& /*sTessConnector*/)
{
m_uCurrentFaceIndice++;
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitEnter(const A3DRiConnector& /*sTessConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitLeave(const A3DRiConnector& /*sTessConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitEnter(const A3DMarkupTessConnector& /*sMarkupTessConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitLeave(const A3DMarkupTessConnector& /*sMarkupTessConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitEnter(const A3DWireTessDataConnector& /*sWireTessConnector*/)
{
return A3D_SUCCESS;
}
A3DStatus A3DVisitorTessellation::visitLeave(const A3DWireTessDataConnector& /*sWireTessConnector*/)
{
return A3D_SUCCESS;
}

45
exchange/exchangesource/Collision/visitor/VisitorTessellation.h Normal file
View File

@@ -0,0 +1,45 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_VISIST_TESSELLATION
#define A3D_VISIST_TESSELLATION
#include "Visitors.h"
#include "TessConnector.h"
class A3DVisitorTessellation : public A3DVisitor
{
friend class A3DVisitorContainer;
protected:
bool m_bShow;
unsigned int m_uCurrentFaceIndice;
public:
A3DVisitorTessellation(A3DVisitorContainer* psContainer = NULL) : A3DVisitor("Tessellation", psContainer) {};
virtual ~A3DVisitorTessellation() {}
virtual A3DStatus visitEnter(const A3DFaceTessDataConnector& sConnector);
virtual A3DStatus visitLeave(const A3DFaceTessDataConnector& sConnector);
virtual A3DStatus visitEnter(const A3DTessDataConnector& sTessConnector);
virtual A3DStatus visitLeave(const A3DTessDataConnector& sTessConnector);
virtual A3DStatus visitEnter(const A3DRiConnector& sTessConnector);
virtual A3DStatus visitLeave(const A3DRiConnector& sTessConnector);
virtual A3DStatus visitEnter(const A3DMarkupTessConnector& sMarkupTessConnector);
virtual A3DStatus visitLeave(const A3DMarkupTessConnector& sMarkupTessConnector);
virtual A3DStatus visitEnter(const A3DWireTessDataConnector& sTessConnector);
virtual A3DStatus visitLeave(const A3DWireTessDataConnector& sTessConnector);
};
#endif

324
exchange/exchangesource/Collision/visitor/VisitorTransfo.cpp Normal file
View File

@@ -0,0 +1,324 @@
/***********************************************************************************************************************
*
* 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 "VisitorTransfo.h"
#include "TreeTraverse.h"
#include "Matrix.h"
#include "VisitorTree.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);
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);
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);
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;
}
//XXX Is There a way to integrate this function in TreeTravrse?
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);
A3DAsmProductOccurrenceGet(pExternal, &sExternalDataData);
CHECK_RET(stProductOccurrenceGetLocation( &sExternalDataData , ppLocation));
A3DAsmProductOccurrenceGet(NULL, &sExternalDataData);
if(*ppLocation)
return A3D_SUCCESS;
}
if (psPOccData->m_pLocation == NULL && psPOccData->m_pPrototype != NULL)
{
A3DAsmProductOccurrenceData sPrototypeData;
A3D_INITIALIZE_DATA( A3DAsmProductOccurrenceData, sPrototypeData);
A3DAsmProductOccurrenceGet(psPOccData->m_pPrototype, &sPrototypeData);
CHECK_RET(stProductOccurrenceGetLocation(&sPrototypeData, ppLocation));
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);
A3DEntityDelete (pTransfo);
return pConnector;
}
else
{
//if(m_psContainer)
//{
// A3DTreeVisitor* pTreeVisitor = (A3DTreeVisitor*)m_psContainer->GetTreeVisitor();
// if(pTreeVisitor)
// {
// A3DStepEntityRefManager const* pSERM = pTreeVisitor->GetFirstActiveStepEntityRefManager();
// 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);
// }
//
// A3DViewLinkedItemManager const* pVLIM = pTreeVisitor->GetFirstActiveViewLinkedItemManager();
// 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);
// }
// }
//}
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);
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;
A3DMiscGeneralTransformationCreate (&sData, &pTransfo);
return (A3DMiscTransformation*)pTransfo;
}

83
exchange/exchangesource/Collision/visitor/VisitorTransfo.h Normal file
View File

@@ -0,0 +1,83 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef VISIT_TRANSFO
#define VISIT_TRANSFO
#include "Visitors.h"
#include <stdio.h>
#include "Matrix.h"
class A3DTransfoConnector;
//Visitor used to Get transfo on each ProductOccurrences and Representation Item Nodes
class A3DVisitorTransfo : public A3DVisitor
{
//friend class A3DVisitorContainer;
protected:
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4251) // Suppress the warning C4251 because it leads to have that kind of warning : "warning
// C4251: 'A3DVisitorColorMaterials::m_apsCascadedAttribute' : class 'std::vector<_Ty>' needs to have dll-interface to
// be used by clients of class 'A3DVisitorColorMaterials"
// This is because of the "dllexport" on the visitor classes, as they use stl members and it seems that stl causes
// warning with dllexport with microsoft compiler
#endif // _MSC_VER
std::vector<A3DMatrix4x4> m_adPushTransfo;
A3DMatrix4x4 m_adLocalMatrix;
bool m_bUnitFormCad;
double m_dUnit;
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
A3DMiscTransformation* CreateTransfo(A3DMatrix4x4 const & rMatrix);
public:
A3DVisitorTransfo(bool bModelFileUnitFormCAD,
double dUnitModelFile,
A3DVisitorContainer* psContainer = NULL);
A3DVisitorTransfo(A3DVisitorContainer* psContainer = NULL);
virtual ~A3DVisitorTransfo();
virtual A3DStatus visitEnter(const A3DRiConnector& sConnector);
virtual A3DStatus visitLeave(const A3DRiConnector& sConnector);
virtual A3DStatus visitEnter(const A3DProductOccurrenceConnector& sConnector);
virtual A3DStatus visitLeave(const A3DProductOccurrenceConnector& sConnector);
virtual A3DStatus visitEnter(const A3DModelFileConnector& sConnector);
virtual A3DStatus visitLeave(const A3DModelFileConnector& sConnector);
virtual A3DStatus SetLocalTransfo(A3DMatrix4x4 const& rdLocalTransfo) { m_adLocalMatrix = rdLocalTransfo; return A3D_SUCCESS; }
virtual A3DStatus SetGlobalTransfo(A3DMatrix4x4 const& /*rdLocalTransfo*/) { return A3D_SUCCESS; }
bool UnitFromCad() const
{
return m_bUnitFormCad;
}
double Unit() const
{
return m_dUnit;
}
A3DTransfoConnector* GetTransfoConnector(bool bUseInstance = false);
A3DTransfoConnector* GetTransfoConnectorFromManager(A3DEntity const * pEntity);
};
#endif

97
exchange/exchangesource/Collision/visitor/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;
}

73
exchange/exchangesource/Collision/visitor/VisitorTree.h Normal file
View File

@@ -0,0 +1,73 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef VISIT_TREE
#define VISIT_TREE
#include "Visitors.h"
#include "VisitorContainer.h"
class A3DConnector;
class A3DVisitorContainer;
class A3DTreeVisitor : public A3DVisitor
{
friend class A3DVisitorContainer;
protected:
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4251) // Suppress the warning C4251 because it leads to have that kind of warning : "warning
// C4251: 'A3DVisitorColorMaterials::m_apsCascadedAttribute' : class 'std::vector<_Ty>' needs to have dll-interface to
// be used by clients of class 'A3DVisitorColorMaterials"
// This is because of the "dllexport" on the visitor classes, as they use stl members and it seems that stl causes
// warning with dllexport with microsoft compiler
#endif // _MSC_VER
unsigned m_uOption;
void* m_pYourEntity;
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
public:
A3DTreeVisitor(A3DVisitorContainer* psContainer = NULL) : A3DVisitor("Tree", psContainer)
{
m_uOption = 0;
m_pYourEntity = NULL;
}
virtual ~A3DTreeVisitor() {};
virtual A3DStatus visitEnter(const A3DRiBrepModelConnector& sConnector);
virtual A3DStatus visitLeave(const A3DRiBrepModelConnector& sConnector);
virtual A3DStatus visitEnter(const A3DRiSetConnector& sConnector);
virtual A3DStatus visitLeave(const A3DRiSetConnector& sConnector);
virtual A3DStatus visitEnter(const A3DRiConnector& sConnector);
virtual A3DStatus visitLeave(const A3DRiConnector& sConnector);
virtual A3DStatus visitEnter(const A3DPartConnector& sConnector );
virtual A3DStatus visitLeave(const A3DPartConnector& sConnector);
virtual A3DStatus visitEnter(const A3DProductOccurrenceConnector& sConnector);
virtual A3DStatus visitLeave(const A3DProductOccurrenceConnector& sConnector);
virtual A3DStatus visitEnter(const A3DMkpViewConnector& sConnector);
virtual A3DStatus visitLeave(const A3DMkpViewConnector& sConnector);
void SetYourEntity(void* pYourEnity);
};
#endif

183
exchange/exchangesource/Collision/visitor/Visitors.h Normal file
View File

@@ -0,0 +1,183 @@
/***********************************************************************************************************************
*
* 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.
*
***********************************************************************************************************************/
#ifndef A3D_VISITOR
#define A3D_VISITOR
#define CONNECT_TRANSFO 0x0001
#define CONNECT_COLORS 0x0002
#define CONNECT_MESH 0x0004
#define CONNECT_ASSEMBLY_TREE 0x008
#define CONNECT_BREP 0x0010
#define CONNECT_PMI 0x00020
#define CONNECT_VIEWS 0x00040
#define CONNECT_FEATURE 0x00080
#include "TreeTraverse.h"
#ifdef CONNECT_PMI
#include "MarkupTraverse.h"
#endif
#ifdef CONNECT_BREP
#include "BrepTraverse.h"
#endif
#ifdef CONNECT_PMI
#include "MarkupTraverse.h"
#endif
#ifdef CONNECT_MESH
#include "TessConnector.h"
#endif
#ifdef CONNECT_VIEWS
#include "ViewTraverse.h"
#endif
#include <string>
#ifndef CHECK_RET
#define CHECK_RET(function) { if ((iRet = function)!=A3D_SUCCESS) { /*__debugbreak();*/ return iRet; }}
#endif
class A3DConnector;
class A3DVisitorContainer;
class A3DVisitor
{
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4251) // Suppress the warning C4251 because it leads to have that kind of warning : "warning
// C4251: 'A3DVisitorColorMaterials::m_apsCascadedAttribute' : class 'std::vector<_Ty>' needs to have dll-interface to
// be used by clients of class 'A3DVisitorColorMaterials"
// This is because of the "dllexport" on the visitor classes, as they use stl members and it seems that stl causes
// warning with dllexport with microsoft compiler
#endif // _MSC_VER
protected:
A3DVisitorContainer* m_psContainer;
std::string m_strName;
#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER
public :
A3DVisitor(std::string strName, A3DVisitorContainer* psContainer = NULL)
: m_strName(strName), m_psContainer(psContainer){}
virtual ~A3DVisitor() {}
virtual std::string GetName() const { return m_strName; }
//Assembly
#ifdef CONNECT_ASSEMBLY_TREE
virtual A3DStatus visitEnter(const A3DModelFileConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DModelFileConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DProductOccurrenceConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DProductOccurrenceConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DPartConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DPartConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DRiConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DRiConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DRiBrepModelConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DRiBrepModelConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DRiSetConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DRiSetConnector& /*sConnector*/) { return A3D_SUCCESS;}
virtual A3DStatus visitEnter(const A3DPolyRiBrepModelConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DPolyRiBrepModelConnector& /*sConnector*/) { return A3D_SUCCESS; }
#endif
//Markup
#ifdef CONNECT_PMI
virtual A3DStatus visitEnter(const A3DMkpAnnotationEntityConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMkpAnnotationEntityConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DMkpAnnotationSetConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMkpAnnotationSetConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DMkpAnnotationItemConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMkpAnnotationItemConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DMarkupConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMarkupConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DMarkupDimensionConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMarkupDimensionConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DMarkupGDTConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMarkupGDTConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DMarkupDatumConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMarkupDatumConnector& /*sConnector*/) { return A3D_SUCCESS; }
#endif
//Brep
#ifdef CONNECT_BREP
virtual A3DStatus visitEnter(const A3DBrepDataConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DBrepDataConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DConnexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DConnexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DShellConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DShellConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DFaceConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DFaceConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DLoopConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DLoopConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DCoEdgeConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DCoEdgeConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DEdgeConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DEdgeConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DUniqueVertexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DUniqueVertexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DMultipleVertexConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMultipleVertexConnector&) { return A3D_SUCCESS; }
#endif
//Mesh
#ifdef CONNECT_MESH
virtual A3DStatus visitEnter(const A3DTessDataConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DTessDataConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DFaceTessDataConnector&) {return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DFaceTessDataConnector&) {return A3D_SUCCESS; }
#endif
//Views
#ifdef CONNECT_VIEWS
virtual A3DStatus visitEnter(const A3DMkpViewConnector&) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DMkpViewConnector&) { return A3D_SUCCESS; }
#endif
#ifdef CONNECT_FEATURE
virtual A3DStatus visitEnter(const A3DFRMFeatureConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DFRMFeatureConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DFRMParameterConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DFRMParameterConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DFRMFeatureTreeConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DFRMFeatureTreeConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitEnter(const A3DFRMFeatureLinkedItemConnector& /*sConnector*/) { return A3D_SUCCESS; }
virtual A3DStatus visitLeave(const A3DFRMFeatureLinkedItemConnector& /*sConnector*/) { return A3D_SUCCESS; }
#endif
};
#endif