doml

Modules

axis_angle_4d
module doml.axis_angle_4d

Represents a 3D rotation of a given radians about an axis represented as an unit 3D vector. <p> This class uses double-precision components.

frustum_intersection
module doml.frustum_intersection

Efficiently performs frustum intersection tests by caching the frustum planes of an arbitrary transformation {@link Matrix4d matrix}. <p> This class is preferred over the frustum intersection methods in {@link Matrix4d} when many objects need to be culled by the same static frustum.

frustum_ray_builder
module doml.frustum_ray_builder

Provides methods to compute rays through an arbitrary perspective transformation defined by a {@link Matrix4d}. <p> This can be used to compute the eye-rays in simple software-based raycasting/raytracing. <p> To obtain the origin of the rays call {@link #origin(Vector3d)}. Then to compute the directions of subsequent rays use {@link #dir(double, double, Vector3d)}.

geometry_utils
module doml.geometry_utils

Useful geometry methods.

interpolation_d
module doml.interpolation_d

Contains various interpolation functions.

intersection_d
module doml.intersection_d

Contains intersection and distance tests for some 2D and 3D geometric primitives.

math
module doml.math

Contains fast approximations of some {@link java.lang.Math} operations. <p> By default, {@link java.lang.Math} methods will be used by all other DOML classes. In order to use the approximations in this class, start the JVM with the parameter <code>-DDOML.fastmath</code>. <p> There are two algorithms for approximating sin/cos: <ol> <li>arithmetic <a href="http://www.java-gaming.org/topics/DOML-1-8-0-release/37491/msg/361815/view.html#msg361815">polynomial approximation</a> contributed by roquendm <li>theagentd's <a href="http://www.java-gaming.org/topics/extremely-fast-sine-cosine/36469/msg/346213/view.html#msg346213">linear interpolation</a> variant of Riven's algorithm from <a href="http://www.java-gaming.org/topics/extremely-fast-sine-cosine/36469/view.html">http://www.java-gaming.org/</a> </ol> By default, the first algorithm is being used. In order to use the second one, start the JVM with <code>-DDOML.sinLookup</code>. The lookup table bit length of the second algorithm can also be adjusted for improved accuracy via <code>-DDOML.sinLookup.bits=&lt;n&gt;</code>, where &lt;n&gt; is the number of bits of the lookup table.

matrix_2d
module doml.matrix_2d

Contains the definition of a 2x2 matrix of doubles, and associated functions to transform it. The matrix is column-major to match OpenGL's interpretation, and it looks like this: <p> m00 m10<br> m01 m11<br>

matrix_3d
module doml.matrix_3d

Contains the definition of a 3x3 matrix of doubles, and associated functions to transform it. The matrix is column-major to match OpenGL's interpretation, and it looks like this: <p> m00 m10 m20<br> m01 m11 m21<br> m02 m12 m22<br>

matrix_3x2d
module doml.matrix_3x2d

Contains the definition of a 3x2 matrix of doubles, and associated functions to transform it. The matrix is column-major to match OpenGL's interpretation, and it looks like this: <p> m00 m10 m20<br> m01 m11 m21<br>

matrix_4d
module doml.matrix_4d

Contains the definition of a 4x4 Matrix of doubles, and associated functions to transform it. The matrix is column-major to match OpenGL's interpretation, and it looks like this: <p> m00 m10 m20 m30<br> m01 m11 m21 m31<br> m02 m12 m22 m32<br> m03 m13 m23 m33<br>

matrix_4x3d
module doml.matrix_4x3d

Contains the definition of an affine 4x3 matrix (4 columns, 3 rows) of doubles, and associated functions to transform it. The matrix is column-major to match OpenGL's interpretation, and it looks like this: <p> m00 m10 m20 m30<br> m01 m11 m21 m31<br> m02 m12 m22 m32<br>

mem_util
module doml.mem_util

Helper class to do efficient memory operations on all DOML objects, NIO buffers and primitive arrays. This class is used internally throughout DOML, is undocumented and is subject to change. Use with extreme caution!

options
module doml.options

Utility class for reading system properties.

quaternion_d
module doml.quaternion_d

Quaternion of 4 double-precision doubles which can represent rotation and uniform scaling.

quaternion_d_interpolator
module doml.quaternion_d_interpolator

Computes the weighted average of multiple rotations represented as {@link Quaterniond} instances. <p> Instances of this class are <i>not</i> thread-safe.

ray_aabb_intersection
module doml.ray_aabb_intersection

This is an implementation of the <a href="http://www.cg.cs.tu-bs.de/media/publications/fast-rayaxis-aligned-bounding-box-overlap-tests-using-ray-slopes.pdf">Fast Ray/Axis-Aligned Bounding Box Overlap Tests using Ray Slopes</a> paper. <p> It is an efficient implementation when testing many axis-aligned boxes against the same ray. <p> This class is thread-safe and can be used in a multithreaded environment when testing many axis-aligned boxes against the same ray concurrently.

rounding_mode
module doml.rounding_mode

Rounding modes.

tests
module doml.tests
vector_2d
module doml.vector_2d

Represents a 2D vector with double-precision.

vector_2i
module doml.vector_2i

Represents a 2D vector with integral-precision.

vector_3d
module doml.vector_3d

Contains the definition of a Vector comprising 3 doubles and associated transformations.

vector_3i
module doml.vector_3i

Contains the definition of a Vector comprising 3 ints and associated transformations.

vector_4d
module doml.vector_4d

Contains the definition of a Vector comprising 4 doubles and associated transformations.

vector_4i
module doml.vector_4i

Contains the definition of a Vector comprising 4 ints and associated transformations.