diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,10 @@ ## Unreleased +## 0.1.1.1 - 2023-12-12 + +- Include header files in package, fixing build + ## 0.1.1.0 - 2023-12-12 ### Added diff --git a/cpp/hs_BRepAlgoAPI_Common.h b/cpp/hs_BRepAlgoAPI_Common.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepAlgoAPI_Common.h @@ -0,0 +1,17 @@ + +#ifndef HS_BREPALGOAPI_COMMON_H +#define HS_BREPALGOAPI_COMMON_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Shape * hs_BRepAlgoAPI_Common(TopoDS_Shape * a, TopoDS_Shape * b); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPALGOAPI_COMMON_H diff --git a/cpp/hs_BRepAlgoAPI_Cut.h b/cpp/hs_BRepAlgoAPI_Cut.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepAlgoAPI_Cut.h @@ -0,0 +1,17 @@ + +#ifndef HS_BREPALGOAPI_CUT_H +#define HS_BREPALGOAPI_CUT_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Shape * hs_BRepAlgoAPI_Cut(TopoDS_Shape * a, TopoDS_Shape * b); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPALGOAPI_CUT_H diff --git a/cpp/hs_BRepAlgoAPI_Fuse.h b/cpp/hs_BRepAlgoAPI_Fuse.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepAlgoAPI_Fuse.h @@ -0,0 +1,17 @@ + +#ifndef HS_BREPALGOAPI_FUSE_H +#define HS_BREPALGOAPI_FUSE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Shape * hs_BRepAlgoAPI_Fuse(TopoDS_Shape * a, TopoDS_Shape * b); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPALGOAPI_FUSE_H diff --git a/cpp/hs_BRepBuilderAPI_GTransform.h b/cpp/hs_BRepBuilderAPI_GTransform.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_GTransform.h @@ -0,0 +1,16 @@ +#ifndef HS_BREPBUILDERAPI_GTRANSFORM_H +#define HS_BREPBUILDERAPI_GTRANSFORM_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Shape * hs_BRepBuilderAPI_GTransform_gtransform(TopoDS_Shape * shape, gp_GTrsf * trsf, bool copy); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPBUILDERAPI_GTRANSFORM_H diff --git a/cpp/hs_BRepBuilderAPI_MakeEdge.h b/cpp/hs_BRepBuilderAPI_MakeEdge.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeEdge.h @@ -0,0 +1,30 @@ +#ifndef HS_BREPBUILDERAPI_MAKEEDGE_H +#define HS_BREPBUILDERAPI_MAKEEDGE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromVertices(TopoDS_Vertex *a, TopoDS_Vertex *b); + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromPnts(gp_Pnt *a, gp_Pnt *b); + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurve(Handle(Geom_Curve) * curve); + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveAndParameters(Handle(Geom_Curve) * curve, double a, double b); + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveAndVertices(Handle(Geom_Curve) * curve, TopoDS_Vertex* a, TopoDS_Vertex* b); + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveAndPnts(Handle(Geom_Curve) * curve, gp_Pnt* a, gp_Pnt* b); + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveVerticesAndParameters(Handle(Geom_Curve) * curve, TopoDS_Vertex* a, TopoDS_Vertex* b, double ap, double bp); + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurvePntsAndParameters(Handle(Geom_Curve) * curve, gp_Pnt* a, gp_Pnt* b, double ap, double bp); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPBUILDERAPI_MAKEEDGE_H diff --git a/cpp/hs_BRepBuilderAPI_MakeFace.h b/cpp/hs_BRepBuilderAPI_MakeFace.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeFace.h @@ -0,0 +1,36 @@ +#ifndef HS_BREPBUILDERAPI_MAKEFACE_H +#define HS_BREPBUILDERAPI_MAKEFACE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace(); + +void hs_delete_BRepBuilderAPI_MakeFace(BRepBuilderAPI_MakeFace * builder); + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromFace(TopoDS_Face * face); + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromSurface(Handle(Geom_Surface)* surface, double tolerance); + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndBounds(Handle(Geom_Surface)* surface, double uMin, double uMax, double vMin, double vMax, double tolerance); + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndWire(Handle(Geom_Surface)* surface, TopoDS_Wire* wire, bool inside); + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromWire(TopoDS_Wire* wire, bool onlyPlane); + +void hs_BRepBuilderAPI_MakeFace_Add(BRepBuilderAPI_MakeFace* builder, TopoDS_Wire* wire); + +bool hs_BRepBuilderAPI_MakeFace_IsDone(BRepBuilderAPI_MakeFace* builder); + +BRepBuilderAPI_FaceError hs_BRepBuilderAPI_MakeFace_Error(BRepBuilderAPI_MakeFace * builder); + +TopoDS_Face * hs_BRepBuilderAPI_MakeFace_Face(BRepBuilderAPI_MakeFace * builder); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPBUILDERAPI_MAKEFACE_H diff --git a/cpp/hs_BRepBuilderAPI_MakeShape.h b/cpp/hs_BRepBuilderAPI_MakeShape.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeShape.h @@ -0,0 +1,17 @@ +#ifndef HS_BREPBUILDERAPI_MAKE_SHAPE_H +#define HS_BREPBUILDERAPI_MAKE_SHAPE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Shape * hs_BRepBuilderAPI_MakeShape_shape(BRepBuilderAPI_MakeShape * builder); + + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPBUILDERAPI_MAKE_SHAPE_H diff --git a/cpp/hs_BRepBuilderAPI_MakeSolid.h b/cpp/hs_BRepBuilderAPI_MakeSolid.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeSolid.h @@ -0,0 +1,22 @@ +#ifndef HS_BREPBUILDERAPI_MAKESOLID_H +#define HS_BREPBUILDERAPI_MAKESOLID_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +BRepBuilderAPI_MakeSolid * hs_new_BRepBuilderAPI_MakeSolid(); + +void hs_delete_BRepBuilderAPI_MakeSolid(BRepBuilderAPI_MakeSolid * builder); + +void hs_BRepBuilderAPI_MakeSolid_add(BRepBuilderAPI_MakeSolid * builder, TopoDS_Shell * shell); + +TopoDS_Solid * hs_BRepBuilderAPI_MakeSolid_solid(BRepBuilderAPI_MakeSolid * builder); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPBUILDERAPI_MAKESOLID_H diff --git a/cpp/hs_BRepBuilderAPI_MakeWire.h b/cpp/hs_BRepBuilderAPI_MakeWire.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeWire.h @@ -0,0 +1,30 @@ +#ifndef HS_BREPBUILDERAPI_MAKEWIRE_H +#define HS_BREPBUILDERAPI_MAKEWIRE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +BRepBuilderAPI_MakeWire * hs_new_BRepBuilderAPI_MakeWire(); + +void hs_delete_BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeWire* builder); + +void hs_BRepBuilderAPI_MakeWire_AddEdge(BRepBuilderAPI_MakeWire* builder, TopoDS_Edge* edge); + +void hs_BRepBuilderAPI_MakeWire_AddWire(BRepBuilderAPI_MakeWire* builder, TopoDS_Wire* wire); + +void hs_BRepBuilderAPI_MakeWire_AddListOfShape(BRepBuilderAPI_MakeWire* builder, TopTools_ListOfShape *list); + +TopoDS_Wire * hs_BRepBuilderAPI_MakeWire_Wire(BRepBuilderAPI_MakeWire* builder); + +bool hs_BRepBuilderAPI_MakeWire_IsDone(BRepBuilderAPI_MakeWire* builder); + +BRepBuilderAPI_WireError hs_BRepBuilderAPI_MakeWire_Error(BRepBuilderAPI_MakeWire* builder); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPBUILDERAPI_MAKEWIRE_H diff --git a/cpp/hs_BRepBuilderAPI_Transform.h b/cpp/hs_BRepBuilderAPI_Transform.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_Transform.h @@ -0,0 +1,16 @@ +#ifndef HS_BREPBUILDERAPI_TRANSFORM_H +#define HS_BREPBUILDERAPI_TRANSFORM_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Shape * hs_BRepBuilderAPI_Transform_transform(TopoDS_Shape * shape, gp_Trsf * trsf, bool copy); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPBUILDERAPI_TRANSFORM_H diff --git a/cpp/hs_BRepFilletAPI_MakeFillet.h b/cpp/hs_BRepFilletAPI_MakeFillet.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepFilletAPI_MakeFillet.h @@ -0,0 +1,24 @@ +#ifndef HS_BREPFILLETAPI_MAKEFILLET_H +#define HS_BREPFILLETAPI_MAKEFILLET_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +BRepFilletAPI_MakeFillet * hs_new_BRepFilletAPI_MakeFillet_fromShape(TopoDS_Shape * shape); + +void hs_delete_BRepFilletAPI_MakeFillet(BRepFilletAPI_MakeFillet * builder); + +void hs_BRepFilletAPI_MakeFillet_addEdge(BRepFilletAPI_MakeFillet * builder, TopoDS_Edge *edge ); + +void hs_BRepFilletAPI_MakeFillet_addEdgeWithRadius(BRepFilletAPI_MakeFillet * builder, double r, TopoDS_Edge *edge ); + +void hs_BRepFilletAPI_MakeFillet_addEdgeWithTwoRadiuses(BRepFilletAPI_MakeFillet * builder, double r1, double r2, TopoDS_Edge *edge ); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPFILLETAPI_MAKEFILLET_H diff --git a/cpp/hs_BRepMesh_IncrementalMesh.h b/cpp/hs_BRepMesh_IncrementalMesh.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepMesh_IncrementalMesh.h @@ -0,0 +1,20 @@ +#ifndef HS_BREPMESH_INCREMENTALMESH_H +#define HS_BREPMESH_INCREMENTALMESH_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +BRepMesh_IncrementalMesh * hs_BRepMesh_IncrementalMesh_fromShapeAndLinDeflection(TopoDS_Shape *shape, double theLinDeflection); + +void hs_delete_BRepMesh_IncrementalMesh(BRepMesh_IncrementalMesh * mesh); + +void hs_BRepMesh_IncrementalMesh_Perform(BRepMesh_IncrementalMesh * mesh); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPMESH_INCREMENTALMESH_H diff --git a/cpp/hs_BRepOffsetAPI_MakeOffsetShape.h b/cpp/hs_BRepOffsetAPI_MakeOffsetShape.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepOffsetAPI_MakeOffsetShape.h @@ -0,0 +1,32 @@ +#ifndef HS_BREPOFFSETAPI_MAKEOFFSETSHAPE_H +#define HS_BREPOFFSETAPI_MAKEOFFSETSHAPE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +BRepOffsetAPI_MakeOffsetShape * hs_new_BRepOffsetAPI_MakeOffsetShape(); + +void hs_delete_BRepOffsetAPI_MakeOffsetShape(BRepOffsetAPI_MakeOffsetShape * builder); + +void hs_BRepOffsetAPI_MakeOffsetShape_performBySimple(BRepOffsetAPI_MakeOffsetShape * builder, TopoDS_Shape * shape, double value); + +void hs_BRepOffsetAPI_MakeOffsetShape_performByJoin( + BRepOffsetAPI_MakeOffsetShape * builder, + TopoDS_Shape * shape, + double value, + double tol, + BRepOffset_Mode mode, + bool intersection, + bool selfInter, + GeomAbs_JoinType join, + bool removeIntEdges + ); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPOFFSETAPI_MAKEOFFSETSHAPE_H diff --git a/cpp/hs_BRepOffsetAPI_MakePipe.h b/cpp/hs_BRepOffsetAPI_MakePipe.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepOffsetAPI_MakePipe.h @@ -0,0 +1,18 @@ +#ifndef HS_BREPOFFSETAPI_MAKEPIPE_H +#define HS_BREPOFFSETAPI_MAKEPIPE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +BRepOffsetAPI_MakePipe * hs_new_BRepOffsetAPI_MakePipe_fromWireAndShape(TopoDS_Wire * wire, TopoDS_Shape * profile); + +void hs_delete_BRepOffsetAPI_MakePipe(BRepOffsetAPI_MakePipe * builder); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPOFFSETAPI_MAKEPIPE_H diff --git a/cpp/hs_BRepPrimAPI_MakeBox.h b/cpp/hs_BRepPrimAPI_MakeBox.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakeBox.h @@ -0,0 +1,23 @@ +#ifndef HS_BREPPRIMAPI_MAKEBOX_H +#define HS_BREPPRIMAPI_MAKEBOX_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +BRepPrimAPI_MakeBox * hs_new_BRepPrimAPI_MakeBox_fromPnts(gp_Pnt * a, gp_Pnt * b); + +void hs_delete_BRepPrimAPI_MakeBox(BRepPrimAPI_MakeBox* builder); + +TopoDS_Shape * hs_BRepPrimAPI_MakeBox_Solid(BRepPrimAPI_MakeBox* builder); + +TopoDS_Shell * hs_BRepPrimAPI_MakeBox_Shell(BRepPrimAPI_MakeBox* builder); + + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPPRIMAPI_MAKEBOX_H diff --git a/cpp/hs_BRepPrimAPI_MakeCylinder.h b/cpp/hs_BRepPrimAPI_MakeCylinder.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakeCylinder.h @@ -0,0 +1,16 @@ +#ifndef HS_BREPPRIMAPI_MAKECYLINDER_H +#define HS_BREPPRIMAPI_MAKECYLINDER_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Solid * hs_BRepPrimAPI_MakeCylinder_fromRadiusAndHeight(double r, double h); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPPRIMAPI_MAKECYLINDER_H diff --git a/cpp/hs_BRepPrimAPI_MakePrism.h b/cpp/hs_BRepPrimAPI_MakePrism.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakePrism.h @@ -0,0 +1,18 @@ +#ifndef HS_BREPPRIMAPI_MAKEPRISM_H +#define HS_BREPPRIMAPI_MAKEPRISM_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Shape * hs_BRepPrimAPI_MakePrism_fromVec(TopoDS_Shape * shape, gp_Vec * vec, bool copy, bool canonize); + +TopoDS_Shape * hs_BRepPrimAPI_MakePrism_fromDir(TopoDS_Shape * shape, gp_Dir * dir, bool inf, bool copy, bool canonize); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPPRIMAPI_MAKEPRISM_H diff --git a/cpp/hs_BRepPrimAPI_MakeRevol.h b/cpp/hs_BRepPrimAPI_MakeRevol.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakeRevol.h @@ -0,0 +1,18 @@ +#ifndef HS_BREPPRIMAPI_MAKEREVOL_H +#define HS_BREPPRIMAPI_MAKEREVOL_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +BRepPrimAPI_MakeRevol * hs_new_BRepPrimAPI_MakeRevol_fromShapeAndAx1(TopoDS_Shape * shape, gp_Ax1 * axis, bool copy); + +void hs_delete_BRepPrimAPI_MakeRevol(BRepPrimAPI_MakeRevol * builder); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPPRIMAPI_MAKEREVOL_H diff --git a/cpp/hs_BRepPrimAPI_MakeSphere.h b/cpp/hs_BRepPrimAPI_MakeSphere.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakeSphere.h @@ -0,0 +1,18 @@ +#ifndef HS_BREPPRIMAPI_MAKESPHERE_H +#define HS_BREPPRIMAPI_MAKESPHERE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Solid * hs_BRepPrimAPI_MakeSphere_fromRadius(double r); + +TopoDS_Solid * hs_BRepPrimAPI_MakeSphere_fromPntAndRadius(gp_Pnt * center, double r); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPPRIMAPI_MAKESPHERE_H diff --git a/cpp/hs_BRepTools_WireExplorer.h b/cpp/hs_BRepTools_WireExplorer.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepTools_WireExplorer.h @@ -0,0 +1,27 @@ +#ifndef HS_BREPTOOLS_WIREEXPLORER_H +#define HS_BREPTOOLS_WIREEXPLORER_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +BRepTools_WireExplorer * hs_new_BRepTools_WireExplorer_fromWire(TopoDS_Wire *wire); + +void hs_delete_BRepTools_WireExplorer(BRepTools_WireExplorer * explorer); + +bool hs_BRepTools_WireExplorer_more(BRepTools_WireExplorer * explorer); + +void hs_BRepTools_WireExplorer_next(BRepTools_WireExplorer * explorer); + +TopoDS_Edge * hs_BRepTools_WireExplorer_current(BRepTools_WireExplorer * explorer); + +TopAbs_Orientation hs_BRepTools_WireExplorer_orientation(BRepTools_WireExplorer * explorer); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREPTOOLS_WIREEXPLORER_H diff --git a/cpp/hs_BRep_Tool.h b/cpp/hs_BRep_Tool.h new file mode 100644 --- /dev/null +++ b/cpp/hs_BRep_Tool.h @@ -0,0 +1,20 @@ +#ifndef HS_BREP_TOOL_H +#define HS_BREP_TOOL_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +Handle(Geom_Curve) * hs_BRep_Tool_curve(TopoDS_Edge * edge); + +double hs_BRep_Tool_curveParamFirst(TopoDS_Edge * edge); + +double hs_BRep_Tool_curveParamLast(TopoDS_Edge * edge); + +#ifdef __cplusplus +} +#endif + +#endif // HS_BREP_TOOL_H diff --git a/cpp/hs_Font_BRepFont.h b/cpp/hs_Font_BRepFont.h new file mode 100644 --- /dev/null +++ b/cpp/hs_Font_BRepFont.h @@ -0,0 +1,32 @@ +#ifndef HS_FONT_BREPFONT_H +#define HS_FONT_BREPFONT_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +Font_BRepFont * hs_new_Font_BRepFont(); + +Font_BRepFont * hs_new_Font_BRepFont_fromStringAndSize(char * path, double size); + +bool hs_Font_BRepFont_initPathAndSize(Font_BRepFont * font, char * path, double size); + +bool hs_Font_BRepFont_initNameAspectAndSize(Font_BRepFont * font, char * name, Font_FontAspect aspect, double size); + +void hs_delete_Font_BRepFont(Font_BRepFont * font); + +double hs_Font_BRepFont_ascender(Font_BRepFont * font); + +double hs_Font_BRepFont_descender(Font_BRepFont * font); + +double hs_Font_BRepFont_lineSpacing(Font_BRepFont * font); + +double hs_Font_BRepFont_pointSize(Font_BRepFont * font); + +#ifdef __cplusplus +} +#endif + +#endif // HS_FONT_BREPFONT_H diff --git a/cpp/hs_Font_BRepTextBuilder.h b/cpp/hs_Font_BRepTextBuilder.h new file mode 100644 --- /dev/null +++ b/cpp/hs_Font_BRepTextBuilder.h @@ -0,0 +1,26 @@ +#ifndef HS_FONT_BREPTEXTBUILDER_H +#define HS_FONT_BREPTEXTBUILDER_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +Font_BRepTextBuilder * hs_new_Font_BRepTextBuilder(); + +void hs_delete_Font_BRepTextBuilder(Font_BRepTextBuilder * builder); + +TopoDS_Shape * hs_Font_BRepTextBuilder_perform( + Font_BRepTextBuilder * builder, + Font_BRepFont * font, + char * theString, + gp_Ax3 * thePenLoc, + Graphic3d_HorizontalTextAlignment theHAlign, + Graphic3d_VerticalTextAlignment theVAlign + ); +#ifdef __cplusplus +} +#endif + +#endif // HS_FONT_BREPFONT_H diff --git a/cpp/hs_GC_MakeArcOfCircle.h b/cpp/hs_GC_MakeArcOfCircle.h new file mode 100644 --- /dev/null +++ b/cpp/hs_GC_MakeArcOfCircle.h @@ -0,0 +1,18 @@ +#ifndef HS_GC_MAKEARCOFCIRCLE_H +#define HS_GC_MAKEARCOFCIRCLE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +Handle(Geom_TrimmedCurve) * hs_GC_MakeArcOfCircle_from3Pnts(gp_Pnt * a, gp_Pnt * b, gp_Pnt * c); + +Handle(Geom_TrimmedCurve) * hs_GC_MakeArcOfCircle_fromPntsAndVec(gp_Pnt * a, gp_Vec * b, gp_Pnt * c); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GC_MAKEARCOFCIRCLE_H diff --git a/cpp/hs_GC_MakeSegment.h b/cpp/hs_GC_MakeSegment.h new file mode 100644 --- /dev/null +++ b/cpp/hs_GC_MakeSegment.h @@ -0,0 +1,17 @@ +#ifndef HS_GC_SEGMENT_H +#define HS_GC_SEGMENT_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +Handle(Geom_TrimmedCurve) * hs_GC_MakeSegment_fromPnts(gp_Pnt* a, gp_Pnt* b); + + +#ifdef __cplusplus +} +#endif + +#endif // HS_GC_MAKESEGMENT_H diff --git a/cpp/hs_Geom_BezierCurve.h b/cpp/hs_Geom_BezierCurve.h new file mode 100644 --- /dev/null +++ b/cpp/hs_Geom_BezierCurve.h @@ -0,0 +1,22 @@ +#ifndef HS_GEOM_BEZIERCURVE_H +#define HS_GEOM_BEZIERCURVE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +Geom_BezierCurve * hs_new_Geom_BezierCurve_fromPnts(ARRAY_1(gp_Pnt) * pnts); + +Handle(Geom_BezierCurve) * hs_Geom_BezierCurve_toHandle(Geom_BezierCurve * curve); + +void hs_delete_Handle_Geom_BezierCurve(Handle(Geom_BezierCurve)* h); + +void hs_delete_Geom_BezierCurve(Geom_BezierCurve * curve); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GEOM_BEZIERCURVE_H diff --git a/cpp/hs_Geom_Curve.h b/cpp/hs_Geom_Curve.h new file mode 100644 --- /dev/null +++ b/cpp/hs_Geom_Curve.h @@ -0,0 +1,18 @@ +#ifndef HS_GEOM_CURVE_H +#define HS_GEOM_CURVE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif +void hs_delete_Handle_Geom_Curve(Handle(Geom_Curve) * handle); + +gp_Pnt * hs_Geom_Curve_value(Handle(Geom_Curve) * curve, double u); + +gp_Vec * hs_Geom_Curve_dn(Handle (Geom_Curve) * curve, double u, int n); +#ifdef __cplusplus +} +#endif + +#endif // HS_GEOM_CURVE_H diff --git a/cpp/hs_Geom_TrimmedCurve.h b/cpp/hs_Geom_TrimmedCurve.h new file mode 100644 --- /dev/null +++ b/cpp/hs_Geom_TrimmedCurve.h @@ -0,0 +1,16 @@ +#ifndef HS_GEOM_TRIMMED_CURVE_H +#define HS_GEOM_TRIMMED_CURVE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void hs_delete_Handle_Geom_TrimmedCurve(Handle(Geom_TrimmedCurve)* h); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GEOM_TRIMMED_CURVE_H diff --git a/cpp/hs_NCollection_Array1.h b/cpp/hs_NCollection_Array1.h new file mode 100644 --- /dev/null +++ b/cpp/hs_NCollection_Array1.h @@ -0,0 +1,20 @@ +#ifndef HS_NCOLLECTION_ARRAY1_H +#define HS_NCOLLECTION_ARRAY1_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +ARRAY_1(gp_Pnt) * hs_new_NCollection_Array1_gp_Pnt(int lower, int upper); + +void hs_NCollection_Array1_gp_Pnt_setValue(ARRAY_1(gp_Pnt) * arr, int index, gp_Pnt * value); + +void hs_delete_NCollection_Array1_gp_Pnt(ARRAY_1(gp_Pnt) * arr); + +#ifdef __cplusplus +} +#endif + +#endif // HS_NCOLLECTION_ARRAY1_H diff --git a/cpp/hs_STEPControl_Writer.h b/cpp/hs_STEPControl_Writer.h new file mode 100644 --- /dev/null +++ b/cpp/hs_STEPControl_Writer.h @@ -0,0 +1,26 @@ +#ifndef HS_STEPCONTROL_WRITER_H +#define HS_STEPCONTROL_WRITER_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +STEPControl_Writer * hs_new_STEPControl_Writer(); + +void hs_delete_STEPControl_Writer(STEPControl_Writer * writer); + +void hs_STEPControl_Writer_setTolerance(STEPControl_Writer * writer, double tolerance); + +void hs_STEPControl_Writer_unsetTolerance(STEPControl_Writer * writer); + +IFSelect_ReturnStatus hs_STEPControl_Writer_transfer(STEPControl_Writer * writer, TopoDS_Shape * shape, STEPControl_StepModelType mode, bool compgraph); + +IFSelect_ReturnStatus hs_STEPControl_Writer_write(STEPControl_Writer* writer, char* filename); + +#ifdef __cplusplus +} +#endif + +#endif // HS_STEPCONTROL_WRITER_H diff --git a/cpp/hs_StlAPI_Writer.h b/cpp/hs_StlAPI_Writer.h new file mode 100644 --- /dev/null +++ b/cpp/hs_StlAPI_Writer.h @@ -0,0 +1,23 @@ + +#ifndef HS_STLAPI_WRITER_H +#define HS_STLAPI_WRITER_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +StlAPI_Writer * hs_new_StlAPI_Writer(); + +void hs_delete_StlAPI_Writer(StlAPI_Writer * writer); + +void hs_StlAPI_Writer_setAsciiMode(StlAPI_Writer * writer, bool asciiMode); + +bool hs_StlAPI_Writer_write(StlAPI_Writer * writer, TopoDS_Shape * shape, char* filename); + +#ifdef __cplusplus +} +#endif + +#endif // HS_STLAPI_WRITER_H diff --git a/cpp/hs_TopExp_Explorer.h b/cpp/hs_TopExp_Explorer.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopExp_Explorer.h @@ -0,0 +1,23 @@ +#ifndef HS_BREPFILLETAPI_MAKEFILLET_H +#define HS_BREPFILLETAPI_MAKEFILLET_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopExp_Explorer * hs_new_TopExp_Explorer(TopoDS_Shape * shape, TopAbs_ShapeEnum toFind); + +void hs_delete_TopExp_Explorer(TopExp_Explorer * explorer); + +bool hs_TopExp_Explorer_more(TopExp_Explorer * explorer); + +void hs_TopExp_Explorer_next(TopExp_Explorer * explorer); + +TopoDS_Shape * hs_TopExp_Explorer_value(TopExp_Explorer * explorer); +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPEXP_EXPLORER_H diff --git a/cpp/hs_TopLoc_Location.h b/cpp/hs_TopLoc_Location.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopLoc_Location.h @@ -0,0 +1,44 @@ +#ifndef HS_TOPLOC_LOCATION_H +#define HS_TOPLOC_LOCATION_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopLoc_Location * hs_new_TopLoc_Location(); + +TopLoc_Location * hs_new_TopLoc_Location_fromGPTrsf(gp_Trsf * trsf); + +void hs_delete_TopLoc_Location(TopLoc_Location * l); + +bool hs_TopLoc_Location_IsIdentity(TopLoc_Location * l); + +int hs_TopLoc_Location_FirstPower(TopLoc_Location * l); + +TopLoc_Location * hs_TopLoc_Location_NextLocation(TopLoc_Location * l); + +TopLoc_Location * hs_TopLoc_Location_Inverted(TopLoc_Location * l); + +TopLoc_Location * hs_TopLoc_Location_Multiplied(TopLoc_Location * a, TopLoc_Location * b); + +TopLoc_Location * hs_TopLoc_Location_Divided(TopLoc_Location * a, TopLoc_Location * b); + +TopLoc_Location * hs_TopLoc_Location_Predivided(TopLoc_Location * a, TopLoc_Location * b); + +TopLoc_Location * hs_TopLoc_Location_Powered(TopLoc_Location * l, int p); + +gp_Trsf * hs_TopLoc_Location_toGPTrsf(TopLoc_Location * l); + +bool hs_TopLoc_Location_IsEqual(TopLoc_Location * a, TopLoc_Location * b); + +bool hs_TopLoc_Location_IsDifferent(TopLoc_Location * a, TopLoc_Location * b); + +void hs_TopLoc_Location_Clear(TopLoc_Location * l); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPLOC_LOCATION_H diff --git a/cpp/hs_TopoDS_CompSolid.h b/cpp/hs_TopoDS_CompSolid.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_CompSolid.h @@ -0,0 +1,16 @@ +#ifndef HS_TOPODS_COMPSOLID_H +#define HS_TOPODS_COMPSOLID_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_CompSolid * hs_new_TopoDS_CompSolid(); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPODS_COMPSOLID_H diff --git a/cpp/hs_TopoDS_Compound.h b/cpp/hs_TopoDS_Compound.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Compound.h @@ -0,0 +1,16 @@ +#ifndef HS_TOPODS_COMPOUND_H +#define HS_TOPODS_COMPOUND_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Compound * hs_new_TopoDS_Compound(); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPODS_COMPOUND_H diff --git a/cpp/hs_TopoDS_Edge.h b/cpp/hs_TopoDS_Edge.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Edge.h @@ -0,0 +1,16 @@ +#ifndef HS_TOPODS_EDGE_H +#define HS_TOPODS_EDGE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Edge * hs_new_TopoDS_Edge(); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPODS_EDGE_H diff --git a/cpp/hs_TopoDS_Face.h b/cpp/hs_TopoDS_Face.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Face.h @@ -0,0 +1,16 @@ +#ifndef HS_TOPODS_FACE_H +#define HS_TOPODS_FACE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Face * hs_new_TopoDS_Face(); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPODS_FACE_H diff --git a/cpp/hs_TopoDS_Shape.h b/cpp/hs_TopoDS_Shape.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Shape.h @@ -0,0 +1,106 @@ +#ifndef HS_TOPODS_SHAPE_H +#define HS_TOPODS_SHAPE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Shape * hs_new_TopoDS_Shape(); + +TopoDS_Shape * hs_new_TopoDS_Shape_copy(TopoDS_Shape * shape); + +void hs_delete_TopoDS_Shape(TopoDS_Shape * shape); + +bool hs_TopoDS_Shape_IsNull(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_Nullify(TopoDS_Shape * shape); + +TopLoc_Location * hs_TopoDS_Shape_Location(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetLocation(TopoDS_Shape * shape, TopLoc_Location * location); + +TopoDS_Shape * hs_TopoDS_Shape_Located(TopoDS_Shape * shape, TopLoc_Location * location); + +TopAbs_Orientation hs_TopoDS_Shape_Orientation(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetOrientation(TopoDS_Shape * shape, TopAbs_Orientation orientation); + +TopoDS_Shape * hs_TopoDS_Shape_Oriented(TopoDS_Shape * shape, TopAbs_Orientation orientation); + +TopAbs_ShapeEnum hs_TopoDS_Shape_ShapeType(TopoDS_Shape * shape); + +bool hs_TopoDS_Shape_Free(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetFree(TopoDS_Shape * shape, bool b); + +bool hs_TopoDS_Shape_Locked(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetLocked(TopoDS_Shape * shape, bool b); + +bool hs_TopoDS_Shape_Modified(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetModified(TopoDS_Shape * shape, bool b); + + +bool hs_TopoDS_Shape_Checked(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetChecked(TopoDS_Shape * shape, bool b); + + +bool hs_TopoDS_Shape_Orientable(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetOrientable(TopoDS_Shape * shape, bool b); + +bool hs_TopoDS_Shape_Closed(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetClosed(TopoDS_Shape * shape, bool b); + + +bool hs_TopoDS_Shape_Infinite(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetInfinite(TopoDS_Shape * shape, bool b); + + +bool hs_TopoDS_Shape_Convex(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_SetConvex(TopoDS_Shape * shape, bool b); + +void hs_TopoDS_Shape_Move(TopoDS_Shape * shape, TopLoc_Location * position); + +TopoDS_Shape * hs_TopoDS_Shape_Moved(TopoDS_Shape * shape, TopLoc_Location * position); + +int hs_TopoDS_Shape_NbChildren(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_Reverse(TopoDS_Shape * shape); + +TopoDS_Shape * hs_TopoDS_Shape_Reversed(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_Complement(TopoDS_Shape * shape); + +TopoDS_Shape * hs_TopoDS_Shape_Complemented(TopoDS_Shape * shape); + +void hs_TopoDS_Shape_Compose(TopoDS_Shape * shape, TopAbs_Orientation orient); + +TopoDS_Shape * hs_TopoDS_Shape_Composed(TopoDS_Shape * shape, TopAbs_Orientation orient); + +bool hs_TopoDS_Shape_IsEqual(TopoDS_Shape * a, TopoDS_Shape* b); + +bool hs_TopoDS_Shape_IsSame(TopoDS_Shape * a, TopoDS_Shape* b); + +bool hs_TopoDS_Shape_IsPartner(TopoDS_Shape * a, TopoDS_Shape* b); + +bool hs_TopoDS_Shape_IsNotEqual(TopoDS_Shape * a, TopoDS_Shape* b); + +void hs_TopoDS_Shape_EmptyCopy(TopoDS_Shape * shape); + +int hs_TopoDS_Shape_hashCode(TopoDS_Shape * shape, int maxN); + +TopoDS_Shape * hs_TopoDS_Shape_EmptyCopied(TopoDS_Shape * shape); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPODS_SHAPE_H diff --git a/cpp/hs_TopoDS_Shell.h b/cpp/hs_TopoDS_Shell.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Shell.h @@ -0,0 +1,16 @@ +#ifndef HS_TOPODS_SHELL_H +#define HS_TOPODS_SHELL_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Shell * hs_new_TopoDS_Shell(); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPODS_SHELL_H diff --git a/cpp/hs_TopoDS_Solid.h b/cpp/hs_TopoDS_Solid.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Solid.h @@ -0,0 +1,16 @@ +#ifndef HS_TOPODS_SOLID_H +#define HS_TOPODS_SOLID_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Solid * hs_new_TopoDS_Solid(); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPODS_SOLID_H diff --git a/cpp/hs_TopoDS_Vertex.h b/cpp/hs_TopoDS_Vertex.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Vertex.h @@ -0,0 +1,16 @@ +#ifndef HS_TOPODS_VERTEX_H +#define HS_TOPODS_VERTEX_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Vertex * hs_new_TopoDS_Vertex(); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPODS_VERTEX_H diff --git a/cpp/hs_TopoDS_Wire.h b/cpp/hs_TopoDS_Wire.h new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Wire.h @@ -0,0 +1,16 @@ +#ifndef HS_TOPODS_WIRE_H +#define HS_TOPODS_WIRE_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +TopoDS_Wire * hs_new_TopoDS_Wire(); + +#ifdef __cplusplus +} +#endif + +#endif // HS_TOPODS_WIRE_H diff --git a/cpp/hs_gp.h b/cpp/hs_gp.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp.h @@ -0,0 +1,44 @@ +#ifndef HS_GP_H +#define HS_GP_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Pnt * hs_gp_Origin(); + +gp_Dir * hs_gp_DX(); + +gp_Dir * hs_gp_DY(); + +gp_Dir * hs_gp_DZ(); + +gp_Ax1 * hs_gp_OX(); + +gp_Ax1 * hs_gp_OY(); + +gp_Ax1 * hs_gp_OZ(); + +gp_Ax2 * hs_gp_XOY(); + +gp_Ax2 * hs_gp_YOZ(); + +gp_Ax2 * hs_gp_ZOX(); + +gp_Pnt2d * hs_gp_Origin2d(); + +gp_Dir2d * hs_gp_DX2d(); + +gp_Dir2d * hs_gp_DY2d(); + +gp_Ax2d * hs_gp_OX2d(); + +gp_Ax2d * hs_gp_OY2d(); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_H diff --git a/cpp/hs_gp_Ax1.h b/cpp/hs_gp_Ax1.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Ax1.h @@ -0,0 +1,72 @@ +#ifndef HS_GP_AX1_H +#define HS_GP_AX1_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Ax1 * hs_new_gp_Ax1(gp_Pnt * origin, gp_Dir * direction); + +void hs_delete_gp_Ax1(gp_Ax1* ax1); + +gp_Dir * hs_gp_Ax1_Direction(gp_Ax1* ax1); + +gp_Pnt * hs_gp_Ax1_Location(gp_Ax1* ax1); + +void hs_gp_Ax1_SetDirection(gp_Ax1* ax1, gp_Dir* direction); + +void hs_gp_Ax1_SetLocation(gp_Ax1* ax1, gp_Pnt* origin); + +bool hs_gp_Ax1_IsCoaxial(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance, double linearTolerance); + +bool hs_gp_Ax1_IsNormal(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance); + +bool hs_gp_Ax1_IsOpposite(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance); + +bool hs_gp_Ax1_IsParallel(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance); + +double hs_gp_Ax1_Angle(gp_Ax1* axis1, gp_Ax1* axis2); + +void hs_gp_Ax1_Reverse(gp_Ax1* ax1); + +gp_Ax1 * hs_gp_Ax1_Reversed(gp_Ax1* ax1); + +void hs_gp_Ax1_Mirror(gp_Ax1* ax1, gp_Ax1* mirror); + +gp_Ax1 * hs_gp_Ax1_Mirrored(gp_Ax1* ax1, gp_Ax1* mirror); + +void hs_gp_Ax1_MirrorAboutPnt(gp_Ax1* ax1, gp_Pnt* mirror); + +gp_Ax1 * hs_gp_Ax1_MirroredAboutPnt(gp_Ax1* ax1, gp_Pnt* mirror); + +void hs_gp_Ax1_MirrorAboutAx2(gp_Ax1* ax1, gp_Ax2* mirror); + +gp_Ax1 * hs_gp_Ax1_MirroredAboutAx2(gp_Ax1* ax1, gp_Ax2* mirror); + +void hs_gp_Ax1_Rotate(gp_Ax1* ax1, gp_Ax1* axisOfRotation, double angle); + +gp_Ax1 * hs_gp_Ax1_Rotated(gp_Ax1* ax1, gp_Ax1* axisOfRotation, double angle); + +void hs_gp_Ax1_Scale(gp_Ax1* ax1, gp_Pnt* origin, double amount); + +gp_Ax1 * hs_gp_Ax1_Scaled(gp_Ax1* ax1, gp_Pnt* origin, double amount); + +void hs_gp_Ax1_Transform(gp_Ax1* ax1, gp_Trsf* trsf); + +gp_Ax1 * hs_gp_Ax1_Transformed(gp_Ax1* ax1, gp_Trsf* trsf); + +void hs_gp_Ax1_Translate(gp_Ax1* ax1, gp_Vec* vec); + +gp_Ax1 * hs_gp_Ax1_Translated(gp_Ax1* ax1, gp_Vec* vec); + +void hs_gp_Ax1_TranslateRelative(gp_Ax1* ax1, gp_Pnt* from, gp_Pnt* to); + +gp_Ax1 * hs_gp_Ax1_TranslatedRelative(gp_Ax1* ax1, gp_Pnt* from, gp_Pnt* to); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_AX1_H diff --git a/cpp/hs_gp_Ax2.h b/cpp/hs_gp_Ax2.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Ax2.h @@ -0,0 +1,76 @@ +#ifndef HS_GP_AX2_H +#define HS_GP_AX2_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Ax2 * hs_new_gp_Ax2(gp_Pnt * origin, gp_Dir * north, gp_Dir * vX); + +void hs_delete_gp_Ax2(gp_Ax2* ax2); + +gp_Ax2 * hs_new_gp_Ax2_autoX(gp_Pnt * origin, gp_Dir * north); + +gp_Dir * hs_gp_Ax2_Direction(gp_Ax2* ax2); + +gp_Pnt * hs_gp_Ax2_Location(gp_Ax2* ax2); + +gp_Dir * hs_gp_Ax2_XDirection(gp_Ax2* ax2); + +gp_Dir * hs_gp_Ax2_YDirection(gp_Ax2* ax2); + +gp_Ax1 * hs_gp_Ax2_Axis(gp_Ax2* ax2); + +void hs_gp_Ax2_SetDirection(gp_Ax2* ax2, gp_Dir* direction); + +void hs_gp_Ax2_SetLocation(gp_Ax2* ax2, gp_Pnt* origin); + +void hs_gp_Ax2_SetXDirection(gp_Ax2* ax2, gp_Dir* direction); + +void hs_gp_Ax2_SetYDirection(gp_Ax2* ax2, gp_Dir* direction); + +void hs_gp_Ax2_SetAxis(gp_Ax2* ax2, gp_Ax1* ax1); + +bool hs_gp_Ax2_IsCoplanar(gp_Ax2* axis1, gp_Ax2* axis2, double linearTolerance, double angularTolerance); + +bool hs_gp_Ax2_IsCoplanarWithAx1(gp_Ax2* axis1, gp_Ax1* axis2, double linearTolerance, double angularTolerance); + +void hs_gp_Ax2_Mirror(gp_Ax2* ax2, gp_Ax2* mirror); + +gp_Ax2 * hs_gp_Ax2_Mirrored(gp_Ax2* ax2, gp_Ax2* mirror); + +void hs_gp_Ax2_MirrorAboutPnt(gp_Ax2* ax2, gp_Pnt* mirror); + +gp_Ax2 * hs_gp_Ax2_MirroredAboutPnt(gp_Ax2* ax2, gp_Pnt* mirror); + +void hs_gp_Ax2_MirrorAboutAx1(gp_Ax2* ax2, gp_Ax1* mirror); + +gp_Ax2 * hs_gp_Ax2_MirroredAboutAx1(gp_Ax2* ax2, gp_Ax1* mirror); + +void hs_gp_Ax2_Rotate(gp_Ax2* ax2, gp_Ax1* axisOfRotation, double angle); + +gp_Ax2 * hs_gp_Ax2_Rotated(gp_Ax2* ax2, gp_Ax1* axisOfRotation, double angle); + +void hs_gp_Ax2_Scale(gp_Ax2* ax2, gp_Pnt* origin, double amount); + +gp_Ax2 * hs_gp_Ax2_Scaled(gp_Ax2* ax2, gp_Pnt* origin, double amount); + +void hs_gp_Ax2_Transform(gp_Ax2* ax2, gp_Trsf* trsf); + +gp_Ax2 * hs_gp_Ax2_Transformed(gp_Ax2* ax2, gp_Trsf* trsf); + +void hs_gp_Ax2_Translate(gp_Ax2* ax2, gp_Vec* vec); + +gp_Ax2 * hs_gp_Ax2_Translated(gp_Ax2* ax2, gp_Vec* vec); + +void hs_gp_Ax2_TranslateRelative(gp_Ax2* ax2, gp_Pnt* from, gp_Pnt* to); + +gp_Ax2 * hs_gp_Ax2_TranslatedRelative(gp_Ax2* ax2, gp_Pnt* from, gp_Pnt* to); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_AX2_H diff --git a/cpp/hs_gp_Ax2d.h b/cpp/hs_gp_Ax2d.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Ax2d.h @@ -0,0 +1,68 @@ +#ifndef HS_GP_AX2D_H +#define HS_GP_AX2D_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Ax2d* hs_new_gp_Ax2d(gp_Pnt2d* location, gp_Dir2d* direction); + +void hs_delete_gp_Ax2d(gp_Ax2d* ax2d); + +gp_Dir2d * hs_gp_Ax2d_Direction(gp_Ax2d* ax2d); + +gp_Pnt2d * hs_gp_Ax2d_Location(gp_Ax2d* ax2d); + +void hs_gp_Ax2d_SetDirection(gp_Ax2d* ax2d, gp_Dir2d* direction); + +void hs_gp_Ax2d_SetLocation(gp_Ax2d* ax2d, gp_Pnt2d* origin); + +bool hs_gp_Ax2d_IsCoaxial(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance, double linearTolerance); + +bool hs_gp_Ax2d_IsNormal(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance); + +bool hs_gp_Ax2d_IsOpposite(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance); + +bool hs_gp_Ax2d_IsParallel(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance); + +double hs_gp_Ax2d_Angle(gp_Ax2d* axis1, gp_Ax2d* axis2); + +void hs_gp_Ax2d_Reverse(gp_Ax2d* ax2d); + +gp_Ax2d * hs_gp_Ax2d_Reversed(gp_Ax2d* ax2d); + +void hs_gp_Ax2d_Mirror(gp_Ax2d* ax2d, gp_Ax2d* mirror); + +gp_Ax2d * hs_gp_Ax2d_Mirrored(gp_Ax2d* ax2d, gp_Ax2d* mirror); + +void hs_gp_Ax2d_MirrorAboutPnt2d(gp_Ax2d* ax2d, gp_Pnt2d* mirror); + +gp_Ax2d * hs_gp_Ax2d_MirroredAboutPnt2d(gp_Ax2d* ax2d, gp_Pnt2d* mirror); + +void hs_gp_Ax2d_Rotate(gp_Ax2d* ax2d, gp_Pnt2d* axisOfRotation, double angle); + +gp_Ax2d * hs_gp_Ax2d_Rotated(gp_Ax2d* ax2d, gp_Pnt2d* axisOfRotation, double angle); + +void hs_gp_Ax2d_Scale(gp_Ax2d* ax2d, gp_Pnt2d* origin, double amount); + +gp_Ax2d * hs_gp_Ax2d_Scaled(gp_Ax2d* ax2d, gp_Pnt2d* origin, double amount); + +void hs_gp_Ax2d_Transform(gp_Ax2d* ax2d, gp_Trsf2d* trsf); + +gp_Ax2d * hs_gp_Ax2d_Transformed(gp_Ax2d* ax2d, gp_Trsf2d* trsf); + +void hs_gp_Ax2d_Translate(gp_Ax2d* ax2d, gp_Vec2d* vec); + +gp_Ax2d * hs_gp_Ax2d_Translated(gp_Ax2d* ax2d, gp_Vec2d* vec); + +void hs_gp_Ax2d_TranslateRelative(gp_Ax2d* ax2d, gp_Pnt2d* from, gp_Pnt2d* to); + +gp_Ax2d * hs_gp_Ax2d_TranslatedRelative(gp_Ax2d* ax2d, gp_Pnt2d* from, gp_Pnt2d* to); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_AX2D_H diff --git a/cpp/hs_gp_Ax3.h b/cpp/hs_gp_Ax3.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Ax3.h @@ -0,0 +1,89 @@ +#ifndef HS_GP_AX3_H +#define HS_GP_AX3_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Ax3 * hs_new_gp_Ax3(); + +gp_Ax3 * hs_new_gp_Ax3_fromAx2(gp_Ax2 * ax); + +gp_Ax3 * hs_new_gp_Ax3_fromPntDirAndDir(gp_Pnt * pnt, gp_Dir *n, gp_Dir *v); + +gp_Ax3 * hs_new_gp_Ax3_fromPntAndDir(gp_Pnt * pnt, gp_Dir *n); + +void hs_delete_gp_Ax3(gp_Ax3* axis); + +void hs_gp_Ax3_xReverse(gp_Ax3 * axis); + +void hs_gp_Ax3_yReverse(gp_Ax3 * axis); + +void hs_gp_Ax3_zReverse(gp_Ax3 * axis); + +void hs_gp_Ax3_setAxis(gp_Ax3 * axis, gp_Ax1 * mainAxis); + +void hs_gp_Ax3_setDirection(gp_Ax3 * axis, gp_Dir * dir); + +void hs_gp_Ax3_setLocation(gp_Ax3 * axis, gp_Pnt * loc); + +void hs_gp_Ax3_setXDirection(gp_Ax3 * axis, gp_Dir * dir); + +void hs_gp_Ax3_setYDirection(gp_Ax3 * axis, gp_Dir * dir); + +double hs_gp_Ax3_angle(gp_Ax3 *axis, gp_Ax3 *other); + +gp_Ax1 * hs_gp_Ax3_axis(gp_Ax3 *axis); + +gp_Ax2 * hs_gp_Ax3_ax2(gp_Ax3 * axis); + +gp_Dir * hs_gp_Ax3_direction(gp_Ax3 * axis); + +gp_Pnt * hs_gp_Ax3_location(gp_Ax3 *axis); + +gp_Dir * hs_gp_Ax3_xDirection(gp_Ax3 * axis); + +gp_Dir * hs_gp_Ax3_yDirection(gp_Ax3 * axis); + +bool hs_gp_Ax3_direct(gp_Ax3 * axis); + +bool hs_gp_Ax3_isCoplanar(gp_Ax3 * axis, gp_Ax3 * other, double linearTolerance, double angularTolerance); + +bool hs_gp_Ax3_isCoplanarAx1(gp_Ax3 * axis, gp_Ax1 * other, double linearTolerance, double angularTolerance); + +void hs_gp_Ax3_mirror(gp_Ax3 * axis, gp_Ax1 *mirrorAxis); + +gp_Ax3* hs_gp_Ax3_mirrored(gp_Ax3 * axis, gp_Ax1 * mirrorAxis); + +void hs_gp_Ax3_mirror_Ax2(gp_Ax3 * axis, gp_Ax2 *mirrorAxis); + +gp_Ax3* hs_gp_Ax3_mirrored_Ax2(gp_Ax3 * axis, gp_Ax2 * mirrorAxis); + +void hs_gp_Ax3_rotate(gp_Ax3 * axis, gp_Ax1 *rotAxis, double angle); + +gp_Ax3* hs_gp_Ax3_rotated(gp_Ax3 * axis, gp_Ax1 * rotAxis, double angle); + +void hs_gp_Ax3_scale(gp_Ax3 * axis, gp_Pnt *center, double factor); + +gp_Ax3* hs_gp_Ax3_scaled(gp_Ax3 * axis, gp_Pnt * center, double factor); + +void hs_gp_Ax3_transform(gp_Ax3 * axis, gp_Trsf *trsf); + +gp_Ax3* hs_gp_Ax3_transformed(gp_Ax3 * axis, gp_Trsf * trsf); + +void hs_gp_Ax3_translate(gp_Ax3 * axis, gp_Vec *vec); + +gp_Ax3* hs_gp_Ax3_translated(gp_Ax3 * axis, gp_Vec * vec); + +void hs_gp_Ax3_translateRelative(gp_Ax3 * axis, gp_Pnt *from, gp_Pnt *to); + +gp_Ax3* hs_gp_Ax3_translatedRelative(gp_Ax3 * axis, gp_Pnt * from, gp_Pnt *to); + + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_AX3_H diff --git a/cpp/hs_gp_Dir.h b/cpp/hs_gp_Dir.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Dir.h @@ -0,0 +1,78 @@ +#ifndef HS_GP_DIR_H +#define HS_GP_DIR_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Dir * hs_new_gp_Dir(double x, double y, double z); + +void hs_delete_gp_Dir(gp_Dir* dir); + +double hs_gp_Dir_X(gp_Dir * pnt); + +double hs_gp_Dir_Y(gp_Dir * pnt); + +double hs_gp_Dir_Z(gp_Dir * pnt); + +void hs_gp_Dir_SetX(gp_Dir * pnt, double x); + +void hs_gp_Dir_SetY(gp_Dir * pnt, double y); + +void hs_gp_Dir_SetZ(gp_Dir * pnt, double z); + +bool hs_gp_Dir_IsEqual(gp_Dir * a, gp_Dir * b, double angularTolerance); + +bool hs_gp_Dir_IsNormal(gp_Dir * a, gp_Dir * b, double angularTolerance); + +bool hs_gp_Dir_IsOpposite(gp_Dir * a, gp_Dir * b, double angularTolerance); + +bool hs_gp_Dir_IsParallel(gp_Dir * a, gp_Dir * b, double angularTolerance); + +double hs_gp_Dir_Angle(gp_Dir * a, gp_Dir * b); + +double hs_gp_Dir_AngleWithRef(gp_Dir * a, gp_Dir * b, gp_Dir* theVRef); + +void hs_gp_Dir_Cross(gp_Dir * a, gp_Dir * b); + +gp_Dir * hs_gp_Dir_Crossed(gp_Dir * a, gp_Dir * b); + +void hs_gp_Dir_CrossCross(gp_Dir * a, gp_Dir * b, gp_Dir * c); + +gp_Dir * hs_gp_Dir_CrossCrossed(gp_Dir * a, gp_Dir * b, gp_Dir * c); + +double hs_gp_Dir_Dot(gp_Dir * a, gp_Dir * b); + +double hs_gp_Dir_DotCross(gp_Dir * a, gp_Dir * b, gp_Dir * c); + +void hs_gp_Dir_Reverse(gp_Dir* ax1); + +gp_Dir * hs_gp_Dir_Reversed(gp_Dir* ax1); + +void hs_gp_Dir_Mirror(gp_Dir * theDir, gp_Dir * theAxis); + +gp_Dir * hs_gp_Dir_Mirrored(gp_Dir * theDir, gp_Dir * theAxis); + +void hs_gp_Dir_MirrorAboutAx1(gp_Dir * theDir, gp_Ax1 * theAxis); + +gp_Dir * hs_gp_Dir_MirroredAboutAx1(gp_Dir * theDir, gp_Ax1 * theAxis); + +void hs_gp_Dir_MirrorAboutAx2(gp_Dir * theDir, gp_Ax2 * theAxis); + +gp_Dir * hs_gp_Dir_MirroredAboutAx2(gp_Dir * theDir, gp_Ax2 * theAxis); + +void hs_gp_Dir_Rotate(gp_Dir * theDir, gp_Ax1 * theAxis, double amount); + +gp_Dir * hs_gp_Dir_Rotated(gp_Dir * theDir, gp_Ax1 * theAxis, double amount); + +void hs_gp_Dir_Transform(gp_Dir * theDir, gp_Trsf * trsf); + +gp_Dir * hs_gp_Dir_Transformed(gp_Dir * theDir, gp_Trsf * trsf); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_DIR_H diff --git a/cpp/hs_gp_Dir2d.h b/cpp/hs_gp_Dir2d.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Dir2d.h @@ -0,0 +1,60 @@ +#ifndef HS_GP_DIR2D_H +#define HS_GP_DIR2D_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Dir2d * hs_new_gp_Dir2d(double x, double y); + +void hs_delete_gp_Dir2d(gp_Dir2d* dir); + +double hs_gp_Dir2d_X(gp_Dir2d * pnt); + +double hs_gp_Dir2d_Y(gp_Dir2d * pnt); + +void hs_gp_Dir2d_SetX(gp_Dir2d * pnt, double x); + +void hs_gp_Dir2d_SetY(gp_Dir2d * pnt, double y); + +bool hs_gp_Dir2d_IsEqual(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance); + +bool hs_gp_Dir2d_IsNormal(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance); + +bool hs_gp_Dir2d_IsOpposite(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance); + +bool hs_gp_Dir2d_IsParallel(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance); + +double hs_gp_Dir2d_Angle(gp_Dir2d * a, gp_Dir2d * b); + +double hs_gp_Dir2d_Crossed(gp_Dir2d * a, gp_Dir2d * b); + +double hs_gp_Dir2d_Dot(gp_Dir2d * a, gp_Dir2d * b); + +void hs_gp_Dir2d_Reverse(gp_Dir2d* ax1); + +gp_Dir2d * hs_gp_Dir2d_Reversed(gp_Dir2d* ax1); + +void hs_gp_Dir2d_Mirror(gp_Dir2d * theDir2d, gp_Dir2d * theAxis); + +gp_Dir2d * hs_gp_Dir2d_Mirrored(gp_Dir2d * theDir2d, gp_Dir2d * theAxis); + +void hs_gp_Dir2d_MirrorAboutAx2d(gp_Dir2d * theDir2d, gp_Ax2d * theAxis); + +gp_Dir2d * hs_gp_Dir2d_MirroredAboutAx2d(gp_Dir2d * theDir2d, gp_Ax2d * theAxis); + +void hs_gp_Dir2d_Rotate(gp_Dir2d * theDir2d, double amount); + +gp_Dir2d * hs_gp_Dir2d_Rotated(gp_Dir2d * theDir2d, double amount); + +void hs_gp_Dir2d_Transform(gp_Dir2d * theDir2d, gp_Trsf2d * trsf); + +gp_Dir2d * hs_gp_Dir2d_Transformed(gp_Dir2d * theDir2d, gp_Trsf2d * trsf); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_DIR_H diff --git a/cpp/hs_gp_GTrsf.h b/cpp/hs_gp_GTrsf.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_GTrsf.h @@ -0,0 +1,23 @@ +#ifndef HS_GP_GTRSF_H +#define HS_GP_GTRSF_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +gp_GTrsf * hs_new_gp_GTrsf(); + +void hs_delete_gp_GTrsf(gp_GTrsf * t); + +void hs_gp_GTrsf_setValue(gp_GTrsf * trsf, int row, int col, double value); + +void hs_gp_GTrsf_setForm(gp_GTrsf * trsf); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_GTRSF_H diff --git a/cpp/hs_gp_Pnt.h b/cpp/hs_gp_Pnt.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Pnt.h @@ -0,0 +1,70 @@ +#ifndef HS_GP_PNT_H +#define HS_GP_PNT_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Pnt * hs_new_gp_Pnt(double x, double y, double z); + +void hs_delete_gp_Pnt(gp_Pnt* pnt); + +double hs_gp_Pnt_X(gp_Pnt * pnt); + +double hs_gp_Pnt_Y(gp_Pnt * pnt); + +double hs_gp_Pnt_Z(gp_Pnt * pnt); + +void hs_gp_Pnt_SetX(gp_Pnt * pnt, double x); + +void hs_gp_Pnt_SetY(gp_Pnt * pnt, double y); + +void hs_gp_Pnt_SetZ(gp_Pnt * pnt, double z); + +double hs_gp_Pnt_Distance(gp_Pnt * a, gp_Pnt * b ); + +double hs_gp_Pnt_SquareDistance(gp_Pnt * a, gp_Pnt * b ); + +void hs_gp_Pnt_BaryCenter(gp_Pnt * a, double alpha, gp_Pnt * b, double beta); + +bool hs_gp_Pnt_IsEqual(gp_Pnt * a, gp_Pnt * b, double tolerance); + +void hs_gp_Pnt_Mirror(gp_Pnt * thePnt, gp_Pnt * theAxis); + +gp_Pnt * hs_gp_Pnt_Mirrored(gp_Pnt * thePnt, gp_Pnt * theAxis); + +void hs_gp_Pnt_MirrorAboutAx1(gp_Pnt * thePnt, gp_Ax1 * theAxis); + +gp_Pnt * hs_gp_Pnt_MirroredAboutAx1(gp_Pnt * thePnt, gp_Ax1 * theAxis); + +void hs_gp_Pnt_MirrorAboutAx2(gp_Pnt * thePnt, gp_Ax2 * theAxis); + +gp_Pnt * hs_gp_Pnt_MirroredAboutAx2(gp_Pnt * thePnt, gp_Ax2 * theAxis); + +void hs_gp_Pnt_Rotate(gp_Pnt * thePnt, gp_Ax1 * theAxis, double amount); + +gp_Pnt * hs_gp_Pnt_Rotated(gp_Pnt * thePnt, gp_Ax1 * theAxis, double amount); + +void hs_gp_Pnt_Scale(gp_Pnt * thePnt, gp_Pnt * origin, double amount); + +gp_Pnt * hs_gp_Pnt_Scaled(gp_Pnt * thePnt, gp_Pnt * origin, double amount); + +void hs_gp_Pnt_Transform(gp_Pnt * thePnt, gp_Trsf * trsf); + +gp_Pnt * hs_gp_Pnt_Transformed(gp_Pnt * thePnt, gp_Trsf * trsf); + +void hs_gp_Pnt_Translate(gp_Pnt * thePnt, gp_Vec * vec); + +gp_Pnt * hs_gp_Pnt_Translated(gp_Pnt * thePnt, gp_Vec * vec); + +void hs_gp_Pnt_TranslateRelative(gp_Pnt * thePnt, gp_Pnt * from, gp_Pnt * to); + +gp_Pnt * hs_gp_Pnt_TranslatedRelative(gp_Pnt * thePnt, gp_Pnt * from, gp_Pnt * to); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_PNT_H diff --git a/cpp/hs_gp_Pnt2d.h b/cpp/hs_gp_Pnt2d.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Pnt2d.h @@ -0,0 +1,60 @@ +#ifndef HS_GP_PNT2D_H +#define HS_GP_PNT2D_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Pnt2d * hs_new_gp_Pnt2d(double x, double y); + +void hs_delete_gp_Pnt2d(gp_Pnt2d* pnt); + +double hs_gp_Pnt2d_X(gp_Pnt2d * pnt); + +double hs_gp_Pnt2d_Y(gp_Pnt2d * pnt); + +void hs_gp_Pnt2d_SetX(gp_Pnt2d * pnt, double x); + +void hs_gp_Pnt2d_SetY(gp_Pnt2d * pnt, double y); + +double hs_gp_Pnt2d_Distance(gp_Pnt2d * a, gp_Pnt2d * b ); + +double hs_gp_Pnt2d_SquareDistance(gp_Pnt2d * a, gp_Pnt2d * b ); + +bool hs_gp_Pnt2d_IsEqual(gp_Pnt2d * a, gp_Pnt2d * b, double tolerance); + +void hs_gp_Pnt2d_Mirror(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis); + +gp_Pnt2d * hs_gp_Pnt2d_Mirrored(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis); + +void hs_gp_Pnt2d_MirrorAboutAx2d(gp_Pnt2d * thePnt2d, gp_Ax2d * theAxis); + +gp_Pnt2d * hs_gp_Pnt2d_MirroredAboutAx2d(gp_Pnt2d * thePnt2d, gp_Ax2d * theAxis); + +void hs_gp_Pnt2d_Rotate(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis, double amount); + +gp_Pnt2d * hs_gp_Pnt2d_Rotated(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis, double amount); + +void hs_gp_Pnt2d_Scale(gp_Pnt2d * thePnt2d, gp_Pnt2d * origin, double amount); + +gp_Pnt2d * hs_gp_Pnt2d_Scaled(gp_Pnt2d * thePnt2d, gp_Pnt2d * origin, double amount); + +void hs_gp_Pnt2d_Transform(gp_Pnt2d * thePnt2d, gp_Trsf2d * trsf); + +gp_Pnt2d * hs_gp_Pnt2d_Transformed(gp_Pnt2d * thePnt2d, gp_Trsf2d * trsf); + +void hs_gp_Pnt2d_Translate(gp_Pnt2d * thePnt2d, gp_Vec2d * vec); + +gp_Pnt2d * hs_gp_Pnt2d_Translated(gp_Pnt2d * thePnt2d, gp_Vec2d * vec); + +void hs_gp_Pnt2d_TranslateRelative(gp_Pnt2d * thePnt2d, gp_Pnt2d * from, gp_Pnt2d * to); + +gp_Pnt2d * hs_gp_Pnt2d_TranslatedRelative(gp_Pnt2d * thePnt2d, gp_Pnt2d * from, gp_Pnt2d * to); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_DIR_H diff --git a/cpp/hs_gp_Trsf.h b/cpp/hs_gp_Trsf.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Trsf.h @@ -0,0 +1,62 @@ +#ifndef HS_GP_TRSF_H +#define HS_GP_TRSF_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +gp_Trsf * hs_new_gp_Trsf(); + +void hs_delete_gp_Trsf(gp_Trsf * t); + +gp_Trsf * hs_new_gp_Trsf_fromTrsf2d(gp_Trsf2d * t); + +void hs_gp_Trsf_SetMirrorAboutPnt(gp_Trsf * trsf, gp_Pnt * pnt); + +void hs_gp_Trsf_SetMirrorAboutAx1(gp_Trsf * trsf, gp_Ax1 * ax); + +void hs_gp_Trsf_SetMirrorAboutAx2(gp_Trsf * trsf, gp_Ax2 * ax); + +void hs_gp_Trsf_SetRotationAboutAxisAngle(gp_Trsf * trsf, gp_Ax1 * ax, double angle); + +void hs_gp_Trsf_SetScale(gp_Trsf * trsf, gp_Pnt * origin, double factor); + +void hs_gp_Trsf_SetTranslation(gp_Trsf * trsf, gp_Vec * trans); + +void hs_gp_Trsf_SetTranslationPart(gp_Trsf * trsf, gp_Vec * trans); + +void hs_gp_Trsf_SetScaleFactor(gp_Trsf * trsf, double s); + +void hs_gp_Trsf_SetValues(gp_Trsf * trsf, + double a11, double a12, double a13, double a14, + double a21, double a22, double a23, double a24, + double a31, double a32, double a33, double a34); + +bool hs_gp_Trsf_IsNegative(gp_Trsf * trsf); + +double hs_gp_Trsf_ScaleFactor(gp_Trsf * trsf); + +double hs_gp_Trsf_Value(gp_Trsf* trsf, int row, int col); + +void hs_gp_Trsf_Invert(gp_Trsf* trsf); + +gp_Trsf * hs_gp_Trsf_Inverted(gp_Trsf* trsf); + +void hs_gp_Trsf_Multiply(gp_Trsf * trsf, gp_Trsf* b); + +gp_Trsf * hs_gp_Trsf_Multiplied(gp_Trsf* a, gp_Trsf* b); + +void hs_gp_Trsf_PreMultiply(gp_Trsf * trsf, gp_Trsf* b); + +void hs_gp_Trsf_Power(gp_Trsf * trsf, int b); + +gp_Trsf * hs_gp_Trsf_Powered(gp_Trsf* a, int b); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_TRSF_H diff --git a/cpp/hs_gp_Trsf2d.h b/cpp/hs_gp_Trsf2d.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Trsf2d.h @@ -0,0 +1,64 @@ +#ifndef HS_GP_TRSF2D_H +#define HS_GP_TRSF2D_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Trsf2d * hs_new_gp_Trsf2d(); + +void hs_delete_gp_Trsf2d(gp_Trsf2d * t); + +gp_Trsf2d * hs_new_gp_Trsf2d_fromTrsf(gp_Trsf * t); + +void hs_gp_Trsf2d_SetMirrorAboutPnt2d(gp_Trsf2d * trsf, gp_Pnt2d * pnt); + +void hs_gp_Trsf2d_SetMirrorAboutAx2d(gp_Trsf2d * trsf, gp_Ax2d * ax); + +void hs_gp_Trsf2d_SetRotation(gp_Trsf2d * trsf, gp_Pnt2d * ax, double angle); + +void hs_gp_Trsf2d_SetScale(gp_Trsf2d * trsf, gp_Pnt2d * origin, double factor); + +void hs_gp_Trsf2d_SetTransformation(gp_Trsf2d * trsf, gp_Ax2d * to); + +void hs_gp_Trsf2d_SetTransformationRelative(gp_Trsf2d * trsf, gp_Ax2d * from, gp_Ax2d * to); + +void hs_gp_Trsf2d_SetTranslation(gp_Trsf2d * trsf, gp_Vec2d * trans); + +void hs_gp_Trsf2d_SetTranslationRelative(gp_Trsf2d * trsf, gp_Pnt2d * from, gp_Pnt2d * to); + +void hs_gp_Trsf2d_SetTranslationPart(gp_Trsf2d * trsf, gp_Vec2d * trans); + +void hs_gp_Trsf2d_SetScaleFactor(gp_Trsf2d * trsf, double s); + +void hs_gp_Trsf2d_SetValues(gp_Trsf2d * trsf, + double a11, double a12, double a13, + double a21, double a22, double a23); + +bool hs_gp_Trsf2d_IsNegative(gp_Trsf2d * trsf); + +double hs_gp_Trsf2d_ScaleFactor(gp_Trsf2d * trsf); + +double hs_gp_Trsf2d_Value(gp_Trsf2d* trsf, int row, int col); + +void hs_gp_Trsf2d_Invert(gp_Trsf2d* trsf); + +gp_Trsf2d * hs_gp_Trsf2d_Inverted(gp_Trsf2d* trsf); + +void hs_gp_Trsf2d_Multiply(gp_Trsf2d * trsf, gp_Trsf2d* b); + +gp_Trsf2d * hs_gp_Trsf2d_Multiplied(gp_Trsf2d* a, gp_Trsf2d* b); + +void hs_gp_Trsf2d_PreMultiply(gp_Trsf2d * trsf, gp_Trsf2d* b); + +void hs_gp_Trsf2d_Power(gp_Trsf2d * trsf, int b); + +gp_Trsf2d * hs_gp_Trsf2d_Powered(gp_Trsf2d* a, int b); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_TRSF2D_H diff --git a/cpp/hs_gp_Vec.h b/cpp/hs_gp_Vec.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Vec.h @@ -0,0 +1,111 @@ +#ifndef HS_GP_VEC_H +#define HS_GP_VEC_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Vec * hs_new_gp_Vec(double x, double y, double z); + +void hs_delete_gp_Vec(gp_Vec* vec); + +double hs_gp_Vec_X(gp_Vec * vec); + +double hs_gp_Vec_Y(gp_Vec * vec); + +double hs_gp_Vec_Z(gp_Vec * vec); + +void hs_gp_Vec_SetX(gp_Vec * vec, double x); + +void hs_gp_Vec_SetY(gp_Vec * vec, double y); + +void hs_gp_Vec_SetZ(gp_Vec * vec, double z); + +bool hs_gp_Vec_IsEqual(gp_Vec * a, gp_Vec * b, double linearTolerance, double angularTolerance); + +bool hs_gp_Vec_IsNormal(gp_Vec * a, gp_Vec * b, double angularTolerance); + +bool hs_gp_Vec_IsOpposite(gp_Vec * a, gp_Vec * b, double angularTolerance); + +bool hs_gp_Vec_IsParallel(gp_Vec * a, gp_Vec * b, double angularTolerance); + +double hs_gp_Vec_Angle(gp_Vec * a, gp_Vec * b); + +double hs_gp_Vec_AngleWithRef(gp_Vec * a, gp_Vec * b, gp_Vec* theVRef); + +double hs_gp_Vec_Magnitude(gp_Vec * a); + +double hs_gp_Vec_SquareMagnitude(gp_Vec * a); + +void hs_gp_Vec_Add(gp_Vec * a, gp_Vec * b); + +gp_Vec * hs_gp_Vec_Added(gp_Vec * a, gp_Vec * b); + +void hs_gp_Vec_Subtract(gp_Vec * a, gp_Vec * b); + +gp_Vec * hs_gp_Vec_Subtracted(gp_Vec * a, gp_Vec * b); + +void hs_gp_Vec_Multiply(gp_Vec * a, double b); + +gp_Vec * hs_gp_Vec_Multiplied(gp_Vec * a, double b); + + +void hs_gp_Vec_Divide(gp_Vec * a, double b); + +gp_Vec * hs_gp_Vec_Divided(gp_Vec * a, double b); + +void hs_gp_Vec_Cross(gp_Vec * a, gp_Vec * b); + +gp_Vec * hs_gp_Vec_Crossed(gp_Vec * a, gp_Vec * b); + +void hs_gp_Vec_CrossCross(gp_Vec * a, gp_Vec * b, gp_Vec * c); + +double hs_gp_Vec_CrossMagnitude(gp_Vec * a, gp_Vec * b); + +double hs_gp_Vec_CrossSquareMagnitude(gp_Vec * a, gp_Vec * b); + +gp_Vec * hs_gp_Vec_CrossCrossed(gp_Vec * a, gp_Vec * b, gp_Vec * c); + +double hs_gp_Vec_Dot(gp_Vec * a, gp_Vec * b); + +double hs_gp_Vec_DotCross(gp_Vec * a, gp_Vec * b, gp_Vec * c); + +void hs_gp_Vec_Normalize(gp_Vec * a); + +gp_Vec * hs_gp_Vec_Normalized(gp_Vec * a); + +void hs_gp_Vec_Reverse(gp_Vec* a); + +gp_Vec * hs_gp_Vec_Reversed(gp_Vec* a); + +void hs_gp_Vec_Mirror(gp_Vec * theVec, gp_Vec * theAxis); + +gp_Vec * hs_gp_Vec_Mirrored(gp_Vec * theVec, gp_Vec * theAxis); + +void hs_gp_Vec_MirrorAboutAx1(gp_Vec * theVec, gp_Ax1 * theAxis); + +gp_Vec * hs_gp_Vec_MirroredAboutAx1(gp_Vec * theVec, gp_Ax1 * theAxis); + +void hs_gp_Vec_MirrorAboutAx2(gp_Vec * theVec, gp_Ax2 * theAxis); + +gp_Vec * hs_gp_Vec_MirroredAboutAx2(gp_Vec * theVec, gp_Ax2 * theAxis); + +void hs_gp_Vec_Rotate(gp_Vec * theVec, gp_Ax1 * theAxis, double amount); + +gp_Vec * hs_gp_Vec_Rotated(gp_Vec * theVec, gp_Ax1 * theAxis, double amount); + +void hs_gp_Vec_Scale(gp_Vec * theVec, double s); + +gp_Vec * hs_gp_Vec_Scaled(gp_Vec * theVec, double s); + +void hs_gp_Vec_Transform(gp_Vec * theVec, gp_Trsf * trsf); + +gp_Vec * hs_gp_Vec_Transformed(gp_Vec * theVec, gp_Trsf * trsf); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_VEC_H diff --git a/cpp/hs_gp_Vec2d.h b/cpp/hs_gp_Vec2d.h new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Vec2d.h @@ -0,0 +1,93 @@ +#ifndef HS_GP_VEC2D_H +#define HS_GP_VEC2D_H + +#include "hs_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +gp_Vec2d * hs_new_gp_Vec2d(double x, double y); + +void hs_delete_gp_Vec2d(gp_Vec2d* vec); + +double hs_gp_Vec2d_X(gp_Vec2d * vec); + +double hs_gp_Vec2d_Y(gp_Vec2d * vec); + +void hs_gp_Vec2d_SetX(gp_Vec2d * vec, double x); + +void hs_gp_Vec2d_SetY(gp_Vec2d * vec, double y); + +bool hs_gp_Vec2d_IsEqual(gp_Vec2d * a, gp_Vec2d * b, double linearTolerance, double angularTolerance); + +bool hs_gp_Vec2d_IsNormal(gp_Vec2d * a, gp_Vec2d * b, double angularTolerance); + +bool hs_gp_Vec2d_IsOpposite(gp_Vec2d * a, gp_Vec2d * b, double angularTolerance); + +bool hs_gp_Vec2d_IsParallel(gp_Vec2d * a, gp_Vec2d * b, double angularTolerance); + +double hs_gp_Vec2d_Angle(gp_Vec2d * a, gp_Vec2d * b); + +double hs_gp_Vec2d_Magnitude(gp_Vec2d * a); + +double hs_gp_Vec2d_SquareMagnitude(gp_Vec2d * a); + +void hs_gp_Vec2d_Add(gp_Vec2d * a, gp_Vec2d * b); + +gp_Vec2d * hs_gp_Vec2d_Added(gp_Vec2d * a, gp_Vec2d * b); + +void hs_gp_Vec2d_Subtract(gp_Vec2d * a, gp_Vec2d * b); + +gp_Vec2d * hs_gp_Vec2d_Subtracted(gp_Vec2d * a, gp_Vec2d * b); + +void hs_gp_Vec2d_Multiply(gp_Vec2d * a, double b); + +gp_Vec2d * hs_gp_Vec2d_Multiplied(gp_Vec2d * a, double b); + + +void hs_gp_Vec2d_Divide(gp_Vec2d * a, double b); + +gp_Vec2d * hs_gp_Vec2d_Divided(gp_Vec2d * a, double b); + +double hs_gp_Vec2d_Crossed(gp_Vec2d * a, gp_Vec2d * b); + +double hs_gp_Vec2d_CrossMagnitude(gp_Vec2d * a, gp_Vec2d * b); + +double hs_gp_Vec2d_CrossSquareMagnitude(gp_Vec2d * a, gp_Vec2d * b); + +double hs_gp_Vec2d_Dot(gp_Vec2d * a, gp_Vec2d * b); + +void hs_gp_Vec2d_Normalize(gp_Vec2d * a); + +gp_Vec2d * hs_gp_Vec2d_Normalized(gp_Vec2d * a); + +void hs_gp_Vec2d_Reverse(gp_Vec2d* a); + +gp_Vec2d * hs_gp_Vec2d_Reversed(gp_Vec2d* a); + +void hs_gp_Vec2d_Mirror(gp_Vec2d * theVec2d, gp_Vec2d * theAxis); + +gp_Vec2d * hs_gp_Vec2d_Mirrored(gp_Vec2d * theVec2d, gp_Vec2d * theAxis); + +void hs_gp_Vec2d_MirrorAboutAx2d(gp_Vec2d * theVec2d, gp_Ax2d * theAxis); + +gp_Vec2d * hs_gp_Vec2d_MirroredAboutAx2d(gp_Vec2d * theVec2d, gp_Ax2d * theAxis); + +void hs_gp_Vec2d_Rotate(gp_Vec2d * theVec2d, double amount); + +gp_Vec2d * hs_gp_Vec2d_Rotated(gp_Vec2d * theVec2d, double amount); + +void hs_gp_Vec2d_Scale(gp_Vec2d * theVec2d, double s); + +gp_Vec2d * hs_gp_Vec2d_Scaled(gp_Vec2d * theVec2d, double s); + +void hs_gp_Vec2d_Transform(gp_Vec2d * theVec2d, gp_Trsf2d * trsf); + +gp_Vec2d * hs_gp_Vec2d_Transformed(gp_Vec2d * theVec2d, gp_Trsf2d * trsf); + +#ifdef __cplusplus +} +#endif + +#endif // HS_GP_VEC2D_H diff --git a/cpp/hs_types.h b/cpp/hs_types.h new file mode 100644 --- /dev/null +++ b/cpp/hs_types.h @@ -0,0 +1,72 @@ +#ifndef HS_TYPES_H +#define HS_TYPES_H + +#ifndef __cplusplus + +typedef void TopoDS_Shape; +typedef void TopoDS_Vertex; +typedef void TopoDS_Edge; +typedef void TopoDS_Face; +typedef void TopoDS_Wire; +typedef void TopoDS_Compound; +typedef void TopoDS_CompSolid; +typedef void TopoDS_Solid; +typedef void TopoDS_Shell; +typedef void TopLoc_Location; +typedef int TopAbs_Orientation; +typedef int TopAbs_ShapeEnum; +typedef void gp_Pnt; +typedef void gp_Ax1; +typedef void gp_Ax2; +typedef void gp_Ax3; +typedef void gp_Ax2d; +typedef void gp_Pnt2d; +typedef void gp_Dir; +typedef void gp_Dir2d; +typedef void gp_Vec; +typedef void gp_Vec2d; +typedef void gp_Trsf; +typedef void gp_GTrsf; +typedef void gp_Trsf2d; +typedef void BRep_Builder; +typedef void BRepBuilderAPI_Transform; +typedef void BRepBuilderAPI_MakeWire; +typedef void BRepBuilderAPI_MakeFace; +typedef void BRepBuilderAPI_MakeSolid; +typedef void BRepBuilderAPI_MakeShape; +typedef int BRepBuilderAPI_WireError; +typedef int BRepBuilderAPI_FaceError; +typedef void BRepFilletAPI_MakeFillet; +typedef void BRepPrimAPI_MakeBox; +typedef void TopExp_Explorer; +typedef void BRepPrimAPI_MakeCylinder; +typedef void BRepPrimAPI_MakeRevol; +typedef void BRepOffsetAPI_MakePipe; +typedef void TopTools_ListOfShape; +typedef void BRepTools_WireExplorer; +typedef void BRepOffsetAPI_MakeThickSolid; +typedef void Geom2d_Ellipse; +typedef void Geom_Curve; +typedef void Geom_BezierCurve; +typedef void BRepOffsetAPI_ThruSections; +typedef void BRepMesh_IncrementalMesh; +typedef void StlAPI_Writer; +typedef void STEPControl_Writer; +typedef int STEPControl_StepModelType; +typedef int IFSelect_ReturnStatus; +typedef void Font_BRepFont; +typedef void Font_BRepTextBuilder; +typedef int Font_FontAspect; +typedef int Graphic3d_HorizontalTextAlignment; +typedef int Graphic3d_VerticalTextAlignment; +typedef void BRepOffsetAPI_MakeOffsetShape; +typedef int BRepOffset_Mode; +typedef int GeomAbs_JoinType; +#define Handle(X) void +#define ARRAY_1(X) void +#else // __cplusplus +#define ARRAY_1(X) NCollection_Array1 +#endif // __cplusplus +#endif // HS_TYPES_H + + diff --git a/opencascade-hs.cabal b/opencascade-hs.cabal --- a/opencascade-hs.cabal +++ b/opencascade-hs.cabal @@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: opencascade-hs -version: 0.1.1.0 +version: 0.1.1.1 synopsis: Thin Wrapper for the OpenCASCADE CAD Kernel description: Please see the README on GitHub at category: Graphics,FFI @@ -21,6 +21,63 @@ LICENSE README.md CHANGELOG.md + cpp/hs_BRep_Tool.h + cpp/hs_BRepAlgoAPI_Common.h + cpp/hs_BRepAlgoAPI_Cut.h + cpp/hs_BRepAlgoAPI_Fuse.h + cpp/hs_BRepBuilderAPI_GTransform.h + cpp/hs_BRepBuilderAPI_MakeEdge.h + cpp/hs_BRepBuilderAPI_MakeFace.h + cpp/hs_BRepBuilderAPI_MakeShape.h + cpp/hs_BRepBuilderAPI_MakeSolid.h + cpp/hs_BRepBuilderAPI_MakeWire.h + cpp/hs_BRepBuilderAPI_Transform.h + cpp/hs_BRepFilletAPI_MakeFillet.h + cpp/hs_BRepMesh_IncrementalMesh.h + cpp/hs_BRepOffsetAPI_MakeOffsetShape.h + cpp/hs_BRepOffsetAPI_MakePipe.h + cpp/hs_BRepPrimAPI_MakeBox.h + cpp/hs_BRepPrimAPI_MakeCylinder.h + cpp/hs_BRepPrimAPI_MakePrism.h + cpp/hs_BRepPrimAPI_MakeRevol.h + cpp/hs_BRepPrimAPI_MakeSphere.h + cpp/hs_BRepTools_WireExplorer.h + cpp/hs_Font_BRepFont.h + cpp/hs_Font_BRepTextBuilder.h + cpp/hs_GC_MakeArcOfCircle.h + cpp/hs_GC_MakeSegment.h + cpp/hs_Geom_BezierCurve.h + cpp/hs_Geom_Curve.h + cpp/hs_Geom_TrimmedCurve.h + cpp/hs_gp.h + cpp/hs_gp_Ax1.h + cpp/hs_gp_Ax2.h + cpp/hs_gp_Ax2d.h + cpp/hs_gp_Ax3.h + cpp/hs_gp_Dir.h + cpp/hs_gp_Dir2d.h + cpp/hs_gp_GTrsf.h + cpp/hs_gp_Pnt.h + cpp/hs_gp_Pnt2d.h + cpp/hs_gp_Trsf.h + cpp/hs_gp_Trsf2d.h + cpp/hs_gp_Vec.h + cpp/hs_gp_Vec2d.h + cpp/hs_NCollection_Array1.h + cpp/hs_STEPControl_Writer.h + cpp/hs_StlAPI_Writer.h + cpp/hs_TopExp_Explorer.h + cpp/hs_TopLoc_Location.h + cpp/hs_TopoDS_Compound.h + cpp/hs_TopoDS_CompSolid.h + cpp/hs_TopoDS_Edge.h + cpp/hs_TopoDS_Face.h + cpp/hs_TopoDS_Shape.h + cpp/hs_TopoDS_Shell.h + cpp/hs_TopoDS_Solid.h + cpp/hs_TopoDS_Vertex.h + cpp/hs_TopoDS_Wire.h + cpp/hs_types.h source-repository head type: git