Commits

Michael Ludwig committed 4648db1

Find/replace <tt> tags with <var> tags in JavaDoc comments.

Comments (0)

Files changed (57)

ferox-input/src/main/java/com/ferox/input/logic/InputManager.java

     /**
      * <p/>
      * Begin registering a new action with this InputManager that will be triggered when
-     * <tt>predicate</tt> evaluates to true. The action will not be registered until
+     * <var>predicate</var> evaluates to true. The action will not be registered until
      * {@link ActionBuilder#trigger(Action)} is called on the returned ActionBuilder.
      * <p/>
      * This allows code to read reasonably fluently: <code>manager.on(condition).trigger(action);</code>
     /**
      * Remove or unregister the given action from this manager. If the action was
      * registered with multiple predicates, all occurrences of it will be removed to
-     * guarantee that <tt>trigger</tt> can no longer be invoked as a result of calling
+     * guarantee that <var>trigger</var> can no longer be invoked as a result of calling
      * this manager's {@link #process()} method.
      *
      * @param trigger The trigger to remove

ferox-input/src/main/java/com/ferox/input/logic/Predicate.java

  */
 public interface Predicate {
     /**
-     * Return true if the state transition represented by <tt>prev</tt> and <tt>next</tt>
-     * match the internal rules of this predicate.
+     * Return true if the state transition represented by <var>prev</var> and
+     * <var>next</var> match the internal rules of this predicate.
      *
      * @param prev The previous state
      * @param next The next state

ferox-input/src/main/java/com/ferox/input/logic/Predicates.java

 
     /**
      * Return a Predicate that evaluates to true when the key code is pressed and released
-     * in under <tt>delay</tt> milliseconds (i.e. typing that key). This will not evaluate
-     * to true until the key is released. If the release occurs too slowly, it will not
-     * trigger.
+     * in under <var>delay</var> milliseconds (i.e. typing that key). This will not
+     * evaluate to true until the key is released. If the release occurs too slowly, it
+     * will not trigger.
      *
      * @param code  The key that is typed
      * @param delay The maximum delay between press and release, in ms
 
     /**
      * Return a Predicate that evaluates to true when the mouse button is pressed and
-     * released <tt>numClicks</tt> times in under 150 milliseconds (i.e. multiple clicks).
-     * This will not evaluate to true until the button is released. If the release occurs
-     * too slowly, it will not trigger.
+     * released <var>numClicks</var> times in under 150 milliseconds (i.e. multiple
+     * clicks). This will not evaluate to true until the button is released. If the
+     * release occurs too slowly, it will not trigger.
      *
      * @param button The button that is clicked
      *
 
     /**
      * Return a Predicate that evaluates to true when the mouse button is pressed and
-     * released <tt>numClicks</tt> times in under <tt>delay</tt> milliseconds (i.e.
+     * released <var>numClicks</var> times in under <var>delay</var> milliseconds (i.e.
      * multiple clicks). This will not evaluate to true until the button is released. If
      * the release occurs too slowly, it will not trigger.
      *
     /**
      * <p/>
      * Return a Predicate that evaluates to true when the mouse's position changes. If
-     * <tt>allowAnyButton</tt> is true, then the predicate does not depend on the mouse's
-     * button state and will return true regardless of which buttons are held down.
+     * <var>allowAnyButton</var> is true, then the predicate does not depend on the
+     * mouse's button state and will return true regardless of which buttons are held
+     * down.
      * <p/>
      * If it is false, the predicate will only return true when no buttons are held down.
      *

ferox-math/src/main/java/com/ferox/math/AxisAlignedBox.java

 
     /**
      * Create a new AxisAlignedBox that uses the given minimum and maximum vectors as its
-     * two control points. Both <tt>min</tt> and <tt>max</tt> will be copied into the
+     * two control points. Both <var>min</var> and <var>max</var> will be copied into the
      * vectors used by the box. It is permissible but not recommended to create an
      * AxisAlignedBox in an inconsistent state.
      *
     }
 
     /**
-     * Create a new AxisAlignedBox that is a clone of <tt>aabb</tt>.
+     * Create a new AxisAlignedBox that is a clone of <var>aabb</var>.
      *
      * @param aabb The AxisAlignedBox to copy
      *
 
     /**
      * Create a new AxisAlignedBox that is fitted to the coordinate data stored in
-     * <tt>vertices</tt>. It is assumed that <tt>vertices</tt> holds <tt>numVertices</tt>
-     * 3D vertices, starting at <tt>offset</tt>. The x, y, and z coordinates are
-     * consecutive elements, with <tt>stride</tt> elements between consecutive vertices.
-     * The created AxisAlignedBox will fit the set of vertices as best as possible.
+     * <var>vertices</var>. It is assumed that <var>vertices</var> holds
+     * <var>numVertices</var> 3D vertices, starting at <var>offset</var>. The x, y, and z
+     * coordinates are consecutive elements, with <var>stride</var> elements between
+     * consecutive vertices. The created AxisAlignedBox will fit the set of vertices as
+     * best as possible.
      *
      * @param vertices    A set of 3D vertices representing a shape, either a point cloud
      *                    or something more complex
     }
 
     /**
-     * Copy the state of <tt>aabb</tt> into this AxisAlignedBox so that this
-     * AxisAlignedBox is equivalent to <tt>aabb</tt>.
+     * Copy the state of <var>aabb</var> into this AxisAlignedBox so that this
+     * AxisAlignedBox is equivalent to <var>aabb</var>.
      *
      * @param aabb The AxisAlignedBox to clone
      *
     }
 
     /**
-     * Return true if this AxisAlignedBox and <tt>other</tt> intersect. It is assumed that
-     * both boxes exist within the same coordinate space. An intersection occurs if any
-     * portion of the two boxes overlap.
+     * Return true if this AxisAlignedBox and <var>other</var> intersect. It is assumed
+     * that both boxes exist within the same coordinate space. An intersection occurs if
+     * any portion of the two boxes overlap.
      *
      * @param other The AxisAlignedBox to test for intersection
      *
     }
 
     /**
-     * Return true if <tt>other</tt> is completely contained within the extents of this
+     * Return true if <var>other</var> is completely contained within the extents of this
      * ReadOnlyAxisAlignedBox. It is assumed that both bounds exist within the same
      * coordinate space.
      *
     }
 
     /**
-     * Compute the intersection of <tt>a</tt> and <tt>b</tt> and store it in this
-     * AxisAlignedBox. If <tt>a</tt> and <tt>b</tt> do not {@link
+     * Compute the intersection of <var>a</var> and <var>b</var> and store it in this
+     * AxisAlignedBox. If <var>a</var> and <var>b</var> do not {@link
      * #intersects(AxisAlignedBox) intersect}, the computed intersection will be an
      * inconsistent box.
      *
     }
 
     /**
-     * Compute the union of <tt>a</tt> and <tt>b</tt> and store the computed bounds in
+     * Compute the union of <var>a</var> and <var>b</var> and store the computed bounds in
      * this AxisAlignedBox.
      *
      * @param a The AxisAlignedBox that is part of the union
 
     /**
      * <p/>
-     * Transform <tt>aabb</tt> by <tt>m</tt> and store the transformed bounds in this
+     * Transform <var>aabb</var> by <var>m</var> and store the transformed bounds in this
      * AxisAlignedBox. This can be used to transform an AxisAlignedBox from one coordinate
      * space to another while preserving the property that whatever was contained by the
      * box in its original space, will be contained by the transformed box after it has
      * been transformed as well.
      * <p/>
-     * For best results, <tt>m</tt> should be an affine transformation.
+     * For best results, <var>m</var> should be an affine transformation.
      *
      * @param aabb The AxisAlignedBox that is transformed
      * @param m    The Matrix4 to act as a transform

ferox-math/src/main/java/com/ferox/math/ColorRGB.java

     }
 
     /**
-     * Create a new ColorRGB that copies the color values from <tt>color</tt> initially.
+     * Create a new ColorRGB that copies the color values from <var>color</var>
+     * initially.
      *
      * @param color The color to copy
      *
     }
 
     /**
-     * Compute a brighter version of <tt>color</tt>, adjusted by the given brightness
-     * <tt>factor</tt> and store it in this color. The <tt>factor</tt> represents the
+     * Compute a brighter version of <var>color</var>, adjusted by the given brightness
+     * <var>factor</var> and store it in this color. The <var>factor</var> represents the
      * fraction to scale each component by. This uses the HDR color values, so the
      * brighter color might extend into high dynamic range values (i.e. if you brightened
      * white).
     }
 
     /**
-     * Compute a darker version of <tt>color</tt>. The <tt>factor</tt> represents the
+     * Compute a darker version of <var>color</var>. The <var>factor</var> represents the
      * fraction to scale each component by. This uses the HDR color values, so it might be
      * possible for the darkened color to be equal in the low dynamic range.
      *
     }
 
     /**
-     * Copy the color values from <tt>color</tt> into this color.
+     * Copy the color values from <var>color</var> into this color.
      *
      * @param color The color to copy
      *
     }
 
     /**
-     * Set the red component value to <tt>blue</tt>. This value can be greater than 1 and
-     * will be unclamped for {@link #redHDR()}, but will be clamped to below 1 for {@link
-     * #red()}. Values below 0 will always be clamped to 0, regardless of dynamic range.
+     * Set the red component value to <var>blue</var>. This value can be greater than 1
+     * and will be unclamped for {@link #redHDR()}, but will be clamped to below 1 for
+     * {@link #red()}. Values below 0 will always be clamped to 0, regardless of dynamic
+     * range.
      *
      * @param red The new red color value
      *
     }
 
     /**
-     * Set the green component value to <tt>blue</tt>. This value can be greater than 1
+     * Set the green component value to <var>blue</var>. This value can be greater than 1
      * and will be unclamped for {@link #greenHDR()}, but will be clamped to below 1 for
      * {@link #green()}. Values below 0 will always be clamped to 0, regardless of dynamic
      * range.
     }
 
     /**
-     * Set the blue component value to <tt>blue</tt>. This value can be greater than 1 and
-     * will be unclamped for {@link #blueHDR()}, but will be clamped to below 1 for {@link
-     * #blue()}. Values below 0 will always be clamped to 0, regardless of dynamic range.
+     * Set the blue component value to <var>blue</var>. This value can be greater than 1
+     * and will be unclamped for {@link #blueHDR()}, but will be clamped to below 1 for
+     * {@link #blue()}. Values below 0 will always be clamped to 0, regardless of dynamic
+     * range.
      *
      * @param blue The new blue color value
      *
     }
 
     /**
-     * Set the component at <tt>index</tt> to the given value. This value can be greater
+     * Set the component at <var>index</var> to the given value. This value can be greater
      * than 1 and will be returned unclamped the HDR functions, but will be clamped to
      * below 1 for LDR values. Values below 0 will always be clamped to 0, regardless of
      * dynamic range.
 
     /**
      * Set this color to the red, green, and blue color values taken from the given array,
-     * starting at <tt>offset</tt>. The values can be LDR or HDR, just as in {@link
+     * starting at <var>offset</var>. The values can be LDR or HDR, just as in {@link
      * #set(float, float, float)}. This assumes that there are at least three elements
      * left in the array, starting at offset.
      *
     }
 
     /**
-     * Get the clamped color value for <tt>component</tt>. Red is 0, green is 1 and blue
+     * Get the clamped color value for <var>component</var>. Red is 0, green is 1 and blue
      * is 2. The value will be in [0, 1].
      *
      * @param component The color component to look up
     }
 
     /**
-     * Get the unclamped color value for <tt>component</tt>. Red is 0, green is 1 and blue
-     * is 2.
+     * Get the unclamped color value for <var>component</var>. Red is 0, green is 1 and
+     * blue is 2.
      *
      * @param component The color component to look up
      *
     }
 
     /**
-     * Copy the clamped color values of this color into <tt>vals</tt> starting at
-     * <tt>offset</tt>. It is assumed that vals has 3 indices starting at offset. The
+     * Copy the clamped color values of this color into <var>vals</var> starting at
+     * <var>offset</var>. It is assumed that vals has 3 indices starting at offset. The
      * color values will be in [0, 1].
      *
      * @param vals   The destination array
     }
 
     /**
-     * As {@link #get(double[], int)}, but with a DoubleBuffer. <tt>offset</tt> is
+     * As {@link #get(double[], int)}, but with a DoubleBuffer. <var>offset</var> is
      * measured from 0, not the buffer's position.
      *
      * @param store  The DoubleBuffer to hold the row values
     }
 
     /**
-     * As {@link #getHDR(double[], int)}, but with a DoubleBuffer. <tt>offset</tt> is
+     * As {@link #getHDR(double[], int)}, but with a DoubleBuffer. <var>offset</var> is
      * measured from 0, not the buffer's position.
      *
      * @param store  The DoubleBuffer to hold the row values
     }
 
     /**
-     * As {@link #get(double[], int)}, but with a FloatBuffer. <tt>offset</tt> is measured
-     * from 0, not the buffer's position.
+     * As {@link #get(double[], int)}, but with a FloatBuffer. <var>offset</var> is
+     * measured from 0, not the buffer's position.
      *
      * @param store  The FloatBuffer to hold the row values
      * @param offset The first index to use in the store
     }
 
     /**
-     * As {@link #getHDR(double[], int)}, but with a FloatBuffer. <tt>offset</tt> is
+     * As {@link #getHDR(double[], int)}, but with a FloatBuffer. <var>offset</var> is
      * measured from 0, not the buffer's position.
      *
      * @param store  The FloatBuffer to hold the row values
     }
 
     /**
-     * Copy the HDR color values of this color into <tt>vals</tt> starting at
-     * <tt>offset</tt>. It is assumed that vals has 3 indices starting at offset.
+     * Copy the HDR color values of this color into <var>vals</var> starting at
+     * <var>offset</var>. It is assumed that vals has 3 indices starting at offset.
      *
      * @param vals   The destination array
      * @param offset The offset into vals
     }
 
     /**
-     * Determine if the two colors are equal. If <tt>asHDR</tt> is true, the HDR color
+     * Determine if the two colors are equal. If <var>asHDR</var> is true, the HDR color
      * values are compared. If it is false, the color values are first clamped to [0, 1]
      * and then compared.
      *

ferox-math/src/main/java/com/ferox/math/Matrix3.java

     }
 
     /**
-     * Create a new matrix that copies the values from <tt>m</tt>.
+     * Create a new matrix that copies the values from <var>m</var>.
      *
      * @param m The matrix to copy
      *
     }
 
     /**
-     * Compute the inverse of <tt>a</tt> and store the inverted matrix in this matrix.
+     * Compute the inverse of <var>a</var> and store the inverted matrix in this matrix.
      *
      * @param a The matrix whose inverse is computed
      *
     }
 
     /**
-     * Multiply <tt>a</tt> by the diagonal matrix that takes it's three diagonal entries
-     * from <tt>b</tt>, or compute <code>[a] X [m]</code>, where [m] is all 0s except m00
-     * = b.x, m11 = b.y, and m22 = b.z.
+     * Multiply <var>a</var> by the diagonal matrix that takes it's three diagonal entries
+     * from <var>b</var>, or compute <code>[a] X [m]</code>, where [m] is all 0s except
+     * m00 = b.x, m11 = b.y, and m22 = b.z.
      *
      * @param a The left matrix in the multiplication
      * @param b Vector holding the three diagonal entries of the other matrix
 
     /**
      * <p/>
-     * Multiply the transpose of <tt>a</tt> by the transpose of <tt>b</tt>, or compute
+     * Multiply the transpose of <var>a</var> by the transpose of <var>b</var>, or compute
      * <code>[a]^T x [b]^T</code> and store it in this matrix.
      * <p/>
      * Note that <code>[a]^T x [b]^T = ([b] x [a])^T</code>
     }
 
     /**
-     * Scale each of <tt>a</tt>'s values by the scalar and store it in this matrix. This
+     * Scale each of <var>a</var>'s values by the scalar and store it in this matrix. This
      * effectively computes <code>scalar x [a]</code>
      *
      * @param a      The matrix to scale
     }
 
     /**
-     * Transpose <tt>a</tt> and store the result in this matrix.
+     * Transpose <var>a</var> and store the result in this matrix.
      *
      * @param a The matrix to transpose
      *
 
     /**
      * Set this Matrix3 to be the rotation matrix representing the same rotation stored by
-     * <tt>q</tt>.
+     * <var>q</var>.
      *
      * @param q The quaternion to convert to matrix form
      *
     }
 
     /**
-     * Set this matrix to the upper 3x3 matrix stored in <tt>m</tt>. The 4th row and
-     * column of <tt>m</tt> are ignored.
+     * Set this matrix to the upper 3x3 matrix stored in <var>m</var>. The 4th row and
+     * column of <var>m</var> are ignored.
      *
      * @param m The matrix whose upper 3x3 is copied
      *
     }
 
     /**
-     * As {@link #get(double[], int, boolean)}, but with a DoubleBuffer. <tt>offset</tt>
+     * As {@link #get(double[], int, boolean)}, but with a DoubleBuffer. <var>offset</var>
      * is measured from 0, not the buffer's position.
      *
      * @param store    The DoubleBuffer to hold the row values
     }
 
     /**
-     * As {@link #get(double[], int, boolean)}, but with a FloatBuffer. <tt>offset</tt> is
-     * measured from 0, not the buffer's position.
+     * As {@link #get(double[], int, boolean)}, but with a FloatBuffer. <var>offset</var>
+     * is measured from 0, not the buffer's position.
      *
      * @param store    The FloatBuffer to hold the row values
      * @param offset   The first index to use in the store

ferox-math/src/main/java/com/ferox/math/Matrix4.java

      * @param m32
      * @param m33
      *
-     * @see #set(double, double, double, double, double, double, double, double, double, double,
-     *      double, double, double, double, double, double)
+     * @see #set(double, double, double, double, double, double, double, double, double,
+     *      double, double, double, double, double, double, double)
      */
     public Matrix4(double m00, double m01, double m02, double m03, double m10, double m11,
                    double m12, double m13, double m20, double m21, double m22, double m23,
     }
 
     /**
-     * Compute an affine transform that translates an object to <tt>from</tt>, and has it
-     * oriented towards the point, <tt>lookAt</tt>. The up axis is the orthogonal vector
-     * closest to <tt>up</tt> that has the above described direction vector.
+     * Compute an affine transform that translates an object to <var>from</var>, and has
+     * it oriented towards the point, <var>lookAt</var>. The up axis is the orthogonal
+     * vector closest to <var>up</var> that has the above described direction vector.
      *
      * @param lookAt The point to look at
      * @param from   The viewing location (e.g. where the camera or object is)
     }
 
     /**
-     * Add <tt>c</tt> to each component of <tt>m</tt> and store the result in this
+     * Add <var>c</var> to each component of <var>m</var> and store the result in this
      * matrix.
      *
      * @param m The matrix in the addition
     }
 
     /**
-     * Compute the inverse of <tt>m</tt> and store it in this matrix.
+     * Compute the inverse of <var>m</var> and store it in this matrix.
      *
      * @param m The matrix to invert
      *
     }
 
     /**
-     * Multiply <tt>a</tt> by the diagonal matrix that takes it's four diagonal entries
-     * from <tt>b</tt>, or compute <code>[a] X [m]</code>, where [m] is all 0s except m00
-     * = b.x, m11 = b.y, m22 = b.z and m33 = b.w
+     * Multiply <var>a</var> by the diagonal matrix that takes it's four diagonal entries
+     * from <var>b</var>, or compute <code>[a] X [m]</code>, where [m] is all 0s except
+     * m00 = b.x, m11 = b.y, m22 = b.z and m33 = b.w
      *
      * @param a The left matrix in the multiplication
      * @param b Vector holding the four diagonal entries of the other matrix
 
     /**
      * <p/>
-     * Multiply the transpose of <tt>a</tt> by the transpose of <tt>b</tt>, or compute
+     * Multiply the transpose of <var>a</var> by the transpose of <var>b</var>, or compute
      * <code>[a]^T x [b]^T</code> and store it in this matrix.
      * <p/>
      * Note that <code>[a]^T x [b]^T = ([b] x [a])^T</code>
     }
 
     /**
-     * Compute the transpose of <tt>m</tt> and store it in this matrix.
+     * Compute the transpose of <var>m</var> and store it in this matrix.
      *
      * @param m The matrix to transpose
      *
     }
 
     /**
-     * Set the upper 3x3 of this matrix to the 9 values stored in <tt>m</tt>. The 4th row
-     * and column of this matrix are not modified.
+     * Set the upper 3x3 of this matrix to the 9 values stored in <var>m</var>. The 4th
+     * row and column of this matrix are not modified.
      *
      * @param m The matrix copied into this matrix's upper 3x3
      *
     }
 
     /**
-     * As {@link #get(double[], int, boolean)}, but with a DoubleBuffer. <tt>offset</tt>
+     * As {@link #get(double[], int, boolean)}, but with a DoubleBuffer. <var>offset</var>
      * is measured from 0, not the buffer's position.
      *
      * @param store    The DoubleBuffer to hold the row values
     }
 
     /**
-     * As {@link #get(double[], int, boolean)}, but with a FloatBuffer. <tt>offset</tt> is
-     * measured from 0, not the buffer's position.
+     * As {@link #get(double[], int, boolean)}, but with a FloatBuffer. <var>offset</var>
+     * is measured from 0, not the buffer's position.
      *
      * @param store    The FloatBuffer to hold the row values
      * @param offset   The first index to use in the store

ferox-math/src/main/java/com/ferox/math/Quat4.java

     }
 
     /**
-     * Create a new Quat4 that copies its values from those in <tt>q</tt>.
+     * Create a new Quat4 that copies its values from those in <var>q</var>.
      *
      * @param q The quaternion to clone
      *
     }
 
     /**
-     * Compute the shortest rotation arc from <tt>a</tt> to <tt>b</tt>, and store the
+     * Compute the shortest rotation arc from <var>a</var> to <var>b</var>, and store the
      * rotation in this quaternion.
      *
      * @param a The starting vector
     }
 
     /**
-     * Multiply <tt>a</tt> by the quaternion implicitly formed by <tt>b</tt>, where b
+     * Multiply <var>a</var> by the quaternion implicitly formed by <var>b</var>, where b
      * holds the first 3 coordinates of the quaternion and its fourth is considered to be
      * 0. The multiplication is stored in this quaternion
      *
     }
 
     /**
-     * Scale the components of <tt>q</tt> by <tt>s</tt> and store them in this
+     * Scale the components of <var>q</var> by <var>s</var> and store them in this
      * quaternion.
      *
      * @param q The quaternion to scale
     }
 
     /**
-     * Normalize the quaternion <tt>a</tt> and store it in this quaternion
+     * Normalize the quaternion <var>a</var> and store it in this quaternion
      *
      * @param a The quaternion being normalized
      *
     }
 
     /**
-     * Compute the dot product between this quaternion and <tt>q</tt>.
+     * Compute the dot product between this quaternion and <var>q</var>.
      *
      * @param q The other quaternion involved in the dot product
      *
-     * @return The dot product between this and <tt>q</tt>, which is the same as if both
+     * @return The dot product between this and <var>q</var>, which is the same as if both
      *         were treated as 4-vectors.
      *
      * @throws NullPointerException if q is null
     }
 
     /**
-     * Compute the angle between this quaternion and <tt>q</tt>
+     * Compute the angle between this quaternion and <var>q</var>
      *
      * @param q The other quaternion
      *
     }
 
     /**
-     * Compute the inverse of <tt>q</tt> and store it in this quaternion.
+     * Compute the inverse of <var>q</var> and store it in this quaternion.
      *
      * @param q The quaternion being inverted
      *
     }
 
     /**
-     * Perform spherical linear interpolation between <tt>a</tt> and <tt>b</tt> and store
-     * the interpolated quaternion in this quaternion. The parameter <tt>t</tt> should be
-     * in the range <code>[0, 1]</code> where a value of 0 represents <tt>a</tt> and a
-     * value of 1 represents <tt>b</tt>.
+     * Perform spherical linear interpolation between <var>a</var> and <var>b</var> and
+     * store the interpolated quaternion in this quaternion. The parameter <var>t</var>
+     * should be in the range <code>[0, 1]</code> where a value of 0 represents
+     * <var>a</var> and a value of 1 represents <var>b</var>.
      *
      * @param a The initial quaternion
      * @param b The end quaternion
     }
 
     /**
-     * Set this quaternion to be the rotation of <tt>angle</tt> radians about the
-     * specified <tt>axis</tt>.
+     * Set this quaternion to be the rotation of <var>angle</var> radians about the
+     * specified <var>axis</var>.
      *
      * @param axis  The axis of rotation, should not be the 0 vector
      * @param angle The angle of rotation, in radians
     }
 
     /**
-     * Set this quaternion to be the rotation described by the Euler angles: <tt>yaw</tt>,
-     * <tt>pitch</tt> and <tt>roll</tt>. Yaw is the rotation around the y-axis, pitch is
-     * the rotation around the x-axis, and roll is the rotation around the z-axis. The
-     * final rotation is formed by rotating first Y, then X and then Z.
+     * Set this quaternion to be the rotation described by the Euler angles:
+     * <var>yaw</var>, <var>pitch</var> and <var>roll</var>. Yaw is the rotation around
+     * the y-axis, pitch is the rotation around the x-axis, and roll is the rotation
+     * around the z-axis. The final rotation is formed by rotating first Y, then X and
+     * then Z.
      *
      * @param yaw   Rotation around the y-axis in radians
      * @param pitch Rotation around the x-axis in radians
 
     /**
      * Set the value of this quaternion to represent the rotation of the given matrix,
-     * <tt>e</tt>. It is assumed that <tt>e</tt> contains a rotation matrix and does not
-     * include scale factors, or other form of 3x3 matrix.
+     * <var>e</var>. It is assumed that <var>e</var> contains a rotation matrix and does
+     * not include scale factors, or other form of 3x3 matrix.
      *
      * @param e The rotation matrix to convert to quaternion form
      *
     }
 
     /**
-     * As {@link #get(double[], int)}, but with a DoubleBuffer. <tt>offset</tt> is
+     * As {@link #get(double[], int)}, but with a DoubleBuffer. <var>offset</var> is
      * measured from 0, not the buffer's position.
      *
      * @param store  The DoubleBuffer to hold the row values
     }
 
     /**
-     * As {@link #get(double[], int)}, but with a FloatBuffer. <tt>offset</tt> is measured
-     * from 0, not the buffer's position.
+     * As {@link #get(double[], int)}, but with a FloatBuffer. <var>offset</var> is
+     * measured from 0, not the buffer's position.
      *
      * @param store  The FloatBuffer to hold the row values
      * @param offset The first index to use in the store

ferox-math/src/main/java/com/ferox/math/Vector3.java

     }
 
     /**
-     * Create a new vector that copies the x, y, and z values from <tt>v</tt>.
+     * Create a new vector that copies the x, y, and z values from <var>v</var>.
      *
      * @param v The vector to copy
      *
     }
 
     /**
-     * Floor each component of the vector <tt>v</tt> and store them in this vector.
+     * Floor each component of the vector <var>v</var> and store them in this vector.
      *
      * @param v The vector to be floored
      *
     }
 
     /**
-     * Compute the ceiling of each component of the vector <tt>v</tt> and store them in
+     * Compute the ceiling of each component of the vector <var>v</var> and store them in
      * this vector.
      *
      * @param v The vector to be ceil'ed
     }
 
     /**
-     * Compute the distance between this vector and <tt>v</tt>, treating both vectors as
+     * Compute the distance between this vector and <var>v</var>, treating both vectors as
      * 3D points.
      *
      * @param v The other vector
     }
 
     /**
-     * Compute the square of the distance between this and <tt>v</tt>, treating both
+     * Compute the square of the distance between this and <var>v</var>, treating both
      * vectors as 3D points.
      *
      * @param v The other vector
     }
 
     /**
-     * Compute a vector orthogonal to <tt>b</tt> and store the result in this vector. The
-     * orthogonal vector will be in the plane formed by <tt>a</tt> and <tt>b</tt>, and it
-     * will be in the same half-plane as <tt>a</tt> formed by a line through <tt>b</tt>.
-     * This uses the Gram-Schmidt process.
+     * Compute a vector orthogonal to <var>b</var> and store the result in this vector.
+     * The orthogonal vector will be in the plane formed by <var>a</var> and <var>b</var>,
+     * and it will be in the same half-plane as <var>a</var> formed by a line through
+     * <var>b</var>. This uses the Gram-Schmidt process.
      *
      * @param a The vector that helps form the plane and chooses the result's orientation
      * @param b The vector the result is orthogonal to
     }
 
     /**
-     * Transform the vector <tt>v</tt> by <tt>q</tt> and store it in this vector.
+     * Transform the vector <var>v</var> by <var>q</var> and store it in this vector.
      *
      * @param v The vector to rotate or transform
      * @param q The quaternion to rotate by
     }
 
     /**
-     * Project <tt>a</tt> onto <tt>b</tt> and store the projected vector in this vector.
+     * Project <var>a</var> onto <var>b</var> and store the projected vector in this
+     * vector.
      *
      * @param a The vector being projected
      * @param b The vector that is projected onto
     }
 
     /**
-     * Normalize <tt>v</tt> to be of length 1 and store it in this vector. The vector
+     * Normalize <var>v</var> to be of length 1 and store it in this vector. The vector
      * can't be normalized if it's length is 0. If it's length is very close to 0, the
      * results may suffer from loss of precision.
      *
 
     /**
      * As {@link #transform(Matrix4, Vector3, double)} where the w-component is set to 1.
-     * Thus, the resulting computation is the transformation of <tt>a</tt> by <tt>m</tt>,
-     * interpreting <tt>a</tt> as a point in space.
+     * Thus, the resulting computation is the transformation of <var>a</var> by
+     * <var>m</var>, interpreting <var>a</var> as a point in space.
      *
      * @param m The transform matrix
      * @param a The point to transform
 
     /**
      * <p/>
-     * Compute <code>[m] x [a']</code> where <tt>[a']</tt> is the 4x1 matrix formed by the
-     * three values of <tt>a</tt> and the specified <tt>w</tt>.
+     * Compute <code>[m] x [a']</code> where <var>[a']</var> is the 4x1 matrix formed by
+     * the three values of <var>a</var> and the specified <var>w</var>.
      * <p/>
-     * Common values of <tt>w</tt> are: <ul> <li><code>w = 0</code> transforms <tt>a</tt>
-     * by the upper 3x3 of <tt>m</tt>, treating <tt>a</tt> as a direction vector.</li>
-     * <li><code>w = 1</code> transforms <tt>a</tt> as if it were a point in 3-space
-     * (assuming m is an affine transform).</li> </ul>
+     * Common values of <var>w</var> are: <ul> <li><code>w = 0</code> transforms
+     * <var>a</var> by the upper 3x3 of <var>m</var>, treating <var>a</var> as a direction
+     * vector.</li> <li><code>w = 1</code> transforms <var>a</var> as if it were a point
+     * in 3-space (assuming m is an affine transform).</li> </ul>
      *
      * @param m The affine transform to transform a with
      * @param a The vector being transformed by m
 
     /**
      * As {@link #transform(Matrix4, Vector3)} where the calling vector is transformed by
-     * the matrix <tt>m</tt>.
+     * the matrix <var>m</var>.
      *
      * @param m The matrix transforming this vector
      *
     }
 
     /**
-     * Set the x, y, and z values of this Vector3 to be equal to <tt>v</tt>
+     * Set the x, y, and z values of this Vector3 to be equal to <var>v</var>
      *
      * @param v Vector to be copied into this
      *
     }
 
     /**
-     * As {@link #get(double[], int)}, but with a DoubleBuffer. <tt>offset</tt> is
+     * As {@link #get(double[], int)}, but with a DoubleBuffer. <var>offset</var> is
      * measured from 0, not the buffer's position.
      *
      * @param store  The DoubleBuffer to hold the row values
     }
 
     /**
-     * As {@link #get(double[], int)}, but with a FloatBuffer. <tt>offset</tt> is measured
-     * from 0, not the buffer's position.
+     * As {@link #get(double[], int)}, but with a FloatBuffer. <var>offset</var> is
+     * measured from 0, not the buffer's position.
      *
      * @param store  The FloatBuffer to hold the row values
      * @param offset The first index to use in the store

ferox-math/src/main/java/com/ferox/math/Vector4.java

     }
 
     /**
-     * Create a new vector that copies the x, y, z, and w values from <tt>v</tt> .
+     * Create a new vector that copies the x, y, z, and w values from <var>v</var> .
      *
      * @param v The vector to copy
      */
     }
 
     /**
-     * Floor each component of the vector <tt>v</tt> and store them in this vector.
+     * Floor each component of the vector <var>v</var> and store them in this vector.
      *
      * @param v The vector to be floored
      *
     }
 
     /**
-     * Compute the ceiling of each component of the vector <tt>v</tt> and store them in
+     * Compute the ceiling of each component of the vector <var>v</var> and store them in
      * this vector.
      *
      * @param v The vector to be ceil'ed
     }
 
     /**
-     * Compute the distance between this vector and <tt>v</tt>, treating both vectors as
+     * Compute the distance between this vector and <var>v</var>, treating both vectors as
      * 4D points.
      *
      * @param v The other vector
     }
 
     /**
-     * Compute the square of the distance between this and <tt>v</tt>, treating both
+     * Compute the square of the distance between this and <var>v</var>, treating both
      * vectors as 4D points.
      *
      * @param v The other vector
     }
 
     /**
-     * Compute a vector orthogonal to <tt>b</tt> and store the result in this vector. The
-     * orthogonal vector will be in the plane formed by <tt>a</tt> and <tt>b</tt>, and it
-     * will be in the same half-plane as <tt>a</tt> formed by a line through <tt>b</tt>.
-     * This uses the Gram-Schmidt process.
+     * Compute a vector orthogonal to <var>b</var> and store the result in this vector.
+     * The orthogonal vector will be in the plane formed by <var>a</var> and <var>b</var>,
+     * and it will be in the same half-plane as <var>a</var> formed by a line through
+     * <var>b</var>. This uses the Gram-Schmidt process.
      *
      * @param a The vector that helps form the plane and chooses the result's orientation
      * @param b The vector the result is orthogonal to
     }
 
     /**
-     * Project <tt>a</tt> onto <tt>b</tt> and store the result in this vector.
+     * Project <var>a</var> onto <var>b</var> and store the result in this vector.
      *
      * @param a The vector being projected
      * @param b The vector that is projected onto
     }
 
     /**
-     * Add <tt>a</tt> and <tt>b</tt> together and store the result in this vector.
+     * Add <var>a</var> and <var>b</var> together and store the result in this vector.
      *
      * @param a The left side of the addition
      * @param b The right side of the addition
     }
 
     /**
-     * Scale <tt>v</tt> by <tt>scalar</tt> and store the result in this vector.
+     * Scale <var>v</var> by <var>scalar</var> and store the result in this vector.
      *
      * @param v      The vector whose scale is computed
      * @param scalar The scale factor
     }
 
     /**
-     * Normalize <tt>v</tt> to be of length 1 and store it in this vector. The vector
+     * Normalize <var>v</var> to be of length 1 and store it in this vector. The vector
      * can't be normalized if it's length is 0. If it's length is very close to 0, the
      * results may suffer from loss of precision.
      *
     }
 
     /**
-     * As {@link #get(double[], int)}, but with a DoubleBuffer. <tt>offset</tt> is
+     * As {@link #get(double[], int)}, but with a DoubleBuffer. <var>offset</var> is
      * measured from 0, not the buffer's position.
      *
      * @param store  The DoubleBuffer to hold the row values
     }
 
     /**
-     * As {@link #get(double[], int)}, but with a FloatBuffer. <tt>offset</tt> is measured
-     * from 0, not the buffer's position.
+     * As {@link #get(double[], int)}, but with a FloatBuffer. <var>offset</var> is
+     * measured from 0, not the buffer's position.
      *
      * @param store  The FloatBuffer to hold the row values
      * @param offset The first index to use in the store

ferox-math/src/main/java/com/ferox/math/bounds/Frustum.java

     }
 
     /**
-     * Set the orientation of this Frustum based on the affine <tt>transform</tt>. The 4th
-     * column's first 3 values encode the transformation. The 3rd column holds the
+     * Set the orientation of this Frustum based on the affine <var>transform</var>. The
+     * 4th column's first 3 values encode the transformation. The 3rd column holds the
      * direction vector, and the 2nd column defines the up vector.
      *
      * @param transform The new transform of the frustum
     /**
      * <p/>
      * Compute and return the intersection of the AxisAlignedBox and this Frustum,
-     * <tt>f</tt>. It is assumed that the Frustum and AxisAlignedBox exist in the same
+     * <var>f</var>. It is assumed that the Frustum and AxisAlignedBox exist in the same
      * coordinate frame. {@link FrustumIntersection#INSIDE} is returned when the
      * AxisAlignedBox is fully contained by the Frustum. {@link
      * FrustumIntersection#INTERSECT} is returned when this box is partially contained by
      * the Frustum, and {@link FrustumIntersection#OUTSIDE} is returned when the box has
      * no intersection with the Frustum.
      * <p/>
-     * If <tt>OUTSIDE</tt> is returned, it is guaranteed that the objects enclosed by the
-     * bounds do not intersect the Frustum. If <tt>INSIDE</tt> is returned, any object
-     * {@link #contains(AxisAlignedBox) contained} by the box will also be completely
-     * inside the Frustum. When <tt>INTERSECT</tt> is returned, there is a chance that the
-     * true representation of the objects enclosed by the box will be outside of the
-     * Frustum, but it is unlikely. This can occur when a corner of the box intersects
-     * with the planes of <tt>f</tt>, but the shape does not exist in that corner.
+     * If <var>OUTSIDE</var> is returned, it is guaranteed that the objects enclosed by
+     * the bounds do not intersect the Frustum. If <var>INSIDE</var> is returned, any
+     * object {@link #contains(AxisAlignedBox) contained} by the box will also be
+     * completely inside the Frustum. When <var>INTERSECT</var> is returned, there is a
+     * chance that the true representation of the objects enclosed by the box will be
+     * outside of the Frustum, but it is unlikely. This can occur when a corner of the box
+     * intersects with the planes of <var>f</var>, but the shape does not exist in that
+     * corner.
      * <p/>
-     * The argument <tt>planeState</tt> can be used to hint to this function which planes
-     * of the Frustum require checking and which do not. When a hierarchy of bounds is
-     * used, the planeState can be used to remove unnecessary plane comparisons. If
-     * <tt>planeState</tt> is null it is assumed that all planes need to be checked. If
-     * <tt>planeState</tt> is not null, this method will mark any plane that the box is
+     * The argument <var>planeState</var> can be used to hint to this function which
+     * planes of the Frustum require checking and which do not. When a hierarchy of bounds
+     * is used, the planeState can be used to remove unnecessary plane comparisons. If
+     * <var>planeState</var> is null it is assumed that all planes need to be checked. If
+     * <var>planeState</var> is not null, this method will mark any plane that the box is
      * completely inside of as not requiring a comparison. It is the responsibility of the
      * caller to save and restore the plane state as needed based on the structure of the
      * bound hierarchy.

ferox-math/src/main/java/com/ferox/math/bounds/Octree.java

     /**
      * <p/>
      * Construct a new Octree that has X, Y, and Z dimensions equal to
-     * <tt>sideLength</tt>, and the depth of the tree is controlled by the estimated
-     * object size, <tt>objSize</tt>. <tt>objSize</tt> should be the approximate dimension
-     * of the average object contained in this index. If it is too big or too small, query
-     * performance may suffer.
+     * <var>sideLength</var>, and the depth of the tree is controlled by the estimated
+     * object size, <var>objSize</var>. <var>objSize</var> should be the approximate
+     * dimension of the average object contained in this index. If it is too big or too
+     * small, query performance may suffer.
      *
      * @param sideLength The side length of the root bounds of the octree
      * @param objSize    The estimated object size
 
     /**
      * <p/>
-     * Construct a new Octree with the given root bounds, <tt>aabb</tt> and tree depth.
+     * Construct a new Octree with the given root bounds, <var>aabb</var> and tree depth.
      * The depth of the tree and the X, Y, and Z dimensions of the root bounds determine
      * the size the leaf octree nodes. If objects are significantly larger than this, they
      * will be contained in multiple nodes and it may hurt performance.
      * <p/>
      * <p/>
-     * The root bounds are copied so future changes to <tt>aabb</tt> will not affect this
-     * tree.
+     * The root bounds are copied so future changes to <var>aabb</var> will not affect
+     * this tree.
      *
      * @param aabb  The root bounds of the tree
      * @param depth The depth of the tree

ferox-math/src/main/java/com/ferox/math/bounds/Plane.java

     private static final float ROOT_2_OVER_2 = .7071067811865f;
 
     /**
-     * Interpret <tt>plane</tt> as a plane within the 3D coordinate space. The plane is
+     * Interpret <var>plane</var> as a plane within the 3D coordinate space. The plane is
      * normalized by dividing all four coordinates by the magnitude of the planes normal
      * vector. The plane is normalized in place.
      *
     }
 
     /**
-     * Compute the signed distance between the plane stored in <tt>plane</tt> and the
-     * given <tt>point</tt>. The Vector4 storing the plane is stored as described above.
+     * Compute the signed distance between the plane stored in <var>plane</var> and the
+     * given <var>point</var>. The Vector4 storing the plane is stored as described above.
      * If the returned distance is less than 0, the point is "behind" the plane, if it is
      * 0 it lies on the plane, and if it is positive, the point lies in front of the
      * plane. In front of and behind depend on the direction which the normal of the plane
     }
 
     /**
-     * Compute the signed distance between <tt>plane</tt> and <tt>point</tt>. If
-     * <tt>assumeNormalized</tt> is false, this functions identically to {@link
+     * Compute the signed distance between <var>plane</var> and <var>point</var>. If
+     * <var>assumeNormalized</var> is false, this functions identically to {@link
      * #getSignedDistance(Vector4, Vector3)}. If it is true, this still returns the signed
      * distance but assumes that the given plane has already been normalized via {@link
      * #normalize(Vector4)}. This avoids a square root and division but can return

ferox-math/src/main/java/com/ferox/math/bounds/QuadTree.java

 
     /**
      * <p/>
-     * Construct a new QuadTree that has X and Z dimensions equal to <tt>sideLength</tt>,
-     * and the depth of the tree is controlled by the estimated object size,
-     * <tt>objSize</tt>. <tt>objSize</tt> should be the approximate dimension of the
-     * average object contained in this index. If it is too big or too small, query
-     * performance may suffer.
+     * Construct a new QuadTree that has X and Z dimensions equal to
+     * <var>sideLength</var>, and the depth of the tree is controlled by the estimated
+     * object size, <var>objSize</var>. <var>objSize</var> should be the approximate
+     * dimension of the average object contained in this index. If it is too big or too
+     * small, query performance may suffer.
      * <p/>
      * The height of the root bounds is estimated as 20 times the object size.
      *
 
     /**
      * <p/>
-     * Construct a new QuadTree with the given root bounds, <tt>aabb</tt> and tree depth.
-     * The depth of the tree and the X and Z dimensions of the root bounds determine the
-     * size the leaf quadtree nodes. If objects are significantly larger than this, they
-     * will be contained in multiple nodes and it may hurt performance.
+     * Construct a new QuadTree with the given root bounds, <var>aabb</var> and tree
+     * depth. The depth of the tree and the X and Z dimensions of the root bounds
+     * determine the size the leaf quadtree nodes. If objects are significantly larger
+     * than this, they will be contained in multiple nodes and it may hurt performance.
      * <p/>
      * <p/>
-     * The root bounds are copied so future changes to <tt>aabb</tt> will not affect this
-     * tree.
+     * The root bounds are copied so future changes to <var>aabb</var> will not affect
+     * this tree.
      *
      * @param aabb  The root bounds of the tree
      * @param depth The depth of the tree

ferox-math/src/main/java/com/ferox/math/bounds/SpatialIndex.java

 public interface SpatialIndex<T> {
     /**
      * <p/>
-     * Add <tt>item</tt> to this SpatialIndex using the given <tt>bounds</tt> to represent
-     * the extents of the item. If the item is already in the index, the item may be
-     * reported multiple times in queries.
+     * Add <var>item</var> to this SpatialIndex using the given <var>bounds</var> to
+     * represent the extents of the item. If the item is already in the index, the item
+     * may be reported multiple times in queries.
      * <p/>
      * Some implementations of SpatialIndex may have constraints on their spatial
-     * dimensions. If <tt>bounds</tt> is unable to fit within these constraints, a false
+     * dimensions. If <var>bounds</var> is unable to fit within these constraints, a false
      * is returned and the item was not added to the hierarchy.
      * <p/>
      * Implementations must copy the provided bounds so that any subsequent changes to the
      * bounds instance to do not affect the index.
      *
      * @param item   The item to add
-     * @param bounds The extends of <tt>item</tt>
+     * @param bounds The extends of <var>item</var>
      *
      * @return True if the item was added to the index, false otherwise
      *
     public boolean add(T item, @Const AxisAlignedBox bounds);
 
     /**
-     * Remove <tt>item</tt> from this hierarchy so that the given item will no longer be
+     * Remove <var>item</var> from this hierarchy so that the given item will no longer be
      * returned in queries on the SpatialIndex. False is returned if the index was not
      * modified (i.e. the item was not in this collection).
      *
     public boolean remove(T item);
 
     /**
-     * Empty this SpatialIndex so that it no longer contains any items. If <tt>fast</tt>
+     * Empty this SpatialIndex so that it no longer contains any items. If <var>fast</var>
      * is true, the index is not required to remove references to old items. This can be
      * more efficient if the index will be re-filled and the old references will be
      * overwritten. However, this may also prevent items from being garbage collected if
      * <p/>
      * Query this SpatialIndex for all previously added items that have their provided
      * bounds {@link AxisAlignedBox#intersects(AxisAlignedBox) intersecting} with
-     * <tt>volume</tt>.
+     * <var>volume</var>.
      * <p/>
      * The provided QueryCallback has its {@link QueryCallback#process(Object)} invoked
      * for each intersecting item. An item will be passed to the callback once per query.
      * <p/>
      * Query this SpatialIndex for all previously added items that have their provided
      * bounds {@link Frustum#intersects(AxisAlignedBox, PlaneState) intersecting} with
-     * <tt>frustum</tt>. An item's bounds intersects with the Frustum if its
+     * <var>frustum</var>. An item's bounds intersects with the Frustum if its
      * FrustumIntersection is not {@link FrustumIntersection#OUTSIDE}.
      * <p/>
      * The provided QueryCallback has its {@link QueryCallback#process(Object)} invoked

ferox-math/src/main/java/com/ferox/math/entreri/AxisAlignedBoxProperty.java

 
     /**
      * Get the axis aligned box of this property, for the component at the given index,
-     * and store it into <tt>result</tt>. If result is null, a new AxisAlignedBox is
+     * and store it into <var>result</var>. If result is null, a new AxisAlignedBox is
      * created and returned.
      *
      * @param index  The component index to retrieve
     }
 
     /**
-     * Copy the state of <tt>b</tt> into the underlying data of this property, for the
+     * Copy the state of <var>b</var> into the underlying data of this property, for the
      * component at the given index.
      *
      * @param v     The box to copy

ferox-math/src/main/java/com/ferox/math/entreri/ColorRGBProperty.java

 
     /**
      * Get the color of this property, for the component at the given index, and store it
-     * into <tt>result</tt>. If result is null, a new ColorRGB is created and returned.
+     * into <var>result</var>. If result is null, a new ColorRGB is created and returned.
      *
      * @param index  The component index to retrieve
      * @param result The color to store the data for the requested component
     }
 
     /**
-     * Copy the values of <tt>v</tt> into the underlying data of this property, for the
+     * Copy the values of <var>v</var> into the underlying data of this property, for the
      * component at the given index.
      *
      * @param v     The color to copy

ferox-math/src/main/java/com/ferox/math/entreri/Matrix3Property.java

 
     /**
      * Get the matrix of this property, for the component at the given index, and store it
-     * into <tt>result</tt>. If result is null, a new Matrix3 is created and returned.
+     * into <var>result</var>. If result is null, a new Matrix3 is created and returned.
      *
      * @param index  The component index to retrieve
      * @param result The matrix to store the data for the requested component
     }
 
     /**
-     * Copy the values of <tt>v</tt> into the underlying data of this property, for the
+     * Copy the values of <var>v</var> into the underlying data of this property, for the
      * component at the given index.
      *
      * @param v     The matrix to copy

ferox-math/src/main/java/com/ferox/math/entreri/Matrix4Property.java

 
     /**
      * Get the matrix of this property, for the component at the given index, and store it
-     * into <tt>result</tt>. If result is null, a new Matrix4 is created and returned.
+     * into <var>result</var>. If result is null, a new Matrix4 is created and returned.
      *
      * @param index  The component index to retrieve
      * @param result The matrix to store the data for the requested component
     }
 
     /**
-     * Copy the values of <tt>v</tt> into the underlying data of this property, for the
+     * Copy the values of <var>v</var> into the underlying data of this property, for the
      * component at the given index.
      *
      * @param v     The matrix to copy

ferox-math/src/main/java/com/ferox/math/entreri/Quat4Property.java

 
     /**
      * Get the quaternion of this property, for the component at the given index, and
-     * store it into <tt>result</tt>. If result is null, a new Quat4 is created and
+     * store it into <var>result</var>. If result is null, a new Quat4 is created and
      * returned.
      *
      * @param index  The component index to retrieve
     }
 
     /**
-     * Copy the values of <tt>v</tt> into the underlying data of this property, for the
+     * Copy the values of <var>v</var> into the underlying data of this property, for the
      * component at the given index.
      *
      * @param v     The quaternion to copy

ferox-math/src/main/java/com/ferox/math/entreri/Vector3Property.java

 
     /**
      * Get the vector of this property, for the component at the given index, and store it
-     * into <tt>result</tt>. If result is null, a new Vector3 is created and returned.
+     * into <var>result</var>. If result is null, a new Vector3 is created and returned.
      *
      * @param index  The component index to retrieve
      * @param result The vector to store the data for the requested component
     }
 
     /**
-     * Copy the values of <tt>v</tt> into the underlying data of this property, for the
+     * Copy the values of <var>v</var> into the underlying data of this property, for the
      * component at the given index.
      *
      * @param v     The vector to copy

ferox-math/src/main/java/com/ferox/math/entreri/Vector4Property.java

 
     /**
      * Get the vector of this property, for the component at the given index, and store it
-     * into <tt>result</tt>. If result is null, a new Vector3 is created and returned.
+     * into <var>result</var>. If result is null, a new Vector3 is created and returned.
      *
      * @param index  The component index to retrieve
      * @param result The vector to store the data for the requested component
     }
 
     /**
-     * Copy the values of <tt>v</tt> into the underlying data of this property, for the
+     * Copy the values of <var>v</var> into the underlying data of this property, for the
      * component at the given index.
      *
      * @param v     The vector to copy

ferox-physics/src/main/java/com/ferox/physics/collision/ClosestPair.java

     private final double distance;
 
     /**
-     * Create a new ClosestPair. <tt>pointOnA</tt> represents the point on the first
+     * Create a new ClosestPair. <var>pointOnA</var> represents the point on the first
      * object's surface. The point on the second object's surface is reconstructed from
-     * <tt>pointOnA</tt>, the <tt>contactNormal</tt>, and the distance along the normal.
-     * It is assumed that the contact normal has already been normalized.
+     * <var>pointOnA</var>, the <var>contactNormal</var>, and the distance along the
+     * normal. It is assumed that the contact normal has already been normalized.
      *
      * @param pointOnA      The closest point on the A's surface
      * @param contactNormal The normal from pointOnA to the point on B's surface,

ferox-physics/src/main/java/com/ferox/physics/collision/CollisionAlgorithm.java

 public interface CollisionAlgorithm<A extends Shape, B extends Shape> {
     /**
      * <p/>
-     * Compute the closest pair of points in world space between <tt>shapeA</tt> and
-     * <tt>shapeB</tt>. If the implementation cannot determine a closest pair, it should
+     * Compute the closest pair of points in world space between <var>shapeA</var> and
+     * <var>shapeB</var>. If the implementation cannot determine a closest pair, it should
      * return null to indicate that the input was ill-conditioned. When a non-null {@link
      * ClosestPair} is returned, it means the two Collidables are either guaranteed
      * separated or intersecting.
      * <p/>
      * If the pair's reported distance is negative, it means the two objects are
      * intersecting. {@link ClosestPair#getClosestPointOnA()} will return the point on the
-     * surface of <tt>shapeA</tt> and {@link ClosestPair#getClosestPointOnB()} will return
-     * the point on the surface of <tt>shapeB</tt>. The contact normal between the two
-     * objects will be from A to B (which is also why negative distance implies
+     * surface of <var>shapeA</var> and {@link ClosestPair#getClosestPointOnB()} will
+     * return the point on the surface of <var>shapeB</var>. The contact normal between
+     * the two objects will be from A to B (which is also why negative distance implies
      * intersection). The surface points and contact normal are in world space, as
-     * determined by <tt>transA</tt> and <tt>transB</tt>.
+     * determined by <var>transA</var> and <var>transB</var>.
      *
      * @param shapeA The Shape of the first object in the collision
      * @param transA The transform that represents the world-space orientation of shapeA

ferox-physics/src/main/java/com/ferox/physics/collision/CollisionBody.java

     }
 
     /**
-     * Compares the collision groups and masks of this CollisionBody and <tt>other</tt>
+     * Compares the collision groups and masks of this CollisionBody and <var>other</var>
      * and returns true if the two instances are capable of colliding. It is always true
      * that <code>objA.canCollide(objB) == objB.canCollide(objA)</code>.
      *
     }
 
     /**
-     * Copy <tt>t</tt> into this Collidable's transform, updating its location and
+     * Copy <var>t</var> into this Collidable's transform, updating its location and
      * orientation. This will also recompute the Collidable's world bounds.
      *
      * @param t The transform to copy

ferox-physics/src/main/java/com/ferox/physics/collision/algorithm/SwappingCollisionAlgorithm.java

 
     /**
      * Create a SwappingCollisionAlgorithm that wraps the given CollisionAlgorithm. Any
-     * call to getClosestPair() on this algorithm will delegate to <tt>toSwap</tt> except
-     * that A and B are swapped.
+     * call to getClosestPair() on this algorithm will delegate to <var>toSwap</var>
+     * except that A and B are swapped.
      *
      * @param toSwap The algorithm to wrap
      *

ferox-physics/src/main/java/com/ferox/physics/collision/shape/AxisSweptShape.java

     }
 
     /**
-     * Return the sign of component of <tt>v</tt> matching the shape's dominant axis.
+     * Return the sign of component of <var>v</var> matching the shape's dominant axis.
      * Thus, if the dominant axis was Z, it returns 1 of <code>v.getZ()</code> is
      * positive, and -1 if not.
      *
     }
 
     /**
-     * Evaluate the "sigma" function of <tt>v</tt>. This is the same as the projected
+     * Evaluate the "sigma" function of <var>v</var>. This is the same as the projected
      * distance of v to the dominant axis.
      *
      * @param v The input vector evaluated by the sigma function

ferox-physics/src/main/java/com/ferox/physics/collision/shape/ConvexShape.java

     /**
      * <p/>
      * Compute and return the evaluation of this convex shape's support function, on input
-     * <tt>v</tt>. The support should be stored and returned in <tt>result</tt>. If result
-     * is null, a new vector should be created and returned. The support function will not
-     * include the margin.
+     * <var>v</var>. The support should be stored and returned in <var>result</var>. If
+     * result is null, a new vector should be created and returned. The support function
+     * will not include the margin.
      * <p/>
-     * The support of a convex shape is a function <tt>Sc</tt> that maps a vector to a
+     * The support of a convex shape is a function <var>Sc</var> that maps a vector to a
      * point on the shape, such that <code>dot(Sc, v)</code> maximizes <code>dot(x,
-     * v)</code> for all <tt>x</tt> on the shape's surface.
+     * v)</code> for all <var>x</var> on the shape's surface.
      *
      * @param v      The support input
      * @param result A vector to contain the result

ferox-renderer/ferox-renderer-api/src/main/java/com/ferox/renderer/FixedFunctionRenderer.java

     /**
      * <p/>
      * Set the current state of this renderer to equal the given state snapshot.
-     * <tt>state</tt> must have been returned by a prior call to {@link
+     * <var>state</var> must have been returned by a prior call to {@link
      * #getCurrentState()} from a FixedFunctionRenderer created by this renderer's
      * Framework or behavior is undefined.
      * <p/>
      * <p/>
      * Configure the lighting model to use Gauroud shading or non-interpolated vertex
      * colors. When smoothed is true, Gauroud shading is used to simuluate per-pixel
-     * lighting. When <tt>smoothed</tt> is false, vertex colors are not interpolated and
+     * lighting. When <var>smoothed</var> is false, vertex colors are not interpolated and
      * rendered geometry will appear faceted.
      * <p/>
      * Smooth shading is enabled by default.
      * light color would make a black contribution since (1, 0, 0, 1) * (0, 1, 0, 1) is
      * (0, 0, 0, 1).
      * <p/>
-     * The colors stored in <tt>amb</tt>, <tt>diff</tt> and <tt>spec</tt> have components
-     * ordered red, green, blue and alpha. The values are clamped to be above 0. Values
-     * higher than 1 cause the light to be outside the standard range and can produce
-     * final colors brighter than white that will be clamped to [0, 1].
+     * The colors stored in <var>amb</var>, <var>diff</var> and <var>spec</var> have
+     * components ordered red, green, blue and alpha. The values are clamped to be above
+     * 0. Values higher than 1 cause the light to be outside the standard range and can
+     * produce final colors brighter than white that will be clamped to [0, 1].
      * <p/>
      * The default colors of the 0th light are a diffuse and specular of (1, 1, 1, 1) and
      * an ambient of (0, 0, 0, 1). All other lights use (0, 0, 0, 1) for all of the
      * represents the 'color' of a lit object while the other color values add more subtle
      * shading to it.
      * <p/>
-     * The colors stored in <tt>amb</tt>, <tt>diff</tt>, <tt>spec</tt> and <tt>emm</tt>
-     * have components ordered red, green, blue and alpha. The values for <tt>amb</tt>,
-     * <tt>diff</tt> and <tt>spec</tt> are clamped to be in [0, 1]. The values in
-     * <tt>emm</tt> are clamped to be above 0 and can be outside the standard range just
-     * like light colors.
+     * The colors stored in <var>amb</var>, <var>diff</var>, <var>spec</var> and
+     * <var>emm</var> have components ordered red, green, blue and alpha. The values for
+     * <var>amb</var>, <var>diff</var> and <var>spec</var> are clamped to be in [0, 1].
+     * The values in <var>emm</var> are clamped to be above 0 and can be outside the
+     * standard range just like light colors.
      * <p/>
      * The default ambient color is (0.2, 0.2, 0.2, 1), the diffuse is (0.8, 0.8, 0.8, 1),
      * and the specular and emissive colors are (0, 0, 0, 1).
 
     /**
      * <p/>
-     * Set the texture coordinate source for all four coordinates to <tt>gen</tt>, for the
-     * given texture unit.
+     * Set the texture coordinate source for all four coordinates to <var>gen</var>, for
+     * the given texture unit.
      * <p/>
      * The default source for every texture unit and coordinate is ATTRIBUTE.
      *
 
     /**
      * <p/>
-     * Configure how the texture's RGB values for the unit, <tt>text</tt> are combined
+     * Configure how the texture's RGB values for the unit, <var>text</var> are combined
      * with the colors from the previous stages of the pipeline. The {@link
      * CombineFunction function} uses the three inputs produced by each pair of {@link
      * CombineOperand operand} and {@link CombineSource source} to produce a color for the
 
     /**
      * <p/>
-     * Configure how the texture's alpha value for the unit, <tt>text</tt> is combined
+     * Configure how the texture's alpha value for the unit, <var>text</var> is combined
      * with the alphas from the previous stages of the pipeline. The {@link
      * CombineFunction function} uses the three inputs produced by each pair of {@link
      * CombineOperand operand} and {@link CombineSource source} to produce a color for the
     /**
      * <p/>
      * Set the VertexAttribute that is used as a source of texture coordinates on the
-     * texture unit, <tt>tex</tt> when {@link #render(PolygonType, int, int)} or {@link
+     * texture unit, <var>tex</var> when {@link #render(PolygonType, int, int)} or {@link
      * #render(PolygonType, com.ferox.resource.VertexBufferObject, int)} is invoked. The
      * attribute element size can be any value between 1 and 4. If the element size of the
      * attribute doesn't meet the expected coordinate size of the bound texture, a default
      * <p/>
      * Every texture unit starst with no attribute bound.
      *
-     * @param tex       The texture unit to bind <tt>texCoords</tt> to
+     * @param tex       The texture unit to bind <var>texCoords</var> to
      * @param texCoords The VertexAttribute holding the texture coordinate data and access
      *                  information
      *

ferox-renderer/ferox-renderer-api/src/main/java/com/ferox/renderer/Framework.java

      * If any of the options have unsupported values, the Framework may change them to
      * successfully create a surface.
      * <p/>
-     * If there is already a fullscreen surface and <tt>options</tt> would create a new
+     * If there is already a fullscreen surface and <var>options</var> would create a new
      * fullscreen surface, an exception is thrown. It is possible to have standard
      * windowed surfaces and fullscreen surface, although the windowed surfaces will be
      * hidden until the fullscreen surface is destroyed.
      * will create new textures that can be retrieved by calling the returned surface's
      * {@link TextureSurface#getColorBuffer(int)} and {@link TextureSurface#getDepthBuffer()}.
      * The size and texture format of the {@link Texture textures} used for the
-     * TextureSurface are determined by the provided <tt>options</tt>.
+     * TextureSurface are determined by the provided <var>options</var>.
      * <p/>
-     * If <tt>options</tt> is unsupported, the Framework is permitted to choose options
+     * If <var>options</var> is unsupported, the Framework is permitted to choose options
      * that allow it to create a valid TextureSurface. This includes changing the format
      * or dimensions to fit within hardware limits.
      *

ferox-renderer/ferox-renderer-api/src/main/java/com/ferox/renderer/GlslRenderer.java

     /**
      * <p/>
      * Set the current state of this renderer to equal the given state snapshot.
-     * <tt>state</tt> must have been returned by a prior call to {@link
+     * <var>state</var> must have been returned by a prior call to {@link
      * #getCurrentState()} from a GlslRenderer created by this renderer's Framework or
      * behavior is undefined.
      * <p/>

ferox-renderer/ferox-renderer-api/src/main/java/com/ferox/renderer/Renderer.java

      * Set the Comparison and reference values used when performing the stencil test. This
      * test will only be performed when it is enabled with {@link
      * #setStencilTestEnabled(boolean)}. When the test is enabled, the current stencil
-     * value is bitwise AND'ed with <tt>testMask</tt> and then compared to <tt>(refValue &
-     * testMask)</tt>. Thus <tt>testMask</tt> acts as a bitwise mask to both the current
-     * stencil value and the assigned reference value.
+     * value is bitwise AND'ed with <var>testMask</var> and then compared to
+     * <var>(refValue & testMask)</var>. Thus <var>testMask</var> acts as a bitwise mask
+     * to both the current stencil value and the assigned reference value.
      * <p/>
      * There are two different stencil test configurations available: one for front-facing
      * polygons and one for back-facing polygons. Points and lines are considered to be
     /**
      * <p/>
      * Set whether or not depth values can be written into the depth buffer once it has
-     * been determined that a pixel should be rendered. If <tt>mask</tt> is true then
+     * been determined that a pixel should be rendered. If <var>mask</var> is true then
      * depth values for rendered pixels will be placed in the depth buffer, otherwise no
      * depth is written.
      * <p/>
      * offset = factor * m + units * r.
      * </pre>
      * <p/>
-     * <tt>offset</tt> is the value added to the pixel's window depth; <tt>factor</tt> and
-     * <tt>units</tt> are the values specified in this method; <tt>m</tt> is the maximum
-     * depth slope of the polygon that contained the rendered pixel; <tt>r</tt> is the
-     * minimum difference between depth values such that they are distinct once stored in
-     * the depth buffer.
+     * <var>offset</var> is the value added to the pixel's window depth; <var>factor</var>
+     * and <var>units</var> are the values specified in this method; <var>m</var> is the
+     * maximum depth slope of the polygon that contained the rendered pixel; <var>r</var>
+     * is the minimum difference between depth values such that they are distinct once
+     * stored in the depth buffer.
      * <p/>
-     * <tt>m</tt> is computed as the length of the vector <dz/dx, dz/dy>. <tt>r</tt> is
-     * implementation dependent since it depends on the size and format of the depth
+     * <var>m</var> is computed as the length of the vector <dz/dx, dz/dy>. <var>r</var>
+     * is implementation dependent since it depends on the size and format of the depth
      * buffer in use for a Surface.
      * <p/>
      * The starting state is to have both factor and units equal to 0.
     /**
      * <p/>
      * Set the DrawStyle to be used for front-facing polygons and back-facing polygons.
-     * The <tt>front</tt> DrawStylespecifies how front-facing polygons are rendered, and
-     * <tt>back</tt> specifies how back-facing polygons are rendered.
+     * The <var>front</var> DrawStylespecifies how front-facing polygons are rendered, and
+     * <var>back</var> specifies how back-facing polygons are rendered.
      * <p/>
      * The facing of a polygon is determined by the counter-clockwise ordering of its
      * vertices. When a polygon is rendered, if it's vertices are specified in
     /**
      * <p/>
      * Set the index buffer that is used when rendering. If the index buffer is not null,
-     * the rendered polygons are described by the index values in <tt>indices</tt> and the
-     * polygon type specified by {@link #render(PolygonType, int, int)}.
+     * the rendered polygons are described by the index values in <var>indices</var> and
+     * the polygon type specified by {@link #render(PolygonType, int, int)}.
      * <p/>
      * The VertexBufferObject might be updated before rendering depending on its update
      * policy. The VertexBufferObject must have an integral data type of INT, SHORT, or
 
     /**
      * <p/>
-     * Render polygons by iterating through <tt>count</tt> of the configured indices
-     * starting at <tt>offset</tt>. Polygons are formed based on the polygon type
+     * Render polygons by iterating through <var>count</var> of the configured indices
+     * starting at <var>offset</var>. Polygons are formed based on the polygon type
      * provided. If there is a non-null bound index buffer count index values are read and
      * used to access the vertex attributes. If there is no index buffer, vertex
      * attributes are read directly starting at offset.
 
     /**
      * <p/>
-     * Clear the framebuffers of the current Surface based on <tt>clearColor</tt>,
-     * <tt>clearDepth</tt> and <tt>clearStencil</tt>. The color buffer will be cleared to
-     * (0, 0, 0,