Skip to main content

CSG Geometric Kernel

Constructive Solid Geometry boolean operations (Union, Subtract, Intersect).

Subsystem Metrics​

  • Total Documented Functions: 63
  • Functions Exercised in Tests: 3
  • Platform-Divergent Implementations: 1
  • Component Source Files: 2

Source Files​

View all 2 source files in this subsystem
Source FilePath
CSGKernel.cppCSG/CSGKernel.cpp
CSGKernel.hCSG/CSGKernel.h

Function Reference​

1. CSGMeshFactorySgCore::createMesh​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

CSGMesh* CSGMeshFactorySgCore::createMesh();
PropertyValue
Return TypeCSGMesh*
ModifiersNone
Source LocationCSG/CSGKernel.cpp:39
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes createMesh within CSG Geometric Kernel. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Dynamic heap allocation via C++ operator new.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on createMesh.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


2. CSGMeshSgCore::weldMesh​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::weldMesh(bool positionOnly);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:44
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes weldMesh within CSG Geometric Kernel. Coordinates interactions with resize, size, swap, reserve.

  • Control Flow & Execution: Iterative loop processing, Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: resize, size, swap, reserve, length, push_back, unsigned.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on weldMesh.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


3. CSGMeshSgCore::EditData::clone​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

sgCObject* CSGMeshSgCore::EditData::clone() const;
PropertyValue
Return TypesgCObject*
Modifiersconst
Source LocationCSG/CSGKernel.cpp:116
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes clone within CSG Geometric Kernel. Coordinates interactions with brepFromBinaryString, getBRepBinaryString.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: brepFromBinaryString, getBRepBinaryString.

How it is Used in Tests​

This function is exercised in 7 test case(s):

  • Instance::Clone (App.UnitTest/Instance.cpp:86)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK_EQUAL(count, RBX::Diagnostics::Countable<RBX::Instance>::getCount())
    • Callsite Snippet: i->clone(RBX::ScriptingCreator);
  • WebSerializer::TestInstanceClone (App.UnitTest/WebSerializerTest.cpp:135)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(cloneModel), BOOST_CHECK(clonePart0), BOOST_CHECK(clonePart1), BOOST_CHECK(cloneWeld), BOOST_CHECK(cloneWeld->getPart0())
    • Callsite Snippet: shared_ptr<Instance> cloneModel = model->clone(EngineCreator);
  • WebSerializer::TestInstanceCloneExternal (App.UnitTest/WebSerializerTest.cpp:164)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(cloneWeld), BOOST_CHECK(cloneWeld->getPart0()), BOOST_CHECK(cloneWeld->getPart0() == part0.get()), BOOST_CHECK(cloneWeld->getPart1()), BOOST_CHECK(cloneWeld->getPart1() == part1.get())
    • Callsite Snippet: shared_ptr<ManualWeld> cloneWeld = Instance::fastSharedDynamicCast<ManualWeld>(weld->clone(EngineCreator));
  • CustomEvents::CloneEventAndReceiver (App.UnitTest/CustomEvents.cpp:491)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_REQUIRE(clonedEvent), BOOST_REQUIRE(clonedReceiver), BOOST_REQUIRE_EQUAL(1, clonedEvent->getAttachedReceivers()->size()), BOOST_REQUIRE_EQUAL(clonedEvent.get(), clonedReceiver->getSource())
    • Callsite Snippet: shared_ptr<Instance> clone(partParent->clone(RBX::ScriptingCreator));

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


4. CSGMeshSgCore::EditData::destroy​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::EditData::destroy();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:123
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes destroy within CSG Geometric Kernel. Coordinates interactions with sgDeleteObject.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: sgDeleteObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on destroy.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


5. CSGMeshSgCore::EditData::setShape​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::EditData::setShape(sgCObject* shapeIn);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:130
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes setShape within CSG Geometric Kernel. Coordinates interactions with destroy.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: destroy.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setShape.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


6. initKernelOnce​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void initKernelOnce();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:136
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes initKernelOnce within CSG Geometric Kernel. Coordinates interactions with sgInitKernel, AutoTriangulate.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: sgInitKernel, AutoTriangulate.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on initKernelOnce.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


7. initKernel​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void initKernel();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:142
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes initKernel within CSG Geometric Kernel. Coordinates interactions with call_once.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: call_once.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on initKernel.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


8. editData​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

: editData(this);
PropertyValue
Return Type:
ModifiersNone
Source LocationCSG/CSGKernel.cpp:150
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes editData within CSG Geometric Kernel. Coordinates interactions with initKernel.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: initKernel.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on editData.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


9. editData​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

: editData(this);
PropertyValue
Return Type:
ModifiersNone
Source LocationCSG/CSGKernel.cpp:156
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes editData within CSG Geometric Kernel. Coordinates interactions with initKernel.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: initKernel.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on editData.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


10. removeAllDXFFiles​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void removeAllDXFFiles();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:186
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes removeAllDXFFiles within CSG Geometric Kernel. Coordinates interactions with getUserDirectory, empty, iter, path.

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getUserDirectory, empty, iter, path, extension, compare, remove.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on removeAllDXFFiles.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


11. removePreviousErrorFiles​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void removePreviousErrorFiles();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:201
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes removePreviousErrorFiles within CSG Geometric Kernel. Coordinates interactions with empty, remove, c_str, removeAllDXFFiles.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: empty, remove, c_str, removeAllDXFFiles.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on removePreviousErrorFiles.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


12. logError​

Status: ⚪ Untested in Suites  |  ⚠️ Platform Divergent

void logError(sgCObject* obj1, sgCObject* obj2, bool unionOperation = true);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:216
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes logError within CSG Geometric Kernel. Coordinates interactions with defined, removePreviousErrorFiles, getMainLogManager, MakeLogFileName.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: defined, removePreviousErrorFiles, getMainLogManager, MakeLogFileName, substr, size, sgGetScene, AttachObject, ExportDXF, c_str, DetachObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on logError.

Behavioral Differences Across Code Files​

Divergence Analysis: Behavior branches internally via conditional compilation for: Windows (Win32/x64 API). Alternative platform-specific implementations exist in: Win/VideoControl.cpp.

  • Platform Preprocessor Guards: Windows (Win32/x64 API)
  • Alternative Implementation Files: Win/VideoControl.cpp

13. gatherGroup​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void gatherGroup(sgCGroup* group, std::vector<sgC3DObject*>& objects);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:237
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes gatherGroup within CSG Geometric Kernel. Coordinates interactions with GetChildrenList, GetHead, gather3DObjects, GetNext.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetChildrenList, GetHead, gather3DObjects, GetNext.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on gatherGroup.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


14. gather3DObjects​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void gather3DObjects(sgCObject* obj, std::vector<sgC3DObject*>& objects);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:247
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes gather3DObjects within CSG Geometric Kernel. Coordinates interactions with GetType, gatherGroup, push_back, Clone.

  • Control Flow & Execution: Multi-case state dispatch.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetType, gatherGroup, push_back, Clone.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on gather3DObjects.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


15. applyMatrixToGroup​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void applyMatrixToGroup(sgCGroup* group, const sgCMatrix& matrix);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:268
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyMatrixToGroup within CSG Geometric Kernel. Coordinates interactions with GetChildrenList, GetHead, applyMatrixTo3DObjects, GetNext.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetChildrenList, GetHead, applyMatrixTo3DObjects, GetNext.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyMatrixToGroup.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


16. applyMatrixTo3DObjects​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void applyMatrixTo3DObjects(sgCObject* obj, const sgCMatrix& matrix);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:278
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyMatrixTo3DObjects within CSG Geometric Kernel. Coordinates interactions with GetType, applyMatrixToGroup, Transform.

  • Control Flow & Execution: Multi-case state dispatch.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetType, applyMatrixToGroup, Transform.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyMatrixTo3DObjects.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


17. applyColorToGroup​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void applyColorToGroup(sgCGroup* group, const Vector3& value);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:301
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyColorToGroup within CSG Geometric Kernel. Coordinates interactions with GetChildrenList, GetHead, applyColorTo3DObjects, GetNext.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetChildrenList, GetHead, applyColorTo3DObjects, GetNext.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyColorToGroup.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


18. applyColorTo3DObjects​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void applyColorTo3DObjects(sgCObject* obj, const Vector3& value);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:311
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyColorTo3DObjects within CSG Geometric Kernel. Coordinates interactions with GetType, applyColorToGroup, SetColor.

  • Control Flow & Execution: Multi-case state dispatch.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetType, applyColorToGroup, SetColor.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyColorTo3DObjects.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


19. applyScaleToGroup​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void applyScaleToGroup(sgCGroup* group, const Vector3& scale);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:337
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyScaleToGroup within CSG Geometric Kernel. Coordinates interactions with GetChildrenList, GetHead, applyScaleTo3DObjects, GetNext.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetChildrenList, GetHead, applyScaleTo3DObjects, GetNext.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyScaleToGroup.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


20. applyScaleTo3DObjects​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void applyScaleTo3DObjects(sgCObject* obj, const Vector3& scale);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:347
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyScaleTo3DObjects within CSG Geometric Kernel. Coordinates interactions with GetType, applyScaleToGroup, Scale.

  • Control Flow & Execution: Multi-case state dispatch.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetType, applyScaleToGroup, Scale.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyScaleTo3DObjects.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


21. applyTranslationToGroup​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void applyTranslationToGroup(sgCGroup* group, const Vector3& translation);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:373
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyTranslationToGroup within CSG Geometric Kernel. Coordinates interactions with GetChildrenList, GetHead, applyTranslationTo3DObjects, GetNext.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetChildrenList, GetHead, applyTranslationTo3DObjects, GetNext.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyTranslationToGroup.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


22. applyTranslationTo3DObjects​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void applyTranslationTo3DObjects(sgCObject* obj, const Vector3& translation);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:383
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyTranslationTo3DObjects within CSG Geometric Kernel. Coordinates interactions with GetType, applyTranslationToGroup, Translate.

  • Control Flow & Execution: Multi-case state dispatch.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetType, applyTranslationToGroup, Translate.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyTranslationTo3DObjects.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


23. calcFlatNormal​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void calcFlatNormal(CSGVertex& vertA, CSGVertex& vertB, CSGVertex& vertC);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:407
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes calcFlatNormal within CSG Geometric Kernel. Coordinates interactions with cross.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: cross.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on calcFlatNormal.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


24. calcFlatTangent​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void calcFlatTangent(CSGVertex& vertA, CSGVertex& vertB, CSGVertex& vertC);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:417
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes calcFlatTangent within CSG Geometric Kernel. Coordinates interactions with Vector3.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: Vector3.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on calcFlatTangent.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


25. averageNormal​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void averageNormal(Vector3& resultNormal,
const Vector3& posA,
const Vector3& posB,
const Vector3& normalA,
const Vector3& normalB);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:448
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes averageNormal within CSG Geometric Kernel. Coordinates interactions with cos, toRadians, fabs, unit.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: cos, toRadians, fabs, unit, dot.
  • External Library Dependencies: G3D Graphics and Math Engine.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on averageNormal.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


26. calcSmoothNormal​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void calcSmoothNormal(CSGVertex& vert, Vector3& normal, const std::vector<CSGVertex>& vertices, std::vector<unsigned int>& indices);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:471
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes calcSmoothNormal within CSG Geometric Kernel. Coordinates interactions with size, averageNormal.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: size, averageNormal.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on calcSmoothNormal.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


27. calcSmoothTangent​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void calcSmoothTangent(CSGVertex& vert, Vector3& tangent, const std::vector<CSGVertex>& vertices, std::vector<unsigned int>& indices);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:480
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes calcSmoothTangent within CSG Geometric Kernel. Coordinates interactions with size, averageNormal.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: size, averageNormal.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on calcSmoothTangent.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


28. calcUV​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void calcUV(CSGVertex& vert);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:489
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes calcUV within CSG Geometric Kernel. Coordinates interactions with unit, fabs, generateUv.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: unit, fabs, generateUv.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on calcUV.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


29. calcFlat​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void calcFlat(Vector3& normal, unsigned int& uvr,
CSGVertex& vertA, CSGVertex& vertB, CSGVertex& vertC);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:511
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes calcFlat within CSG Geometric Kernel. Coordinates interactions with cross, fabs.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: cross, fabs.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on calcFlat.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


30. calcFlatTangent​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void calcFlatTangent(Vector3& tangent, CSGVertex& vertA, CSGVertex& vertB, CSGVertex& vertC);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:531
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes calcFlatTangent within CSG Geometric Kernel. Coordinates interactions with Vector3.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: Vector3.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on calcFlatTangent.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


31. triangulateGroup​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool triangulateGroup(sgCGroup* group, unsigned int& counter, std::vector<CSGVertex>& vertices, std::vector<unsigned int>& indices);
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:562
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes triangulateGroup within CSG Geometric Kernel. Coordinates interactions with GetChildrenList, GetHead, triangulateObject, GetNext.

  • Control Flow & Execution: Iterative loop processing, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetChildrenList, GetHead, triangulateObject, GetNext.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on triangulateGroup.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


32. triangulate3D​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool triangulate3D(sgC3DObject* object, unsigned int& index, std::vector<CSGVertex>& vertices, std::vector<unsigned int>& indices);
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:573
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes triangulate3D within CSG Geometric Kernel. Coordinates interactions with Triangulate, SetMaterial, GetTriangles, Color4uint8.

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: Triangulate, SetMaterial, GetTriangles, Color4uint8, Vector3, push_back.
  • External Library Dependencies: OpenGL / GLES Graphics API.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on triangulate3D.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


33. triangulateObject​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool triangulateObject(sgCObject* obj, unsigned int& counter, std::vector<CSGVertex>& vertices, std::vector<unsigned int>& indices);
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:621
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes triangulateObject within CSG Geometric Kernel. Coordinates interactions with GetType, triangulateGroup, triangulate3D.

  • Control Flow & Execution: Multi-case state dispatch, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: GetType, triangulateGroup, triangulate3D.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on triangulateObject.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


34. CSGMeshSgCore::newTriangulate​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool CSGMeshSgCore::newTriangulate();
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:635
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes newTriangulate within CSG Geometric Kernel. Coordinates interactions with clear, getShape, triangulateObject, size. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: Dynamic heap allocation via C++ operator new; Heap memory deallocation via operator delete.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: clear, getShape, triangulateObject, size, resize, clusterVertices, begin, end, erase, makeHalfEdges, calcFlat, cos.
  • External Library Dependencies: G3D Graphics and Math Engine.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on newTriangulate.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


35. CSGMeshSgCore::triangulate​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::triangulate();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:900
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes triangulate within CSG Geometric Kernel. Coordinates interactions with clear, getShape, triangulateObject, resize.

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: clear, getShape, triangulateObject, resize, size, calcFlatNormal, calcUV, calcFlatTangent, calcSmoothNormal, calcSmoothTangent, length, unit.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on triangulate.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


36. CSGMeshSgCore::sgCoreUnion​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool CSGMeshSgCore::sgCoreUnion(const CSGMeshSgCore& a, const CSGMeshSgCore& b);
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:947
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes sgCoreUnion within CSG Geometric Kernel. Coordinates interactions with getShape, gather3DObjects, size, logError.

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getShape, gather3DObjects, size, logError, Union, GetChildrenList, GetCount, allChildren, BreakGroup, sgDeleteObject, push_back, resize.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on sgCoreUnion.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


37. CSGMeshSgCore::sgCoreSubtract​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool CSGMeshSgCore::sgCoreSubtract(const CSGMeshSgCore& a, const CSGMeshSgCore& b);
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1022
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes sgCoreSubtract within CSG Geometric Kernel. Coordinates interactions with getShape, gather3DObjects, size, logError.

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getShape, gather3DObjects, size, logError, Sub, sgDeleteObject, GetChildrenList, GetCount, allChildren, BreakGroup, push_back, resize.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on sgCoreSubtract.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


38. CSGMeshSgCore::unionMesh​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool CSGMeshSgCore::unionMesh(const CSGMesh* a, const CSGMesh* b);
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1110
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes unionMesh within CSG Geometric Kernel. Coordinates interactions with sgCoreUnion.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: sgCoreUnion.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on unionMesh.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


39. CSGMeshSgCore::intersectMesh​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool CSGMeshSgCore::intersectMesh(const CSGMesh* a, const CSGMesh* b);
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1121
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes intersectMesh within CSG Geometric Kernel.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on intersectMesh.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


40. CSGMeshSgCore::subractMesh​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool CSGMeshSgCore::subractMesh(const CSGMesh* a, const CSGMesh* b);
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1127
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes subractMesh within CSG Geometric Kernel. Coordinates interactions with sgCoreSubtract.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: sgCoreSubtract.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on subractMesh.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


41. CSGMeshSgCore::applyCoordinateFrame​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::applyCoordinateFrame(CoordinateFrame cFrame);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1138
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyCoordinateFrame within CSG Geometric Kernel. Coordinates interactions with getShape, matrix, applyMatrixTo3DObjects, applyTranslationTo3DObjects.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getShape, matrix, applyMatrixTo3DObjects, applyTranslationTo3DObjects.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyCoordinateFrame.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


42. CSGMeshSgCore::applyTranslation​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::applyTranslation(const G3D::Vector3& trans);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1171
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyTranslation within CSG Geometric Kernel. Coordinates interactions with getShape, applyTranslationTo3DObjects.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getShape, applyTranslationTo3DObjects.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyTranslation.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


43. CSGMeshSgCore::applyScale​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::applyScale(const G3D::Vector3& scale);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1178
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyScale within CSG Geometric Kernel. Coordinates interactions with getShape, applyScaleTo3DObjects.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getShape, applyScaleTo3DObjects.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyScale.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


44. CSGMeshSgCore::applyColor​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::applyColor(const G3D::Vector3& color);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1186
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes applyColor within CSG Geometric Kernel. Coordinates interactions with getShape, applyColorTo3DObjects.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getShape, applyColorTo3DObjects.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on applyColor.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


45. CSGMeshSgCore::buildBRep​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::buildBRep();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1194
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes buildBRep within CSG Geometric Kernel. Coordinates interactions with size, float, push_back, setShape.

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: size, float, push_back, setShape, ObjectFromTriangles, int, getShape.
  • External Library Dependencies: OpenGL / GLES Graphics API.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on buildBRep.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


46. CSGMeshSgCore::getBRepBinaryString​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

std::string CSGMeshSgCore::getBRepBinaryString() const;
PropertyValue
Return Typestd::string
Modifiersconst
Source LocationCSG/CSGKernel.cpp:1229
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes getBRepBinaryString within CSG Geometric Kernel. Coordinates interactions with getShape, ObjectToBitArray, write, str.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: getShape, ObjectToBitArray, write, str.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getBRepBinaryString.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


47. CSGMeshSgCore::brepFromBinaryString​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

sgCObject* CSGMeshSgCore::brepFromBinaryString(const std::string& str) const;
PropertyValue
Return TypesgCObject*
Modifiersconst
Source LocationCSG/CSGKernel.cpp:1248
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes brepFromBinaryString within CSG Geometric Kernel. Coordinates interactions with empty, stream, read, resize.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: empty, stream, read, resize, BitArrayToObject, c_str, size.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on brepFromBinaryString.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


48. CSGMeshSgCore::setBRepFromBinaryString​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::setBRepFromBinaryString(const std::string& str);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1270
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes setBRepFromBinaryString within CSG Geometric Kernel. Coordinates interactions with empty, brepFromBinaryString, setShape.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: empty, brepFromBinaryString, setShape.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setBRepFromBinaryString.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


49. CSGMeshSgCore::isValid​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

bool CSGMeshSgCore::isValid() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationCSG/CSGKernel.cpp:1284
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes isValid within CSG Geometric Kernel. Coordinates interactions with getShape.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: getShape.

How it is Used in Tests​

This function is exercised in 3 test case(s):

  • URLParser::Split (App.UnitTest/URLParserTest.cpp:7)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(url.isValid())
    • Callsite Snippet: BOOST_CHECK(url.isValid());
  • URLParser::Normalization (App.UnitTest/URLParserTest.cpp:76)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(url.isValid())
    • Callsite Snippet: BOOST_CHECK(url.isValid());
  • URLParser::Invalid (App.UnitTest/URLParserTest.cpp:128)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(!url.isValid()), BOOST_CHECK(!url.isValid()), BOOST_CHECK(!url.isValid())
    • Callsite Snippet: BOOST_CHECK(!url.isValid());

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


50. CSGMeshSgCore::clone​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

CSGMesh* CSGMeshSgCore::clone() const;
PropertyValue
Return TypeCSGMesh*
Modifiersconst
Source LocationCSG/CSGKernel.cpp:1289
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes clone within CSG Geometric Kernel. Coordinates interactions with CSGMeshSgCore. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Dynamic heap allocation via C++ operator new.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: CSGMeshSgCore.

How it is Used in Tests​

This function is exercised in 7 test case(s):

  • Instance::Clone (App.UnitTest/Instance.cpp:86)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK_EQUAL(count, RBX::Diagnostics::Countable&lt;RBX::Instance&gt;::getCount())
    • Callsite Snippet: i-&gt;clone(RBX::ScriptingCreator);
  • WebSerializer::TestInstanceClone (App.UnitTest/WebSerializerTest.cpp:135)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(cloneModel), BOOST_CHECK(clonePart0), BOOST_CHECK(clonePart1), BOOST_CHECK(cloneWeld), BOOST_CHECK(cloneWeld-&gt;getPart0())
    • Callsite Snippet: shared_ptr&lt;Instance&gt; cloneModel = model-&gt;clone(EngineCreator);
  • WebSerializer::TestInstanceCloneExternal (App.UnitTest/WebSerializerTest.cpp:164)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(cloneWeld), BOOST_CHECK(cloneWeld-&gt;getPart0()), BOOST_CHECK(cloneWeld-&gt;getPart0() == part0.get()), BOOST_CHECK(cloneWeld-&gt;getPart1()), BOOST_CHECK(cloneWeld-&gt;getPart1() == part1.get())
    • Callsite Snippet: shared_ptr&lt;ManualWeld&gt; cloneWeld = Instance::fastSharedDynamicCast&lt;ManualWeld&gt;(weld-&gt;clone(EngineCreator));
  • CustomEvents::CloneEventAndReceiver (App.UnitTest/CustomEvents.cpp:491)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_REQUIRE(clonedEvent), BOOST_REQUIRE(clonedReceiver), BOOST_REQUIRE_EQUAL(1, clonedEvent-&gt;getAttachedReceivers()-&gt;size()), BOOST_REQUIRE_EQUAL(clonedEvent.get(), clonedReceiver-&gt;getSource())
    • Callsite Snippet: shared_ptr&lt;Instance&gt; clone(partParent-&gt;clone(RBX::ScriptingCreator));

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


51. CSGClustering::addPos​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

CSGClustering::IPosClassMap::iterator CSGClustering::addPos(uint64 key, int indx);
PropertyValue
Return TypeCSGClustering::IPosClassMap::iterator
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1305
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes addPos within CSG Geometric Kernel. Coordinates interactions with find, end, insert, size.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: find, end, insert, size, push_back, value_type.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on addPos.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


52. CSGClustering::mergeClasses​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGClustering::mergeClasses(IPosClassMap::iterator it[8]);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1325
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes mergeClasses within CSG Geometric Kernel. Coordinates interactions with insert, size, begin, end.

  • Control Flow & Execution: Iterative loop processing, Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: insert, size, begin, end, clear.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on mergeClasses.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


53. CSGClustering::addPosClasses​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGClustering::addPosClasses(G3D::uint64 key[8], int indx);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1356
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes addPosClasses within CSG Geometric Kernel. Coordinates interactions with addPos, mergeClasses.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: addPos, mergeClasses.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on addPosClasses.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


54. CSGClustering::makeKey​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

uint64 CSGClustering::makeKey(const v3i2& v, unsigned int ii);
PropertyValue
Return Typeuint64
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1366
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes makeKey within CSG Geometric Kernel. Coordinates interactions with return.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: return.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on makeKey.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


55. CSGClustering::cluster​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGClustering::cluster();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1379
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes cluster within CSG Geometric Kernel. Coordinates interactions with size, floor, makeKey, addPosClasses.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: size, floor, makeKey, addPosClasses.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on cluster.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


56. CSGClustering::extractVertices​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

size_t CSGClustering::extractVertices();
PropertyValue
Return Typesize_t
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1397
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes extractVertices within CSG Geometric Kernel. Coordinates interactions with size, empty, begin, push_back.

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: size, empty, begin, push_back, max, end, swap.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on extractVertices.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


57. CSGMeshSgCore::clusterVertices​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

size_t CSGMeshSgCore::clusterVertices(float resolution);
PropertyValue
Return Typesize_t
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1420
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes clusterVertices within CSG Geometric Kernel. Coordinates interactions with makeExtents, min, size, max.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: makeExtents, min, size, max, clustering, cluster, extractVertices.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on clusterVertices.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


58. CSGMeshSgCore::makeExtents​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::makeExtents();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1436
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes makeExtents within CSG Geometric Kernel. Coordinates interactions with negativeMaxExtents, begin, end, expandToContain.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: negativeMaxExtents, begin, end, expandToContain.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on makeExtents.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


59. CSGMeshSgCore::translate​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void CSGMeshSgCore::translate(const G3D::Vector3& translation);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1444
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes translate within CSG Geometric Kernel. Coordinates interactions with size, shift.

  • Control Flow & Execution: Iterative loop processing.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: size, shift.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on translate.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


60. CSGMeshSgCore::makeHalfEdges​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool CSGMeshSgCore::makeHalfEdges(std::vector< int>& vertexEdges);
PropertyValue
Return Typebool
ModifiersNone
Source LocationCSG/CSGKernel.cpp:1464
SubsystemCSG Geometric Kernel

How it Works Internally​

Executes makeHalfEdges within CSG Geometric Kernel. Coordinates interactions with size, resize, insert, value_type.

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: size, resize, insert, value_type, find, end.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on makeHalfEdges.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


Additional Functions

There are 3 additional internal and inline functions in this subsystem. All functions are indexed and cross-referenced in the Complete Function Catalog.