Functions#

bool IsBrepStatusSuccess(BrepStatus status)
BrepStatus PlanFaceOuterLoop(uint32_t uiLoopCount, uint32_t uiSourceOuterLoopIndex, bool bClosedSurface, bool bAllLoopsCW, uint32_t uiCCWLoopCount, const std::vector< bool > &vLoopEffectivelyCCW, const std::vector< uint32_t > &vLoopCoedgeCount, SourceFaceOuterLoopData &rOuterLoopData)
SmStatus SMU_BrepConvert::AppendSmBrepData_ToUsdBrepArrayData(SmBrepData *pSmBrepData, SmTArray< SmAttribute * > &rAttributes, UsdBrepData::UsdBrepArrayData &rArrays, SmBrep *pOptSmBrep, pxr::SdfPathVector *pOptPaths)
SmStatus SMU_BrepConvert::ApplyUsdXformOp(SmCurve &rCurve, const pxr::UsdGeomXformOp &crXformOp)
SmStatus SMU_BrepConvert::ApplyUsdXformOp(SmBSplineSurface &rBSSurface, const pxr::UsdGeomXformOp &crXformOp)
SmStatus SMU_BrepConvert::ApplyUsdXformOp(SmBrep &rBrep, const pxr::UsdGeomXformOp &crXformOp)
SmStatus SMU_BrepConvert::BrepAppend_SMLibToUsd(std::vector< SmBrep * > &rSmBreps, pxr::UsdPrim &crUsdBrepArray, bool bExportUVCurves=true, bool bBoundUnboundedFaceRanges=false)
SmStatus SMU_BrepConvert::BrepAppend_SMLibToUsdBrep(std::vector< SmBrep * > &rSmBreps, UsdBrepData::UsdBrepArrayData &rArrays, pxr::SdfPathVector *pOptPaths=nullptr, bool bExportUVCurves=true, bool bBoundUnboundedFaceRanges=false)
SmStatus SMU_BrepConvert::BrepMove_OneUsdBrepToSMLib(const SmContext &crSmContext, const UsdBrepData::UsdBrepArrayData &rArrays, UsdBrepData::UsdBrepArraySpans &rSpans, uint32_t iBrepIndex, SmBrep *&prSmBrep_ii, SmBoolean bHealerIsEnabled=TRUE)
SmStatus SMU_BrepConvert::BrepMove_OneUsdBrepToSMLibData(const SmContext &crSmContext, const UsdBrepData::UsdBrepArrayData &rArrays, UsdBrepData::UsdBrepArraySpans &rSpans, uint32_t iBrepIndex, SmBrepData *&prSmBrepData_ii, SmTArray< SmAttribute * > &rAttributes)
SmStatus SMU_BrepConvert::BrepMove_UsdToSMLib(const SmContext &crSmContext, const pxr::UsdGeomGprim &crUsdBrepArray, std::vector< SmBrep * > &rSmBreps, SmBoolean bHealerIsEnabled=TRUE)
SmStatus SMU_BrepConvert::BrepMove_UsdToSMLibWithResults(const SmContext &crSmContext, const pxr::UsdGeomGprim &crUsdBrepArray, std::vector< BrepImportResult > &rResults, SmBoolean bHealerIsEnabled=TRUE, SmBoolean bStopAfterFailure=FALSE)
SmStatus SMU_BrepConvert::CreateSmBrep_FromUsdCapsule(const SmContext &crSmContext, const pxr::UsdGeomCapsule &crUsdCapsule, SmBrep *&prSmBrep)
SmStatus SMU_BrepConvert::CreateSmBrep_FromUsdCone(const SmContext &crSmContext, const pxr::UsdGeomCone &crUsdCone, SmBrep *&prSmBrep)
SmStatus SMU_BrepConvert::CreateSmBrep_FromUsdCube(const SmContext &crSmContext, const pxr::UsdGeomCube &crUsdCube, SmBrep *&prSmBrep)
SmStatus SMU_BrepConvert::CreateSmBrep_FromUsdCylinder(const SmContext &crSmContext, const pxr::UsdGeomCylinder &crUsdCylinder, SmBrep *&prSmBrep)
SmStatus SMU_BrepConvert::CreateSmBrep_FromUsdSphere(const SmContext &crSmContext, const pxr::UsdGeomSphere &crUsdSphere, SmBrep *&prSmBrep)
SmStatus SMU_BrepConvert::CreateSmPolyBrep_FromUsdMesh(const SmContext &crSmContext, const pxr::UsdGeomMesh &crUsdGeomMesh, SmPolyBrep *&prSmPolyBrep)
SmStatus SMU_BrepConvert::GetBoundaryData(SmBrep *pBrep, double dAngleTolDeg, pxr::VtArray< pxr::GfVec3f > &rPoints, pxr::VtIntArray &rVertexCounts)
SmStatus SMU_BrepConvert::GetMeshData(SmPolyBrep &crSmPolyBrep, pxr::VtArray< pxr::GfVec3f > &rExtent, pxr::VtArray< pxr::GfVec3f > &rPoints, pxr::VtIntArray &rFaceVertexCounts, pxr::VtIntArray &rFaceVertexIndices, pxr::VtArray< pxr::GfVec3f > &rPrimvarNormals, pxr::VtIntArray &rPrimvarNormalsIndices, pxr::TfToken &sPrimvarNormalsInterpolation, pxr::TfToken &rSubdivisionScheme, pxr::VtArray< pxr::VtIntArray > *pOptGeomSubsetIndices=NULL, SmTArray< SmSdfPathAttribute * > *pOptSubsetMaterialPaths=NULL)
SmStatus SMU_BrepConvert::GetTessellatedMeshData(SmPolyBrep &rMesh, pxr::VtArray< pxr::GfVec3f > &rExtent, pxr::VtArray< pxr::GfVec3f > &rPoints, pxr::VtIntArray &rFaceVertexCounts, pxr::VtIntArray &rFaceVertexIndices, pxr::VtArray< pxr::GfVec3f > &rNormals, pxr::VtIntArray &rNormalsIndices, pxr::TfToken &rNormalsInterpolation, pxr::TfToken &rSubdivisionScheme, pxr::VtArray< pxr::VtIntArray > &rSubsetIndices, pxr::VtArray< pxr::SdfPath > &rMaterialPaths)
SmStatus SMU_BrepConvert::PopulateMeshAttr(const pxr::VtArray< pxr::GfVec3f > &crExtent, const pxr::VtArray< pxr::GfVec3f > &crPoints, const pxr::VtIntArray &crFaceVertexCounts, const pxr::VtIntArray &crFaceVertexIndices, const pxr::VtArray< pxr::GfVec3f > &crNormals, const pxr::VtIntArray &crNormalsIndices, const pxr::TfToken &crNormalsInterpolation, const pxr::TfToken &crSubdivisionScheme, const pxr::VtArray< pxr::VtIntArray > &crSubsetIndices, const pxr::VtArray< pxr::SdfPath > &crMaterialPaths, const pxr::SdfPrimSpecHandle &rPrimSpecHandle)
SmStatus SMU_BrepConvert::PopulateMeshAttr(SmPolyBrep &crSmPolyBrep, const pxr::SdfPrimSpecHandle &rPrimSpecHandle)
SmStatus SMU_BrepConvert::SmTransformToUsdXform(const SmVector3d &rScale, const SmAxis2Placement &rTransform, pxr::GfMatrix4d &r4x4)
SmStatus SMU_BrepConvert::SmTransformToUsdXform(const SmVector3d &rScale, const SmAxis2Placement &rTransform, pxr::UsdGeomXformOp &rXformOp)
SmStatus SMU_BrepConvert::UsdXformToSmTransform(const pxr::UsdGeomXformOp &crXformOp, SmVector3d &rScale, SmAxis2Placement &rTransform)
pxr::SdfPrimSpecHandle SMU_BrepConvert::smuGenerateBrepMetadata(const pxr::SdfPrimSpecHandle &rParentSpecHandle, const std::string sName, std::string *pOptDisplayName, pxr::GfMatrix4d &rBrepMat, ULONG uIndex, const pxr::SdfPath materialPath)
pxr::SdfPrimSpecHandle SMU_BrepConvert::smuGenerateMeshMetadata(const pxr::SdfPrimSpecHandle &rParentSpecHandle, const std::string sName, std::string *pOptDisplayName, pxr::GfMatrix4d &rBrepMat, bool bDoubleSided, ULONG uIndex, const pxr::SdfPath materialPath)
SmApiStatus SmApiBoolean(SmBrep *pBrep1, SmBrep *pBrep2, SmBooleanOperationType lOperation, SmBrep *&rpResult): Two-Brep Booleans (SmApiBoolean, SmApiBooleanUnion, SmApiBooleanDifference, SmApiBooleanIntersection, SmApiBooleanMerge, SmApiBooleanWithCurves, SmApiBooleanWithOptions, SmApiNonManifoldBoolean), in addition to the per-parameter notes:
SmApiStatus SmApiBoolean2d(SmBrep *pBrep1, SmBrep *pBrep2, Sm2DBooleanOperationType eOpType, SmBrep *&rpResult): If either input has zero faces, returns SM_SUCCESS without assigning rpResult or deleting pBrep2.
SmApiStatus SmApiBooleanDifference(SmBrep *pBrep1, SmBrep *pBrep2, SmBrep *&rpResult)
SmApiStatus SmApiBooleanIntersection(SmBrep *pBrep1, SmBrep *pBrep2, SmBrep *&rpResult)
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)
SmApiStatus SmApiBooleanMerge(SmBrep *pBrep1, SmBrep *pBrep2, SmBrep *&rpResult)
SmApiStatus SmApiBooleanTrees(SmTArray< SmBrep * > &rBreps, SmTArray< long > &rPostFixTrees)
SmApiStatus SmApiBooleanUnion(SmBrep *pBrep1, SmBrep *pBrep2, SmBrep *&rpResult)
SmApiStatus SmApiBooleanWithCurves(SmBrep *pBrep1, SmBrep *pBrep2, SmBooleanOperationType lOperation, SmBrep *&rpResult, SmTArray< SmEdge * > &rIntersectionEdges)
SmApiStatus SmApiBooleanWithOptions(SmBrep *pBrep1, SmBrep *pBrep2, SmBooleanOperationType eOperation, SmBoolean bCookieCutter, SmBoolean bImprinting, SmBoolean bBooleanPostProcess, SmBoolean bImprintAndClassifyFaces, SmBoolean bKeepOtherBrep, SmBrep *&rpResult)
SmApiStatus SmApiBrepBoundingBox(const SmBrep *pBrep, SmBoolean bTight, SmPoint3d &rMin, SmPoint3d &rMax)
SmApiStatus SmApiBrepClosestPoint(const SmBrep *pBrep, const SmPoint3d &crPoint, SmPoint3d &rClosestPoint, double &rdDistance)
SmApiStatus SmApiBrepClosestPointAll(const SmBrep *pBrep, const SmPoint3d &crPoint, SmTArray< SmPoint3d > &rPoints, SmTArray< double > &rDistances)
SmApiStatus SmApiBrepComputeArea(SmBrep *pBrep, double dRelativeAccuracy, double &rdArea): Total surface area: the sum of SmApiFaceComputeArea over every face, with the same accuracy envelope. Works on sheet bodies and open shells, which SmApiBrepComputeMassProperties rejects.
SmApiStatus SmApiBrepComputeMassProperties(const SmBrep *pBrep, double dRelativeAccuracy, double dDensity, const SmPoint3d &crOrigin, double &rdArea, double &rdVolume, double &rdMass, SmPoint3d &rCentroid, SmVector3d &rMomentsOfInertia, SmVector3d &rProductsOfInertia)
SmApiStatus SmApiBrepComputeVolume(const SmBrep *pBrep, double dRelativeAccuracy, double &rdVolume)
SmApiStatus SmApiBrepCopy(const SmBrep *pBrep, SmBrep *&rpResult)
SmApiStatus SmApiBrepDistance(const SmBrep *pBrepA, const SmBrep *pBrepB, double &rdDistance)
SmApiStatus SmApiBrepIsManifoldSolid(const SmBrep *pBrep, SmBoolean &rbIsManifoldSolid)
SmApiStatus SmApiBrepMaterialCensus(const SmBrep *pBrep, long &rlSolidCount, long &rlVoidCount)
SmApiStatus SmApiBrepRelationship(const SmBrep *pBrepA, const SmBrep *pBrepB, int &rRelationship, double &rdDistance)
SmApiStatus SmApiChamferFillet(SmBrep *pBrep, double dRadius)
SmApiStatus SmApiCircularFillet(SmBrep *pBrep, double dRadius)
SmApiStatus SmApiConvertToLinesAndArcs(SmBSplineCurve *pCurve, SmTArray< SmBSplineCurve * > &pLinesAndArcs)
SmApiStatus SmApiCreateArc(const SmPoint3d &crCenterPt, double dRadius, double dStartAngleDeg, double dEndAngleDeg, SmBSplineCurve *&rpResult)
SmApiStatus SmApiCreateBlendPrimitive(SmBrep *pBrep, SmEdge *pEdge1, SmFace *pFace1, SmEdge *pEdge2, SmFace *pFace2, SmBoolean bSameDirCurves, SmFace *&rpBlendFace)
SmApiStatus SmApiCreateBox(const SmVector3d &crOrigin, double dLength, double dWidth, double dHeight, SmBrep *&pResult)
SmApiStatus SmApiCreateCanonicalCurve(const SmTArray< SmPoint3d > &crPoints, const SmTArray< double > &crKnots, const SmTArray< ULONG > &crKnotMultiplicities, const SmTArray< double > *crWeights, ULONG lDegree, SmBSplineCurveForm eBSplineCurveForm, SmBSplineCurve *&rpResult)
SmApiStatus SmApiCreateCircle(const SmPoint3d &crCenterPt, double dRadius, SmCircle *&rpResult): Center coordinates and radius must be valid doubles in [-1e18, 1e18] (SM_IS_VALID_DOUBLE / SM_BIG_DOUBLE/100). The radius must exceed SM_EFF_ZERO (1e-12), and the center/radius combination must be representable: a center whose magnitude dwarfs the radius (e.g. (1e18,0,0) with radius 1) collapses the circle's extents in double precision and is rejected. Any violation returns SM_ERR_INVALID_INPUT with rpResult == NULL; rpResult is only valid on SM_SUCCESS.
SmApiStatus SmApiCreateCircle(const SmPoint3d &crCenterPt, double dRadius, SmBSplineCurve *&rpResult): Center coordinates and radius must be valid doubles in [-1e18, 1e18] (SM_IS_VALID_DOUBLE / SM_BIG_DOUBLE/100). The radius must exceed SM_EFF_ZERO (1e-12), and the center/radius combination must be representable: a center whose magnitude dwarfs the radius (e.g. (1e18,0,0) with radius 1) collapses the circle's extents in double precision and is rejected. Any violation returns SM_ERR_INVALID_INPUT with rpResult == NULL; rpResult is only valid on SM_SUCCESS.
SmApiStatus SmApiCreateCone(const SmVector3d &crOrigin, double dRadiusBase, double dRadiusTop, double dHeight, SmSurface *&rpResult)
SmApiStatus SmApiCreateCone(const SmVector3d &crOrigin, double dRadiusBase, double dRadiusTop, double dHeight, SmBrep *&rpResult)
SmApiStatus SmApiCreateConeEllipticEnds(double dFrontRadius, double dRearRadius, double dHeight, double dFrontYTiltDeg, double dRearYTiltDeg, double dFrontXTiltDeg, double dRearXTiltDeg, SmBoolean bEndCaps, SmBrep *&rpResult)
void SmApiCreateContext()
SmApiStatus SmApiCreateCurve(const SmTArray< SmPoint3d > &crPoints, SmBSplineCurve *&rpResult): Requires at least 4 points (cubic); fewer returns SM_ERR_INVALID_INPUT.
SmApiStatus SmApiCreateCurveApproxPoints(const SmTArray< SmPoint3d > &crPoints, SmCurve *&rpResult)
SmApiStatus SmApiCreateCurveInterpPoints(const SmTArray< SmPoint3d > &crPoints, SmCurve *&rpResult, SmCurveParameterizationType eParameterization=SM_CP_UNIFORM): Requires at least 4 finite points (degree-3 fit). Fewer points or any non-finite point returns SM_ERR_INVALID_INPUT with rpResult == NULL. For the distance-based parameterizations (SM_CP_CHORDLENGTH and SM_CP_CENTRIPETAL) successive points must be distinct: a coincident pair (separation <= SM_EFF_ZERO) also returns SM_ERR_INVALID_INPUT, since a zero-length span has no defined chord/centripetal spacing. SM_CP_UNIFORM ignores spacing and tolerates duplicates. rpResult is only valid on SM_SUCCESS.
SmApiStatus SmApiCreateCurveSweep(SmTArray< SmCurve * > &rProfileCurves, SmBSplineCurve *pPathCurve, SmBSplineCurve *pScaleReference, SmBSplineCurve *pScaleCurve, SmSweepOptions *pOptions, SmBrep *&rpResult, SmTArray< SmFace * > *pOptStartFaces, SmTArray< SmFace * > *pOptSideFaces, SmTArray< SmFace * > *pOptEndFaces): The profile, path, and scale curves are not consumed; the caller keeps ownership and all inputs remain unchanged. The caller owns the new rpResult on success; on failure rpResult is NULL (any partially built Brep is deleted). The same applies to SmApiCreateCurveSweepFromFaces and SmApiCreateCurveSweepFromEdges.
SmApiStatus SmApiCreateCurveSweepFromEdges(SmTArray< SmEdge * > &rEdges, SmBSplineCurve *pPathCurve, SmBSplineCurve *pScaleReference, SmBSplineCurve *pScaleCurve, SmSweepOptions *pOptions, SmBrep *&rpResult, SmTArray< SmFace * > *pOptStartFaces, SmTArray< SmFace * > *pOptSideFaces, SmTArray< SmFace * > *pOptEndFaces)
SmApiStatus SmApiCreateCurveSweepFromFaces(SmTArray< SmFace * > &rFaces, SmBSplineCurve *pPathCurve, SmBSplineCurve *pScaleReference, SmBSplineCurve *pScaleCurve, SmSweepOptions *pOptions, SmBrep *&rpResult, SmTArray< SmFace * > *pOptStartFaces, SmTArray< SmFace * > *pOptSideFaces, SmTArray< SmFace * > *pOptEndFaces)
SmApiStatus SmApiCreateCylinder(const SmVector3d &crOrigin, double dRadius, double dHeight, SmBrep *&rpResult)
SmApiStatus SmApiCreateCylinder(const SmVector3d &crOrigin, double dRadius, double dHeight, SmSurface *&rpResult)
SmApiStatus SmApiCreateCylindricalBox(const SmVector3d &crOrigin, double dLength, double dInsideRadius, double dOutsideRadius, double dStartAngleDeg, double dEndAngleDeg, SmBrep *&rpResult)
SmApiStatus SmApiCreateDraftSweep(const SmTArray< SmCurve * > &rCurvesToSweep, double dHeight, double dAngleDeg, SmBoolean bCornerType, int iCapEnds, SmBrep *&rpResult)
SmApiStatus SmApiCreateEllipse(const SmPoint3d &crOrigin, double dRadius1, double dRadius2, SmEllipse *&rpResult)
SmApiStatus SmApiCreateExtrude(SmBSplineCurve *pCurve, const SmVector3d &rSweepVector, SmSurface *&rpResult)
SmApiStatus SmApiCreateHelix(const SmPoint3d &crOrigin, double dHeight, double dRadiusStart, double dRadiusEnd, double dNumTurns, SmBoolean bRightHanded, double dTolerance, SmBSplineCurve *&rpResult): Every input is validated against a finite domain before the fitter runs; any out-of-domain value returns SM_ERR_INVALID_INPUT with rpResult == NULL. dTolerance is a hard contract: the achieved maximum 3D deviation from the analytic helix is verified after the fit, and if it exceeds dTolerance the call returns SM_ERR_NOT_WITHIN_TOLERANCE with rpResult == NULL. Fractional dNumTurns is accepted, but below ~1 turn the helix winds steeply (nearly straight): a tight dTolerance may be unmeetable (returning SM_ERR_NOT_WITHIN_TOLERANCE) and such paths may be rejected by SmApiCreatePipeSweep. Prefer dNumTurns >= 1 for a reliable sweep path.
SmApiStatus SmApiCreateLine(const SmPoint3d &crStartPt, const SmVector3d &crDirection, SmLine *&rpResult)
SmApiStatus SmApiCreateLineSegment(const SmPoint3d &crStartPt, const SmPoint3d &crEndPt, SmLine *&rpResult)
SmApiStatus SmApiCreateLinearSweep(const SmTArray< SmCurve * > &rCurvesToSweep, const SmVector3d &rSweepDir, double dSweepDist, SmBoolean bCapEnds, SmBrep *&rpResult): rCurvesToSweep are copied, not consumed: the caller keeps ownership and the curves are unchanged. The caller owns the new rpResult.
SmApiStatus SmApiCreateLinearSweepWithRepetitions(const SmTArray< SmCurve * > &rCurvesToSweep, const SmVector3d &rSweepDir, double dSweepDist, ULONG nRepetitions, SmBoolean bCapEnds, SmBrep *&rpResult)
SmApiStatus SmApiCreateOffsetProfile(const SmTArray< SmCurve * > &rPlanarCurves, double dOffsetDistance, ULONG lOffsetType, SmBoolean bRoundCorners, SmBoolean bShellResult, SmBrep *&rpResult): rPlanarCurves and the curves it contains are borrowed. They remain caller-owned and unchanged on both success and failure.
SmApiStatus SmApiCreateOffsetSurface(SmSurface *pSrfToOffset, double dOffsetDistance, SmSurface *&rpResult)
SmApiStatus SmApiCreatePartialCone(const SmVector3d &crOrigin, double dRadiusBase, double dRadiusTop, double dHeight, double dStartAngleDeg, double dEndAngleDeg, SmBrep *&rpResult)
SmApiStatus SmApiCreatePartialCylinder(const SmVector3d &crOrigin, double dRadius, double dHeight, double dStartAngleDeg, double dEndAngleDeg, SmBrep *&rpResult)
SmApiStatus SmApiCreatePartialSphere(const SmVector3d &crOrigin, double dRadius, double dStartAngleDeg, double dEndAngleDeg, SmBrep *&rpResult)
SmApiStatus SmApiCreatePartialTorus(const SmVector3d &crOrigin, double dRadiusMajor, double dRadiusMinor, double dStartAngleDeg, double dEndAngleDeg, SmBrep *&rpResult)
SmApiStatus SmApiCreatePipeSweep(double dPipeRadius, SmBSplineCurve *pPathCurve, SmBoolean bCapEnds, SmBrep *&rpResult)
SmApiStatus SmApiCreatePlanarCircle(const SmVector3d &crOrigin, double dRadius, SmBrep *&rpResult)
SmApiStatus SmApiCreatePlanarFaces(const SmTArray< SmCurve * > &crPlanarCurves, SmBrep *&rpResult): Ownership of crPlanarCurves: consumed on success (the new faces use them; do not delete or reuse them). On failure they are left with the caller, who must delete them, and rpResult is set to NULL.
SmApiStatus SmApiCreatePlane(const SmVector3d &crOrigin, double dX, double dY, SmBrep *&rpResult)
SmApiStatus SmApiCreatePlane(const SmVector3d &crOrigin, double dLength, double dWidth, SmPlane *&rpResult)
SmApiStatus SmApiCreatePyramid(const SmVector3d &crOrigin, double dLength, double dHeight, SmBrep *&rpResult)
SmApiStatus SmApiCreateRectangle(const SmPoint3d &crCenterPt, double dLength, double dWidth, SmTArray< SmBSplineCurve * > &rpResult)
SmApiStatus SmApiCreateRegularPolygon(const SmPoint3d &crCenterPt, ULONG nSides, double dRadius, SmTArray< SmBSplineCurve * > &rpResult)
SmApiStatus SmApiCreateRotationalSweep(const SmTArray< SmCurve * > &rCurvesToSweep, const SmPoint3d &rBasePt, const SmVector3d &rAxis, double dAngleDeg, SmBoolean bCapEnds, SmBrep *&rpResult): rCurvesToSweep are copied, not consumed: the caller keeps ownership and the curves are unchanged. The caller owns the new rpResult.
SmApiStatus SmApiCreateRotationalSweepWithRepetitions(const SmTArray< SmCurve * > &rCurvesToSweep, const SmPoint3d &rBasePt, const SmVector3d &rAxis, double dAngleDeg, ULONG nRepetitions, SmBoolean bCapEnds, SmBrep *&rpResult)
SmApiStatus SmApiCreateRuledSurface(SmBSplineCurve *rCurve1, SmBSplineCurve *rCurve2, SmSurface *&rpResult)
SmApiStatus SmApiCreateSilhouetteCurves(SmBrep *pBrep, const SmVector3d &rPlanePt, const SmVector3d &rPlaneNormal, SmTArray< SmCurve * > &rProjectionCurves)
SmApiStatus SmApiCreateSkin(const SmTArray< SmBSplineCurve * > &rProfiles, SmSurface *&rpResult)
SmApiStatus SmApiCreateSkinFromFaces(SmTArray< SmFace * > &rFaces, ULONG lDegree, SmTArray< SmFace * > &rNewFaces, SmBrep *&rpResult)
SmApiStatus SmApiCreateSkinPrimitive(const SmTArray< ULONG > &rCurvesInEachProfile, const SmTArray< const SmCurve * > &r3DCurves, ULONG lDegree, SmBoolean bCapEnds, SmBrep *&rpResult, SmTArray< SmFace * > *pOptStartFaces, SmTArray< SmFace * > *pOptSideFaces, SmTArray< SmFace * > *pOptEndFaces)
SmApiStatus SmApiCreateSphere(const SmVector3d &crOrigin, double dRadius, SmBrep *&pResult)
SmApiStatus SmApiCreateSphereNoPole(const SmVector3d &crCenter, double dRadius, SmBrep *&rpResult)
SmApiStatus SmApiCreateSurface(const SmTArray< SmPoint3d > &rControlPoints, ULONG lNumRows, ULONG lNumColumns, SmSurface *&rpResult): Requires at least 4 rows and 4 columns (bicubic); fewer returns SM_ERR_INVALID_INPUT.
SmApiStatus SmApiCreateSurfaceFromCornerPoints(const SmPoint3d &crCornerUminVmin, const SmPoint3d &crCornerUmaxVmin, const SmPoint3d &crCornerUminVmax, const SmPoint3d &crCornerUmaxVmax, SmSurface *&rpResult)
SmApiStatus SmApiCreateSurfaceFromOrderedPoints(const SmTArray< SmPoint3d > &rPoints, ULONG lNumRows, ULONG lNumColumns, SmSurface *&rpResult)
SmApiStatus SmApiCreateSurfaceFromRandomPoints(const SmTArray< SmPoint3d > &rPoints, SmSurface *&rpResult)
SmApiStatus SmApiCreateSurfaceRevolution(SmBSplineCurve *rCurve, const SmPoint3d &rOrigin, const SmVector3d &rAxisDir, double dAngleDeg, SmSurface *&rpResult)
SmApiStatus SmApiCreateSweep(SmBSplineCurve *pCurve, SmBSplineCurve *pPath, SmSurface *&rpResult)
SmApiStatus SmApiCreateSweepAlongPlanarPath(SmTArray< SmCurve * > &rProfileCurves, SmTArray< SmCurve * > &rPathCurves, SmBoolean bMoveProfile, int iCapEnds, SmBrep *&rpResult): Pure producer that sweeps profile boundary curves along a planar path.
SmApiStatus SmApiCreateSwungPrimitive(SmTArray< SmCurve * > &rXYCurves, SmTArray< SmCurve * > &rXZCurves, double dScale, SmBrep *&rpResult)
SmApiStatus SmApiCreateTaperExtrude(const SmTArray< SmCurve * > &rCurves, double dHeight, double dDraftAngleDeg, int iEndCaps, SmBoolean bFilletCorner, SmBrep *&rpResult)
SmApiStatus SmApiCreateTorus(const SmVector3d &crOrigin, double dRadiusMajor, double dRadiusMinor, SmBrep *&rpResult)
SmApiStatus SmApiCreateTorus(const SmVector3d &crOrigin, double dRadiusMajor, double dRadiusMinor, SmSurface *&rpResult)
SmApiStatus SmApiCurveClosestPoint(const SmCurve *pCurve, const SmPoint3d &crPoint, SmPoint3d &rClosestPoint, double &rdParameter, double &rdDistance): Returns SM_ERR_INVALID_INPUT for a NULL curve, propagates solver/evaluation failures, and returns SM_ERR if the solve succeeds without any solution.
SmApiStatus SmApiCurveClosestPointAll(const SmCurve *pCurve, const SmPoint3d &crPoint, SmTArray< SmPoint3d > &rPoints, SmTArray< double > &rParameters, SmTArray< double > &rDistances): Same status rules as SmApiCurveClosestPoint. Appends aligned result entries; an evaluation failure can leave a successfully evaluated prefix appended.
SmApiStatus SmApiCut(SmBrep *pBrep, const SmVector3d &rPlanePt, const SmVector3d &rPlaneNormal)
SmApiStatus SmApiDraw(SmFace *pFace, const SmVector3d *pColor=NULL, SmBoolean bClearFirst=false, SmBoolean bCenter=false)
SmApiStatus SmApiDraw(const SmTArray< SmPoint3d > &pArray, const SmVector3d *pColor=NULL, SmBoolean bClearFirst=false, SmBoolean bCenter=false)
SmApiStatus SmApiDraw(const SmPoint3d &rBasePt, const SmVector3d &rDirection, const SmVector3d *pColor=NULL, SmBoolean bClearFirst=false, SmBoolean bCenter=false)
SmApiStatus SmApiDraw(const SmPoint3d &rBasePt, const SmVector3d *pColor=NULL, SmBoolean bClearFirst=false, SmBoolean bCenter=false): [in ]: Center object [Optional] default:[false]
SmApiStatus SmApiDraw(SmSurface *pSurface, const SmVector3d *pColor=NULL, SmBoolean bClearFirst=false, SmBoolean bCenter=false)
SmApiStatus SmApiDraw(SmPolyBrep *pPolyBrep, const SmVector3d *pColor=NULL, SmBoolean bClearFirst=false, SmBoolean bCenter=false)
SmApiStatus SmApiDraw(SmBrep *pBrep, const SmVector3d *pColor=NULL, SmBoolean bClearFirst=false, SmBoolean bCenter=false)
SmApiStatus SmApiDraw(const SmTArray< SmCurve * > &pArray, const SmVector3d *pColor=NULL, SmBoolean bClearFirst=false, SmBoolean bCenter=false)
SmApiStatus SmApiDraw(SmCurve *pCurve, const SmVector3d *pColor=NULL, SmBoolean bClearFirst=false, SmBoolean bCenter=false)
SmApiStatus SmApiDropCurveToSrf(SmBSplineCurve *pCurve, SmSurface *pSurface, SmTArray< SmBSplineCurve * > *pOptCurves2d, SmTArray< SmBSplineCurve * > *pOptCurves3d)
SmApiStatus SmApiEdgeBoundingBox(const SmEdge *pEdge, SmBoolean bTight, SmPoint3d &rMin, SmPoint3d &rMax)
SmApiStatus SmApiEdgeClassifyParameter(const SmEdge *pEdge, double dParameter, int &rClassification)
SmApiStatus SmApiEdgeClosestPoint(SmEdge *pEdge, const SmPoint3d &crPoint, SmPoint3d &rClosestPoint, double &rdParameter, double &rdDistance)
SmApiStatus SmApiEdgeComputeLength(const SmEdge *pEdge, double dDesiredAccuracy, double &rdLength)
SmApiStatus SmApiEdgeParameterRange(const SmEdge *pEdge, double &rdMin, double &rdMax)
SmApiStatus SmApiEdgeTangent(const SmEdge *pEdge, double dParameter, SmVector3d &rTangent)
SmApiStatus SmApiEvaluateContinuity(const SmCurve *pCurve, double dParameter, SmContinuityType &crType): Returns SM_ERR_INVALID_INPUT for a NULL curve or a parameter outside its natural interval (including NaN); otherwise returns the kernel status.
SmApiStatus SmApiEvaluateCurve(const SmCurve *pCurve, double dParameter, SmVector3d *&crPoint, SmVector3d *&crDeriv1, SmVector3d *&crDeriv2)
SmApiStatus SmApiEvaluateSurfaceDerivatives(const SmSurface *pSurface, const SmVector2d &crUV, SmVector3d &crPoint, SmVector3d &rDU, SmVector3d &rDV)
SmApiStatus SmApiEvaluateSurfaceNormal(const SmSurface *pSurface, const SmVector2d &crUV, SmVector3d &crNormal)
SmApiStatus SmApiEvaluateSurfacePoint(const SmSurface *pSurface, const SmVector2d &crUV, SmVector3d &crPoint): The three surface evaluators below write their outputs only on success.
SmApiStatus SmApiFaceBoundingBox(const SmFace *pFace, SmBoolean bTight, SmPoint3d &rMin, SmPoint3d &rMax)
SmApiStatus SmApiFaceClassifyUV(const SmFace *pFace, const SmPoint2d &crUV, int &rClassification)
SmApiStatus SmApiFaceClosestPoint(SmFace *pFace, const SmPoint3d &crPoint, SmPoint3d &rClosestPoint, double &rdDistance)
SmApiStatus SmApiFaceComputeArea(const SmFace *pFace, double dRelativeAccuracy, double &rdArea): Single-face area. For whole-solid area+volume+centroid+inertia, use SmApiBrepComputeMassProperties (one call; also yields solid volume). This area-only query skips volume and moment integration.
SmApiStatus SmApiFaceComputeCentroid(const SmFace *pFace, double dRelativeAccuracy, double &rdArea, SmPoint3d &rCentroid): Single-face area centroid (integrates only area and area first moments). For a whole-solid mass centroid, use SmApiBrepComputeMassProperties.
SmApiStatus SmApiFaceGetBoundaryLoops(SmFace *pFace, SmTArray< ULONG > &rEdgeCountsPerLoop, SmTArray< SmEdge * > &rEdges, SmTArray< SmOrientType > &rOrientations)
SmApiStatus SmApiFaceInternalPoint(const SmFace *pFace, SmPoint3d &rPoint)
SmApiStatus SmApiFilletEdges(SmBrep *pBrep, SmTArray< SmEdge * > &rEdges, double dRadius, ULONG lXSectType, ULONG lContinuity, double dThumbweight)
SmApiStatus SmApiFilletEdgesPerEdge(SmBrep *pBrep, SmTArray< SmEdge * > &rEdges, SmTArray< double > &rRadii, SmTArray< SmFilletSurfaceGeneratorType > &rXSectTypes, ULONG lContinuity, double dThumbweight)
SmApiStatus SmApiFilletPreview(SmBrep *pBrep, SmTArray< SmEdge * > &rEdges, double dRadius, SmTArray< SmSurface * > &rPreviewSurfaces)
SmApiStatus SmApiFindEdge(SmBrep *pBrep, const SmPoint3d &crPoint, ULONG &rlEdgeIndex, double &rdParam): Returns the edge nearest to crPoint. There is no distance limit: a point far from every edge still returns the nearest one, so check the distance if the point may be off the Brep.
SmApiStatus SmApiFindFaces(SmBrep *pBrep, const SmPoint3d &crPoint, SmFace *&rpFace)
SmApiStatus SmApiGetClosestPoint(const SmBrep *pBrep, const SmPoint3d &crPoint, SmPoint3d &rClosestPoint, double &rdDistance)
SmApiStatus SmApiGetEdges(SmBrep *pBrep, SmTArray< SmEdge * > &rEdges)
SmApiStatus SmApiGetFaces(SmBrep *pBrep, SmTArray< SmFace * > &rFaces)
SmContext * SmApiGetOrCreateContext()
SmApiStatus SmApiHealBrep(SmBrep *pBrep)
SmApiStatus SmApiIntersectBrepWithPlane(SmBrep *pBrep, const SmVector3d &rPlanePt, const SmVector3d &rPlaneNormal, SmTArray< SmCurve * > &rSectionCurves)
SmApiStatus SmApiIntersectBreps(SmBrep *pBrep1, SmBrep *pBrep2, SmTArray< SmCurve * > &rCurves3d, SmTArray< SmPoint3d > *pOptPoints3d)
SmApiStatus SmApiIntersectCurveBrep(SmCurve *pCurve, SmBrep *pBrep, SmTArray< SmCurve * > &rCurves, SmTArray< SmPoint3d > &rPoints)
SmApiStatus SmApiIntersectCurveFace(SmCurve *pCurve, SmFace *pFace, SmTArray< SmCurve * > &rCurves, SmTArray< SmPoint3d > &rPoints)
SmApiStatus SmApiIntersectCurveSurface(SmCurve *pCurve, SmSurface *pSurface, SmTArray< SmCurve * > &rCurves, SmTArray< SmPoint3d > &rPoints)
SmApiStatus SmApiIntersectCurves(SmCurve *pCurve1, SmCurve *pCurve2, SmTArray< SmPoint3d > *p3DPoints, SmTArray< double > *parametersOnCurve1, SmTArray< double > *parametersOnCurve2)
SmApiStatus SmApiIntersectFaces(SmFace *pFace1, SmFace *pFace2, SmTArray< SmCurve * > &r3DCurves, SmTArray< SmPoint3d > *pOpt3DPoints)
SmApiStatus SmApiIntersectSurfaces(SmSurface *pSurface1, SmSurface *pSurface2, SmTArray< SmCurve * > *p3DCurves)
SmApiStatus SmApiLiftUVCurveFromSrf(const SmBSplineCurve *pUVCurve, const SmSurface *pSurface, SmTArray< SmBSplineCurve * > *pCurves3d)
SmApiStatus SmApiMakeCurvesCompatible(SmTArray< SmBSplineCurve * > &pCurves)
SmApiStatus SmApiMergeBreps(SmTArray< SmBrep * > &rBreps, SmBooleanOperationType lOperation, SmBrep *&rpResult)
SmApiStatus SmApiNonManifoldBoolean(SmBrep *pBrep1, SmBrep *pBrep2, SmBooleanOperationType eOperation, SmBrep *&rpResult)
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)
SmApiStatus SmApiNonManifoldSweep(SmBrep *pBrepToSweep, SmBrep *pRegionBrep, const SmVector3d &rSweepDir, double dSweepDist, SmBoolean bDoStitching, SmBoolean bDoMerge, SmTArray< SmFace * > *pOptFaces, SmTArray< SmEdge * > *pOptEdges, SmTArray< SmVertex * > *pOptVertices)
SmApiStatus SmApiOffsetBrepFull(SmBrep *pBrep, double dOffsetDistance, SmBoolean bDoExtendedOffset, SmBoolean bDoSelfInt, SmBrep *&rpResult)
SmApiStatus SmApiOffsetCurve(SmBSplineCurve *pCurveToOffset, double dOffsetDistance, SmBSplineCurve *&rpResult)
SmApiStatus SmApiOrderCurves(SmTArray< SmBSplineCurve * > &pCurves)
SmApiStatus SmApiPiecewiseMerge(SmBrep *pBrep1, SmBrep *pBrep2, SmBoolean bCreateNewBrepsForFaces, SmBrep *&rpResult)
SmApiStatus SmApiPolyBoolean(SmPolyBrep *pPolyBrep1, SmPolyBrep *pPolyBrep2, SmPolyBooleanOperationType lOperation, SmPolyBrep *&rpResult): Ownership contract for the PolyBrep Booleans: pPolyBrep1 is modified in place and returned as rpResult; pPolyBrep2 is deleted on success, except for SM_PBO_PARTIAL_MERGE. SM_PBO_IMPRINT does delete pPolyBrep2. A NULL operand or pPolyBrep1 == pPolyBrep2 returns SM_ERR_INVALID_INPUT with both inputs untouched.
SmApiStatus SmApiPolyBooleanDifference(SmPolyBrep *pPolyBrep1, SmPolyBrep *pPolyBrep2, SmPolyBrep *&rpResult)
SmApiStatus SmApiPolyBooleanIntersection(SmPolyBrep *pPolyBrep1, SmPolyBrep *pPolyBrep2, SmPolyBrep *&rpResult)
SmApiStatus SmApiPolyBooleanMerge(SmPolyBrep *pPolyBrep1, SmPolyBrep *pPolyBrep2, SmPolyBrep *&rpResult)
SmApiStatus SmApiPolyBooleanUnion(SmPolyBrep *pPolyBrep1, SmPolyBrep *pPolyBrep2, SmPolyBrep *&rpResult)
SmApiStatus SmApiPolyBrepComputeMassProperties(const SmPolyBrep *pPolyBrep, double dDensity, const SmPoint3d &crOrigin, double &rdArea, double &rdVolume, double &rdMass, SmPoint3d &rCentroid, SmVector3d &rMomentsOfInertia, SmVector3d &rProductsOfInertia): Mesh counterpart of SmApiBrepComputeMassProperties: same outputs and conventions, computed exactly from the mesh's triangles (one pass, no accuracy parameter accuracy is that of the tessellation). Independent of winding direction: a closed mesh wound inside-out (e.g. as imported) gives the same result as its correctly wound counterpart. Returns SM_ERR_INVALID_INPUT for a non-finite / sub-SM_EFF_ZERO density, a non-finite origin, a mesh that is not a closed manifold solid, or a zero-volume result.
SmApiStatus SmApiPolyBrepComputeVolume(const SmPolyBrep *pPolyBrep, double &rdVolume)
SmApiStatus SmApiPolyBrepCopy(const SmPolyBrep *pPolyBrep, SmPolyBrep *&rpResult)
SmApiStatus SmApiPolyBrepIsManifoldSolid(const SmPolyBrep *pPolyBrep, SmBoolean &rbIsManifoldSolid)
SmApiStatus SmApiProjectAndTrim(SmBrep *pBrep, SmBSplineCurve *rCurveToProject, const SmVector3d &rProjectionDir, const SmPoint3d &rRefPt)
SmApiStatus SmApiProjectBrepOntoPlane(SmBrep *pBrep, const SmVector3d &rPlanePt, const SmVector3d &rPlaneNormal, SmTArray< SmCurve * > &rProjectionCurves)
SmApiStatus SmApiProjectCurve(SmBrep *pBrep, SmBSplineCurve *pCurveToProject, const SmVector3d &projectionVector, SmTArray< SmCurve * > &r3DCurves)
SmApiStatus SmApiProjectCurve(const SmBSplineCurve *pCurve, const SmSurface *pSurface, SmTArray< SmBSplineCurve * > *pOptCurves2d, SmTArray< SmBSplineCurve * > *pOptCurves3d): Either output may be NULL to ignore it. Outputs are appended to only on success; a failed lift returns its status and leaves the outputs unchanged.
SmApiStatus SmApiReadBrepFromFile(const TCHAR *pFileName, SmBoolean bAscii, SmBoolean bRebuildUVTrimCurves, SmBrep *&rpBrep): Read one Brep from a native SMLib .smb file.
SmApiStatus SmApiReadPartFromFile(const TCHAR *pFileName, SmBoolean bAscii, SmTArray< SmCurve * > &rCurves, SmTArray< SmSurface * > &rSurfaces, SmTArray< long > &rBooleanTreeNodes, SmTArray< SmBrep * > &rBreps): Read a native SMLib part container.
SmApiStatus SmApiRemoveCurveKnots(SmCurve *pCurve): Remove B-spline knots in place using the curve's effective approximation tolerance. Non-B-spline curve types are unchanged. Returns SM_ERR_INVALID_INPUT for a null curve; propagates knot-removal failures.
SmApiStatus SmApiRemoveFillet(SmBrep *pBrep)
SmApiStatus SmApiRotate(SmObject *pObj, const SmVector3d &rRefPt, const SmVector3d &rAxis, double dAngleDeg)
SmApiStatus SmApiScale(SmObject *pObj, const SmVector3d &rScale)
SmApiStatus SmApiScaleByPt(SmObject *pObj, const SmVector3d &rRefPt, const SmVector3d &rScale)
SmApiStatus SmApiSetBevelCorners(SmBrep *pBrep, SmTArray< SmEdge * > &rEdges, double dRadius, SmTArray< SmVertex * > &rBevelVertices)
SmApiStatus SmApiShellBrepFull(const SmBrep *pBrep, double dOffsetDistance, SmBoolean bDoExtendedOffset, SmBoolean bDoSelfInt, SmBoolean bCreateOffsetSolid, const SmTArray< const SmFace * > &rFacesToShell, SmBrep *&rpResult)
SmApiStatus SmApiSimpleFaceStitch(SmBrep *pBrep, const SmTArray< SmFace * > &rFacesToKeep, const SmTArray< SmFace * > &rFacesToDelete, ULONG &rlStitchedEdges, double &rdMaxVertexGap, double &rdMaxEdgeGap)
SmApiStatus SmApiStitch(SmBrep *pBrep, SmFace *pFaceToStitch)
SmApiStatus SmApiStitch(SmBrep *pBrep)
SmApiStatus SmApiStitchAdvanced(SmBrep *pBrep, double dStitchTol3d, SmBoolean bSqueezeSmallEdges, SmBoolean bSplitEdgesWithVertices, SmBoolean bMakingManifoldSolid, SmBoolean bRemoveLaminarSlivers, ULONG &rlStitchedEdges, ULONG &rlLaminaEdges, double &rdMaxVertexGap, double &rdMaxEdgeGap)
SmApiStatus SmApiStitchIntoShell(SmBrep *pBrep, SmBoolean &rbShellIsWellFormed, double dMaxStitchingRatio, ULONG &rlStitchedEdges, double &rdMaxVertexGap, double &rdMaxEdgeGap)
SmApiStatus SmApiStitchIntoSolid(SmBrep *pBrep, SmBoolean &rbProducesASolid, ULONG &rlStitchedEdges, double &rdMaxVertexGap, double &rdMaxEdgeGap)
SmApiStatus SmApiSurfaceClosestPoint(const SmSurface *pSurface, const SmPoint3d &crPoint, SmPoint3d &rClosestPoint, SmTArray< SmPoint2d > &rUVs, double &rdDistance)
SmApiStatus SmApiSurfaceSurfaceFillet(SmSurface *pSurface1, SmSurface *pSurface2, double dRadius1, double dRadius2, double dTolerance, SmBrep *&rpResult, ULONG lXSectType, SmBoolean bMirror, SmBoolean bComplement)
SmApiStatus SmApiTessellate(SmBrep *pBrep, SmPolyBrep *&rpResult, const SmTessellationParams &rParams=SmTessellationParams(), SmBoolean bAllowPartial=FALSE, SmTArray< SmTessellationFailure > *pFailures=nullptr, SmTessellationReport *pReport=nullptr): Tessellate a brep into a SmPolyBrep mesh using the supplied quality controls. Rejects failed faces unless bAllowPartial is TRUE and pFailures or pReport is supplied. Output errors always fail. The caller owns successful output; errors leave it null. pFailures is cleared on entry and retained on error, using input GetFaces() indices.
SmApiStatus SmApiTessellateBoundaries(SmBrep *pBrep, double dAngleTolDeg, SmTArray< SmPoint3d > &rPoints, SmTArray< ULONG > &rVertexCounts, SmTArray< SmEdge * > &rEdges): Sample trimmed edges; finite, positive angle in degrees. Brep is unchanged. Replaces flat points, counts and borrowed edges. Missing/failed curves: zero counts and SM_ERR; valid samples are retained. Degenerate curves retain one point.
SmApiStatus SmApiTransform(SmObject *pObj, const SmAxis2Placement &rRotateMove): Transform operations accept independent modeling objects: Breps, PolyBreps, standalone Curves, and standalone Surfaces.
SmApiStatus SmApiTranslate(SmObject *pObj, const SmVector3d &crTranslate)
SmApiStatus SmApiTrimProjectParallel(SmObject *pObject, SmBSplineCurve *crCurveToProject, const SmVector3d &crProjectionDirection, const SmPoint3d &crReferencePoint, SmTrimType eTrimType, SmBrep *&rpResult)
SmApiStatus SmApiTrimSurfaceWith3dCurves(SmSurface *pSurface, const SmTArray< ULONG > &crCurveLoops, const SmTArray< SmCurve * > &cr3DCurves, SmBrep *&rpResult): Ownership: on success pSurface and the cr3DCurves curves are consumed into rpResult. On failure rpResult is NULL and ownership of pSurface and the curves is indeterminate: some may already be attached to a partial Brep that is not freed.
SmApiStatus SmApiTurnToNurbs(SmBrep *pBrep): Replaces every analytic / periodic surface in pBrep (cylinder, cone, sphere, torus, plane) with an equivalent NURBS surface in place. No-op on already-NURBS surfaces.
SmApiStatus SmApiUnifyNormals(SmBrep *pBrep, SmFace *pStartFace, ULONG lNumSamples, SmTArray< SmFace * > &rFlippedFaces)
SmStatus SmApiUsdAppendBreps(const char *pFileName, std::vector< SmBrep * > &rSmBreps, SmBoolean bExportUVCurves=TRUE, SmBoolean bBoundUnboundedFaceRanges=FALSE): Append SmBreps to an existing USD file.
SmStatus SmApiUsdAppendMeshes(const char *pFileName, std::vector< SmPolyBrep * > &rSmPolyBreps): Append SmPolyBreps as new UsdGeomMesh prims under /World.
SmStatus SmApiUsdEnsurePluginRegistered(): Ensure the omniSolid BrepArray schema plugin is registered with USD.
SmStatus SmApiUsdExportBrep(const char *pFileName, SmBrep *pSmBrep, SmBoolean bExportUVCurves=TRUE, SmBoolean bBoundUnboundedFaceRanges=FALSE): Export a single SmBrep to a new USD file. Retains generated trims, caches, and destination-path attributes on the input with the same side effects as SmApiUsdExportBreps; does not copy the Brep.
SmStatus SmApiUsdExportBreps(const char *pFileName, std::vector< SmBrep * > &rSmBreps, SmBoolean bExportUVCurves=TRUE, SmBoolean bBoundUnboundedFaceRanges=FALSE): Export a vector of SmBreps to a new USD file.
SmStatus SmApiUsdExportMesh(const char *pFileName, SmPolyBrep *pSmPolyBrep): Export a single polygon mesh ( SmPolyBrep ) to a new USD file as UsdGeomMesh .
SmStatus SmApiUsdExportMeshes(const char *pFileName, std::vector< SmPolyBrep * > &rSmPolyBreps): Export SmPolyBreps to a new USD file as UsdGeomMesh children under /World.
SmStatus SmApiUsdHealFile(const char *pInputFile, const char *pOutputFile, int iThreadCount, std::vector< SmApiUsdBrepArrayHealResult > &rResults): Heal BrepArray definitions in the layers used by the current USD composition and write the scene to pOutputFile, keeping its layers, references, native instancing, transforms and materials. Each BrepArray is healed in the layer that defines it; other layers (including package members) are written as standalone layers to <output stem>_layers/ beside the output, with references redirected. External layers used only by unselected variants are not enumerated or healed; their references keep pointing at the original assets.
SmStatus SmApiUsdImportBrep(const char *pFileName, const char *pPrimPath, SmBrep *&rpSmBrep, SmBoolean bHealerIsEnabled=TRUE): Load a single BRep prim from a USD file by SdfPath and convert to SmBrep. If the prim contains multiple packed Breps, every member must convert successfully; the first is returned and the remaining members are deleted.
SmStatus SmApiUsdImportBreps(const char *pFileName, std::vector< SmBrep * > &rSmBreps, SmBoolean bHealerIsEnabled, SmBoolean bAllowPartial, std::vector< SmApiUsdBrepImportResult > *pImportResults): Load BRep prims from a USD file using an explicit partial-import policy.
SmStatus SmApiUsdImportBreps(const char *pFileName, std::vector< SmBrep * > &rSmBreps, SmBoolean bHealerIsEnabled=TRUE): Load all BRep prims from a USD file and convert them to SmBreps.
SmStatus SmApiUsdImportMesh(const char *pFileName, const char *pPrimPath, SmPolyBrep *&rpSmPolyBrep): Load a single UsdGeomMesh prim by SdfPath and convert to SmPolyBrep.
SmStatus SmApiUsdImportMeshes(const char *pFileName, std::vector< SmPolyBrep * > &rSmPolyBreps): Load every active UsdGeomMesh on the stage (traversal order) and convert each to an SmPolyBrep.
SmStatus SmApiUsdTessellateBrepArray(const pxr::UsdPrim &crBrepArray, const SmTessellationParams &crParams, SmBoolean bHealerIsEnabled, double dBoundaryAngleTolDeg, std::vector< SmApiUsdTessellatedBrep > &rResults): Import, tessellate and extract each Brep of a BrepArray prim, one result per member in packed order. Members fail independently; SmApiTessellate keeps partial meshes. Uses a context private to the call, so concurrent calls are safe while the stage is not being modified. Returns an error with one whole-prim result if the prim cannot be read or has no Breps; malformed packed data stops at that member.
SmStatus SmApiUsdTessellateFile(const char *pInputFile, const char *pOutputFile, const SmTessellationParams &crParams, SmBoolean bHealerIsEnabled, int iThreadCount, std::vector< SmApiUsdMeshTessellationResult > &rResults): Tessellate every BrepArray prim in a USD file and write a copy of the stage with a UsdGeomMesh per Brep under the default prim (or /Output), named tess_<prim>_<brep> (_<n> added if taken). Each mesh gets its Brep's world transform, visibility and purpose (default time) and material. Relative asset paths are rewritten if the output is in another directory. The input layer is not modified, even if the caller has it open.
SmApiStatus SmApiVariableRadiusFillet(SmBrep *pBrep, SmTArray< SmEdge * > &rEdges, double dStartRadius, double dEndRadius, ULONG lXSectType, ULONG lContinuity)
SmApiStatus SmApiVertexGetPoint(const SmVertex *pVertex, SmPoint3d &rPoint)
SmApiStatus SmApiWriteBrepToFile(const SmBrep *pBrep, const TCHAR *pFileName, SmBoolean bAscii): Write one Brep to a native SMLib .smb file.
bool UsdBrep::AppendBrepToArray(const UsdBrepView &brep, UsdBrepArrayData &rDest)
double UsdBrep::ApproxBoundaryLength(const UsdBrepView &brep, uint32_t iLocalFace, UsdBrepDomainEdge edge, uint32_t numSegments=32)
pxr::VtArray< double > UsdBrep::BuildFlatKnots(const std::vector< double > &rKnots, const std::vector< int > &rMults, int iDegree, bool bPeriodic)
void UsdBrep::CompressFlatKnots(const std::vector< double > &rFlatKnots, std::vector< double > &rOutKnots, std::vector< int > &rOutMults, double dTolerance=1e-9)
UsdBrepSurfaceDomain UsdBrep::ComputeTrimmedDomain(const UsdBrepView &brep, uint32_t iLocalFace, uint32_t samplesPerEdge=16)
void UsdBrep::DetectSurfacePeriodicity(const UsdBrepView &brep, uint32_t iLocalFace, double &oUPeriod, double &oVPeriod)
void UsdBrep::DetectSurfacePoles(const UsdBrepView &brep, uint32_t iLocalFace, bool &oHasPoleVMin, bool &oHasPoleVMax)
GfVec3d UsdBrep::EvalCircleCurve(const GfVec3d &center, const GfVec3d &axis, const GfVec3d &refDir, double radius, double t)
GfVec3d UsdBrep::EvalConeSurface(const GfVec3d &origin, const GfVec3d &axis, const GfVec3d &refDir, double radius, double semiAngle, double u, double v)
GfVec3d UsdBrep::EvalConeSurfaceNormal(const GfVec3d &axis, const GfVec3d &refDir, double semiAngle, double u)
GfVec3d UsdBrep::EvalCylinderSurface(const GfVec3d &origin, const GfVec3d &axis, const GfVec3d &refDir, double radius, double u, double v)
GfVec3d UsdBrep::EvalCylinderSurfaceNormal(const GfVec3d &axis, const GfVec3d &refDir, double u)
GfVec3d UsdBrep::EvalEllipseCurve(const GfVec3d &center, const GfVec3d &axis, const GfVec3d &refDir, double xRadius, double yRadius, double t)
GfVec3d UsdBrep::EvalLineCurve(const GfVec3d &origin, const GfVec3d &direction, double t)
GfVec2d UsdBrep::EvalNurbsCurve2d(TfSpan< const GfVec2d > controlVertices, TfSpan< const double > knots, TfSpan< const double > weights, uint32_t order, double t)
GfVec3d UsdBrep::EvalNurbsCurve3d(TfSpan< const GfVec3d > controlVertices, TfSpan< const double > knots, TfSpan< const double > weights, uint32_t order, double t)
GfVec3d UsdBrep::EvalNurbsSurface(TfSpan< const GfVec3d > controlVertices, uint32_t uVertexCount, uint32_t vVertexCount, TfSpan< const double > uKnots, TfSpan< const double > vKnots, TfSpan< const double > weights, uint32_t uOrder, uint32_t vOrder, double u, double v)
GfVec3d UsdBrep::EvalPlaneSurface(const GfVec3d &origin, const GfVec3d &axis, const GfVec3d &refDir, double u, double v)
GfVec3d UsdBrep::EvalPlaneSurfaceNormal(const GfVec3d &axis)
GfVec3d UsdBrep::EvalSphereSurface(const GfVec3d &center, const GfVec3d &axis, const GfVec3d &refDir, double radius, double u, double v)
GfVec3d UsdBrep::EvalSphereSurfaceNormal(const GfVec3d &axis, const GfVec3d &refDir, double u, double v)
GfVec3d UsdBrep::EvalTorusSurface(const GfVec3d &origin, const GfVec3d &axis, const GfVec3d &refDir, double majorRadius, double minorRadius, double u, double v)
GfVec3d UsdBrep::EvalTorusSurfaceNormal(const GfVec3d &axis, const GfVec3d &refDir, double majorRadius, double minorRadius, double u, double v)
GfVec2d UsdBrep::EvaluateCurve2d(const UsdBrepView &brep, uint32_t iLocalEdgeuse, double t)
GfVec3d UsdBrep::EvaluateCurve3d(const UsdBrepView &brep, uint32_t iLocalEdge, double t)
GfVec3d UsdBrep::EvaluateSurface(const UsdBrepView &brep, uint32_t iLocalFace, double u, double v)
GfVec3d UsdBrep::EvaluateSurfaceBoundary(const UsdBrepView &brep, uint32_t iLocalFace, UsdBrepDomainEdge edge, double t)
GfVec3d UsdBrep::EvaluateSurfaceClamped(const UsdBrepView &brep, uint32_t iLocalFace, double u, double v)
GfVec3d UsdBrep::EvaluateSurfaceNormal(const UsdBrepView &brep, uint32_t iLocalFace, double u, double v)
GfVec3d UsdBrep::EvaluateSurfaceNormalNormalized(const UsdBrepView &brep, uint32_t iLocalFace, double s, double t)
GfVec3d UsdBrep::EvaluateSurfaceNormalized(const UsdBrepView &brep, uint32_t iLocalFace, double s, double t)
std::vector< UsdPrim > UsdBrep::FindBrepArrayPrims(const UsdStageRefPtr &rStage)
bool UsdBrep::GetFaceLoopEdgeuseStart(const UsdBrepView &brep, uint32_t iLocalFace, uint32_t localLoopIndex, uint32_t &oEuStart, uint32_t &oEuCount)
GfVec2d UsdBrep::GetPCurveRange(const UsdBrepView &brep, uint32_t iLocalEdgeuse)
UsdBrepSurfaceDomain UsdBrep::GetSurfaceDomain(const UsdBrepView &brep, uint32_t iLocalFace)
void UsdBrep::GetSurfacePeriodicity(const TfToken &surfaceType, bool &oUPeriodic, bool &oVPeriodic, double &oUPeriod, double &oVPeriod)
bool UsdBrep::HasPCurve(const UsdBrepView &brep, uint32_t iLocalEdgeuse)
GfVec2d UsdBrep::InverseProjectCone(const GfVec3d &origin, const GfVec3d &axis, const GfVec3d &refDir, double radius, double semiAngle, const GfVec3d &point)
GfVec2d UsdBrep::InverseProjectCylinder(const GfVec3d &origin, const GfVec3d &axis, const GfVec3d &refDir, double radius, const GfVec3d &point)
GfVec2d UsdBrep::InverseProjectPlane(const GfVec3d &origin, const GfVec3d &axis, const GfVec3d &refDir, const GfVec3d &point)
GfVec2d UsdBrep::InverseProjectSphere(const GfVec3d &center, const GfVec3d &axis, const GfVec3d &refDir, double radius, const GfVec3d &point)
GfVec2d UsdBrep::InverseProjectSurface(const UsdBrepView &brep, uint32_t iLocalFace, const GfVec3d &point)
GfVec2d UsdBrep::InverseProjectSurfaceWithHint(const UsdBrepView &brep, uint32_t iLocalFace, const GfVec3d &point, const GfVec2d &uvHint)
GfVec2d UsdBrep::InverseProjectTorus(const GfVec3d &origin, const GfVec3d &axis, const GfVec3d &refDir, double majorRadius, double minorRadius, const GfVec3d &point)
bool UsdBrep::IsFaceNormalOutward(const UsdBrepView &brep, uint32_t iLocalFace)
bool UsdBrep::IsFaceuseOpposite(const UsdBrepView &brep, uint32_t iLocalFace)
bool UsdBrep::LoadAllBrepArrays(const std::string &sUsdFilePath, std::vector< std::pair< SdfPath, std::unique_ptr< UsdBrepArrayData > > > &rResults)
bool UsdBrep::LoadBrepArray(const UsdPrim &rPrim, UsdBrepArrayData &rArrays)
int UsdBrep::PeriodicExtraPoles(const std::vector< int > &rMults, int iDegree, bool bPeriodic)
std::vector< GfVec3d > UsdBrep::SampleSurfaceBoundary(const UsdBrepView &brep, uint32_t iLocalFace, UsdBrepDomainEdge edge, uint32_t numSegments)
bool UsdBrep::SaveBrepArray(const UsdBrepArrayData &rArrays, UsdPrim &rPrim)
double UsdBrep::SignedArea2D(const std::vector< GfVec2d > &polygon)
bool UsdBrepData::AddAppliedSchema(const pxr::SdfPrimSpecHandle &rPrimSpecHandle, const pxr::TfToken &rAppliedSchemaToken)
bool UsdBrepData::AddMultiAppliedSchema(const pxr::SdfPrimSpecHandle &rPrimSpecHandle, const pxr::TfToken &rAppliedSchemaToken, const pxr::TfToken &rInstanceToken)
bool UsdBrepData::AreOmniSolidSchemasKnown()
bool UsdBrepData::BrepReadFromUsdStage(const pxr::UsdPrim &crUsdBrepArray, UsdBrepArrayData &rArrays)
bool UsdBrepData::BrepWriteToUsdStage(const UsdBrepArrayData &rArrays, pxr::UsdPrim &rUsdBrepArray)
void UsdBrepData::Dump_BrepArrayData(const UsdBrepArrayData &rArrays, bool bDumpData=false)
void UsdBrepData::Dump_BrepArraySpans(const UsdBrepArrayData &rArrays, const UsdBrepArraySpans &rSpans, bool bDumpData=false)
void UsdBrepData::Dump_PrimProperties(const pxr::UsdPrim &crPrim)
void UsdBrepData::Dump_PrimProperties_fromPrimSpecHandle(const pxr::SdfPrimSpecHandle &crPrimSpecHandle, pxr::UsdStageRefPtr &rStage)
void UsdBrepData::Dump_PrimSpecProperties(const pxr::SdfPrimSpecHandle &rPrimSpecHandle)
pxr::TfToken UsdBrepData::GetNameSpacePropertyToken(const pxr::TfToken &rInstanceToken, const pxr::TfToken &rPropName)
uint32_t UsdBrepData::GetUsdBrepArray_BrepCount(const pxr::UsdPrim &crUsdBrepArray)
bool UsdBrepData::IsOmniSolidResourcesPluginRegistered()
bool UsdBrepData::RegisterOmniSolidResourcesPlugin()
pxr::SdfAttributeSpecHandle UsdBrepData::setAttributeSpec(const pxr::SdfPrimSpecHandle &rOwnerPrimSpecHandle, const pxr::TfToken &rToken, const pxr::SdfValueTypeName &rTypeName, const pxr::VtValue &rValue, pxr::SdfVariability eVariability=pxr::SdfVariabilityUniform, bool bCustom=false)
pxr::SdfAttributeSpecHandle UsdBrepData::setMultiAppliedAttributeSpec(const pxr::SdfPrimSpecHandle &rOwnerPrimSpecHandle, const pxr::TfToken &rInstanceToken, const pxr::TfToken &rPropToken, const pxr::SdfValueTypeName &rTypeName, const pxr::VtValue &rValue, pxr::SdfVariability variability=pxr::SdfVariabilityUniform, bool custom=false)
bool occt::BuildOcctModel(const UsdBrepData::UsdBrepArrayData &rArrays, SOcctModel &rModel, std::string &rError)
bool occt::ConvertCurve2dToNurb(const SCurve2d &rCurve, const pxr::GfRange1d &rInterval, const pxr::GfVec2d &rScale, const pxr::GfVec2d &rTranslation, StagedCurveData2d &rOut)
bool occt::ConvertCurve3d(const SCurve3d &rCurve, const pxr::GfMatrix4d &rTransform, StagedCurveData &rOut, const pxr::GfRange1d *pInterval=nullptr)
bool occt::ConvertOcctDataToUsd(const std::string &rOcctData, const pxr::UsdStageRefPtr &rStage, const pxr::SdfPath &rRootPath, std::string &rError)
bool occt::ConvertOcctFileToUsd(const std::string &rInputOcctPath, const std::string &rOutputUsdPath, std::string &rError)
bool occt::ConvertOcctTextToUsd(const std::string &rOcctText, const pxr::UsdStageRefPtr &rStage, const pxr::SdfPath &rRootPath, std::string &rError)
bool occt::ConvertSurface(const SSurface &rSurface, const pxr::GfMatrix4d &rTransform, StagedSurfaceData &rOut, const pxr::GfRange2d *pUVHint=nullptr, pxr::GfRange2d *pSweptDomainOut=nullptr)
const char * occt::CurveTypeName(ECurveType eType)
pxr::GfVec3d occt::EvalCurve3dPoint(const SCurve3d &rCurve, const pxr::GfMatrix4d &rTransform, double t)
bool occt::ExportBrepArrayToFile(const UsdBrepData::UsdBrepArrayData &rArrays, const std::string &rPath, std::string &rError)
bool occt::ExportBrepArrayToText(const UsdBrepData::UsdBrepArrayData &rArrays, std::string &rText, std::string &rError)
bool occt::IsBinaryOcct(const std::string &rData)
bool occt::ReadOcct(const std::string &rText, SOcctModel &rModel, std::string &rError)
bool occt::ReadOcctBinary(const std::string &rData, SOcctModel &rModel, std::string &rError)
pxr::GfMatrix4d occt::ResolveLocation(const SOcctModel &rModel, int iLocationIndex)
const char * occt::ShapeTypeName(EShapeType eType)
const char * occt::SurfaceTypeName(ESurfaceType eType)
std::string occt::WriteOcct(const SOcctModel &rModel)
void smu_WriteBuffer(const TCHAR *pBuff, const TCHAR *pBuffForFile=NULL)
void smu_sprintf(char *buff, const char *format, Args… args)
bool usdBrep_CreateOutputFiles()
void usdBrep_WriteString(const std::string &string)