opencascade-hs 0.1.1.0 → 0.1.1.1

raw patch · 59 files changed

+2075/−1 lines, 59 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +4/−0
• cpp/hs_BRepAlgoAPI_Common.h +17/−0
• cpp/hs_BRepAlgoAPI_Cut.h +17/−0
• cpp/hs_BRepAlgoAPI_Fuse.h +17/−0
• cpp/hs_BRepBuilderAPI_GTransform.h +16/−0
• cpp/hs_BRepBuilderAPI_MakeEdge.h +30/−0
• cpp/hs_BRepBuilderAPI_MakeFace.h +36/−0
• cpp/hs_BRepBuilderAPI_MakeShape.h +17/−0
• cpp/hs_BRepBuilderAPI_MakeSolid.h +22/−0
• cpp/hs_BRepBuilderAPI_MakeWire.h +30/−0
• cpp/hs_BRepBuilderAPI_Transform.h +16/−0
• cpp/hs_BRepFilletAPI_MakeFillet.h +24/−0
• cpp/hs_BRepMesh_IncrementalMesh.h +20/−0
• cpp/hs_BRepOffsetAPI_MakeOffsetShape.h +32/−0
• cpp/hs_BRepOffsetAPI_MakePipe.h +18/−0
• cpp/hs_BRepPrimAPI_MakeBox.h +23/−0
• cpp/hs_BRepPrimAPI_MakeCylinder.h +16/−0
• cpp/hs_BRepPrimAPI_MakePrism.h +18/−0
• cpp/hs_BRepPrimAPI_MakeRevol.h +18/−0
• cpp/hs_BRepPrimAPI_MakeSphere.h +18/−0
• cpp/hs_BRepTools_WireExplorer.h +27/−0
• cpp/hs_BRep_Tool.h +20/−0
• cpp/hs_Font_BRepFont.h +32/−0
• cpp/hs_Font_BRepTextBuilder.h +26/−0
• cpp/hs_GC_MakeArcOfCircle.h +18/−0
• cpp/hs_GC_MakeSegment.h +17/−0
• cpp/hs_Geom_BezierCurve.h +22/−0
• cpp/hs_Geom_Curve.h +18/−0
• cpp/hs_Geom_TrimmedCurve.h +16/−0
• cpp/hs_NCollection_Array1.h +20/−0
• cpp/hs_STEPControl_Writer.h +26/−0
• cpp/hs_StlAPI_Writer.h +23/−0
• cpp/hs_TopExp_Explorer.h +23/−0
• cpp/hs_TopLoc_Location.h +44/−0
• cpp/hs_TopoDS_CompSolid.h +16/−0
• cpp/hs_TopoDS_Compound.h +16/−0
• cpp/hs_TopoDS_Edge.h +16/−0
• cpp/hs_TopoDS_Face.h +16/−0
• cpp/hs_TopoDS_Shape.h +106/−0
• cpp/hs_TopoDS_Shell.h +16/−0
• cpp/hs_TopoDS_Solid.h +16/−0
• cpp/hs_TopoDS_Vertex.h +16/−0
• cpp/hs_TopoDS_Wire.h +16/−0
• cpp/hs_gp.h +44/−0
• cpp/hs_gp_Ax1.h +72/−0
• cpp/hs_gp_Ax2.h +76/−0
• cpp/hs_gp_Ax2d.h +68/−0
• cpp/hs_gp_Ax3.h +89/−0
• cpp/hs_gp_Dir.h +78/−0
• cpp/hs_gp_Dir2d.h +60/−0
• cpp/hs_gp_GTrsf.h +23/−0
• cpp/hs_gp_Pnt.h +70/−0
• cpp/hs_gp_Pnt2d.h +60/−0
• cpp/hs_gp_Trsf.h +62/−0
• cpp/hs_gp_Trsf2d.h +64/−0
• cpp/hs_gp_Vec.h +111/−0
• cpp/hs_gp_Vec2d.h +93/−0
• cpp/hs_types.h +72/−0
• opencascade-hs.cabal +58/−1

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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<X>+#endif // __cplusplus+#endif // HS_TYPES_H++

@@ -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 <https://github.com/joe-warren/opencascade-hs#readme> 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