Uses of Interface
org.joml.Vector3dc

Packages that use Vector3dc

Package	Description
org.joml	Contains all classes of JOML.

Uses of Vector3dc in org.joml

Classes in org.joml that implement Vector3dc

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

Methods in org.joml that return Vector3dc

Modifier and Type	Method	Description
Vector3dc	Vector3d.getToAddress(long address)
Vector3dc	Vector3dc.getToAddress(long address)	Store this vector at the given off-heap memory address.

Methods in org.joml with parameters of type Vector3dc

Modifier and Type	Method	Description
Vector3d	Vector3d.add(Vector3dc v)	Add the supplied vector to this one.
Vector3d	Vector3d.add(Vector3dc v, Vector3d dest)
Vector3d	Vector3dc.add(Vector3dc v, Vector3d dest)	Add the supplied vector to this one and store the result in dest.
double	Vector3d.angle(Vector3dc v)
double	Vector3dc.angle(Vector3dc v)	Return the angle between this vector and the supplied vector.
double	Vector3d.angleCos(Vector3dc v)
double	Vector3dc.angleCos(Vector3dc v)	Return the cosine of the angle between this vector and the supplied vector.
double	Vector3d.angleSigned(Vector3dc v, Vector3dc n)
double	Vector3dc.angleSigned(Vector3dc v, Vector3dc n)	Return the signed angle between this vector and the supplied vector with respect to the plane with the given normal vector n.
Matrix4d	Matrix4d.arcball(double radius, Vector3dc center, double angleX, double 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.
Matrix4d	Matrix4d.arcball(double radius, Vector3dc center, double angleX, double angleY, Matrix4d dest)
Matrix4d	Matrix4dc.arcball(double radius, Vector3dc center, double angleX, double angleY, Matrix4d 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.
Matrix4x3d	Matrix4x3d.arcball(double radius, Vector3dc center, double angleX, double 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.
Matrix4x3d	Matrix4x3d.arcball(double radius, Vector3dc center, double angleX, double angleY, Matrix4x3d dest)
Matrix4x3d	Matrix4x3dc.arcball(double radius, Vector3dc center, double angleX, double angleY, Matrix4x3d 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.
Matrix4d	Matrix4d.billboardCylindrical(Vector3dc objPos, Vector3dc targetPos, Vector3dc 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.
Matrix4x3d	Matrix4x3d.billboardCylindrical(Vector3dc objPos, Vector3dc targetPos, Vector3dc 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.
Matrix4d	Matrix4d.billboardSpherical(Vector3dc objPos, Vector3dc 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.
Matrix4d	Matrix4d.billboardSpherical(Vector3dc objPos, Vector3dc targetPos, Vector3dc 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.
Matrix4x3d	Matrix4x3d.billboardSpherical(Vector3dc objPos, Vector3dc 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.
Matrix4x3d	Matrix4x3d.billboardSpherical(Vector3dc objPos, Vector3dc targetPos, Vector3dc 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.
Vector3d	Vector3d.cross(Vector3dc v)	Set this vector to be the cross product of this and v2.
Vector3d	Vector3d.cross(Vector3dc v, Vector3d dest)
Vector3d	Vector3dc.cross(Vector3dc v, Vector3d dest)	Calculate the cross product of this and v2 and store the result in dest.
double	Vector3d.distance(Vector3dc v)
double	Vector3dc.distance(Vector3dc v)	Return the distance between this vector and v.
double	Vector3d.distanceSquared(Vector3dc v)
double	Vector3dc.distanceSquared(Vector3dc v)	Return the square of the distance between this vector and v.
Vector3d	Vector3d.div(Vector3dc v, Vector3d dest)
Vector3d	Vector3dc.div(Vector3dc v, Vector3d dest)	Divide this by v component-wise and store the result into dest.
double	Vector3d.dot(Vector3dc v)
double	Vector3dc.dot(Vector3dc v)	Return the dot product of this vector and the supplied vector.
boolean	Vector3d.equals(Vector3dc v, double delta)
boolean	Vector3dc.equals(Vector3dc v, double 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	Intersectiond.findClosestPointOnTriangle(Vector3dc v0, Vector3dc v1, Vector3dc v2, Vector3dc p, Vector3d 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, Vector3dc b)	Add the component-wise multiplication of a * b to this vector.
Vector3d	Vector3d.fma(double a, Vector3dc b, Vector3d dest)
Vector3d	Vector3d.fma(Vector3dc a, Vector3dc b)	Add the component-wise multiplication of a * b to this vector.
Vector3d	Vector3d.fma(Vector3dc a, Vector3dc b, Vector3d dest)
Vector3d	Vector3d.fma(Vector3dc a, Vector3fc b, Vector3d dest)
Vector3d	Vector3dc.fma(double a, Vector3dc 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, Vector3dc 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.
Quaterniond	Quaterniond.fromAxisAngleDeg(Vector3dc axis, double angle)	Set this quaternion to be a representation of the supplied axis and angle (in degrees).
Quaterniond	Quaterniond.fromAxisAngleRad(Vector3dc axis, double angle)	Set this quaternion to be a representation of the supplied axis and angle (in radians).
Vector3d	Vector3d.half(Vector3dc other)	Compute the half vector between this and the other vector.
Vector3d	Vector3d.half(Vector3dc other, Vector3d dest)
Vector3d	Vector3dc.half(Vector3dc other, Vector3d dest)	Compute the half vector between this and the other vector and store the result in dest.
Vector3d	Vector3d.hermite(Vector3dc t0, Vector3dc v1, Vector3dc t1, double t, Vector3d dest)
Vector3d	Vector3dc.hermite(Vector3dc t0, Vector3dc v1, Vector3dc t1, double t, Vector3d dest)	Compute a hermite interpolation between this vector and its associated tangent t0 and the given vector v with its tangent t1 and store the result in dest.
static int	Intersectiond.intersectLineSegmentAab(Vector3dc p0, Vector3dc p1, Vector3dc min, Vector3dc max, Vector2d 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	Intersectiond.intersectLineSegmentTriangle(Vector3dc p0, Vector3dc p1, Vector3dc v0, Vector3dc v1, Vector3dc v2, double epsilon, Vector3d 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	Intersectiond.intersectRayAab(Vector3dc origin, Vector3dc dir, Vector3dc min, Vector3dc max, Vector2d 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 double	Intersectiond.intersectRayPlane(Vector3dc origin, Vector3dc dir, Vector3dc point, Vector3dc normal, double 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	Intersectiond.intersectRaySphere(Vector3dc origin, Vector3dc dir, Vector3dc center, double radiusSquared, Vector2d 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 double	Intersectiond.intersectRayTriangle(Vector3dc origin, Vector3dc dir, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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 double	Intersectiond.intersectRayTriangleFront(Vector3dc origin, Vector3dc dir, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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.
static boolean	Intersectiond.intersectSphereSphere(Vector3dc centerA, double radiusSquaredA, Vector3dc centerB, double radiusSquaredB, Vector4d 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.
Vector3d	Vector3d.lerp(Vector3dc other, double t)	Linearly interpolate this and other using the given interpolation factor t and store the result in this.
Vector3d	Vector3d.lerp(Vector3dc other, double t, Vector3d dest)
Vector3d	Vector3dc.lerp(Vector3dc other, double t, Vector3d dest)	Linearly interpolate this and other using the given interpolation factor t and store the result in dest.
Matrix3d	Matrix3d.lookAlong(Vector3dc dir, Vector3dc up)	Apply a rotation transformation to this matrix to make -z point along dir.
Matrix3d	Matrix3d.lookAlong(Vector3dc dir, Vector3dc up, Matrix3d dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix3d	Matrix3dc.lookAlong(Vector3dc dir, Vector3dc up, Matrix3d dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix4d	Matrix4d.lookAlong(Vector3dc dir, Vector3dc up)	Apply a rotation transformation to this matrix to make -z point along dir.
Matrix4d	Matrix4d.lookAlong(Vector3dc dir, Vector3dc up, Matrix4d dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix4d	Matrix4dc.lookAlong(Vector3dc dir, Vector3dc up, Matrix4d dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix4x3d	Matrix4x3d.lookAlong(Vector3dc dir, Vector3dc up)	Apply a rotation transformation to this matrix to make -z point along dir.
Matrix4x3d	Matrix4x3d.lookAlong(Vector3dc dir, Vector3dc up, Matrix4x3d dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Matrix4x3d	Matrix4x3dc.lookAlong(Vector3dc dir, Vector3dc up, Matrix4x3d dest)	Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
Quaterniond	Quaterniond.lookAlong(Vector3dc dir, Vector3dc up)	Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
Quaterniond	Quaterniond.lookAlong(Vector3dc dir, Vector3dc up, Quaterniond dest)
Quaterniond	Quaterniondc.lookAlong(Vector3dc dir, Vector3dc up, Quaterniond dest)	Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in dest.
Matrix4d	Matrix4d.lookAt(Vector3dc eye, Vector3dc center, Vector3dc up)	Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye.
Matrix4d	Matrix4d.lookAt(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4d 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.
Matrix4d	Matrix4dc.lookAt(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4d 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.
Matrix4x3d	Matrix4x3d.lookAt(Vector3dc eye, Vector3dc center, Vector3dc up)	Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns -z with center - eye.
Matrix4x3d	Matrix4x3d.lookAt(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4x3d 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.
Matrix4x3d	Matrix4x3dc.lookAt(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4x3d 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.
Matrix4d	Matrix4d.lookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up)	Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye.
Matrix4d	Matrix4d.lookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4d 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.
Matrix4d	Matrix4dc.lookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4d 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.
Matrix4x3d	Matrix4x3d.lookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up)	Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns +z with center - eye.
Matrix4x3d	Matrix4x3d.lookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4x3d 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.
Matrix4x3d	Matrix4x3dc.lookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up, Matrix4x3d 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.
Vector3d	Vector3d.max(Vector3dc v)	Set the components of this vector to be the component-wise maximum of this and the other vector.
Vector3d	Vector3d.max(Vector3dc v, Vector3d dest)
Vector3d	Vector3dc.max(Vector3dc v, Vector3d dest)	Set the components of dest to be the component-wise maximum of this and the other vector.
Vector3d	Vector3d.min(Vector3dc v)	Set the components of this vector to be the component-wise minimum of this and the other vector.
Vector3d	Vector3d.min(Vector3dc v, Vector3d dest)
Vector3d	Vector3dc.min(Vector3dc v, Vector3d dest)	Set the components of dest to be the component-wise minimum of this and the other vector.
Vector3d	Vector3d.mul(Vector3dc v)	Multiply this Vector3d component-wise by another Vector3dc.
Vector3d	Vector3d.mul(Vector3dc v, Vector3d dest)
Vector3d	Vector3dc.mul(Vector3dc v, Vector3d dest)	Multiply this by v component-wise and store the result into dest.
Vector3d	Vector3d.mulAdd(double a, Vector3dc b)	Add the component-wise multiplication of this * a to b and store the result in this.
Vector3d	Vector3d.mulAdd(double a, Vector3dc b, Vector3d dest)
Vector3d	Vector3d.mulAdd(Vector3dc a, Vector3dc b)	Add the component-wise multiplication of this * a to b and store the result in this.
Vector3d	Vector3d.mulAdd(Vector3dc a, Vector3dc b, Vector3d dest)
Vector3d	Vector3d.mulAdd(Vector3fc a, Vector3dc b, Vector3d dest)
Vector3d	Vector3dc.mulAdd(double a, Vector3dc b, Vector3d dest)	Add the component-wise multiplication of this * a to b and store the result in dest.
Vector3d	Vector3dc.mulAdd(Vector3dc a, Vector3dc b, Vector3d dest)	Add the component-wise multiplication of this * a to b and store the result in 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.
Vector3d	Vector3d.orthogonalize(Vector3dc v)	Transform this vector so that it is orthogonal to the given vector v and normalize the result.
Vector3d	Vector3d.orthogonalize(Vector3dc v, Vector3d dest)
Vector3d	Vector3dc.orthogonalize(Vector3dc v, Vector3d dest)	Transform this vector so that it is orthogonal to the given vector v, normalize the result and store it into dest.
Vector3d	Vector3d.orthogonalizeUnit(Vector3dc v)	Transform this vector so that it is orthogonal to the given unit vector v and normalize the result.
Vector3d	Vector3d.orthogonalizeUnit(Vector3dc v, Vector3d dest)
Vector3d	Vector3dc.orthogonalizeUnit(Vector3dc v, Vector3d dest)	Transform this vector so that it is orthogonal to the given unit vector v, normalize the result and store it into dest.
Vector3d	Matrix4d.project(Vector3dc position, int[] viewport, Vector3d dest)
Vector4d	Matrix4d.project(Vector3dc position, int[] viewport, Vector4d dest)
Vector3d	Matrix4dc.project(Vector3dc position, int[] viewport, Vector3d winCoordsDest)	Project the given position via this matrix using the specified viewport and store the resulting window coordinates in winCoordsDest.
Vector4d	Matrix4dc.project(Vector3dc position, int[] viewport, Vector4d winCoordsDest)	Project the given position via this matrix using the specified viewport and store the resulting window coordinates in winCoordsDest.
double	Matrix3d.quadraticFormProduct(Vector3dc v)
double	Matrix3dc.quadraticFormProduct(Vector3dc v)	Compute v^T * this * v.
Matrix3d	Matrix3d.reflect(Vector3dc normal)	Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal.
Matrix3d	Matrix3d.reflect(Vector3dc normal, Matrix3d dest)
Matrix3d	Matrix3dc.reflect(Vector3dc normal, Matrix3d 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.
Matrix4d	Matrix4d.reflect(Quaterniondc orientation, Vector3dc 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.
Matrix4d	Matrix4d.reflect(Quaterniondc orientation, Vector3dc point, Matrix4d dest)
Matrix4d	Matrix4d.reflect(Vector3dc normal, Vector3dc 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.
Matrix4d	Matrix4d.reflect(Vector3dc normal, Vector3dc point, Matrix4d dest)
Matrix4d	Matrix4dc.reflect(Quaterniondc orientation, Vector3dc point, Matrix4d 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.
Matrix4d	Matrix4dc.reflect(Vector3dc normal, Vector3dc point, Matrix4d 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.
Matrix4x3d	Matrix4x3d.reflect(Quaterniondc orientation, Vector3dc 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.
Matrix4x3d	Matrix4x3d.reflect(Quaterniondc orientation, Vector3dc point, Matrix4x3d dest)
Matrix4x3d	Matrix4x3d.reflect(Vector3dc normal, Vector3dc 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.
Matrix4x3d	Matrix4x3d.reflect(Vector3dc normal, Vector3dc point, Matrix4x3d dest)
Matrix4x3d	Matrix4x3dc.reflect(Quaterniondc orientation, Vector3dc point, Matrix4x3d 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.
Matrix4x3d	Matrix4x3dc.reflect(Vector3dc normal, Vector3dc point, Matrix4x3d 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.
Vector3d	Vector3d.reflect(Vector3dc normal)	Reflect this vector about the given normal vector.
Vector3d	Vector3d.reflect(Vector3dc normal, Vector3d dest)
Vector3d	Vector3dc.reflect(Vector3dc normal, Vector3d dest)	Reflect this vector about the given normal vector and store the result in dest.
Matrix3d	Matrix3d.reflection(Vector3dc normal)	Set this matrix to a mirror/reflection transformation that reflects through the given plane specified via the plane normal.
Matrix4d	Matrix4d.reflection(Quaterniondc orientation, Vector3dc 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.
Matrix4d	Matrix4d.reflection(Vector3dc normal, Vector3dc 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.
Matrix4x3d	Matrix4x3d.reflection(Quaterniondc orientation, Vector3dc 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.
Matrix4x3d	Matrix4x3d.reflection(Vector3dc normal, Vector3dc 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, Vector3dc axis)	Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix3d	Matrix3d.rotate(double angle, Vector3dc 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, Vector3dc axis, Matrix3d dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4d	Matrix4d.rotate(double angle, Vector3dc axis)	Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix4d	Matrix4d.rotate(double angle, Vector3dc 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, Vector3dc axis, Matrix4d dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Matrix4x3d	Matrix4x3d.rotate(double angle, Vector3dc axis)	Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix4x3d	Matrix4x3d.rotate(double angle, Vector3dc 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, Vector3dc axis, Matrix4x3d dest)	Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
Quaterniond	Quaterniond.rotateAxis(double angle, Vector3dc axis)	Apply a rotation to this quaternion rotating the given radians about the specified axis.
Quaterniond	Quaterniond.rotateAxis(double angle, Vector3dc axis, Quaterniond dest)
Quaterniond	Quaterniondc.rotateAxis(double angle, Vector3dc axis, Quaterniond dest)	Apply a rotation to this quaternion rotating the given radians about the specified axis and store the result in dest.
Quaterniond	Quaterniond.rotateTo(Vector3dc fromDir, Vector3dc toDir)	Apply a rotation to this that rotates the fromDir vector to point along toDir.
Quaterniond	Quaterniond.rotateTo(Vector3dc fromDir, Vector3dc toDir, Quaterniond dest)
Quaterniond	Quaterniondc.rotateTo(Vector3dc fromDir, Vector3dc toDir, Quaterniond dest)	Apply a rotation to this that rotates the fromDir vector to point along toDir and store the result in dest.
Matrix3d	Matrix3d.rotateTowards(Vector3dc direction, Vector3dc up)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction.
Matrix3d	Matrix3d.rotateTowards(Vector3dc direction, Vector3dc up, Matrix3d 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.
Matrix3d	Matrix3dc.rotateTowards(Vector3dc direction, Vector3dc up, Matrix3d 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.
Matrix4d	Matrix4d.rotateTowards(Vector3dc direction, Vector3dc up)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction.
Matrix4d	Matrix4d.rotateTowards(Vector3dc direction, Vector3dc up, Matrix4d 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.
Matrix4d	Matrix4dc.rotateTowards(Vector3dc direction, Vector3dc up, Matrix4d 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.
Matrix4x3d	Matrix4x3d.rotateTowards(Vector3dc dir, Vector3dc up)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir.
Matrix4x3d	Matrix4x3d.rotateTowards(Vector3dc dir, Vector3dc up, Matrix4x3d 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.
Matrix4x3d	Matrix4x3dc.rotateTowards(Vector3dc dir, Vector3dc up, Matrix4x3d dest)	Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the -z axis with dir and store the result in dest.
Matrix3d	Matrix3d.rotation(double angle, Vector3dc axis)	Set this matrix to a rotation matrix which rotates the given radians about a given axis.
Matrix4d	Matrix4d.rotation(double angle, Vector3dc axis)	Set this matrix to a rotation matrix which rotates the given radians about a given axis.
Matrix4x3d	Matrix4x3d.rotation(double angle, Vector3dc axis)	Set this matrix to a rotation matrix which rotates the given radians about a given axis.
Quaterniond	Quaterniond.rotationTo(Vector3dc fromDir, Vector3dc toDir)	Set this quaternion to a rotation that rotates the fromDir vector to point along toDir.
Quaterniond	Vector3d.rotationTo(Vector3dc toDir, Quaterniond dest)
Quaterniond	Vector3dc.rotationTo(Vector3dc toDir, Quaterniond dest)	Compute the quaternion representing a rotation of this vector to point along toDir and store the result in dest.
Matrix3d	Matrix3d.rotationTowards(Vector3dc dir, Vector3dc up)	Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local -z axis with center - eye.
Matrix4d	Matrix4d.rotationTowards(Vector3dc dir, Vector3dc up)	Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local -z axis with dir.
Matrix4x3d	Matrix4x3d.rotationTowards(Vector3dc dir, Vector3dc up)	Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local -z axis with dir.
Matrix3d	Matrix3d.scale(Vector3dc xyz)	Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively.
Matrix3d	Matrix3d.scale(Vector3dc xyz, Matrix3d dest)
Matrix3d	Matrix3dc.scale(Vector3dc xyz, Matrix3d 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.
Matrix4d	Matrix4d.scale(Vector3dc xyz)	Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively.
Matrix4d	Matrix4d.scale(Vector3dc xyz, Matrix4d dest)
Matrix4d	Matrix4dc.scale(Vector3dc xyz, Matrix4d 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.
Matrix4x3d	Matrix4x3d.scale(Vector3dc xyz)	Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively.
Matrix4x3d	Matrix4x3d.scale(Vector3dc xyz, Matrix4x3d dest)
Matrix4x3d	Matrix4x3dc.scale(Vector3dc xyz, Matrix4x3d 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.
Matrix3d	Matrix3d.scaling(Vector3dc xyz)	Set this matrix to be a simple scale matrix which scales the base axes by xyz.x, xyz.y and xyz.z respectively.
Matrix4d	Matrix4d.scaling(Vector3dc xyz)	Set this matrix to be a simple scale matrix which scales the base axes by xyz.x, xyz.y and xyz.z, respectively.
Matrix4x3d	Matrix4x3d.scaling(Vector3dc xyz)	Set this matrix to be a simple scale matrix which scales the base axes by xyz.x, xyz.y and xyz.z, respectively.
AxisAngle4d	AxisAngle4d.set(double angle, Vector3dc v)	Set this AxisAngle4d to the given values.
Matrix3d	Matrix3d.set(Vector3dc col0, Vector3dc col1, Vector3dc col2)	Set the three columns of this matrix to the supplied vectors, respectively.
Matrix4x3d	Matrix4x3d.set(Vector3dc col0, Vector3dc col1, Vector3dc col2, Vector3dc col3)	Set the four columns of this matrix to the supplied vectors, respectively.
Vector3d	Vector3d.set(Vector3dc v)	Set the x, y and z components to match the supplied vector.
Vector3f	Vector3f.set(Vector3dc v)	Set the x, y and z components to match the supplied vector.
Vector3i	Vector3i.set(Vector3dc v)	Set this Vector3i to the values of v using RoundingMode.TRUNCATE rounding.
Vector3i	Vector3i.set(Vector3dc v, int mode)	Set this Vector3i to the values of v using the given RoundingMode.
Vector4d	Vector4d.set(Vector3dc v, double w)	Set the x, y, and z components of this to the components of v and the w component to w.
Quaterniond	Quaterniond.setAngleAxis(double angle, Vector3dc axis)	Set this quaternion to be a representation of the supplied axis and angle (in radians).
Matrix3d	Matrix3d.setColumn(int column, Vector3dc src)	Set the column at the given column index, starting with 0.
Matrix4x3d	Matrix4x3d.setColumn(int column, Vector3dc src)	Set the column at the given column index, starting with 0.
Matrix3d	Matrix3d.setLookAlong(Vector3dc dir, Vector3dc up)	Set this matrix to a rotation transformation to make -z point along dir.
Matrix4d	Matrix4d.setLookAlong(Vector3dc dir, Vector3dc up)	Set this matrix to a rotation transformation to make -z point along dir.
Matrix4x3d	Matrix4x3d.setLookAlong(Vector3dc dir, Vector3dc up)	Set this matrix to a rotation transformation to make -z point along dir.
Matrix4d	Matrix4d.setLookAt(Vector3dc eye, Vector3dc center, Vector3dc up)	Set this matrix to be a "lookat" transformation for a right-handed coordinate system, that aligns -z with center - eye.
Matrix4x3d	Matrix4x3d.setLookAt(Vector3dc eye, Vector3dc center, Vector3dc up)	Set this matrix to be a "lookat" transformation for a right-handed coordinate system, that aligns -z with center - eye.
Matrix4d	Matrix4d.setLookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up)	Set this matrix to be a "lookat" transformation for a left-handed coordinate system, that aligns +z with center - eye.
Matrix4x3d	Matrix4x3d.setLookAtLH(Vector3dc eye, Vector3dc center, Vector3dc up)	Set this matrix to be a "lookat" transformation for a left-handed coordinate system, that aligns +z with center - eye.
Matrix3d	Matrix3d.setRow(int row, Vector3dc src)	Set the row at the given row index, starting with 0.
Matrix4d	Matrix4d.setTranslation(Vector3dc xyz)	Set only the translation components (m30, m31, m32) of this matrix to the given values (xyz.x, xyz.y, xyz.z).
Matrix4x3d	Matrix4x3d.setTranslation(Vector3dc xyz)	Set only the translation components (m30, m31, m32) of this matrix to the given values (xyz.x, xyz.y, xyz.z).
Vector3d	Vector3d.smoothStep(Vector3dc v, double t, Vector3d dest)
Vector3d	Vector3dc.smoothStep(Vector3dc v, double t, Vector3d dest)	Compute a smooth-step (i.e.
Vector3d	Vector3d.sub(Vector3dc v)	Subtract the supplied vector from this one.
Vector3d	Vector3d.sub(Vector3dc v, Vector3d dest)
Vector3d	Vector3dc.sub(Vector3dc v, Vector3d dest)	Subtract the supplied vector from this one and store the result in dest.
static boolean	Intersectiond.testAabAab(Vector3dc minA, Vector3dc maxA, Vector3dc minB, Vector3dc 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	Intersectiond.testAabPlane(Vector3dc min, Vector3dc max, double a, double b, double c, double 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	Intersectiond.testAabSphere(Vector3dc min, Vector3dc max, Vector3dc center, double 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.
static boolean	Intersectiond.testLineSegmentSphere(Vector3dc p0, Vector3dc p1, Vector3dc center, double 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	Intersectiond.testLineSegmentTriangle(Vector3dc p0, Vector3dc p1, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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.
static boolean	Intersectiond.testRayAab(Vector3dc origin, Vector3dc dir, Vector3dc min, Vector3dc 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	Intersectiond.testRaySphere(Vector3dc origin, Vector3dc dir, Vector3dc center, double 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	Intersectiond.testRayTriangle(Vector3dc origin, Vector3dc dir, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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	Intersectiond.testRayTriangleFront(Vector3dc origin, Vector3dc dir, Vector3dc v0, Vector3dc v1, Vector3dc v2, double 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	Intersectiond.testSphereSphere(Vector3dc centerA, double radiusSquaredA, Vector3dc centerB, double radiusSquaredB)	Test whether the one sphere with center centerA and square radius radiusSquaredA intersects the other sphere with center centerB and square radius radiusSquaredB.
Vector3d	AxisAngle4d.transform(Vector3dc v, Vector3d dest)	Transform the given vector by the rotation transformation described by this AxisAngle4d and store the result in dest.
Vector3d	Matrix3d.transform(Vector3dc v, Vector3d dest)
Vector3d	Matrix3dc.transform(Vector3dc v, Vector3d dest)	Transform the given vector by this matrix and store the result in dest.
Vector3d	Matrix3x2d.transform(Vector3dc v, Vector3d dest)	Transform/multiply the given vector by this matrix by assuming a third row in this matrix of (0, 0, 1) and store the result in dest.
Vector3d	Matrix3x2dc.transform(Vector3dc v, Vector3d dest)	Transform/multiply the given vector by this matrix and store the result in dest.
Vector3d	Quaterniond.transform(Vector3dc vec, Vector3d dest)
Vector3d	Quaterniondc.transform(Vector3dc vec, Vector3d dest)	Transform the given vector by this quaternion and store the result in dest.
Vector3d	Quaternionf.transform(Vector3dc vec, Vector3d dest)
Vector3d	Quaternionfc.transform(Vector3dc vec, Vector3d dest)	Transform the given vector by this quaternion and store the result in dest.
Matrix4d	Matrix4d.transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d outMax)
Matrix4d	Matrix4dc.transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d 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.
Matrix4x3d	Matrix4x3d.transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d outMax)
Matrix4x3d	Matrix4x3dc.transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d 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.
Vector3d	Matrix4d.transformDirection(Vector3dc v, Vector3d dest)
Vector3d	Matrix4dc.transformDirection(Vector3dc v, Vector3d 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.
Vector3d	Matrix4x3d.transformDirection(Vector3dc v, Vector3d dest)
Vector3d	Matrix4x3dc.transformDirection(Vector3dc v, Vector3d 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.
Vector3d	Quaterniond.transformInverse(Vector3dc vec, Vector3d dest)
Vector3d	Quaterniondc.transformInverse(Vector3dc vec, Vector3d dest)	Transform the given vector by the inverse of this quaternion and store the result in dest.
Vector3d	Quaternionf.transformInverse(Vector3dc vec, Vector3d dest)
Vector3d	Quaternionfc.transformInverse(Vector3dc vec, Vector3d dest)	Transform the given vector by the inverse of this quaternion and store the result in dest.
Vector3d	Quaterniond.transformInverseUnit(Vector3dc vec, Vector3d dest)
Vector3d	Quaterniondc.transformInverseUnit(Vector3dc vec, Vector3d dest)	Transform the given vector by the inverse of this unit quaternion and store the result in dest.
Vector3d	Quaternionf.transformInverseUnit(Vector3dc vec, Vector3d dest)
Vector3d	Quaternionfc.transformInverseUnit(Vector3dc vec, Vector3d dest)	Transform the given vector by the inverse of this unit quaternion and store the result in dest.
Vector3d	Matrix4d.transformPosition(Vector3dc v, Vector3d dest)
Vector3d	Matrix4dc.transformPosition(Vector3dc v, Vector3d 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.
Vector3d	Matrix4x3d.transformPosition(Vector3dc v, Vector3d dest)
Vector3d	Matrix4x3dc.transformPosition(Vector3dc v, Vector3d 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.
Vector3d	Matrix4d.transformProject(Vector3dc v, Vector3d dest)
Vector3d	Matrix4dc.transformProject(Vector3dc v, Vector3d dest)	Transform/multiply the given vector by this matrix, perform perspective divide and store the result in dest.
Vector3d	Matrix3d.transformTranspose(Vector3dc v, Vector3d dest)
Vector3d	Matrix3dc.transformTranspose(Vector3dc v, Vector3d dest)	Transform the given vector by the transpose of this matrix and store the result in dest.
Vector3d	Quaterniond.transformUnit(Vector3dc vec, Vector3d dest)
Vector3d	Quaterniondc.transformUnit(Vector3dc vec, Vector3d dest)	Transform the given vector by this unit quaternion and store the result in dest.
Vector3d	Quaternionf.transformUnit(Vector3dc vec, Vector3d dest)
Vector3d	Quaternionfc.transformUnit(Vector3dc vec, Vector3d dest)	Transform the given vector by this unit quaternion and store the result in dest.
Matrix4d	Matrix4d.translate(Vector3dc offset)	Apply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4d	Matrix4d.translate(Vector3dc 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(Vector3dc 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.
Matrix4x3d	Matrix4x3d.translate(Vector3dc offset)	Apply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4x3d	Matrix4x3d.translate(Vector3dc 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(Vector3dc 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.
Matrix4d	Matrix4d.translateLocal(Vector3dc offset)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4d	Matrix4d.translateLocal(Vector3dc 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(Vector3dc 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.
Matrix4x3d	Matrix4x3d.translateLocal(Vector3dc offset)	Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z.
Matrix4x3d	Matrix4x3d.translateLocal(Vector3dc 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(Vector3dc 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.
Matrix4d	Matrix4d.translation(Vector3dc offset)	Set this matrix to be a simple translation matrix.
Matrix4x3d	Matrix4x3d.translation(Vector3dc offset)	Set this matrix to be a simple translation matrix.
Matrix4d	Matrix4d.translationRotate(Vector3dc translation, Quaterniondc quat)	Set this matrix to T * R, where T is the given translation and R is a rotation transformation specified by the given quaternion.
Matrix4x3d	Matrix4x3d.translationRotate(Vector3dc translation, Quaterniondc quat)	Set this matrix to T * R, where T is the given translation and R is a rotation transformation specified by the given quaternion.
Matrix4x3d	Matrix4x3d.translationRotateInvert(Vector3dc translation, Quaterniondc 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(Vector3dc translation, Quaterniondc 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(Vector3dc translation, Quaterniondc quat, Vector3dc 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(Vector3dc translation, Quaterniondc quat, Vector3dc 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(Vector3dc translation, Quaterniondc 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(Vector3dc translation, Quaterniondc quat, Vector3dc 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.
Matrix4x3d	Matrix4x3d.translationRotateScaleMul(Vector3dc translation, Quaterniondc quat, Vector3dc scale, Matrix4x3dc 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.translationRotateTowards(Vector3dc pos, Vector3dc dir, Vector3dc 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.
Matrix4x3d	Matrix4x3d.translationRotateTowards(Vector3dc pos, Vector3dc dir, Vector3dc 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.
Vector3d	Matrix4d.unproject(Vector3dc winCoords, int[] viewport, Vector3d dest)
Vector4d	Matrix4d.unproject(Vector3dc winCoords, int[] viewport, Vector4d dest)
Vector3d	Matrix4dc.unproject(Vector3dc winCoords, int[] viewport, Vector3d dest)	Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Vector4d	Matrix4dc.unproject(Vector3dc winCoords, int[] viewport, Vector4d dest)	Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Vector3d	Matrix4d.unprojectInv(Vector3dc winCoords, int[] viewport, Vector3d dest)
Vector4d	Matrix4d.unprojectInv(Vector3dc winCoords, int[] viewport, Vector4d dest)
Vector3d	Matrix4dc.unprojectInv(Vector3dc winCoords, int[] viewport, Vector3d dest)	Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Vector4d	Matrix4dc.unprojectInv(Vector3dc winCoords, int[] viewport, Vector4d dest)	Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Matrix4d	Matrix4d.withLookAtUp(Vector3dc up)	Apply a transformation to this matrix to ensure that the local Y axis (as obtained by Matrix4d.positiveY(Vector3d)) will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4d.positiveZ(Vector3d)) and the given vector up.
Matrix4d	Matrix4d.withLookAtUp(Vector3dc up, Matrix4d dest)
Matrix4d	Matrix4dc.withLookAtUp(Vector3dc up, Matrix4d dest)	Apply a transformation to this matrix to ensure that the local Y axis (as obtained by Matrix4dc.positiveY(Vector3d)) will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4dc.positiveZ(Vector3d)) and the given vector up, and store the result in dest.

Constructors in org.joml with parameters of type Vector3dc

Modifier	Constructor	Description
	AxisAngle4d(double angle, Vector3dc v)	Create a new AxisAngle4d with the given values.
	Matrix3d(Vector3dc col0, Vector3dc col1, Vector3dc col2)	Create a new Matrix3d and initialize its three columns using the supplied vectors.
	Vector3d(Vector3dc v)	Create a new Vector3d whose values will be copied from the given vector.
	Vector3i(Vector3dc v, int mode)	Create a new Vector3i and initialize its components to the rounded value of the given vector.
	Vector4d(Vector3dc v, double w)	Create a new Vector4d with the first three components from the given v and the given w.