Welcome to the official site for the Geometric Tools Engine, a library of source code for computing in the fields of mathematics, graphics, image analysis and physics. The engine is written in C++ 11 and, as such, has portable access to standard constructs for multithreading programming on cores. The engine also supports high-performance computing using general purpose GPU programming (GPGPU). SIMD code is also available using Intel Streaming SIMD Extensions (SSE). Portions of the code are described in various books as well as in documents available at this site. The source code is freely downloadable.
The current version of the library is Geometric Tools Engine (GTEngine) 3.10, posted on September 16, 2017. The source code is covered by the Boost License. The following operating systems and compilers are supported, and testing was performed on all systems. GTEngine requires OpenGL 4.3 (or later) and GLSL 4.3 (or later) in order to support compute shaders and GLSL introspection.
Geometric Tools: The Final Cut. I plan on one last evolutionary step for
the source code, The Geometric Tools Library (GTL). The motivation for
Geometric Tools was initiated by my graduate school studies in medical image
processing; it was then named Magic Software (My Alternate Graphics
and Image Code). When I entered the 3D video game industry,
I spent less time on image code and more time on graphics, physics and mathematics code.
Much of the code was a result of helping people who posted problems to the Usenet forum
comp.graphics.algorithms. I am now deep into high-performance computing
in several areas where the problems are even more heavy on the mathematics and geometry.
Technical support questions over recent years have made it clear to me that the
mathematics and geometry code is what people use the most, so I will focus on those
GTL will be a reworking of the mathematics and geometry code in GTEngine followed by adding new code as time permits. Some users have been reluctant to use GTEngine because it supports only Microsoft Visual Studio 2013 and later, instead opting for Wild Magic 5 because there is also support for Microsoft Visual Studio 2010 and 2012. I stopped maintaining that code base quite some time ago, and any bugs I have discovered in GTEngine have not been retrofitted to Wild Magic 5. Unfortunately, these older compiler versions do not support the full C++11 feature set. I am trying to ensure that GTL compiles with Microsoft Visual Studio 2012 and later. There is a chance I can tolerate the pain of Microsoft Visual Studio 2010 and have it compile GTL (no promises, though). The code will also be developed to run on Linux distributions. Macintosh support is out of the question.
I am attempting to streamline the code, to provide consistent naming and interfaces and to extend the capabilities. For example, GTEngine has class Vector for sizes known at compile time and class GVector for sizes known only at run time. In GTL, these are consolidated into shared template code with name Vector<T,N>. When N is positive, you get the class for compile-time-known sizes. When N is 0 (the default template parameter), the name is Vector<T> and you get the class for the run-time-known sizes. Moreover, the run-time-known class includes adapter member functions that allow you to provide raw pointers to be reinterpreted as class objects. In GTEngine, there are multiple classes that represent matrix objects; for example, Matrix, GMatrix, Array2 and LexicoArray2. Row-major or column-major storage is specified by conditional compilation. In GTL, these classes are consolidated into a single class Matrix with selection of compile-time-known or run-time-known sizes based on template parameters. Moreover, the choice of row-major or column-major order is made by template parameter, so you can use both conventions as needed. Matrix also has adapter member functions that allow you to provide raw pointers to be reinterpreted as matrices.
Some of the GTEngine geometry code already contains multithreading, especially useful when the numeric type is BSNumber or BSRational for exact rational arithmetic. In GTL, I plan to include multithreading in more algorithms. Separate libraries will be available for GPGPU-based implementations using CUDA, HLSL or GLSL and for SIMD-based implementations using Intel's SSE or AVX.
GTL will be written in a semi-literate programming style. A PDF-based reference document will be provided that describes the algorithms, the implementations and examples of how to use the code. Hyperlinks will exist from the reference document to the source-code files and vice versa. Effectively, this (large) reference is my single-authored version 2 of the book Geometric Tools for Computer Graphics.
The code base has an associated unit-test suite. No code will be posted to the website unless it has accompanying unit tests and documentation. Any code for graphics and application support exists only for samples that illustrate the GTL algorithms, and it will be contained in a separate library, provided as-is without unit-test support.
Like its predecessors, the GTL source code will be freely downloadable and subject to the Boost License.
Special thanks to Justin "Satriani" Hunt for the website design and support.