libgdx API

Uses of Class
com.badlogic.gdx.math.Vector3

Packages that use Vector3
com.badlogic.gdx.graphics   
com.badlogic.gdx.graphics.g3d   
com.badlogic.gdx.graphics.g3d.decals   
com.badlogic.gdx.graphics.g3d.model.skeleton   
com.badlogic.gdx.graphics.glutils   
com.badlogic.gdx.math   
com.badlogic.gdx.math.collision   
 

Uses of Vector3 in com.badlogic.gdx.graphics
 

Fields in com.badlogic.gdx.graphics declared as Vector3
 Vector3 Camera.direction
          the unit length direction vector of the camera
 Vector3 Camera.position
          the position of the camera
 Vector3 Camera.up
          the unit length up vector of the camera
 

Methods in com.badlogic.gdx.graphics with parameters of type Vector3
 void Camera.project(Vector3 vec)
          Projects the Vector3 given in object/world space to window coordinates.
 void Camera.project(Vector3 vec, float viewportX, float viewportY, float viewportWidth, float viewportHeight)
          Projects the Vector3 given in object/world space to window coordinates.
 void Camera.rotate(Vector3 axis, float angle)
          Rotates the direction and up vector of this camera by the given angle around the given axis.
 void Camera.rotateAround(Vector3 point, Vector3 axis, float angle)
          Rotates the direction and up vector of this camera by the given angle around the given axis, with the axis attached to given point.
 void Camera.translate(Vector3 vec)
          Moves the camera by the given vector.
 void Camera.unproject(Vector3 vec)
          Function to translate a point given in window (or window) coordinates to world space.
 void Camera.unproject(Vector3 vec, float viewportX, float viewportY, float viewportWidth, float viewportHeight)
          Function to translate a point given in window (or window) coordinates to world space.
 

Uses of Vector3 in com.badlogic.gdx.graphics.g3d
 

Fields in com.badlogic.gdx.graphics.g3d declared as Vector3
 Vector3 StillModelNode.origin
           
 Vector3 StillModelNode.transformedPosition
           
 

Methods in com.badlogic.gdx.graphics.g3d that return Vector3
 Vector3 StillModelInstance.getSortCenter()
           
 Vector3 StillModelNode.getSortCenter()
           
 

Uses of Vector3 in com.badlogic.gdx.graphics.g3d.decals
 

Fields in com.badlogic.gdx.graphics.g3d.decals declared as Vector3
protected  Vector3 Decal.position
           
protected static Vector3 Decal.X_AXIS
           
protected static Vector3 Decal.Y_AXIS
           
protected static Vector3 Decal.Z_AXIS
           
 

Methods in com.badlogic.gdx.graphics.g3d.decals that return Vector3
 Vector3 Decal.getPosition()
          Returns the position of this decal.
 

Methods in com.badlogic.gdx.graphics.g3d.decals with parameters of type Vector3
 void Decal.lookAt(Vector3 position, Vector3 up)
          Sets the rotation of the Decal to face the given point.
 void Decal.setRotation(Vector3 dir, Vector3 up)
          Sets the rotation of this decal based on the (normalized) direction and up vector.
 

Uses of Vector3 in com.badlogic.gdx.graphics.g3d.model.skeleton
 

Fields in com.badlogic.gdx.graphics.g3d.model.skeleton declared as Vector3
 Vector3 SkeletonJoint.position
           
 Vector3 SkeletonKeyframe.position
           
 Vector3 SkeletonJoint.scale
           
 Vector3 SkeletonKeyframe.scale
           
 

Uses of Vector3 in com.badlogic.gdx.graphics.glutils
 

Methods in com.badlogic.gdx.graphics.glutils with parameters of type Vector3
 void ShaderProgram.setUniformf(int location, Vector3 values)
           
 void ShaderProgram.setUniformf(java.lang.String name, Vector3 values)
          Sets the uniform with the given name.
 void ImmediateModeRenderer10.vertex(Vector3 point)
           
 

Uses of Vector3 in com.badlogic.gdx.math
 

Fields in com.badlogic.gdx.math declared as Vector3
protected static Vector3[] Frustum.clipSpacePlanePoints
           
 Vector3 Plane.normal
           
 Vector3[] Frustum.planePoints
          eight points making up the near and far clipping "rectangles".
static Vector3 Vector3.tmp
          Static temporary vector.
static Vector3 Vector3.tmp2
          Static temporary vector.
static Vector3 Vector3.tmp3
          Static temporary vector.
static Vector3 Vector3.X
           
static Vector3 Vector3.Y
           
static Vector3 Vector3.Z
           
static Vector3 Vector3.Zero
           
 

Methods in com.badlogic.gdx.math that return Vector3
 Vector3 Vector3.add(float values)
          Adds the given value to all three components of the vector.
 Vector3 Vector3.add(float x, float y, float z)
          Adds the given vector to this component
 Vector3 Vector3.add(Vector3 vector)
          Adds the given vector to this vector
 Vector3 Vector3.cpy()
           
 Vector3 Vector3.crs(float x, float y, float z)
          Sets this vector to the cross product between it and the other vector.
 Vector3 Vector3.crs(Vector3 vector)
          Sets this vector to the cross product between it and the other vector.
 Vector3 Vector3.div(float value)
          Divides all components of this vector by the given value
 Vector3 Vector3.div(float vx, float vy, float vz)
           
 Vector3 Vector3.div(Vector3 other)
           
 Vector3 Plane.getNormal()
           
 Vector3 Vector3.lerp(Vector3 target, float alpha)
          Linearly interpolates between this vector and the target vector by alpha which is in the range [0,1].
 Vector3 Vector3.mul(float value)
          Multiplies all components of this vector by the given value
 Vector3 Vector3.mul(float vx, float vy, float vz)
          Multiplies all components of this vector by the given values
 Vector3 Vector3.mul(Matrix4 matrix)
          Multiplies the vector by the given matrix.
 Vector3 Vector3.mul(Vector3 other)
          Multiplies all components of this vector by the given vector3's values
 Vector3 Vector3.nor()
          Normalizes this vector to unit length
 Vector3 Vector3.prj(Matrix4 matrix)
          Multiplies this vector by the given matrix dividing by w.
 Vector3 Vector3.rot(Matrix4 matrix)
          Multiplies this vector by the first three columns of the matrix, essentially only applying rotation and scaling.
 Vector3 Vector3.rotate(float angle, float axisX, float axisY, float axisZ)
          Rotates this vector by the given angle around the given axis.
 Vector3 Vector3.rotate(Vector3 axis, float angle)
          Rotates this vector by the given angle around the given axis.
 Vector3 Vector3.scale(float scalarX, float scalarY, float scalarZ)
          Scales the vector components by the given scalars.
 Vector3 Vector3.set(float[] values)
          Sets the components from the array.
 Vector3 Vector3.set(float x, float y, float z)
          Sets the vector to the given components
 Vector3 Vector3.set(Vector3 vector)
          Sets the components of the given vector
 Vector3 Vector3.slerp(Vector3 target, float alpha)
          Spherically interpolates between this vector and the target vector by alpha which is in the range [0,1].
 Vector3 Vector3.sub(float value)
          Subtracts the given value from all components of this vector
 Vector3 Vector3.sub(float x, float y, float z)
          Subtracts the other vector from this vector.
 Vector3 Vector3.sub(Vector3 a_vec)
          Subtracts the given vector from this vector
 Vector3 Vector3.tmp()
          NEVER EVER SAVE THIS REFERENCE! Do not use this unless you are aware of the side-effects, e.g.
 Vector3 Vector3.tmp2()
          NEVER EVER SAVE THIS REFERENCE! Do not use this unless you are aware of the side-effects, e.g.
 

Methods in com.badlogic.gdx.math that return types with arguments of type Vector3
 java.util.List<Vector3> CatmullRomSpline.getControlPoints()
           
 java.util.List<Vector3> CatmullRomSpline.getPath(int numPoints)
          Returns a path, between every two control points numPoints are generated and the control points themselves are added too.
 java.util.List<Vector3> CatmullRomSpline.getTangentNormals(int numPoints, java.util.List<Vector3> up)
           
 java.util.List<Vector3> CatmullRomSpline.getTangentNormals(int numPoints, Vector3 up)
          Returns the tangent's normals using the tangent and provided up vector doing a cross product.
 java.util.List<Vector3> CatmullRomSpline.getTangentNormals2D(int numPoints)
          Returns all tangent's normals in 2D space for the points in a path.
 java.util.List<Vector3> CatmullRomSpline.getTangents(int numPoints)
          Returns all tangents for the points in a path.
 

Methods in com.badlogic.gdx.math with parameters of type Vector3
 void CatmullRomSpline.add(Vector3 point)
          Adds a new control point
 Vector3 Vector3.add(Vector3 vector)
          Adds the given vector to this vector
 Vector3 Vector3.crs(Vector3 vector)
          Sets this vector to the cross product between it and the other vector.
 float Plane.distance(Vector3 point)
          Calculates the shortest signed distance between the plane and the given point.
 Vector3 Vector3.div(Vector3 other)
           
 float Vector3.dot(Vector3 vector)
           
 float Vector3.dst(Vector3 vector)
           
 float Vector3.dst2(Vector3 point)
          Returns the squared distance between this point and the given point
 boolean Vector3.epsilonEquals(Vector3 obj, float epsilon)
          Compares this vector with the other vector, using the supplied epsilon for fuzzy equality testing.
 void CatmullRomSpline.getPath(Vector3[] points, int numPoints)
          Returns a path, between every two control points numPoints are generated and the control points themselves are added too.
 java.util.List<Vector3> CatmullRomSpline.getTangentNormals(int numPoints, Vector3 up)
          Returns the tangent's normals using the tangent and provided up vector doing a cross product.
 void Matrix4.getTranslation(Vector3 position)
           
 boolean Vector3.idt(Vector3 vector)
           
static float Intersector.intersectLinePlane(float x, float y, float z, float x2, float y2, float z2, Plane plane, Vector3 intersection)
          Intersects a line and a plane.
static boolean Intersector.intersectRayPlane(Ray ray, Plane plane, Vector3 intersection)
          Intersects a Ray and a Plane.
static boolean Intersector.intersectRaySphere(Ray ray, Vector3 center, float radius, Vector3 intersection)
          Intersects a Ray and a sphere, returning the intersection point in intersection.
static boolean Intersector.intersectRayTriangle(Ray ray, Vector3 t1, Vector3 t2, Vector3 t3, Vector3 intersection)
          Intersect a Ray and a triangle, returning the intersection point in intersection.
static boolean Intersector.intersectRayTriangles(Ray ray, float[] vertices, short[] indices, int vertexSize, Vector3 intersection)
          Intersects the given ray with list of triangles.
static boolean Intersector.intersectRayTriangles(Ray ray, float[] triangles, Vector3 intersection)
          Intersects the given ray with list of triangles.
static boolean Intersector.intersectRayTriangles(Ray ray, java.util.List<Vector3> triangles, Vector3 intersection)
          Intersects the given ray with list of triangles.
static boolean Intersector.intersectSegmentPlane(Vector3 start, Vector3 end, Plane plane, Vector3 intersection)
           
 boolean Plane.isFrontFacing(Vector3 direction)
          Returns whether the plane is facing the direction vector.
static boolean Intersector.isPointInTriangle(Vector3 point, Vector3 t1, Vector3 t2, Vector3 t3)
          Returns whether the given point is inside the triangle.
 Vector3 Vector3.lerp(Vector3 target, float alpha)
          Linearly interpolates between this vector and the target vector by alpha which is in the range [0,1].
 Vector3 Vector3.mul(Vector3 other)
          Multiplies all components of this vector by the given vector3's values
 boolean Frustum.pointInFrustum(Vector3 point)
          Returns whether the point is in the frustum.
 Matrix4 Matrix4.rotate(Vector3 axis, float angle)
          Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
 Vector3 Vector3.rotate(Vector3 axis, float angle)
          Rotates this vector by the given angle around the given axis.
 Matrix3 Matrix3.scl(Vector3 scale)
          Scale this matrix using the x and y components of the vector but leave the rest of the matrix alone.
 Matrix4 Matrix4.scl(Vector3 scale)
           
 Vector3 Vector3.set(Vector3 vector)
          Sets the components of the given vector
 Quaternion Quaternion.set(Vector3 axis, float angle)
          Sets the quaternion components from the given axis and angle around that axis.
 void Plane.set(Vector3 point, Vector3 normal)
          Sets the plane to the given point and normal.
 void Plane.set(Vector3 point1, Vector3 point2, Vector3 point3)
          Sets the plane normal and distance to the origin based on the three given points which are considered to be on the plane.
 Matrix4 Matrix4.set(Vector3 xAxis, Vector3 yAxis, Vector3 zAxis, Vector3 pos)
          Sets the four columns of the matrix which correspond to the x-, y- and z-axis of the vector space this matrix creates as well as the 4th column representing the translation of any point that is multiplied by this matrix.
 Quaternion Quaternion.setFromAxis(Vector3 axis, float angle)
          Sets the quaternion components from the given axis and angle around that axis.
 Quaternion Quaternion.setFromCross(Vector3 v1, Vector3 v2)
          Set this quaternion to the rotation between two vectors.
 Matrix4 Matrix4.setToLookAt(Vector3 direction, Vector3 up)
          Sets the matrix to a look at matrix with a direction and an up vector.
 Matrix4 Matrix4.setToLookAt(Vector3 position, Vector3 target, Vector3 up)
          Sets this matrix to a look at matrix with the given position, target and up vector.
 Matrix4 Matrix4.setToRotation(Vector3 axis, float angle)
          Sets the matrix to a rotation matrix around the given axis.
 Matrix4 Matrix4.setToRotation(Vector3 v1, Vector3 v2)
          Set the matrix to a rotation matrix between two vectors.
 Matrix4 Matrix4.setToScaling(Vector3 vector)
          Sets this matrix to a scaling matrix
 Matrix4 Matrix4.setToTranslation(Vector3 vector)
          Sets this matrix to a translation matrix, overwriting it first by an identity matrix and then setting the 4th column to the translation vector.
 Matrix4 Matrix4.setToTranslationAndScaling(Vector3 translation, Vector3 scaling)
          Sets this matrix to a translation and scaling matrix by first overwritting it with an identity and then setting the translation vector in the 4th column and the scaling vector in the diagonal.
 Matrix4 Matrix4.setToWorld(Vector3 position, Vector3 forward, Vector3 up)
           
 Vector3 Vector3.slerp(Vector3 target, float alpha)
          Spherically interpolates between this vector and the target vector by alpha which is in the range [0,1].
 boolean Frustum.sphereInFrustum(Vector3 center, float radius)
          Returns whether the given sphere is in the frustum.
 boolean Frustum.sphereInFrustumWithoutNearFar(Vector3 center, float radius)
          Returns whether the given sphere is in the frustum not checking whether it is behind the near and far clipping plane.
 Vector3 Vector3.sub(Vector3 a_vec)
          Subtracts the given vector from this vector
 Plane.PlaneSide Plane.testPoint(Vector3 point)
          Returns on which side the given point lies relative to the plane and its normal.
 void Quaternion.transform(Vector3 v)
          Transforms the given vector using this quaternion
 Matrix4 Matrix4.translate(Vector3 translation)
          Postmultiplies this matrix by a translation matrix.
 Matrix3 Matrix3.trn(Vector3 vector)
          Adds a translational component to the matrix in the 3rd column.
 Matrix4 Matrix4.trn(Vector3 vector)
          Adds a translational component to the matrix in the 4th column.
 

Method parameters in com.badlogic.gdx.math with type arguments of type Vector3
 java.util.List<Vector3> CatmullRomSpline.getTangentNormals(int numPoints, java.util.List<Vector3> up)
           
static boolean Intersector.intersectRayTriangles(Ray ray, java.util.List<Vector3> triangles, Vector3 intersection)
          Intersects the given ray with list of triangles.
 

Constructors in com.badlogic.gdx.math with parameters of type Vector3
Plane(Vector3 normal, float d)
          Constructs a new plane based on the normal and distance to the origin.
Plane(Vector3 normal, Vector3 point)
          Constructs a new plane based on the normal and a point on the plane.
Plane(Vector3 point1, Vector3 point2, Vector3 point3)
          Constructs a new plane out of the three given points that are considered to be on the plane.
Quaternion(Vector3 axis, float angle)
          Constructor, sets the quaternion from the given axis vector and the angle around that axis in degrees.
Vector3(Vector3 vector)
          Creates a vector from the given vector
 

Uses of Vector3 in com.badlogic.gdx.math.collision
 

Fields in com.badlogic.gdx.math.collision declared as Vector3
 Vector3 Segment.a
          the starting position
 Vector3 Segment.b
          the ending position
 Vector3 Sphere.center
          the center of the sphere
 Vector3 Ray.direction
           
 Vector3 BoundingBox.max
           
 Vector3 BoundingBox.min
           
 Vector3 Ray.origin
           
 

Methods in com.badlogic.gdx.math.collision that return Vector3
 Vector3 BoundingBox.getCenter()
           
 Vector3[] BoundingBox.getCorners()
           
 Vector3 BoundingBox.getDimensions()
           
 Vector3 Ray.getEndPoint(float distance)
          Returns and endpoint given the distance.
 Vector3 BoundingBox.getMax()
           
 Vector3 BoundingBox.getMin()
           
 

Methods in com.badlogic.gdx.math.collision with parameters of type Vector3
 boolean BoundingBox.contains(Vector3 v)
          Returns whether the given vector is contained in this bounding box.
 BoundingBox BoundingBox.ext(Vector3 point)
          Extends the bounding box to incorporate the given Vector3.
 BoundingBox BoundingBox.set(Vector3[] points)
          Sets the bounding box minimum and maximum vector from the given points.
 BoundingBox BoundingBox.set(Vector3 minimum, Vector3 maximum)
          Sets the given minimum and maximum vector.
 Ray Ray.set(Vector3 origin, Vector3 direction)
          Sets the starting position and the direction of this ray.
 

Method parameters in com.badlogic.gdx.math.collision with type arguments of type Vector3
 BoundingBox BoundingBox.set(java.util.List<Vector3> points)
          Sets the bounding box minimum and maximum vector from the given points.
 

Constructors in com.badlogic.gdx.math.collision with parameters of type Vector3
BoundingBox(Vector3 minimum, Vector3 maximum)
          Constructs the new bounding box using the given minimum and maximum vector.
Ray(Vector3 origin, Vector3 direction)
          Constructor, sets the starting position of the ray and the direction.
Segment(Vector3 a, Vector3 b)
          Constructs a new Segment from the two points given.
Sphere(Vector3 center, float radius)
          Constructs a sphere with the given center and radius
 


libgdx API

Copyright 2010 Mario Zechner (contact@badlogicgames.com), Nathan Sweet (admin@esotericsoftware.com)