diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,11 @@ +# Changelog for `opencascade-hs` + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to the +[Haskell Package Versioning Policy](https://pvp.haskell.org/). + +## Unreleased + +## 0.0.0.1 - YYYY-MM-DD diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,502 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,1 @@ +# OpenCASCADE-hs diff --git a/cpp/hs_BRepAlgoAPI_Common.cpp b/cpp/hs_BRepAlgoAPI_Common.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepAlgoAPI_Common.cpp @@ -0,0 +1,9 @@ +#include +#include "hs_BRepAlgoAPI_Common.h" + +#include + +TopoDS_Shape * hs_BRepAlgoAPI_Common(TopoDS_Shape * a, TopoDS_Shape * b){ + auto builder = BRepAlgoAPI_Common(*a, *b); + return new TopoDS_Shape(builder.Shape()); +} diff --git a/cpp/hs_BRepAlgoAPI_Cut.cpp b/cpp/hs_BRepAlgoAPI_Cut.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepAlgoAPI_Cut.cpp @@ -0,0 +1,9 @@ +#include +#include "hs_BRepAlgoAPI_Cut.h" + +#include + +TopoDS_Shape * hs_BRepAlgoAPI_Cut(TopoDS_Shape * a, TopoDS_Shape * b){ + auto builder = BRepAlgoAPI_Cut(*a, *b); + return new TopoDS_Shape(builder.Shape()); +} diff --git a/cpp/hs_BRepAlgoAPI_Fuse.cpp b/cpp/hs_BRepAlgoAPI_Fuse.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepAlgoAPI_Fuse.cpp @@ -0,0 +1,9 @@ +#include +#include "hs_BRepAlgoAPI_Fuse.h" + +#include + +TopoDS_Shape * hs_BRepAlgoAPI_Fuse(TopoDS_Shape * a, TopoDS_Shape * b){ + auto builder = BRepAlgoAPI_Fuse(*a, *b); + return new TopoDS_Shape(builder.Shape()); +} diff --git a/cpp/hs_BRepBuilderAPI_GTransform.cpp b/cpp/hs_BRepBuilderAPI_GTransform.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_GTransform.cpp @@ -0,0 +1,10 @@ +#include +#include +#include "hs_BRepBuilderAPI_GTransform.h" + +TopoDS_Shape * hs_BRepBuilderAPI_GTransform_gtransform(TopoDS_Shape * shape, gp_GTrsf * trsf, bool copy){ + auto builder = BRepBuilderAPI_GTransform(*shape, *trsf, copy); + return new TopoDS_Shape(builder.Shape()); +} + + diff --git a/cpp/hs_BRepBuilderAPI_MakeEdge.cpp b/cpp/hs_BRepBuilderAPI_MakeEdge.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeEdge.cpp @@ -0,0 +1,36 @@ +#include +#include +#include "hs_BRepBuilderAPI_MakeEdge.h" + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromVertices(TopoDS_Vertex *a, TopoDS_Vertex *b){ + return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*a, *b)); +} + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromPnts(gp_Pnt *a, gp_Pnt *b){ + return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*a, *b)); +} + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurve(Handle(Geom_Curve) * curve){ + return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve)); +} + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveAndParameters(Handle(Geom_Curve) * curve, double a, double b){ + return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, a, b)); +} + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveAndVertices(Handle(Geom_Curve) * curve, TopoDS_Vertex* a, TopoDS_Vertex* b){ + return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, *a, *b)); +} + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveAndPnts(Handle(Geom_Curve) * curve, gp_Pnt* a, gp_Pnt* b){ + return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, *a, *b)); +} + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurveVerticesAndParameters(Handle(Geom_Curve) * curve, TopoDS_Vertex* a, TopoDS_Vertex* b, double ap, double bp){ + return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, *a, *b, ap, bp)); +} + + +TopoDS_Edge * hs_BRepBuilderAPI_MakeEdge_fromCurvePntsAndParameters(Handle(Geom_Curve) * curve, gp_Pnt* a, gp_Pnt* b, double ap, double bp){ + return new TopoDS_Edge(BRepBuilderAPI_MakeEdge(*curve, *a, *b, ap, bp)); +} diff --git a/cpp/hs_BRepBuilderAPI_MakeFace.cpp b/cpp/hs_BRepBuilderAPI_MakeFace.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeFace.cpp @@ -0,0 +1,47 @@ +#include +#include +#include "hs_BRepBuilderAPI_MakeFace.h" + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace(){ + return new BRepBuilderAPI_MakeFace(); +} + +void hs_delete_BRepBuilderAPI_MakeFace(BRepBuilderAPI_MakeFace * builder){ + delete builder; +} + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromFace(TopoDS_Face * face){ + return new BRepBuilderAPI_MakeFace(*face); +} + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromSurface(Handle(Geom_Surface)* surface, double tolerance){ + return new BRepBuilderAPI_MakeFace(*surface, tolerance); +} + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndBounds(Handle(Geom_Surface)* surface, double uMin, double uMax, double vMin, double vMax, double tolerance){ + return new BRepBuilderAPI_MakeFace(*surface, uMin, uMax, vMin, vMax, tolerance); +} + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndWire(Handle(Geom_Surface)* surface, TopoDS_Wire* wire, bool inside){ + return new BRepBuilderAPI_MakeFace(*surface, *wire, inside); +} + +BRepBuilderAPI_MakeFace * hs_new_BRepBuilderAPI_MakeFace_fromWire(TopoDS_Wire* wire, bool onlyPlane){ + return new BRepBuilderAPI_MakeFace(*wire, onlyPlane); +} + +void hs_BRepBuilderAPI_MakeFace_Add(BRepBuilderAPI_MakeFace* builder, TopoDS_Wire* wire){ + builder->Add(*wire); +} + +bool hs_BRepBuilderAPI_MakeFace_IsDone(BRepBuilderAPI_MakeFace* builder){ + return builder->IsDone(); +} + +BRepBuilderAPI_FaceError hs_BRepBuilderAPI_MakeFace_Error(BRepBuilderAPI_MakeFace * builder){ + return builder->Error(); +} + +TopoDS_Face * hs_BRepBuilderAPI_MakeFace_Face(BRepBuilderAPI_MakeFace * builder){ + return new TopoDS_Face(builder->Face()); +} diff --git a/cpp/hs_BRepBuilderAPI_MakeShape.cpp b/cpp/hs_BRepBuilderAPI_MakeShape.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeShape.cpp @@ -0,0 +1,7 @@ +#include +#include +#include "hs_BRepBuilderAPI_MakeShape.h" + +TopoDS_Shape * hs_BRepBuilderAPI_MakeShape_shape(BRepBuilderAPI_MakeShape* builder){ + return new TopoDS_Shape(builder->Shape()); +} diff --git a/cpp/hs_BRepBuilderAPI_MakeSolid.cpp b/cpp/hs_BRepBuilderAPI_MakeSolid.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeSolid.cpp @@ -0,0 +1,20 @@ +#include +#include +#include "hs_BRepBuilderAPI_MakeSolid.h" + +BRepBuilderAPI_MakeSolid * hs_new_BRepBuilderAPI_MakeSolid(){ + auto everywhere = BRepBuilderAPI_MakeSolid().Shape(); + return new BRepBuilderAPI_MakeSolid(); +} + +void hs_delete_BRepBuilderAPI_MakeSolid(BRepBuilderAPI_MakeSolid * builder){ + delete builder; +} + +void hs_BRepBuilderAPI_MakeSolid_add(BRepBuilderAPI_MakeSolid * builder, TopoDS_Shell * shell){ + builder->Add(*shell); +} + +TopoDS_Solid * hs_BRepBuilderAPI_MakeSolid_solid(BRepBuilderAPI_MakeSolid * builder){ + return new TopoDS_Solid(builder->Solid()); +} diff --git a/cpp/hs_BRepBuilderAPI_MakeWire.cpp b/cpp/hs_BRepBuilderAPI_MakeWire.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_MakeWire.cpp @@ -0,0 +1,35 @@ +#include +#include +#include "hs_BRepBuilderAPI_MakeWire.h" + +BRepBuilderAPI_MakeWire * hs_new_BRepBuilderAPI_MakeWire(){ + return new BRepBuilderAPI_MakeWire(); +} + +void hs_delete_BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeWire* builder){ + delete builder; +} + +void hs_BRepBuilderAPI_MakeWire_AddEdge(BRepBuilderAPI_MakeWire* builder, TopoDS_Edge* edge){ + builder->Add(*edge); +} + +void hs_BRepBuilderAPI_MakeWire_AddWire(BRepBuilderAPI_MakeWire* builder, TopoDS_Wire* wire){ + builder->Add(*wire); +} + +void hs_BRepBuilderAPI_MakeWire_AddListOfShape(BRepBuilderAPI_MakeWire* builder, TopTools_ListOfShape *list){ + builder->Add(*list); +} + +TopoDS_Wire * hs_BRepBuilderAPI_MakeWire_Wire(BRepBuilderAPI_MakeWire* builder){ + return new TopoDS_Wire(builder->Wire()); +} + +bool hs_BRepBuilderAPI_MakeWire_IsDone(BRepBuilderAPI_MakeWire* builder){ + return builder->IsDone(); +} + +BRepBuilderAPI_WireError hs_BRepBuilderAPI_MakeWire_Error(BRepBuilderAPI_MakeWire* builder){ + return builder->Error(); +} diff --git a/cpp/hs_BRepBuilderAPI_Transform.cpp b/cpp/hs_BRepBuilderAPI_Transform.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepBuilderAPI_Transform.cpp @@ -0,0 +1,10 @@ +#include +#include +#include "hs_BRepBuilderAPI_Transform.h" + +TopoDS_Shape * hs_BRepBuilderAPI_Transform_transform(TopoDS_Shape * shape, gp_Trsf * trsf, bool copy){ + auto builder = BRepBuilderAPI_Transform(*shape, *trsf, copy); + return new TopoDS_Shape(builder.Shape()); +} + + diff --git a/cpp/hs_BRepFilletAPI_MakeFillet.cpp b/cpp/hs_BRepFilletAPI_MakeFillet.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepFilletAPI_MakeFillet.cpp @@ -0,0 +1,25 @@ +#include +#include +#include "hs_BRepFilletAPI_MakeFillet.h" + +BRepFilletAPI_MakeFillet * hs_new_BRepFilletAPI_MakeFillet_fromShape(TopoDS_Shape * shape) { + return new BRepFilletAPI_MakeFillet(*shape); +} + +void hs_delete_BRepFilletAPI_MakeFillet(BRepFilletAPI_MakeFillet * builder) { + delete builder; +} + +void hs_BRepFilletAPI_MakeFillet_addEdge(BRepFilletAPI_MakeFillet * builder, TopoDS_Edge *edge ){ + builder->Add(*edge); +} + +void hs_BRepFilletAPI_MakeFillet_addEdgeWithRadius(BRepFilletAPI_MakeFillet * builder, double r, TopoDS_Edge *edge ){ + builder->Add(r, *edge); +} + + +void hs_BRepFilletAPI_MakeFillet_addEdgeWithTwoRadiuses(BRepFilletAPI_MakeFillet * builder, double r1, double r2, TopoDS_Edge *edge ){ + builder->Add(r1, r2, *edge); +} + diff --git a/cpp/hs_BRepMesh_IncrementalMesh.cpp b/cpp/hs_BRepMesh_IncrementalMesh.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepMesh_IncrementalMesh.cpp @@ -0,0 +1,15 @@ +#include +#include "hs_BRepMesh_IncrementalMesh.h" + + +BRepMesh_IncrementalMesh * hs_BRepMesh_IncrementalMesh_fromShapeAndLinDeflection(TopoDS_Shape *shape, double theLinDeflection){ + return new BRepMesh_IncrementalMesh(*shape, theLinDeflection); +} + +void hs_delete_BRepMesh_IncrementalMesh(BRepMesh_IncrementalMesh * mesh){ + delete mesh; +} + +void hs_BRepMesh_IncrementalMesh_Perform(BRepMesh_IncrementalMesh * mesh){ + mesh->Perform(); +} diff --git a/cpp/hs_BRepOffsetAPI_MakePipe.cpp b/cpp/hs_BRepOffsetAPI_MakePipe.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepOffsetAPI_MakePipe.cpp @@ -0,0 +1,13 @@ +#include +#include "hs_BRepOffsetAPI_MakePipe.h" + +BRepOffsetAPI_MakePipe * hs_new_BRepOffsetAPI_MakePipe_fromWireAndShape(TopoDS_Wire * wire, TopoDS_Shape * profile){ + return new BRepOffsetAPI_MakePipe(*wire, *profile); +} + + +void hs_delete_BRepOffsetAPI_MakePipe(BRepOffsetAPI_MakePipe * builder){ + delete builder; +} + + diff --git a/cpp/hs_BRepPrimAPI_MakeBox.cpp b/cpp/hs_BRepPrimAPI_MakeBox.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakeBox.cpp @@ -0,0 +1,21 @@ +#include +#include +#include +#include "hs_BRepPrimAPI_MakeBox.h" + + +BRepPrimAPI_MakeBox * hs_new_BRepPrimAPI_MakeBox_fromPnts(gp_Pnt *a, gp_Pnt *b){ + return new BRepPrimAPI_MakeBox(*a, *b); +} + +void hs_delete_BRepPrimAPI_MakeBox(BRepPrimAPI_MakeBox* builder){ + delete builder; +} + +TopoDS_Shape * hs_BRepPrimAPI_MakeBox_Solid(BRepPrimAPI_MakeBox* builder){ + return new TopoDS_Shape(builder->Solid()); +} + +TopoDS_Shell * hs_BRepPrimAPI_MakeBox_Shell(BRepPrimAPI_MakeBox* builder){ + return new TopoDS_Shell(builder->Shell()); +} diff --git a/cpp/hs_BRepPrimAPI_MakeCylinder.cpp b/cpp/hs_BRepPrimAPI_MakeCylinder.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakeCylinder.cpp @@ -0,0 +1,7 @@ +#include +#include "hs_BRepPrimAPI_MakeCylinder.h" + +TopoDS_Solid * hs_BRepPrimAPI_MakeCylinder_fromRadiusAndHeight(double r, double h){ + auto builder = BRepPrimAPI_MakeCylinder(r, h); + return new TopoDS_Solid(builder.Solid()); +} diff --git a/cpp/hs_BRepPrimAPI_MakePrism.cpp b/cpp/hs_BRepPrimAPI_MakePrism.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakePrism.cpp @@ -0,0 +1,13 @@ +#include +#include "hs_BRepPrimAPI_MakePrism.h" + + +TopoDS_Shape * hs_BRepPrimAPI_MakePrism_fromVec(TopoDS_Shape * shape, gp_Vec * vec, bool copy, bool canonize){ + auto builder = BRepPrimAPI_MakePrism(*shape, *vec, copy, canonize); + return new TopoDS_Shape(builder.Shape()); +} + +TopoDS_Shape * hs_BRepPrimAPI_MakePrism_fromDir(TopoDS_Shape * shape, gp_Dir * dir, bool inf, bool copy, bool canonize){ + auto builder = BRepPrimAPI_MakePrism(*shape, *dir, inf, copy, canonize); + return new TopoDS_Shape(builder.Shape()); +} diff --git a/cpp/hs_BRepPrimAPI_MakeRevol.cpp b/cpp/hs_BRepPrimAPI_MakeRevol.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakeRevol.cpp @@ -0,0 +1,10 @@ +#include +#include "hs_BRepPrimAPI_MakeRevol.h" + +BRepPrimAPI_MakeRevol * hs_new_BRepPrimAPI_MakeRevol_fromShapeAndAx1(TopoDS_Shape * shape, gp_Ax1 * axis, bool copy){ + return new BRepPrimAPI_MakeRevol(*shape, *axis, copy); +} + +void hs_delete_BRepPrimAPI_MakeRevol(BRepPrimAPI_MakeRevol * builder){ + delete builder; +} diff --git a/cpp/hs_BRepPrimAPI_MakeSphere.cpp b/cpp/hs_BRepPrimAPI_MakeSphere.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepPrimAPI_MakeSphere.cpp @@ -0,0 +1,13 @@ +#include +#include "hs_BRepPrimAPI_MakeSphere.h" + + +TopoDS_Solid * hs_BRepPrimAPI_MakeSphere_fromRadius(double r){ + auto builder = BRepPrimAPI_MakeSphere(r); + return new TopoDS_Solid(builder.Solid()); +} + +TopoDS_Solid * hs_BRepPrimAPI_MakeSphere_fromPntAndRadius(gp_Pnt * center, double r){ + auto builder = BRepPrimAPI_MakeSphere(*center, r); + return new TopoDS_Solid(builder.Solid()); +} diff --git a/cpp/hs_BRepTools_WireExplorer.cpp b/cpp/hs_BRepTools_WireExplorer.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRepTools_WireExplorer.cpp @@ -0,0 +1,26 @@ +#include +#include "hs_BRepTools_WireExplorer.h" + +BRepTools_WireExplorer * hs_new_BRepTools_WireExplorer_fromWire(TopoDS_Wire *wire){ + return new BRepTools_WireExplorer(*wire); +} + +void hs_delete_BRepTools_WireExplorer(BRepTools_WireExplorer * explorer){ + delete explorer; +} + +bool hs_BRepTools_WireExplorer_more(BRepTools_WireExplorer * explorer){ + return explorer->More(); +} + +void hs_BRepTools_WireExplorer_next(BRepTools_WireExplorer * explorer){ + explorer->Next(); +} + +TopoDS_Edge * hs_BRepTools_WireExplorer_current(BRepTools_WireExplorer * explorer){ + return (TopoDS_Edge *) &(explorer->Current()); +} + +TopAbs_Orientation hs_BRepTools_WireExplorer_orientation(BRepTools_WireExplorer * explorer){ + return explorer->Orientation(); +} diff --git a/cpp/hs_BRep_Tool.cpp b/cpp/hs_BRep_Tool.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_BRep_Tool.cpp @@ -0,0 +1,22 @@ +#include +#include +#include "hs_BRep_Tool.h" + +Handle(Geom_Curve) * hs_BRep_Tool_curve(TopoDS_Edge * edge){ + double s, e; + return new Handle(Geom_Curve)(BRep_Tool::Curve(*edge, s, e)); +} + +double hs_BRep_Tool_curveParamFirst(TopoDS_Edge * edge){ + double s, e; + BRep_Tool::Curve(*edge, s, e); + return s; +} + +double hs_BRep_Tool_curveParamLast(TopoDS_Edge * edge){ + double s, e; + BRep_Tool::Curve(*edge, s, e); + return e; +} + + diff --git a/cpp/hs_GC_MakeArcOfCircle.cpp b/cpp/hs_GC_MakeArcOfCircle.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_GC_MakeArcOfCircle.cpp @@ -0,0 +1,10 @@ +#include +#include "hs_GC_MakeArcOfCircle.h" + +Handle(Geom_TrimmedCurve) * hs_GC_MakeArcOfCircle_from3Pnts(gp_Pnt * a, gp_Pnt * b, gp_Pnt * c){ + return new opencascade::handle(GC_MakeArcOfCircle(*a, *b, *c).Value()); +} + +Handle(Geom_TrimmedCurve) * hs_GC_MakeArcOfCircle_fromPntsAndVec(gp_Pnt * a, gp_Vec * b, gp_Pnt * c){ + return new opencascade::handle(GC_MakeArcOfCircle(*a, *b, *c).Value()); +} diff --git a/cpp/hs_GC_MakeSegment.cpp b/cpp/hs_GC_MakeSegment.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_GC_MakeSegment.cpp @@ -0,0 +1,6 @@ +#include +#include "hs_GC_MakeSegment.h" + +Handle(Geom_TrimmedCurve) * hs_GC_MakeSegment_fromPnts(gp_Pnt* a, gp_Pnt* b){ + return new opencascade::handle(GC_MakeSegment(*a, *b).Value()); +} diff --git a/cpp/hs_Geom_BezierCurve.cpp b/cpp/hs_Geom_BezierCurve.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_Geom_BezierCurve.cpp @@ -0,0 +1,21 @@ +#include +#include +#include +#include +#include "hs_Geom_BezierCurve.h" + +Geom_BezierCurve * hs_new_Geom_BezierCurve_fromPnts(ARRAY_1(gp_Pnt) * pnts){ + return new Geom_BezierCurve(*pnts); +} + +Handle(Geom_BezierCurve) * hs_Geom_BezierCurve_toHandle(Geom_BezierCurve * curve){ + return new Handle(Geom_BezierCurve)(new Geom_BezierCurve(*curve)); +} + +void hs_delete_Handle_Geom_BezierCurve(Handle(Geom_BezierCurve)* h){ + delete h; +} + +void hs_delete_Geom_BezierCurve(Geom_BezierCurve * curve){ + delete curve; +} diff --git a/cpp/hs_Geom_Curve.cpp b/cpp/hs_Geom_Curve.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_Geom_Curve.cpp @@ -0,0 +1,12 @@ +#include +#include +#include "hs_Geom_Curve.h" + +void hs_delete_Handle_Geom_Curve(Handle(Geom_Curve) * handle){ + delete handle; +} + +gp_Pnt * hs_Geom_Curve_value(Handle(Geom_Curve) * curve, double u){ + return new gp_Pnt((*curve)->Value(u)); +} + diff --git a/cpp/hs_Geom_TrimmedCurve.cpp b/cpp/hs_Geom_TrimmedCurve.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_Geom_TrimmedCurve.cpp @@ -0,0 +1,8 @@ +#include +#include "hs_Geom_TrimmedCurve.h" + +void hs_delete_Handle_Geom_TrimmedCurve(Handle(Geom_TrimmedCurve)* h){ + delete h; +} + + diff --git a/cpp/hs_NCollection_Array1.cpp b/cpp/hs_NCollection_Array1.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_NCollection_Array1.cpp @@ -0,0 +1,15 @@ +#include +#include +#include "hs_NCollection_Array1.h" + +ARRAY_1(gp_Pnt) * hs_new_NCollection_Array1_gp_Pnt(int lower, int upper){ + return new NCollection_Array1(lower, upper); +} + +void hs_NCollection_Array1_gp_Pnt_setValue(ARRAY_1(gp_Pnt) * arr, int index, gp_Pnt * value){ + arr->SetValue(index, *value); +} + +void hs_delete_NCollection_Array1_gp_Pnt(ARRAY_1(gp_Pnt) * arr){ + delete arr; +} diff --git a/cpp/hs_STEPControl_Writer.cpp b/cpp/hs_STEPControl_Writer.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_STEPControl_Writer.cpp @@ -0,0 +1,26 @@ +#include +#include "hs_STEPControl_Writer.h" + +STEPControl_Writer * hs_new_STEPControl_Writer(){ + return new STEPControl_Writer(); +} + +void hs_delete_STEPControl_Writer(STEPControl_Writer * writer){ + delete writer; +} + +void hs_STEPControl_Writer_setTolerance(STEPControl_Writer * writer, double tolerance){ + writer->SetTolerance(tolerance); +} + +void hs_STEPControl_Writer_unsetTolerance(STEPControl_Writer * writer){ + writer->UnsetTolerance(); +} + +IFSelect_ReturnStatus hs_STEPControl_Writer_transfer(STEPControl_Writer * writer, TopoDS_Shape * shape, STEPControl_StepModelType mode, bool compgraph){ + return writer->Transfer(*shape, mode, compgraph); +} + +IFSelect_ReturnStatus hs_STEPControl_Writer_write(STEPControl_Writer* writer, char* filename){ + return writer->Write(filename); +} diff --git a/cpp/hs_StlAPI_Writer.cpp b/cpp/hs_StlAPI_Writer.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_StlAPI_Writer.cpp @@ -0,0 +1,18 @@ +#include +#include "hs_StlAPI_Writer.h" + +StlAPI_Writer * hs_new_StlAPI_Writer(){ + return new StlAPI_Writer(); +} + +void hs_delete_StlAPI_Writer(StlAPI_Writer * writer){ + delete writer; +} + +void hs_StlAPI_Writer_setAsciiMode(StlAPI_Writer * writer, bool asciiMode){ + writer->ASCIIMode() = asciiMode; +} + +bool hs_StlAPI_Writer_write(StlAPI_Writer * writer, TopoDS_Shape * shape, char* filename){ + return writer->Write(*shape, filename); +} diff --git a/cpp/hs_TopExp_Explorer.cpp b/cpp/hs_TopExp_Explorer.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopExp_Explorer.cpp @@ -0,0 +1,22 @@ +#include +#include "hs_TopExp_Explorer.h" + +TopExp_Explorer * hs_new_TopExp_Explorer(TopoDS_Shape * shape, TopAbs_ShapeEnum toFind){ + return new TopExp_Explorer(*shape, toFind); +} + +void hs_delete_TopExp_Explorer(TopExp_Explorer * explorer){ + delete explorer; +} + +bool hs_TopExp_Explorer_more(TopExp_Explorer * explorer){ + return explorer->More(); +} + +void hs_TopExp_Explorer_next(TopExp_Explorer * explorer){ + return explorer->Next(); +} + +TopoDS_Shape * hs_TopExp_Explorer_value(TopExp_Explorer * explorer){ + return (TopoDS_Shape *) &(explorer->Value()); +} diff --git a/cpp/hs_TopLoc_Location.cpp b/cpp/hs_TopLoc_Location.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopLoc_Location.cpp @@ -0,0 +1,62 @@ +#include +#include "hs_TopLoc_Location.h" + +TopLoc_Location * hs_new_TopLoc_Location(){ + return new TopLoc_Location(); +} + +TopLoc_Location * hs_new_TopLoc_Location_fromGPTrsf(gp_Trsf * trsf){ + return new TopLoc_Location(*trsf); +} + +void hs_delete_TopLoc_Location(TopLoc_Location * l){ + delete l; +} + +bool hs_TopLoc_Location_IsIdentity(TopLoc_Location * l){ + return l->IsIdentity(); +} + +int hs_TopLoc_Location_FirstPower(TopLoc_Location * l){ + return l->FirstPower(); +} + +TopLoc_Location * hs_TopLoc_Location_NextLocation(TopLoc_Location * l){ + return new TopLoc_Location(l->NextLocation()); +} + +TopLoc_Location * hs_TopLoc_Location_Inverted(TopLoc_Location * l){ + return new TopLoc_Location(l->Inverted()); +} + +TopLoc_Location * hs_TopLoc_Location_Multiplied(TopLoc_Location * a, TopLoc_Location * b){ + return new TopLoc_Location(a->Multiplied(*b)); +} + +TopLoc_Location * hs_TopLoc_Location_Divided(TopLoc_Location * a, TopLoc_Location * b){ + return new TopLoc_Location(a->Divided(*b)); +} + +TopLoc_Location * hs_TopLoc_Location_Predivided(TopLoc_Location * a, TopLoc_Location * b){ + return new TopLoc_Location(a->Predivided(*b)); +} + +TopLoc_Location * hs_TopLoc_Location_Powered(TopLoc_Location * l, int p){ + return new TopLoc_Location(l->Powered(p)); +} + +gp_Trsf * hs_TopLoc_Location_toGPTrsf(TopLoc_Location * l){ + return new gp_Trsf(gp_Trsf(*l)); +} + +bool hs_TopLoc_Location_IsEqual(TopLoc_Location * a, TopLoc_Location * b){ + return a->IsEqual(*b); +} + +bool hs_TopLoc_Location_IsDifferent(TopLoc_Location * a, TopLoc_Location * b){ + return a->IsDifferent(*b); +} + +void hs_TopLoc_Location_Clear(TopLoc_Location * l){ + l->Clear(); +} diff --git a/cpp/hs_TopoDS_CompSolid.cpp b/cpp/hs_TopoDS_CompSolid.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_CompSolid.cpp @@ -0,0 +1,7 @@ +#include +#include "hs_TopoDS_CompSolid.h" + +TopoDS_CompSolid * hs_new_TopoDS_CompSolid(){ + return new TopoDS_CompSolid(); +} + diff --git a/cpp/hs_TopoDS_Compound.cpp b/cpp/hs_TopoDS_Compound.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Compound.cpp @@ -0,0 +1,7 @@ +#include +#include "hs_TopoDS_Compound.h" + +TopoDS_Compound * hs_new_TopoDS_Compound(){ + return new TopoDS_Compound(); +} + diff --git a/cpp/hs_TopoDS_Edge.cpp b/cpp/hs_TopoDS_Edge.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Edge.cpp @@ -0,0 +1,7 @@ +#include +#include "hs_TopoDS_Edge.h" + +TopoDS_Edge * hs_new_TopoDS_Edge(){ + return new TopoDS_Edge(); +} + diff --git a/cpp/hs_TopoDS_Face.cpp b/cpp/hs_TopoDS_Face.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Face.cpp @@ -0,0 +1,7 @@ +#include +#include "hs_TopoDS_Face.h" + +TopoDS_Face * hs_new_TopoDS_Face(){ + return new TopoDS_Face(); +} + diff --git a/cpp/hs_TopoDS_Shape.cpp b/cpp/hs_TopoDS_Shape.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Shape.cpp @@ -0,0 +1,185 @@ +#include +#include "hs_TopoDS_Shape.h" + +TopoDS_Shape * hs_new_TopoDS_Shape(){ + return new TopoDS_Shape(); +} + +TopoDS_Shape * hs_new_TopoDS_Shape_copy(TopoDS_Shape * shape){ + return new TopoDS_Shape(*shape); +} + +void hs_delete_TopoDS_Shape(TopoDS_Shape * shape){ + delete shape; +} + +bool hs_TopoDS_Shape_IsNull(TopoDS_Shape * shape){ + return shape->IsNull(); +} + +void hs_TopoDS_Shape_Nullify(TopoDS_Shape * shape){ + shape->Nullify(); +} + +TopLoc_Location * hs_TopoDS_Shape_Location(TopoDS_Shape * shape){ + return new TopLoc_Location(shape->Location()); +} + +void hs_TopoDS_Shape_SetLocation(TopoDS_Shape * shape, TopLoc_Location * location){ + shape->Location(*location); +} + +TopoDS_Shape * hs_TopoDS_Shape_Located(TopoDS_Shape * shape, TopLoc_Location * location){ + return new TopoDS_Shape(shape->Located(*location)); +} + +TopAbs_Orientation hs_TopoDS_Shape_Orientation(TopoDS_Shape * shape){ + return shape->Orientation(); +} + +void hs_TopoDS_Shape_SetOrientation(TopoDS_Shape * shape, TopAbs_Orientation orientation){ + return shape->Orientation(orientation); +} + +TopoDS_Shape * hs_TopoDS_Shape_Oriented(TopoDS_Shape * shape, TopAbs_Orientation orientation){ + return new TopoDS_Shape(shape->Oriented(orientation)); +} + +TopAbs_ShapeEnum hs_TopoDS_Shape_ShapeType(TopoDS_Shape * shape){ + return shape->ShapeType(); +} + +bool hs_TopoDS_Shape_Free(TopoDS_Shape * shape){ + return shape->Free(); +} + +void hs_TopoDS_Shape_SetFree(TopoDS_Shape * shape, bool b){ + shape->Free(b); +} + + +bool hs_TopoDS_Shape_Locked(TopoDS_Shape * shape){ + return shape->Locked(); +} + +void hs_TopoDS_Shape_SetLocked(TopoDS_Shape * shape, bool b){ + shape->Locked(b); +} + +bool hs_TopoDS_Shape_Modified(TopoDS_Shape * shape){ + return shape->Modified(); +} + +void hs_TopoDS_Shape_SetModified(TopoDS_Shape * shape, bool b){ + shape->Modified(b); +} + + +bool hs_TopoDS_Shape_Checked(TopoDS_Shape * shape){ + return shape->Checked(); +} + +void hs_TopoDS_Shape_SetChecked(TopoDS_Shape * shape, bool b){ + shape->Checked(b); +} + + +bool hs_TopoDS_Shape_Orientable(TopoDS_Shape * shape){ + return shape->Orientable(); +} + +void hs_TopoDS_Shape_SetOrientable(TopoDS_Shape * shape, bool b){ + shape->Orientable(b); +} + +bool hs_TopoDS_Shape_Closed(TopoDS_Shape * shape){ + return shape->Closed(); +} + +void hs_TopoDS_Shape_SetClosed(TopoDS_Shape * shape, bool b){ + shape->Closed(b); +} + + +bool hs_TopoDS_Shape_Infinite(TopoDS_Shape * shape){ + return shape->Infinite(); +} + +void hs_TopoDS_Shape_SetInfinite(TopoDS_Shape * shape, bool b){ + shape->Infinite(b); +} + + +bool hs_TopoDS_Shape_Convex(TopoDS_Shape * shape){ + return shape->Convex(); +} + +void hs_TopoDS_Shape_SetConvex(TopoDS_Shape * shape, bool b){ + shape->Convex(b); +} + +void hs_TopoDS_Shape_Move(TopoDS_Shape * shape, TopLoc_Location * position){ + shape->Move(*position); +} + +TopoDS_Shape * hs_TopoDS_Shape_Moved(TopoDS_Shape * shape, TopLoc_Location * position){ + return new TopoDS_Shape(shape->Moved(*position)); +} + +int hs_TopoDS_Shape_NbChildren(TopoDS_Shape * shape){ + return shape->NbChildren(); +} + +void hs_TopoDS_Shape_Reverse(TopoDS_Shape * shape){ + shape->Reverse(); +} + +TopoDS_Shape * hs_TopoDS_Shape_Reversed(TopoDS_Shape * shape){ + return new TopoDS_Shape(shape->Reversed()); +} + + +void hs_TopoDS_Shape_Complement(TopoDS_Shape * shape){ + shape->Complement(); +} + +TopoDS_Shape * hs_TopoDS_Shape_Complemented(TopoDS_Shape * shape){ + return new TopoDS_Shape(shape->Complemented()); +} + +void hs_TopoDS_Shape_Compose(TopoDS_Shape * shape, TopAbs_Orientation orient){ + shape->Compose(orient); +} + +TopoDS_Shape * hs_TopoDS_Shape_Composed(TopoDS_Shape * shape, TopAbs_Orientation orient){ + return new TopoDS_Shape(shape->Composed(orient)); +} + +bool hs_TopoDS_Shape_IsEqual(TopoDS_Shape * a, TopoDS_Shape* b){ + return a->IsEqual(*b); +} + +bool hs_TopoDS_Shape_IsSame(TopoDS_Shape * a, TopoDS_Shape* b){ + return a->IsSame(*b); +} + +bool hs_TopoDS_Shape_IsPartner(TopoDS_Shape * a, TopoDS_Shape* b){ + return a->IsPartner(*b); +} + +bool hs_TopoDS_Shape_IsNotEqual(TopoDS_Shape * a, TopoDS_Shape* b){ + return a->IsNotEqual(*b); +} + + +void hs_TopoDS_Shape_EmptyCopy(TopoDS_Shape * shape){ + shape->EmptyCopy(); +} + +TopoDS_Shape * hs_TopoDS_Shape_EmptyCopied(TopoDS_Shape * shape){ + return new TopoDS_Shape(shape->EmptyCopied()); +} + +int hs_TopoDS_Shape_hashCode(TopoDS_Shape * shape, int maxN){ + return shape->HashCode(maxN); +} diff --git a/cpp/hs_TopoDS_Shell.cpp b/cpp/hs_TopoDS_Shell.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Shell.cpp @@ -0,0 +1,7 @@ +#include +#include "hs_TopoDS_Shell.h" + +TopoDS_Shell * hs_new_TopoDS_Shell(){ + return new TopoDS_Shell(); +} + diff --git a/cpp/hs_TopoDS_Solid.cpp b/cpp/hs_TopoDS_Solid.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Solid.cpp @@ -0,0 +1,7 @@ +#include +#include "hs_TopoDS_Solid.h" + +TopoDS_Solid * hs_new_TopoDS_Solid(){ + return new TopoDS_Solid(); +} + diff --git a/cpp/hs_TopoDS_Vertex.cpp b/cpp/hs_TopoDS_Vertex.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Vertex.cpp @@ -0,0 +1,7 @@ +#include +#include "hs_TopoDS_Vertex.h" + +TopoDS_Vertex * hs_new_TopoDS_Vertex(){ + return new TopoDS_Vertex(); +} + diff --git a/cpp/hs_TopoDS_Wire.cpp b/cpp/hs_TopoDS_Wire.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_TopoDS_Wire.cpp @@ -0,0 +1,7 @@ +#include +#include "hs_TopoDS_Wire.h" + +TopoDS_Wire * hs_new_TopoDS_Wire(){ + return new TopoDS_Wire(); +} + diff --git a/cpp/hs_gp.cpp b/cpp/hs_gp.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp.cpp @@ -0,0 +1,69 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include "hs_gp.h" + +gp_Pnt * hs_gp_Origin(){ + return new gp_Pnt(gp::Origin()); +} + +gp_Dir * hs_gp_DX(){ + return new gp_Dir(gp::DX()); +} + +gp_Dir * hs_gp_DY(){ + return new gp_Dir(gp::DY()); +} + +gp_Dir * hs_gp_DZ(){ + return new gp_Dir(gp::DZ()); +} + +gp_Ax1 * hs_gp_OX(){ + return new gp_Ax1(gp::OX()); +} + +gp_Ax1 * hs_gp_OY(){ + return new gp_Ax1(gp::OY()); +} + +gp_Ax1 * hs_gp_OZ(){ + return new gp_Ax1(gp::OZ()); +} + +gp_Ax2 * hs_gp_XOY(){ + return new gp_Ax2(gp::XOY()); +} + +gp_Ax2 * hs_gp_YOZ(){ + return new gp_Ax2(gp::YOZ()); +} + +gp_Ax2 * hs_gp_ZOX(){ + return new gp_Ax2(gp::ZOX()); +} + +gp_Pnt2d * hs_gp_Origin2d(){ + return new gp_Pnt2d(gp::Origin2d()); +} + +gp_Dir2d * hs_gp_DX2d(){ + return new gp_Dir2d(gp::DX2d()); +} + +gp_Dir2d * hs_gp_DY2d(){ + return new gp_Dir2d(gp::DY2d()); +} + +gp_Ax2d * hs_gp_OX2d(){ + return new gp_Ax2d(gp::OX2d()); +} + +gp_Ax2d * hs_gp_OY2d(){ + return new gp_Ax2d(gp::OY2d()); +} diff --git a/cpp/hs_gp_Ax1.cpp b/cpp/hs_gp_Ax1.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Ax1.cpp @@ -0,0 +1,118 @@ +#include +#include "hs_gp_Ax1.h" + +gp_Ax1 * hs_new_gp_Ax1(gp_Pnt * origin, gp_Dir * direction){ + return new gp_Ax1(*origin, *direction); +} + +void hs_delete_gp_Ax1(gp_Ax1* ax1){ + delete ax1; +} + +gp_Dir * hs_gp_Ax1_Direction(gp_Ax1* ax1){ + return new gp_Dir(ax1->Direction()); +} + +gp_Pnt * hs_gp_Ax1_Location(gp_Ax1* ax1){ + return new gp_Pnt(ax1->Location()); +} + +void hs_gp_Ax1_SetDirection(gp_Ax1* ax1, gp_Dir* direction){ + ax1->SetDirection(*direction); +} + +void hs_gp_Ax1_SetLocation(gp_Ax1* ax1, gp_Pnt* origin){ + ax1->SetLocation(*origin); +} + +bool hs_gp_Ax1_IsCoaxial(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance, double linearTolerance){ + return axis1->IsCoaxial(*axis2, angularTolerance, linearTolerance); +} + +bool hs_gp_Ax1_IsNormal(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance){ + return axis1->IsNormal(*axis2, angularTolerance); +} + +bool hs_gp_Ax1_IsOpposite(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance){ + return axis1->IsOpposite(*axis2, angularTolerance); +} + +bool hs_gp_Ax1_IsParallel(gp_Ax1* axis1, gp_Ax1* axis2, double angularTolerance){ + return axis1->IsParallel(*axis2, angularTolerance); +} + +double hs_gp_Ax1_Angle(gp_Ax1* axis1, gp_Ax1* axis2){ + return axis1->Angle(*axis2); +} + +void hs_gp_Ax1_Reverse(gp_Ax1* ax1){ + ax1->Reverse(); +} + +gp_Ax1 * hs_gp_Ax1_Reversed(gp_Ax1* ax1){ + return new gp_Ax1(ax1->Reversed()); +} + +void hs_gp_Ax1_Mirror(gp_Ax1* ax1, gp_Ax1* mirror){ + ax1->Mirror(*mirror); +} + +gp_Ax1 * hs_gp_Ax1_Mirrored(gp_Ax1* ax1, gp_Ax1* mirror){ + return new gp_Ax1(ax1->Mirrored(*mirror)); +} + +void hs_gp_Ax1_MirrorAboutPnt(gp_Ax1* ax1, gp_Pnt* mirror){ + ax1->Mirror(*mirror); +} + +gp_Ax1 * hs_gp_Ax1_MirroredAboutPnt(gp_Ax1* ax1, gp_Pnt* mirror){ + return new gp_Ax1(ax1->Mirrored(*mirror)); +} + +void hs_gp_Ax1_MirrorAboutAx2(gp_Ax1* ax1, gp_Ax2* mirror){ + ax1->Mirror(*mirror); +} + +gp_Ax1 * hs_gp_Ax1_MirroredAboutAx2(gp_Ax1* ax1, gp_Ax2* mirror){ + return new gp_Ax1(ax1->Mirrored(*mirror)); +} + +void hs_gp_Ax1_Rotate(gp_Ax1* ax1, gp_Ax1* axisOfRotation, double angle){ + ax1->Rotate(*axisOfRotation, angle); +} + +gp_Ax1 * hs_gp_Ax1_Rotated(gp_Ax1* ax1, gp_Ax1* axisOfRotation, double angle){ + return new gp_Ax1(ax1->Rotated(*axisOfRotation, angle)); +} + +void hs_gp_Ax1_Scale(gp_Ax1* ax1, gp_Pnt* origin, double amount){ + ax1->Scale(*origin, amount); +} + +gp_Ax1 * hs_gp_Ax1_Scaled(gp_Ax1* ax1, gp_Pnt* origin, double amount){ + return new gp_Ax1(ax1->Scaled(*origin, amount)); +} + +void hs_gp_Ax1_Transform(gp_Ax1* ax1, gp_Trsf* trsf){ + ax1->Transform(*trsf); +} + +gp_Ax1 * hs_gp_Ax1_Transformed(gp_Ax1* ax1, gp_Trsf* trsf){ + return new gp_Ax1(ax1->Transformed(*trsf)); +} + +void hs_gp_Ax1_Translate(gp_Ax1* ax1, gp_Vec* vec){ + ax1->Translate(*vec); +} + +gp_Ax1 * hs_gp_Ax1_Translated(gp_Ax1* ax1, gp_Vec* vec){ + return new gp_Ax1(ax1->Translated(*vec)); +} + +void hs_gp_Ax1_TranslateRelative(gp_Ax1* ax1, gp_Pnt* from, gp_Pnt* to){ + ax1->Translate(*from, *to); +} + +gp_Ax1 * hs_gp_Ax1_TranslatedRelative(gp_Ax1* ax1, gp_Pnt* from, gp_Pnt* to){ + return new gp_Ax1(ax1->Translated(*from, *to)); +} diff --git a/cpp/hs_gp_Ax2.cpp b/cpp/hs_gp_Ax2.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Ax2.cpp @@ -0,0 +1,126 @@ +#include +#include "hs_gp_Ax2.h" + +gp_Ax2 * hs_new_gp_Ax2(gp_Pnt * origin, gp_Dir * north, gp_Dir * vX){ + return new gp_Ax2(*origin, *north, *vX); +} + +void hs_delete_gp_Ax2(gp_Ax2* ax2){ + delete ax2; +} + +gp_Ax2 * hs_new_gp_Ax2_autoX(gp_Pnt * origin, gp_Dir * north){ + return new gp_Ax2(*origin, *north); +} + +gp_Dir * hs_gp_Ax2_Direction(gp_Ax2* ax2){ + return new gp_Dir(ax2->Direction()); +} + +gp_Pnt * hs_gp_Ax2_Location(gp_Ax2* ax2){ + return new gp_Pnt(ax2->Location()); +} + +gp_Dir * hs_gp_Ax2_XDirection(gp_Ax2* ax2){ + return new gp_Dir(ax2->XDirection()); +} + +gp_Dir * hs_gp_Ax2_YDirection(gp_Ax2* ax2){ + return new gp_Dir(ax2->YDirection()); +} + +gp_Ax1 * hs_gp_Ax2_Axis(gp_Ax2* ax2){ + return new gp_Ax1(ax2->Axis()); +} + +void hs_gp_Ax2_SetDirection(gp_Ax2* ax2, gp_Dir* direction){ + ax2->SetDirection(*direction); +} + +void hs_gp_Ax2_SetLocation(gp_Ax2* ax2, gp_Pnt* origin){ + ax2->SetLocation(*origin); +} + +void hs_gp_Ax2_SetXDirection(gp_Ax2* ax2, gp_Dir* direction){ + ax2->SetXDirection(*direction); +} + +void hs_gp_Ax2_SetYDirection(gp_Ax2* ax2, gp_Dir* direction){ + ax2->SetYDirection(*direction); +} + +void hs_gp_Ax2_SetAxis(gp_Ax2* ax2, gp_Ax1* ax1){ + ax2->SetAxis(*ax1); +} + +bool hs_gp_Ax2_IsCoplanar(gp_Ax2* axis1, gp_Ax2* axis2, double linearTolerance, double angularTolerance){ + return axis1->IsCoplanar(*axis2, linearTolerance, angularTolerance); +} + +bool hs_gp_Ax2_IsCoplanarWithAx1(gp_Ax2* axis1, gp_Ax1* axis2, double linearTolerance, double angularTolerance){ + return axis1->IsCoplanar(*axis2, linearTolerance, angularTolerance); +} + +void hs_gp_Ax2_Mirror(gp_Ax2* ax2, gp_Ax2* mirror){ + ax2->Mirror(*mirror); +} + +gp_Ax2 * hs_gp_Ax2_Mirrored(gp_Ax2* ax2, gp_Ax2* mirror){ + return new gp_Ax2(ax2->Mirrored(*mirror)); +} + +void hs_gp_Ax2_MirrorAboutPnt(gp_Ax2* ax2, gp_Pnt* mirror){ + ax2->Mirror(*mirror); +} + +gp_Ax2 * hs_gp_Ax2_MirroredAboutPnt(gp_Ax2* ax2, gp_Pnt* mirror){ + return new gp_Ax2(ax2->Mirrored(*mirror)); +} + +void hs_gp_Ax2_MirrorAboutAx1(gp_Ax2* ax2, gp_Ax1* mirror){ + ax2->Mirror(*mirror); +} + +gp_Ax2 * hs_gp_Ax2_MirroredAboutAx1(gp_Ax2* ax2, gp_Ax1* mirror){ + return new gp_Ax2(ax2->Mirrored(*mirror)); +} + +void hs_gp_Ax2_Rotate(gp_Ax2* ax2, gp_Ax1* axisOfRotation, double angle){ + ax2->Rotate(*axisOfRotation, angle); +} + +gp_Ax2 * hs_gp_Ax2_Rotated(gp_Ax2* ax2, gp_Ax1* axisOfRotation, double angle){ + return new gp_Ax2(ax2->Rotated(*axisOfRotation, angle)); +} + +void hs_gp_Ax2_Scale(gp_Ax2* ax2, gp_Pnt* origin, double amount){ + ax2->Scale(*origin, amount); +} + +gp_Ax2 * hs_gp_Ax2_Scaled(gp_Ax2* ax2, gp_Pnt* origin, double amount){ + return new gp_Ax2(ax2->Scaled(*origin, amount)); +} + +void hs_gp_Ax2_Transform(gp_Ax2* ax2, gp_Trsf* trsf){ + ax2->Transform(*trsf); +} + +gp_Ax2 * hs_gp_Ax2_Transformed(gp_Ax2* ax2, gp_Trsf* trsf){ + return new gp_Ax2(ax2->Transformed(*trsf)); +} + +void hs_gp_Ax2_Translate(gp_Ax2* ax2, gp_Vec* vec){ + ax2->Translate(*vec); +} + +gp_Ax2 * hs_gp_Ax2_Translated(gp_Ax2* ax2, gp_Vec* vec){ + return new gp_Ax2(ax2->Translated(*vec)); +} + +void hs_gp_Ax2_TranslateRelative(gp_Ax2* ax2, gp_Pnt* from, gp_Pnt* to){ + ax2->Translate(*from, *to); +} + +gp_Ax2 * hs_gp_Ax2_TranslatedRelative(gp_Ax2* ax2, gp_Pnt* from, gp_Pnt* to){ + return new gp_Ax2(ax2->Translated(*from, *to)); +} diff --git a/cpp/hs_gp_Ax2d.cpp b/cpp/hs_gp_Ax2d.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Ax2d.cpp @@ -0,0 +1,110 @@ +#include +#include "hs_gp_Ax2d.h" + +gp_Ax2d* hs_new_gp_Ax2d(gp_Pnt2d* location, gp_Dir2d* direction){ + return new gp_Ax2d(*location, *direction); +} + +void hs_delete_gp_Ax2d(gp_Ax2d* ax2d){ + delete ax2d; +} + +gp_Dir2d * hs_gp_Ax2d_Direction(gp_Ax2d* ax2d){ + return new gp_Dir2d(ax2d->Direction()); +} + +gp_Pnt2d * hs_gp_Ax2d_Location(gp_Ax2d* ax2d){ + return new gp_Pnt2d(ax2d->Location()); +} + +void hs_gp_Ax2d_SetDirection(gp_Ax2d* ax2d, gp_Dir2d* direction){ + ax2d->SetDirection(*direction); +} + +void hs_gp_Ax2d_SetLocation(gp_Ax2d* ax2d, gp_Pnt2d* origin){ + ax2d->SetLocation(*origin); +} + +bool hs_gp_Ax2d_IsCoaxial(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance, double linearTolerance){ + return axis1->IsCoaxial(*axis2, angularTolerance, linearTolerance); +} + +bool hs_gp_Ax2d_IsNormal(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance){ + return axis1->IsNormal(*axis2, angularTolerance); +} + +bool hs_gp_Ax2d_IsOpposite(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance){ + return axis1->IsOpposite(*axis2, angularTolerance); +} + +bool hs_gp_Ax2d_IsParallel(gp_Ax2d* axis1, gp_Ax2d* axis2, double angularTolerance){ + return axis1->IsParallel(*axis2, angularTolerance); +} + +double hs_gp_Ax2d_Angle(gp_Ax2d* axis1, gp_Ax2d* axis2){ + return axis1->Angle(*axis2); +} + +void hs_gp_Ax2d_Reverse(gp_Ax2d* ax2d){ + ax2d->Reverse(); +} + +gp_Ax2d * hs_gp_Ax2d_Reversed(gp_Ax2d* ax2d){ + return new gp_Ax2d(ax2d->Reversed()); +} + +void hs_gp_Ax2d_Mirror(gp_Ax2d* ax2d, gp_Ax2d* mirror){ + ax2d->Mirror(*mirror); +} + +gp_Ax2d * hs_gp_Ax2d_Mirrored(gp_Ax2d* ax2d, gp_Ax2d* mirror){ + return new gp_Ax2d(ax2d->Mirrored(*mirror)); +} + +void hs_gp_Ax2d_MirrorAboutPnt2d(gp_Ax2d* ax2d, gp_Pnt2d* mirror){ + ax2d->Mirror(*mirror); +} + +gp_Ax2d * hs_gp_Ax2d_MirroredAboutPnt2d(gp_Ax2d* ax2d, gp_Pnt2d* mirror){ + return new gp_Ax2d(ax2d->Mirrored(*mirror)); +} + +void hs_gp_Ax2d_Rotate(gp_Ax2d* ax2d, gp_Pnt2d* axisOfRotation, double angle){ + ax2d->Rotate(*axisOfRotation, angle); +} + +gp_Ax2d * hs_gp_Ax2d_Rotated(gp_Ax2d* ax2d, gp_Pnt2d* axisOfRotation, double angle){ + return new gp_Ax2d(ax2d->Rotated(*axisOfRotation, angle)); +} + +void hs_gp_Ax2d_Scale(gp_Ax2d* ax2d, gp_Pnt2d* origin, double amount){ + ax2d->Scale(*origin, amount); +} + +gp_Ax2d * hs_gp_Ax2d_Scaled(gp_Ax2d* ax2d, gp_Pnt2d* origin, double amount){ + return new gp_Ax2d(ax2d->Scaled(*origin, amount)); +} + +void hs_gp_Ax2d_Transform(gp_Ax2d* ax2d, gp_Trsf2d* trsf){ + ax2d->Transform(*trsf); +} + +gp_Ax2d * hs_gp_Ax2d_Transformed(gp_Ax2d* ax2d, gp_Trsf2d* trsf){ + return new gp_Ax2d(ax2d->Transformed(*trsf)); +} + +void hs_gp_Ax2d_Translate(gp_Ax2d* ax2d, gp_Vec2d* vec){ + ax2d->Translate(*vec); +} + +gp_Ax2d * hs_gp_Ax2d_Translated(gp_Ax2d* ax2d, gp_Vec2d* vec){ + return new gp_Ax2d(ax2d->Translated(*vec)); +} + +void hs_gp_Ax2d_TranslateRelative(gp_Ax2d* ax2d, gp_Pnt2d* from, gp_Pnt2d* to){ + ax2d->Translate(*from, *to); +} + +gp_Ax2d * hs_gp_Ax2d_TranslatedRelative(gp_Ax2d* ax2d, gp_Pnt2d* from, gp_Pnt2d* to){ + return new gp_Ax2d(ax2d->Translated(*from, *to)); +} diff --git a/cpp/hs_gp_Dir.cpp b/cpp/hs_gp_Dir.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Dir.cpp @@ -0,0 +1,131 @@ +#include +#include "hs_gp_Dir.h" + +gp_Dir * hs_new_gp_Dir(double x, double y, double z) { + return new gp_Dir(x, y, z); +} + +void hs_delete_gp_Dir(gp_Dir* dir){ + delete dir; +} + +double hs_gp_Dir_X(gp_Dir * pnt){ + return pnt->X(); +} + +double hs_gp_Dir_Y(gp_Dir * pnt){ + return pnt->Y(); +} + +double hs_gp_Dir_Z(gp_Dir * pnt){ + return pnt->Z(); +} + +void hs_gp_Dir_SetX(gp_Dir * pnt, double x){ + pnt->SetX(x); +} + +void hs_gp_Dir_SetY(gp_Dir * pnt, double y){ + pnt->SetY(y); +} + +void hs_gp_Dir_SetZ(gp_Dir * pnt, double z){ + pnt->SetZ(z); +} + +bool hs_gp_Dir_IsEqual(gp_Dir * a, gp_Dir * b, double angularTolerance){ + return a->IsEqual(*b, angularTolerance); +} + +bool hs_gp_Dir_IsNormal(gp_Dir * a, gp_Dir * b, double angularTolerance){ + return a->IsNormal(*b, angularTolerance); +} + +bool hs_gp_Dir_IsOpposite(gp_Dir * a, gp_Dir * b, double angularTolerance){ + return a->IsOpposite(*b, angularTolerance); +} + +bool hs_gp_Dir_IsParallel(gp_Dir * a, gp_Dir * b, double angularTolerance){ + return a->IsParallel(*b, angularTolerance); +} + +double hs_gp_Dir_Angle(gp_Dir * a, gp_Dir * b){ + return a->Angle(*b); +} + +double hs_gp_Dir_AngleWithRef(gp_Dir * a, gp_Dir * b, gp_Dir* theVRef){ + return a->AngleWithRef(*b, *theVRef); +} + +void hs_gp_Dir_Cross(gp_Dir * a, gp_Dir * b){ + a->Cross(*b); +} + +gp_Dir * hs_gp_Dir_Crossed(gp_Dir * a, gp_Dir * b){ + return new gp_Dir(a->Crossed(*b)); +} + +void hs_gp_Dir_CrossCross(gp_Dir * a, gp_Dir * b, gp_Dir * c){ + return a->CrossCross(*b, *c); +} + +gp_Dir * hs_gp_Dir_CrossCrossed(gp_Dir * a, gp_Dir * b, gp_Dir * c){ + return new gp_Dir(a->CrossCrossed(*b, *c)); +} + +double hs_gp_Dir_Dot(gp_Dir * a, gp_Dir * b){ + return a->Dot(*b); +} + +double hs_gp_Dir_DotCross(gp_Dir * a, gp_Dir * b, gp_Dir * c){ + return a->DotCross(*b, *c); +} + + +void hs_gp_Dir_Reverse(gp_Dir* ax1){ + ax1->Reverse(); +} + +gp_Dir * hs_gp_Dir_Reversed(gp_Dir* ax1){ + return new gp_Dir(ax1->Reversed()); +} + +void hs_gp_Dir_Mirror(gp_Dir * theDir, gp_Dir * theAxis){ + theDir->Mirror(*theAxis); +} + +gp_Dir * hs_gp_Dir_Mirrored(gp_Dir * theDir, gp_Dir * theAxis){ + return new gp_Dir(theDir->Mirrored(*theAxis)); +} + +void hs_gp_Dir_MirrorAboutAx1(gp_Dir * theDir, gp_Ax1 * theAxis){ + theDir->Mirror(*theAxis); +} + +gp_Dir * hs_gp_Dir_MirroredAboutAx1(gp_Dir * theDir, gp_Ax1 * theAxis){ + return new gp_Dir(theDir->Mirrored(*theAxis)); +} + +void hs_gp_Dir_MirrorAboutAx2(gp_Dir * theDir, gp_Ax2 * theAxis){ + theDir->Mirror(*theAxis); +} + +gp_Dir * hs_gp_Dir_MirroredAboutAx2(gp_Dir * theDir, gp_Ax2 * theAxis){ + return new gp_Dir(theDir->Mirrored(*theAxis)); +} + +void hs_gp_Dir_Rotate(gp_Dir * theDir, gp_Ax1 * theAxis, double amount){ + theDir->Rotate(*theAxis, amount); +} + +gp_Dir * hs_gp_Dir_Rotated(gp_Dir * theDir, gp_Ax1 * theAxis, double amount){ + return new gp_Dir(theDir->Rotated(*theAxis, amount)); +} + +void hs_gp_Dir_Transform(gp_Dir * theDir, gp_Trsf * trsf){ + theDir->Transform(*trsf); +} + +gp_Dir * hs_gp_Dir_Transformed(gp_Dir * theDir, gp_Trsf * trsf){ + return new gp_Dir(theDir->Transformed(*trsf)); +} diff --git a/cpp/hs_gp_Dir2d.cpp b/cpp/hs_gp_Dir2d.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Dir2d.cpp @@ -0,0 +1,95 @@ +#include +#include "hs_gp_Dir2d.h" + +gp_Dir2d * hs_new_gp_Dir2d(double x, double y) { + return new gp_Dir2d(x, y); +} + +void hs_delete_gp_Dir2d(gp_Dir2d* dir){ + delete dir; +} + +double hs_gp_Dir2d_X(gp_Dir2d * pnt){ + return pnt->X(); +} + +double hs_gp_Dir2d_Y(gp_Dir2d * pnt){ + return pnt->Y(); +} + + +void hs_gp_Dir2d_SetX(gp_Dir2d * pnt, double x){ + pnt->SetX(x); +} + +void hs_gp_Dir2d_SetY(gp_Dir2d * pnt, double y){ + pnt->SetY(y); +} + +bool hs_gp_Dir2d_IsEqual(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance){ + return a->IsEqual(*b, angularTolerance); +} + +bool hs_gp_Dir2d_IsNormal(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance){ + return a->IsNormal(*b, angularTolerance); +} + +bool hs_gp_Dir2d_IsOpposite(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance){ + return a->IsOpposite(*b, angularTolerance); +} + +bool hs_gp_Dir2d_IsParallel(gp_Dir2d * a, gp_Dir2d * b, double angularTolerance){ + return a->IsParallel(*b, angularTolerance); +} + +double hs_gp_Dir2d_Angle(gp_Dir2d * a, gp_Dir2d * b){ + return a->Angle(*b); +} + +double hs_gp_Dir2d_Crossed(gp_Dir2d * a, gp_Dir2d * b){ + return a->Crossed(*b); +} + +double hs_gp_Dir2d_Dot(gp_Dir2d * a, gp_Dir2d * b){ + return a->Dot(*b); +} + +void hs_gp_Dir2d_Reverse(gp_Dir2d* ax1){ + ax1->Reverse(); +} + +gp_Dir2d * hs_gp_Dir2d_Reversed(gp_Dir2d* ax1){ + return new gp_Dir2d(ax1->Reversed()); +} + +void hs_gp_Dir2d_Mirror(gp_Dir2d * theDir2d, gp_Dir2d * theAxis){ + theDir2d->Mirror(*theAxis); +} + +gp_Dir2d * hs_gp_Dir2d_Mirrored(gp_Dir2d * theDir2d, gp_Dir2d * theAxis){ + return new gp_Dir2d(theDir2d->Mirrored(*theAxis)); +} + +void hs_gp_Dir2d_MirrorAboutAx2d(gp_Dir2d * theDir2d, gp_Ax2d * theAxis){ + theDir2d->Mirror(*theAxis); +} + +gp_Dir2d * hs_gp_Dir2d_MirroredAboutAx2d(gp_Dir2d * theDir2d, gp_Ax2d * theAxis){ + return new gp_Dir2d(theDir2d->Mirrored(*theAxis)); +} + +void hs_gp_Dir2d_Rotate(gp_Dir2d * theDir2d, double amount){ + theDir2d->Rotate(amount); +} + +gp_Dir2d * hs_gp_Dir2d_Rotated(gp_Dir2d * theDir2d, double amount){ + return new gp_Dir2d(theDir2d->Rotated(amount)); +} + +void hs_gp_Dir2d_Transform(gp_Dir2d * theDir2d, gp_Trsf2d * trsf){ + theDir2d->Transform(*trsf); +} + +gp_Dir2d * hs_gp_Dir2d_Transformed(gp_Dir2d * theDir2d, gp_Trsf2d * trsf){ + return new gp_Dir2d(theDir2d->Transformed(*trsf)); +} diff --git a/cpp/hs_gp_GTrsf.cpp b/cpp/hs_gp_GTrsf.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_GTrsf.cpp @@ -0,0 +1,19 @@ +#include +#include "hs_gp_GTrsf.h" + +gp_GTrsf * hs_new_gp_GTrsf(){ + return new gp_GTrsf(); +} + +void hs_delete_gp_GTrsf(gp_GTrsf * t){ + delete t; +} + +void hs_gp_GTrsf_setValue(gp_GTrsf * trsf, int row, int col, double value){ + trsf->SetValue(row, col, value); +} + + +void hs_gp_GTrsf_setForm(gp_GTrsf * trsf){ + trsf->SetForm(); +} diff --git a/cpp/hs_gp_Pnt.cpp b/cpp/hs_gp_Pnt.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Pnt.cpp @@ -0,0 +1,117 @@ +#include +#include "hs_gp_Pnt.h" + +gp_Pnt * hs_new_gp_Pnt(double x, double y, double z) { + return new gp_Pnt(x, y, z); +} + +void hs_delete_gp_Pnt(gp_Pnt* pnt){ + delete pnt; +} + +double hs_gp_Pnt_X(gp_Pnt * pnt){ + return pnt->X(); +} + +double hs_gp_Pnt_Y(gp_Pnt * pnt){ + return pnt->Y(); +} + +double hs_gp_Pnt_Z(gp_Pnt * pnt){ + return pnt->Z(); +} + +void hs_gp_Pnt_SetX(gp_Pnt * pnt, double x){ + pnt->SetX(x); +} + +void hs_gp_Pnt_SetY(gp_Pnt * pnt, double y){ + pnt->SetY(y); +} + +void hs_gp_Pnt_SetZ(gp_Pnt * pnt, double z){ + pnt->SetZ(z); +} + +double hs_gp_Pnt_Distance(gp_Pnt * a, gp_Pnt * b ){ + return a->Distance(*b); +} + +double hs_gp_Pnt_SquareDistance(gp_Pnt * a, gp_Pnt * b ){ + return a->SquareDistance(*b); +} + +void hs_gp_Pnt_BaryCenter(gp_Pnt * a, double alpha, gp_Pnt * b, double beta){ + a->BaryCenter(alpha, *b, beta); +} + +bool hs_gp_Pnt_IsEqual(gp_Pnt * a, gp_Pnt * b, double tolerance){ + return a->IsEqual(*b, tolerance); +} + +void hs_gp_Pnt_Mirror(gp_Pnt * thePnt, gp_Pnt * theAxis){ + thePnt->Mirror(*theAxis); +} + +gp_Pnt * hs_gp_Pnt_Mirrored(gp_Pnt * thePnt, gp_Pnt * theAxis){ + return new gp_Pnt(thePnt->Mirrored(*theAxis)); +} + +void hs_gp_Pnt_MirrorAboutAx1(gp_Pnt * thePnt, gp_Ax1 * theAxis){ + thePnt->Mirror(*theAxis); +} + +gp_Pnt * hs_gp_Pnt_MirroredAboutAx1(gp_Pnt * thePnt, gp_Ax1 * theAxis){ + return new gp_Pnt(thePnt->Mirrored(*theAxis)); +} + +void hs_gp_Pnt_MirrorAboutAx2(gp_Pnt * thePnt, gp_Ax2 * theAxis){ + thePnt->Mirror(*theAxis); +} + +gp_Pnt * hs_gp_Pnt_MirroredAboutAx2(gp_Pnt * thePnt, gp_Ax2 * theAxis){ + return new gp_Pnt(thePnt->Mirrored(*theAxis)); +} + +void hs_gp_Pnt_Rotate(gp_Pnt * thePnt, gp_Ax1 * theAxis, double amount){ + thePnt->Rotate(*theAxis, amount); +} + +gp_Pnt * hs_gp_Pnt_Rotated(gp_Pnt * thePnt, gp_Ax1 * theAxis, double amount){ + return new gp_Pnt(thePnt->Rotated(*theAxis, amount)); +} + +void hs_gp_Pnt_Scale(gp_Pnt * thePnt, gp_Pnt * origin, double amount){ + thePnt->Scale(*origin, amount); +} + +gp_Pnt * hs_gp_Pnt_Scaled(gp_Pnt * thePnt, gp_Pnt * origin, double amount){ + return new gp_Pnt(thePnt->Scaled(*origin, amount)); +} + +void hs_gp_Pnt_Transform(gp_Pnt * thePnt, gp_Trsf * trsf){ + thePnt->Transform(*trsf); +} + +gp_Pnt * hs_gp_Pnt_Transformed(gp_Pnt * thePnt, gp_Trsf * trsf){ + return new gp_Pnt(thePnt->Transformed(*trsf)); +} + +void hs_gp_Pnt_Translate(gp_Pnt * thePnt, gp_Vec * vec){ + thePnt->Translate(*vec); +} + +gp_Pnt * hs_gp_Pnt_Translated(gp_Pnt * thePnt, gp_Vec * vec){ + return new gp_Pnt(thePnt->Translated(*vec)); +} + +void hs_gp_Pnt_TranslateRelative(gp_Pnt * thePnt, gp_Pnt * from, gp_Pnt * to){ + thePnt->Translate(*from, *to); +} + +gp_Pnt * hs_gp_Pnt_TranslatedRelative(gp_Pnt * thePnt, gp_Pnt * from, gp_Pnt * to){ + return new gp_Pnt(thePnt->Translated(*from, *to)); +} + + + diff --git a/cpp/hs_gp_Pnt2d.cpp b/cpp/hs_gp_Pnt2d.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Pnt2d.cpp @@ -0,0 +1,95 @@ +#include +#include "hs_gp_Pnt2d.h" + +gp_Pnt2d * hs_new_gp_Pnt2d(double x, double y) { + return new gp_Pnt2d(x, y); +} + +void hs_delete_gp_Pnt2d(gp_Pnt2d* pnt){ + delete pnt; +} + +double hs_gp_Pnt2d_X(gp_Pnt2d * pnt){ + return pnt->X(); +} + +double hs_gp_Pnt2d_Y(gp_Pnt2d * pnt){ + return pnt->Y(); +} + +void hs_gp_Pnt2d_SetX(gp_Pnt2d * pnt, double x){ + pnt->SetX(x); +} + +void hs_gp_Pnt2d_SetY(gp_Pnt2d * pnt, double y){ + pnt->SetY(y); +} + +double hs_gp_Pnt2d_Distance(gp_Pnt2d * a, gp_Pnt2d * b ){ + return a->Distance(*b); +} + +double hs_gp_Pnt2d_SquareDistance(gp_Pnt2d * a, gp_Pnt2d * b ){ + return a->SquareDistance(*b); +} + +bool hs_gp_Pnt2d_IsEqual(gp_Pnt2d * a, gp_Pnt2d * b, double tolerance){ + return a->IsEqual(*b, tolerance); +} + +void hs_gp_Pnt2d_Mirror(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis){ + thePnt2d->Mirror(*theAxis); +} + +gp_Pnt2d * hs_gp_Pnt2d_Mirrored(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis){ + return new gp_Pnt2d(thePnt2d->Mirrored(*theAxis)); +} + +void hs_gp_Pnt2d_MirrorAboutAx2d(gp_Pnt2d * thePnt2d, gp_Ax2d * theAxis){ + thePnt2d->Mirror(*theAxis); +} + +gp_Pnt2d * hs_gp_Pnt2d_MirroredAboutAx2d(gp_Pnt2d * thePnt2d, gp_Ax2d * theAxis){ + return new gp_Pnt2d(thePnt2d->Mirrored(*theAxis)); +} + +void hs_gp_Pnt2d_Rotate(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis, double amount){ + thePnt2d->Rotate(*theAxis, amount); +} + +gp_Pnt2d * hs_gp_Pnt2d_Rotated(gp_Pnt2d * thePnt2d, gp_Pnt2d * theAxis, double amount){ + return new gp_Pnt2d(thePnt2d->Rotated(*theAxis, amount)); +} + +void hs_gp_Pnt2d_Scale(gp_Pnt2d * thePnt2d, gp_Pnt2d * origin, double amount){ + thePnt2d->Scale(*origin, amount); +} + +gp_Pnt2d * hs_gp_Pnt2d_Scaled(gp_Pnt2d * thePnt2d, gp_Pnt2d * origin, double amount){ + return new gp_Pnt2d(thePnt2d->Scaled(*origin, amount)); +} + +void hs_gp_Pnt2d_Transform(gp_Pnt2d * thePnt2d, gp_Trsf2d * trsf){ + thePnt2d->Transform(*trsf); +} + +gp_Pnt2d * hs_gp_Pnt2d_Transformed(gp_Pnt2d * thePnt2d, gp_Trsf2d * trsf){ + return new gp_Pnt2d(thePnt2d->Transformed(*trsf)); +} + +void hs_gp_Pnt2d_Translate(gp_Pnt2d * thePnt2d, gp_Vec2d * vec){ + thePnt2d->Translate(*vec); +} + +gp_Pnt2d * hs_gp_Pnt2d_Translated(gp_Pnt2d * thePnt2d, gp_Vec2d * vec){ + return new gp_Pnt2d(thePnt2d->Translated(*vec)); +} + +void hs_gp_Pnt2d_TranslateRelative(gp_Pnt2d * thePnt2d, gp_Pnt2d * from, gp_Pnt2d * to){ + thePnt2d->Translate(*from, *to); +} + +gp_Pnt2d * hs_gp_Pnt2d_TranslatedRelative(gp_Pnt2d * thePnt2d, gp_Pnt2d * from, gp_Pnt2d * to){ + return new gp_Pnt2d(thePnt2d->Translated(*from, *to)); +} + diff --git a/cpp/hs_gp_Trsf.cpp b/cpp/hs_gp_Trsf.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Trsf.cpp @@ -0,0 +1,98 @@ +#include +#include "hs_gp_Trsf.h" + +gp_Trsf * hs_new_gp_Trsf(){ + return new gp_Trsf(); +} + +void hs_delete_gp_Trsf(gp_Trsf * t){ + delete t; +} + +gp_Trsf * hs_new_gp_Trsf_fromTrsf2d(gp_Trsf2d * t){ + return new gp_Trsf(*t); +} + +void hs_gp_Trsf_SetMirrorAboutPnt(gp_Trsf * trsf, gp_Pnt * pnt){ + trsf->SetMirror(*pnt); +} + +void hs_gp_Trsf_SetMirrorAboutAx1(gp_Trsf * trsf, gp_Ax1 * ax){ + trsf->SetMirror(*ax); +} + +void hs_gp_Trsf_SetMirrorAboutAx2(gp_Trsf * trsf, gp_Ax2 * ax){ + trsf->SetMirror(*ax); +} + +void hs_gp_Trsf_SetRotationAboutAxisAngle(gp_Trsf * trsf, gp_Ax1 * ax, double angle){ + trsf->SetRotation(*ax, angle); +} + +void hs_gp_Trsf_SetScale(gp_Trsf * trsf, gp_Pnt * origin, double factor){ + trsf->SetScale(*origin, factor); +} + +void hs_gp_Trsf_SetTranslation(gp_Trsf * trsf, gp_Vec * trans){ + trsf->SetTranslation(*trans); +} + +void hs_gp_Trsf_SetTranslationPart(gp_Trsf * trsf, gp_Vec * trans){ + trsf->SetTranslationPart(*trans); +} + +void hs_gp_Trsf_SetScaleFactor(gp_Trsf * trsf, double s){ + trsf->SetScaleFactor(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){ + trsf->SetValues( + a11, a12, a13, a14, + a21, a22, a23, a24, + a31, a32, a33, a34 + ); +} + +bool hs_gp_Trsf_IsNegative(gp_Trsf * trsf){ + return trsf->IsNegative(); +} + +double hs_gp_Trsf_ScaleFactor(gp_Trsf * trsf){ + return trsf->ScaleFactor(); +} + +double hs_gp_Trsf_Value(gp_Trsf* trsf, int row, int col){ + return trsf->Value(row, col); +} + +void hs_gp_Trsf_Invert(gp_Trsf* trsf){ + trsf->Invert(); +} + +gp_Trsf * hs_gp_Trsf_Inverted(gp_Trsf* trsf){ + return new gp_Trsf(trsf->Inverted()); +} + +void hs_gp_Trsf_Multiply(gp_Trsf * trsf, gp_Trsf* b){ + trsf->Multiply(*b); +} + +gp_Trsf * hs_gp_Trsf_Multiplied(gp_Trsf* a, gp_Trsf* b){ + return new gp_Trsf(a->Multiplied(*b)); +} + +void hs_gp_Trsf_PreMultiply(gp_Trsf * trsf, gp_Trsf* b){ + trsf->PreMultiply(*b); +} + +void hs_gp_Trsf_Power(gp_Trsf * trsf, int b){ + trsf->Power(b); +} + +gp_Trsf * hs_gp_Trsf_Powered(gp_Trsf* a, int b){ + return new gp_Trsf(a->Powered(b)); +} + diff --git a/cpp/hs_gp_Trsf2d.cpp b/cpp/hs_gp_Trsf2d.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Trsf2d.cpp @@ -0,0 +1,104 @@ +#include +#include "hs_gp_Trsf2d.h" + +gp_Trsf2d * hs_new_gp_Trsf2d(){ + return new gp_Trsf2d(); +} + +void hs_delete_gp_Trsf2d(gp_Trsf2d * t){ + delete t; +} + +gp_Trsf2d * hs_new_gp_Trsf2d_fromTrsf(gp_Trsf * t){ + return new gp_Trsf2d(*t); +} + +void hs_gp_Trsf2d_SetMirrorAboutPnt2d(gp_Trsf2d * trsf, gp_Pnt2d * pnt){ + trsf->SetMirror(*pnt); +} + +void hs_gp_Trsf2d_SetMirrorAboutAx2d(gp_Trsf2d * trsf, gp_Ax2d * ax){ + trsf->SetMirror(*ax); +} + +void hs_gp_Trsf2d_SetRotation(gp_Trsf2d * trsf, gp_Pnt2d * ax, double angle){ + trsf->SetRotation(*ax, angle); +} + +void hs_gp_Trsf2d_SetScale(gp_Trsf2d * trsf, gp_Pnt2d * origin, double factor){ + trsf->SetScale(*origin, factor); +} + +void hs_gp_Trsf2d_SetTransformation(gp_Trsf2d * trsf, gp_Ax2d * to){ + trsf->SetTransformation(*to); +} + +void hs_gp_Trsf2d_SetTransformationRelative(gp_Trsf2d * trsf, gp_Ax2d * from, gp_Ax2d * to){ + trsf->SetTransformation(*from, *to); +} + +void hs_gp_Trsf2d_SetTranslation(gp_Trsf2d * trsf, gp_Vec2d * trans){ + trsf->SetTranslation(*trans); +} + +void hs_gp_Trsf2d_SetTranslationRelative(gp_Trsf2d * trsf, gp_Pnt2d * from, gp_Pnt2d * to){ + trsf->SetTranslation(*from, *to); +} + +void hs_gp_Trsf2d_SetTranslationPart(gp_Trsf2d * trsf, gp_Vec2d * trans){ + trsf->SetTranslationPart(*trans); +} + +void hs_gp_Trsf2d_SetScaleFactor(gp_Trsf2d * trsf, double s){ + trsf->SetScaleFactor(s); +} + +void hs_gp_Trsf2d_SetValues(gp_Trsf2d * trsf, + double a11, double a12, double a13, + double a21, double a22, double a23){ + trsf->SetValues( + a11, a12, a13, + a21, a22, a23 + ); +} + +bool hs_gp_Trsf2d_IsNegative(gp_Trsf2d * trsf){ + return trsf->IsNegative(); +} + +double hs_gp_Trsf2d_ScaleFactor(gp_Trsf2d * trsf){ + return trsf->ScaleFactor(); +} + +double hs_gp_Trsf2d_Value(gp_Trsf2d* trsf, int row, int col){ + return trsf->Value(row, col); +} + +void hs_gp_Trsf2d_Invert(gp_Trsf2d* trsf){ + trsf->Invert(); +} + +gp_Trsf2d * hs_gp_Trsf2d_Inverted(gp_Trsf2d* trsf){ + return new gp_Trsf2d(trsf->Inverted()); +} + +void hs_gp_Trsf2d_Multiply(gp_Trsf2d * trsf, gp_Trsf2d* b){ + trsf->Multiply(*b); +} + +gp_Trsf2d * hs_gp_Trsf2d_Multiplied(gp_Trsf2d* a, gp_Trsf2d* b){ + return new gp_Trsf2d(a->Multiplied(*b)); +} + +void hs_gp_Trsf2d_PreMultiply(gp_Trsf2d * trsf, gp_Trsf2d* b){ + trsf->PreMultiply(*b); +} + +void hs_gp_Trsf2d_Power(gp_Trsf2d * trsf, int b){ + trsf->Power(b); +} + +gp_Trsf2d * hs_gp_Trsf2d_Powered(gp_Trsf2d* a, int b){ + return new gp_Trsf2d(a->Powered(b)); +} + diff --git a/cpp/hs_gp_Vec.cpp b/cpp/hs_gp_Vec.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Vec.cpp @@ -0,0 +1,197 @@ +#include +#include "hs_gp_Vec.h" + +gp_Vec * hs_new_gp_Vec(double x, double y, double z) { + return new gp_Vec(x, y, z); +} + +void hs_delete_gp_Vec(gp_Vec* vec){ + delete vec; +} + + +double hs_gp_Vec_X(gp_Vec * vec){ + return vec->X(); +} + +double hs_gp_Vec_Y(gp_Vec * vec){ + return vec->Y(); +} + +double hs_gp_Vec_Z(gp_Vec * vec){ + return vec->Z(); +} + +void hs_gp_Vec_SetX(gp_Vec * vec, double x){ + vec->SetX(x); +} + +void hs_gp_Vec_SetY(gp_Vec * vec, double y){ + vec->SetY(y); +} + +void hs_gp_Vec_SetZ(gp_Vec * vec, double z){ + vec->SetZ(z); +} + +bool hs_gp_Vec_IsEqual(gp_Vec * a, gp_Vec * b, double linearTolerance, double angularTolerance){ + return a->IsEqual(*b, linearTolerance, angularTolerance); +} + +bool hs_gp_Vec_IsNormal(gp_Vec * a, gp_Vec * b, double angularTolerance){ + return a->IsNormal(*b, angularTolerance); +} + +bool hs_gp_Vec_IsOpposite(gp_Vec * a, gp_Vec * b, double angularTolerance){ + return a->IsOpposite(*b, angularTolerance); +} + +bool hs_gp_Vec_IsParallel(gp_Vec * a, gp_Vec * b, double angularTolerance){ + return a->IsParallel(*b, angularTolerance); +} + +double hs_gp_Vec_Angle(gp_Vec * a, gp_Vec * b){ + return a->Angle(*b); +} + +double hs_gp_Vec_AngleWithRef(gp_Vec * a, gp_Vec * b, gp_Vec* theVRef){ + return a->AngleWithRef(*b, *theVRef); +} + +double hs_gp_Vec_Magnitude(gp_Vec * a){ + return a->Magnitude(); +} + +double hs_gp_Vec_SquareMagnitude(gp_Vec * a){ + return a->SquareMagnitude(); +} + +void hs_gp_Vec_Add(gp_Vec * a, gp_Vec * b){ + a->Add(*b); +} + +gp_Vec * hs_gp_Vec_Added(gp_Vec * a, gp_Vec * b){ + return new gp_Vec(a->Added(*b)); +} + + +void hs_gp_Vec_Subtract(gp_Vec * a, gp_Vec * b){ + a->Subtract(*b); +} + +gp_Vec * hs_gp_Vec_Subtracted(gp_Vec * a, gp_Vec * b){ + return new gp_Vec(a->Subtracted(*b)); +} + +void hs_gp_Vec_Multiply(gp_Vec * a, double b){ + a->Multiply(b); +} + +gp_Vec * hs_gp_Vec_Multiplied(gp_Vec * a, double b){ + return new gp_Vec(a->Multiplied(b)); +} + + +void hs_gp_Vec_Divide(gp_Vec * a, double b){ + a->Divide(b); +} + +gp_Vec * hs_gp_Vec_Divided(gp_Vec * a, double b){ + return new gp_Vec(a->Divided(b)); +} + +void hs_gp_Vec_Cross(gp_Vec * a, gp_Vec * b){ + a->Cross(*b); +} + +gp_Vec * hs_gp_Vec_Crossed(gp_Vec * a, gp_Vec * b){ + return new gp_Vec(a->Crossed(*b)); +} + +void hs_gp_Vec_CrossCross(gp_Vec * a, gp_Vec * b, gp_Vec * c){ + return a->CrossCross(*b, *c); +} + +double hs_gp_Vec_CrossMagnitude(gp_Vec * a, gp_Vec * b){ + return a->CrossMagnitude(*b); +} + +double hs_gp_Vec_CrossSquareMagnitude(gp_Vec * a, gp_Vec * b){ + return a->CrossSquareMagnitude(*b); +} + +gp_Vec * hs_gp_Vec_CrossCrossed(gp_Vec * a, gp_Vec * b, gp_Vec * c){ + return new gp_Vec(a->CrossCrossed(*b, *c)); +} + +double hs_gp_Vec_Dot(gp_Vec * a, gp_Vec * b){ + return a->Dot(*b); +} + +double hs_gp_Vec_DotCross(gp_Vec * a, gp_Vec * b, gp_Vec * c){ + return a->DotCross(*b, *c); +} + +void hs_gp_Vec_Normalize(gp_Vec * a){ + a->Normalize(); +} + +gp_Vec * hs_gp_Vec_Normalized(gp_Vec * a){ + return new gp_Vec(a->Normalized()); +} + +void hs_gp_Vec_Reverse(gp_Vec* a){ + a->Reverse(); +} + +gp_Vec * hs_gp_Vec_Reversed(gp_Vec* a){ + return new gp_Vec(a->Reversed()); +} + +void hs_gp_Vec_Mirror(gp_Vec * theVec, gp_Vec * theAxis){ + theVec->Mirror(*theAxis); +} + +gp_Vec * hs_gp_Vec_Mirrored(gp_Vec * theVec, gp_Vec * theAxis){ + return new gp_Vec(theVec->Mirrored(*theAxis)); +} + +void hs_gp_Vec_MirrorAboutAx1(gp_Vec * theVec, gp_Ax1 * theAxis){ + theVec->Mirror(*theAxis); +} + +gp_Vec * hs_gp_Vec_MirroredAboutAx1(gp_Vec * theVec, gp_Ax1 * theAxis){ + return new gp_Vec(theVec->Mirrored(*theAxis)); +} + +void hs_gp_Vec_MirrorAboutAx2(gp_Vec * theVec, gp_Ax2 * theAxis){ + theVec->Mirror(*theAxis); +} + +gp_Vec * hs_gp_Vec_MirroredAboutAx2(gp_Vec * theVec, gp_Ax2 * theAxis){ + return new gp_Vec(theVec->Mirrored(*theAxis)); +} + +void hs_gp_Vec_Rotate(gp_Vec * theVec, gp_Ax1 * theAxis, double amount){ + theVec->Rotate(*theAxis, amount); +} + +gp_Vec * hs_gp_Vec_Rotated(gp_Vec * theVec, gp_Ax1 * theAxis, double amount){ + return new gp_Vec(theVec->Rotated(*theAxis, amount)); +} + +void hs_gp_Vec_Scale(gp_Vec * theVec, double s){ + theVec->Scale(s); +} + +gp_Vec * hs_gp_Vec_Scaled(gp_Vec * theVec, double s){ + return new gp_Vec(theVec->Scaled(s)); +} + +void hs_gp_Vec_Transform(gp_Vec * theVec, gp_Trsf * trsf){ + theVec->Transform(*trsf); +} + +gp_Vec * hs_gp_Vec_Transformed(gp_Vec * theVec, gp_Trsf * trsf){ + return new gp_Vec(theVec->Transformed(*trsf)); +} diff --git a/cpp/hs_gp_Vec2d.cpp b/cpp/hs_gp_Vec2d.cpp new file mode 100644 --- /dev/null +++ b/cpp/hs_gp_Vec2d.cpp @@ -0,0 +1,159 @@ +#include +#include "hs_gp_Vec2d.h" + +gp_Vec2d * hs_new_gp_Vec2d(double x, double y) { + return new gp_Vec2d(x, y); +} + +void hs_delete_gp_Vec2d(gp_Vec2d* vec){ + delete vec; +} + +double hs_gp_Vec2d_X(gp_Vec2d * vec){ + return vec->X(); +} + +double hs_gp_Vec2d_Y(gp_Vec2d * vec){ + return vec->Y(); +} + +void hs_gp_Vec2d_SetX(gp_Vec2d * vec, double x){ + vec->SetX(x); +} + +void hs_gp_Vec2d_SetY(gp_Vec2d * vec, double y){ + vec->SetY(y); +} + +bool hs_gp_Vec2d_IsEqual(gp_Vec2d * a, gp_Vec2d * b, double linearTolerance, double angularTolerance){ + return a->IsEqual(*b, linearTolerance, angularTolerance); +} + +bool hs_gp_Vec2d_IsNormal(gp_Vec2d * a, gp_Vec2d * b, double angularTolerance){ + return a->IsNormal(*b, angularTolerance); +} + +bool hs_gp_Vec2d_IsOpposite(gp_Vec2d * a, gp_Vec2d * b, double angularTolerance){ + return a->IsOpposite(*b, angularTolerance); +} + +bool hs_gp_Vec2d_IsParallel(gp_Vec2d * a, gp_Vec2d * b, double angularTolerance){ + return a->IsParallel(*b, angularTolerance); +} + +double hs_gp_Vec2d_Angle(gp_Vec2d * a, gp_Vec2d * b){ + return a->Angle(*b); +} + +double hs_gp_Vec2d_Magnitude(gp_Vec2d * a){ + return a->Magnitude(); +} + +double hs_gp_Vec2d_SquareMagnitude(gp_Vec2d * a){ + return a->SquareMagnitude(); +} + +void hs_gp_Vec2d_Add(gp_Vec2d * a, gp_Vec2d * b){ + a->Add(*b); +} + +gp_Vec2d * hs_gp_Vec2d_Added(gp_Vec2d * a, gp_Vec2d * b){ + return new gp_Vec2d(a->Added(*b)); +} + +void hs_gp_Vec2d_Subtract(gp_Vec2d * a, gp_Vec2d * b){ + a->Subtract(*b); +} + +gp_Vec2d * hs_gp_Vec2d_Subtracted(gp_Vec2d * a, gp_Vec2d * b){ + return new gp_Vec2d(a->Subtracted(*b)); +} + +void hs_gp_Vec2d_Multiply(gp_Vec2d * a, double b){ + a->Multiply(b); +} + +gp_Vec2d * hs_gp_Vec2d_Multiplied(gp_Vec2d * a, double b){ + return new gp_Vec2d(a->Multiplied(b)); +} + + +void hs_gp_Vec2d_Divide(gp_Vec2d * a, double b){ + a->Divide(b); +} + +gp_Vec2d * hs_gp_Vec2d_Divided(gp_Vec2d * a, double b){ + return new gp_Vec2d(a->Divided(b)); +} + +double hs_gp_Vec2d_Crossed(gp_Vec2d * a, gp_Vec2d * b){ + return a->Crossed(*b); +} + +double hs_gp_Vec2d_CrossMagnitude(gp_Vec2d * a, gp_Vec2d * b){ + return a->CrossMagnitude(*b); +} + +double hs_gp_Vec2d_CrossSquareMagnitude(gp_Vec2d * a, gp_Vec2d * b){ + return a->CrossSquareMagnitude(*b); +} + +double hs_gp_Vec2d_Dot(gp_Vec2d * a, gp_Vec2d * b){ + return a->Dot(*b); +} + +void hs_gp_Vec2d_Normalize(gp_Vec2d * a){ + a->Normalize(); +} + +gp_Vec2d * hs_gp_Vec2d_Normalized(gp_Vec2d * a){ + return new gp_Vec2d(a->Normalized()); +} + +void hs_gp_Vec2d_Reverse(gp_Vec2d* a){ + a->Reverse(); +} + +gp_Vec2d * hs_gp_Vec2d_Reversed(gp_Vec2d* a){ + return new gp_Vec2d(a->Reversed()); +} + +void hs_gp_Vec2d_Mirror(gp_Vec2d * theVec2d, gp_Vec2d * theAxis){ + theVec2d->Mirror(*theAxis); +} + +gp_Vec2d * hs_gp_Vec2d_Mirrored(gp_Vec2d * theVec2d, gp_Vec2d * theAxis){ + return new gp_Vec2d(theVec2d->Mirrored(*theAxis)); +} + +void hs_gp_Vec2d_MirrorAboutAx2d(gp_Vec2d * theVec2d, gp_Ax2d * theAxis){ + theVec2d->Mirror(*theAxis); +} + +gp_Vec2d * hs_gp_Vec2d_MirroredAboutAx2d(gp_Vec2d * theVec2d, gp_Ax2d * theAxis){ + return new gp_Vec2d(theVec2d->Mirrored(*theAxis)); +} + +void hs_gp_Vec2d_Rotate(gp_Vec2d * theVec2d, double amount){ + theVec2d->Rotate(amount); +} + +gp_Vec2d * hs_gp_Vec2d_Rotated(gp_Vec2d * theVec2d, double amount){ + return new gp_Vec2d(theVec2d->Rotated(amount)); +} + +void hs_gp_Vec2d_Scale(gp_Vec2d * theVec2d, double s){ + theVec2d->Scale(s); +} + +gp_Vec2d * hs_gp_Vec2d_Scaled(gp_Vec2d * theVec2d, double s){ + return new gp_Vec2d(theVec2d->Scaled(s)); +} + +void hs_gp_Vec2d_Transform(gp_Vec2d * theVec2d, gp_Trsf2d * trsf){ + theVec2d->Transform(*trsf); +} + +gp_Vec2d * hs_gp_Vec2d_Transformed(gp_Vec2d * theVec2d, gp_Trsf2d * trsf){ + return new gp_Vec2d(theVec2d->Transformed(*trsf)); +} diff --git a/opencascade-hs.cabal b/opencascade-hs.cabal new file mode 100644 --- /dev/null +++ b/opencascade-hs.cabal @@ -0,0 +1,222 @@ +cabal-version: 2.2 + +-- This file has been generated from package.yaml by hpack version 0.36.0. +-- +-- see: https://github.com/sol/hpack + +name: opencascade-hs +version: 0.0.0.1 +synopsis: Thin Wrapper for the OpenCASCADE CAD Kernel +description: Please see the README on GitHub at +category: Graphics,FFI +homepage: https://github.com/joe-warren/opencascade-hs#readme +bug-reports: https://github.com/joe-warren/opencascade-hs/issues +author: Joe Warren +maintainer: josephmarkwarren@gmail.com +copyright: 2023 Joe Warren +license: LGPL-2.1-only +license-file: LICENSE +build-type: Simple +extra-source-files: + LICENSE + README.md + CHANGELOG.md + +source-repository head + type: git + location: https://github.com/joe-warren/opencascade-hs + +library + exposed-modules: + OpenCascade.BRep.Tool + OpenCascade.BRepAlgoAPI.Common + OpenCascade.BRepAlgoAPI.Cut + OpenCascade.BRepAlgoAPI.Fuse + OpenCascade.BRepBuilderAPI + OpenCascade.BRepBuilderAPI.FaceError + OpenCascade.BRepBuilderAPI.GTransform + OpenCascade.BRepBuilderAPI.Internal.Destructors + OpenCascade.BRepBuilderAPI.MakeEdge + OpenCascade.BRepBuilderAPI.MakeFace + OpenCascade.BRepBuilderAPI.MakeShape + OpenCascade.BRepBuilderAPI.MakeSolid + OpenCascade.BRepBuilderAPI.MakeWire + OpenCascade.BRepBuilderAPI.Transform + OpenCascade.BRepBuilderAPI.Types + OpenCascade.BRepBuilderAPI.WireError + OpenCascade.BRepFilletAPI + OpenCascade.BRepFilletAPI.Internal.Destructors + OpenCascade.BRepFilletAPI.MakeFillet + OpenCascade.BRepFilletAPI.Types + OpenCascade.BRepMesh + OpenCascade.BRepMesh.IncrementalMesh + OpenCascade.BRepMesh.Internal.Destructors + OpenCascade.BRepMesh.Types + OpenCascade.BRepOffsetAPI + OpenCascade.BRepOffsetAPI.Internal.Destructors + OpenCascade.BRepOffsetAPI.MakePipe + OpenCascade.BRepOffsetAPI.Types + OpenCascade.BRepPrimAPI + OpenCascade.BRepPrimAPI.Internal.Destructors + OpenCascade.BRepPrimAPI.MakeBox + OpenCascade.BRepPrimAPI.MakeCylinder + OpenCascade.BRepPrimAPI.MakePrism + OpenCascade.BRepPrimAPI.MakeRevol + OpenCascade.BRepPrimAPI.MakeSphere + OpenCascade.BRepPrimAPI.Types + OpenCascade.BRepTools + OpenCascade.BRepTools.Internal.Destructors + OpenCascade.BRepTools.Types + OpenCascade.BRepTools.WireExplorer + OpenCascade.GC.MakeArcOfCircle + OpenCascade.GC.MakeSegment + OpenCascade.Geom + OpenCascade.Geom.BezierCurve + OpenCascade.Geom.Curve + OpenCascade.Geom.Internal.Destructors + OpenCascade.Geom.Types + OpenCascade.GP + OpenCascade.GP.Ax1 + OpenCascade.GP.Ax2 + OpenCascade.GP.Ax2d + OpenCascade.GP.Dir + OpenCascade.GP.Dir2d + OpenCascade.GP.GTrsf + OpenCascade.GP.Internal.Destructors + OpenCascade.GP.Pnt + OpenCascade.GP.Pnt2d + OpenCascade.GP.Trsf + OpenCascade.GP.Trsf2d + OpenCascade.GP.Types + OpenCascade.GP.Vec + OpenCascade.GP.Vec2d + OpenCascade.Handle + OpenCascade.IFSelect.ReturnStatus + OpenCascade.Inheritance + OpenCascade.Internal.Bool + OpenCascade.NCollection + OpenCascade.NCollection.Array1 + OpenCascade.NCollection.Internal.Destructors + OpenCascade.NCollection.Types + OpenCascade.STEPControl + OpenCascade.STEPControl.Internal.Destructors + OpenCascade.STEPControl.StepModelType + OpenCascade.STEPControl.Types + OpenCascade.STEPControl.Writer + OpenCascade.StlAPI + OpenCascade.StlAPI.Internal.Destructors + OpenCascade.StlAPI.Types + OpenCascade.StlAPI.Writer + OpenCascade.TopAbs + OpenCascade.TopAbs.Orientation + OpenCascade.TopAbs.ShapeEnum + OpenCascade.TopExp + OpenCascade.TopExp.Explorer + OpenCascade.TopExp.Internal.Destructors + OpenCascade.TopExp.Types + OpenCascade.TopLoc + OpenCascade.TopLoc.Internal.Destructors + OpenCascade.TopLoc.Location + OpenCascade.TopLoc.Types + OpenCascade.TopoDS + OpenCascade.TopoDS.Compound + OpenCascade.TopoDS.CompSolid + OpenCascade.TopoDS.Edge + OpenCascade.TopoDS.Face + OpenCascade.TopoDS.Internal.Destructors + OpenCascade.TopoDS.Shape + OpenCascade.TopoDS.Shell + OpenCascade.TopoDS.Solid + OpenCascade.TopoDS.Types + OpenCascade.TopoDS.Vertex + OpenCascade.TopoDS.Wire + OpenCascade.TopTools + OpenCascade.TopTools.Types + other-modules: + Paths_opencascade_hs + autogen-modules: + Paths_opencascade_hs + hs-source-dirs: + src + ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints + cc-options: -Werror + cxx-options: -std=c++17 + include-dirs: + cpp + /usr/include/opencascade + c-sources: + cpp/hs_BRep_Tool.cpp + cpp/hs_BRepAlgoAPI_Common.cpp + cpp/hs_BRepAlgoAPI_Cut.cpp + cpp/hs_BRepAlgoAPI_Fuse.cpp + cpp/hs_BRepBuilderAPI_GTransform.cpp + cpp/hs_BRepBuilderAPI_MakeEdge.cpp + cpp/hs_BRepBuilderAPI_MakeFace.cpp + cpp/hs_BRepBuilderAPI_MakeShape.cpp + cpp/hs_BRepBuilderAPI_MakeSolid.cpp + cpp/hs_BRepBuilderAPI_MakeWire.cpp + cpp/hs_BRepBuilderAPI_Transform.cpp + cpp/hs_BRepFilletAPI_MakeFillet.cpp + cpp/hs_BRepMesh_IncrementalMesh.cpp + cpp/hs_BRepOffsetAPI_MakePipe.cpp + cpp/hs_BRepPrimAPI_MakeBox.cpp + cpp/hs_BRepPrimAPI_MakeCylinder.cpp + cpp/hs_BRepPrimAPI_MakePrism.cpp + cpp/hs_BRepPrimAPI_MakeRevol.cpp + cpp/hs_BRepPrimAPI_MakeSphere.cpp + cpp/hs_BRepTools_WireExplorer.cpp + cpp/hs_GC_MakeArcOfCircle.cpp + cpp/hs_GC_MakeSegment.cpp + cpp/hs_Geom_BezierCurve.cpp + cpp/hs_Geom_Curve.cpp + cpp/hs_Geom_TrimmedCurve.cpp + cpp/hs_gp.cpp + cpp/hs_gp_Ax1.cpp + cpp/hs_gp_Ax2.cpp + cpp/hs_gp_Ax2d.cpp + cpp/hs_gp_Dir.cpp + cpp/hs_gp_Dir2d.cpp + cpp/hs_gp_GTrsf.cpp + cpp/hs_gp_Pnt.cpp + cpp/hs_gp_Pnt2d.cpp + cpp/hs_gp_Trsf.cpp + cpp/hs_gp_Trsf2d.cpp + cpp/hs_gp_Vec.cpp + cpp/hs_gp_Vec2d.cpp + cpp/hs_NCollection_Array1.cpp + cpp/hs_STEPControl_Writer.cpp + cpp/hs_StlAPI_Writer.cpp + cpp/hs_TopExp_Explorer.cpp + cpp/hs_TopLoc_Location.cpp + cpp/hs_TopoDS_Compound.cpp + cpp/hs_TopoDS_CompSolid.cpp + cpp/hs_TopoDS_Edge.cpp + cpp/hs_TopoDS_Face.cpp + cpp/hs_TopoDS_Shape.cpp + cpp/hs_TopoDS_Shell.cpp + cpp/hs_TopoDS_Solid.cpp + cpp/hs_TopoDS_Vertex.cpp + cpp/hs_TopoDS_Wire.cpp + extra-libraries: + stdc++ + TKGeomBase + TKStd + TKG3d + TKG2d + TKMath + TKernel + TKBRep + TKGeomBase + TKOffset + TKFillet + TKBO + TKPrim + TKTopAlgo + TKSTL + TKSTEP + TKV3d + TKMesh + build-depends: + base >=4.7 && <5 + , resourcet >=1.2 && <1.4 + default-language: Haskell2010 diff --git a/src/OpenCascade/BRep/Tool.hs b/src/OpenCascade/BRep/Tool.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRep/Tool.hs @@ -0,0 +1,32 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRep.Tool +( curve +, curveParamFirst +, curveParamLast +) where + +import qualified OpenCascade.Geom as Geom +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.Handle (Handle) +import OpenCascade.Geom.Internal.Destructors (deleteHandleCurve) +import Foreign.Ptr +import Foreign.C +import Data.Coerce +import Data.Acquire +import qualified Data.Acquire as Data + +foreign import capi unsafe "hs_BRep_Tool.h hs_BRep_Tool_curve" rawCurve :: Ptr (TopoDS.Edge) -> IO(Ptr (Handle Geom.Curve)) + +curve :: Ptr TopoDS.Edge -> Data.Acquire (Ptr (Handle Geom.Curve)) +curve edge = mkAcquire (rawCurve edge) deleteHandleCurve + +foreign import capi unsafe "hs_BRep_Tool.h hs_BRep_Tool_curveParamFirst" rawCurveParamFirst :: Ptr (TopoDS.Edge) -> IO(CDouble) + +curveParamFirst :: Ptr TopoDS.Edge -> IO Double +curveParamFirst = coerce rawCurveParamFirst + +foreign import capi unsafe "hs_BRep_Tool.h hs_BRep_Tool_curveParamLast" rawCurveParamLast :: Ptr (TopoDS.Edge) -> IO(CDouble) + +curveParamLast :: Ptr TopoDS.Edge -> IO Double +curveParamLast = coerce rawCurveParamLast + diff --git a/src/OpenCascade/BRepAlgoAPI/Common.hs b/src/OpenCascade/BRepAlgoAPI/Common.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepAlgoAPI/Common.hs @@ -0,0 +1,15 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepAlgoAPI.Common +( common +) where + +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.TopoDS.Internal.Destructors (deleteShape) +import Foreign.Ptr +import Data.Acquire + + +foreign import capi unsafe "hs_BRepAlgoAPI_Common.h hs_BRepAlgoAPI_Common" rawCommon :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape -> IO (Ptr TopoDS.Shape) + +common :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape -> Acquire (Ptr TopoDS.Shape) +common a b = mkAcquire (rawCommon a b) deleteShape diff --git a/src/OpenCascade/BRepAlgoAPI/Cut.hs b/src/OpenCascade/BRepAlgoAPI/Cut.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepAlgoAPI/Cut.hs @@ -0,0 +1,15 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepAlgoAPI.Cut +( cut +) where + +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.TopoDS.Internal.Destructors (deleteShape) +import Foreign.Ptr +import Data.Acquire + + +foreign import capi unsafe "hs_BRepAlgoAPI_Cut.h hs_BRepAlgoAPI_Cut" rawCut :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape -> IO (Ptr TopoDS.Shape) + +cut :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape -> Acquire (Ptr TopoDS.Shape) +cut a b = mkAcquire (rawCut a b) deleteShape diff --git a/src/OpenCascade/BRepAlgoAPI/Fuse.hs b/src/OpenCascade/BRepAlgoAPI/Fuse.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepAlgoAPI/Fuse.hs @@ -0,0 +1,15 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepAlgoAPI.Fuse +( fuse +) where + +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.TopoDS.Internal.Destructors (deleteShape) +import Foreign.Ptr +import Data.Acquire + + +foreign import capi unsafe "hs_BRepAlgoAPI_Fuse.h hs_BRepAlgoAPI_Fuse" rawFuse :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape -> IO (Ptr TopoDS.Shape) + +fuse :: Ptr TopoDS.Shape -> Ptr TopoDS.Shape -> Acquire (Ptr TopoDS.Shape) +fuse a b = mkAcquire (rawFuse a b) deleteShape diff --git a/src/OpenCascade/BRepBuilderAPI.hs b/src/OpenCascade/BRepBuilderAPI.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI.hs @@ -0,0 +1,5 @@ +module OpenCascade.BRepBuilderAPI +( module OpenCascade.BRepBuilderAPI.Types +) where + +import OpenCascade.BRepBuilderAPI.Types diff --git a/src/OpenCascade/BRepBuilderAPI/FaceError.hs b/src/OpenCascade/BRepBuilderAPI/FaceError.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/FaceError.hs @@ -0,0 +1,6 @@ +module OpenCascade.BRepBuilderAPI.FaceError +( FaceError (..) +) where + +-- order must match the definition of BRepBuilderAPI FaceError +data FaceError = FaceDone | NoFace | NotPlanar | CurveProjectionFailed | ParametersOutOfRange deriving (Eq, Enum) diff --git a/src/OpenCascade/BRepBuilderAPI/GTransform.hs b/src/OpenCascade/BRepBuilderAPI/GTransform.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/GTransform.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepBuilderAPI.GTransform +( gtransform +) where + +import qualified OpenCascade.GP as GP +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.Internal.Bool +import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Acquire + +foreign import capi unsafe "hs_BRepBuilderAPI_GTransform.h hs_BRepBuilderAPI_GTransform_gtransform" rawGTransform :: Ptr TopoDS.Shape -> Ptr GP.GTrsf -> CBool -> IO (Ptr TopoDS.Shape) + +gtransform :: Ptr TopoDS.Shape -> Ptr GP.GTrsf -> Bool -> Acquire (Ptr TopoDS.Shape) +gtransform shape trsf copy = mkAcquire (rawGTransform shape trsf (boolToCBool copy)) TopoDS.Destructors.deleteShape diff --git a/src/OpenCascade/BRepBuilderAPI/Internal/Destructors.hs b/src/OpenCascade/BRepBuilderAPI/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/Internal/Destructors.hs @@ -0,0 +1,12 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepBuilderAPI.Internal.Destructors where + +import OpenCascade.BRepBuilderAPI.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_delete_BRepBuilderAPI_MakeWire" deleteMakeWire :: Ptr MakeWire -> IO () +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_delete_BRepBuilderAPI_MakeFace" deleteMakeFace :: Ptr MakeFace -> IO () +foreign import capi unsafe "hs_BRepBuilderAPI_MakeSolid.h hs_delete_BRepBuilderAPI_MakeSolid" deleteMakeSolid :: Ptr MakeSolid -> IO () + + diff --git a/src/OpenCascade/BRepBuilderAPI/MakeEdge.hs b/src/OpenCascade/BRepBuilderAPI/MakeEdge.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/MakeEdge.hs @@ -0,0 +1,84 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepBuilderAPI.MakeEdge +( fromVertices +, fromPnts +, fromCurve +, fromCurveAndParameters +, fromCurveAndVertices +, fromCurveAndPnts +, fromCurveVerticesAndParameters +, fromCurvePntsAndParameters +) where + +import OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors +import qualified OpenCascade.TopoDS as TopoDS +import qualified OpenCascade.GP as GP +import qualified OpenCascade.Geom as Geom +import OpenCascade.Handle +import OpenCascade.Inheritance +import Foreign.C +import Foreign.Ptr +import Data.Acquire + + +-- fromVertices + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromVertices" rawFromVertices :: Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> IO (Ptr TopoDS.Edge) + +fromVertices :: Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> Acquire (Ptr TopoDS.Edge) +fromVertices start end = mkAcquire (rawFromVertices start end) (TopoDS.Destructors.deleteShape . upcast) + + +-- fromPnts + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromPnts" rawFromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> IO (Ptr TopoDS.Edge) + +fromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr TopoDS.Edge) +fromPnts start end = mkAcquire (rawFromPnts start end) (TopoDS.Destructors.deleteShape . upcast) + + +-- fromCurve + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurve" rawFromCurve :: Ptr (Handle Geom.Curve) -> IO (Ptr TopoDS.Edge) + +fromCurve :: Ptr (Handle Geom.Curve) -> Acquire (Ptr TopoDS.Edge) +fromCurve curve = mkAcquire (rawFromCurve curve) (TopoDS.Destructors.deleteShape . upcast) + +-- fromCurveAndParameters + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurveAndParameters" rawFromCurveAndParameters :: Ptr (Handle Geom.Curve) -> CDouble -> CDouble -> IO (Ptr TopoDS.Edge) + +fromCurveAndParameters :: Ptr (Handle Geom.Curve) -> Double -> Double -> Acquire (Ptr TopoDS.Edge) +fromCurveAndParameters curve p1 p2 = mkAcquire (rawFromCurveAndParameters curve (CDouble p1) (CDouble p2)) (TopoDS.Destructors.deleteShape . upcast) + + +-- fromCurveAndVertices + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurveAndVertices" rawFromCurveAndVertices :: Ptr (Handle Geom.Curve) -> Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> IO (Ptr TopoDS.Edge) + +fromCurveAndVertices :: Ptr (Handle Geom.Curve) -> Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> Acquire (Ptr TopoDS.Edge) +fromCurveAndVertices curve v1 v2 = mkAcquire (rawFromCurveAndVertices curve v1 v2) (TopoDS.Destructors.deleteShape . upcast) + + +-- fromCurveAndPnts + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurveAndPnts" rawFromCurveAndPnts :: Ptr (Handle Geom.Curve) -> Ptr GP.Pnt -> Ptr GP.Pnt -> IO (Ptr TopoDS.Edge) + +fromCurveAndPnts :: Ptr (Handle Geom.Curve) -> Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr TopoDS.Edge) +fromCurveAndPnts curve v1 v2 = mkAcquire (rawFromCurveAndPnts curve v1 v2) (TopoDS.Destructors.deleteShape . upcast) + + +-- fromCurveVerticesAndParameters + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurveVerticesAndParameters" rawFromCurveVerticesAndParameters :: Ptr (Handle Geom.Curve) -> Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> CDouble -> CDouble -> IO (Ptr TopoDS.Edge) + +fromCurveVerticesAndParameters :: Ptr (Handle Geom.Curve) -> Ptr TopoDS.Vertex -> Ptr TopoDS.Vertex -> Double -> Double -> Acquire (Ptr TopoDS.Edge) +fromCurveVerticesAndParameters curve v1 v2 p1 p2 = mkAcquire (rawFromCurveVerticesAndParameters curve v1 v2 (CDouble p1) (CDouble p2)) (TopoDS.Destructors.deleteShape . upcast) + + +-- fromCurvePntsAndParameters + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeEdge.h hs_BRepBuilderAPI_MakeEdge_fromCurvePntsAndParameters" rawFromCurvePntsAndParameters :: Ptr (Handle Geom.Curve) -> Ptr GP.Pnt -> Ptr GP.Pnt -> CDouble -> CDouble -> IO (Ptr TopoDS.Edge) + +fromCurvePntsAndParameters :: Ptr (Handle Geom.Curve) -> Ptr GP.Pnt -> Ptr GP.Pnt -> Double -> Double -> Acquire (Ptr TopoDS.Edge) +fromCurvePntsAndParameters curve v1 v2 p1 p2 = mkAcquire (rawFromCurvePntsAndParameters curve v1 v2 (CDouble p1) (CDouble p2)) (TopoDS.Destructors.deleteShape . upcast) diff --git a/src/OpenCascade/BRepBuilderAPI/MakeFace.hs b/src/OpenCascade/BRepBuilderAPI/MakeFace.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/MakeFace.hs @@ -0,0 +1,93 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepBuilderAPI.MakeFace +( MakeFace +, new +, face +, fromFace +, fromSurface +, fromSurfaceAndBounds +, fromSurfaceAndWire +, fromWire +, add +, isDone +, error +) where + +import Prelude hiding (error) +import OpenCascade.BRepBuilderAPI.Types +import OpenCascade.BRepBuilderAPI.Internal.Destructors +import OpenCascade.Handle +import OpenCascade.Internal.Bool +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.TopoDS.Internal.Destructors (deleteShape) +import OpenCascade.Inheritance (upcast) +import qualified OpenCascade.Geom as Geom +import OpenCascade.BRepBuilderAPI.FaceError (FaceError) +import Foreign.C +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace" rawNew :: IO (Ptr MakeFace) + +new :: Acquire (Ptr MakeFace) +new = mkAcquire rawNew deleteMakeFace + +-- fromFace + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromFace" rawFromFace :: Ptr TopoDS.Face -> IO (Ptr MakeFace) + +fromFace :: Ptr TopoDS.Face -> Acquire (Ptr MakeFace) +fromFace face = mkAcquire (rawFromFace face) deleteMakeFace + +-- fromSurface + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromSurface" rawFromSurface :: Ptr (Handle (Geom.Surface)) -> CDouble -> IO (Ptr MakeFace) + +fromSurface :: Ptr (Handle Geom.Surface) -> Double -> Acquire (Ptr MakeFace) +fromSurface surf tolerance = mkAcquire (rawFromSurface surf (CDouble tolerance)) deleteMakeFace + +-- fromSurfaceAndBounds + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndBounds" rawFromSurfaceAndBounds :: Ptr (Handle (Geom.Surface)) -> CDouble -> CDouble -> CDouble -> CDouble -> CDouble -> IO (Ptr MakeFace) + +fromSurfaceAndBounds :: Ptr (Handle Geom.Surface) -> Double -> Double -> Double -> Double -> Double -> Acquire (Ptr MakeFace) +fromSurfaceAndBounds surf uMin uMax vMin vMax tolerance = mkAcquire (rawFromSurfaceAndBounds surf (CDouble uMin) (CDouble uMax) (CDouble vMin) (CDouble vMax) (CDouble tolerance)) deleteMakeFace + +-- fromSurfaceAndWire +-- +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromSurfaceAndWire" rawFromSurfaceAndWire :: Ptr (Handle (Geom.Surface)) -> Ptr TopoDS.Wire -> CBool -> IO (Ptr MakeFace) + +fromSurfaceAndWire :: Ptr (Handle Geom.Surface) -> Ptr TopoDS.Wire -> Bool -> Acquire (Ptr MakeFace) +fromSurfaceAndWire surf wire inside = mkAcquire (rawFromSurfaceAndWire surf wire (boolToCBool inside)) deleteMakeFace + +-- fromWire + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_new_BRepBuilderAPI_MakeFace_fromWire" rawFromWire :: Ptr TopoDS.Wire -> CBool -> IO (Ptr MakeFace) + +fromWire :: Ptr TopoDS.Wire -> Bool -> Acquire (Ptr MakeFace) +fromWire wire onlyPlane = mkAcquire (rawFromWire wire (boolToCBool onlyPlane)) deleteMakeFace + +-- add +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_BRepBuilderAPI_MakeFace_Add" add :: Ptr MakeFace -> Ptr TopoDS.Wire -> IO () + +-- isDone +-- +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_BRepBuilderAPI_MakeFace_IsDone" rawIsDone :: Ptr MakeFace -> IO (CBool) + +isDone :: Ptr MakeFace -> IO Bool +isDone p = cBoolToBool <$> rawIsDone p + +-- error +-- +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_BRepBuilderAPI_MakeFace_Error" rawError :: Ptr MakeFace -> IO (CInt) + +error :: Ptr MakeFace -> IO FaceError +error p = toEnum . fromIntegral <$> rawError p + + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeFace.h hs_BRepBuilderAPI_MakeFace_Face" rawFace :: Ptr MakeFace -> IO (Ptr TopoDS.Face) + +face :: Ptr MakeFace -> Acquire (Ptr TopoDS.Face) +face builder = mkAcquire (rawFace builder) (deleteShape . upcast) diff --git a/src/OpenCascade/BRepBuilderAPI/MakeShape.hs b/src/OpenCascade/BRepBuilderAPI/MakeShape.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/MakeShape.hs @@ -0,0 +1,18 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepBuilderAPI.MakeShape +( MakeShape +, shape +) where +import OpenCascade.BRepBuilderAPI.Types +import OpenCascade.BRepBuilderAPI.Internal.Destructors +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.Inheritance (upcast) +import OpenCascade.TopoDS.Internal.Destructors (deleteShape) +import Foreign.C +import Foreign.Ptr +import Data.Acquire + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeShape.h hs_BRepBuilderAPI_MakeShape_shape" rawShape :: Ptr MakeShape -> IO (Ptr TopoDS.Shape) + +shape :: Ptr MakeShape -> Acquire (Ptr TopoDS.Shape) +shape builder = mkAcquire (rawShape builder) (deleteShape) diff --git a/src/OpenCascade/BRepBuilderAPI/MakeSolid.hs b/src/OpenCascade/BRepBuilderAPI/MakeSolid.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/MakeSolid.hs @@ -0,0 +1,31 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepBuilderAPI.MakeSolid +( MakeSolid +, new +, add +, solid +) where +import OpenCascade.BRepBuilderAPI.Types +import OpenCascade.BRepBuilderAPI.Internal.Destructors +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.Inheritance (upcast) +import OpenCascade.TopoDS.Internal.Destructors (deleteShape) +import Foreign.C +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeSolid.h hs_new_BRepBuilderAPI_MakeSolid" rawNew :: IO (Ptr MakeSolid) + +new :: Acquire (Ptr MakeSolid) +new = mkAcquire rawNew deleteMakeSolid + +-- add +foreign import capi unsafe "hs_BRepBuilderAPI_MakeSolid.h hs_BRepBuilderAPI_MakeSolid_add" add :: Ptr MakeSolid -> Ptr TopoDS.Shell -> IO () + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeSolid.h hs_BRepBuilderAPI_MakeSolid_solid" rawSolid :: Ptr MakeSolid -> IO (Ptr TopoDS.Solid) + +solid :: Ptr MakeSolid -> Acquire (Ptr TopoDS.Solid) +solid builder = mkAcquire (rawSolid builder) (deleteShape . upcast) + diff --git a/src/OpenCascade/BRepBuilderAPI/MakeWire.hs b/src/OpenCascade/BRepBuilderAPI/MakeWire.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/MakeWire.hs @@ -0,0 +1,66 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepBuilderAPI.MakeWire +( MakeWire +, new +, addEdge +, addWire +, addListOfShape +, wire +, isDone +, error +) where + +import Prelude hiding (error) +import OpenCascade.BRepBuilderAPI.Types +import OpenCascade.BRepBuilderAPI.Internal.Destructors +import OpenCascade.Inheritance +import OpenCascade.Internal.Bool +import qualified OpenCascade.TopoDS as TopoDS +import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors +import qualified OpenCascade.TopTools as TopTools +import OpenCascade.BRepBuilderAPI.WireError (WireError) +import Foreign.C +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_new_BRepBuilderAPI_MakeWire" rawNew :: IO (Ptr MakeWire) + +new :: Acquire (Ptr MakeWire) +new = mkAcquire rawNew deleteMakeWire + +-- addEdge + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_AddEdge" addEdge :: Ptr MakeWire -> Ptr TopoDS.Edge -> IO () + + +-- addWire + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_AddWire" addWire :: Ptr MakeWire -> Ptr TopoDS.Wire -> IO () + + +-- addListOfShape + +foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_AddListOfShape" addListOfShape :: Ptr MakeWire -> Ptr TopTools.ListOfShape -> IO () + +-- wire +-- +foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_Wire" rawWire :: Ptr MakeWire -> IO (Ptr TopoDS.Wire) + +wire :: Ptr MakeWire -> Acquire (Ptr TopoDS.Wire) +wire builder = mkAcquire (rawWire builder) (TopoDS.Destructors.deleteShape . upcast) + +-- isDone +-- +foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_IsDone" rawIsDone :: Ptr MakeWire -> IO (CBool) + +isDone :: Ptr MakeWire -> IO Bool +isDone p = cBoolToBool <$> rawIsDone p + +-- error +-- +foreign import capi unsafe "hs_BRepBuilderAPI_MakeWire.h hs_BRepBuilderAPI_MakeWire_Error" rawError :: Ptr MakeWire -> IO (CInt) + +error :: Ptr MakeWire -> IO WireError +error p = toEnum . fromIntegral <$> rawError p diff --git a/src/OpenCascade/BRepBuilderAPI/Transform.hs b/src/OpenCascade/BRepBuilderAPI/Transform.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/Transform.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepBuilderAPI.Transform +( transform +) where + +import qualified OpenCascade.GP as GP +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.Internal.Bool +import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Acquire + +foreign import capi unsafe "hs_BRepBuilderAPI_Transform.h hs_BRepBuilderAPI_Transform_transform" rawTransform :: Ptr TopoDS.Shape -> Ptr GP.Trsf -> CBool -> IO (Ptr TopoDS.Shape) + +transform :: Ptr TopoDS.Shape -> Ptr GP.Trsf -> Bool -> Acquire (Ptr TopoDS.Shape) +transform shape trsf copy = mkAcquire (rawTransform shape trsf (boolToCBool copy)) TopoDS.Destructors.deleteShape diff --git a/src/OpenCascade/BRepBuilderAPI/Types.hs b/src/OpenCascade/BRepBuilderAPI/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/Types.hs @@ -0,0 +1,16 @@ +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.BRepBuilderAPI.Types where + +import qualified OpenCascade.Inheritance as Inheritance + +data MakeWire +data MakeFace +data MakeSolid + +data MakeShape + +instance Inheritance.SubTypeOf MakeShape MakeWire +instance Inheritance.SubTypeOf MakeShape MakeSolid +instance Inheritance.SubTypeOf MakeShape MakeFace + diff --git a/src/OpenCascade/BRepBuilderAPI/WireError.hs b/src/OpenCascade/BRepBuilderAPI/WireError.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepBuilderAPI/WireError.hs @@ -0,0 +1,6 @@ +module OpenCascade.BRepBuilderAPI.WireError +( WireError (..) +) where + +-- order must match the definition of BRepBuilderAPI_WireError +data WireError = WireDone | EmptyWire | DisconnectedWire | NonManifoldWire deriving (Eq, Enum) diff --git a/src/OpenCascade/BRepFilletAPI.hs b/src/OpenCascade/BRepFilletAPI.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepFilletAPI.hs @@ -0,0 +1,5 @@ +module OpenCascade.BRepFilletAPI +( module OpenCascade.BRepFilletAPI.Types +) where + +import OpenCascade.BRepFilletAPI.Types diff --git a/src/OpenCascade/BRepFilletAPI/Internal/Destructors.hs b/src/OpenCascade/BRepFilletAPI/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepFilletAPI/Internal/Destructors.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepFilletAPI.Internal.Destructors where + +import OpenCascade.BRepFilletAPI.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_delete_BRepFilletAPI_MakeFillet" deleteMakeFillet :: Ptr MakeFillet -> IO () + + diff --git a/src/OpenCascade/BRepFilletAPI/MakeFillet.hs b/src/OpenCascade/BRepFilletAPI/MakeFillet.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepFilletAPI/MakeFillet.hs @@ -0,0 +1,34 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepFilletAPI.MakeFillet +( MakeFillet +, fromShape +, addEdge +, addEdgeWithRadius +, addEdgeWithTwoRadiuses +) where + +import OpenCascade.BRepFilletAPI.Types (MakeFillet) +import OpenCascade.BRepFilletAPI.Internal.Destructors (deleteMakeFillet) +import qualified OpenCascade.TopoDS as TopoDS +import Foreign.Ptr +import Foreign.C +import Data.Acquire +import Data.Coerce (coerce) + +foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_new_BRepFilletAPI_MakeFillet_fromShape" rawFromShape :: Ptr TopoDS.Shape -> IO (Ptr MakeFillet) + +fromShape :: Ptr TopoDS.Shape -> Acquire (Ptr MakeFillet) +fromShape shape = mkAcquire (rawFromShape shape) deleteMakeFillet + +foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_BRepFilletAPI_MakeFillet_addEdge" addEdge :: Ptr MakeFillet -> Ptr TopoDS.Edge -> IO () + +foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_BRepFilletAPI_MakeFillet_addEdgeWithRadius" rawAddEdgeWithRadius :: Ptr MakeFillet -> CDouble -> Ptr TopoDS.Edge -> IO () + +addEdgeWithRadius :: Ptr MakeFillet -> Double -> Ptr TopoDS.Edge -> IO () +addEdgeWithRadius = coerce rawAddEdgeWithRadius + + +foreign import capi unsafe "hs_BRepFilletAPI_MakeFillet.h hs_BRepFilletAPI_MakeFillet_addEdgeWithTwoRadiuses" rawAddEdgeWithTwoRadiuses :: Ptr MakeFillet -> CDouble -> CDouble -> Ptr TopoDS.Edge -> IO () + +addEdgeWithTwoRadiuses :: Ptr MakeFillet -> Double -> Double -> Ptr TopoDS.Edge -> IO () +addEdgeWithTwoRadiuses = coerce rawAddEdgeWithTwoRadiuses diff --git a/src/OpenCascade/BRepFilletAPI/Types.hs b/src/OpenCascade/BRepFilletAPI/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepFilletAPI/Types.hs @@ -0,0 +1,12 @@ +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.BRepFilletAPI.Types +( MakeFillet +) where + +import qualified OpenCascade.Inheritance as Inheritance +import OpenCascade.BRepBuilderAPI.MakeShape (MakeShape) + +data MakeFillet + +instance Inheritance.SubTypeOf MakeShape MakeFillet diff --git a/src/OpenCascade/BRepMesh.hs b/src/OpenCascade/BRepMesh.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepMesh.hs @@ -0,0 +1,5 @@ +module OpenCascade.BRepMesh +( module OpenCascade.BRepMesh.Types +) where + +import OpenCascade.BRepMesh.Types diff --git a/src/OpenCascade/BRepMesh/IncrementalMesh.hs b/src/OpenCascade/BRepMesh/IncrementalMesh.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepMesh/IncrementalMesh.hs @@ -0,0 +1,20 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepMesh.IncrementalMesh +( fromShapeAndLinDeflection +, perform +) where + +import OpenCascade.BRepMesh.Types (IncrementalMesh) +import OpenCascade.BRepMesh.Internal.Destructors (deleteIncrementalMesh) +import qualified OpenCascade.TopoDS as TopoDS +import Foreign.Ptr +import Data.Acquire +import Data.Coerce (coerce) + + +foreign import capi unsafe "hs_BRepMesh_IncrementalMesh.h hs_BRepMesh_IncrementalMesh_fromShapeAndLinDeflection" rawFromShapeAndLinDeflection :: Ptr TopoDS.Shape -> Double -> IO (Ptr IncrementalMesh) + +fromShapeAndLinDeflection :: Ptr TopoDS.Shape -> Double -> Acquire (Ptr IncrementalMesh) +fromShapeAndLinDeflection shape linDeflection = mkAcquire (rawFromShapeAndLinDeflection shape (coerce linDeflection)) deleteIncrementalMesh + +foreign import capi unsafe "hs_BRepMesh_IncrementalMesh.h hs_BRepMesh_IncrementalMesh_Perform" perform :: Ptr IncrementalMesh -> IO () diff --git a/src/OpenCascade/BRepMesh/Internal/Destructors.hs b/src/OpenCascade/BRepMesh/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepMesh/Internal/Destructors.hs @@ -0,0 +1,9 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepMesh.Internal.Destructors where + +import OpenCascade.BRepMesh.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_BRepMesh_IncrementalMesh.h hs_delete_BRepMesh_IncrementalMesh" deleteIncrementalMesh :: Ptr IncrementalMesh -> IO () + diff --git a/src/OpenCascade/BRepMesh/Types.hs b/src/OpenCascade/BRepMesh/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepMesh/Types.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.BRepMesh.Types where + +data IncrementalMesh diff --git a/src/OpenCascade/BRepOffsetAPI.hs b/src/OpenCascade/BRepOffsetAPI.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepOffsetAPI.hs @@ -0,0 +1,5 @@ +module OpenCascade.BRepOffsetAPI +( module OpenCascade.BRepOffsetAPI.Types +) where + +import OpenCascade.BRepOffsetAPI.Types diff --git a/src/OpenCascade/BRepOffsetAPI/Internal/Destructors.hs b/src/OpenCascade/BRepOffsetAPI/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepOffsetAPI/Internal/Destructors.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepOffsetAPI.Internal.Destructors where + +import OpenCascade.BRepOffsetAPI.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_BRepOffsetAPI_MakePipe.h hs_delete_BRepOffsetAPI_MakePipe" deleteMakePipe :: Ptr MakePipe -> IO () + + diff --git a/src/OpenCascade/BRepOffsetAPI/MakePipe.hs b/src/OpenCascade/BRepOffsetAPI/MakePipe.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepOffsetAPI/MakePipe.hs @@ -0,0 +1,16 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepOffsetAPI.MakePipe +( MakePipe +, fromWireAndShape +) where + +import OpenCascade.BRepOffsetAPI.Types (MakePipe) +import OpenCascade.BRepOffsetAPI.Internal.Destructors (deleteMakePipe) +import qualified OpenCascade.TopoDS as TopoDS +import Foreign.Ptr +import Data.Acquire + +foreign import capi unsafe "hs_BRepOffsetAPI_MakePipe.h hs_new_BRepOffsetAPI_MakePipe_fromWireAndShape" rawFromWireAndShape :: Ptr TopoDS.Wire -> Ptr TopoDS.Shape -> IO (Ptr MakePipe) + +fromWireAndShape :: Ptr TopoDS.Wire -> Ptr TopoDS.Shape -> Acquire (Ptr MakePipe) +fromWireAndShape wire profile = mkAcquire (rawFromWireAndShape wire profile) deleteMakePipe diff --git a/src/OpenCascade/BRepOffsetAPI/Types.hs b/src/OpenCascade/BRepOffsetAPI/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepOffsetAPI/Types.hs @@ -0,0 +1,12 @@ +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.BRepOffsetAPI.Types +( MakePipe +) where + +import qualified OpenCascade.Inheritance as Inheritance +import OpenCascade.BRepBuilderAPI.MakeShape (MakeShape) + +data MakePipe + +instance Inheritance.SubTypeOf MakeShape MakePipe diff --git a/src/OpenCascade/BRepPrimAPI.hs b/src/OpenCascade/BRepPrimAPI.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepPrimAPI.hs @@ -0,0 +1,5 @@ +module OpenCascade.BRepPrimAPI +( module OpenCascade.BRepPrimAPI.Types +) where + +import OpenCascade.BRepPrimAPI.Types diff --git a/src/OpenCascade/BRepPrimAPI/Internal/Destructors.hs b/src/OpenCascade/BRepPrimAPI/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepPrimAPI/Internal/Destructors.hs @@ -0,0 +1,11 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepPrimAPI.Internal.Destructors where + +import OpenCascade.BRepPrimAPI.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_BRepPrimAPI_MakeBox.h hs_delete_BRepPrimAPI_MakeBox" deleteMakeBox :: Ptr MakeBox -> IO () +foreign import capi unsafe "hs_BRepPrimAPI_MakeRevol.h hs_delete_BRepPrimAPI_MakeRevol" deleteMakeRevol :: Ptr MakeRevol -> IO () + + diff --git a/src/OpenCascade/BRepPrimAPI/MakeBox.hs b/src/OpenCascade/BRepPrimAPI/MakeBox.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepPrimAPI/MakeBox.hs @@ -0,0 +1,39 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepPrimAPI.MakeBox +( fromPnts +, solid +, shell +) where + +import OpenCascade.BRepPrimAPI.Types (MakeBox) +import OpenCascade.BRepPrimAPI.Internal.Destructors (deleteMakeBox) +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.TopoDS.Internal.Destructors (deleteShape) +import qualified OpenCascade.GP as GP +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_BRepPrimAPI_MakeBox.h hs_new_BRepPrimAPI_MakeBox_fromPnts" rawFromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> IO (Ptr MakeBox) + +fromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr MakeBox) +fromPnts a b = mkAcquire (rawFromPnts a b) deleteMakeBox + +-- solid + + +foreign import capi unsafe "hs_BRepPrimAPI_MakeBox.h hs_BRepPrimAPI_MakeBox_Solid" rawSolid :: Ptr MakeBox -> IO (Ptr TopoDS.Solid) + +solid :: Ptr MakeBox -> Acquire (Ptr TopoDS.Solid) +solid builder = mkAcquire (rawSolid builder) (deleteShape . castPtr) + +-- shell + +foreign import capi unsafe "hs_BRepPrimAPI_MakeBox.h hs_BRepPrimAPI_MakeBox_Shell" rawShell :: Ptr MakeBox -> IO (Ptr TopoDS.Shell) + +shell:: Ptr MakeBox -> Acquire (Ptr TopoDS.Shell) +shell builder = mkAcquire (rawShell builder) (deleteShape . castPtr) + + + diff --git a/src/OpenCascade/BRepPrimAPI/MakeCylinder.hs b/src/OpenCascade/BRepPrimAPI/MakeCylinder.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepPrimAPI/MakeCylinder.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepPrimAPI.MakeCylinder +( fromRadiusAndHeight +) where + +import qualified OpenCascade.GP as GP +import qualified OpenCascade.TopoDS as TopoDS +import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Acquire +import Data.Coerce (coerce) + +foreign import capi unsafe "hs_BRepPrimAPI_MakeCylinder.h hs_BRepPrimAPI_MakeCylinder_fromRadiusAndHeight" rawFromRadiusAndHeight :: CDouble -> CDouble -> IO (Ptr TopoDS.Solid) + +fromRadiusAndHeight :: Double -> Double -> Acquire (Ptr TopoDS.Solid) +fromRadiusAndHeight r h = mkAcquire (rawFromRadiusAndHeight (coerce r) (coerce h)) (TopoDS.Destructors.deleteShape . castPtr) diff --git a/src/OpenCascade/BRepPrimAPI/MakePrism.hs b/src/OpenCascade/BRepPrimAPI/MakePrism.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepPrimAPI/MakePrism.hs @@ -0,0 +1,24 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepPrimAPI.MakePrism +( fromVec +, fromDir +) where + +import qualified OpenCascade.GP as GP +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.Internal.Bool +import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Acquire + +foreign import capi unsafe "hs_BRepPrimAPI_MakePrism.h hs_BRepPrimAPI_MakePrism_fromVec" rawFromVec :: Ptr TopoDS.Shape -> Ptr GP.Vec -> CBool -> CBool -> IO (Ptr TopoDS.Shape) + +fromVec :: Ptr TopoDS.Shape -> Ptr GP.Vec -> Bool -> Bool -> Acquire (Ptr TopoDS.Shape) +fromVec shape vec copy canonize = mkAcquire (rawFromVec shape vec (boolToCBool copy) (boolToCBool canonize)) TopoDS.Destructors.deleteShape + + +foreign import capi unsafe "hs_BRepPrimAPI_MakePrism.h hs_BRepPrimAPI_MakePrism_fromDir" rawFromDir :: Ptr TopoDS.Shape -> Ptr GP.Dir -> CBool -> CBool -> CBool -> IO (Ptr TopoDS.Shape) + +fromDir :: Ptr TopoDS.Shape -> Ptr GP.Dir -> Bool -> Bool -> Bool -> Acquire (Ptr TopoDS.Shape) +fromDir shape dir inf copy canonize = mkAcquire (rawFromDir shape dir (boolToCBool inf) (boolToCBool copy) (boolToCBool canonize)) TopoDS.Destructors.deleteShape diff --git a/src/OpenCascade/BRepPrimAPI/MakeRevol.hs b/src/OpenCascade/BRepPrimAPI/MakeRevol.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepPrimAPI/MakeRevol.hs @@ -0,0 +1,20 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepPrimAPI.MakeRevol +( MakeRevol +, fromShapeAndAx1 +) where + +import OpenCascade.BRepPrimAPI.Types (MakeRevol) +import OpenCascade.BRepPrimAPI.Internal.Destructors (deleteMakeRevol) + +import qualified OpenCascade.TopoDS as TopoDS +import qualified OpenCascade.GP as GP +import OpenCascade.Internal.Bool (boolToCBool) +import Foreign.C +import Foreign.Ptr +import Data.Acquire + +foreign import capi unsafe "hs_BRepPrimAPI_MakeRevol.h hs_new_BRepPrimAPI_MakeRevol_fromShapeAndAx1" rawFromShapeAndAx1 :: Ptr TopoDS.Shape -> Ptr GP.Ax1 -> CBool -> IO (Ptr MakeRevol) + +fromShapeAndAx1 :: Ptr TopoDS.Shape -> Ptr GP.Ax1 -> Bool -> Acquire (Ptr MakeRevol) +fromShapeAndAx1 shape axis copy = mkAcquire (rawFromShapeAndAx1 shape axis (boolToCBool copy)) deleteMakeRevol diff --git a/src/OpenCascade/BRepPrimAPI/MakeSphere.hs b/src/OpenCascade/BRepPrimAPI/MakeSphere.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepPrimAPI/MakeSphere.hs @@ -0,0 +1,23 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepPrimAPI.MakeSphere +( fromRadius +, fromPntAndRadius +) where + +import qualified OpenCascade.GP as GP +import qualified OpenCascade.TopoDS as TopoDS +import qualified OpenCascade.TopoDS.Internal.Destructors as TopoDS.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Acquire +import Data.Coerce (coerce) + +foreign import capi unsafe "hs_BRepPrimAPI_MakeSphere.h hs_BRepPrimAPI_MakeSphere_fromRadius" rawFromRadius :: CDouble -> IO (Ptr TopoDS.Solid) + +fromRadius :: Double -> Acquire (Ptr TopoDS.Solid) +fromRadius r = mkAcquire (rawFromRadius (coerce r)) (TopoDS.Destructors.deleteShape . castPtr) + +foreign import capi unsafe "hs_BRepPrimAPI_MakeSphere.h hs_BRepPrimAPI_MakeSphere_fromPntAndRadius" rawFromPntAndRadius :: Ptr GP.Pnt -> CDouble -> IO (Ptr TopoDS.Solid) + +fromPntAndRadius :: Ptr GP.Pnt -> Double -> Acquire (Ptr TopoDS.Solid) +fromPntAndRadius center radius = mkAcquire (rawFromPntAndRadius center (coerce radius)) (TopoDS.Destructors.deleteShape . castPtr) diff --git a/src/OpenCascade/BRepPrimAPI/Types.hs b/src/OpenCascade/BRepPrimAPI/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepPrimAPI/Types.hs @@ -0,0 +1,15 @@ +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.BRepPrimAPI.Types +( MakeBox +, MakeRevol +) where + +import OpenCascade.BRepBuilderAPI.MakeShape +import qualified OpenCascade.Inheritance as Inheritance + +data MakeBox +data MakeRevol + +instance Inheritance.SubTypeOf MakeShape MakeBox +instance Inheritance.SubTypeOf MakeShape MakeRevol diff --git a/src/OpenCascade/BRepTools.hs b/src/OpenCascade/BRepTools.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepTools.hs @@ -0,0 +1,5 @@ +module OpenCascade.BRepTools +( module OpenCascade.BRepTools.Types +) where + +import OpenCascade.BRepTools.Types diff --git a/src/OpenCascade/BRepTools/Internal/Destructors.hs b/src/OpenCascade/BRepTools/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepTools/Internal/Destructors.hs @@ -0,0 +1,8 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepTools.Internal.Destructors where + +import OpenCascade.BRepTools.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_delete_BRepTools_WireExplorer" deleteWireExplorer :: Ptr WireExplorer -> IO () diff --git a/src/OpenCascade/BRepTools/Types.hs b/src/OpenCascade/BRepTools/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepTools/Types.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.BRepTools.Types where + +data WireExplorer diff --git a/src/OpenCascade/BRepTools/WireExplorer.hs b/src/OpenCascade/BRepTools/WireExplorer.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/BRepTools/WireExplorer.hs @@ -0,0 +1,37 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.BRepTools.WireExplorer +( WireExplorer +, fromWire +, more +, next +, current +, orientation +)where + +import qualified OpenCascade.TopoDS as TopoDS +import OpenCascade.BRepTools.Types (WireExplorer) +import OpenCascade.BRepTools.Internal.Destructors (deleteWireExplorer) +import OpenCascade.Internal.Bool (cBoolToBool) +import qualified OpenCascade.TopAbs as TopAbs +import Foreign.Ptr +import Foreign.C +import Data.Acquire +foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_new_BRepTools_WireExplorer_fromWire" rawNew :: Ptr TopoDS.Wire -> IO (Ptr WireExplorer) + +fromWire :: Ptr TopoDS.Wire -> Acquire (Ptr WireExplorer) +fromWire wire = mkAcquire (rawNew wire) deleteWireExplorer + +foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_BRepTools_WireExplorer_more" rawMore :: Ptr WireExplorer -> IO (CBool) + +more :: Ptr WireExplorer -> IO Bool +more = fmap (cBoolToBool) . rawMore + +foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_BRepTools_WireExplorer_next" next :: Ptr WireExplorer -> IO () + +foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_BRepTools_WireExplorer_current" current :: Ptr WireExplorer -> IO (Ptr TopoDS.Edge) + +foreign import capi unsafe "hs_BRepTools_WireExplorer.h hs_BRepTools_WireExplorer_orientation" rawOrientation :: Ptr WireExplorer -> IO (CInt) + +orientation :: Ptr WireExplorer -> IO TopAbs.Orientation +orientation explorer = toEnum . fromIntegral <$> rawOrientation explorer + diff --git a/src/OpenCascade/GC/MakeArcOfCircle.hs b/src/OpenCascade/GC/MakeArcOfCircle.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GC/MakeArcOfCircle.hs @@ -0,0 +1,31 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GC.MakeArcOfCircle +( from3Pnts +, fromPntsAndVec +) where + +import qualified OpenCascade.Geom.Internal.Destructors as Geom.Destructors +import qualified OpenCascade.GP as GP +import qualified OpenCascade.Geom as Geom +import OpenCascade.Handle +import Foreign.Ptr +import Data.Acquire + + +-- from3Pnts + +foreign import capi unsafe "hs_GC_MakeArcOfCircle.h hs_GC_MakeArcOfCircle_from3Pnts" rawFrom3Pnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Ptr GP.Pnt -> IO (Ptr (Handle (Geom.TrimmedCurve))) + +from3Pnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr (Handle Geom.TrimmedCurve)) +from3Pnts start mid end = mkAcquire (rawFrom3Pnts start mid end) Geom.Destructors.deleteHandleTrimmedCurve + + +-- fromPntsAndVec + +foreign import capi unsafe "hs_GC_MakeArcOfCircle.h hs_GC_MakeArcOfCircle_fromPntsAndVec" rawFromPntsAndVec :: Ptr GP.Pnt -> Ptr GP.Vec -> Ptr GP.Pnt -> IO (Ptr (Handle (Geom.TrimmedCurve))) + +fromPntsAndVec :: Ptr GP.Pnt -> Ptr GP.Vec -> Ptr GP.Pnt -> Acquire (Ptr (Handle Geom.TrimmedCurve)) +fromPntsAndVec start dir end = mkAcquire (rawFromPntsAndVec start dir end) Geom.Destructors.deleteHandleTrimmedCurve + + + diff --git a/src/OpenCascade/GC/MakeSegment.hs b/src/OpenCascade/GC/MakeSegment.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GC/MakeSegment.hs @@ -0,0 +1,19 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GC.MakeSegment +( fromPnts +) where + +import qualified OpenCascade.Geom.Internal.Destructors as Geom.Destructors +import qualified OpenCascade.GP as GP +import qualified OpenCascade.Geom as Geom +import OpenCascade.Handle +import Foreign.Ptr +import Data.Acquire + + +-- fromPnts + +foreign import capi unsafe "hs_GC_MakeSegment.h hs_GC_MakeSegment_fromPnts" rawFromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> IO (Ptr (Handle (Geom.TrimmedCurve))) + +fromPnts :: Ptr GP.Pnt -> Ptr GP.Pnt -> Acquire (Ptr (Handle Geom.TrimmedCurve)) +fromPnts start end = mkAcquire (rawFromPnts start end) Geom.Destructors.deleteHandleTrimmedCurve diff --git a/src/OpenCascade/GP.hs b/src/OpenCascade/GP.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP +( origin +, dx +, dy +, dz +, ox +, oy +, oz +, xoy +, yoz +, zox +, origin2d +, dx2d +, dy2d +, ox2d +, oy2d +, module OpenCascade.GP.Types +) where + +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.Ptr +import Data.Acquire + +-- origin + +foreign import capi unsafe "hs_gp.h hs_gp_Origin" rawOrigin :: IO (Ptr Pnt) + +origin :: Acquire (Ptr Pnt) +origin = mkAcquire (rawOrigin) deletePnt + +-- cardinal directions + +foreign import capi unsafe "hs_gp.h hs_gp_DX" rawDX :: IO (Ptr Dir) + +dx :: Acquire (Ptr Dir) +dx = mkAcquire (rawDX) deleteDir + +foreign import capi unsafe "hs_gp.h hs_gp_DY" rawDY :: IO (Ptr Dir) + +dy :: Acquire (Ptr Dir) +dy = mkAcquire (rawDY) deleteDir + + +foreign import capi unsafe "hs_gp.h hs_gp_DZ" rawDZ :: IO (Ptr Dir) + +dz :: Acquire (Ptr Dir) +dz = mkAcquire (rawDZ) deleteDir + +-- cardinal axes + +foreign import capi unsafe "hs_gp.h hs_gp_OX" rawOX :: IO (Ptr Ax1) + +ox :: Acquire (Ptr Ax1) +ox = mkAcquire (rawOX) deleteAx1 + +foreign import capi unsafe "hs_gp.h hs_gp_OY" rawOY :: IO (Ptr Ax1) + +oy :: Acquire (Ptr Ax1) +oy = mkAcquire (rawOY) deleteAx1 + + +foreign import capi unsafe "hs_gp.h hs_gp_OZ" rawOZ :: IO (Ptr Ax1) + +oz :: Acquire (Ptr Ax1) +oz = mkAcquire (rawOZ) deleteAx1 + +-- axes - 2 + +foreign import capi unsafe "hs_gp.h hs_gp_XOY" rawXOY :: IO (Ptr Ax2) + +xoy :: Acquire (Ptr Ax2) +xoy = mkAcquire (rawXOY) deleteAx2 + +foreign import capi unsafe "hs_gp.h hs_gp_YOZ" rawYOZ :: IO (Ptr Ax2) + +yoz :: Acquire (Ptr Ax2) +yoz = mkAcquire (rawYOZ) deleteAx2 + + +foreign import capi unsafe "hs_gp.h hs_gp_ZOX" rawZOX :: IO (Ptr Ax2) + +zox :: Acquire (Ptr Ax2) +zox = mkAcquire (rawZOX) deleteAx2 + +-- origin 2d + +foreign import capi unsafe "hs_gp.h hs_gp_Origin2d" rawOrigin2d :: IO (Ptr Pnt2d) + +origin2d :: Acquire (Ptr Pnt2d) +origin2d = mkAcquire (rawOrigin2d) deletePnt2d + +-- cardinal directions (2d) + +foreign import capi unsafe "hs_gp.h hs_gp_DX2d" rawDX2d :: IO (Ptr Dir2d) + +dx2d :: Acquire (Ptr Dir2d) +dx2d = mkAcquire (rawDX2d) deleteDir2d + +foreign import capi unsafe "hs_gp.h hs_gp_DY2d" rawDY2d :: IO (Ptr Dir2d) + +dy2d :: Acquire (Ptr Dir2d) +dy2d = mkAcquire (rawDY2d) deleteDir2d + +-- cardinal axes (2d) + +foreign import capi unsafe "hs_gp.h hs_gp_OX2d" rawOX2d :: IO (Ptr Ax2d) + +ox2d :: Acquire (Ptr Ax2d) +ox2d = mkAcquire (rawOX2d) deleteAx2d + +foreign import capi unsafe "hs_gp.h hs_gp_OY2d" rawOY2d :: IO (Ptr Ax2d) + +oy2d :: Acquire (Ptr Ax2d) +oy2d = mkAcquire (rawOY2d) deleteAx2d diff --git a/src/OpenCascade/GP/Ax1.hs b/src/OpenCascade/GP/Ax1.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Ax1.hs @@ -0,0 +1,187 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Ax1 +( Ax1 +, new +, location +, direction +, setLocation +, setDirection +, isCoaxial +, isNormal +, isOpposite +, isParallel +, angle +, reverse +, reversed +, mirror +, mirrored +, mirrorAboutPnt +, mirroredAboutPnt +, mirrorAboutAx2 +, mirroredAboutAx2 +, rotate +, rotated +, scale +, scaled +, transform +, transformed +, translate +, translated +, translateRelative +, translatedRelative +) where + +import Prelude hiding (reverse) +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.Ptr +import Foreign.C.Types +import Data.Acquire +import Data.Coerce (coerce) + +-- new and delete + +foreign import capi unsafe "hs_gp_Ax1.h hs_new_gp_Ax1" rawNew :: Ptr Pnt -> Ptr Dir -> IO (Ptr Ax1) + +new :: Ptr Pnt -> Ptr Dir -> Acquire (Ptr Ax1) +new origin dir = mkAcquire (rawNew origin dir) deleteAx1 + +-- getters + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Location" rawLocation :: Ptr Ax1 -> IO (Ptr Pnt) + +location :: Ptr Ax1 -> Acquire (Ptr Pnt) +location ax1 = mkAcquire (rawLocation ax1) deletePnt + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Direction" rawDirection :: Ptr Ax1 -> IO (Ptr Dir) + +direction :: Ptr Ax1 -> Acquire (Ptr Dir) +direction ax1 = mkAcquire (rawDirection ax1) deleteDir + +-- setters + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_SetDirection" setDirection :: Ptr Ax1 -> Ptr Dir -> IO () + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_SetLocation" setLocation :: Ptr Ax1 -> Ptr Pnt -> IO () + +-- tests + +-- isCoaxial + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_IsCoaxial" rawIsCoaxial :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> CDouble -> IO CBool + +isCoaxial :: Ptr Ax1 -> Ptr Ax1 -> Double -> Double -> IO Bool +isCoaxial a b angularTolerance linearTolerance = (/= 0) <$> rawIsCoaxial a b (CDouble angularTolerance) (CDouble linearTolerance) + +-- isNormal + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_IsNormal" rawIsNormal :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO CBool + +isNormal :: Ptr Ax1 -> Ptr Ax1 -> Double -> IO Bool +isNormal a b angularTolerance = (/= 0) <$> rawIsNormal a b (CDouble angularTolerance) + +-- isOpposite + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_IsOpposite" rawIsOpposite :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO CBool + +isOpposite :: Ptr Ax1 -> Ptr Ax1 -> Double -> IO Bool +isOpposite a b angularTolerance = (/= 0) <$> rawIsOpposite a b (CDouble angularTolerance) + +-- isParallel + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_IsParallel" rawIsParallel :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO CBool + +isParallel :: Ptr Ax1 -> Ptr Ax1 -> Double -> IO Bool +isParallel a b angularTolerance = (/= 0) <$> rawIsParallel a b (CDouble angularTolerance) + +-- angle + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Angle" rawAngle :: Ptr Ax1 -> Ptr Ax1 -> IO CDouble + +angle :: Ptr Ax1 -> Ptr Ax1 -> IO Double +angle = coerce rawAngle + +-- reverse/reversed + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Reverse" reverse :: Ptr Ax1 -> IO () + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Reversed" rawReversed :: Ptr Ax1 -> IO (Ptr Ax1) + +reversed :: Ptr Ax1 -> Acquire (Ptr Ax1) +reversed axis = mkAcquire (rawReversed axis) deleteAx1 + +-- mirror/mirrored + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Mirror" mirror :: Ptr Ax1 -> Ptr Ax1 -> IO () + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Mirrored" rawMirrored :: Ptr Ax1 -> Ptr Ax1 -> IO (Ptr Ax1) + +mirrored :: Ptr Ax1 -> Ptr Ax1 -> Acquire (Ptr Ax1) +mirrored axis mirror = mkAcquire (rawMirrored axis mirror) deleteAx1 + + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_MirrorAboutPnt" mirrorAboutPnt :: Ptr Ax1 -> Ptr Pnt -> IO () + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_MirroredAboutPnt" rawMirroredAboutPnt :: Ptr Ax1 -> Ptr Pnt -> IO (Ptr Ax1) + +mirroredAboutPnt :: Ptr Ax1 -> Ptr Pnt -> Acquire (Ptr Ax1) +mirroredAboutPnt axis mirror = mkAcquire (rawMirroredAboutPnt axis mirror) deleteAx1 + + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_MirrorAboutAx2" mirrorAboutAx2 :: Ptr Ax1 -> Ptr Ax2 -> IO () + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_MirroredAboutAx2" rawMirroredAboutAx2 :: Ptr Ax1 -> Ptr Ax2 -> IO (Ptr Ax1) + +mirroredAboutAx2 :: Ptr Ax1 -> Ptr Ax2 -> Acquire (Ptr Ax1) +mirroredAboutAx2 axis mirror = mkAcquire (rawMirroredAboutAx2 axis mirror) deleteAx1 + +-- rotate/rotated + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Rotate" rawRotate :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO () + +rotate :: Ptr Ax1 -> Ptr Ax1 -> Double -> IO () +rotate = coerce rawRotate + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Rotated" rawRotated :: Ptr Ax1 -> Ptr Ax1 -> CDouble -> IO (Ptr Ax1) + +rotated :: Ptr Ax1 -> Ptr Ax1 -> Double -> Acquire (Ptr Ax1) +rotated axis axisOfRotation angle = mkAcquire (rawRotated axis axisOfRotation (CDouble angle)) deleteAx1 + +-- scale/scaled + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Scale" rawScale :: Ptr Ax1 -> Ptr Pnt -> CDouble -> IO () + +scale :: Ptr Ax1 -> Ptr Pnt -> Double -> IO () +scale = coerce rawScale + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Scaled" rawScaled :: Ptr Ax1 -> Ptr Pnt -> CDouble -> IO (Ptr Ax1) + +scaled :: Ptr Ax1 -> Ptr Pnt -> Double -> Acquire (Ptr Ax1) +scaled axis origin amount = mkAcquire (rawScaled axis origin (CDouble amount)) deleteAx1 + +-- transform/transformed + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Transform" transform :: Ptr Ax1 -> Ptr Trsf -> IO () + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Transformed" rawTransformed :: Ptr Ax1 -> Ptr Trsf -> IO (Ptr Ax1) + +transformed :: Ptr Ax1 -> Ptr Trsf -> Acquire (Ptr Ax1) +transformed axis trsf = mkAcquire (rawTransformed axis trsf) deleteAx1 + + +-- translate/translated + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Translate" translate :: Ptr Ax1 -> Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_Translated" rawTranslated :: Ptr Ax1 -> Ptr Vec -> IO (Ptr Ax1) + +translated :: Ptr Ax1 -> Ptr Vec -> Acquire (Ptr Ax1) +translated axis vec = mkAcquire (rawTranslated axis vec) deleteAx1 + + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_TranslateRelative" translateRelative :: Ptr Ax1 -> Ptr Pnt -> Ptr Pnt -> IO () + +foreign import capi unsafe "hs_gp_Ax1.h hs_gp_Ax1_TranslatedRelative" rawTranslatedRelative :: Ptr Ax1 -> Ptr Pnt -> Ptr Pnt -> IO (Ptr Ax1) + +translatedRelative :: Ptr Ax1 -> Ptr Pnt -> Ptr Pnt -> Acquire (Ptr Ax1) +translatedRelative axis from to = mkAcquire (rawTranslatedRelative axis from to) deleteAx1 diff --git a/src/OpenCascade/GP/Ax2.hs b/src/OpenCascade/GP/Ax2.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Ax2.hs @@ -0,0 +1,184 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Ax2 +( Ax2 +, new +, newAutoX +, location +, direction +, xDirection +, yDirection +, axis +, setLocation +, setDirection +, setXDirection +, setYDirection +, setAxis +, isCoplanar +, isCoplanarWithAx1 +, mirror +, mirrored +, mirrorAboutPnt +, mirroredAboutPnt +, mirrorAboutAx1 +, mirroredAboutAx1 +, rotate +, rotated +, scale +, scaled +, transform +, transformed +, translate +, translated +, translateRelative +, translatedRelative +) where + +import Prelude hiding (reverse) +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.Ptr +import Foreign.C.Types +import Data.Acquire +import Data.Coerce (coerce) + +-- new and delete + +foreign import capi unsafe "hs_gp_Ax2.h hs_new_gp_Ax2" rawNew :: Ptr Pnt -> Ptr Dir -> Ptr Dir -> IO (Ptr Ax2) + +new :: Ptr Pnt -> Ptr Dir -> Ptr Dir -> Acquire (Ptr Ax2) +new origin axis vX = mkAcquire (rawNew origin axis vX) deleteAx2 + +foreign import capi unsafe "hs_gp_Ax2.h hs_new_gp_Ax2_autoX" rawNewAutoX :: Ptr Pnt -> Ptr Dir -> IO (Ptr Ax2) + +newAutoX :: Ptr Pnt -> Ptr Dir -> Acquire (Ptr Ax2) +newAutoX origin axis = mkAcquire (rawNewAutoX origin axis) deleteAx2 + + +-- getters + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Location" rawLocation :: Ptr Ax2 -> IO (Ptr Pnt) + +location :: Ptr Ax2 -> Acquire (Ptr Pnt) +location ax2 = mkAcquire (rawLocation ax2) deletePnt + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Direction" rawDirection :: Ptr Ax2 -> IO (Ptr Dir) + +direction :: Ptr Ax2 -> Acquire (Ptr Dir) +direction ax2 = mkAcquire (rawDirection ax2) deleteDir + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_XDirection" rawXDirection :: Ptr Ax2 -> IO (Ptr Dir) + +xDirection :: Ptr Ax2 -> Acquire (Ptr Dir) +xDirection ax2 = mkAcquire (rawXDirection ax2) deleteDir + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_YDirection" rawYDirection :: Ptr Ax2 -> IO (Ptr Dir) + +yDirection :: Ptr Ax2 -> Acquire (Ptr Dir) +yDirection ax2 = mkAcquire (rawYDirection ax2) deleteDir + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Axis" rawAxis :: Ptr Ax2 -> IO (Ptr Ax1) + +axis :: Ptr Ax2 -> Acquire (Ptr Ax1) +axis ax2 = mkAcquire (rawAxis ax2) deleteAx1 + +-- setters + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetDirection" setDirection :: Ptr Ax2 -> Ptr Dir -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetLocation" setLocation :: Ptr Ax2 -> Ptr Pnt -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetXDirection" setXDirection :: Ptr Ax2 -> Ptr Dir -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetYDirection" setYDirection :: Ptr Ax2 -> Ptr Dir -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_SetAxis" setAxis :: Ptr Ax2 -> Ptr Ax1 -> IO () + +-- isCoplanar + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_IsCoplanar" rawIsCoplanar :: Ptr Ax2 -> Ptr Ax2 -> CDouble -> CDouble -> IO CBool + +isCoplanar :: Ptr Ax2 -> Ptr Ax2 -> Double -> Double -> IO Bool +isCoplanar a b linearTolerance angularTolerance = (/= 0) <$> rawIsCoplanar a b (CDouble linearTolerance) (CDouble angularTolerance) + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_IsCoplanarWithAx1" rawIsCoplanarWithAx1 :: Ptr Ax2 -> Ptr Ax1 -> CDouble -> CDouble -> IO CBool + +isCoplanarWithAx1 :: Ptr Ax2 -> Ptr Ax1 -> Double -> Double -> IO Bool +isCoplanarWithAx1 a b linearTolerance angularTolerance = (/= 0) <$> rawIsCoplanarWithAx1 a b (CDouble linearTolerance) (CDouble angularTolerance) + +-- mirror/mirrored + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Mirror" mirror :: Ptr Ax2 -> Ptr Ax2 -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Mirrored" rawMirrored :: Ptr Ax2 -> Ptr Ax2 -> IO (Ptr Ax2) + +mirrored :: Ptr Ax2 -> Ptr Ax2 -> Acquire (Ptr Ax2) +mirrored axis mirror = mkAcquire (rawMirrored axis mirror) deleteAx2 + + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_MirrorAboutPnt" mirrorAboutPnt :: Ptr Ax2 -> Ptr Pnt -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_MirroredAboutPnt" rawMirroredAboutPnt :: Ptr Ax2 -> Ptr Pnt -> IO (Ptr Ax2) + +mirroredAboutPnt :: Ptr Ax2 -> Ptr Pnt -> Acquire (Ptr Ax2) +mirroredAboutPnt axis mirror = mkAcquire (rawMirroredAboutPnt axis mirror) deleteAx2 + + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_MirrorAboutAx1" mirrorAboutAx1 :: Ptr Ax2 -> Ptr Ax1 -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_MirroredAboutAx1" rawMirroredAboutAx1 :: Ptr Ax2 -> Ptr Ax1 -> IO (Ptr Ax2) + +mirroredAboutAx1 :: Ptr Ax2 -> Ptr Ax1 -> Acquire (Ptr Ax2) +mirroredAboutAx1 axis mirror = mkAcquire (rawMirroredAboutAx1 axis mirror) deleteAx2 + + +-- rotate/rotated + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Rotate" rawRotate :: Ptr Ax2 -> Ptr Ax1 -> CDouble -> IO () + +rotate :: Ptr Ax2 -> Ptr Ax1 -> Double -> IO () +rotate = coerce rawRotate + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Rotated" rawRotated :: Ptr Ax2 -> Ptr Ax1 -> CDouble -> IO (Ptr Ax2) + +rotated :: Ptr Ax2 -> Ptr Ax1 -> Double -> Acquire (Ptr Ax2) +rotated axis axisOfRotation angle = mkAcquire (rawRotated axis axisOfRotation (CDouble angle)) deleteAx2 + +-- scale/scaled + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Scale" rawScale :: Ptr Ax2 -> Ptr Pnt -> CDouble -> IO () + +scale :: Ptr Ax2 -> Ptr Pnt -> Double -> IO () +scale = coerce rawScale + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Scaled" rawScaled :: Ptr Ax2 -> Ptr Pnt -> CDouble -> IO (Ptr Ax2) + +scaled :: Ptr Ax2 -> Ptr Pnt -> Double -> Acquire (Ptr Ax2) +scaled axis origin amount = mkAcquire (rawScaled axis origin (CDouble amount)) deleteAx2 + +-- transform/transformed + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Transform" transform :: Ptr Ax2 -> Ptr Trsf -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Transformed" rawTransformed :: Ptr Ax2 -> Ptr Trsf -> IO (Ptr Ax2) + +transformed :: Ptr Ax2 -> Ptr Trsf -> Acquire (Ptr Ax2) +transformed axis trsf = mkAcquire (rawTransformed axis trsf) deleteAx2 + + +-- translate/translated + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Translate" translate :: Ptr Ax2 -> Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_Translated" rawTranslated :: Ptr Ax2 -> Ptr Vec -> IO (Ptr Ax2) + +translated :: Ptr Ax2 -> Ptr Vec -> Acquire (Ptr Ax2) +translated axis vec = mkAcquire (rawTranslated axis vec) deleteAx2 + + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_TranslateRelative" translateRelative :: Ptr Ax2 -> Ptr Pnt -> Ptr Pnt -> IO () + +foreign import capi unsafe "hs_gp_Ax2.h hs_gp_Ax2_TranslatedRelative" rawTranslatedRelative :: Ptr Ax2 -> Ptr Pnt -> Ptr Pnt -> IO (Ptr Ax2) + +translatedRelative :: Ptr Ax2 -> Ptr Pnt -> Ptr Pnt -> Acquire (Ptr Ax2) +translatedRelative axis from to = mkAcquire (rawTranslatedRelative axis from to) deleteAx2 + diff --git a/src/OpenCascade/GP/Ax2d.hs b/src/OpenCascade/GP/Ax2d.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Ax2d.hs @@ -0,0 +1,179 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Ax2d +( Ax2d +, new +, location +, direction +, setLocation +, setDirection +, isCoaxial +, isNormal +, isOpposite +, isParallel +, angle +, reverse +, reversed +, mirror +, mirrored +, mirrorAboutPnt2d +, mirroredAboutPnt2d +, rotate +, rotated +, scale +, scaled +, transform +, transformed +, translate +, translated +, translateRelative +, translatedRelative +) where + +import Prelude hiding (reverse) +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.Ptr +import Foreign.C.Types +import Data.Acquire +import Data.Coerce (coerce) + + +-- new and delete + +foreign import capi unsafe "hs_gp_Ax2d.h hs_new_gp_Ax2d" rawNew :: Ptr Pnt2d -> Ptr Dir2d -> IO (Ptr Ax2d) + +new :: Ptr Pnt2d -> Ptr Dir2d -> Acquire (Ptr Ax2d) +new origin dir = mkAcquire (rawNew origin dir) deleteAx2d + +-- getters + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Location" rawLocation :: Ptr Ax2d -> IO (Ptr Pnt2d) + +location :: Ptr Ax2d -> Acquire (Ptr Pnt2d) +location ax2d = mkAcquire (rawLocation ax2d) deletePnt2d + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Direction" rawDirection :: Ptr Ax2d -> IO (Ptr Dir2d) + +direction :: Ptr Ax2d -> Acquire (Ptr Dir2d) +direction ax2d = mkAcquire (rawDirection ax2d) deleteDir2d + +-- setters + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_SetDirection" setDirection :: Ptr Ax2d -> Ptr Dir2d -> IO () + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_SetLocation" setLocation :: Ptr Ax2d -> Ptr Pnt2d -> IO () + +-- tests + +-- isCoaxial + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_IsCoaxial" rawIsCoaxial :: Ptr Ax2d -> Ptr Ax2d -> CDouble -> CDouble -> IO CBool + +isCoaxial :: Ptr Ax2d -> Ptr Ax2d -> Double -> Double -> IO Bool +isCoaxial a b angularTolerance linearTolerance = (/= 0) <$> rawIsCoaxial a b (CDouble angularTolerance) (CDouble linearTolerance) + +-- isNormal + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_IsNormal" rawIsNormal :: Ptr Ax2d -> Ptr Ax2d -> CDouble -> IO CBool + +isNormal :: Ptr Ax2d -> Ptr Ax2d -> Double -> IO Bool +isNormal a b angularTolerance = (/= 0) <$> rawIsNormal a b (CDouble angularTolerance) + +-- isOpposite + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_IsOpposite" rawIsOpposite :: Ptr Ax2d -> Ptr Ax2d -> CDouble -> IO CBool + +isOpposite :: Ptr Ax2d -> Ptr Ax2d -> Double -> IO Bool +isOpposite a b angularTolerance = (/= 0) <$> rawIsOpposite a b (CDouble angularTolerance) + +-- isParallel + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_IsParallel" rawIsParallel :: Ptr Ax2d -> Ptr Ax2d -> CDouble -> IO CBool + +isParallel :: Ptr Ax2d -> Ptr Ax2d -> Double -> IO Bool +isParallel a b angularTolerance = (/= 0) <$> rawIsParallel a b (CDouble angularTolerance) + +-- angle + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Angle" rawAngle :: Ptr Ax2d -> Ptr Ax2d -> IO CDouble + +angle :: Ptr Ax2d -> Ptr Ax2d -> IO Double +angle = coerce rawAngle + +-- reverse/reversed + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Reverse" reverse :: Ptr Ax2d -> IO () + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Reversed" rawReversed :: Ptr Ax2d -> IO (Ptr Ax2d) + +reversed :: Ptr Ax2d -> Acquire (Ptr Ax2d) +reversed axis = mkAcquire (rawReversed axis) deleteAx2d + +-- mirror/mirrored + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Mirror" mirror :: Ptr Ax2d -> Ptr Ax2d -> IO () + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Mirrored" rawMirrored :: Ptr Ax2d -> Ptr Ax2d -> IO (Ptr Ax2d) + +mirrored :: Ptr Ax2d -> Ptr Ax2d -> Acquire (Ptr Ax2d) +mirrored axis mirror = mkAcquire (rawMirrored axis mirror) deleteAx2d + + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_MirrorAboutPnt2d" mirrorAboutPnt2d :: Ptr Ax2d -> Ptr Pnt2d -> IO () + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_MirroredAboutPnt2d" rawMirroredAboutPnt2d :: Ptr Ax2d -> Ptr Pnt2d -> IO (Ptr Ax2d) + +mirroredAboutPnt2d :: Ptr Ax2d -> Ptr Pnt2d -> Acquire (Ptr Ax2d) +mirroredAboutPnt2d axis mirror = mkAcquire (rawMirroredAboutPnt2d axis mirror) deleteAx2d + +-- rotate/rotated + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Rotate" rawRotate :: Ptr Ax2d -> Ptr Pnt2d -> CDouble -> IO () + +rotate :: Ptr Ax2d -> Ptr Pnt2d -> Double -> IO () +rotate = coerce rawRotate + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Rotated" rawRotated :: Ptr Ax2d -> Ptr Pnt2d -> CDouble -> IO (Ptr Ax2d) + +rotated :: Ptr Ax2d -> Ptr Pnt2d -> Double -> Acquire (Ptr Ax2d) +rotated axis axisOfRotation angle = mkAcquire (rawRotated axis axisOfRotation (CDouble angle)) deleteAx2d + +-- scale/scaled + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Scale" rawScale :: Ptr Ax2d -> Ptr Pnt2d -> CDouble -> IO () + +scale :: Ptr Ax2d -> Ptr Pnt2d -> Double -> IO () +scale = coerce rawScale + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Scaled" rawScaled :: Ptr Ax2d -> Ptr Pnt2d -> CDouble -> IO (Ptr Ax2d) + +scaled :: Ptr Ax2d -> Ptr Pnt2d -> Double -> Acquire (Ptr Ax2d) +scaled axis origin amount = mkAcquire (rawScaled axis origin (CDouble amount)) deleteAx2d + +-- transform/transformed + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Transform" transform :: Ptr Ax2d -> Ptr Trsf2d -> IO () + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Transformed" rawTransformed :: Ptr Ax2d -> Ptr Trsf2d -> IO (Ptr Ax2d) + +transformed :: Ptr Ax2d -> Ptr Trsf2d -> Acquire (Ptr Ax2d) +transformed axis trsf = mkAcquire (rawTransformed axis trsf) deleteAx2d + + +-- translate/translated + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Translate" translate :: Ptr Ax2d -> Ptr Vec2d -> IO () + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_Translated" rawTranslated :: Ptr Ax2d -> Ptr Vec2d -> IO (Ptr Ax2d) + +translated :: Ptr Ax2d -> Ptr Vec2d -> Acquire (Ptr Ax2d) +translated axis vec = mkAcquire (rawTranslated axis vec) deleteAx2d + + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_TranslateRelative" translateRelative :: Ptr Ax2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO () + +foreign import capi unsafe "hs_gp_Ax2d.h hs_gp_Ax2d_TranslatedRelative" rawTranslatedRelative :: Ptr Ax2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO (Ptr Ax2d) + +translatedRelative :: Ptr Ax2d -> Ptr Pnt2d -> Ptr Pnt2d -> Acquire (Ptr Ax2d) +translatedRelative axis from to = mkAcquire (rawTranslatedRelative axis from to) deleteAx2d + diff --git a/src/OpenCascade/GP/Dir.hs b/src/OpenCascade/GP/Dir.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Dir.hs @@ -0,0 +1,218 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Dir +( Dir +, new +, getX +, getY +, getZ +, setX +, setY +, setZ +, isEqual +, isOpposite +, isNormal +, isParallel +, angle +, angleWithRef +, cross +, crossed +, crossCross +, crossCrossed +, dot +, dotCross +, reverse +, reversed +, mirror +, mirrored +, mirrorAboutAx1 +, mirroredAboutAx1 +, mirrorAboutAx2 +, mirroredAboutAx2 +, rotate +, rotated +, transform +, transformed +) where + + +import Prelude hiding (reverse) +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Coerce (coerce) +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_gp_Dir.h hs_new_gp_Dir" rawNew :: CDouble -> CDouble -> CDouble -> IO (Ptr Dir) + +new :: Double -> Double -> Double -> Acquire (Ptr Dir) +new x y z = mkAcquire (rawNew (CDouble x) (CDouble y) (CDouble z)) deleteDir + +-- getters + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_X" rawX :: Ptr Dir -> IO (CDouble) + +getX :: Ptr Dir -> IO Double +getX = coerce rawX + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Y" rawY :: Ptr Dir -> IO (CDouble) + +getY :: Ptr Dir -> IO Double +getY = coerce rawY + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Z" rawZ :: Ptr Dir -> IO (CDouble) + +getZ :: Ptr Dir -> IO Double +getZ = coerce rawZ + +-- setters + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_SetX" rawSetX :: Ptr Dir -> CDouble -> IO () + +setX :: Ptr Dir -> Double -> IO () +setX = coerce rawSetX + + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_SetY" rawSetY :: Ptr Dir -> CDouble -> IO () + +setY :: Ptr Dir -> Double -> IO () +setY = coerce rawSetY + + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_SetZ" rawSetZ :: Ptr Dir -> CDouble -> IO () + +setZ :: Ptr Dir -> Double -> IO () +setZ = coerce rawSetZ + +-- tests + +-- isEqual + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_IsEqual" rawIsEqual :: Ptr Dir -> Ptr Dir -> CDouble -> IO CBool + +isEqual :: Ptr Dir -> Ptr Dir -> Double -> IO Bool +isEqual a b tolerance = (/= 0) <$> rawIsEqual a b (CDouble tolerance) + +-- isNormal + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_IsNormal" rawIsNormal :: Ptr Dir -> Ptr Dir -> CDouble -> IO CBool + +isNormal :: Ptr Dir -> Ptr Dir -> Double -> IO Bool +isNormal a b tolerance = (/= 0) <$> rawIsNormal a b (CDouble tolerance) + + +-- isOpposite + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_IsOpposite" rawIsOpposite :: Ptr Dir -> Ptr Dir -> CDouble -> IO CBool + +isOpposite :: Ptr Dir -> Ptr Dir -> Double -> IO Bool +isOpposite a b tolerance = (/= 0) <$> rawIsOpposite a b (CDouble tolerance) + +-- isParallel + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_IsParallel" rawIsParallel :: Ptr Dir -> Ptr Dir -> CDouble -> IO CBool + +isParallel :: Ptr Dir -> Ptr Dir -> Double -> IO Bool +isParallel a b tolerance = (/= 0) <$> rawIsParallel a b (CDouble tolerance) + +-- angle + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Angle" rawAngle :: Ptr Dir -> Ptr Dir -> IO CDouble + +angle :: Ptr Dir -> Ptr Dir -> IO Double +angle = coerce rawAngle + +-- angleWithRef + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_AngleWithRef" rawAngleWithRef :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO CDouble + +angleWithRef :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO Double +angleWithRef = coerce rawAngleWithRef + +-- cross/crossed + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Cross" cross :: Ptr Dir -> Ptr Dir -> IO () + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Crossed" rawCrossed :: Ptr Dir -> Ptr Dir -> IO (Ptr Dir) + +crossed :: Ptr Dir -> Ptr Dir -> Acquire (Ptr Dir) +crossed a b = mkAcquire (rawCrossed a b) deleteDir + + +-- crossCross/crossCrossed + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_CrossCross" crossCross :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO () + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_CrossCrossed" rawCrossCrossed :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO (Ptr Dir) + +crossCrossed :: Ptr Dir -> Ptr Dir -> Ptr Dir -> Acquire (Ptr Dir) +crossCrossed a b c = mkAcquire (rawCrossCrossed a b c) deleteDir + + +-- dot + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Dot" rawDot :: Ptr Dir -> Ptr Dir -> IO CDouble + +dot :: Ptr Dir -> Ptr Dir -> IO Double +dot = coerce rawDot + + +-- dotCross + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_DotCross" rawDotCross :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO CDouble + +dotCross :: Ptr Dir -> Ptr Dir -> Ptr Dir -> IO Double +dotCross = coerce rawDotCross + + +-- reverse/reversed + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Reverse" reverse :: Ptr Dir -> IO () + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Reversed" rawReversed :: Ptr Dir -> IO (Ptr Dir) + +reversed :: Ptr Dir -> Acquire (Ptr Dir) +reversed axis = mkAcquire (rawReversed axis) deleteDir + +-- mirror/mirrored + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Mirror" mirror :: Ptr Dir -> Ptr Dir -> IO () + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Mirrored" rawMirrored :: Ptr Dir -> Ptr Dir -> IO (Ptr Dir) + +mirrored :: Ptr Dir -> Ptr Dir -> Acquire (Ptr Dir) +mirrored point axis = mkAcquire (rawMirrored point axis) deleteDir + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_MirrorAboutAx1" mirrorAboutAx1 :: Ptr Dir -> Ptr Ax1 -> IO () + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_MirroredAboutAx1" rawMirroredAboutAx1 :: Ptr Dir -> Ptr Ax1 -> IO (Ptr Dir) + +mirroredAboutAx1 :: Ptr Dir -> Ptr Ax1 -> Acquire (Ptr Dir) +mirroredAboutAx1 point axis = mkAcquire (rawMirroredAboutAx1 point axis) deleteDir + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_MirrorAboutAx2" mirrorAboutAx2 :: Ptr Dir -> Ptr Ax2 -> IO () + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_MirroredAboutAx2" rawMirroredAboutAx2 :: Ptr Dir -> Ptr Ax2 -> IO (Ptr Dir) + +mirroredAboutAx2 :: Ptr Dir -> Ptr Ax2 -> Acquire (Ptr Dir) +mirroredAboutAx2 point axis = mkAcquire (rawMirroredAboutAx2 point axis) deleteDir + +-- rotate/rotated + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Rotate" rotate :: Ptr Dir -> Ptr Ax1 -> CDouble-> IO () + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Rotated" rawRotated :: Ptr Dir -> Ptr Ax1 -> CDouble -> IO (Ptr Dir) + +rotated :: Ptr Dir -> Ptr Ax1 -> Double -> Acquire (Ptr Dir) +rotated point axis amount = mkAcquire (rawRotated point axis (CDouble amount)) deleteDir + +-- transform/transformed + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Transform" transform :: Ptr Dir -> Ptr Trsf -> IO () + +foreign import capi unsafe "hs_gp_Dir.h hs_gp_Dir_Transformed" rawTransformed :: Ptr Dir -> Ptr Trsf -> IO (Ptr Dir) + +transformed :: Ptr Dir -> Ptr Trsf -> Acquire (Ptr Dir) +transformed point trsf = mkAcquire (rawTransformed point trsf) deleteDir diff --git a/src/OpenCascade/GP/Dir2d.hs b/src/OpenCascade/GP/Dir2d.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Dir2d.hs @@ -0,0 +1,162 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Dir2d +( Dir2d +, new +, getX +, getY +, setX +, setY +, isEqual +, isOpposite +, isNormal +, isParallel +, angle +, crossed +, dot +, reverse +, reversed +, mirror +, mirrored +, mirrorAboutAx2d +, mirroredAboutAx2d +, rotate +, rotated +, transform +, transformed +) where + + +import Prelude hiding (reverse) +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Coerce (coerce) +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_gp_Dir2d.h hs_new_gp_Dir2d" rawNew :: CDouble -> CDouble -> IO (Ptr Dir2d) + +new :: Double -> Double -> Acquire (Ptr Dir2d) +new x y = mkAcquire (rawNew (CDouble x) (CDouble y)) deleteDir2d + +-- getters + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_X" rawX :: Ptr Dir2d -> IO (CDouble) + +getX :: Ptr Dir2d -> IO Double +getX = coerce rawX + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Y" rawY :: Ptr Dir2d -> IO (CDouble) + +getY :: Ptr Dir2d -> IO Double +getY = coerce rawY + +-- setters + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_SetX" rawSetX :: Ptr Dir2d -> CDouble -> IO () + +setX :: Ptr Dir2d -> Double -> IO () +setX = coerce rawSetX + + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_SetY" rawSetY :: Ptr Dir2d -> CDouble -> IO () + +setY :: Ptr Dir2d -> Double -> IO () +setY = coerce rawSetY + +-- tests + +-- isEqual + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_IsEqual" rawIsEqual :: Ptr Dir2d -> Ptr Dir2d -> CDouble -> IO CBool + +isEqual :: Ptr Dir2d -> Ptr Dir2d -> Double -> IO Bool +isEqual a b tolerance = (/= 0) <$> rawIsEqual a b (CDouble tolerance) + +-- isNormal + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_IsNormal" rawIsNormal :: Ptr Dir2d -> Ptr Dir2d -> CDouble -> IO CBool + +isNormal :: Ptr Dir2d -> Ptr Dir2d -> Double -> IO Bool +isNormal a b tolerance = (/= 0) <$> rawIsNormal a b (CDouble tolerance) + + +-- isOpposite + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_IsOpposite" rawIsOpposite :: Ptr Dir2d -> Ptr Dir2d -> CDouble -> IO CBool + +isOpposite :: Ptr Dir2d -> Ptr Dir2d -> Double -> IO Bool +isOpposite a b tolerance = (/= 0) <$> rawIsOpposite a b (CDouble tolerance) + +-- isParallel + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_IsParallel" rawIsParallel :: Ptr Dir2d -> Ptr Dir2d -> CDouble -> IO CBool + +isParallel :: Ptr Dir2d -> Ptr Dir2d -> Double -> IO Bool +isParallel a b tolerance = (/= 0) <$> rawIsParallel a b (CDouble tolerance) + +-- angle + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Angle" rawAngle :: Ptr Dir2d -> Ptr Dir2d -> IO CDouble + +angle :: Ptr Dir2d -> Ptr Dir2d -> IO Double +angle = coerce rawAngle + +-- crossed + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Crossed" rawCrossed :: Ptr Dir2d -> Ptr Dir2d -> IO CDouble + +crossed :: Ptr Dir2d -> Ptr Dir2d -> IO Double +crossed = coerce rawCrossed + +-- dot + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Dot" rawDot :: Ptr Dir2d -> Ptr Dir2d -> IO CDouble + +dot :: Ptr Dir2d -> Ptr Dir2d -> IO Double +dot = coerce rawDot + +-- reverse/reversed + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Reverse" reverse :: Ptr Dir2d -> IO () + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Reversed" rawReversed :: Ptr Dir2d -> IO (Ptr Dir2d) + +reversed :: Ptr Dir2d -> Acquire (Ptr Dir2d) +reversed axis = mkAcquire (rawReversed axis) deleteDir2d + +-- mirror/mirrored + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Mirror" mirror :: Ptr Dir2d -> Ptr Dir2d -> IO () + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Mirrored" rawMirrored :: Ptr Dir2d -> Ptr Dir2d -> IO (Ptr Dir2d) + +mirrored :: Ptr Dir2d -> Ptr Dir2d -> Acquire (Ptr Dir2d) +mirrored point axis = mkAcquire (rawMirrored point axis) deleteDir2d + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_MirrorAboutAx2d" mirrorAboutAx2d :: Ptr Dir2d -> Ptr Ax2d -> IO () + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_MirroredAboutAx2d" rawMirroredAboutAx2d :: Ptr Dir2d -> Ptr Ax2d -> IO (Ptr Dir2d) + +mirroredAboutAx2d :: Ptr Dir2d -> Ptr Ax2d -> Acquire (Ptr Dir2d) +mirroredAboutAx2d point axis = mkAcquire (rawMirroredAboutAx2d point axis) deleteDir2d + +-- rotate/rotated + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Rotate" rotate :: Ptr Dir2d -> CDouble-> IO () + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Rotated" rawRotated :: Ptr Dir2d -> CDouble -> IO (Ptr Dir2d) + +rotated :: Ptr Dir2d -> Double -> Acquire (Ptr Dir2d) +rotated point amount = mkAcquire (rawRotated point (CDouble amount)) deleteDir2d + +-- transform/transformed + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Transform" transform :: Ptr Dir2d -> Ptr Trsf2d -> IO () + +foreign import capi unsafe "hs_gp_Dir2d.h hs_gp_Dir2d_Transformed" rawTransformed :: Ptr Dir2d -> Ptr Trsf2d -> IO (Ptr Dir2d) + +transformed :: Ptr Dir2d -> Ptr Trsf2d -> Acquire (Ptr Dir2d) +transformed point trsf = mkAcquire (rawTransformed point trsf) deleteDir2d diff --git a/src/OpenCascade/GP/GTrsf.hs b/src/OpenCascade/GP/GTrsf.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/GTrsf.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.GTrsf +( GTrsf +, new +, setValue +, setForm +) where + +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Coerce (coerce) +import Data.Acquire + +foreign import capi unsafe "hs_gp_GTrsf.h hs_new_gp_GTrsf" rawNew ::IO (Ptr GTrsf) + +new :: Acquire (Ptr GTrsf) +new = mkAcquire rawNew deleteGTrsf + +foreign import capi unsafe "hs_gp_GTrsf.h hs_gp_GTrsf_setValue" rawSetValue :: Ptr GTrsf -> CInt -> CInt -> CDouble -> IO () + +setValue :: Ptr GTrsf -> Int -> Int -> Double -> IO () +setValue trsf row column value = rawSetValue trsf (fromIntegral row) (fromIntegral column) (coerce value) + +foreign import capi unsafe "hs_gp_GTrsf.h hs_gp_GTrsf_setForm" setForm :: Ptr GTrsf -> IO () diff --git a/src/OpenCascade/GP/Internal/Destructors.hs b/src/OpenCascade/GP/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Internal/Destructors.hs @@ -0,0 +1,20 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Internal.Destructors where + +import OpenCascade.GP.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_gp_Pnt.h hs_delete_gp_Pnt" deletePnt :: Ptr Pnt -> IO () +foreign import capi unsafe "hs_gp_Pnt2d.h hs_delete_gp_Pnt2d" deletePnt2d :: Ptr Pnt2d -> IO () +foreign import capi unsafe "hs_gp_Ax1.h hs_delete_gp_Ax1" deleteAx1 :: Ptr Ax1 -> IO () +foreign import capi unsafe "hs_gp_Ax2.h hs_delete_gp_Ax2" deleteAx2 :: Ptr Ax2 -> IO () +foreign import capi unsafe "hs_gp_Ax2.h hs_delete_gp_Ax2" deleteAx2d :: Ptr Ax2d -> IO () +foreign import capi unsafe "hs_gp_Dir.h hs_delete_gp_Dir" deleteDir :: Ptr Dir -> IO () +foreign import capi unsafe "hs_gp_Dir2d.h hs_delete_gp_Dir2d" deleteDir2d :: Ptr Dir2d -> IO () +foreign import capi unsafe "hs_gp_Vec.h hs_delete_gp_Vec" deleteVec :: Ptr Vec -> IO () +foreign import capi unsafe "hs_gp_Vec2d.h hs_delete_gp_Vec2d" deleteVec2d :: Ptr Vec2d -> IO () +foreign import capi unsafe "hs_gp_Trsf.h hs_delete_gp_Trsf" deleteTrsf :: Ptr Trsf -> IO () +foreign import capi unsafe "hs_gp_GTrsf.h hs_delete_gp_GTrsf" deleteGTrsf :: Ptr GTrsf -> IO () +foreign import capi unsafe "hs_gp_Trsf2d.h hs_delete_gp_Trsf2d" deleteTrsf2d :: Ptr Trsf2d -> IO () + diff --git a/src/OpenCascade/GP/Pnt.hs b/src/OpenCascade/GP/Pnt.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Pnt.hs @@ -0,0 +1,178 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Pnt +( Pnt +, new +, getX +, getY +, getZ +, setX +, setY +, setZ +, distance +, squareDistance +, baryCenter +, isEqual +, mirror +, mirrored +, mirrorAboutAx1 +, mirroredAboutAx1 +, mirrorAboutAx2 +, mirroredAboutAx2 +, rotate +, rotated +, scale +, scaled +, transform +, transformed +, translate +, translated +, translateRelative +, translatedRelative +) where + +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Coerce (coerce) +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_gp_Pnt.h hs_new_gp_Pnt" rawNew :: CDouble -> CDouble -> CDouble -> IO (Ptr Pnt) + +new :: Double -> Double -> Double -> Acquire (Ptr Pnt) +new x y z = mkAcquire (rawNew (CDouble x) (CDouble y) (CDouble z)) deletePnt + +-- getters + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_X" rawX :: Ptr Pnt -> IO (CDouble) + +getX :: Ptr Pnt -> IO Double +getX = coerce rawX + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Y" rawY :: Ptr Pnt -> IO (CDouble) + +getY :: Ptr Pnt -> IO Double +getY = coerce rawY + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Z" rawZ :: Ptr Pnt -> IO (CDouble) + +getZ :: Ptr Pnt -> IO Double +getZ = coerce rawZ + +-- setters + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_SetX" rawSetX :: Ptr Pnt -> CDouble -> IO () + +setX :: Ptr Pnt -> Double -> IO () +setX = coerce rawSetX + + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_SetY" rawSetY :: Ptr Pnt -> CDouble -> IO () + +setY :: Ptr Pnt -> Double -> IO () +setY = coerce rawSetY + + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_SetZ" rawSetZ :: Ptr Pnt -> CDouble -> IO () + +setZ :: Ptr Pnt -> Double -> IO () +setZ = coerce rawSetZ + + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Distance" rawDistance :: Ptr Pnt -> Ptr Pnt -> IO CDouble + + +-- distance and quadrance + +distance :: Ptr Pnt -> Ptr Pnt -> IO Double +distance = coerce rawDistance + + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_SquareDistance" rawSquareDistance :: Ptr Pnt -> Ptr Pnt -> IO CDouble + +squareDistance :: Ptr Pnt -> Ptr Pnt -> IO Double +squareDistance = coerce rawSquareDistance + +-- baryCenter + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_BaryCenter" rawBaryCenter :: Ptr Pnt -> CDouble -> Ptr Pnt -> CDouble -> IO () + +baryCenter :: Ptr Pnt -> Double -> Ptr Pnt -> Double -> IO () +baryCenter = coerce rawBaryCenter + +-- isEqual + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_IsEqual" rawIsEqual :: Ptr Pnt -> Ptr Pnt -> CDouble -> IO CBool + +isEqual :: Ptr Pnt -> Ptr Pnt -> Double -> IO Bool +isEqual a b tolerance = (/= 0) <$> rawIsEqual a b (CDouble tolerance) + +-- mirror/mirrored + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Mirror" mirror :: Ptr Pnt -> Ptr Pnt -> IO () + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Mirrored" rawMirrored :: Ptr Pnt -> Ptr Pnt -> IO (Ptr Pnt) + +mirrored :: Ptr Pnt -> Ptr Pnt -> Acquire (Ptr Pnt) +mirrored point axis = mkAcquire (rawMirrored point axis) deletePnt + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_MirrorAboutAx1" mirrorAboutAx1 :: Ptr Pnt -> Ptr Ax1 -> IO () + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_MirroredAboutAx1" rawMirroredAboutAx1 :: Ptr Pnt -> Ptr Ax1 -> IO (Ptr Pnt) + +mirroredAboutAx1 :: Ptr Pnt -> Ptr Ax1 -> Acquire (Ptr Pnt) +mirroredAboutAx1 point axis = mkAcquire (rawMirroredAboutAx1 point axis) deletePnt + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_MirrorAboutAx2" mirrorAboutAx2 :: Ptr Pnt -> Ptr Ax2 -> IO () + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_MirroredAboutAx2" rawMirroredAboutAx2 :: Ptr Pnt -> Ptr Ax2 -> IO (Ptr Pnt) + +mirroredAboutAx2 :: Ptr Pnt -> Ptr Ax2 -> Acquire (Ptr Pnt) +mirroredAboutAx2 point axis = mkAcquire (rawMirroredAboutAx2 point axis) deletePnt + +-- rotate/rotated + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Rotate" rotate :: Ptr Pnt -> Ptr Ax1 -> CDouble-> IO () + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Rotated" rawRotated :: Ptr Pnt -> Ptr Ax1 -> CDouble -> IO (Ptr Pnt) + +rotated :: Ptr Pnt -> Ptr Ax1 -> Double -> Acquire (Ptr Pnt) +rotated point axis amount = mkAcquire (rawRotated point axis (CDouble amount)) deletePnt + +-- scale/scaled + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Scale" scale :: Ptr Pnt -> Ptr Pnt -> CDouble-> IO () + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Scaled" rawScaled :: Ptr Pnt -> Ptr Pnt -> CDouble -> IO (Ptr Pnt) + +scaled :: Ptr Pnt -> Ptr Pnt -> Double -> Acquire (Ptr Pnt) +scaled point origin amount = mkAcquire (rawScaled point origin (CDouble amount)) deletePnt + +-- transform/transformed + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Transform" transform :: Ptr Pnt -> Ptr Trsf -> IO () + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Transformed" rawTransformed :: Ptr Pnt -> Ptr Trsf -> IO (Ptr Pnt) + +transformed :: Ptr Pnt -> Ptr Trsf -> Acquire (Ptr Pnt) +transformed point trsf = mkAcquire (rawTransformed point trsf) deletePnt + +-- translate/translated + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Translate" translate :: Ptr Pnt -> Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_Translated" rawTranslated :: Ptr Pnt -> Ptr Vec -> IO (Ptr Pnt) + +translated :: Ptr Pnt -> Ptr Vec -> Acquire (Ptr Pnt) +translated point vec = mkAcquire (rawTranslated point vec) deletePnt + +-- translateRelative/translatedRelative + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_TranslateRelative" translateRelative :: Ptr Pnt -> Ptr Pnt -> Ptr Pnt -> IO () + +foreign import capi unsafe "hs_gp_Pnt.h hs_gp_Pnt_TranslatedRelative" rawTranslatedRelative :: Ptr Pnt -> Ptr Pnt -> Ptr Pnt -> IO (Ptr Pnt) + +translatedRelative :: Ptr Pnt -> Ptr Pnt -> Ptr Pnt -> Acquire (Ptr Pnt) +translatedRelative point from to = mkAcquire (rawTranslatedRelative point from to) deletePnt diff --git a/src/OpenCascade/GP/Pnt2d.hs b/src/OpenCascade/GP/Pnt2d.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Pnt2d.hs @@ -0,0 +1,147 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Pnt2d +( Pnt2d +, new +, getX +, getY +, setX +, setY +, distance +, squareDistance +, isEqual +, mirror +, mirrored +, mirrorAboutAx2d +, mirroredAboutAx2d +, rotate +, rotated +, scale +, scaled +, transform +, transformed +, translate +, translated +, translateRelative +, translatedRelative +) where + +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Coerce (coerce) +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_new_gp_Pnt2d" rawNew :: CDouble -> CDouble -> IO (Ptr Pnt2d) + +new :: Double -> Double -> Acquire (Ptr Pnt2d) +new x y = mkAcquire (rawNew (CDouble x) (CDouble y)) deletePnt2d + +-- getters + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_X" rawX :: Ptr Pnt2d -> IO (CDouble) + +getX :: Ptr Pnt2d -> IO Double +getX = coerce rawX + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Y" rawY :: Ptr Pnt2d -> IO (CDouble) + +getY :: Ptr Pnt2d -> IO Double +getY = coerce rawY + +-- setters + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_SetX" rawSetX :: Ptr Pnt2d -> CDouble -> IO () + +setX :: Ptr Pnt2d -> Double -> IO () +setX = coerce rawSetX + + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_SetY" rawSetY :: Ptr Pnt2d -> CDouble -> IO () + +setY :: Ptr Pnt2d -> Double -> IO () +setY = coerce rawSetY + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Distance" rawDistance :: Ptr Pnt2d -> Ptr Pnt2d -> IO CDouble + +-- distance and quadrance + +distance :: Ptr Pnt2d -> Ptr Pnt2d -> IO Double +distance = coerce rawDistance + + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_SquareDistance" rawSquareDistance :: Ptr Pnt2d -> Ptr Pnt2d -> IO CDouble + +squareDistance :: Ptr Pnt2d -> Ptr Pnt2d -> IO Double +squareDistance = coerce rawSquareDistance + +-- isEqual + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_IsEqual" rawIsEqual :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble -> IO CBool + +isEqual :: Ptr Pnt2d -> Ptr Pnt2d -> Double -> IO Bool +isEqual a b tolerance = (/= 0) <$> rawIsEqual a b (CDouble tolerance) + +-- mirror/mirrored + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Mirror" mirror :: Ptr Pnt2d -> Ptr Pnt2d -> IO () + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Mirrored" rawMirrored :: Ptr Pnt2d -> Ptr Pnt2d -> IO (Ptr Pnt2d) + +mirrored :: Ptr Pnt2d -> Ptr Pnt2d -> Acquire (Ptr Pnt2d) +mirrored point axis = mkAcquire (rawMirrored point axis) deletePnt2d + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_MirrorAboutAx2d" mirrorAboutAx2d :: Ptr Pnt2d -> Ptr Ax2d -> IO () + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_MirroredAboutAx2d" rawMirroredAboutAx2d :: Ptr Pnt2d -> Ptr Ax2d -> IO (Ptr Pnt2d) + +mirroredAboutAx2d :: Ptr Pnt2d -> Ptr Ax2d -> Acquire (Ptr Pnt2d) +mirroredAboutAx2d point axis = mkAcquire (rawMirroredAboutAx2d point axis) deletePnt2d + +-- rotate/rotated + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Rotate" rotate :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble-> IO () + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Rotated" rawRotated :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble -> IO (Ptr Pnt2d) + +rotated :: Ptr Pnt2d -> Ptr Pnt2d -> Double -> Acquire (Ptr Pnt2d) +rotated point axis amount = mkAcquire (rawRotated point axis (CDouble amount)) deletePnt2d + +-- scale/scaled + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Scale" scale :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble-> IO () + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Scaled" rawScaled :: Ptr Pnt2d -> Ptr Pnt2d -> CDouble -> IO (Ptr Pnt2d) + +scaled :: Ptr Pnt2d -> Ptr Pnt2d -> Double -> Acquire (Ptr Pnt2d) +scaled point origin amount = mkAcquire (rawScaled point origin (CDouble amount)) deletePnt2d + +-- transform/transformed + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Transform" transform :: Ptr Pnt2d -> Ptr Trsf2d -> IO () + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Transformed" rawTransformed :: Ptr Pnt2d -> Ptr Trsf2d -> IO (Ptr Pnt2d) + +transformed :: Ptr Pnt2d -> Ptr Trsf2d -> Acquire (Ptr Pnt2d) +transformed point trsf = mkAcquire (rawTransformed point trsf) deletePnt2d + +-- translate/translated + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Translate" translate :: Ptr Pnt2d -> Ptr Vec2d -> IO () + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_Translated" rawTranslated :: Ptr Pnt2d -> Ptr Vec2d -> IO (Ptr Pnt2d) + +translated :: Ptr Pnt2d -> Ptr Vec2d -> Acquire (Ptr Pnt2d) +translated point vec = mkAcquire (rawTranslated point vec) deletePnt2d + +-- translateRelative/translatedRelative + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_TranslateRelative" translateRelative :: Ptr Pnt2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO () + +foreign import capi unsafe "hs_gp_Pnt2d.h hs_gp_Pnt2d_TranslatedRelative" rawTranslatedRelative :: Ptr Pnt2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO (Ptr Pnt2d) + +translatedRelative :: Ptr Pnt2d -> Ptr Pnt2d -> Ptr Pnt2d -> Acquire (Ptr Pnt2d) +translatedRelative point from to = mkAcquire (rawTranslatedRelative point from to) deletePnt2d + diff --git a/src/OpenCascade/GP/Trsf.hs b/src/OpenCascade/GP/Trsf.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Trsf.hs @@ -0,0 +1,138 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Trsf +( Trsf +, new +, fromTrsf2d +, setMirrorAboutPnt +, setMirrorAboutAx1 +, setMirrorAboutAx2 +, setRotationAboutAxisAngle +, setScale +, setTranslation +, setScaleFactor +, setTranslationPart +, setValues +, isNegative +, scaleFactor +, value +, invert +, inverted +, multiply +, multiplied +, preMultiply +, power +, powered +) where + +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Coerce (coerce) +import Data.Acquire + + +-- new + +foreign import capi unsafe "hs_gp_Trsf.h hs_new_gp_Trsf" rawNew ::IO (Ptr Trsf) + +new :: Acquire (Ptr Trsf) +new = mkAcquire rawNew deleteTrsf + +foreign import capi unsafe "hs_gp_Trsf.h hs_new_gp_Trsf_fromTrsf2d" rawFromTrsf2d :: Ptr Trsf2d -> IO (Ptr Trsf) + +fromTrsf2d :: Ptr Trsf2d -> Acquire (Ptr Trsf) +fromTrsf2d t = mkAcquire (rawFromTrsf2d t) deleteTrsf + +-- mirror + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetMirrorAboutPnt" setMirrorAboutPnt :: Ptr Trsf -> Ptr Pnt -> IO () + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetMirrorAboutAx1" setMirrorAboutAx1 :: Ptr Trsf -> Ptr Ax1 -> IO () + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetMirrorAboutAx2" setMirrorAboutAx2 :: Ptr Trsf -> Ptr Ax2 -> IO () + +-- rotate + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetRotationAboutAxisAngle" rawSetRotationAboutAxisAngle :: Ptr Trsf -> Ptr Ax1 -> CDouble -> IO () + +setRotationAboutAxisAngle :: Ptr Trsf -> Ptr Ax1 -> Double -> IO () +setRotationAboutAxisAngle = coerce rawSetRotationAboutAxisAngle + +-- scale + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetScale" rawSetScale :: Ptr Trsf -> Ptr Pnt -> CDouble -> IO () + +setScale :: Ptr Trsf -> Ptr Pnt -> Double -> IO () +setScale = coerce rawSetScale + +-- translation + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetTranslation" setTranslation :: Ptr Trsf -> Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetTranslationPart" setTranslationPart :: Ptr Trsf -> Ptr Vec -> IO () + +-- scaleFactor + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetScaleFactor" rawSetScaleFactor :: Ptr Trsf -> CDouble -> IO () + +setScaleFactor :: Ptr Trsf -> Double -> IO () +setScaleFactor = coerce rawSetScaleFactor + +-- setValues + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_SetValues" rawSetValues :: Ptr Trsf -> CDouble -> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> CDouble -> IO () + +setValues :: Ptr Trsf -> Double -> Double-> Double-> Double-> Double-> Double-> Double-> Double-> Double-> Double-> Double-> Double -> IO () +setValues = coerce rawSetValues + +-- tests + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_IsNegative" rawIsNegative :: Ptr Trsf -> IO CBool + +isNegative :: Ptr Trsf -> IO Bool +isNegative = fmap (/= 0) . rawIsNegative + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_ScaleFactor" rawScaleFactor :: Ptr Trsf -> IO CDouble + +scaleFactor :: Ptr Trsf -> IO Double +scaleFactor = coerce rawScaleFactor + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Value" rawValue :: Ptr Trsf -> CInt -> CInt -> IO CDouble + +value :: Ptr Trsf -> Int -> Int -> IO Double +value t row col = coerce $ rawValue t (fromIntegral row) (fromIntegral col) + +-- invert/inverted + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Invert" invert :: Ptr Trsf-> IO () + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Inverted" rawInverted :: Ptr Trsf-> IO (Ptr Trsf) + +inverted :: Ptr Trsf -> Acquire (Ptr Trsf) +inverted t = mkAcquire (rawInverted t) deleteTrsf + +-- multiply/multiplied + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Multiply" multiply :: Ptr Trsf -> Ptr Trsf -> IO () + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Multiplied" rawMultiplied :: Ptr Trsf -> Ptr Trsf -> IO (Ptr Trsf) + +multiplied :: Ptr Trsf -> Ptr Trsf -> Acquire (Ptr Trsf) +multiplied a b = mkAcquire (rawMultiplied a b) deleteTrsf + +-- PreMultiply + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_PreMultiply" preMultiply :: Ptr Trsf -> Ptr Trsf -> IO () + +-- power/powered + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Power" rawPower :: Ptr Trsf -> CInt -> IO () + +power :: Ptr Trsf -> Int -> IO () +power trsf times = rawPower trsf (fromIntegral times) + +foreign import capi unsafe "hs_gp_Trsf.h hs_gp_Trsf_Powered" rawPowered :: Ptr Trsf -> CInt -> IO (Ptr Trsf) + +powered :: Ptr Trsf -> Int -> Acquire (Ptr Trsf) +powered trsf times = mkAcquire (rawPowered trsf (fromIntegral times)) deleteTrsf diff --git a/src/OpenCascade/GP/Trsf2d.hs b/src/OpenCascade/GP/Trsf2d.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Trsf2d.hs @@ -0,0 +1,146 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Trsf2d +( Trsf2d +, new +, fromTrsf +, setMirrorAboutPnt2d +, setMirrorAboutAx2d +, setRotation +, setScale +, setTransformation +, setTransformationRelative +, setTranslation +, setScaleFactor +, setTranslationPart +, setTranslationRelative +, setValues +, isNegative +, scaleFactor +, value +, invert +, inverted +, multiply +, multiplied +, preMultiply +, power +, powered +) where + +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Coerce (coerce) +import Data.Acquire + + +-- new + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_new_gp_Trsf2d" rawNew ::IO (Ptr Trsf2d) + +new :: Acquire (Ptr Trsf2d) +new = mkAcquire rawNew deleteTrsf2d + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_new_gp_Trsf2d_fromTrsf" rawFromTrsf :: Ptr Trsf -> IO (Ptr Trsf2d) + +fromTrsf :: Ptr Trsf -> Acquire (Ptr Trsf2d) +fromTrsf t = mkAcquire (rawFromTrsf t) deleteTrsf2d + +-- mirror + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetMirrorAboutPnt2d" setMirrorAboutPnt2d :: Ptr Trsf2d -> Ptr Pnt2d -> IO () + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetMirrorAboutAx2d" setMirrorAboutAx2d :: Ptr Trsf2d -> Ptr Ax2d -> IO () + +-- rotate + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetRotation" rawSetRotation :: Ptr Trsf2d -> Ptr Pnt2d -> CDouble -> IO () + +setRotation :: Ptr Trsf2d -> Ptr Pnt2d -> Double -> IO () +setRotation = coerce rawSetRotation + +-- scale + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetScale" rawSetScale :: Ptr Trsf2d -> Ptr Pnt2d -> CDouble -> IO () + +setScale :: Ptr Trsf2d -> Ptr Pnt2d -> Double -> IO () +setScale = coerce rawSetScale + +-- transformation + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTransformation" setTransformation :: Ptr Trsf2d -> Ptr Ax2d -> IO () + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTransformationRelative" setTransformationRelative :: Ptr Trsf2d -> Ptr Ax2d -> Ptr Ax2d -> IO () + +-- translation + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTranslation" setTranslation :: Ptr Trsf2d -> Ptr Vec2d -> IO () + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTranslationPart" setTranslationPart :: Ptr Trsf2d -> Ptr Vec2d -> IO () + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetTranslationRelative" setTranslationRelative :: Ptr Trsf2d -> Ptr Pnt2d -> Ptr Pnt2d -> IO () + +-- scaleFactor + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetScaleFactor" rawSetScaleFactor :: Ptr Trsf2d -> CDouble -> IO () + +setScaleFactor :: Ptr Trsf2d -> Double -> IO () +setScaleFactor = coerce rawSetScaleFactor + +-- setValues + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_SetValues" rawSetValues :: Ptr Trsf2d -> CDouble -> CDouble-> CDouble-> CDouble-> CDouble-> CDouble-> IO () + +setValues :: Ptr Trsf2d -> Double -> Double -> Double -> Double-> Double -> Double -> IO () +setValues = coerce rawSetValues + +-- tests + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_IsNegative" rawIsNegative :: Ptr Trsf2d -> IO CBool + +isNegative :: Ptr Trsf2d -> IO Bool +isNegative = fmap (/= 0) . rawIsNegative + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_ScaleFactor" rawScaleFactor :: Ptr Trsf2d -> IO CDouble + +scaleFactor :: Ptr Trsf2d -> IO Double +scaleFactor = coerce rawScaleFactor + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Value" rawValue :: Ptr Trsf2d -> CInt -> CInt -> IO CDouble + +value :: Ptr Trsf2d -> Int -> Int -> IO Double +value t row col = coerce $ rawValue t (fromIntegral row) (fromIntegral col) + +-- invert/inverted + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Invert" invert :: Ptr Trsf2d-> IO () + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Inverted" rawInverted :: Ptr Trsf2d-> IO (Ptr Trsf2d) + +inverted :: Ptr Trsf2d -> Acquire (Ptr Trsf2d) +inverted t = mkAcquire (rawInverted t) deleteTrsf2d + +-- multiply/multiplied + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Multiply" multiply :: Ptr Trsf2d -> Ptr Trsf2d -> IO () + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Multiplied" rawMultiplied :: Ptr Trsf2d -> Ptr Trsf2d -> IO (Ptr Trsf2d) + +multiplied :: Ptr Trsf2d -> Ptr Trsf2d -> Acquire (Ptr Trsf2d) +multiplied a b = mkAcquire (rawMultiplied a b) deleteTrsf2d + +-- PreMultiply + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_PreMultiply" preMultiply :: Ptr Trsf2d -> Ptr Trsf2d -> IO () + +-- power/powered + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Power" rawPower :: Ptr Trsf2d -> CInt -> IO () + +power :: Ptr Trsf2d -> Int -> IO () +power trsf times = rawPower trsf (fromIntegral times) + +foreign import capi unsafe "hs_gp_Trsf2d.h hs_gp_Trsf2d_Powered" rawPowered :: Ptr Trsf2d -> CInt -> IO (Ptr Trsf2d) + +powered :: Ptr Trsf2d -> Int -> Acquire (Ptr Trsf2d) +powered trsf times = mkAcquire (rawPowered trsf (fromIntegral times)) deleteTrsf2d diff --git a/src/OpenCascade/GP/Types.hs b/src/OpenCascade/GP/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Types.hs @@ -0,0 +1,16 @@ +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.GP.Types where + +data Pnt +data Pnt2d +data Ax1 +data Ax2 +data Ax2d +data Dir +data Dir2d +data Vec +data Vec2d +data Trsf +data Trsf2d +data GTrsf + diff --git a/src/OpenCascade/GP/Vec.hs b/src/OpenCascade/GP/Vec.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Vec.hs @@ -0,0 +1,316 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Vec +( Vec +, new +, getX +, getY +, getZ +, setX +, setY +, setZ +, isEqual +, isOpposite +, isNormal +, isParallel +, angle +, angleWithRef +, magnitude +, squareMagnitude +, add +, added +, subtract +, subtracted +, multiply +, multiplied +, divide +, divided +, cross +, crossed +, crossCross +, crossCrossed +, crossMagnitude +, crossSquareMagnitude +, dot +, dotCross +, reverse +, reversed +, mirror +, mirrored +, mirrorAboutAx1 +, mirroredAboutAx1 +, mirrorAboutAx2 +, mirroredAboutAx2 +, rotate +, rotated +, scale +, scaled +, transform +, transformed +) where + + +import Prelude hiding (reverse, subtract) +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Coerce (coerce) +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_gp_Vec.h hs_new_gp_Vec" rawNew :: CDouble -> CDouble -> CDouble -> IO (Ptr Vec) + +new :: Double -> Double -> Double -> Acquire (Ptr Vec) +new x y z = mkAcquire (rawNew (CDouble x) (CDouble y) (CDouble z)) deleteVec + +-- getters + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_X" rawX :: Ptr Vec -> IO (CDouble) + +getX :: Ptr Vec -> IO Double +getX = coerce rawX + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Y" rawY :: Ptr Vec -> IO (CDouble) + +getY :: Ptr Vec -> IO Double +getY = coerce rawY + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Z" rawZ :: Ptr Vec -> IO (CDouble) + +getZ :: Ptr Vec -> IO Double +getZ = coerce rawZ + +-- setters + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_SetX" rawSetX :: Ptr Vec -> CDouble -> IO () + +setX :: Ptr Vec -> Double -> IO () +setX = coerce rawSetX + + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_SetY" rawSetY :: Ptr Vec -> CDouble -> IO () + +setY :: Ptr Vec -> Double -> IO () +setY = coerce rawSetY + + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_SetZ" rawSetZ :: Ptr Vec -> CDouble -> IO () + +setZ :: Ptr Vec -> Double -> IO () +setZ = coerce rawSetZ + +-- tests + +-- isEqual + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_IsEqual" rawIsEqual :: Ptr Vec -> Ptr Vec -> CDouble -> CDouble -> IO CBool + +isEqual :: Ptr Vec -> Ptr Vec -> Double -> Double -> IO Bool +isEqual a b linearTolerance angularTolerance = (/= 0) <$> rawIsEqual a b (CDouble linearTolerance) (CDouble angularTolerance) + +-- isNormal + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_IsNormal" rawIsNormal :: Ptr Vec -> Ptr Vec -> CDouble -> IO CBool + +isNormal :: Ptr Vec -> Ptr Vec -> Double -> IO Bool +isNormal a b tolerance = (/= 0) <$> rawIsNormal a b (CDouble tolerance) + +-- isOpposite + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_IsOpposite" rawIsOpposite :: Ptr Vec -> Ptr Vec -> CDouble -> IO CBool + +isOpposite :: Ptr Vec -> Ptr Vec -> Double -> IO Bool +isOpposite a b tolerance = (/= 0) <$> rawIsOpposite a b (CDouble tolerance) + +-- isParallel + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_IsParallel" rawIsParallel :: Ptr Vec -> Ptr Vec -> CDouble -> IO CBool + +isParallel :: Ptr Vec -> Ptr Vec -> Double -> IO Bool +isParallel a b tolerance = (/= 0) <$> rawIsParallel a b (CDouble tolerance) + +-- angle + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Angle" rawAngle :: Ptr Vec -> Ptr Vec -> IO CDouble + +angle :: Ptr Vec -> Ptr Vec -> IO Double +angle = coerce rawAngle + +-- angleWithRef + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_AngleWithRef" rawAngleWithRef :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO CDouble + +angleWithRef :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO Double +angleWithRef = coerce rawAngleWithRef + + +-- magnitude + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Magnitude" rawMagnitude :: Ptr Vec -> IO CDouble + +magnitude :: Ptr Vec -> IO Double +magnitude = coerce rawMagnitude + + +-- squareMagnitude + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_SquareMagnitude" rawSquareMagnitude :: Ptr Vec -> IO CDouble + +squareMagnitude :: Ptr Vec -> IO Double +squareMagnitude = coerce rawSquareMagnitude + +-- add/added + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Add" add :: Ptr Vec -> Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Added" rawAdded :: Ptr Vec -> Ptr Vec -> IO (Ptr Vec) + +added :: Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec) +added a b = mkAcquire (rawAdded a b) deleteVec + + +-- subtract/subtracted + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Subtract" subtract :: Ptr Vec -> Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Subtracted" rawSubtracted :: Ptr Vec -> Ptr Vec -> IO (Ptr Vec) + +subtracted :: Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec) +subtracted a b = mkAcquire (rawSubtracted a b) deleteVec + + +-- multiply/multiplied + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Multiply" rawMultiply :: Ptr Vec -> CDouble -> IO () + +multiply :: Ptr Vec -> Double -> IO () +multiply = coerce rawMultiply + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Multiplied" rawMultiplied :: Ptr Vec -> CDouble -> IO (Ptr Vec) + +multiplied :: Ptr Vec -> Double -> Acquire (Ptr Vec) +multiplied a b = mkAcquire (rawMultiplied a (CDouble b)) deleteVec + +-- divide/divided + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Divide" rawDivide :: Ptr Vec -> CDouble -> IO () + +divide :: Ptr Vec -> Double -> IO () +divide = coerce rawDivide + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Divided" rawDivided :: Ptr Vec -> CDouble -> IO (Ptr Vec) + +divided :: Ptr Vec -> Double -> Acquire (Ptr Vec) +divided a b = mkAcquire (rawDivided a (CDouble b)) deleteVec + +-- cross/crossed + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Cross" cross :: Ptr Vec -> Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Crossed" rawCrossed :: Ptr Vec -> Ptr Vec -> IO (Ptr Vec) + +crossed :: Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec) +crossed a b = mkAcquire (rawCrossed a b) deleteVec + +-- crossCross/crossCrossed + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_CrossCross" crossCross :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_CrossCrossed" rawCrossCrossed :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO (Ptr Vec) + +crossCrossed :: Ptr Vec -> Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec) +crossCrossed a b c = mkAcquire (rawCrossCrossed a b c) deleteVec + +-- crossMagnitude + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_CrossMagnitude" rawCrossMagnitude :: Ptr Vec -> Ptr Vec -> IO CDouble + +crossMagnitude :: Ptr Vec -> Ptr Vec -> IO Double +crossMagnitude = coerce rawCrossMagnitude + +-- crossSquareMagnitude + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_CrossSquareMagnitude" rawCrossSquareMagnitude :: Ptr Vec -> Ptr Vec -> IO CDouble + +crossSquareMagnitude :: Ptr Vec -> Ptr Vec -> IO Double +crossSquareMagnitude = coerce rawCrossSquareMagnitude + +-- dot + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Dot" rawDot :: Ptr Vec -> Ptr Vec -> IO CDouble + +dot :: Ptr Vec -> Ptr Vec -> IO Double +dot = coerce rawDot + + +-- dotCross + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_DotCross" rawDotCross :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO CDouble + +dotCross :: Ptr Vec -> Ptr Vec -> Ptr Vec -> IO Double +dotCross = coerce rawDotCross + + +-- reverse/reversed + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Reverse" reverse :: Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Reversed" rawReversed :: Ptr Vec -> IO (Ptr Vec) + +reversed :: Ptr Vec -> Acquire (Ptr Vec) +reversed axis = mkAcquire (rawReversed axis) deleteVec + +-- mirror/mirrored + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Mirror" mirror :: Ptr Vec -> Ptr Vec -> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Mirrored" rawMirrored :: Ptr Vec -> Ptr Vec -> IO (Ptr Vec) + +mirrored :: Ptr Vec -> Ptr Vec -> Acquire (Ptr Vec) +mirrored point axis = mkAcquire (rawMirrored point axis) deleteVec + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_MirrorAboutAx1" mirrorAboutAx1 :: Ptr Vec -> Ptr Ax1 -> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_MirroredAboutAx1" rawMirroredAboutAx1 :: Ptr Vec -> Ptr Ax1 -> IO (Ptr Vec) + +mirroredAboutAx1 :: Ptr Vec -> Ptr Ax1 -> Acquire (Ptr Vec) +mirroredAboutAx1 point axis = mkAcquire (rawMirroredAboutAx1 point axis) deleteVec + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_MirrorAboutAx2" mirrorAboutAx2 :: Ptr Vec -> Ptr Ax2 -> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_MirroredAboutAx2" rawMirroredAboutAx2 :: Ptr Vec -> Ptr Ax2 -> IO (Ptr Vec) + +mirroredAboutAx2 :: Ptr Vec -> Ptr Ax2 -> Acquire (Ptr Vec) +mirroredAboutAx2 point axis = mkAcquire (rawMirroredAboutAx2 point axis) deleteVec + +-- rotate/rotated + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Rotate" rotate :: Ptr Vec -> Ptr Ax1 -> CDouble-> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Rotated" rawRotated :: Ptr Vec -> Ptr Ax1 -> CDouble -> IO (Ptr Vec) + +rotated :: Ptr Vec -> Ptr Ax1 -> Double -> Acquire (Ptr Vec) +rotated point axis amount = mkAcquire (rawRotated point axis (CDouble amount)) deleteVec + +-- scale/scaled + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Scale" rawScale :: Ptr Vec -> CDouble -> IO () + +scale :: Ptr Vec -> Double -> IO () +scale = coerce rawScale + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Scaled" rawScaled :: Ptr Vec -> CDouble -> IO (Ptr Vec) + +scaled :: Ptr Vec -> Double -> Acquire (Ptr Vec) +scaled a b = mkAcquire (rawScaled a (CDouble b)) deleteVec + + +-- transform/transformed + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Transform" transform :: Ptr Vec -> Ptr Trsf -> IO () + +foreign import capi unsafe "hs_gp_Vec.h hs_gp_Vec_Transformed" rawTransformed :: Ptr Vec -> Ptr Trsf -> IO (Ptr Vec) + +transformed :: Ptr Vec -> Ptr Trsf -> Acquire (Ptr Vec) +transformed point trsf = mkAcquire (rawTransformed point trsf) deleteVec diff --git a/src/OpenCascade/GP/Vec2d.hs b/src/OpenCascade/GP/Vec2d.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/GP/Vec2d.hs @@ -0,0 +1,262 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.GP.Vec2d +( Vec2d +, new +, getX +, getY +, setX +, setY +, isEqual +, isOpposite +, isNormal +, isParallel +, angle +, magnitude +, squareMagnitude +, add +, added +, subtract +, subtracted +, multiply +, multiplied +, divide +, divided +, crossed +, crossMagnitude +, crossSquareMagnitude +, dot +, reverse +, reversed +, mirror +, mirrored +, mirrorAboutAx2d +, mirroredAboutAx2d +, rotate +, rotated +, scale +, scaled +, transform +, transformed +) where + + +import Prelude hiding (reverse, subtract) +import OpenCascade.GP.Types +import OpenCascade.GP.Internal.Destructors +import Foreign.C +import Foreign.Ptr +import Data.Coerce (coerce) +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_gp_Vec2d.h hs_new_gp_Vec2d" rawNew :: CDouble -> CDouble -> IO (Ptr Vec2d) + +new :: Double -> Double -> Acquire (Ptr Vec2d) +new x y = mkAcquire (rawNew (CDouble x) (CDouble y)) deleteVec2d + +-- getters + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_X" rawX :: Ptr Vec2d -> IO (CDouble) + +getX :: Ptr Vec2d -> IO Double +getX = coerce rawX + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Y" rawY :: Ptr Vec2d -> IO (CDouble) + +getY :: Ptr Vec2d -> IO Double +getY = coerce rawY + +-- setters + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_SetX" rawSetX :: Ptr Vec2d -> CDouble -> IO () + +setX :: Ptr Vec2d -> Double -> IO () +setX = coerce rawSetX + + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_SetY" rawSetY :: Ptr Vec2d -> CDouble -> IO () + +setY :: Ptr Vec2d -> Double -> IO () +setY = coerce rawSetY + +-- tests + +-- isEqual + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_IsEqual" rawIsEqual :: Ptr Vec2d -> Ptr Vec2d -> CDouble -> CDouble -> IO CBool + +isEqual :: Ptr Vec2d -> Ptr Vec2d -> Double -> Double -> IO Bool +isEqual a b linearTolerance angularTolerance = (/= 0) <$> rawIsEqual a b (CDouble linearTolerance) (CDouble angularTolerance) + +-- isNormal + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_IsNormal" rawIsNormal :: Ptr Vec2d -> Ptr Vec2d -> CDouble -> IO CBool + +isNormal :: Ptr Vec2d -> Ptr Vec2d -> Double -> IO Bool +isNormal a b tolerance = (/= 0) <$> rawIsNormal a b (CDouble tolerance) + +-- isOpposite + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_IsOpposite" rawIsOpposite :: Ptr Vec2d -> Ptr Vec2d -> CDouble -> IO CBool + +isOpposite :: Ptr Vec2d -> Ptr Vec2d -> Double -> IO Bool +isOpposite a b tolerance = (/= 0) <$> rawIsOpposite a b (CDouble tolerance) + +-- isParallel + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_IsParallel" rawIsParallel :: Ptr Vec2d -> Ptr Vec2d -> CDouble -> IO CBool + +isParallel :: Ptr Vec2d -> Ptr Vec2d -> Double -> IO Bool +isParallel a b tolerance = (/= 0) <$> rawIsParallel a b (CDouble tolerance) + +-- angle + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Angle" rawAngle :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble + +angle :: Ptr Vec2d -> Ptr Vec2d -> IO Double +angle = coerce rawAngle + + +-- magnitude + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Magnitude" rawMagnitude :: Ptr Vec2d -> IO CDouble + +magnitude :: Ptr Vec2d -> IO Double +magnitude = coerce rawMagnitude + + +-- squareMagnitude + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_SquareMagnitude" rawSquareMagnitude :: Ptr Vec2d -> IO CDouble + +squareMagnitude :: Ptr Vec2d -> IO Double +squareMagnitude = coerce rawSquareMagnitude + +-- add/added + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Add" add :: Ptr Vec2d -> Ptr Vec2d -> IO () + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Added" rawAdded :: Ptr Vec2d -> Ptr Vec2d -> IO (Ptr Vec2d) + +added :: Ptr Vec2d -> Ptr Vec2d -> Acquire (Ptr Vec2d) +added a b = mkAcquire (rawAdded a b) deleteVec2d + + +-- subtract/subtracted + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Subtract" subtract :: Ptr Vec2d -> Ptr Vec2d -> IO () + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Subtracted" rawSubtracted :: Ptr Vec2d -> Ptr Vec2d -> IO (Ptr Vec2d) + +subtracted :: Ptr Vec2d -> Ptr Vec2d -> Acquire (Ptr Vec2d) +subtracted a b = mkAcquire (rawSubtracted a b) deleteVec2d + + +-- multiply/multiplied + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Multiply" rawMultiply :: Ptr Vec2d -> CDouble -> IO () + +multiply :: Ptr Vec2d -> Double -> IO () +multiply = coerce rawMultiply + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Multiplied" rawMultiplied :: Ptr Vec2d -> CDouble -> IO (Ptr Vec2d) + +multiplied :: Ptr Vec2d -> Double -> Acquire (Ptr Vec2d) +multiplied a b = mkAcquire (rawMultiplied a (CDouble b)) deleteVec2d + +-- divide/divided + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Divide" rawDivide :: Ptr Vec2d -> CDouble -> IO () + +divide :: Ptr Vec2d -> Double -> IO () +divide = coerce rawDivide + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Divided" rawDivided :: Ptr Vec2d -> CDouble -> IO (Ptr Vec2d) + +divided :: Ptr Vec2d -> Double -> Acquire (Ptr Vec2d) +divided a b = mkAcquire (rawDivided a (CDouble b)) deleteVec2d + +-- cross/crossed + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Crossed" rawCrossed :: Ptr Vec2d -> Ptr Vec2d -> IO (CDouble) + +crossed :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble +crossed = coerce rawCrossed + +-- crossMagnitude + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_CrossMagnitude" rawCrossMagnitude :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble + +crossMagnitude :: Ptr Vec2d -> Ptr Vec2d -> IO Double +crossMagnitude = coerce rawCrossMagnitude + +-- crossSquareMagnitude + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_CrossSquareMagnitude" rawCrossSquareMagnitude :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble + +crossSquareMagnitude :: Ptr Vec2d -> Ptr Vec2d -> IO Double +crossSquareMagnitude = coerce rawCrossSquareMagnitude + +-- dot + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Dot" rawDot :: Ptr Vec2d -> Ptr Vec2d -> IO CDouble + +dot :: Ptr Vec2d -> Ptr Vec2d -> IO Double +dot = coerce rawDot + +-- reverse/reversed + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Reverse" reverse :: Ptr Vec2d -> IO () + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Reversed" rawReversed :: Ptr Vec2d -> IO (Ptr Vec2d) + +reversed :: Ptr Vec2d -> Acquire (Ptr Vec2d) +reversed axis = mkAcquire (rawReversed axis) deleteVec2d + +-- mirror/mirrored + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Mirror" mirror :: Ptr Vec2d -> Ptr Vec2d -> IO () + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Mirrored" rawMirrored :: Ptr Vec2d -> Ptr Vec2d -> IO (Ptr Vec2d) + +mirrored :: Ptr Vec2d -> Ptr Vec2d -> Acquire (Ptr Vec2d) +mirrored point axis = mkAcquire (rawMirrored point axis) deleteVec2d + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_MirrorAboutAx2d" mirrorAboutAx2d :: Ptr Vec2d -> Ptr Ax2d -> IO () + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_MirroredAboutAx2d" rawMirroredAboutAx2d :: Ptr Vec2d -> Ptr Ax2d -> IO (Ptr Vec2d) + +mirroredAboutAx2d :: Ptr Vec2d -> Ptr Ax2d -> Acquire (Ptr Vec2d) +mirroredAboutAx2d point axis = mkAcquire (rawMirroredAboutAx2d point axis) deleteVec2d + +-- rotate/rotated + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Rotate" rotate :: Ptr Vec2d -> CDouble-> IO () + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Rotated" rawRotated :: Ptr Vec2d -> CDouble -> IO (Ptr Vec2d) + +rotated :: Ptr Vec2d -> Double -> Acquire (Ptr Vec2d) +rotated point angle = mkAcquire (rawRotated point (CDouble angle)) deleteVec2d + +-- scale/scaled + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Scale" rawScale :: Ptr Vec2d -> CDouble -> IO () + +scale :: Ptr Vec2d -> Double -> IO () +scale = coerce rawScale + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Scaled" rawScaled :: Ptr Vec2d -> CDouble -> IO (Ptr Vec2d) + +scaled :: Ptr Vec2d -> Double -> Acquire (Ptr Vec2d) +scaled a b = mkAcquire (rawScaled a (CDouble b)) deleteVec2d + + +-- transform/transformed + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Transform" transform :: Ptr Vec2d -> Ptr Trsf -> IO () + +foreign import capi unsafe "hs_gp_Vec2d.h hs_gp_Vec2d_Transformed" rawTransformed :: Ptr Vec2d -> Ptr Trsf -> IO (Ptr Vec2d) + +transformed :: Ptr Vec2d -> Ptr Trsf -> Acquire (Ptr Vec2d) +transformed point trsf = mkAcquire (rawTransformed point trsf) deleteVec2d diff --git a/src/OpenCascade/Geom.hs b/src/OpenCascade/Geom.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/Geom.hs @@ -0,0 +1,5 @@ +module OpenCascade.Geom +( module OpenCascade.Geom.Types +) where + +import OpenCascade.Geom.Types diff --git a/src/OpenCascade/Geom/BezierCurve.hs b/src/OpenCascade/Geom/BezierCurve.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/Geom/BezierCurve.hs @@ -0,0 +1,24 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.Geom.BezierCurve +( fromPnts +, toHandle +) where +import Foreign.Ptr +import Data.Acquire +import OpenCascade.Geom.Types (BezierCurve) +import OpenCascade.Geom.Internal.Destructors (deleteBezierCurve, deleteHandleBezierCurve) +import OpenCascade.GP (Pnt(..)) +import OpenCascade.NCollection (Array1) +import OpenCascade.Handle (Handle) +foreign import capi unsafe "hs_Geom_BezierCurve.h hs_new_Geom_BezierCurve_fromPnts" rawFromPnts :: Ptr (Array1 Pnt) -> IO(Ptr BezierCurve) + +fromPnts :: Ptr (Array1 Pnt) -> Acquire (Ptr BezierCurve) +fromPnts arr = mkAcquire (rawFromPnts arr) (deleteBezierCurve) + +foreign import capi unsafe "hs_Geom_BezierCurve.h hs_Geom_BezierCurve_toHandle" rawToHandle :: Ptr BezierCurve -> IO (Ptr (Handle BezierCurve)) + +toHandle :: Ptr BezierCurve -> Acquire (Ptr (Handle BezierCurve)) +toHandle curve = mkAcquire (rawToHandle curve) deleteHandleBezierCurve + + + diff --git a/src/OpenCascade/Geom/Curve.hs b/src/OpenCascade/Geom/Curve.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/Geom/Curve.hs @@ -0,0 +1,16 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.Geom.Curve +( value +) where +import Foreign.Ptr +import Foreign.C +import Data.Coerce +import Data.Acquire +import OpenCascade.Geom.Types (Curve) +import OpenCascade.GP (Pnt) +import OpenCascade.GP.Internal.Destructors (deletePnt) +import OpenCascade.Handle (Handle) +foreign import capi unsafe "hs_Geom_Curve.h hs_Geom_Curve_value" rawValue :: Ptr (Handle Curve) -> CDouble -> IO(Ptr Pnt) + +value :: Ptr (Handle Curve) -> Double -> Acquire (Ptr Pnt) +value curve u = mkAcquire (rawValue curve (coerce u)) deletePnt diff --git a/src/OpenCascade/Geom/Internal/Destructors.hs b/src/OpenCascade/Geom/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/Geom/Internal/Destructors.hs @@ -0,0 +1,16 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.Geom.Internal.Destructors where + +import OpenCascade.Geom.Types + +import OpenCascade.Handle + +import Foreign.Ptr + +foreign import capi unsafe "hs_Geom_Curve.h hs_delete_Handle_Geom_Curve" deleteHandleCurve :: Ptr (Handle Curve) -> IO () + +foreign import capi unsafe "hs_Geom_TrimmedCurve.h hs_delete_Handle_Geom_TrimmedCurve" deleteHandleTrimmedCurve :: Ptr (Handle TrimmedCurve) -> IO () + +foreign import capi unsafe "hs_Geom_BezierCurve.h hs_delete_Handle_Geom_BezierCurve" deleteHandleBezierCurve :: Ptr (Handle BezierCurve) -> IO () + +foreign import capi unsafe "hs_Geom_BezierCurve.h hs_delete_Geom_BezierCurve" deleteBezierCurve :: Ptr BezierCurve -> IO () diff --git a/src/OpenCascade/Geom/Types.hs b/src/OpenCascade/Geom/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/Geom/Types.hs @@ -0,0 +1,18 @@ +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.Geom.Types +( Curve +, TrimmedCurve +, BezierCurve +, Surface +) where + +import OpenCascade.Inheritance + +data Curve +data TrimmedCurve +data BezierCurve +data Surface + +instance SubTypeOf Curve TrimmedCurve +instance SubTypeOf Curve BezierCurve diff --git a/src/OpenCascade/Handle.hs b/src/OpenCascade/Handle.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/Handle.hs @@ -0,0 +1,14 @@ +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.Handle +( Handle +) where +import OpenCascade.Inheritance + +data Handle a + +instance SubTypeOf a b => SubTypeOf (Handle a) (Handle b) + + + + diff --git a/src/OpenCascade/IFSelect/ReturnStatus.hs b/src/OpenCascade/IFSelect/ReturnStatus.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/IFSelect/ReturnStatus.hs @@ -0,0 +1,6 @@ +module OpenCascade.IFSelect.ReturnStatus +( ReturnStatus (..) +) where + +-- Should match the order in IFSelect_ReturnStatus.hxx +data ReturnStatus = Void | Done | Error | Fail | Stop deriving Enum diff --git a/src/OpenCascade/Inheritance.hs b/src/OpenCascade/Inheritance.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/Inheritance.hs @@ -0,0 +1,23 @@ +{-# LANGUAGE MultiParamTypeClasses #-} + +module OpenCascade.Inheritance +( SubTypeOf (..) +, DiscriminatedSubTypeOf (..) +, unsafeDowncast +) where + +import Foreign.Ptr + +class SubTypeOf a b where + upcast :: Ptr b -> Ptr a + upcast = castPtr + +class SubTypeOf a b => DiscriminatedSubTypeOf a b where + downcast :: Ptr a -> IO (Maybe (Ptr b)) + +unsafeDowncast :: DiscriminatedSubTypeOf a b => Ptr a -> IO (Ptr b) +unsafeDowncast p = do + maybeT <- downcast p + maybe (error "Incorrect subtype in cast") pure maybeT + + diff --git a/src/OpenCascade/Internal/Bool.hs b/src/OpenCascade/Internal/Bool.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/Internal/Bool.hs @@ -0,0 +1,14 @@ +module OpenCascade.Internal.Bool +( boolToCBool +, cBoolToBool +) where + + +import Foreign.C + +boolToCBool :: Bool -> CBool +boolToCBool b = if b then 1 else 0 + +cBoolToBool :: CBool -> Bool +cBoolToBool = (/=0) + diff --git a/src/OpenCascade/NCollection.hs b/src/OpenCascade/NCollection.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/NCollection.hs @@ -0,0 +1,5 @@ +module OpenCascade.NCollection ( + module OpenCascade.NCollection.Types +) where + +import OpenCascade.NCollection.Types diff --git a/src/OpenCascade/NCollection/Array1.hs b/src/OpenCascade/NCollection/Array1.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/NCollection/Array1.hs @@ -0,0 +1,23 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.NCollection.Array1 +( + newGPPntArray, + setValueGPPnt +) where + +import Data.Acquire +import Foreign.Ptr +import Foreign.C +import OpenCascade.GP.Types +import OpenCascade.NCollection.Types +import OpenCascade.NCollection.Internal.Destructors + +foreign import capi unsafe "hs_NCollection_Array1.h hs_new_NCollection_Array1_gp_Pnt" rawNewGPPntArray :: CInt -> CInt -> IO (Ptr (Array1 Pnt)) + +newGPPntArray :: Int -> Int -> Acquire (Ptr (Array1 Pnt)) +newGPPntArray lo hi = mkAcquire (rawNewGPPntArray (fromIntegral lo) (fromIntegral hi)) deletePntArray + +foreign import capi unsafe "hs_NCollection_Array1.h hs_NCollection_Array1_gp_Pnt_setValue" rawSetValueGPPnt :: Ptr (Array1 Pnt) -> CInt -> Ptr Pnt -> IO () + +setValueGPPnt :: Ptr (Array1 Pnt) -> Int -> Ptr Pnt -> IO () +setValueGPPnt arr i p = rawSetValueGPPnt arr (fromIntegral i) p diff --git a/src/OpenCascade/NCollection/Internal/Destructors.hs b/src/OpenCascade/NCollection/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/NCollection/Internal/Destructors.hs @@ -0,0 +1,9 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.NCollection.Internal.Destructors where + +import OpenCascade.NCollection.Types +import OpenCascade.GP.Types +import Foreign.Ptr + +foreign import capi unsafe "hs_NCollection_Array1.h hs_delete_NCollection_Array1_gp_Pnt" deletePntArray :: Ptr (Array1 Pnt) -> IO () + diff --git a/src/OpenCascade/NCollection/Types.hs b/src/OpenCascade/NCollection/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/NCollection/Types.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.NCollection.Types where + +data Array1 a diff --git a/src/OpenCascade/STEPControl.hs b/src/OpenCascade/STEPControl.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/STEPControl.hs @@ -0,0 +1,5 @@ +module OpenCascade.STEPControl +( module OpenCascade.STEPControl.Types +) where + +import OpenCascade.STEPControl.Types diff --git a/src/OpenCascade/STEPControl/Internal/Destructors.hs b/src/OpenCascade/STEPControl/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/STEPControl/Internal/Destructors.hs @@ -0,0 +1,8 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.STEPControl.Internal.Destructors where + +import OpenCascade.STEPControl.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_STEPControl_Writer.h hs_delete_STEPControl_Writer" deleteWriter :: Ptr Writer -> IO () diff --git a/src/OpenCascade/STEPControl/StepModelType.hs b/src/OpenCascade/STEPControl/StepModelType.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/STEPControl/StepModelType.hs @@ -0,0 +1,15 @@ +module OpenCascade.STEPControl.StepModelType +( StepModelType(..) +) where + +-- this should match the order defined in StepModelType +data StepModelType = + Asls | + ManifoldSolidBrep | + BrepWithVoids | + FacetedBrep | + FacetedBrepAndBrepWithVoids | + ShellBasedSurfaceModel | + GeometricCurveSet | + Hybrid + deriving Enum diff --git a/src/OpenCascade/STEPControl/Types.hs b/src/OpenCascade/STEPControl/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/STEPControl/Types.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.STEPControl.Types where + +data Writer diff --git a/src/OpenCascade/STEPControl/Writer.hs b/src/OpenCascade/STEPControl/Writer.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/STEPControl/Writer.hs @@ -0,0 +1,41 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.STEPControl.Writer +( new +, setTolerance +, unsetTolerance +, transfer +, write +) where + +import OpenCascade.STEPControl.Types (Writer) +import OpenCascade.STEPControl.Internal.Destructors (deleteWriter) +import qualified OpenCascade.TopoDS as TopoDS +import Foreign.C +import Foreign.Ptr +import Data.Acquire +import OpenCascade.Internal.Bool (boolToCBool) +import qualified OpenCascade.IFSelect.ReturnStatus as IFSelect.ReturnStatus +import OpenCascade.STEPControl.StepModelType (StepModelType) +import Data.Coerce (coerce) + +foreign import capi unsafe "hs_STEPControl_Writer.h hs_new_STEPControl_Writer" rawNew :: IO (Ptr Writer) + +new :: Acquire (Ptr Writer) +new = mkAcquire rawNew deleteWriter + +foreign import capi unsafe "hs_STEPControl_Writer.h hs_STEPControl_Writer_setTolerance" rawSetTolerance :: Ptr Writer -> CDouble -> IO () + +setTolerance :: Ptr Writer -> Double -> IO () +setTolerance = coerce rawSetTolerance + +foreign import capi unsafe "hs_STEPControl_Writer.h hs_STEPControl_Writer_unsetTolerance" unsetTolerance :: Ptr Writer -> IO () + +foreign import capi unsafe "hs_STEPControl_Writer.h hs_STEPControl_Writer_transfer" rawTransfer :: Ptr Writer -> Ptr TopoDS.Shape -> CInt -> CBool -> IO CInt + +transfer :: Ptr Writer -> Ptr TopoDS.Shape -> StepModelType -> Bool -> IO IFSelect.ReturnStatus.ReturnStatus +transfer writer shape mode compgraph = toEnum . fromIntegral <$> rawTransfer writer shape (fromIntegral . fromEnum $ mode) (boolToCBool compgraph) + +foreign import capi unsafe "hs_STEPControl_Writer.h hs_STEPControl_Writer_write" rawWrite :: Ptr Writer -> CString -> IO CInt + +write :: Ptr Writer -> String -> IO IFSelect.ReturnStatus.ReturnStatus +write writer filename = toEnum . fromIntegral <$> withCString filename (rawWrite writer) diff --git a/src/OpenCascade/StlAPI.hs b/src/OpenCascade/StlAPI.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/StlAPI.hs @@ -0,0 +1,5 @@ +module OpenCascade.StlAPI +( module OpenCascade.StlAPI.Types +) where + +import OpenCascade.StlAPI.Types diff --git a/src/OpenCascade/StlAPI/Internal/Destructors.hs b/src/OpenCascade/StlAPI/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/StlAPI/Internal/Destructors.hs @@ -0,0 +1,8 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.StlAPI.Internal.Destructors where + +import OpenCascade.StlAPI.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_StlAPI_Writer.h hs_delete_StlAPI_Writer" deleteWriter :: Ptr Writer -> IO () diff --git a/src/OpenCascade/StlAPI/Types.hs b/src/OpenCascade/StlAPI/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/StlAPI/Types.hs @@ -0,0 +1,5 @@ + +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.StlAPI.Types where + +data Writer diff --git a/src/OpenCascade/StlAPI/Writer.hs b/src/OpenCascade/StlAPI/Writer.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/StlAPI/Writer.hs @@ -0,0 +1,30 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.StlAPI.Writer +( new +, setAsciiMode +, write +) where + +import OpenCascade.StlAPI.Types (Writer) +import OpenCascade.StlAPI.Internal.Destructors (deleteWriter) +import qualified OpenCascade.TopoDS as TopoDS +import Foreign.C +import Foreign.Ptr +import Data.Acquire +import OpenCascade.Internal.Bool (boolToCBool, cBoolToBool) + +foreign import capi unsafe "hs_StlAPI_Writer.h hs_new_StlAPI_Writer" rawNew :: IO (Ptr Writer) + +new :: Acquire (Ptr Writer) +new = mkAcquire rawNew deleteWriter + +foreign import capi unsafe "hs_StlAPI_Writer.h hs_StlAPI_Writer_setAsciiMode" rawSetAsciiMode :: Ptr Writer -> CBool -> IO () + +setAsciiMode :: Ptr Writer -> Bool -> IO () +setAsciiMode writer mode = rawSetAsciiMode writer (boolToCBool mode) + + +foreign import capi unsafe "hs_StlAPI_Writer.h hs_StlAPI_Writer_write" rawWrite :: Ptr Writer -> Ptr TopoDS.Shape -> CString -> IO (CBool) + +write :: Ptr Writer -> Ptr TopoDS.Shape -> String -> IO (Bool) +write writer shape filename = cBoolToBool <$> withCString filename (rawWrite writer shape) diff --git a/src/OpenCascade/TopAbs.hs b/src/OpenCascade/TopAbs.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopAbs.hs @@ -0,0 +1,7 @@ +module OpenCascade.TopAbs +( Orientation +, ShapeEnum +) +where +import OpenCascade.TopAbs.Orientation +import OpenCascade.TopAbs.ShapeEnum diff --git a/src/OpenCascade/TopAbs/Orientation.hs b/src/OpenCascade/TopAbs/Orientation.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopAbs/Orientation.hs @@ -0,0 +1,6 @@ +module OpenCascade.TopAbs.Orientation +( Orientation (..) +) where + +-- this should match the orientation in TopAbs_Orientation +data Orientation = Forward | Reversed | Internal | External deriving (Show, Enum) diff --git a/src/OpenCascade/TopAbs/ShapeEnum.hs b/src/OpenCascade/TopAbs/ShapeEnum.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopAbs/ShapeEnum.hs @@ -0,0 +1,6 @@ +module OpenCascade.TopAbs.ShapeEnum +( ShapeEnum (..) +) where + +-- this should match the enumeration in TopAbs_ShapeEnum +data ShapeEnum = Compound | CompSolid | Solid | Shell | Face | Wire | Edge | Vertex | Shape deriving (Show, Eq, Enum) diff --git a/src/OpenCascade/TopExp.hs b/src/OpenCascade/TopExp.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopExp.hs @@ -0,0 +1,5 @@ +module OpenCascade.TopExp +( module OpenCascade.TopExp.Types +) where + +import OpenCascade.TopExp.Types diff --git a/src/OpenCascade/TopExp/Explorer.hs b/src/OpenCascade/TopExp/Explorer.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopExp/Explorer.hs @@ -0,0 +1,31 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopExp.Explorer +( Explorer +, new +, more +, next +, value +) where + +import OpenCascade.TopExp.Types (Explorer) +import OpenCascade.TopExp.Internal.Destructors (deleteExplorer) +import qualified OpenCascade.TopoDS as TopoDS +import qualified OpenCascade.TopAbs as TopAbs +import Data.Acquire +import Foreign.Ptr +import Foreign.C +import OpenCascade.Internal.Bool (cBoolToBool) + +foreign import capi unsafe "hs_TopExp_Explorer.h hs_new_TopExp_Explorer" rawNew :: Ptr TopoDS.Shape -> CInt -> IO (Ptr Explorer) + +new :: Ptr TopoDS.Shape -> TopAbs.ShapeEnum -> Acquire (Ptr Explorer) +new shape theType = mkAcquire (rawNew shape (fromIntegral . fromEnum $ theType)) deleteExplorer + +foreign import capi unsafe "hs_TopExp_Explorer.h hs_TopExp_Explorer_more" rawMore :: Ptr Explorer -> IO (CBool) + +more :: Ptr Explorer -> IO Bool +more = fmap (cBoolToBool) . rawMore + +foreign import capi unsafe "hs_TopExp_Explorer.h hs_TopExp_Explorer_next" next :: Ptr Explorer -> IO () + +foreign import capi unsafe "hs_TopExp_Explorer.h hs_TopExp_Explorer_value" value :: Ptr Explorer -> IO (Ptr TopoDS.Shape) diff --git a/src/OpenCascade/TopExp/Internal/Destructors.hs b/src/OpenCascade/TopExp/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopExp/Internal/Destructors.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopExp.Internal.Destructors where + +import OpenCascade.TopExp.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_TopExp_Explorer.h hs_delete_TopExp_Explorer" deleteExplorer :: Ptr Explorer -> IO () + + diff --git a/src/OpenCascade/TopExp/Types.hs b/src/OpenCascade/TopExp/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopExp/Types.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.TopExp.Types where + +data Explorer diff --git a/src/OpenCascade/TopLoc.hs b/src/OpenCascade/TopLoc.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopLoc.hs @@ -0,0 +1,4 @@ +module OpenCascade.TopLoc +( module OpenCascade.TopLoc.Types +) where +import OpenCascade.TopLoc.Types diff --git a/src/OpenCascade/TopLoc/Internal/Destructors.hs b/src/OpenCascade/TopLoc/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopLoc/Internal/Destructors.hs @@ -0,0 +1,8 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopLoc.Internal.Destructors where + +import OpenCascade.TopLoc.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_TopLoc_Location.h hs_delete_TopLoc_Location" deleteLocation :: Ptr Location -> IO () diff --git a/src/OpenCascade/TopLoc/Location.hs b/src/OpenCascade/TopLoc/Location.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopLoc/Location.hs @@ -0,0 +1,126 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopLoc.Location +( Location +, new +, fromGPTrsf +, isIdentity +, firstPower +, nextLocation +, inverted +, multiplied +, divided +, predivided +, powered +, isEqual +, isDifferent +, clear +, toGPTrsf +) where + +import OpenCascade.TopLoc.Types +import OpenCascade.TopLoc.Internal.Destructors +import OpenCascade.GP.Internal.Destructors (deleteTrsf) +import Foreign.C +import Foreign.Ptr +import Data.Acquire +import qualified OpenCascade.GP as GP + +-- new + +foreign import capi unsafe "hs_TopLoc_Location.h hs_new_TopLoc_Location" rawNew :: IO (Ptr Location) + +new :: Acquire (Ptr Location) +new = mkAcquire rawNew deleteLocation + +-- from GP.Trsf + +foreign import capi unsafe "hs_TopLoc_Location.h hs_new_TopLoc_Location_fromGPTrsf" rawFromGPTrsf :: Ptr GP.Trsf -> IO (Ptr Location) + +fromGPTrsf :: Ptr (GP.Trsf) -> Acquire (Ptr Location) +fromGPTrsf t = mkAcquire (rawFromGPTrsf t) deleteLocation + +-- isIdentity + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_IsIdentity" rawIsIdentity :: Ptr Location -> IO (CBool) + +isIdentity :: Ptr Location -> IO Bool +isIdentity l = (/=0) <$> rawIsIdentity l + +-- firstPower +-- +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_FirstPower" rawFirstPower :: Ptr Location -> IO (CInt) + +firstPower :: Ptr Location -> IO Int +firstPower l = fromIntegral <$> rawFirstPower l + +-- nextLocation + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_NextLocation" rawNextLocation :: Ptr Location -> IO (Ptr Location) + +nextLocation :: Ptr Location -> Acquire (Ptr Location) +nextLocation l = mkAcquire (rawNextLocation l) deleteLocation + +-- inverted + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Inverted" rawInverted :: Ptr Location -> IO (Ptr Location) + +inverted :: Ptr Location -> Acquire (Ptr Location) +inverted l = mkAcquire (rawInverted l) deleteLocation + +-- multiplied + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Multiplied" rawMultiplied :: Ptr Location -> Ptr Location -> IO (Ptr Location) + +multiplied :: Ptr Location -> Ptr Location -> Acquire (Ptr Location) +multiplied a b = mkAcquire (rawMultiplied a b) deleteLocation + + +-- divided + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Divided" rawDivided :: Ptr Location -> Ptr Location -> IO (Ptr Location) + +divided :: Ptr Location -> Ptr Location -> Acquire (Ptr Location) +divided a b = mkAcquire (rawDivided a b) deleteLocation + + +-- predivided + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Predivided" rawPredivided :: Ptr Location -> Ptr Location -> IO (Ptr Location) + +predivided :: Ptr Location -> Ptr Location -> Acquire (Ptr Location) +predivided a b = mkAcquire (rawPredivided a b) deleteLocation + +-- powered + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Powered" rawPowered :: Ptr Location -> CInt -> IO (Ptr Location) + +powered :: Ptr Location -> Int -> Acquire (Ptr Location) +powered l p = mkAcquire (rawPowered l (fromIntegral p)) deleteLocation + +-- isEqual + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_IsEqual" rawIsEqual :: Ptr Location -> Ptr Location -> IO (CBool) + +isEqual :: Ptr Location -> Ptr Location -> IO Bool +isEqual a b = (/=0) <$> rawIsEqual a b + + +-- isDifferent + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_IsDifferent" rawIsDifferent :: Ptr Location -> Ptr Location -> IO (CBool) + +isDifferent :: Ptr Location -> Ptr Location -> IO Bool +isDifferent a b = (/=0) <$> rawIsDifferent a b + + +-- clear + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_Clear" clear :: Ptr Location -> IO () + +-- toGPTrsf +-- + +foreign import capi unsafe "hs_TopLoc_Location.h hs_TopLoc_Location_toGPTrsf" rawToGPTrsf :: Ptr Location -> IO (Ptr GP.Trsf) + +toGPTrsf :: Ptr Location -> Acquire (Ptr GP.Trsf) +toGPTrsf l = mkAcquire (rawToGPTrsf l) deleteTrsf diff --git a/src/OpenCascade/TopLoc/Types.hs b/src/OpenCascade/TopLoc/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopLoc/Types.hs @@ -0,0 +1,5 @@ +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.TopLoc.Types where + +data Location + diff --git a/src/OpenCascade/TopTools.hs b/src/OpenCascade/TopTools.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopTools.hs @@ -0,0 +1,4 @@ +module OpenCascade.TopTools +( module OpenCascade.TopTools.Types +) where +import OpenCascade.TopTools.Types diff --git a/src/OpenCascade/TopTools/Types.hs b/src/OpenCascade/TopTools/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopTools/Types.hs @@ -0,0 +1,4 @@ +{-# LANGUAGE EmptyDataDecls #-} +module OpenCascade.TopTools.Types where + +data ListOfShape diff --git a/src/OpenCascade/TopoDS.hs b/src/OpenCascade/TopoDS.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE MultiParamTypeClasses #-} +module OpenCascade.TopoDS +( module OpenCascade.TopoDS.Types +) where + +import OpenCascade.TopoDS.Types diff --git a/src/OpenCascade/TopoDS/CompSolid.hs b/src/OpenCascade/TopoDS/CompSolid.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/CompSolid.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.CompSolid +( CompSolid +, new +) where + +import OpenCascade.TopoDS.Types +import OpenCascade.TopoDS.Internal.Destructors +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_TopoDS_CompSolid.h hs_new_TopoDS_CompSolid" rawNew :: IO (Ptr CompSolid) + +new :: Acquire (Ptr CompSolid) +new = mkAcquire rawNew (deleteShape . castPtr) diff --git a/src/OpenCascade/TopoDS/Compound.hs b/src/OpenCascade/TopoDS/Compound.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Compound.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Compound +( Compound +, new +) where + +import OpenCascade.TopoDS.Types +import OpenCascade.TopoDS.Internal.Destructors +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_TopoDS_Compound.h hs_new_TopoDS_Compound" rawNew :: IO (Ptr Compound) + +new :: Acquire (Ptr Compound) +new = mkAcquire rawNew (deleteShape . castPtr) diff --git a/src/OpenCascade/TopoDS/Edge.hs b/src/OpenCascade/TopoDS/Edge.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Edge.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Edge +( Edge +, new +) where + +import OpenCascade.TopoDS.Types +import OpenCascade.TopoDS.Internal.Destructors +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_TopoDS_Edge.h hs_new_TopoDS_Edge" rawNew :: IO (Ptr Edge) + +new :: Acquire (Ptr Edge) +new = mkAcquire rawNew (deleteShape . castPtr) diff --git a/src/OpenCascade/TopoDS/Face.hs b/src/OpenCascade/TopoDS/Face.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Face.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Face +( Face +, new +) where + +import OpenCascade.TopoDS.Types +import OpenCascade.TopoDS.Internal.Destructors +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_TopoDS_Face.h hs_new_TopoDS_Face" rawNew :: IO (Ptr Face) + +new :: Acquire (Ptr Face) +new = mkAcquire rawNew (deleteShape . castPtr) diff --git a/src/OpenCascade/TopoDS/Internal/Destructors.hs b/src/OpenCascade/TopoDS/Internal/Destructors.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Internal/Destructors.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Internal.Destructors where + +import OpenCascade.TopoDS.Types + +import Foreign.Ptr + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_delete_TopoDS_Shape" deleteShape :: Ptr Shape -> IO () + + diff --git a/src/OpenCascade/TopoDS/Shape.hs b/src/OpenCascade/TopoDS/Shape.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Shape.hs @@ -0,0 +1,341 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Shape +( Shape +, new +, copy +, isNull +, nullify +, location +, setLocation +, located +, orientation +, setOrientation +, oriented +, shapeType +, free +, setFree +, locked +, setLocked +, modified +, setModified +, checked +, setChecked +, orientable +, setOrientable +, closed +, setClosed +, infinite +, setInfinite +, convex +, setConvex +, move +, moved +, nbChildren +, reverse +, reversed +, complement +, complemented +, isEqual +, isPartner +, isSame +, isNotEqual +, emptyCopy +, emptyCopied +, hashCode +) where + +import Prelude hiding (reverse) +import OpenCascade.TopoDS.Types +import OpenCascade.TopoDS.Internal.Destructors +import OpenCascade.Internal.Bool +import Foreign.C +import Foreign.Ptr +import Data.Acquire + +import qualified OpenCascade.TopLoc as TopLoc +import qualified OpenCascade.TopLoc.Internal.Destructors as TopLoc.Destructors +import qualified OpenCascade.TopAbs as TopAbs +-- new + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_new_TopoDS_Shape" rawNew :: IO (Ptr Shape) + +new :: Acquire (Ptr Shape) +new = mkAcquire rawNew deleteShape + +-- copy + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_new_TopoDS_Shape" rawCopy :: Ptr Shape -> IO (Ptr Shape) + +copy :: Ptr Shape -> Acquire (Ptr Shape) +copy shape = mkAcquire (rawCopy shape) deleteShape + +-- isNull +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsNull" rawIsNull :: Ptr Shape -> IO CBool + +isNull :: Ptr Shape -> IO Bool +isNull s = cBoolToBool <$> rawIsNull s + +-- Nullify +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Nullify" nullify :: Ptr Shape -> IO () + +-- location +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Location" rawLocation :: Ptr Shape -> IO (Ptr TopLoc.Location) + +location :: Ptr Shape -> Acquire (Ptr TopLoc.Location) +location s = mkAcquire (rawLocation s) TopLoc.Destructors.deleteLocation + +-- setLocation +-- + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetLocation" setLocation :: Ptr Shape -> Ptr TopLoc.Location -> IO () + +-- located +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Located" rawLocated :: Ptr Shape -> Ptr TopLoc.Location -> IO (Ptr Shape) + +located :: Ptr Shape -> Ptr TopLoc.Location -> Acquire (Ptr Shape) +located s l = mkAcquire (rawLocated s l) deleteShape + + +-- orientation + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Orientation" rawOrientation :: Ptr Shape -> IO (CInt) + +orientation :: Ptr Shape -> IO TopAbs.Orientation +orientation s = toEnum . fromIntegral <$> rawOrientation s + +-- setOrientation + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetOrientation" rawSetOrientation :: Ptr Shape -> CInt -> IO () + +setOrientation :: Ptr Shape -> TopAbs.Orientation -> IO () +setOrientation s o = rawSetOrientation s (fromIntegral . fromEnum $ o) + + +-- oriented +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Oriented" rawOriented :: Ptr Shape -> CInt -> IO (Ptr Shape) + +oriented :: Ptr Shape -> TopAbs.Orientation -> Acquire (Ptr Shape) +oriented s o = mkAcquire (rawOriented s (fromIntegral . fromEnum $ o)) deleteShape + +-- shapeType +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_ShapeType" rawShapeType :: Ptr Shape -> IO CInt + +shapeType :: Ptr Shape -> IO TopAbs.ShapeEnum +shapeType s = toEnum . fromIntegral <$> rawShapeType s + +-- free + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Free" rawFree :: Ptr Shape -> IO CBool + +free :: Ptr Shape -> IO Bool +free s = cBoolToBool <$> rawFree s + +--setFree + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetFree" rawSetFree :: Ptr Shape -> CBool-> IO () + +setFree :: Ptr Shape -> Bool -> IO () +setFree s b = rawSetFree s (boolToCBool b) + +-- locked + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Locked" rawLocked :: Ptr Shape -> IO CBool + +locked :: Ptr Shape -> IO Bool +locked s = cBoolToBool <$> rawLocked s + +--setLocked + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetLocked" rawSetLocked :: Ptr Shape -> CBool-> IO () + +setLocked :: Ptr Shape -> Bool -> IO () +setLocked s b = rawSetLocked s (boolToCBool b) + + + +-- modified + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Modified" rawModified :: Ptr Shape -> IO CBool + +modified :: Ptr Shape -> IO Bool +modified s = cBoolToBool <$> rawModified s + +--setModified + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetModified" rawSetModified :: Ptr Shape -> CBool-> IO () + +setModified :: Ptr Shape -> Bool -> IO () +setModified s b = rawSetModified s (boolToCBool b) + + +-- checked + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Checked" rawChecked :: Ptr Shape -> IO CBool + +checked :: Ptr Shape -> IO Bool +checked s = cBoolToBool <$> rawChecked s + +--setChecked + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetChecked" rawSetChecked :: Ptr Shape -> CBool-> IO () + +setChecked :: Ptr Shape -> Bool -> IO () +setChecked s b = rawSetChecked s (boolToCBool b) + +-- orientable + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Orientable" rawOrientable :: Ptr Shape -> IO CBool + +orientable :: Ptr Shape -> IO Bool +orientable s = cBoolToBool <$> rawOrientable s + +--setOrientable + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetOrientable" rawSetOrientable :: Ptr Shape -> CBool-> IO () + +setOrientable :: Ptr Shape -> Bool -> IO () +setOrientable s b = rawSetOrientable s (boolToCBool b) + +-- closed + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Closed" rawClosed :: Ptr Shape -> IO CBool + +closed :: Ptr Shape -> IO Bool +closed s = cBoolToBool <$> rawClosed s + +--setClosed + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetClosed" rawSetClosed :: Ptr Shape -> CBool-> IO () + +setClosed :: Ptr Shape -> Bool -> IO () +setClosed s b = rawSetClosed s (boolToCBool b) + + +-- infinite + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Infinite" rawInfinite :: Ptr Shape -> IO CBool + +infinite :: Ptr Shape -> IO Bool +infinite s = cBoolToBool <$> rawInfinite s + +--setInfinite + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetInfinite" rawSetInfinite :: Ptr Shape -> CBool-> IO () + +setInfinite :: Ptr Shape -> Bool -> IO () +setInfinite s b = rawSetInfinite s (boolToCBool b) + + + +-- convex + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Convex" rawConvex :: Ptr Shape -> IO CBool + +convex :: Ptr Shape -> IO Bool +convex s = cBoolToBool <$> rawConvex s + +--setConvex + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_SetConvex" rawSetConvex :: Ptr Shape -> CBool-> IO () + +setConvex :: Ptr Shape -> Bool -> IO () +setConvex s b = rawSetConvex s (boolToCBool b) + + +-- move +-- + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Move" move :: Ptr Shape -> Ptr TopLoc.Location -> IO () + +-- moved +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Moved" rawMoved :: Ptr Shape -> Ptr TopLoc.Location -> IO (Ptr Shape) + +moved :: Ptr Shape -> Ptr TopLoc.Location -> Acquire (Ptr Shape) +moved s l = mkAcquire (rawMoved s l) deleteShape + +-- nbChildren + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_NbChildren" rawNbChildren :: Ptr Shape -> IO (CInt) + +nbChildren :: Ptr Shape -> IO Int +nbChildren s = fromIntegral <$> rawNbChildren s + +-- reverse +-- + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Reverse" reverse :: Ptr Shape -> IO () + +-- reversed +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Reversed" rawReversed :: Ptr Shape -> IO (Ptr Shape) + +reversed :: Ptr Shape -> Acquire (Ptr Shape) +reversed s = mkAcquire (rawReversed s) deleteShape + + +-- complement +-- + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Complement" complement :: Ptr Shape -> IO () + +-- complemented +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_Complemented" rawComplemented :: Ptr Shape -> IO (Ptr Shape) + +complemented :: Ptr Shape -> Acquire (Ptr Shape) +complemented s = mkAcquire (rawComplemented s) deleteShape + +-- isEqual + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsEqual" rawIsEqual :: Ptr Shape -> Ptr Shape -> IO CBool + +isEqual :: Ptr Shape -> Ptr Shape -> IO Bool +isEqual a b = cBoolToBool <$> rawIsEqual a b + + +-- isSame + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsSame" rawIsSame :: Ptr Shape -> Ptr Shape -> IO CBool + +isSame :: Ptr Shape -> Ptr Shape -> IO Bool +isSame a b = cBoolToBool <$> rawIsSame a b + + +-- isPartner + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsPartner" rawIsPartner :: Ptr Shape -> Ptr Shape -> IO CBool + +isPartner :: Ptr Shape -> Ptr Shape -> IO Bool +isPartner a b = cBoolToBool <$> rawIsPartner a b + +-- isNotEqual + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_IsNotEqual" rawIsNotEqual :: Ptr Shape -> Ptr Shape -> IO CBool + +isNotEqual :: Ptr Shape -> Ptr Shape -> IO Bool +isNotEqual a b = cBoolToBool <$> rawIsNotEqual a b + +-- emptyCopy +-- + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_EmptyCopy" emptyCopy :: Ptr Shape -> IO () + +-- emptyCopied +-- +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_EmptyCopied" rawEmptyCopied :: Ptr Shape -> IO (Ptr Shape) + +emptyCopied :: Ptr Shape -> Acquire (Ptr Shape) +emptyCopied s = mkAcquire (rawEmptyCopied s) deleteShape + + +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_hashCode" rawHashCode :: Ptr Shape -> CInt -> IO CInt + +hashCode :: Ptr Shape -> Int -> IO Int +hashCode shape upperBound = fromIntegral <$> rawHashCode shape (fromIntegral upperBound) diff --git a/src/OpenCascade/TopoDS/Shell.hs b/src/OpenCascade/TopoDS/Shell.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Shell.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Shell +( Shell +, new +) where + +import OpenCascade.TopoDS.Types +import OpenCascade.TopoDS.Internal.Destructors +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_TopoDS_Shell.h hs_new_TopoDS_Shell" rawNew :: IO (Ptr Shell) + +new :: Acquire (Ptr Shell) +new = mkAcquire rawNew (deleteShape . castPtr) diff --git a/src/OpenCascade/TopoDS/Solid.hs b/src/OpenCascade/TopoDS/Solid.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Solid.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Solid +( Solid +, new +) where + +import OpenCascade.TopoDS.Types +import OpenCascade.TopoDS.Internal.Destructors +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_TopoDS_Solid.h hs_new_TopoDS_Solid" rawNew :: IO (Ptr Solid) + +new :: Acquire (Ptr Solid) +new = mkAcquire rawNew (deleteShape . castPtr) diff --git a/src/OpenCascade/TopoDS/Types.hs b/src/OpenCascade/TopoDS/Types.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Types.hs @@ -0,0 +1,96 @@ +{-# LANGUAGE EmptyDataDecls #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Types +( Shape +, CompSolid +, Compound +, Edge +, Face +, Shell +, Solid +, Vertex +, Wire +) + +where + + +import OpenCascade.Inheritance +import OpenCascade.TopAbs.ShapeEnum +import qualified OpenCascade.TopAbs.ShapeEnum as ShapeEnum +import Foreign.Ptr +import Foreign.C + + +data Shape +data CompSolid +data Compound +data Edge +data Face +data Shell +data Solid +data Vertex +data Wire + +-- duplicate definition of shape type from TopoDS.Shape +-- to simultaniously avoid Orphan Instances + circular dependencies +foreign import capi unsafe "hs_TopoDS_Shape.h hs_TopoDS_Shape_ShapeType" rawShapeType :: Ptr Shape -> IO CInt + +shapeType :: Ptr Shape -> IO ShapeEnum +shapeType s = toEnum . fromIntegral <$> rawShapeType s + +enumDowncast :: ShapeEnum -> Ptr Shape -> IO (Maybe (Ptr t)) +enumDowncast enum p = do + e <- shapeType p + return $ if e == enum + then Just (castPtr p) + else Nothing + + +instance SubTypeOf Shape Compound + +instance DiscriminatedSubTypeOf Shape Compound where + downcast = enumDowncast ShapeEnum.Compound + + +instance SubTypeOf Shape CompSolid + +instance DiscriminatedSubTypeOf Shape CompSolid where + downcast = enumDowncast ShapeEnum.CompSolid + + +instance SubTypeOf Shape Solid + +instance DiscriminatedSubTypeOf Shape Solid where + downcast = enumDowncast ShapeEnum.Solid + + +instance SubTypeOf Shape Shell + +instance DiscriminatedSubTypeOf Shape Shell where + downcast = enumDowncast ShapeEnum.Shell + + +instance SubTypeOf Shape Face + +instance DiscriminatedSubTypeOf Shape Face where + downcast = enumDowncast ShapeEnum.Face + +instance SubTypeOf Shape Wire + +instance DiscriminatedSubTypeOf Shape Wire where + downcast = enumDowncast ShapeEnum.Wire + + +instance SubTypeOf Shape Edge + +instance DiscriminatedSubTypeOf Shape Edge where + downcast = enumDowncast ShapeEnum.Edge + + +instance SubTypeOf Shape Vertex + +instance DiscriminatedSubTypeOf Shape Vertex where + downcast = enumDowncast ShapeEnum.Vertex + diff --git a/src/OpenCascade/TopoDS/Vertex.hs b/src/OpenCascade/TopoDS/Vertex.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Vertex.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Vertex +( Vertex +, new +) where + +import OpenCascade.TopoDS.Types +import OpenCascade.TopoDS.Internal.Destructors +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_TopoDS_Vertex.h hs_new_TopoDS_Vertex" rawNew :: IO (Ptr Vertex) + +new :: Acquire (Ptr Vertex) +new = mkAcquire rawNew (deleteShape . castPtr) diff --git a/src/OpenCascade/TopoDS/Wire.hs b/src/OpenCascade/TopoDS/Wire.hs new file mode 100644 --- /dev/null +++ b/src/OpenCascade/TopoDS/Wire.hs @@ -0,0 +1,17 @@ +{-# LANGUAGE CApiFFI #-} +module OpenCascade.TopoDS.Wire +( Wire +, new +) where + +import OpenCascade.TopoDS.Types +import OpenCascade.TopoDS.Internal.Destructors +import Foreign.Ptr +import Data.Acquire + +-- new + +foreign import capi unsafe "hs_TopoDS_Wire.h hs_new_TopoDS_Wire" rawNew :: IO (Ptr Wire) + +new :: Acquire (Ptr Wire) +new = mkAcquire rawNew (deleteShape . castPtr)