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 and Description
class	Vector3d Contains the definition of a Vector comprising 3 doubles and associated transformations.

Methods in org.joml with parameters of type Vector3dc

Modifier and Type	Method and 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.
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.
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	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.
Matrix4d	Matrix4d.arcball(double radius, Vector3dc center, double angleX, double angleY, Matrix4d 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.
Matrix4x3d	Matrix4x3d.arcball(double radius, Vector3dc center, double angleX, double angleY, Matrix4x3d dest)
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.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.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) 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.
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.
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	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	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	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	Vector3d.fma(Vector3dc a, Vector3fc b, Vector3d 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.
Matrix4x3d	Matrix4x3d.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) Apply a rotation transformation to this matrix to make -z point along dir.
Quaterniond	Quaterniond.lookAlong(Vector3dc dir, Vector3dc up) Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
Matrix4d	Matrix4d.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	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.
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.
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.
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.
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.
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.
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	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.
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.
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.
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	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.
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	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.
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.
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.
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.
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.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	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.
Vector3d	Matrix4d.project(Vector3dc position, int[] viewport, Vector3d dest)
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.
Vector4d	Matrix4d.project(Vector3dc position, int[] viewport, Vector4d 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.
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	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	Matrix4d.reflect(Quaterniondc orientation, Vector3dc point, Matrix4d 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	Matrix4x3d.reflect(Quaterniondc orientation, Vector3dc point, Matrix4x3d dest)
Vector3d	Vector3d.reflect(Vector3dc normal) Reflect this vector about the given normal vector.
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.
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.
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.
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	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.
Matrix4d	Matrix4d.reflect(Vector3dc normal, Vector3dc point, Matrix4d 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.
Matrix4x3d	Matrix4x3d.reflect(Vector3dc normal, Vector3dc point, Matrix4x3d dest)
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.
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.
Matrix3d	Matrix3d.reflection(Vector3dc normal) Set this matrix to a mirror/reflection transformation that reflects through the given plane specified via the plane normal.
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.
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.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) Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
Matrix4d	Matrix4d.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	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.
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.
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.
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.
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.
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.
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.
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.
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	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.
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.
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.
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	Matrix4x3d.rotation(double angle, Vector3dc axis) Set this matrix to a rotation matrix which rotates the given radians about a given axis.
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.
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.
Quaterniond	Quaterniond.rotationTo(Vector3dc fromDir, Vector3dc toDir) Set this quaternion to a rotation that rotates the fromDir vector to point along toDir.
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.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.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) 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) 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	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.
Matrix4d	Matrix4d.scale(Vector3dc xyz, Matrix4d 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.
Matrix4x3d	Matrix4x3d.scale(Vector3dc xyz, Matrix4x3d dest)
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.
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.
AxisAngle4d	AxisAngle4d.set(double angle, Vector3dc v) Set this AxisAngle4d to the given values.
Vector3d	Vector3d.set(Vector3dc v) Set the x, y and z components to match the supplied vector.
Vector3i	Vector3i.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.
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.
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.
Quaterniond	Quaterniond.setAngleAxis(double angle, Vector3dc axis) Set this quaternion to be a representation of the supplied axis and angle (in radians).
Matrix4x3d	Matrix4x3d.setColumn(int column, Vector3dc src) Set the column at the given column index, starting with 0.
Matrix3d	Matrix3d.setColumn(int column, Vector3dc src) Set the column at the given column index, starting with 0.
Matrix4x3d	Matrix4x3d.setLookAlong(Vector3dc dir, Vector3dc up) Set this matrix to a rotation transformation to make -z point along dir.
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.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.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.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.
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.
AABBd	AABBd.setMax(Vector3dc max) Set the maximum corner coordinates.
AABBd	AABBd.setMin(Vector3dc min) Set the minimum corner coordinates.
Matrix3d	Matrix3d.setRow(int row, Vector3dc src) Set the row at the given row index, starting with 0.
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).
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).
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.
boolean	AABBd.testPoint(Vector3dc point) Test whether the given point lies inside this AABB.
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	Matrix3d.transform(Vector3dc v, Vector3d dest)
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	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	Quaterniond.transform(Vector3dc vec, Vector3d dest)
Vector3d	Matrix3x2dc.transform(Vector3dc v, Vector3d dest) Transform/multiply the given vector by this matrix and store the result in dest.
Vector3d	Quaterniondc.transform(Vector3dc vec, Vector3d dest) Transform the given vector by this quaternion and store the result in dest.
Vector3d	Matrix3dc.transform(Vector3dc v, Vector3d dest) Transform the given vector by this matrix and store the result in dest.
Vector3d	Quaternionf.transform(Vector3dc vec, Vector3d dest)
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.
Matrix4x3d	Matrix4x3d.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.
Matrix4d	Matrix4d.transformAab(Vector3dc min, Vector3dc max, Vector3d outMin, Vector3d outMax)
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	Matrix4x3d.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	Matrix4d.transformDirection(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	Matrix4x3d.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	Matrix4d.transformPosition(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	Matrix4d.transformProject(Vector3dc v, Vector3d 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.
Matrix4x3d	Matrix4x3d.translate(Vector3dc offset) Apply a translation to this matrix by translating by the given number of units in x, y and z.
Sphered	Sphered.translate(Vector3dc xyz) Translate this by the given vector xyz.
AABBd	AABBd.translate(Vector3dc xyz) Translate this by the given vector xyz.
Matrix4d	Matrix4d.translate(Vector3dc offset) Apply a translation to this matrix by translating by the given number of units in x, y and z.
AABBd	AABBd.translate(Vector3dc xyz, AABBd dest) Translate this by the given vector xyz 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.
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.
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.
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.
Sphered	Sphered.translate(Vector3dc xyz, Sphered dest) Translate this by the given vector xyz 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.
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	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.
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.
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.
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	Matrix4x3d.translation(Vector3dc offset) Set this matrix to be a simple translation matrix.
Matrix4d	Matrix4d.translation(Vector3dc offset) Set this matrix to be a simple translation matrix.
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.
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.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.
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.
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.
AABBd	AABBd.union(Vector3dc p) Set this to the union of this and the given point p.
AABBd	AABBd.union(Vector3dc p, AABBd dest) Compute the union of this and the given point p and store the result in dest.
Vector3d	Matrix4dc.unproject(Vector3dc winCoords, int[] viewport, Vector3d dest) Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Vector3d	Matrix4d.unproject(Vector3dc winCoords, int[] viewport, Vector3d dest)
Vector4d	Matrix4dc.unproject(Vector3dc winCoords, int[] viewport, Vector4d dest) Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Vector4d	Matrix4d.unproject(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.
Vector3d	Matrix4d.unprojectInv(Vector3dc winCoords, int[] viewport, Vector3d dest)
Vector4d	Matrix4dc.unprojectInv(Vector3dc winCoords, int[] viewport, Vector4d dest) Unproject the given window coordinates winCoords by this matrix using the specified viewport.
Vector4d	Matrix4d.unprojectInv(Vector3dc winCoords, int[] viewport, Vector4d dest)
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	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.
Matrix4d	Matrix4d.withLookAtUp(Vector3dc up, Matrix4d dest)

Constructors in org.joml with parameters of type Vector3dc

Constructor and Description
AABBd(Vector3dc min, Vector3dc max) Create a new AABBd with the given minimum and maximum corner coordinates.
AxisAngle4d(double angle, Vector3dc v) Create a new AxisAngle4d with the given values.
LineSegmentd(Vector3dc a, Vector3dc b) Create a new LineSegmentd between the given two points.
Matrix3d(Vector3dc col0, Vector3dc col1, Vector3dc col2) Create a new Matrix3d and initialize its three columns using the supplied vectors.
Planed(Vector3dc point, Vector3dc normal) Create a new Planed from the given point lying on the plane and the given normal.
Planed(Vector3dc pointA, Vector3dc pointB, Vector3dc pointC) Create a new Planef from the given three points lying on the plane.
Rayd(Vector3dc origin, Vector3dc direction) Create a new Rayd with the given origin and direction.
Sphered(Vector3dc c, double r) Create a new Sphered with center position c and radius r.
Vector3d(Vector3dc v) Create a new Vector3d whose values will be copied from 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.