Uses of Interface
org.joml.Vector3fc

Packages that use Vector3fc

Package	Description
org.joml	Contains all classes of JOML.

Uses of Vector3fc in org.joml

Classes in org.joml that implement Vector3fc

Modifier and Type	Class	Description
class	Vector3f	Contains the definition of a Vector comprising 3 floats and associated transformations.

Methods in org.joml that return Vector3fc

Modifier and Type	Method	Description
Vector3fc	FrustumRayBuilder.dir(float x, float y, Vector3f dir)	Obtain the normalized direction of a ray starting at the center of the coordinate system and going through the near frustum plane.
Vector3fc	Vector3f.getToAddress(long address)
Vector3fc	Vector3fc.getToAddress(long address)	Store this vector at the given off-heap memory address.
Vector3fc	FrustumRayBuilder.origin(Vector3f origin)	Store the eye/origin of the perspective frustum in the given origin.

Methods in org.joml with parameters of type Vector3fc

Modifier and Type	Method	Description
Vector3d	Vector3d.add(Vector3fc v)	Add the supplied vector to this one.
Vector3d	Vector3d.add(Vector3fc v, Vector3d dest)
Vector3d	Vector3dc.add(Vector3fc v, Vector3d dest)	Add the supplied vector to this one and store the result in dest.
Vector3f	Vector3f.add(Vector3fc v)	Add the supplied vector to this one.
Vector3f	Vector3f.add(Vector3fc v, Vector3f dest)
Vector3f	Vector3fc.add(Vector3fc v, Vector3f dest)	Add the supplied vector to this one and store the result in dest.
float	Vector3f.angle(Vector3fc v)
float	Vector3fc.angle(Vector3fc v)	Return the angle between this vector and the supplied vector.
float	Vector3f.angleCos(Vector3fc v)
float	Vector3fc.angleCos(Vector3fc v)	Return the cosine of the angle between this vector and the supplied vector.
float	Vector3f.angleSigned(Vector3fc v, Vector3fc n)
float	Vector3fc.angleSigned(Vector3fc v, Vector3fc n)	Return the signed angle between this vector and the supplied vector with respect to the plane with the given normal vector n.
Matrix4f	Matrix4f.arcball(float radius, Vector3fc center, float angleX, float angleY)	Apply an arcball view transformation to this matrix with the given radius and center position of the arcball and the specified X and Y rotation angles.
Matrix4f	Matrix4f.arcball(float radius, Vector3fc center, float angleX, float angleY, Matrix4f dest)
Matrix4f	Matrix4fc.arcball(float radius, Vector3fc center, float angleX, float angleY, Matrix4f dest)	Apply an arcball view transformation to this matrix with the given radius and center position of the arcball and the specified X and Y rotation angles, and store the result in dest.
Matrix4x3f	Matrix4x3f.arcball(float radius, Vector3fc center, float angleX, float angleY)	Apply an arcball view transformation to this matrix with the given radius and center position of the arcball and the specified X and Y rotation angles.
Matrix4x3f	Matrix4x3f.arcball(float radius, Vector3fc center, float angleX, float angleY, Matrix4x3f dest)
Matrix4x3f	Matrix4x3fc.arcball(float radius, Vector3fc center, float angleX, float angleY, Matrix4x3f dest)	Apply an arcball view transformation to this matrix with the given radius and center position of the arcball and the specified X and Y rotation angles, and store the result in dest.
Matrix4f	Matrix4f.billboardCylindrical(Vector3fc objPos, Vector3fc targetPos, Vector3fc up)	Set this matrix to a cylindrical billboard transformation that rotates the local +Z axis of a given object with position objPos towards a target position at targetPos while constraining a cylindrical rotation around the given up vector.
Matrix4x3f	Matrix4x3f.billboardCylindrical(Vector3fc objPos, Vector3fc targetPos, Vector3fc up)	Set this matrix to a cylindrical billboard transformation that rotates the local +Z axis of a given object with position objPos towards a target position at targetPos while constraining a cylindrical rotation around the given up vector.
Matrix4f	Matrix4f.billboardSpherical(Vector3fc objPos, Vector3fc targetPos)	Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position objPos towards a target position at targetPos using a shortest arc rotation by not preserving any up vector of the object.
Matrix4f	Matrix4f.billboardSpherical(Vector3fc objPos, Vector3fc targetPos, Vector3fc up)	Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position objPos towards a target position at targetPos.
Matrix4x3f	Matrix4x3f.billboardSpherical(Vector3fc objPos, Vector3fc targetPos)	Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position objPos towards a target position at targetPos using a shortest arc rotation by not preserving any up vector of the object.
Matrix4x3f	Matrix4x3f.billboardSpherical(Vector3fc objPos, Vector3fc targetPos, Vector3fc up)	Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position objPos towards a target position at targetPos.
static void	GeometryUtils.bitangent(Vector3fc v1, Vector2fc uv1, Vector3fc v2, Vector2fc uv2, Vector3fc v3, Vector2fc uv3, Vector3f dest)	Calculate the surface bitangent for the three supplied vertices and UV coordinates and store the result in dest.
Vector3f	Vector3f.cross(Vector3fc v)	Set this vector to be the cross product of itself and v.
Vector3f	Vector3f.cross(Vector3fc v, Vector3f dest)
Vector3f	Vector3fc.cross(Vector3fc v, Vector3f dest)	Compute the cross product of this vector and v and store the result in dest.
float	Vector3f.distance(Vector3fc v)
float	Vector3fc.distance(Vector3fc v)	Return the distance between this Vector and v.
float	Vector3f.distanceSquared(Vector3fc v)
float	Vector3fc.distanceSquared(Vector3fc v)	Return the square of the distance between this vector and v.
Vector3d	Vector3d.div(Vector3fc v)	Divide this Vector3d component-wise by another Vector3fc.
Vector3d	Vector3d.div(Vector3fc v, Vector3d dest)
Vector3d	Vector3dc.div(Vector3fc v, Vector3d dest)	Divide this Vector3d component-wise by another Vector3f and store the result in dest.
Vector3f	Vector3f.div(Vector3fc v)	Divide this Vector3f component-wise by another Vector3fc.
Vector3f	Vector3f.div(Vector3fc v, Vector3f dest)
Vector3f	Vector3fc.div(Vector3fc v, Vector3f dest)	Divide this Vector3f component-wise by another Vector3f and store the result in dest.
float	Vector3f.dot(Vector3fc v)
float	Vector3fc.dot(Vector3fc v)	Return the dot product of this vector and the supplied vector.
boolean	Vector3f.equals(Vector3fc v, float delta)
boolean	Vector3fc.equals(Vector3fc v, float delta)	Compare the vector components of this vector with the given vector using the given delta and return whether all of them are equal within a maximum difference of delta.
static int	Intersectionf.findClosestPointOnTriangle(Vector3fc v0, Vector3fc v1, Vector3fc v2, Vector3fc p, Vector3f result)	Determine the closest point on the triangle with the vertices v0, v1, v2 between that triangle and the given point p and store that point into the given result.
Vector3d	Vector3d.fma(double a, Vector3fc b)	Add the component-wise multiplication of a * b to this vector.
Vector3d	Vector3d.fma(double a, Vector3fc b, Vector3d dest)
Vector3d	Vector3d.fma(Vector3dc a, Vector3fc b, Vector3d dest)
Vector3d	Vector3d.fma(Vector3fc a, Vector3fc b)	Add the component-wise multiplication of a * b to this vector.
Vector3d	Vector3d.fma(Vector3fc a, Vector3fc b, Vector3d dest)
Vector3d	Vector3dc.fma(double a, Vector3fc b, Vector3d dest)	Add the component-wise multiplication of a * b to this vector and store the result in dest.
Vector3d	Vector3dc.fma(Vector3dc a, Vector3fc b, Vector3d dest)	Add the component-wise multiplication of a * b to this vector and store the result in dest.
Vector3d	Vector3dc.fma(Vector3fc a, Vector3fc b, Vector3d dest)	Add the component-wise multiplication of a * b to this vector and store the result in dest.
Vector3f	Vector3f.fma(float a, Vector3fc b)	Add the component-wise multiplication of a * b to this vector.
Vector3f	Vector3f.fma(float a, Vector3fc b, Vector3f dest)
Vector3f	Vector3f.fma(Vector3fc a, Vector3fc b)	Add the component-wise multiplication of a * b to this vector.
Vector3f	Vector3f.fma(Vector3fc a, Vector3fc b, Vector3f dest)
Vector3f	Vector3fc.fma(float a, Vector3fc b, Vector3f dest)	Add the component-wise multiplication of a * b to this vector and store the result in dest.
Vector3f	Vector3fc.fma(Vector3fc a, Vector3fc b, Vector3f dest)	Add the component-wise multiplication of a * b to this vector and store the result in dest.
Quaternionf	Quaternionf.fromAxisAngleDeg(Vector3fc axis, float angle)	Set this quaternion to be a representation of the supplied axis and angle (in degrees).
Quaternionf	Quaternionf.fromAxisAngleRad(Vector3fc axis, float angle)	Set this quaternion to be a representation of the supplied axis and angle (in radians).
Vector3f	Vector3f.half(Vector3fc other)	Compute the half vector between this and the other vector.
Vector3f	Vector3f.half(Vector3fc other, Vector3f dest)
Vector3f	Vector3fc.half(Vector3fc other, Vector3f dest)	Compute the half vector between this and the other vector and store the result in dest.
Vector3f	Vector3f.hermite(Vector3fc t0, Vector3fc v1, Vector3fc t1, float t, Vector3f dest)
Vector3f	Vector3fc.hermite(Vector3fc t0, Vector3fc v1, Vector3fc t1, float t, Vector3f dest)	Compute a hermite interpolation between this vector with its associated tangent t0 and the given vector v with its tangent t1 and store the result in dest.
int	FrustumIntersection.intersectAab(Vector3fc min, Vector3fc max)	Determine whether the given axis-aligned box is partly or completely within or outside of the frustum defined by this frustum culler and, if the box is not inside this frustum, return the index of the plane that culled it.
int	FrustumIntersection.intersectAab(Vector3fc min, Vector3fc max, int mask)	Determine whether the given axis-aligned box is partly or completely within or outside of the frustum defined by this frustum culler and, if the box is not inside this frustum, return the index of the plane that culled it.
int	FrustumIntersection.intersectAab(Vector3fc min, Vector3fc max, int mask, int startPlane)	Determine whether the given axis-aligned box is partly or completely within or outside of the frustum defined by this frustum culler and, if the box is not inside this frustum, return the index of the plane that culled it.
static int	Intersectionf.intersectLineSegmentAab(Vector3fc p0, Vector3fc p1, Vector3fc min, Vector3fc max, Vector2f result)	Determine whether the undirected line segment with the end points p0 and p1 intersects the axis-aligned box given as its minimum corner min and maximum corner max, and return the values of the parameter t in the ray equation p(t) = origin + p0 * (p1 - p0) of the near and far point of intersection.
static boolean	Intersectionf.intersectLineSegmentTriangle(Vector3fc p0, Vector3fc p1, Vector3fc v0, Vector3fc v1, Vector3fc v2, float epsilon, Vector3f intersectionPoint)	Determine whether the line segment with the end points p0 and p1 intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points, and return the point of intersection.
static boolean	Intersectionf.intersectRayAab(Vector3fc origin, Vector3fc dir, Vector3fc min, Vector3fc max, Vector2f result)	Test whether the ray with the given origin and direction dir intersects the axis-aligned box specified as its minimum corner min and maximum corner max, and return the values of the parameter t in the ray equation p(t) = origin + t * dir of the near and far point of intersection..
static float	Intersectionf.intersectRayPlane(Vector3fc origin, Vector3fc dir, Vector3fc point, Vector3fc normal, float epsilon)	Test whether the ray with given origin and direction dir intersects the plane containing the given point and having the given normal, and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the intersection point.
static boolean	Intersectionf.intersectRaySphere(Vector3fc origin, Vector3fc dir, Vector3fc center, float radiusSquared, Vector2f result)	Test whether the ray with the given origin and normalized direction dir intersects the sphere with the given center and square radius radiusSquared, and store the values of the parameter t in the ray equation p(t) = origin + t * dir for both points (near and far) of intersections into the given result vector.
static float	Intersectionf.intersectRayTriangle(Vector3fc origin, Vector3fc dir, Vector3fc v0, Vector3fc v1, Vector3fc v2, float epsilon)	Determine whether the ray with the given origin and the given dir intersects the triangle consisting of the three vertices v0, v1 and v2 and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.
static float	Intersectionf.intersectRayTriangleFront(Vector3fc origin, Vector3fc dir, Vector3fc v0, Vector3fc v1, Vector3fc v2, float epsilon)	Determine whether the ray with the given origin and the given dir intersects the frontface of the triangle consisting of the three vertices v0, v1 and v2 and return the value of the parameter t in the ray equation p(t) = origin + t * dir of the point of intersection.
int	FrustumIntersection.intersectSphere(Vector3fc center, float radius)	Determine whether the given sphere is partly or completely within or outside of the frustum defined by this frustum culler.
static boolean	Intersectionf.intersectSphereSphere(Vector3fc centerA, float radiusSquaredA, Vector3fc centerB, float radiusSquaredB, Vector4f centerAndRadiusOfIntersectionCircle)	Test whether the one sphere with center centerA and square radius radiusSquaredA intersects the other sphere with center centerB and square radius radiusSquaredB, and store the center of the circle of intersection in the (x, y, z) components of the supplied vector and the radius of that circle in the w component.
Vector3f	Vector3f.lerp(Vector3fc other, float t)	Linearly interpolate this and other using the given interpolation factor t and store the result in this.
Vector3f	Vector3f.lerp(Vector3fc other, float t, Vector3f dest)
Vector3f	Vector3fc.lerp(Vector3fc other, float t, Vector3f dest)	Linearly interpolate this and other using the given interpolation factor t and store the result in dest.
Matrix3f	Matrix3f.lookAlong(Vector3fc dir, Vector3fc up)	Apply a rotation transformation to this matrix to make -z point along dir.
Matrix3f	Matrix3f.lookAlong(Vector3fc dir, Vector3fc up, Matrix3f dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix3f	Matrix3fc.lookAlong(Vector3fc dir, Vector3fc up, Matrix3f dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix4f	Matrix4f.lookAlong(Vector3fc dir, Vector3fc up)	Apply a rotation transformation to this matrix to make -z point along dir.
Matrix4f	Matrix4f.lookAlong(Vector3fc dir, Vector3fc up, Matrix4f dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix4f	Matrix4fc.lookAlong(Vector3fc dir, Vector3fc up, Matrix4f dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix4x3f	Matrix4x3f.lookAlong(Vector3fc dir, Vector3fc up)	Apply a rotation transformation to this matrix to make -z point along dir.
Matrix4x3f	Matrix4x3f.lookAlong(Vector3fc dir, Vector3fc up, Matrix4x3f dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix4x3f	Matrix4x3fc.lookAlong(Vector3fc dir, Vector3fc up, Matrix4x3f dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Quaternionf	Quaternionf.lookAlong(Vector3fc dir, Vector3fc up)	Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
Quaternionf	Quaternionf.lookAlong(Vector3fc dir, Vector3fc up, Quaternionf dest)
Quaternionf	Quaternionfc.lookAlong(Vector3fc dir, Vector3fc up, Quaternionf dest)	Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in dest.
Matrix4f	Matrix4f.lookAt(Vector3fc eye, Vector3fc center, Vector3fc up)	Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye.
Matrix4f	Matrix4f.lookAt(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4f dest)	Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye and store the result in dest.
Matrix4f	Matrix4fc.lookAt(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4f dest)	Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye and store the result in dest.
Matrix4x3f	Matrix4x3f.lookAt(Vector3fc eye, Vector3fc center, Vector3fc up)	Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye.
Matrix4x3f	Matrix4x3f.lookAt(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4x3f dest)	Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye and store the result in dest.
Matrix4x3f	Matrix4x3fc.lookAt(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4x3f dest)	Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye and store the result in dest.
Matrix4f	Matrix4f.lookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up)	Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye.
Matrix4f	Matrix4f.lookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4f dest)	Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye and store the result in dest.
Matrix4f	Matrix4fc.lookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4f dest)	Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye and store the result in dest.
Matrix4x3f	Matrix4x3f.lookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up)	Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye.
Matrix4x3f	Matrix4x3f.lookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4x3f dest)	Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye and store the result in dest.
Matrix4x3f	Matrix4x3fc.lookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4x3f dest)	Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye and store the result in dest.
Vector3f	Vector3f.max(Vector3fc v)	Set the components of this vector to be the component-wise maximum of this and the other vector.
Vector3f	Vector3f.max(Vector3fc v, Vector3f dest)
Vector3f	Vector3fc.max(Vector3fc v, Vector3f dest)	Set the components of dest to be the component-wise maximum of this and the other vector.
Vector3f	Vector3f.min(Vector3fc v)	Set the components of this vector to be the component-wise minimum of this and the other vector.
Vector3f	Vector3f.min(Vector3fc v, Vector3f dest)
Vector3f	Vector3fc.min(Vector3fc v, Vector3f dest)	Set the components of dest to be the component-wise minimum of this and the other vector.
Vector3d	Vector3d.mul(Vector3fc v)	Multiply this Vector3d component-wise by another Vector3fc.
Vector3d	Vector3d.mul(Vector3fc v, Vector3d dest)
Vector3d	Vector3dc.mul(Vector3fc v, Vector3d dest)	Multiply this Vector3d component-wise by another Vector3f and store the result in dest.
Vector3f	Vector3f.mul(Vector3fc v)	Multiply this Vector3f component-wise by another Vector3fc.
Vector3f	Vector3f.mul(Vector3fc v, Vector3f dest)
Vector3f	Vector3fc.mul(Vector3fc v, Vector3f dest)	Multiply this Vector3f component-wise by another Vector3f and store the result in dest.
Vector3d	Vector3d.mulAdd(Vector3fc a, Vector3dc b, Vector3d dest)
Vector3d	Vector3dc.mulAdd(Vector3fc a, Vector3dc b, Vector3d dest)	Add the component-wise multiplication of this * a to b and store the result in dest.
Vector3f	Vector3f.mulAdd(float a, Vector3fc b)	Add the component-wise multiplication of this * a to b and store the result in this.
Vector3f	Vector3f.mulAdd(float a, Vector3fc b, Vector3f dest)
Vector3f	Vector3f.mulAdd(Vector3fc a, Vector3fc b)	Add the component-wise multiplication of this * a to b and store the result in this.
Vector3f	Vector3f.mulAdd(Vector3fc a, Vector3fc b, Vector3f dest)
Vector3f	Vector3fc.mulAdd(float a, Vector3fc b, Vector3f dest)	Add the component-wise multiplication of this * a to b and store the result in dest.
Vector3f	Vector3fc.mulAdd(Vector3fc a, Vector3fc b, Vector3f dest)	Add the component-wise multiplication of this * a to b and store the result in dest.
static void	GeometryUtils.normal(Vector3fc v0, Vector3fc v1, Vector3fc v2, Vector3f dest)	Calculate the normal of a surface defined by points v1, v2 and v3 and store it in dest.
Vector3f	Vector3f.orthogonalize(Vector3fc v)	Transform this vector so that it is orthogonal to the given vector v and normalize the result.
Vector3f	Vector3f.orthogonalize(Vector3fc v, Vector3f dest)
Vector3f	Vector3fc.orthogonalize(Vector3fc v, Vector3f dest)	Transform this vector so that it is orthogonal to the given vector v, normalize the result and store it into dest.
Vector3f	Vector3f.orthogonalizeUnit(Vector3fc v)	Transform this vector so that it is orthogonal to the given unit vector v and normalize the result.
Vector3f	Vector3f.orthogonalizeUnit(Vector3fc v, Vector3f dest)
Vector3f	Vector3fc.orthogonalizeUnit(Vector3fc v, Vector3f dest)	Transform this vector so that it is orthogonal to the given unit vector v, normalize the result and store it into dest.
static void	GeometryUtils.perpendicular(Vector3fc v, Vector3f dest1, Vector3f dest2)	Compute two arbitrary vectors perpendicular to the given normalized vector v, and store them in dest1 and dest2, respectively.
Vector3f	Matrix4f.project(Vector3fc position, int[] viewport, Vector3f winCoordsDest)
Vector4f	Matrix4f.project(Vector3fc position, int[] viewport, Vector4f winCoordsDest)
Vector3f	Matrix4fc.project(Vector3fc position, int[] viewport, Vector3f winCoordsDest)	Project the given position via this matrix using the specified viewport and store the resulting window coordinates in winCoordsDest.
Vector4f	Matrix4fc.project(Vector3fc position, int[] viewport, Vector4f winCoordsDest)	Project the given position via this matrix using the specified viewport and store the resulting window coordinates in winCoordsDest.
double	Matrix3d.quadraticFormProduct(Vector3fc v)
double	Matrix3dc.quadraticFormProduct(Vector3fc v)	Compute v^T * this * v.
float	Matrix3f.quadraticFormProduct(Vector3fc v)
float	Matrix3fc.quadraticFormProduct(Vector3fc v)	Compute v^T * this * v.
Matrix3f	Matrix3f.reflect(Vector3fc normal)	Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal.
Matrix3f	Matrix3f.reflect(Vector3fc normal, Matrix3f dest)
Matrix3f	Matrix3fc.reflect(Vector3fc normal, Matrix3f dest)	Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal, and store the result in dest.
Matrix4f	Matrix4f.reflect(Quaternionfc orientation, Vector3fc point)	Apply a mirror/reflection transformation to this matrix that reflects about a plane specified via the plane orientation and a point on the plane.
Matrix4f	Matrix4f.reflect(Quaternionfc orientation, Vector3fc point, Matrix4f dest)
Matrix4f	Matrix4f.reflect(Vector3fc normal, Vector3fc point)	Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the plane normal and a point on the plane.
Matrix4f	Matrix4f.reflect(Vector3fc normal, Vector3fc point, Matrix4f dest)
Matrix4f	Matrix4fc.reflect(Quaternionfc orientation, Vector3fc point, Matrix4f dest)	Apply a mirror/reflection transformation to this matrix that reflects about a plane specified via the plane orientation and a point on the plane, and store the result in dest.
Matrix4f	Matrix4fc.reflect(Vector3fc normal, Vector3fc point, Matrix4f dest)	Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the plane normal and a point on the plane, and store the result in dest.
Matrix4x3f	Matrix4x3f.reflect(Quaternionfc orientation, Vector3fc point)	Apply a mirror/reflection transformation to this matrix that reflects about a plane specified via the plane orientation and a point on the plane.
Matrix4x3f	Matrix4x3f.reflect(Quaternionfc orientation, Vector3fc point, Matrix4x3f dest)
Matrix4x3f	Matrix4x3f.reflect(Vector3fc normal, Vector3fc point)	Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the plane normal and a point on the plane.
Matrix4x3f	Matrix4x3f.reflect(Vector3fc normal, Vector3fc point, Matrix4x3f dest)
Matrix4x3f	Matrix4x3fc.reflect(Quaternionfc orientation, Vector3fc point, Matrix4x3f dest)	Apply a mirror/reflection transformation to this matrix that reflects about a plane specified via the plane orientation and a point on the plane, and store the result in dest.
Matrix4x3f	Matrix4x3fc.reflect(Vector3fc normal, Vector3fc point, Matrix4x3f dest)	Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the plane normal and a point on the plane, and store the result in dest.
Vector3f	Vector3f.reflect(Vector3fc normal)	Reflect this vector about the given normal vector.
Vector3f	Vector3f.reflect(Vector3fc normal, Vector3f dest)
Vector3f	Vector3fc.reflect(Vector3fc normal, Vector3f dest)	Reflect this vector about the given normal vector and store the result in dest.
Matrix3f	Matrix3f.reflection(Vector3fc normal)	Set this matrix to a mirror/reflection transformation that reflects through the given plane specified via the plane normal.
Matrix4f	Matrix4f.reflection(Quaternionfc orientation, Vector3fc point)	Set this matrix to a mirror/reflection transformation that reflects about a plane specified via the plane orientation and a point on the plane.
Matrix4f	Matrix4f.reflection(Vector3fc normal, Vector3fc point)	Set this matrix to a mirror/reflection transformation that reflects about the given plane specified via the plane normal and a point on the plane.
Matrix4x3f	Matrix4x3f.reflection(Quaternionfc orientation, Vector3fc point)	Set this matrix to a mirror/reflection transformation that reflects about a plane specified via the plane orientation and a point on the plane.
Matrix4x3f	Matrix4x3f.reflection(Vector3fc normal, Vector3fc point)	Set this matrix to a mirror/reflection transformation that reflects about the given plane specified via the plane normal and a point on the plane.
Matrix3d	Matrix3d.rotate(double angle, Vector3fc axis)	Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix3d	Matrix3d.rotate(double angle, Vector3fc axis, Matrix3d dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix3d	Matrix3dc.rotate(double angle, Vector3fc axis, Matrix3d dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix3f	Matrix3f.rotate(float angle, Vector3fc axis)	Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix3f	Matrix3f.rotate(float angle, Vector3fc axis, Matrix3f dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix3f	Matrix3fc.rotate(float angle, Vector3fc axis, Matrix3f dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4d	Matrix4d.rotate(double angle, Vector3fc axis)	Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix4d	Matrix4d.rotate(double angle, Vector3fc axis, Matrix4d dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4d	Matrix4dc.rotate(double angle, Vector3fc axis, Matrix4d dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4f	Matrix4f.rotate(float angle, Vector3fc axis)	Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix4f	Matrix4f.rotate(float angle, Vector3fc axis, Matrix4f dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4f	Matrix4fc.rotate(float angle, Vector3fc axis, Matrix4f dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4x3d	Matrix4x3d.rotate(double angle, Vector3fc axis)	Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix4x3d	Matrix4x3d.rotate(double angle, Vector3fc axis, Matrix4x3d dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4x3d	Matrix4x3dc.rotate(double angle, Vector3fc axis, Matrix4x3d dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4x3f	Matrix4x3f.rotate(float angle, Vector3fc axis)	Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix4x3f	Matrix4x3f.rotate(float angle, Vector3fc axis, Matrix4x3f dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4x3f	Matrix4x3fc.rotate(float angle, Vector3fc axis, Matrix4x3f dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Quaternionf	Quaternionf.rotateAxis(float angle, Vector3fc axis)	Apply a rotation to this quaternion rotating the given radians about the specified axis.
Quaternionf	Quaternionf.rotateAxis(float angle, Vector3fc axis, Quaternionf dest)
Quaternionf	Quaternionfc.rotateAxis(float angle, Vector3fc axis, Quaternionf dest)	Apply a rotation to this quaternion rotating the given radians about the specified axis and store the result in dest.
Quaternionf	Quaternionf.rotateTo(Vector3fc fromDir, Vector3fc toDir)	Apply a rotation to this that rotates the fromDir vector to point along toDir.
Quaternionf	Quaternionf.rotateTo(Vector3fc fromDir, Vector3fc toDir, Quaternionf dest)
Quaternionf	Quaternionfc.rotateTo(Vector3fc fromDir, Vector3fc toDir, Quaternionf dest)	Apply a rotation to this that rotates the fromDir vector to point along toDir and store the result in dest.
Matrix3f	Matrix3f.rotateTowards(Vector3fc direction, Vector3fc up)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction.
Matrix3f	Matrix3f.rotateTowards(Vector3fc direction, Vector3fc up, Matrix3f dest)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction and store the result in dest.
Matrix3f	Matrix3fc.rotateTowards(Vector3fc direction, Vector3fc up, Matrix3f dest)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction and store the result in dest.
Matrix4f	Matrix4f.rotateTowards(Vector3fc dir, Vector3fc up)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir.
Matrix4f	Matrix4f.rotateTowards(Vector3fc dir, Vector3fc up, Matrix4f dest)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir and store the result in dest.
Matrix4f	Matrix4fc.rotateTowards(Vector3fc dir, Vector3fc up, Matrix4f dest)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir and store the result in dest.
Matrix4x3f	Matrix4x3f.rotateTowards(Vector3fc dir, Vector3fc up)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir.
Matrix4x3f	Matrix4x3f.rotateTowards(Vector3fc dir, Vector3fc up, Matrix4x3f dest)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir and store the result in dest.
Matrix4x3f	Matrix4x3fc.rotateTowards(Vector3fc dir, Vector3fc up, Matrix4x3f dest)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir and store the result in dest.
Matrix4f	Matrix4f.rotateXYZ(Vector3fc angles)	Apply rotation of angles.x radians about the X axis, followed by a rotation of angles.y radians about the Y axis and followed by a rotation of angles.z radians about the Z axis.
Matrix3d	Matrix3d.rotation(double angle, Vector3fc axis)	Set this matrix to a rotation matrix which rotates the given radians about a given axis.
Matrix3f	Matrix3f.rotation(float angle, Vector3fc axis)	Set this matrix to a rotation matrix which rotates the given radians about a given axis.
Matrix4d	Matrix4d.rotation(double angle, Vector3fc axis)	Set this matrix to a rotation matrix which rotates the given radians about a given axis.
Matrix4f	Matrix4f.rotation(float angle, Vector3fc axis)	Set this matrix to a rotation matrix which rotates the given radians about a given axis.
Matrix4x3d	Matrix4x3d.rotation(double angle, Vector3fc axis)	Set this matrix to a rotation matrix which rotates the given radians about a given axis.
Matrix4x3f	Matrix4x3f.rotation(float angle, Vector3fc axis)	Set this matrix to a rotation matrix which rotates the given radians about a given axis.
Quaternionf	Quaternionf.rotationAxis(float angle, Vector3fc axis)	Set this quaternion to a rotation of the given angle in radians about the supplied axis.
Quaternionf	Quaternionf.rotationTo(Vector3fc fromDir, Vector3fc toDir)	Set this quaternion to a rotation that rotates the fromDir vector to point along toDir.
Quaternionf	Vector3f.rotationTo(Vector3fc toDir, Quaternionf dest)
Quaternionf	Vector3fc.rotationTo(Vector3fc toDir, Quaternionf dest)	Compute the quaternion representing a rotation of this vector to point along toDir and store the result in dest.
Matrix3f	Matrix3f.rotationTowards(Vector3fc dir, Vector3fc up)	Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local -z axis with center - eye.
Matrix4f	Matrix4f.rotationTowards(Vector3fc dir, Vector3fc up)	Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local -z axis with dir.
Matrix4x3f	Matrix4x3f.rotationTowards(Vector3fc dir, Vector3fc up)	Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local -z axis with dir.
Matrix3f	Matrix3f.scale(Vector3fc xyz)	Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively.
Matrix3f	Matrix3f.scale(Vector3fc xyz, Matrix3f dest)
Matrix3f	Matrix3fc.scale(Vector3fc xyz, Matrix3f dest)	Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively and store the result in dest.
Matrix4f	Matrix4f.scale(Vector3fc xyz)	Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively.
Matrix4f	Matrix4f.scale(Vector3fc xyz, Matrix4f dest)
Matrix4f	Matrix4fc.scale(Vector3fc xyz, Matrix4f dest)	Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively and store the result in dest.
Matrix4x3f	Matrix4x3f.scale(Vector3fc xyz)	Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively.
Matrix4x3f	Matrix4x3f.scale(Vector3fc xyz, Matrix4x3f dest)
Matrix4x3f	Matrix4x3fc.scale(Vector3fc xyz, Matrix4x3f dest)	Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively and store the result in dest.
Matrix3f	Matrix3f.scaling(Vector3fc xyz)	Set this matrix to be a simple scale matrix which scales the base axes by xyz.x, xyz.y and xyz.z respectively.
Matrix4f	Matrix4f.scaling(Vector3fc xyz)	Set this matrix to be a simple scale matrix which scales the base axes by xyz.x, xyz.y and xyz.z respectively.
Matrix4x3f	Matrix4x3f.scaling(Vector3fc xyz)	Set this matrix to be a simple scale matrix which scales the base axes by xyz.x, xyz.y and xyz.z respectively.
AxisAngle4f	AxisAngle4f.set(float angle, Vector3fc v)	Set this AxisAngle4f to the given values.
Matrix3f	Matrix3f.set(Vector3fc col0, Vector3fc col1, Vector3fc col2)	Set the three columns of this matrix to the supplied vectors, respectively.
Matrix4x3f	Matrix4x3f.set(Vector3fc col0, Vector3fc col1, Vector3fc col2, Vector3fc col3)	Set the four columns of this matrix to the supplied vectors, respectively.
Vector3d	Vector3d.set(Vector3fc v)	Set the x, y and z components to match the supplied vector.
Vector3f	Vector3f.set(Vector3fc v)	Set the x, y and z components to match the supplied vector.
Vector3i	Vector3i.set(Vector3fc v, int mode)	Set this Vector3i to the values of v using the given RoundingMode.
Vector4d	Vector4d.set(Vector3fc v, double w)	Set the x, y, and z components of this to the components of v and the w component to w.
Vector4f	Vector4f.set(Vector3fc v, float w)	Set the first three components of this to the components of v and the last component to w.
Matrix3f	Matrix3f.setColumn(int column, Vector3fc src)	Set the column at the given column index, starting with 0.
Matrix4x3f	Matrix4x3f.setColumn(int column, Vector3fc src)	Set the column at the given column index, starting with 0.
Matrix3f	Matrix3f.setLookAlong(Vector3fc dir, Vector3fc up)	Set this matrix to a rotation transformation to make -z point along dir.
Matrix4f	Matrix4f.setLookAlong(Vector3fc dir, Vector3fc up)	Set this matrix to a rotation transformation to make -z point along dir.
Matrix4x3f	Matrix4x3f.setLookAlong(Vector3fc dir, Vector3fc up)	Set this matrix to a rotation transformation to make -z point along dir.
Matrix4f	Matrix4f.setLookAt(Vector3fc eye, Vector3fc center, Vector3fc up)	Set this matrix to be a "lookat" transformation for a right-handed coordinate system, that aligns -z with center - eye.
Matrix4x3f	Matrix4x3f.setLookAt(Vector3fc eye, Vector3fc center, Vector3fc up)	Set this matrix to be a "lookat" transformation for a right-handed coordinate system, that aligns -z with center - eye.
Matrix4f	Matrix4f.setLookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up)	Set this matrix to be a "lookat" transformation for a left-handed coordinate system, that aligns +z with center - eye.
Matrix4x3f	Matrix4x3f.setLookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up)	Set this matrix to be a "lookat" transformation for a left-handed coordinate system, that aligns +z with center - eye.
Matrix3f	Matrix3f.setRow(int row, Vector3fc src)	Set the row at the given row index, starting with 0.
Matrix4f	Matrix4f.setTranslation(Vector3fc xyz)	Set only the translation components (m30, m31, m32) of this matrix to the values (xyz.x, xyz.y, xyz.z).
Matrix4x3f	Matrix4x3f.setTranslation(Vector3fc xyz)	Set only the translation components (m30, m31, m32) of this matrix to the values (xyz.x, xyz.y, xyz.z).
Vector3f	Vector3f.smoothStep(Vector3fc v, float t, Vector3f dest)
Vector3f	Vector3fc.smoothStep(Vector3fc v, float t, Vector3f dest)	Compute a smooth-step (i.e.
Vector3d	Vector3d.sub(Vector3fc v)	Subtract the supplied vector from this one.
Vector3d	Vector3d.sub(Vector3fc v, Vector3d dest)
Vector3d	Vector3dc.sub(Vector3fc v, Vector3d dest)	Subtract the supplied vector from this one and store the result in dest.
Vector3f	Vector3f.sub(Vector3fc v)	Subtract the supplied vector from this one and store the result in this.
Vector3f	Vector3f.sub(Vector3fc v, Vector3f dest)
Vector3f	Vector3fc.sub(Vector3fc v, Vector3f dest)	Subtract the supplied vector from this one and store the result in dest.
static void	GeometryUtils.tangent(Vector3fc v1, Vector2fc uv1, Vector3fc v2, Vector2fc uv2, Vector3fc v3, Vector2fc uv3, Vector3f dest)	Calculate the surface tangent for the three supplied vertices and UV coordinates and store the result in dest.
static void	GeometryUtils.tangentBitangent(Vector3fc v1, Vector2fc uv1, Vector3fc v2, Vector2fc uv2, Vector3fc v3, Vector2fc uv3, Vector3f destTangent, Vector3f destBitangent)	Calculate the surface tangent and bitangent for the three supplied vertices and UV coordinates and store the result in dest.
boolean	FrustumIntersection.testAab(Vector3fc min, Vector3fc max)	Test whether the given axis-aligned box is partly or completely within or outside of the frustum defined by this frustum culler.
static boolean	Intersectionf.testAabAab(Vector3fc minA, Vector3fc maxA, Vector3fc minB, Vector3fc maxB)	Test whether the axis-aligned box with minimum corner minA and maximum corner maxA intersects the axis-aligned box with minimum corner minB and maximum corner maxB.
static boolean	Intersectionf.testAabPlane(Vector3fc min, Vector3fc max, float a, float b, float c, float d)	Test whether the axis-aligned box with minimum corner min and maximum corner max intersects the plane with the general equation a*x + b*y + c*z + d = 0.
static boolean	Intersectionf.testAabSphere(Vector3fc min, Vector3fc max, Vector3fc center, float radiusSquared)	Test whether the axis-aligned box with minimum corner min and maximum corner max intersects the sphere with the given center and square radius radiusSquared.
boolean	FrustumIntersection.testLineSegment(Vector3fc a, Vector3fc b)	Test whether the given line segment, defined by the end points a and b, is partly or completely within the frustum defined by this frustum culler.
static boolean	Intersectionf.testLineSegmentSphere(Vector3fc p0, Vector3fc p1, Vector3fc center, float radiusSquared)	Test whether the line segment with the end points p0 and p1 intersects the given sphere with center center and square radius radiusSquared.
static boolean	Intersectionf.testLineSegmentTriangle(Vector3fc p0, Vector3fc p1, Vector3fc v0, Vector3fc v1, Vector3fc v2, float epsilon)	Test whether the line segment with the end points p0 and p1 intersects the triangle consisting of the three vertices (v0X, v0Y, v0Z), (v1X, v1Y, v1Z) and (v2X, v2Y, v2Z), regardless of the winding order of the triangle or the direction of the line segment between its two end points.
boolean	FrustumIntersection.testPoint(Vector3fc point)	Test whether the given point is within the frustum defined by this frustum culler.
static boolean	Intersectionf.testRayAab(Vector3fc origin, Vector3fc dir, Vector3fc min, Vector3fc max)	Test whether the ray with the given origin and direction dir intersects the axis-aligned box specified as its minimum corner min and maximum corner max.
static boolean	Intersectionf.testRaySphere(Vector3fc origin, Vector3fc dir, Vector3fc center, float radiusSquared)	Test whether the ray with the given origin and normalized direction dir intersects the sphere with the given center and square radius.
static boolean	Intersectionf.testRayTriangle(Vector3fc origin, Vector3fc dir, Vector3fc v0, Vector3fc v1, Vector3fc v2, float epsilon)	Test whether the ray with the given origin and the given dir intersects the frontface of the triangle consisting of the three vertices v0, v1 and v2.
static boolean	Intersectionf.testRayTriangleFront(Vector3fc origin, Vector3fc dir, Vector3fc v0, Vector3fc v1, Vector3fc v2, float epsilon)	Test whether the ray with the given origin and the given dir intersects the frontface of the triangle consisting of the three vertices v0, v1 and v2.
boolean	FrustumIntersection.testSphere(Vector3fc center, float radius)	Test whether the given sphere is partly or completely within or outside of the frustum defined by this frustum culler.
static boolean	Intersectionf.testSphereSphere(Vector3fc centerA, float radiusSquaredA, Vector3fc centerB, float radiusSquaredB)	Test whether the one sphere with center centerA and square radius radiusSquaredA intersects the other sphere with center centerB and square radius radiusSquaredB.
Vector3f	AxisAngle4d.transform(Vector3fc v, Vector3f dest)	Transform the given vector by the rotation transformation described by this AxisAngle4d and store the result in dest.
Vector3f	AxisAngle4f.transform(Vector3fc v, Vector3f dest)	Transform the given vector by the rotation transformation described by this AxisAngle4f and store the result in dest.
Vector3f	Matrix3d.transform(Vector3fc v, Vector3f dest)
Vector3f	Matrix3dc.transform(Vector3fc v, Vector3f dest)	Transform the given vector by this matrix and store the result in dest.
Vector3f	Matrix3f.transform(Vector3fc v, Vector3f dest)
Vector3f	Matrix3fc.transform(Vector3fc v, Vector3f dest)	Transform the given vector by this matrix and store the result in dest.
Vector3f	Quaterniond.transform(Vector3fc vec, Vector3f dest)
Vector3f	Quaterniondc.transform(Vector3fc vec, Vector3f dest)	Transform the given vector by this quaternion and store the result in dest.
Vector3f	Quaternionf.transform(Vector3fc vec, Vector3f dest)
Vector3f	Quaternionfc.transform(Vector3fc vec, Vector3f dest)	Transform the given vector by this quaternion and store the result in dest.
Matrix4f	Matrix4f.transformAab(Vector3fc min, Vector3fc max, Vector3f outMin, Vector3f outMax)
Matrix4f	Matrix4fc.transformAab(Vector3fc min, Vector3fc max, Vector3f outMin, Vector3f outMax)	Transform the axis-aligned box given as the minimum corner min and maximum corner max by this affine matrix and compute the axis-aligned box of the result whose minimum corner is stored in outMin and maximum corner stored in outMax.
Matrix4x3f	Matrix4x3f.transformAab(Vector3fc min, Vector3fc max, Vector3f outMin, Vector3f outMax)
Matrix4x3f	Matrix4x3fc.transformAab(Vector3fc min, Vector3fc max, Vector3f outMin, Vector3f outMax)	Transform the axis-aligned box given as the minimum corner min and maximum corner max by this matrix and compute the axis-aligned box of the result whose minimum corner is stored in outMin and maximum corner stored in outMax.
Vector3f	Matrix4d.transformDirection(Vector3fc v, Vector3f dest)
Vector3f	Matrix4dc.transformDirection(Vector3fc v, Vector3f dest)	Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by this matrix and store the result in dest.
Vector3f	Matrix4f.transformDirection(Vector3fc v, Vector3f dest)
Vector3f	Matrix4fc.transformDirection(Vector3fc v, Vector3f dest)	Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by this matrix and store the result in dest.
Vector3f	Matrix4x3f.transformDirection(Vector3fc v, Vector3f dest)
Vector3f	Matrix4x3fc.transformDirection(Vector3fc v, Vector3f dest)	Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by this matrix and store the result in dest.
Vector3f	Quaterniond.transformInverse(Vector3fc vec, Vector3f dest)
Vector3f	Quaterniondc.transformInverse(Vector3fc vec, Vector3f dest)	Transform the given vector by the inverse of this quaternion and store the result in dest.
Vector3f	Quaternionf.transformInverse(Vector3fc vec, Vector3f dest)
Vector3f	Quaternionfc.transformInverse(Vector3fc vec, Vector3f dest)	Transform the given vector by the inverse of quaternion and store the result in dest.
Vector3f	Quaterniond.transformInverseUnit(Vector3fc vec, Vector3f dest)
Vector3f	Quaterniondc.transformInverseUnit(Vector3fc vec, Vector3f dest)	Transform the given vector by the inverse of this unit quaternion and store the result in dest.
Vector3f	Quaternionf.transformInverseUnit(Vector3fc vec, Vector3f dest)
Vector3f	Quaternionfc.transformInverseUnit(Vector3fc vec, Vector3f dest)	Transform the given vector by the inverse of this unit quaternion and store the result in dest.
Vector3f	Matrix4f.transformPosition(Vector3fc v, Vector3f dest)
Vector3f	Matrix4fc.transformPosition(Vector3fc v, Vector3f dest)	Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=1, by this matrix and store the result in dest.
Vector3f	Matrix4x3f.transformPosition(Vector3fc v, Vector3f dest)
Vector3f	Matrix4x3fc.transformPosition(Vector3fc v, Vector3f dest)	Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=1, by this matrix and store the result in dest.
Vector3f	Matrix4f.transformProject(Vector3fc v, Vector3f dest)
Vector3f	Matrix4fc.transformProject(Vector3fc v, Vector3f dest)	Transform/multiply the given vector by this matrix, perform perspective divide and store the result in dest.
Vector3f	Matrix3f.transformTranspose(Vector3fc v, Vector3f dest)
Vector3f	Matrix3fc.transformTranspose(Vector3fc v, Vector3f dest)	Transform the given vector by the transpose of this matrix and store the result in dest.
Vector3f	Quaterniond.transformUnit(Vector3fc vec, Vector3f dest)
Vector3f	Quaterniondc.transformUnit(Vector3fc vec, Vector3f dest)	Transform the given vector by this unit quaternion and store the result in dest.
Vector3f	Quaternionf.transformUnit(Vector3fc vec, Vector3f dest)
Vector3f	Quaternionfc.transformUnit(Vector3fc vec, Vector3f dest)	Transform the given vector by this unit quaternion and store the result in dest.
Matrix4d	Matrix4d.translate(Vector3fc offset)	Apply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4d	Matrix4d.translate(Vector3fc offset, Matrix4d dest)	Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4d	Matrix4dc.translate(Vector3fc offset, Matrix4d dest)	Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4f	Matrix4f.translate(Vector3fc offset)	Apply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4f	Matrix4f.translate(Vector3fc offset, Matrix4f dest)	Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4f	Matrix4fc.translate(Vector3fc offset, Matrix4f dest)	Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4x3d	Matrix4x3d.translate(Vector3fc offset)	Apply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4x3d	Matrix4x3d.translate(Vector3fc offset, Matrix4x3d dest)	Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4x3d	Matrix4x3dc.translate(Vector3fc offset, Matrix4x3d dest)	Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4x3f	Matrix4x3f.translate(Vector3fc offset)	Apply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4x3f	Matrix4x3f.translate(Vector3fc offset, Matrix4x3f dest)	Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4x3f	Matrix4x3fc.translate(Vector3fc offset, Matrix4x3f dest)	Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4d	Matrix4d.translateLocal(Vector3fc offset)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4d	Matrix4d.translateLocal(Vector3fc offset, Matrix4d dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4d	Matrix4dc.translateLocal(Vector3fc offset, Matrix4d dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4f	Matrix4f.translateLocal(Vector3fc offset)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4f	Matrix4f.translateLocal(Vector3fc offset, Matrix4f dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4f	Matrix4fc.translateLocal(Vector3fc offset, Matrix4f dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4x3d	Matrix4x3d.translateLocal(Vector3fc offset)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4x3d	Matrix4x3d.translateLocal(Vector3fc offset, Matrix4x3d dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4x3d	Matrix4x3dc.translateLocal(Vector3fc offset, Matrix4x3d dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4x3f	Matrix4x3f.translateLocal(Vector3fc offset)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4x3f	Matrix4x3f.translateLocal(Vector3fc offset, Matrix4x3f dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4x3f	Matrix4x3fc.translateLocal(Vector3fc offset, Matrix4x3f dest)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in dest.
Matrix4d	Matrix4d.translation(Vector3fc offset)	Set this matrix to be a simple translation matrix.
Matrix4f	Matrix4f.translation(Vector3fc offset)	Set this matrix to be a simple translation matrix.
Matrix4x3d	Matrix4x3d.translation(Vector3fc offset)	Set this matrix to be a simple translation matrix.
Matrix4x3f	Matrix4x3f.translation(Vector3fc offset)	Set this matrix to be a simple translation matrix.
Matrix4f	Matrix4f.translationRotate(Vector3fc translation, Quaternionfc quat)	Set this matrix to T * R, where T is the given translation and R is a rotation transformation specified by the given quaternion.
Matrix4x3f	Matrix4x3f.translationRotate(Vector3fc translation, Quaternionfc quat)	Set this matrix to T * R, where T is the given translation and R is a rotation transformation specified by the given quaternion.
Matrix4d	Matrix4d.translationRotateInvert(Vector3fc translation, Quaternionfc quat)	Set this matrix to (T * R)-1, where T is the given translation and R is a rotation transformation specified by the given quaternion.
Matrix4f	Matrix4f.translationRotateInvert(Vector3fc translation, Quaternionfc quat)	Set this matrix to (T * R)-1, where T is the given translation and R is a rotation transformation specified by the given quaternion.
Matrix4x3f	Matrix4x3f.translationRotateInvert(Vector3fc translation, Quaternionfc quat)	Set this matrix to (T * R)-1, where T is the given translation and R is a rotation transformation specified by the given quaternion.
Matrix4d	Matrix4d.translationRotateScale(Vector3fc translation, Quaternionfc quat, double scale)	Set this matrix to T * R * S, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales all three axes by scale.
Matrix4d	Matrix4d.translationRotateScale(Vector3fc translation, Quaternionfc quat, Vector3fc scale)	Set this matrix to T * R * S, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales the axes by scale.
Matrix4f	Matrix4f.translationRotateScale(Vector3fc translation, Quaternionfc quat, float scale)	Set this matrix to T * R * S, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales all three axes by scale.
Matrix4f	Matrix4f.translationRotateScale(Vector3fc translation, Quaternionfc quat, Vector3fc scale)	Set this matrix to T * R * S, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales the axes by scale.
Matrix4x3d	Matrix4x3d.translationRotateScale(Vector3fc translation, Quaternionfc quat, Vector3fc scale)	Set this matrix to T * R * S, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales the axes by scale.
Matrix4x3f	Matrix4x3f.translationRotateScale(Vector3fc translation, Quaternionfc quat, Vector3fc scale)	Set this matrix to T * R * S, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales the axes by scale.
Matrix4d	Matrix4d.translationRotateScaleInvert(Vector3fc translation, Quaternionfc quat, double scale)	Set this matrix to (T * R * S)-1, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales all three axes by scale.
Matrix4d	Matrix4d.translationRotateScaleInvert(Vector3fc translation, Quaternionfc quat, Vector3fc scale)	Set this matrix to (T * R * S)-1, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales the axes by scale.
Matrix4f	Matrix4f.translationRotateScaleInvert(Vector3fc translation, Quaternionfc quat, float scale)	Set this matrix to (T * R * S)-1, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales all three axes by scale.
Matrix4f	Matrix4f.translationRotateScaleInvert(Vector3fc translation, Quaternionfc quat, Vector3fc scale)	Set this matrix to (T * R * S)-1, where T is the given translation, R is a rotation transformation specified by the given quaternion, and S is a scaling transformation which scales the axes by scale.
Matrix4x3f	Matrix4x3f.translationRotateScaleMul(Vector3fc translation, Quaternionfc quat, Vector3fc scale, Matrix4x3f m)	Set this matrix to T * R * S * M, where T is the given translation, R is a rotation transformation specified by the given quaternion, S is a scaling transformation which scales the axes by scale.
Matrix4d	Matrix4d.translationRotateScaleMulAffine(Vector3fc translation, Quaterniondc quat, Vector3fc scale, Matrix4d m)	Set this matrix to T * R * S * M, where T is the given translation, R is a rotation - and possibly scaling - transformation specified by the given quaternion, S is a scaling transformation which scales the axes by scale and M is an affine matrix.
Matrix4f	Matrix4f.translationRotateScaleMulAffine(Vector3fc translation, Quaternionfc quat, Vector3fc scale, Matrix4f m)	Set this matrix to T * R * S * M, where T is the given translation, R is a rotation - and possibly scaling - transformation specified by the given quaternion, S is a scaling transformation which scales the axes by scale and M is an affine matrix.
Matrix4f	Matrix4f.translationRotateTowards(Vector3fc pos, Vector3fc dir, Vector3fc up)	Set this matrix to a model transformation for a right-handed coordinate system, that translates to the given pos and aligns the local -z axis with dir.
Matrix4x3f	Matrix4x3f.translationRotateTowards(Vector3fc pos, Vector3fc dir, Vector3fc up)	Set this matrix to a model transformation for a right-handed coordinate system, that translates to the given pos and aligns the local -z axis with dir.
Vector3f	Matrix4f.unproject(Vector3fc winCoords, int[] viewport, Vector3f dest)
Vector4f	Matrix4f.unproject(Vector3fc winCoords, int[] viewport, Vector4f dest)
Vector3f	Matrix4fc.unproject(Vector3fc winCoords, int[] viewport, Vector3f dest)	Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Vector4f	Matrix4fc.unproject(Vector3fc winCoords, int[] viewport, Vector4f dest)	Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Vector3f	Matrix4f.unprojectInv(Vector3fc winCoords, int[] viewport, Vector3f dest)
Vector4f	Matrix4f.unprojectInv(Vector3fc winCoords, int[] viewport, Vector4f dest)
Vector3f	Matrix4fc.unprojectInv(Vector3fc winCoords, int[] viewport, Vector3f dest)	Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Vector4f	Matrix4fc.unprojectInv(Vector3fc winCoords, int[] viewport, Vector4f dest)	Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Matrix4f	Matrix4f.withLookAtUp(Vector3fc up)	Apply a transformation to this matrix to ensure that the local Y axis (as obtained by Matrix4f.positiveY(Vector3f)) will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4f.positiveZ(Vector3f)) and the given vector up.
Matrix4f	Matrix4f.withLookAtUp(Vector3fc up, Matrix4f dest)
Matrix4f	Matrix4fc.withLookAtUp(Vector3fc up, Matrix4f dest)	Apply a transformation to this matrix to ensure that the local Y axis (as obtained by Matrix4fc.positiveY(Vector3f)) will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4fc.positiveZ(Vector3f)) and the given vector up, and store the result in dest.
Matrix4x3f	Matrix4x3f.withLookAtUp(Vector3fc up)	Apply a transformation to this matrix to ensure that the local Y axis (as obtained by Matrix4x3f.positiveY(Vector3f)) will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4x3f.positiveZ(Vector3f)) and the given vector up.
Matrix4x3f	Matrix4x3f.withLookAtUp(Vector3fc up, Matrix4x3f dest)
Matrix4x3f	Matrix4x3fc.withLookAtUp(Vector3fc up, Matrix4x3f dest)	Apply a transformation to this matrix to ensure that the local Y axis (as obtained by Matrix4x3fc.positiveY(Vector3f)) will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4x3fc.positiveZ(Vector3f)) and the given vector up, and store the result in dest.

Constructors in org.joml with parameters of type Vector3fc

Modifier	Constructor	Description
	AxisAngle4f(float angle, Vector3fc v)	Create a new AxisAngle4f with the given values.
	Matrix3f(Vector3fc col0, Vector3fc col1, Vector3fc col2)	Create a new Matrix3f and initialize its three columns using the supplied vectors.
	Matrix4x3f(Vector3fc col0, Vector3fc col1, Vector3fc col2, Vector3fc col3)	Create a new Matrix4x3f and initialize its four columns using the supplied vectors.
	Vector3d(Vector3fc v)	Create a new Vector3d whose values will be copied from the given vector.
	Vector3f(Vector3fc v)	Create a new Vector3f with the same values as v.
	Vector3i(Vector3fc v, int mode)	Create a new Vector3i and initialize its components to the rounded value of the given vector.
	Vector4d(Vector3fc v, double w)	Create a new Vector4d with the x, y, and z components from the given v and the w component from the given w.
	Vector4f(Vector3fc v, float w)	Create a new Vector4f with the first three components from the given v and the given w.
	Vector4i(Vector3fc v, float w, int mode)	Create a new Vector4i with the first three components from the given v and the given w and round using the given RoundingMode.