SmApiBrep.h

Fully qualified name: SM_API/inc/SmApiBrep.h

File members: SM_API/inc/SmApiBrep.h

// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

/**********************************************************************
FILE NAME: SmBrep.h

PURPOSE:
    Contains high level "C" type functions that operate on SmBreps.

GENERAL NOTES:
    High level functions may assume some input parameters
    for ease of use. For maximum flexibility, related functions
    can be found in SmMerge, etc
**********************************************************************/

#ifndef __SmApiBrep_H__
#define __SmApiBrep_H__

#ifndef __SmApiTypes_H__
#include <SmApiTypes.h>
#endif

#include <SmMerge.h>
#include <SmPrimitiveCreation.h>
#include <SmFilletSolver.h>
#include <SmTArray.h>
#include <SmApiTessellationParams.h>

class SmContext;
class SmBrep;
class SmPolyBrep;
class SmEdge;
class SmFace;
class SmVertex;
class SmSurface;
class SmBSplineCurve;
class SmSweepOptions;

SMAPI_EXPORT SmApiStatus SmApiBoolean(
    SmBrep*  pBrep1,
    SmBrep*  pBrep2,
    SmBooleanOperationType lOperation,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiBooleanUnion(
    SmBrep*  pBrep1,
    SmBrep*  pBrep2,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiBooleanDifference(
    SmBrep*  pBrep1,
    SmBrep*  pBrep2,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiBooleanIntersection(
    SmBrep*  pBrep1,
    SmBrep*  pBrep2,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiBooleanMerge(
    SmBrep*  pBrep1,
    SmBrep*  pBrep2,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiMergeBreps(
    SmTArray<SmBrep*>& rBreps,
    SmBooleanOperationType lOperation,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiBooleanWithCurves(
    SmBrep*  pBrep1,
    SmBrep*  pBrep2,
    SmBooleanOperationType lOperation,
    SmBrep*& rpResult,
    SmTArray<SmEdge*>& rIntersectionEdges
);

SMAPI_EXPORT SmApiStatus SmApiBoolean2d(
  SmBrep*  pBrep1,
  SmBrep*  pBrep2,
  Sm2DBooleanOperationType eOpType,
  SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiTessellate(
    SmBrep* pBrep,
    SmPolyBrep*& rpResult,
    const SmTessellationParams& rParams = SmTessellationParams(),
    SmBoolean bAllowPartial = FALSE,
    SmTArray<SmTessellationFailure>* pFailures = nullptr,
    SmTessellationReport* pReport = nullptr
);

SMAPI_EXPORT SmApiStatus SmApiTessellateBoundaries(
    SmBrep* pBrep,
    double dAngleTolDeg,
    SmTArray<SmPoint3d>& rPoints,
    SmTArray<ULONG>& rVertexCounts,
    SmTArray<SmEdge*>& rEdges
);

SMAPI_EXPORT SmApiStatus SmApiTurnToNurbs(
    SmBrep*  pBrep
);

SMAPI_EXPORT SmApiStatus SmApiProjectBrepOntoPlane(
    SmBrep*  pBrep,
    const SmVector3d& rPlanePt,
    const SmVector3d& rPlaneNormal,
    SmTArray<SmCurve*>& rProjectionCurves
);

SMAPI_EXPORT SmApiStatus SmApiCut(
    SmBrep*  pBrep,
    const SmVector3d& rPlanePt,
    const SmVector3d& rPlaneNormal
);

SMAPI_EXPORT SmApiStatus SmApiProjectAndTrim(
    SmBrep*  pBrep,
    SmBSplineCurve* rCurveToProject,
    const SmVector3d& rProjectionDir,
    const SmPoint3d& rRefPt
);

SMAPI_EXPORT SmApiStatus SmApiCreateSilhouetteCurves(
    SmBrep*  pBrep,
    const SmVector3d& rPlanePt,
    const SmVector3d& rPlaneNormal,
    SmTArray<SmCurve*>& rProjectionCurves
);

SMAPI_EXPORT SmApiStatus SmApiProjectCurve(
    SmBrep* pBrep,
    SmBSplineCurve* pCurveToProject,
    const SmVector3d& projectionVector,
    SmTArray<SmCurve*> & r3DCurves
);

SMAPI_EXPORT SmApiStatus SmApiStitch(
    SmBrep* pBrep
);

SMAPI_EXPORT SmApiStatus SmApiStitch(
    SmBrep* pBrep,
    SmFace* pFaceToStitch
);

// Family of Sweep Functions
// These all create SmBrep.
// For simple sweep functions that create a single surface, refer to SmSurfaces

SMAPI_EXPORT SmApiStatus SmApiCreateLinearSweep(
    const SmTArray<SmCurve*>& rCurvesToSweep,
    const SmVector3d& rSweepDir,
    double dSweepDist,
    SmBoolean bCapEnds,
    SmBrep*& rpResult
) ;

SMAPI_EXPORT SmApiStatus SmApiCreateRotationalSweep(
    const SmTArray<SmCurve*>& rCurvesToSweep,
    const SmPoint3d& rBasePt,
    const SmVector3d& rAxis,
    double dAngleDeg,
    SmBoolean bCapEnds,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiCreateDraftSweep(
    const SmTArray<SmCurve*>& rCurvesToSweep,
    double dHeight,
    double dAngleDeg,
    SmBoolean bCornerType,
    int iCapEnds,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiCreatePipeSweep(
    double              dPipeRadius,
    SmBSplineCurve    * pPathCurve,
    SmBoolean           bCapEnds,
    SmBrep*&            rpResult
);

SMAPI_EXPORT SmApiStatus SmApiCreateSweepAlongPlanarPath(
    SmTArray<SmCurve*>& rProfileCurves,
    SmTArray<SmCurve*>& rPathCurves,
    SmBoolean           bMoveProfile,
    int iCapEnds,
    SmBrep*& rpResult
);

// Advanced Sweep Functions

SMAPI_EXPORT SmApiStatus SmApiCreateCurveSweep(
    SmTArray<SmCurve*>& rProfileCurves,
    SmBSplineCurve* pPathCurve,
    SmBSplineCurve* pScaleReference,
    SmBSplineCurve* pScaleCurve,
    SmSweepOptions* pOptions,
    SmBrep*& rpResult,
    SmTArray<SmFace*>* pOptStartFaces,
    SmTArray<SmFace*>* pOptSideFaces,
    SmTArray<SmFace*>* pOptEndFaces
);

SMAPI_EXPORT SmApiStatus SmApiCreateCurveSweepFromFaces(
    SmTArray<SmFace*>& rFaces,
    SmBSplineCurve* pPathCurve,
    SmBSplineCurve* pScaleReference,
    SmBSplineCurve* pScaleCurve,
    SmSweepOptions* pOptions,
    SmBrep*& rpResult,
    SmTArray<SmFace*>* pOptStartFaces,
    SmTArray<SmFace*>* pOptSideFaces,
    SmTArray<SmFace*>* pOptEndFaces
);

SMAPI_EXPORT SmApiStatus SmApiCreateCurveSweepFromEdges(
    SmTArray<SmEdge*>& rEdges,
    SmBSplineCurve* pPathCurve,
    SmBSplineCurve* pScaleReference,
    SmBSplineCurve* pScaleCurve,
    SmSweepOptions* pOptions,
    SmBrep*& rpResult,
    SmTArray<SmFace*>* pOptStartFaces,
    SmTArray<SmFace*>* pOptSideFaces,
    SmTArray<SmFace*>* pOptEndFaces
);

SMAPI_EXPORT SmApiStatus SmApiCreateTaperExtrude(
    const SmTArray<SmCurve*>& rCurves,
    double dHeight,
    double dDraftAngleDeg,
    int iEndCaps,
    SmBoolean bFilletCorner,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiCreateLinearSweepWithRepetitions(
    const SmTArray<SmCurve*>& rCurvesToSweep,
    const SmVector3d& rSweepDir,
    double dSweepDist,
    ULONG nRepetitions,
    SmBoolean bCapEnds,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiCreateRotationalSweepWithRepetitions(
    const SmTArray<SmCurve*>& rCurvesToSweep,
    const SmPoint3d& rBasePt,
    const SmVector3d& rAxis,
    double dAngleDeg,
    ULONG nRepetitions,
    SmBoolean bCapEnds,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiNonManifoldSweep(
    SmBrep* pBrepToSweep,
    SmBrep* pRegionBrep,
    const SmVector3d& rSweepDir,
    double dSweepDist,
    SmBoolean bDoStitching,
    SmBoolean bDoMerge,
    SmTArray<SmFace*>* pOptFaces,
    SmTArray<SmEdge*>* pOptEdges,
    SmTArray<SmVertex*>* pOptVertices
);

SMAPI_EXPORT SmApiStatus SmApiNonManifoldRotationalSweep(
    SmBrep* pBrepToSweep,
    SmBrep* pRegionBrep,
    const SmPoint3d& rBasePt,
    const SmVector3d& rAxis,
    double dAngleDeg,
    SmBoolean bDoStitching,
    SmBoolean bDoMerge,
    SmTArray<SmFace*>* pOptFaces,
    SmTArray<SmEdge*>* pOptEdges,
    SmTArray<SmVertex*>* pOptVertices
);

// Advanced Boolean Functions

SMAPI_EXPORT SmApiStatus SmApiBooleanWithOptions(
    SmBrep* pBrep1,
    SmBrep* pBrep2,
    SmBooleanOperationType eOperation,
    SmBoolean bCookieCutter,
    SmBoolean bImprinting,
    SmBoolean bBooleanPostProcess,
    SmBoolean bImprintAndClassifyFaces,
    SmBoolean bKeepOtherBrep,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiNonManifoldBoolean(
    SmBrep* pBrep1,
    SmBrep* pBrep2,
    SmBooleanOperationType eOperation,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiPiecewiseMerge(
    SmBrep* pBrep1,
    SmBrep* pBrep2,
    SmBoolean bCreateNewBrepsForFaces,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiBooleanLists(
    const SmTArray<SmBrep*>& rBreps1,
    const SmTArray<SmSurface*>& rSurfaces1,
    const SmTArray<SmBrep*>& rBreps2,
    const SmTArray<SmSurface*>& rSurfaces2,
    int operation,
    SmTArray<SmBrep*>& rResultBreps,
    SmTArray<SmSurface*>& rResultSurfaces
);

SMAPI_EXPORT SmApiStatus SmApiBooleanTrees(
    SmTArray<SmBrep*>& rBreps,
    SmTArray<long>& rPostFixTrees
);

// Advanced Fillet Functions

SMAPI_EXPORT SmApiStatus SmApiFilletEdges(
    SmBrep* pBrep,
    SmTArray<SmEdge*>& rEdges,
    double dRadius,
    ULONG lXSectType,
    ULONG lContinuity,
    double dThumbweight
);

SMAPI_EXPORT SmApiStatus SmApiFilletEdgesPerEdge(
    SmBrep* pBrep,
    SmTArray<SmEdge*>& rEdges,
    SmTArray<double>& rRadii,
    SmTArray<SmFilletSurfaceGeneratorType>& rXSectTypes,
    ULONG lContinuity,
    double dThumbweight
);

SMAPI_EXPORT SmApiStatus SmApiVariableRadiusFillet(
    SmBrep* pBrep,
    SmTArray<SmEdge*>& rEdges,
    double dStartRadius,
    double dEndRadius,
    ULONG lXSectType,
    ULONG lContinuity
);

SMAPI_EXPORT SmApiStatus SmApiSurfaceSurfaceFillet(
    SmSurface* pSurface1,
    SmSurface* pSurface2,
    double dRadius1,
    double dRadius2,
    double dTolerance,
    SmBrep*& rpResult,
    ULONG lXSectType,
    SmBoolean bMirror,
    SmBoolean bComplement
);

SMAPI_EXPORT SmApiStatus SmApiFilletPreview(
    SmBrep* pBrep,
    SmTArray<SmEdge*>& rEdges,
    double dRadius,
    SmTArray<SmSurface*>& rPreviewSurfaces
);

SMAPI_EXPORT SmApiStatus SmApiSetBevelCorners(
    SmBrep* pBrep,
    SmTArray<SmEdge*>& rEdges,
    double dRadius,
    SmTArray<SmVertex*>& rBevelVertices
);

// Advanced Offset / Shell Functions

SMAPI_EXPORT SmApiStatus SmApiShellBrepFull(
    const SmBrep* pBrep,
    double dOffsetDistance,
    SmBoolean bDoExtendedOffset,
    SmBoolean bDoSelfInt,
    SmBoolean bCreateOffsetSolid,
    const SmTArray<const SmFace*>& rFacesToShell,
    SmBrep*& rpResult
);

SMAPI_EXPORT SmApiStatus SmApiOffsetBrepFull(
    SmBrep* pBrep,
    double dOffsetDistance,
    SmBoolean bDoExtendedOffset,
    SmBoolean bDoSelfInt,
    SmBrep*& rpResult
);

// Advanced Stitching Functions

SMAPI_EXPORT SmApiStatus SmApiStitchIntoSolid(
    SmBrep* pBrep,
    SmBoolean& rbProducesASolid,
    ULONG& rlStitchedEdges,
    double& rdMaxVertexGap,
    double& rdMaxEdgeGap
);

SMAPI_EXPORT SmApiStatus SmApiStitchIntoShell(
    SmBrep* pBrep,
    SmBoolean& rbShellIsWellFormed,
    double dMaxStitchingRatio,
    ULONG& rlStitchedEdges,
    double& rdMaxVertexGap,
    double& rdMaxEdgeGap
);

SMAPI_EXPORT SmApiStatus SmApiUnifyNormals(
    SmBrep* pBrep,
    SmFace* pStartFace,
    ULONG lNumSamples,
    SmTArray<SmFace*>& rFlippedFaces
);

SMAPI_EXPORT SmApiStatus SmApiSimpleFaceStitch(
    SmBrep* pBrep,
    const SmTArray<SmFace*>& rFacesToKeep,
    const SmTArray<SmFace*>& rFacesToDelete,
    ULONG& rlStitchedEdges,
    double& rdMaxVertexGap,
    double& rdMaxEdgeGap
);

SMAPI_EXPORT SmApiStatus SmApiStitchAdvanced(
    SmBrep* pBrep,
    double dStitchTol3d,
    SmBoolean bSqueezeSmallEdges,
    SmBoolean bSplitEdgesWithVertices,
    SmBoolean bMakingManifoldSolid,
    SmBoolean bRemoveLaminarSlivers,
    ULONG& rlStitchedEdges,
    ULONG& rlLaminaEdges,
    double& rdMaxVertexGap,
    double& rdMaxEdgeGap
);

#endif