Uses of Class
com.jme.math.Vector3f

Packages that use Vector3f
com.jme.animation   
com.jme.bounding   
com.jme.curve   
com.jme.image   
com.jme.input   
com.jme.input.action   
com.jme.input.controls.controller.camera   
com.jme.input.thirdperson   
com.jme.intersection   
com.jme.light   
com.jme.math   
com.jme.math.spring   
com.jme.renderer   
com.jme.renderer.jogl   
com.jme.renderer.lwjgl   
com.jme.renderer.pass   
com.jme.scene   
com.jme.scene.geometryinstancing   
com.jme.scene.geometryinstancing.instance   
com.jme.scene.shadow   
com.jme.scene.shape Standard geometric shapes. 
com.jme.scene.state   
com.jme.scene.state.jogl.records   
com.jme.scene.state.lwjgl.records   
com.jme.system   
com.jme.system.dummy   
com.jme.util   
com.jme.util.geom   
com.jme.util.stat.graph   
com.jmex.audio   
com.jmex.editors.swing.widget   
com.jmex.effects   
com.jmex.effects.cloth   
com.jmex.effects.particles   
com.jmex.effects.water   
com.jmex.font3d   
com.jmex.font3d.effects   
com.jmex.font3d.math   
com.jmex.model   
com.jmex.model.animation   
com.jmex.model.converters   
com.jmex.model.converters.maxutils   
com.jmex.model.ogrexml.anim   
com.jmex.terrain   
com.jmex.terrain.util   
 

Uses of Vector3f in com.jme.animation
 

Fields in com.jme.animation declared as Vector3f
 Vector3f BoneInfluence.nOffset
           
protected static Vector3f SkinNode.normal
           
protected  Vector3f Bone.oldScale
           
protected  Vector3f Bone.oldTran
           
protected static Vector3f SkinNode.vertex
           
 Vector3f BoneInfluence.vOffset
           
protected  Vector3f Bone.workVectA
           
 

Methods in com.jme.animation that return Vector3f
 Vector3f TextureAnimationController.getTextureRotationAxis()
           
 Vector3f TextureAnimationController.getTranslationDelta()
           
 Vector3f[] BoneTransform.getTranslations()
           
 

Methods in com.jme.animation with parameters of type Vector3f
 void Bone.applyBone(BoneInfluence inf, Vector3f vstore, Vector3f nstore)
          applyBone affects a given vertex by its current world position.
 void Bone.setLocalScale(Vector3f localScale)
           
 void Bone.setLocalTranslation(Vector3f localTranslation)
           
 void SpatialTransformer.setPosition(int indexInST, float time, Vector3f position)
          Sets object with index indexInST to translate by position at time time.
 void SpatialTransformer.setScale(int indexInST, float time, Vector3f scale)
          Sets object with index indexInST to scale by scale at time time.
(package private)  void SpatialTransformer.PointInTime.setScale(int objIndex, Vector3f scale)
          Sets the scale for objIndex and sets usedScale to true for that index
 void TextureAnimationController.setTextureRotationAxis(Vector3f textureRotationAxis)
           
 void BoneTransform.setTranslation(int index, Vector3f translation)
          setTranslation sets a translation for a given frame.
(package private)  void SpatialTransformer.PointInTime.setTranslation(int objIndex, Vector3f trans)
          Sets the translation for objIndex and sets usedTrans to true for that index
 void TextureAnimationController.setTranslationDelta(Vector3f translationDelta)
           
 void BoneTransform.setTranslations(Vector3f[] translations)
          sets the translations array for the keyframes.
 

Uses of Vector3f in com.jme.bounding
 

Fields in com.jme.bounding declared as Vector3f
protected static Vector3f BoundingVolume._compVect1
           
protected static Vector3f BoundingVolume._compVect2
           
protected static Vector3f BoundingVolume._compVect3
           
protected  Vector3f BoundingVolume.center
           
 Vector3f LineBoundingBox.extent
          Extents of the box along the x,y,z axis.
 Vector3f OrientedBoundingBox.extent
          Extents of the box along the x,y,z axis.
 Vector3f OrthogonalBoundingBox.extent
          Extents of the box along the x,y,z axis.
 Vector3f[] LineBoundingBox.vectorStore
          Vector array used to store the array of 8 corners the box has.
 Vector3f[] OrientedBoundingBox.vectorStore
          Vector array used to store the array of 8 corners the box has.
 Vector3f[] OrthogonalBoundingBox.vectorStore
          Vector array used to store the array of 8 corners the box has.
 Vector3f LineBoundingBox.xAxis
          X axis of the Oriented Box.
 Vector3f OrientedBoundingBox.xAxis
          X axis of the Oriented Box.
 Vector3f OrthogonalBoundingBox.xAxis
          X axis of the Oriented Box.
 Vector3f LineBoundingBox.yAxis
          Y axis of the Oriented Box.
 Vector3f OrientedBoundingBox.yAxis
          Y axis of the Oriented Box.
 Vector3f OrthogonalBoundingBox.yAxis
          Y axis of the Oriented Box.
 Vector3f LineBoundingBox.zAxis
          Z axis of the Oriented Box.
 Vector3f OrientedBoundingBox.zAxis
          Z axis of the Oriented Box.
 Vector3f OrthogonalBoundingBox.zAxis
          Z axis of the Oriented Box.
 

Methods in com.jme.bounding that return Vector3f
 Vector3f BoundingVolume.getCenter()
           
 Vector3f BoundingVolume.getCenter(Vector3f store)
           
 Vector3f LineBoundingBox.getExtent()
           
 Vector3f OrientedBoundingBox.getExtent()
           
 Vector3f OrthogonalBoundingBox.getExtent()
           
 Vector3f BoundingBox.getExtent(Vector3f store)
          Query extent.
 Vector3f LineBoundingBox.getXAxis()
           
 Vector3f OrientedBoundingBox.getXAxis()
           
 Vector3f OrthogonalBoundingBox.getXAxis()
           
 Vector3f LineBoundingBox.getYAxis()
           
 Vector3f OrientedBoundingBox.getYAxis()
           
 Vector3f OrthogonalBoundingBox.getYAxis()
           
 Vector3f LineBoundingBox.getZAxis()
           
 Vector3f OrientedBoundingBox.getZAxis()
           
 Vector3f OrthogonalBoundingBox.getZAxis()
           
 

Methods in com.jme.bounding with parameters of type Vector3f
 void BoundingSphere.averagePoints(Vector3f[] points)
          averagePoints selects the sphere center to be the average of the points and the sphere radius to be the smallest value to enclose all points.
 boolean BoundingCapsule.contains(float sphereRadius, Vector3f sphereCenter)
           
 boolean BoundingCapsule.contains(float radius, Vector3f start, Vector3f end)
           
 boolean BoundingBox.contains(Vector3f point)
           
 boolean BoundingCapsule.contains(Vector3f point)
           
 boolean BoundingSphere.contains(Vector3f point)
           
abstract  boolean BoundingVolume.contains(Vector3f point)
          determines if a given point is contained within this bounding volume.
 boolean LineBoundingBox.contains(Vector3f point)
           
 boolean OrientedBoundingBox.contains(Vector3f point)
           
 boolean OrthogonalBoundingBox.contains(Vector3f point)
           
 float BoundingVolume.distanceSquaredTo(Vector3f point)
          Find the squared distance from the center of this Bounding Volume to the given point.
 float BoundingVolume.distanceTo(Vector3f point)
          Find the distance from the center of this Bounding Volume to the given point.
 float BoundingBox.distanceToEdge(Vector3f point)
           
 float BoundingCapsule.distanceToEdge(Vector3f point)
           
 float BoundingSphere.distanceToEdge(Vector3f point)
           
abstract  float BoundingVolume.distanceToEdge(Vector3f point)
          Find the distance from the nearest edge of this Bounding Volume to the given point.
 float LineBoundingBox.distanceToEdge(Vector3f point)
           
 float OrientedBoundingBox.distanceToEdge(Vector3f point)
           
 float OrthogonalBoundingBox.distanceToEdge(Vector3f point)
           
 Vector3f BoundingVolume.getCenter(Vector3f store)
           
 Vector3f BoundingBox.getExtent(Vector3f store)
          Query extent.
 void BoundingVolume.setCenter(Vector3f newCenter)
           
 void TreeComparator.setCenter(Vector3f center)
           
 void LineBoundingBox.setExtent(Vector3f ext)
           
 void OrientedBoundingBox.setExtent(Vector3f ext)
           
 void OrthogonalBoundingBox.setExtent(Vector3f ext)
           
 void LineBoundingBox.setXAxis(Vector3f axis)
           
 void OrientedBoundingBox.setXAxis(Vector3f axis)
           
 void OrthogonalBoundingBox.setXAxis(Vector3f axis)
           
 void LineBoundingBox.setYAxis(Vector3f axis)
           
 void OrientedBoundingBox.setYAxis(Vector3f axis)
           
 void OrthogonalBoundingBox.setYAxis(Vector3f axis)
           
 void LineBoundingBox.setZAxis(Vector3f axis)
           
 void OrientedBoundingBox.setZAxis(Vector3f axis)
           
 void OrthogonalBoundingBox.setZAxis(Vector3f axis)
           
 BoundingVolume LineBoundingBox.transform(Matrix3f rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
           
 BoundingVolume OrientedBoundingBox.transform(Matrix3f rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
           
 BoundingVolume OrthogonalBoundingBox.transform(Matrix3f rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
           
 BoundingVolume BoundingVolume.transform(Quaternion rotate, Vector3f translate, Vector3f scale)
          transform alters the location of the bounding volume by a rotation, translation and a scalar.
 BoundingVolume BoundingBox.transform(Quaternion rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
          transform modifies the center of the box to reflect the change made via a rotation, translation and scale.
 BoundingVolume BoundingCapsule.transform(Quaternion rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
           
 BoundingVolume BoundingSphere.transform(Quaternion rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
          transform modifies the center of the sphere to reflect the change made via a rotation, translation and scale.
abstract  BoundingVolume BoundingVolume.transform(Quaternion rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
          transform alters the location of the bounding volume by a rotation, translation and a scalar.
 BoundingVolume LineBoundingBox.transform(Quaternion rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
           
 BoundingVolume OrientedBoundingBox.transform(Quaternion rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
           
 BoundingVolume OrthogonalBoundingBox.transform(Quaternion rotate, Vector3f translate, Vector3f scale, BoundingVolume store)
           
 

Constructors in com.jme.bounding with parameters of type Vector3f
BoundingBox(Vector3f c, float x, float y, float z)
          Contstructor instantiates a new BoundingBox object with given specs.
BoundingCapsule(Vector3f center, LineSegment ls, float radius)
           
BoundingSphere(float r, Vector3f c)
          Constructor instantiates a new BoundingSphere object.
BoundingVolume(Vector3f center)
           
 

Uses of Vector3f in com.jme.curve
 

Methods in com.jme.curve that return Vector3f
 Vector3f BezierCurve.getPoint(float time)
           
 Vector3f CatmullRomCurve.getPoint(float time)
           
abstract  Vector3f Curve.getPoint(float time)
          getPoint calculates a point on the curve based on the time, where time is [0, 1].
 Vector3f PolylineCurve.getPoint(float time)
           
 Vector3f BezierCurve.getPoint(float time, Vector3f point)
          getPoint calculates a point on a Bezier curve from a given time value within the interval [0, 1].
 Vector3f CatmullRomCurve.getPoint(float time, Vector3f point)
          getPoint calculates a point on a Catmull-Rom curve from a given time value within the interval [0, 1].
abstract  Vector3f Curve.getPoint(float time, Vector3f store)
          Equivalent to getPoint(float) but instead of creating a new Vector3f object on the heap, the result is stored in store and store is returned.
 Vector3f PolylineCurve.getPoint(float time, Vector3f store)
           
 

Methods in com.jme.curve with parameters of type Vector3f
 Matrix3f BezierCurve.getOrientation(float time, float precision, Vector3f up)
          getOrientation calculates the rotation matrix for any given point along to the line to still be facing in the direction of the line.
 Matrix3f CatmullRomCurve.getOrientation(float time, float precision, Vector3f up)
          getOrientation calculates the rotation matrix for any given point along to the line to still be facing in the direction of the line.
abstract  Matrix3f Curve.getOrientation(float time, float precision, Vector3f up)
          getOrientation calculates a rotation matrix that defines the orientation along a curve.
 Matrix3f PolylineCurve.getOrientation(float time, float precision, Vector3f up)
          getOrientation calculates the rotation matrix for any given point along to the line to still be facing in the direction of the line.
 Vector3f BezierCurve.getPoint(float time, Vector3f point)
          getPoint calculates a point on a Bezier curve from a given time value within the interval [0, 1].
 Vector3f CatmullRomCurve.getPoint(float time, Vector3f point)
          getPoint calculates a point on a Catmull-Rom curve from a given time value within the interval [0, 1].
abstract  Vector3f Curve.getPoint(float time, Vector3f store)
          Equivalent to getPoint(float) but instead of creating a new Vector3f object on the heap, the result is stored in store and store is returned.
 Vector3f PolylineCurve.getPoint(float time, Vector3f store)
           
 void CurveController.setUpVector(Vector3f up)
          setUpVector sets the locking vector for the spatials up vector.
 

Constructors in com.jme.curve with parameters of type Vector3f
BezierCurve(java.lang.String name, Vector3f[] controlPoints)
          Constructor instantiates a new BezierCurve object.
CatmullRomCurve(java.lang.String name, Vector3f[] controlPoints)
          Constructor instantiates a new CatmullRomCurve object.
Curve(java.lang.String name, Vector3f[] controlPoints)
          Constructor creates a Curve object.
PolylineCurve(java.lang.String name, Vector3f[] controlPoints)
          Constructor instantiates a new PolylineCurve object.
 

Uses of Vector3f in com.jme.image
 

Methods in com.jme.image that return Vector3f
 Vector3f Texture.getScale()
           
 Vector3f Texture.getTranslation()
           
 

Methods in com.jme.image with parameters of type Vector3f
 void Texture.setScale(Vector3f scale)
           
 void Texture.setTranslation(Vector3f translation)
           
 

Uses of Vector3f in com.jme.input
 

Fields in com.jme.input declared as Vector3f
protected  Vector3f ThirdPersonHandler.calcVector
          An internal vector used for calculations to prevent object creation.
protected  Vector3f ChaseCamera.compVect
           
static Vector3f ChaseCamera.DEFAULT_WORLDUPVECTOR
           
protected  Vector3f ChaseCamera.dirVec
           
protected  Vector3f Mouse.hotSpotLocation
          This mouse's actual location after hotspot offset is taken into account.
protected  Vector3f Mouse.hotSpotOffset
          This mouse's hotspot location.
protected  Vector3f ChaseCamera.idealPosition
           
protected  Vector3f ChaseCamera.idealSphereCoords
           
protected  Vector3f ChaseCamera.leftVec
           
protected  Vector3f ThirdPersonHandler.loc
          Stores the new location of the node after actions.
protected  Vector3f ChaseCamera.oldCameraDir
           
protected  Vector3f ThirdPersonHandler.prevLoc
          The previous location of the target node...
protected  Vector3f ChaseCamera.targetOffset
           
protected  Vector3f ChaseCamera.targetPos
           
protected  Vector3f ChaseCamera.upVec
           
protected  Vector3f ThirdPersonHandler.upVector
          World up vector.
protected  Vector3f ChaseCamera.velocity
           
protected  Vector3f ChaseCamera.worldUpVec
           
 

Methods in com.jme.input that return Vector3f
 Vector3f Mouse.getHotSpotOffset()
          Returns the currently set hotspot of the mouse.
 Vector3f Mouse.getHotSpotPosition()
          Returns this mouse's location relative to the hotspot offset.
 Vector3f ChaseCamera.getIdealPosition()
           
 Vector3f ChaseCamera.getIdealSphereCoords()
           
 Vector3f ChaseCamera.getTargetOffset()
           
 Vector3f ThirdPersonHandler.getUpVector()
           
 

Methods in com.jme.input with parameters of type Vector3f
protected  void ChaseCamera.enforceMinMaxDistance(Vector3f camPos)
           
 void Mouse.setHotSpotOffset(Vector3f offset)
          Sets the mouse's hotspot offset.
 void ChaseCamera.setIdealSphereCoords(Vector3f idealSphereCoords)
           
 void KeyboardLookHandler.setLockAxis(Vector3f lock)
           
 void MouseLookHandler.setLockAxis(Vector3f lock)
           
 void ChaseCamera.setTargetOffset(Vector3f targetOffset)
           
 void KeyboardLookHandler.setUpAxis(Vector3f upAxis)
           
 void ThirdPersonHandler.setUpVector(Vector3f upAngle)
           
 void ChaseCamera.setWorldUpVec(Vector3f worldUpVec)
           
protected  void ChaseCamera.updateCameraPosition(float time, Vector3f camPos)
           
protected  void ChaseCamera.updateIdealAzimuth(float time, Vector3f camPos)
           
protected  void ChaseCamera.updateTargetPosition(Vector3f camPos)
           
 

Uses of Vector3f in com.jme.input.action
 

Methods in com.jme.input.action that return Vector3f
 Vector3f MouseLook.getLockAxis()
          Returns the axis that is currently locked.
 Vector3f NodeMouseLook.getLockAxis()
          Returns the axis that is currently locked.
 Vector3f KeyStrafeDownAction.getUpVector()
           
 Vector3f KeyStrafeUpAction.getUpVector()
           
 

Methods in com.jme.input.action with parameters of type Vector3f
 void KeyNodeRotateLeftAction.setLockAxis(Vector3f lockAxis)
          setLockAxis allows a certain axis to be locked, meaning the camera will always be within the plane of the locked axis.
 void KeyNodeRotateRightAction.setLockAxis(Vector3f lockAxis)
          setLockAxis allows a certain axis to be locked, meaning the camera will always be within the plane of the locked axis.
 void KeyRotateLeftAction.setLockAxis(Vector3f lockAxis)
          setLockAxis allows a certain axis to be locked, meaning the camera will always be within the plane of the locked axis.
 void KeyRotateRightAction.setLockAxis(Vector3f lockAxis)
          setLockAxis allows a certain axis to be locked, meaning the camera will always be within the plane of the locked axis.
 void MouseLook.setLockAxis(Vector3f lockAxis)
          setLockAxis sets the axis that should be locked down.
 void NodeMouseLook.setLockAxis(Vector3f lockAxis)
          setLockAxis sets the axis that should be locked down.
 void KeyStrafeDownAction.setUpVector(Vector3f upVector)
           
 void KeyStrafeUpAction.setUpVector(Vector3f upVector)
           
 

Uses of Vector3f in com.jme.input.controls.controller.camera
 

Methods in com.jme.input.controls.controller.camera that return Vector3f
 Vector3f FixedCameraPerspective.getLocation()
           
 

Constructors in com.jme.input.controls.controller.camera with parameters of type Vector3f
FixedCameraPerspective(Vector3f location)
           
FixedCameraPerspective(Vector3f location, boolean hideSpatialOnActivate)
           
 

Uses of Vector3f in com.jme.input.thirdperson
 

Fields in com.jme.input.thirdperson declared as Vector3f
protected  Vector3f ThirdPersonMouseLook.difTemp
           
protected  Vector3f ThirdPersonMouseLook.rightTemp
           
protected  Vector3f ThirdPersonMouseLook.sphereTemp
           
protected  Vector3f ThirdPersonMouseLook.worldUpVec
           
 

Methods in com.jme.input.thirdperson with parameters of type Vector3f
 void ThirdPersonMouseLook.setWorldUpVec(Vector3f worldUpVec)
           
 

Uses of Vector3f in com.jme.intersection
 

Methods in com.jme.intersection that return Vector3f
 Vector3f IntersectionRecord.getIntersectionPoint(int index)
          Returns an intersection point at a provided index.
 

Methods in com.jme.intersection with parameters of type Vector3f
static float Distance.distance(Vector3f point, Ray ray)
          distance calculates the distance between a point and a ray.
static float Distance.distance(Vector3f point1, Vector3f point2)
          distance calculates the distance between two points.
static float Distance.distanceSquared(Vector3f p1, Vector3f p2)
          distanceSquared returns the distance between two points, with the distance squared.
static boolean IntersectionSphere.intersection(BoundingSphere sphere1, BoundingSphere sphere2, Vector3f velocity1, Vector3f velocity2, float time)
          intersection compares two dynamic spheres.
static boolean IntersectionSphere.intersection(Line line, BoundingSphere sphere, Vector3f velocity, float time)
          intersection compares a dynamic sphere to a stationary line.
static boolean IntersectionSphere.intersection(Plane plane, BoundingSphere sphere, Vector3f velocity, float time)
          intersection compares a dynamix sphere to a stationary plane.
static boolean Intersection.intersection(Vector3f v0, Vector3f v1, Vector3f v2, Vector3f u0, Vector3f u1, Vector3f u2)
          This method tests for the intersection between two triangles defined by their vertexes.
 

Constructors in com.jme.intersection with parameters of type Vector3f
IntersectionRecord(float[] distances, Vector3f[] points)
          Instantiates a new IntersectionRecord defining the distances and points.
 

Uses of Vector3f in com.jme.light
 

Methods in com.jme.light that return Vector3f
 Vector3f DirectionalLight.getDirection()
          getDirection returns the direction the light is emitting from.
 Vector3f SpotLight.getDirection()
          getDirection returns the direction the spot light pointing.
 Vector3f PointLight.getLocation()
          getLocation returns the position of this light.
 

Methods in com.jme.light with parameters of type Vector3f
 void DirectionalLight.setDirection(Vector3f direction)
          setDirection sets the direction the light is emitting from.
 void SpotLight.setDirection(Vector3f direction)
          setDirection sets the direction the spot light is pointing.
 void PointLight.setLocation(Vector3f location)
          setLocation sets the position of the light.
 

Uses of Vector3f in com.jme.math
 

Fields in com.jme.math declared as Vector3f
 Vector3f Ray.direction
          The direction of the ray.
(package private)  Vector3f[] Eigen3f.eigenVectors
           
 Vector3f Plane.normal
          Vector normal to the plane.
 Vector3f Ray.origin
          The ray's begining point.
protected static Vector3f Ray.tempVa
           
protected static Vector3f Ray.tempVb
           
protected static Vector3f Ray.tempVc
           
protected static Vector3f Ray.tempVd
           
static Vector3f Vector3f.UNIT_X
           
static Vector3f Vector3f.UNIT_XYZ
           
static Vector3f Vector3f.UNIT_Y
           
static Vector3f Vector3f.UNIT_Z
           
static Vector3f Vector3f.ZERO
           
 

Methods in com.jme.math that return Vector3f
 Vector3f Vector3f.add(float addX, float addY, float addZ)
          add adds the provided values to this vector, creating a new vector that is then returned.
 Vector3f Vector3f.add(Vector3f vec)
          add adds a provided vector to this vector creating a resultant vector which is returned.
 Vector3f Vector3f.add(Vector3f vec, Vector3f result)
          add adds the values of a provided vector storing the values in the supplied vector.
 Vector3f Vector3f.addLocal(float addX, float addY, float addZ)
          addLocal adds the provided values to this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector3f Vector3f.addLocal(Vector3f vec)
          addLocal adds a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
static Vector3f FastMath.cartesianToSpherical(Vector3f cartCoords, Vector3f store)
          Converts a point from Cartesian coordinates (using positive Y as up) to Spherical and stores the results in the store var.
static Vector3f FastMath.cartesianZToSpherical(Vector3f cartCoords, Vector3f store)
          Converts a point from Cartesian coordinates (using positive Z as up) to Spherical and stores the results in the store var.
 Vector3f Vector3f.clone()
           
 Vector3f Vector3f.cross(float otherX, float otherY, float otherZ, Vector3f result)
          cross calculates the cross product of this vector with a Vector comprised of the specified other* elements.
 Vector3f Vector2f.cross(Vector2f v)
          cross calculates the cross product of this vector with a parameter vector v.
 Vector3f Vector3f.cross(Vector3f v)
          Returns a new vector which is the cross product of this vector with the specified vector.
 Vector3f Vector3f.cross(Vector3f v, Vector3f result)
          cross calculates the cross product of this vector with a parameter vector v.
 Vector3f Vector3f.crossLocal(float otherX, float otherY, float otherZ)
          crossLocal calculates the cross product of this vector with a parameter vector v.
 Vector3f Vector3f.crossLocal(Vector3f v)
          crossLocal calculates the cross product of this vector with a parameter vector v.
 Vector3f Vector3f.divide(float scalar)
          divide divides the values of this vector by a scalar and returns the result.
 Vector3f Vector3f.divide(Vector3f scalar)
          divide divides the values of this vector by a scalar and returns the result.
 Vector3f Vector3f.divideLocal(float scalar)
          divideLocal divides this vector by a scalar internally, and returns a handle to this vector for easy chaining of calls.
 Vector3f Vector3f.divideLocal(Vector3f scalar)
          divideLocal divides this vector by a scalar internally, and returns a handle to this vector for easy chaining of calls.
 Vector3f Triangle.get(int i)
          get retrieves a point on the triangle denoted by the index supplied.
 Vector3f Rectangle.getA()
          getA returns the first point of the rectangle.
 Vector3f Rectangle.getB()
          getB returns the second point of the rectangle.
 Vector3f Rectangle.getC()
          getC returns the third point of the rectangle.
 Vector3f Ring.getCenter()
          getCenter returns the center of the ring.
 Vector3f Triangle.getCenter()
          obtains the center point of this triangle (average of the three triangles)
 Vector3f Matrix3f.getColumn(int i)
          getColumn returns one of three columns specified by the parameter.
 Vector3f Matrix3f.getColumn(int i, Vector3f store)
          getColumn returns one of three columns specified by the parameter.
 Vector3f Line.getDirection()
          getDirection returns the direction of the line.
 Vector3f LineSegment.getDirection()
           
 Vector3f Ray.getDirection()
          getDirection retrieves the direction vector of the ray.
 Vector3f Eigen3f.getEigenVector(int i)
           
 Vector3f[] Eigen3f.getEigenVectors()
           
 Vector3f LineSegment.getNegativeEnd(Vector3f store)
           
 Vector3f Plane.getNormal()
          getNormal retrieves the normal of the plane.
 Vector3f Triangle.getNormal()
          obtains the unit length normal vector of this triangle, if set or calculated
 Vector3f Line.getOrigin()
          getOrigin returns the origin of the line.
 Vector3f LineSegment.getOrigin()
           
 Vector3f Ray.getOrigin()
          getOrigin retrieves the origin point of the ray.
 Vector3f LineSegment.getPositiveEnd(Vector3f store)
           
 Vector3f Quaternion.getRotationColumn(int i)
          getRotationColumn returns one of three columns specified by the parameter.
 Vector3f Quaternion.getRotationColumn(int i, Vector3f store)
          getRotationColumn returns one of three columns specified by the parameter.
 Vector3f Matrix3f.getRow(int i)
          getColumn returns one of three rows as specified by the parameter.
 Vector3f Matrix3f.getRow(int i, Vector3f store)
          getRow returns one of three rows as specified by the parameter.
 Vector3f TransformQuaternion.getScale()
          Return the scale vector in this matrix.
 Vector3f TransformMatrix.getScale(Vector3f storeS)
          Returns this TransformMatrix's scale factor
 Vector3f TransformQuaternion.getScale(Vector3f scale)
          Stores this scale value into the given vector3f.
 Vector3f TransformQuaternion.getTranslation()
          Return the translation vector in this matrix.
 Vector3f TransformMatrix.getTranslation(Vector3f tranStore)
          Stores the translational part of this matrix into the passed matrix.
 Vector3f TransformQuaternion.getTranslation(Vector3f trans)
          Stores this translation value into the given vector3f.
 Vector3f Ring.getUp()
          getUp returns the ring's up vector.
 Vector3f Vector3f.mult(float scalar)
          mult multiplies this vector by a scalar.
 Vector3f Vector3f.mult(float scalar, Vector3f product)
          mult multiplies this vector by a scalar.
 Vector3f Matrix3f.mult(Vector3f vec)
          mult multiplies this matrix by a given Vector3f object.
 Vector3f Matrix4f.mult(Vector3f vec)
          mult multiplies a vector about a rotation matrix.
 Vector3f Quaternion.mult(Vector3f v)
          mult multiplies this quaternion by a parameter vector.
 Vector3f Vector3f.mult(Vector3f vec)
          Returns a new Vector instance comprised of elements which are the product of the corresponding vector elements.
 Vector3f Matrix3f.mult(Vector3f vec, Vector3f product)
          Multiplies this 3x3 matrix by the 1x3 Vector vec and stores the result in product.
 Vector3f Matrix4f.mult(Vector3f vec, Vector3f store)
          mult multiplies a vector about a rotation matrix and adds translation.
 Vector3f Quaternion.mult(Vector3f v, Vector3f store)
          mult multiplies this quaternion by a parameter vector.
 Vector3f Vector3f.mult(Vector3f vec, Vector3f store)
          Multiplies a provided 'vec' vector with this vector.
 Vector3f Matrix4f.multAcross(Vector3f vec, Vector3f store)
          mult multiplies a vector about a rotation matrix.
 Vector3f Vector3f.multLocal(float scalar)
          multLocal multiplies this vector by a scalar internally, and returns a handle to this vector for easy chaining of calls.
 Vector3f Matrix3f.multLocal(Vector3f vec)
          multLocal multiplies this matrix by a given Vector3f object.
 Vector3f Quaternion.multLocal(Vector3f v)
          mult multiplies this quaternion by a parameter vector.
 Vector3f Vector3f.multLocal(Vector3f vec)
          multLocal multiplies a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector3f TransformMatrix.multNormal(Vector3f vec)
          mult multiplies a normal about a transform matrix and stores the result back in vec.
 Vector3f TransformMatrix.multPoint(Vector3f vec)
          mult multiplies a vector about a transform matrix.
 Vector3f Vector3f.negate()
          negate returns the negative of this vector.
 Vector3f Vector3f.negateLocal()
          negateLocal negates the internal values of this vector.
 Vector3f Vector3f.normalize()
          normalize returns the unit vector of this vector.
 Vector3f Vector3f.normalizeLocal()
          normalizeLocal makes this vector into a unit vector of itself.
 Vector3f Line.random()
          random determines a random point along the line.
 Vector3f Rectangle.random()
          random returns a random point within the plane defined by: A, B, C, and (B + C) - A.
 Vector3f Ring.random()
          random returns a random point within the ring.
 Vector3f Line.random(Vector3f result)
          random determines a random point along the line.
 Vector3f Rectangle.random(Vector3f result)
          random returns a random point within the plane defined by: A, B, C, and (B + C) - A.
 Vector3f Ring.random(Vector3f result)
          random returns a random point within the ring.
 Vector3f Vector3f.set(float x, float y, float z)
          set sets the x,y,z values of the vector based on passed parameters.
 Vector3f Vector3f.set(Vector3f vect)
          set sets the x,y,z values of the vector by copying the supplied vector.
static Vector3f FastMath.sphericalToCartesian(Vector3f sphereCoords, Vector3f store)
          Converts a point from Spherical coordinates to Cartesian (using positive Y as up) and stores the results in the store var.
static Vector3f FastMath.sphericalToCartesianZ(Vector3f sphereCoords, Vector3f store)
          Converts a point from Spherical coordinates to Cartesian (using positive Z as up) and stores the results in the store var.
 Vector3f Vector3f.subtract(float subtractX, float subtractY, float subtractZ)
          subtract subtracts the provided values from this vector, creating a new vector that is then returned.
 Vector3f Vector3f.subtract(Vector3f vec)
          subtract subtracts the values of a given vector from those of this vector creating a new vector object.
 Vector3f Vector3f.subtract(Vector3f vec, Vector3f result)
          subtract
 Vector3f Vector3f.subtractLocal(float subtractX, float subtractY, float subtractZ)
          subtractLocal subtracts the provided values from this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector3f Vector3f.subtractLocal(Vector3f vec)
          subtractLocal subtracts a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector3f Matrix4f.toTranslationVector()
           
 

Methods in com.jme.math that return types with arguments of type Vector3f
 java.lang.Class<? extends Vector3f> Vector3f.getClassTag()
           
 

Methods in com.jme.math with parameters of type Vector3f
 Vector3f Vector3f.add(Vector3f vec)
          add adds a provided vector to this vector creating a resultant vector which is returned.
 Vector3f Vector3f.add(Vector3f vec, Vector3f result)
          add adds the values of a provided vector storing the values in the supplied vector.
 Vector3f Vector3f.addLocal(Vector3f vec)
          addLocal adds a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 float Vector3f.angleBetween(Vector3f otherVector)
          angleBetween returns (in radians) the angle between two vectors.
 void Matrix4f.angleRotation(Vector3f angles)
          angleRotation sets this matrix to that of a rotation about three axes (x, y, z).
static Vector3f FastMath.cartesianToSpherical(Vector3f cartCoords, Vector3f store)
          Converts a point from Cartesian coordinates (using positive Y as up) to Spherical and stores the results in the store var.
static Vector3f FastMath.cartesianZToSpherical(Vector3f cartCoords, Vector3f store)
          Converts a point from Cartesian coordinates (using positive Z as up) to Spherical and stores the results in the store var.
 Vector3f Vector3f.cross(float otherX, float otherY, float otherZ, Vector3f result)
          cross calculates the cross product of this vector with a Vector comprised of the specified other* elements.
 Vector3f Vector3f.cross(Vector3f v)
          Returns a new vector which is the cross product of this vector with the specified vector.
 Vector3f Vector3f.cross(Vector3f v, Vector3f result)
          cross calculates the cross product of this vector with a parameter vector v.
 Vector3f Vector3f.crossLocal(Vector3f v)
          crossLocal calculates the cross product of this vector with a parameter vector v.
 float Line.distance(Vector3f point)
           
 float LineSegment.distance(Vector3f point)
           
 float Vector3f.distance(Vector3f v)
          distance calculates the distance between this vector and vector v.
 float Line.distanceSquared(Vector3f point)
           
 float LineSegment.distanceSquared(Vector3f point)
           
 float Ray.distanceSquared(Vector3f point)
           
 float Vector3f.distanceSquared(Vector3f v)
          distanceSquared calculates the distance squared between this vector and vector v.
 Vector3f Vector3f.divide(Vector3f scalar)
          divide divides the values of this vector by a scalar and returns the result.
 Vector3f Vector3f.divideLocal(Vector3f scalar)
          divideLocal divides this vector by a scalar internally, and returns a handle to this vector for easy chaining of calls.
 float Vector3f.dot(Vector3f vec)
          dot calculates the dot product of this vector with a provided vector.
 void Matrix3f.fromAngleAxis(float angle, Vector3f axis)
          fromAngleAxis sets this matrix4f to the values specified by an angle and an axis of rotation.
 void Matrix4f.fromAngleAxis(float angle, Vector3f axis)
          fromAngleAxis sets this matrix4f to the values specified by an angle and an axis of rotation.
 Quaternion Quaternion.fromAngleAxis(float angle, Vector3f axis)
          fromAngleAxis sets this quaternion to the values specified by an angle and an axis of rotation.
 void Matrix3f.fromAngleNormalAxis(float angle, Vector3f axis)
          fromAngleNormalAxis sets this matrix4f to the values specified by an angle and a normalized axis of rotation.
 void Matrix4f.fromAngleNormalAxis(float angle, Vector3f axis)
          fromAngleNormalAxis sets this matrix4f to the values specified by an angle and a normalized axis of rotation.
 Quaternion Quaternion.fromAngleNormalAxis(float angle, Vector3f axis)
          fromAngleNormalAxis sets this quaternion to the values specified by an angle and a normalized axis of rotation.
 Quaternion Quaternion.fromAxes(Vector3f[] axis)
          fromAxes creates a Quaternion that represents the coordinate system defined by three axes.
 void Matrix3f.fromAxes(Vector3f uAxis, Vector3f vAxis, Vector3f wAxis)
          Recreate Matrix using the provided axis.
 Quaternion Quaternion.fromAxes(Vector3f xAxis, Vector3f yAxis, Vector3f zAxis)
          fromAxes creates a Quaternion that represents the coordinate system defined by three axes.
 void Matrix3f.fromStartEndVectors(Vector3f start, Vector3f end)
          A function for creating a rotation matrix that rotates a vector called "start" into another vector called "end".
static void Vector3f.generateComplementBasis(Vector3f u, Vector3f v, Vector3f w)
           
static void Vector3f.generateOrthonormalBasis(Vector3f u, Vector3f v, Vector3f w)
           
 Vector3f Matrix3f.getColumn(int i, Vector3f store)
          getColumn returns one of three columns specified by the parameter.
 Vector3f LineSegment.getNegativeEnd(Vector3f store)
           
 Vector3f LineSegment.getPositiveEnd(Vector3f store)
           
 Vector3f Quaternion.getRotationColumn(int i, Vector3f store)
          getRotationColumn returns one of three columns specified by the parameter.
 Vector3f Matrix3f.getRow(int i, Vector3f store)
          getRow returns one of three rows as specified by the parameter.
 Vector3f TransformMatrix.getScale(Vector3f storeS)
          Returns this TransformMatrix's scale factor
 Vector3f TransformQuaternion.getScale(Vector3f scale)
          Stores this scale value into the given vector3f.
 Vector3f TransformMatrix.getTranslation(Vector3f tranStore)
          Stores the translational part of this matrix into the passed matrix.
 Vector3f TransformQuaternion.getTranslation(Vector3f trans)
          Stores this translation value into the given vector3f.
 void Vector3f.interpolate(Vector3f finalVec, float changeAmnt)
          Sets this vector to the interpolation by changeAmnt from this to the finalVec this=(1-changeAmnt)*this + changeAmnt * finalVec
 void Vector3f.interpolate(Vector3f beginVec, Vector3f finalVec, float changeAmnt)
          Sets this vector to the interpolation by changeAmnt from beginVec to finalVec this=(1-changeAmnt)*beginVec + changeAmnt * finalVec
 boolean Ray.intersect(Vector3f v0, Vector3f v1, Vector3f v2)
          intersect determines if the Ray intersects a triangle defined by the specified points.
 boolean Ray.intersectsWherePlane(Plane p, Vector3f loc)
           
 boolean Ray.intersectWhere(Triangle t, Vector3f loc)
          intersectWhere determines if the Ray intersects a triangle.
 boolean Ray.intersectWhere(Vector3f v0, Vector3f v1, Vector3f v2, Vector3f loc)
          intersectWhere determines if the Ray intersects a triangle defined by the specified points and if so it stores the point of intersection in the given loc vector.
 boolean Ray.intersectWherePlanar(Triangle t, Vector3f loc)
          intersectWherePlanar determines if the Ray intersects a triangle and if so it stores the point of intersection in the given loc vector as t, u, v where t is the distance from the origin to the point of intersection and u,v is the intersection point in terms of the triangle plane.
 boolean Ray.intersectWherePlanar(Vector3f v0, Vector3f v1, Vector3f v2, Vector3f loc)
          intersectWherePlanar determines if the Ray intersects a triangle defined by the specified points and if so it stores the point of intersection in the given loc vector as t, u, v where t is the distance from the origin to the point of intersection and u,v is the intersection point in terms of the triangle plane.
 boolean Ray.intersectWherePlanarQuad(Vector3f v0, Vector3f v1, Vector3f v2, Vector3f loc)
          intersectWherePlanar determines if the Ray intersects a quad defined by the specified points and if so it stores the point of intersection in the given loc vector as t, u, v where t is the distance from the origin to the point of intersection and u,v is the intersection point in terms of the quad plane.
 void Matrix4f.inverseRotateVect(Vector3f vec)
          inverseRotateVect rotates a given Vector3f by the rotation part of this matrix.
 void Matrix4f.inverseTranslateVect(Vector3f data)
          inverseTranslateVect translates a given Vector3f by the translation part of this matrix.
 boolean LineSegment.isPointInsideBounds(Vector3f point)
          Evaluates whether a given point is contained within the axis aligned bounding box that contains this LineSegment.
 boolean LineSegment.isPointInsideBounds(Vector3f point, float error)
          Evaluates whether a given point is contained within the axis aligned bounding box that contains this LineSegment.
static boolean Vector3f.isValidVector(Vector3f vector)
          Check a vector...
 void Quaternion.lookAt(Vector3f direction, Vector3f up)
          lookAt is a convienence method for auto-setting the quaternion based on a direction and an up vector.
 Vector3f Vector3f.mult(float scalar, Vector3f product)
          mult multiplies this vector by a scalar.
 Vector3f Matrix3f.mult(Vector3f vec)
          mult multiplies this matrix by a given Vector3f object.
 Vector3f Matrix4f.mult(Vector3f vec)
          mult multiplies a vector about a rotation matrix.
 Vector3f Quaternion.mult(Vector3f v)
          mult multiplies this quaternion by a parameter vector.
 Vector3f Vector3f.mult(Vector3f vec)
          Returns a new Vector instance comprised of elements which are the product of the corresponding vector elements.
 Vector3f Matrix3f.mult(Vector3f vec, Vector3f product)
          Multiplies this 3x3 matrix by the 1x3 Vector vec and stores the result in product.
 Vector3f Matrix4f.mult(Vector3f vec, Vector3f store)
          mult multiplies a vector about a rotation matrix and adds translation.
 Vector3f Quaternion.mult(Vector3f v, Vector3f store)
          mult multiplies this quaternion by a parameter vector.
 Vector3f Vector3f.mult(Vector3f vec, Vector3f store)
          Multiplies a provided 'vec' vector with this vector.
 Vector3f Matrix4f.multAcross(Vector3f vec, Vector3f store)
          mult multiplies a vector about a rotation matrix.
 TransformMatrix TransformMatrix.multLocal(TransformMatrix child, Vector3f tempStore)
          multLocal multiplies this matrix with another matrix and stores the result back in this, returning this.
 Vector3f Matrix3f.multLocal(Vector3f vec)
          multLocal multiplies this matrix by a given Vector3f object.
 Vector3f Quaternion.multLocal(Vector3f v)
          mult multiplies this quaternion by a parameter vector.
 Vector3f Vector3f.multLocal(Vector3f vec)
          multLocal multiplies a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector3f TransformMatrix.multNormal(Vector3f vec)
          mult multiplies a normal about a transform matrix and stores the result back in vec.
 Vector3f TransformMatrix.multPoint(Vector3f vec)
          mult multiplies a vector about a transform matrix.
 float Plane.pseudoDistance(Vector3f point)
          pseudoDistance calculates the distance from this plane to a provided point.
 Vector3f Line.random(Vector3f result)
          random determines a random point along the line.
 Vector3f Rectangle.random(Vector3f result)
          random returns a random point within the plane defined by: A, B, C, and (B + C) - A.
 Vector3f Ring.random(Vector3f result)
          random returns a random point within the ring.
 void Matrix4f.rotateVect(Vector3f vec)
           
 void Matrix3f.scale(Vector3f scale)
          scale scales the operation performed by this matrix on a per-component basis.
 void Matrix4f.scale(Vector3f scale)
          Apply a scale to this matrix.
 void Vector3f.scaleAdd(float scalar, Vector3f add)
          scaleAdd multiplies this vector by a scalar then adds the given Vector3f.
 void Vector3f.scaleAdd(float scalar, Vector3f mult, Vector3f add)
          scaleAdd multiplies the given vector by a scalar then adds the given vector.
 void Triangle.set(int i, Vector3f point)
          set sets one of the triangles points to that specified as a parameter.
 void TransformMatrix.set(Quaternion rotation, Vector3f translation)
          set changes this matrix's rotational and translational components to that represented by the given parameters, by copying.
 Vector3f Vector3f.set(Vector3f vect)
          set sets the x,y,z values of the vector by copying the supplied vector.
 void Rectangle.setA(Vector3f a)
          setA sets the first point of the rectangle.
 void Rectangle.setB(Vector3f b)
          setB sets the second point of the rectangle.
 void Rectangle.setC(Vector3f c)
          setC sets the third point of the rectangle.
 void Ring.setCenter(Vector3f center)
          setCenter sets the center of the ring.
 void Triangle.setCenter(Vector3f center)
          sets the center point of this triangle (average of the three triangles)
 void Matrix3f.setColumn(int i, Vector3f column)
          setColumn sets a particular column of this matrix to that represented by the provided vector.
 void Line.setDirection(Vector3f direction)
          setDirection sets the direction of the line.
 void LineSegment.setDirection(Vector3f direction)
           
 void Ray.setDirection(Vector3f direction)
          setDirection sets the direction vector of the ray.
 void TransformMatrix.setEulerRot(Vector3f eulerVec)
          setEulerRot is equivalent to setEulerRot(eulerVec.x,eulverVec.y,eulverVec.z){
 void Plane.setNormal(Vector3f normal)
          setNormal sets the normal of the plane.
 void Triangle.setNormal(Vector3f normal)
          sets the normal vector of this triangle (to conform, must be unit length)
 void Line.setOrigin(Vector3f origin)
          setOrigin sets the origin of the line.
 void LineSegment.setOrigin(Vector3f origin)
           
 void Ray.setOrigin(Vector3f origin)
          setOrigin sets the origin of the ray.
 void Plane.setPlanePoints(Vector3f v1, Vector3f v2, Vector3f v3)
          Initialize the Plane using the given 3 points as coplanar.
 void Matrix3f.setRow(int i, Vector3f row)
          setRow sets a particular row of this matrix to that represented by the provided vector.
 void TransformMatrix.setScale(Vector3f scale)
          Sets this TransformMatrix's scale to the given scale (x,y,z), by copying.
 void TransformQuaternion.setScale(Vector3f scale)
          Sets this scale to the given value by copying.
 void Matrix4f.setTranslation(Vector3f translation)
          setTranslation will set the matrix's translation values.
 void TransformMatrix.setTranslation(Vector3f trans)
          setTranslation will copy the given Vector3f's values into this Matrix's translational component
 void TransformQuaternion.setTranslation(Vector3f trans)
          Sets this translation to the given value by copying.
 void Ring.setUp(Vector3f up)
          setUp sets the ring's up vector.
static Vector3f FastMath.sphericalToCartesian(Vector3f sphereCoords, Vector3f store)
          Converts a point from Spherical coordinates to Cartesian (using positive Y as up) and stores the results in the store var.
static Vector3f FastMath.sphericalToCartesianZ(Vector3f sphereCoords, Vector3f store)
          Converts a point from Spherical coordinates to Cartesian (using positive Z as up) and stores the results in the store var.
 Vector3f Vector3f.subtract(Vector3f vec)
          subtract subtracts the values of a given vector from those of this vector creating a new vector object.
 Vector3f Vector3f.subtract(Vector3f vec, Vector3f result)
          subtract
 Vector3f Vector3f.subtractLocal(Vector3f vec)
          subtractLocal subtracts a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 float Quaternion.toAngleAxis(Vector3f axisStore)
          toAngleAxis sets a given angle and axis to that represented by the current quaternion.
 void Quaternion.toAxes(Vector3f[] axis)
          toAxes takes in an array of three vectors.
 void Matrix4f.toTranslationVector(Vector3f vector)
           
 void Matrix4f.translateVect(Vector3f data)
          inverseTranslateVect translates a given Vector3f by the translation part of this matrix.
 Plane.Side Plane.whichSide(Vector3f p)
          Determine on which side of this plane the point p lies.
 

Constructors in com.jme.math with parameters of type Vector3f
Line(Vector3f origin, Vector3f direction)
          Constructor instantiates a new Line object.
LineSegment(Vector3f start, Vector3f end)
          Creates a new LineSegment with a given origin and end.
LineSegment(Vector3f origin, Vector3f direction, float extent)
          Creates a new LineSegment with the given origin, direction and extent.
Plane(Vector3f normal, float constant)
          Constructor instantiates a new Plane object.
Ray(Vector3f origin, Vector3f direction)
          Constructor instantiates a new Ray object.
Rectangle(Vector3f a, Vector3f b, Vector3f c)
          Constructor creates a new Rectangle with defined A, B, and C points that define the area of the rectangle.
Ring(Vector3f center, Vector3f up, float innerRadius, float outerRadius)
          Constructor creates a new Ring with defined center point, up vector, and inner and outer radii.
TransformMatrix(Quaternion myRot, Vector3f myPos)
          Constructor instantiates a new TransformMatrix that has rotation and translation defined by its parameters
Triangle(Vector3f p1, Vector3f p2, Vector3f p3)
          Constructor instantiates a new Triangle object with the supplied vectors as the points.
Vector3f(Vector3f copy)
          Constructor instantiates a new Vector3f that is a copy of the provided vector
 

Uses of Vector3f in com.jme.math.spring
 

Fields in com.jme.math.spring declared as Vector3f
 Vector3f SpringPoint.acceleration
          Acceleration vector, zeroed and recalculated on each SpringSystem.calcForces(float).
 Vector3f SpringPoint.oldPos
          Previous Position of this point in space.
 Vector3f SpringPoint.position
          Position of this point in space.
 

Constructors in com.jme.math.spring with parameters of type Vector3f
SpringPoint(Vector3f pos)
          Public constructor.
 

Uses of Vector3f in com.jme.renderer
 

Fields in com.jme.renderer declared as Vector3f
protected  Vector3f AbstractCamera.direction
          Direction the camera is facing.
protected  Vector3f AbstractCamera.left
          Direction of camera's 'left'
protected  Vector3f AbstractCamera.location
          Camera's location
protected  Vector3f AbstractCamera.newDirection
          Computation vector used in lookAt operations.
protected  Vector3f AbstractCamera.up
          Direction of 'up' for camera.
 

Methods in com.jme.renderer that return Vector3f
 Vector3f AbstractCamera.getDirection()
          getDirection retrieves the direction vector the camera is facing.
 Vector3f Camera.getDirection()
          getDirection returns the direction the camera is facing.
 Vector3f AbstractCamera.getLeft()
          getLeft retrieves the left axis of the camera.
 Vector3f Camera.getLeft()
          getLeft returns the left axis of the camera.
 Vector3f AbstractCamera.getLocation()
          getLocation retrieves the location vector of the camera.
 Vector3f Camera.getLocation()
          getLocation returns the position of the camera.
 Vector3f AbstractCamera.getScreenCoordinates(Vector3f worldPos)
           
 Vector3f Camera.getScreenCoordinates(Vector3f worldPosition)
          Convert world to screen coordinates.
 Vector3f AbstractCamera.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
          Implementation contributed by Zbyl.
 Vector3f Camera.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
          Convert world to screen coordinates.
 Vector3f AbstractCamera.getUp()
          getUp retrieves the up axis of the camera.
 Vector3f Camera.getUp()
          getUp returns the up axis of the camera.
 Vector3f AbstractCamera.getWorldCoordinates(Vector2f screenPos, float zPos)
           
 Vector3f Camera.getWorldCoordinates(Vector2f screenPosition, float zPos)
          Convert screen to world coordinates.
 Vector3f AbstractCamera.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
           
 Vector3f Camera.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
          Convert screen to world coordinates.
 

Methods in com.jme.renderer with parameters of type Vector3f
 Vector3f AbstractCamera.getScreenCoordinates(Vector3f worldPos)
           
 Vector3f Camera.getScreenCoordinates(Vector3f worldPosition)
          Convert world to screen coordinates.
 Vector3f AbstractCamera.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
          Implementation contributed by Zbyl.
 Vector3f Camera.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
          Convert world to screen coordinates.
 Vector3f AbstractCamera.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
           
 Vector3f Camera.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
          Convert screen to world coordinates.
 void AbstractCamera.lookAt(Vector3f pos, Vector3f worldUpVector)
          lookAt is a convienence method for auto-setting the frame based on a world position the user desires the camera to look at.
 void Camera.lookAt(Vector3f pos, Vector3f worldUpVector)
          lookAt is a convienence method for auto-setting the frame based on a world position the user desires the camera to look at.
 void AbstractCamera.setAxes(Vector3f left, Vector3f up, Vector3f direction)
          setAxes sets the axes (left, up and direction) for this camera.
 void Camera.setAxes(Vector3f left, Vector3f up, Vector3f direction)
          setAxes sets the axes that define the camera's orientation.
 void AbstractCamera.setDirection(Vector3f direction)
          setDirection sets the direction this camera is facing.
 void Camera.setDirection(Vector3f direction)
          setDirection sets the direction the camera is facing.
 void AbstractCamera.setFrame(Vector3f location, Quaternion axes)
          setFrame sets the orientation and location of the camera.
 void Camera.setFrame(Vector3f location, Quaternion axes)
          setFrame sets the view frame of the camera by setting the location and the orientation of the camera model.
 void AbstractCamera.setFrame(Vector3f location, Vector3f left, Vector3f up, Vector3f direction)
          setFrame sets the orientation and location of the camera.
 void Camera.setFrame(Vector3f location, Vector3f left, Vector3f up, Vector3f direction)
          setFrame sets the view frame of the camera by setting the location and orientation of the camera model.
 void AbstractCamera.setLeft(Vector3f left)
          setLeft sets the left axis of this camera.
 void Camera.setLeft(Vector3f left)
          setLeft sets the left axis of the camera.
 void AbstractCamera.setLocation(Vector3f location)
          setLocation sets the position of the camera.
 void Camera.setLocation(Vector3f location)
          setLocation the position of the camera.
 void AbstractCamera.setUp(Vector3f up)
          setUp sets the up axis of this camera.
 void Camera.setUp(Vector3f up)
          setUp sets the up axis of the camera.
 

Uses of Vector3f in com.jme.renderer.jogl
 

Methods in com.jme.renderer.jogl with parameters of type Vector3f
 void JOGLFont.print(Renderer r, float x, float y, Vector3f scale, java.lang.StringBuffer text, int set)
          print renders the specified string to a given (x,y) location.
 

Uses of Vector3f in com.jme.renderer.lwjgl
 

Methods in com.jme.renderer.lwjgl with parameters of type Vector3f
 void LWJGLFont.print(Renderer r, float x, float y, Vector3f scale, java.lang.StringBuffer text, int set)
          print renders the specified string to a given (x,y) location.
 

Uses of Vector3f in com.jme.renderer.pass
 

Fields in com.jme.renderer.pass declared as Vector3f
protected  Vector3f DirectionalShadowMapPass.direction
          The direction shadows are being cast from - directional light?
 

Methods in com.jme.renderer.pass with parameters of type Vector3f
 void DirectionalShadowMapPass.setViewTarget(Vector3f target)
          Set the target of the view.
 

Constructors in com.jme.renderer.pass with parameters of type Vector3f
DirectionalShadowMapPass(Vector3f direction)
          Create a shadow map pass casting shadows from a light with the direction given.
DirectionalShadowMapPass(Vector3f direction, int shadowMapSize)
          Create a shadow map pass casting shadows from a light with the direction given.
 

Uses of Vector3f in com.jme.scene
 

Fields in com.jme.scene declared as Vector3f
protected static Vector3f Geometry.compVect
          Static computation field
protected  Vector3f Spatial.localScale
          Spatial's scale relative to its parent.
protected  Vector3f Spatial.localTranslation
          Spatial's translation relative to its parent.
protected  Vector3f Spatial.worldScale
          Spatial's world absolute scale.
protected  Vector3f Spatial.worldTranslation
          Spatial's world absolute translation.
protected  Vector3f ImposterNode.worldUpVector
           
 

Methods in com.jme.scene that return Vector3f
 Vector3f BezierPatch.getAnchor(int i, int j)
          getAnchor returns a single control anchor of a given (i, j) of the patch.
 Vector3f[][] BezierPatch.getAnchors()
          getAnchors returns the control anchors that make up this patch.
 Vector3f Spatial.getLocalScale()
          getLocalScale retrieves the local scale of this node.
 Vector3f Spatial.getLocalTranslation()
          getLocalTranslation retrieves the local translation of this node.
 Vector3f[] QuadMesh.getMeshAsQuadsVertices(Vector3f[] verts)
          Return this mesh object as quads.
 Vector3f[] SharedMesh.getMeshAsTrianglesVertices(Vector3f[] verts)
          retrieves the mesh as triangle vertices of the target mesh.
 Vector3f[] TriMesh.getMeshAsTrianglesVertices(Vector3f[] verts)
          Return this mesh object as triangles.
static Vector3f[] QuadMesh.getQuads()
           
 Vector3f Spatial.getWorldScale()
          getWorldScale retrieves the absolute scale factor of the spatial.
 Vector3f Spatial.getWorldTranslation()
          getWorldTranslation retrieves the absolute translation of the spatial.
 Vector3f ImposterNode.getWorldUpVector()
           
 Vector3f Spatial.localToWorld(Vector3f in, Vector3f store)
          Convert a vector (in) from this spatials local coordinate space to world coordinate space.
 Vector3f TriMesh.randomPointOnTriangles(Vector3f fill, Vector3f work)
          Returns a random point on the surface of a randomly selected triangle on the mesh
 Vector3f Geometry.randomVertex(Vector3f fill)
          randomVertex returns a random vertex from the list of vertices set to this geometry.
 Vector3f SharedMesh.randomVertex(Vector3f fill)
           
 Vector3f Spatial.worldToLocal(Vector3f in, Vector3f store)
          Convert a vector (in) from world coordinate space to this spatials local coordinate space.
 

Methods in com.jme.scene with parameters of type Vector3f
 Vector3f[] QuadMesh.getMeshAsQuadsVertices(Vector3f[] verts)
          Return this mesh object as quads.
 Vector3f[] SharedMesh.getMeshAsTrianglesVertices(Vector3f[] verts)
          retrieves the mesh as triangle vertices of the target mesh.
 Vector3f[] TriMesh.getMeshAsTrianglesVertices(Vector3f[] verts)
          Return this mesh object as triangles.
 void QuadMesh.getQuad(int i, Vector3f[] vertices)
          Stores in the vertices array the vertex values of quad i.
 void SharedMesh.getTriangle(int i, Vector3f[] vertices)
          Stores in the vertices array the vertex values of triangle i.
 void TriMesh.getTriangle(int i, Vector3f[] vertices)
          Stores in the vertices array the vertex values of triangle i.
 Vector3f Spatial.localToWorld(Vector3f in, Vector3f store)
          Convert a vector (in) from this spatials local coordinate space to world coordinate space.
 void Spatial.lookAt(Vector3f position, Vector3f upVector)
          lookAt is a convienence method for auto-setting the local rotation based on a position and an up vector.
static TexCoords TexCoords.makeNew(Vector3f[] coords)
           
 Vector3f TriMesh.randomPointOnTriangles(Vector3f fill, Vector3f work)
          Returns a random point on the surface of a randomly selected triangle on the mesh
 Vector3f Geometry.randomVertex(Vector3f fill)
          randomVertex returns a random vertex from the list of vertices set to this geometry.
 Vector3f SharedMesh.randomVertex(Vector3f fill)
           
 void Spatial.rotateUpTo(Vector3f newUp)
          rotateUpTo is a util function that alters the localrotation to point the Y axis in the direction given by newUp.
 void BezierPatch.setAnchor(int i, int j, Vector3f anchor)
          setAnchor sets a single anchor of the patch.
 void BezierPatch.setAnchors(Vector3f[][] anchors)
          setAnchors sets the control anchors of this patch.
 void Spatial.setLocalScale(Vector3f localScale)
          setLocalScale sets the local scale of this node.
 void Spatial.setLocalTranslation(Vector3f localTranslation)
          setLocalTranslation sets the local translation of this node.
static void QuadMesh.setQuads(Vector3f[] quads)
           
 void ImposterNode.setWorldUpVector(Vector3f worldUpVector)
           
 void Geometry.translatePoints(Vector3f amount)
           
 void ImposterNode.updateCamera(Vector3f eyeLocation)
          Force the texture camera to update its position and direction based on the given eyeLocation
 Vector3f Spatial.worldToLocal(Vector3f in, Vector3f store)
          Convert a vector (in) from world coordinate space to this spatials local coordinate space.
 

Constructors in com.jme.scene with parameters of type Vector3f
BezierPatch(Vector3f[][] anchors)
          Constructor instantiates a new BezierPatch with a given control point grid and a default detail level of zero.
BezierPatch(Vector3f[][] anchors, int detailLevel)
          Constructor instantiates a new BezierPatch with a given control point grid and a given detail level.
Line(java.lang.String name, Vector3f[] vertex, Vector3f[] normal, ColorRGBA[] color, Vector2f[] texture)
          Constructor instantiates a new Line object with a given set of data.
Line(java.lang.String name, Vector3f[] vertex, Vector3f[] normal, ColorRGBA[] color, Vector2f[] texture)
          Constructor instantiates a new Line object with a given set of data.
Point(java.lang.String name, Vector3f[] vertex, Vector3f[] normal, ColorRGBA[] color, Vector2f[] texture)
          Constructor instantiates a new Point object with a given set of data.
Point(java.lang.String name, Vector3f[] vertex, Vector3f[] normal, ColorRGBA[] color, Vector2f[] texture)
          Constructor instantiates a new Point object with a given set of data.
 

Uses of Vector3f in com.jme.scene.geometryinstancing
 

Fields in com.jme.scene.geometryinstancing declared as Vector3f
(package private)  Vector3f GeometryBatchInstance.worldVector
          Vector used to store and calculate world transformations
 

Constructors in com.jme.scene.geometryinstancing with parameters of type Vector3f
GeometryBatchInstanceAttributes(Vector3f translation, Vector3f scale, Quaternion rotation, ColorRGBA color)
           
 

Uses of Vector3f in com.jme.scene.geometryinstancing.instance
 

Fields in com.jme.scene.geometryinstancing.instance declared as Vector3f
protected  Vector3f GeometryInstanceAttributes.scale
           
protected  Vector3f GeometryInstanceAttributes.translation
           
 

Methods in com.jme.scene.geometryinstancing.instance that return Vector3f
 Vector3f GeometryInstanceAttributes.getScale()
           
 Vector3f GeometryInstanceAttributes.getTranslation()
           
 

Methods in com.jme.scene.geometryinstancing.instance with parameters of type Vector3f
 void GeometryInstanceAttributes.setScale(Vector3f scale)
          After using the setScale function, user needs to call the buildMatrices function
 void GeometryInstanceAttributes.setTranslation(Vector3f translation)
          After using the setTranslation function, user needs to call the buildMatrices function
 

Constructors in com.jme.scene.geometryinstancing.instance with parameters of type Vector3f
GeometryInstanceAttributes(Vector3f translation, Vector3f scale, Quaternion rotation)
           
 

Uses of Vector3f in com.jme.scene.shadow
 

Fields in com.jme.scene.shadow declared as Vector3f
protected static Vector3f MeshShadows.compVect
          Static computation field
protected  Vector3f ShadowVolume.direction
           
protected  Vector3f MeshShadows.oldWorldScale
          The world scale of the trimesh at the last mesh construction
protected  Vector3f MeshShadows.oldWorldTranslation
          The world translation of the trimesh at the last mesh construction
protected  Vector3f ShadowVolume.position
           
 

Methods in com.jme.scene.shadow that return Vector3f
 Vector3f ShadowVolume.getDirection()
           
 Vector3f ShadowVolume.getPosition()
           
 

Methods in com.jme.scene.shadow with parameters of type Vector3f
protected  float MeshShadows.getIntersectTime(Plane p, Vector3f p0, Vector3f v)
           
 void ShadowVolume.setDirection(Vector3f direction)
           
 void ShadowVolume.setPosition(Vector3f position)
           
 

Uses of Vector3f in com.jme.scene.shape
 

Fields in com.jme.scene.shape declared as Vector3f
 Vector3f AbstractBox.center
           
protected  Vector3f OrientedBox.center
          Center of the Oriented Box.
 Vector3f Sphere.center
          the center of the sphere
protected  Vector3f OrientedBox.extent
          Extents of the box along the x,y,z axis.
 Vector3f[] OrientedBox.vectorStore
          Vector array used to store the array of 8 corners the box has.
protected  Vector3f OrientedBox.xAxis
          X axis of the Oriented Box.
protected  Vector3f OrientedBox.yAxis
          Y axis of the Oriented Box.
protected  Vector3f OrientedBox.zAxis
          Z axis of the Oriented Box.
 

Methods in com.jme.scene.shape that return Vector3f
 Vector3f[] AbstractBox.computeVertices()
          Deprecated. method will be made protected.
 Vector3f[] RoundedBox.computeVertices()
          Deprecated. this method will be made private.
 Vector3f RoundedBox.getBorder()
           
 Vector3f AbstractBox.getCenter()
          Get the centre point of this box.
 Vector3f Dome.getCenter()
           
 Vector3f OrientedBox.getCenter()
          Returns the center of the box.
 Vector3f Quad.getCenter()
          getCenter returns the center of the Quad.
 Vector3f Sphere.getCenter()
          Returns the center of this sphere.
 Vector3f OrientedBox.getExtent()
          Returns the box's extent vector along the x,y,z.
 Vector3f RoundedBox.getExtent()
           
 Vector3f RoundedBox.getSlope()
           
 Vector3f OrientedBox.getxAxis()
          Deprecated. Use OrientedBox.getXAxis() instead
 Vector3f OrientedBox.getXAxis()
           
 Vector3f OrientedBox.getyAxis()
          Deprecated. Use OrientedBox.getYAxis() instead
 Vector3f OrientedBox.getYAxis()
           
 Vector3f OrientedBox.getzAxis()
          Deprecated. Use OrientedBox.getZAxis() instead
 Vector3f OrientedBox.getZAxis()
           
 

Methods in com.jme.scene.shape with parameters of type Vector3f
 void Capsule.reconstruct(Vector3f top, Vector3f bottom, float radius)
          Deprecated. use @{link Capsule.updateGeometry(Vector3f, Vector3f, float).
 void AbstractBox.setCenter(Vector3f center)
          Deprecated. use AbstractBox.updateGeometry(Vector3f, float, float, float).
 void OrientedBox.setCenter(Vector3f center)
          Deprecated. use #updateGeometry(Vector3f, Vector2f, Vector2f, Vector2f, Vector2f, boolean) instead.
 void Sphere.setCenter(Vector3f aCenter)
          Deprecated. Use Sphere.updateGeometry(Vector3f,int,int,float) instead
 void AbstractBox.setData(Vector3f center, float x, float y, float z)
          Deprecated. use AbstractBox.updateGeometry(Vector3f, float, float, float).
 void Sphere.setData(Vector3f center, int zSamples, int radialSamples, float radius)
          Deprecated. Use Sphere.updateGeometry(Vector3f,int,int,float) instead
 void Dome.setData(Vector3f center, int planes, int radialSamples, float radius, boolean updateBuffers, boolean outsideView)
          Deprecated. use Dome.updateGeometry(Vector3f, int, int, float, boolean).
 void AbstractBox.setData(Vector3f minPoint, Vector3f maxPoint)
          Deprecated. use AbstractBox.updateGeometry(Vector3f, Vector3f).
 void OrientedBox.setExtent(Vector3f extent)
          Deprecated. use #updateGeometry(Vector3f, Vector2f, Vector2f, Vector2f, Vector2f, boolean) instead.
 void OrientedBox.setxAxis(Vector3f xAxis)
          Deprecated. use #updateGeometry(Vector3f, Vector2f, Vector2f, Vector2f, Vector2f, boolean) instead.
 void OrientedBox.setyAxis(Vector3f yAxis)
          Deprecated. use #updateGeometry(Vector3f, Vector2f, Vector2f, Vector2f, Vector2f, boolean) instead.
 void OrientedBox.setzAxis(Vector3f zAxis)
          Deprecated. use #updateGeometry(Vector3f, Vector2f, Vector2f, Vector2f, Vector2f, boolean) instead.
 void Extrusion.updateGeometry(Line shape, java.util.List<Vector3f> path, boolean closed, Vector3f up)
          Update vertex, color, index and texture buffers (0) to contain an extrusion of shape along path.
 void Extrusion.updateGeometry(Line shape, java.util.List<Vector3f> points, int segments, boolean closed, Vector3f up)
          Performs cubic spline interpolation to find a path through the supporting points where the second derivative is zero.
 void Extrusion.updateGeometry(Line shape, java.util.List<Vector3f> points, int segments, Vector3f up)
          Performs cubic spline interpolation to find a path through the supporting points where the second derivative is zero.
 void Extrusion.updateGeometry(Line shape, java.util.List<Vector3f> path, Vector3f up)
          Update vertex, color, index and texture buffers (0) to contain an extrusion of shape along path.
 void AbstractBox.updateGeometry(Vector3f center, float x, float y, float z)
          Rebuilds this box based on a new set of parameters.
 void Sphere.updateGeometry(Vector3f center, int zSamples, int radialSamples, float radius)
          Changes the information of the sphere into the given values.
 void Dome.updateGeometry(Vector3f center, int planes, int radialSamples, float radius, boolean outsideView)
          Rebuilds the dome with a new set of parameters.
 void Sphere.updateGeometry(Vector3f center, int zSamples, int radialSamples, float radius, boolean useEvenSlices)
           
 void OrientedBox.updateGeometry(Vector3f center, Vector2f topRight, Vector2f topLeft, Vector2f bottomRight, Vector2f bottomLeft)
           
 void AbstractBox.updateGeometry(Vector3f minPoint, Vector3f maxPoint)
          Rebuilds this box based on a new set of parameters.
 void Capsule.updateGeometry(Vector3f top, Vector3f bottom, float radius)
          Rebuilds this capsule based on a new set of parameters.
 void RoundedBox.updateGeometry(Vector3f extent, Vector3f border, Vector3f slope)
           
 

Method parameters in com.jme.scene.shape with type arguments of type Vector3f
 void Extrusion.updateGeometry(Line shape, java.util.List<Vector3f> path, boolean closed, Vector3f up)
          Update vertex, color, index and texture buffers (0) to contain an extrusion of shape along path.
 void Extrusion.updateGeometry(Line shape, java.util.List<Vector3f> points, int segments, boolean closed, Vector3f up)
          Performs cubic spline interpolation to find a path through the supporting points where the second derivative is zero.
 void Extrusion.updateGeometry(Line shape, java.util.List<Vector3f> points, int segments, Vector3f up)
          Performs cubic spline interpolation to find a path through the supporting points where the second derivative is zero.
 void Extrusion.updateGeometry(Line shape, java.util.List<Vector3f> path, Vector3f up)
          Update vertex, color, index and texture buffers (0) to contain an extrusion of shape along path.
 

Constructors in com.jme.scene.shape with parameters of type Vector3f
Box(java.lang.String name, Vector3f center, float x, float y, float z)
          Creates a new box.
Box(java.lang.String name, Vector3f min, Vector3f max)
          Constructor instantiates a new Box object.
Dome(java.lang.String name, Vector3f center, int planes, int radialSamples, float radius)
          Constructs a dome.
Dome(java.lang.String name, Vector3f center, int planes, int radialSamples, float radius, boolean outsideView)
          Constructs a dome.
Extrusion(Line shape, java.util.List<Vector3f> path, Vector3f up)
          Convenience constructor.
Extrusion(java.lang.String name, Line shape, java.util.List<Vector3f> path, Vector3f up)
          Convenience constructor.
MultiFaceBox(java.lang.String name, Vector3f center, float xExtent, float yExtent, float zExtent)
           
MultiFaceBox(java.lang.String name, Vector3f min, Vector3f max)
           
OrientedBox(java.lang.String name, Vector3f center, Vector2f topRight, Vector2f topLeft, Vector2f bottomRight, Vector2f bottomLeft)
          Create a new oriented box.
RoundedBox(java.lang.String name, Vector3f extent)
           
RoundedBox(java.lang.String name, Vector3f extent, Vector3f border, Vector3f slope)
           
Sphere(java.lang.String name, Vector3f center, int zSamples, int radialSamples, float radius)
          Constructs a sphere.
Sphere(java.lang.String name, Vector3f center, int zSamples, int radialSamples, float radius, boolean useEvenSlices)
          Constructs a sphere.
StripBox(java.lang.String name, Vector3f center, float xExtent, float yExtent, float zExtent)
          Constructs a new box.
StripBox(java.lang.String name, Vector3f min, Vector3f max)
          Constructor instantiates a new StripBox object.
 

Constructor parameters in com.jme.scene.shape with type arguments of type Vector3f
Extrusion(Line shape, java.util.List<Vector3f> path, Vector3f up)
          Convenience constructor.
Extrusion(java.lang.String name, Line shape, java.util.List<Vector3f> path, Vector3f up)
          Convenience constructor.
 

Uses of Vector3f in com.jme.scene.state
 

Methods in com.jme.scene.state with parameters of type Vector3f
 void GLSLShaderObjectsState.setUniform(java.lang.String name, Vector3f value)
          Set an uniform value for this shader object.
 

Uses of Vector3f in com.jme.scene.state.jogl.records
 

Fields in com.jme.scene.state.jogl.records declared as Vector3f
 Vector3f TextureUnitRecord.texScale
           
 Vector3f TextureStateRecord.tmp_rotation1
          temporary rotation axis vector to flatline memory usage.
 

Uses of Vector3f in com.jme.scene.state.lwjgl.records
 

Fields in com.jme.scene.state.lwjgl.records declared as Vector3f
 Vector3f TextureUnitRecord.texScale
           
 Vector3f TextureStateRecord.tmp_rotation1
          temporary rotation axis vector to flatline memory usage.
 

Uses of Vector3f in com.jme.system
 

Methods in com.jme.system that return Vector3f
 Vector3f DisplaySystem.getScreenCoordinates(Vector3f worldPosition)
          Translate world to screen coordinates
 Vector3f DisplaySystem.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
          Translate world to screen coordinates
 Vector3f DisplaySystem.getWorldCoordinates(Vector2f screenPosition, float zPos)
          Translate screen to world coordinates.
 Vector3f DisplaySystem.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
          Translate screen to world coordinates.
 

Methods in com.jme.system with parameters of type Vector3f
 Vector3f DisplaySystem.getScreenCoordinates(Vector3f worldPosition)
          Translate world to screen coordinates
 Vector3f DisplaySystem.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
          Translate world to screen coordinates
 Vector3f DisplaySystem.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
          Translate screen to world coordinates.
 

Uses of Vector3f in com.jme.system.dummy
 

Methods in com.jme.system.dummy that return Vector3f
 Vector3f DummyDisplaySystem.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
           
 Vector3f DummyDisplaySystem.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
           
 

Methods in com.jme.system.dummy with parameters of type Vector3f
 Vector3f DummyDisplaySystem.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
           
 Vector3f DummyDisplaySystem.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
           
 

Uses of Vector3f in com.jme.util
 

Fields in com.jme.util declared as Vector3f
(package private)  Vector3f BumpMapColorController.BumpStore.oldScale
           
(package private)  Vector3f BumpMapColorController.BumpStore.oldTrans
           
 

Uses of Vector3f in com.jme.util.geom
 

Fields in com.jme.util.geom declared as Vector3f
 Vector3f VertexData.coord
           
 Vector3f VertexData.normal
           
 

Methods in com.jme.util.geom that return Vector3f
static Vector3f[] BufferUtils.getVector3Array(java.nio.FloatBuffer buff)
          Generates a Vector3f array from the given FloatBuffer.
 

Methods in com.jme.util.geom with parameters of type Vector3f
static void BufferUtils.addInBuffer(Vector3f toAdd, java.nio.FloatBuffer buf, int index)
          Add to a Vector3f in-buffer.
static java.nio.FloatBuffer BufferUtils.createFloatBuffer(Vector3f... data)
          Generate a new FloatBuffer using the given array of Vector3f objects.
static boolean BufferUtils.equals(Vector3f check, java.nio.FloatBuffer buf, int index)
          Checks to see if the given Vector3f is equals to the data stored in the buffer at the given data index.
static void BufferUtils.multInBuffer(Vector3f toMult, java.nio.FloatBuffer buf, int index)
          Multiply and store a Vector3f in-buffer.
static void BufferUtils.populateFromBuffer(Vector3f vector, java.nio.FloatBuffer buf, int index)
          Updates the values of the given vector from the specified buffer at the index provided.
static void BufferUtils.setInBuffer(Vector3f vector, java.nio.FloatBuffer buf, int index)
          Sets the data contained in the given Vector3F into the FloatBuffer at the specified index.
 

Constructors in com.jme.util.geom with parameters of type Vector3f
VertKey(Vector3f vert, Vector3f norm, ColorRGBA color, Vector2f[] texs, int options)
           
 

Uses of Vector3f in com.jme.util.stat.graph
 

Fields in com.jme.util.stat.graph with type parameters of type Vector3f
 java.util.ArrayList<Vector3f> LineGrapher.LineEntry.verts
           
 java.util.ArrayList<Vector3f> TimedAreaGrapher.AreaEntry.verts
           
 

Uses of Vector3f in com.jmex.audio
 

Methods in com.jmex.audio that return Vector3f
 Vector3f AudioTrack.getCurrVelocity()
           
 Vector3f Ear.getCurrVelocity()
           
 Vector3f Ear.getFacingVector()
           
 Vector3f Ear.getPosition()
           
 Vector3f RangedAudioTracker.getPosition()
           
 Vector3f Ear.getUpVector()
           
 Vector3f AudioTrack.getWorldPosition()
           
 

Methods in com.jmex.audio with parameters of type Vector3f
 void Ear.EarTracker.applyOrientation(Vector3f up, Vector3f facing)
           
 void Ear.EarTracker.applyPosition(Vector3f position, Vector3f velocity, float dt)
           
 void RangedAudioTracker.checkTrackAudible(Vector3f from)
           
 void AudioTrack.setCurrVelocity(Vector3f currVelocity)
           
 void Ear.setCurrVelocity(Vector3f currVelocity)
           
 void Ear.setFacingVector(Vector3f facingVector)
           
 void Ear.setPosition(Vector3f position)
           
 void RangedAudioTracker.setPosition(Vector3f position)
           
 void Ear.setUpVector(Vector3f upVector)
           
 void AudioTrack.setWorldPosition(Vector3f position)
           
 

Uses of Vector3f in com.jmex.editors.swing.widget
 

Methods in com.jmex.editors.swing.widget that return Vector3f
 Vector3f SphericalUnitVectorPanel.getValue()
           
 Vector3f VectorPanel.getValue()
           
 

Methods in com.jmex.editors.swing.widget with parameters of type Vector3f
 void SphericalUnitVectorPanel.setValue(Vector3f value)
           
 void VectorPanel.setValue(Vector3f value)
           
 

Uses of Vector3f in com.jmex.effects
 

Fields in com.jmex.effects declared as Vector3f
 Vector3f TrailMesh.TrailData.interpolatedPosition
           
 Vector3f TrailMesh.TrailData.position
           
 Vector3f TrailMesh.TrailData.tangent
           
 

Methods in com.jmex.effects with parameters of type Vector3f
static void ProjectedTextureUtil.matrixLookAt(Vector3f location, Vector3f at, Vector3f up, Matrix4f result)
          Populates a Matrix4f with the proper look at transformations from the ModelView matrix.
 void TrailMesh.resetPosition(Vector3f position)
           
 void TrailMesh.setTrailFront(Vector3f position, float width, float tpf)
          Update the front position of the trail.
 void TrailMesh.setTrailFront(Vector3f position, Vector3f tangent, float width, float tpf)
          Update the front position of the trail.
 void TrailMesh.update(Vector3f camPos)
          Update the vertices of the trail.
 void FlareQuad.updatePosition(Vector3f flarePoint, Vector2f midPoint)
          Updates worldTranslation of this FlareQuad.
static void ProjectedTextureUtil.updateProjectedTexture(Texture texture, float fov, float aspect, float near, float far, Vector3f pos, Vector3f aim, Vector3f up)
          Updated texture matrix on the provided texture
 

Uses of Vector3f in com.jmex.effects.cloth
 

Fields in com.jmex.effects.cloth declared as Vector3f
protected  Vector3f CollidingClothPatch.calcTemp
           
 

Methods in com.jmex.effects.cloth that return Vector3f
protected  Vector3f ClothPatch.getTriangleNormal(int vert1, int vert2, int vert3, Vector3f store)
          Get the normal of the triangle defined by the given vertices.
 

Methods in com.jmex.effects.cloth with parameters of type Vector3f
static SpringPointForce ClothUtils.createBasicWind(float windStr, Vector3f windDir, boolean addRandom)
          Creates a basic wind that always blows in a single direction.
protected  Vector3f ClothPatch.getTriangleNormal(int vert1, int vert2, int vert3, Vector3f store)
          Get the normal of the triangle defined by the given vertices.
protected  void ClothPatch.initCloth(float nodeMass, Vector3f upperLeft, Vector3f lowerLeft, Vector3f lowerRight, Vector3f upperRight)
          Initialize the values of the vertex, normal and texture[0] arrays.
 

Constructors in com.jmex.effects.cloth with parameters of type Vector3f
ClothPatch(java.lang.String name, int nodesX, int nodesY, Vector3f upperLeft, Vector3f lowerLeft, Vector3f lowerRight, Vector3f upperRight, float nodeMass)
           
 

Uses of Vector3f in com.jmex.effects.particles
 

Fields in com.jmex.effects.particles declared as Vector3f
protected  Vector3f ParticleSystem.absUpVector
           
protected  Vector3f ParticleSystem.abUpMinUp
           
protected  Vector3f ParticleSystem.emissionDirection
           
protected  Vector3f ParticleSystem.invScale
           
protected  Vector3f ParticleSystem.leftVector
           
protected  Vector3f ParticleSystem.oldEmit
          Setup the rotation matrix used to determine initial particle velocity based on emission angle and emission direction.
protected  Vector3f ParticleSystem.originCenter
           
protected  Vector3f ParticleSystem.originOffset
           
protected  Vector3f ParticleSystem.upVector
           
protected  Vector3f ParticleSystem.upXemit
           
protected static Vector3f ParticleSystem.workVect3
           
protected  Vector3f ParticleSystem.worldEmit
           
 

Methods in com.jmex.effects.particles that return Vector3f
 Vector3f ParticleSystem.getEmissionDirection()
           
 Vector3f SimpleParticleInfluenceFactory.BasicGravity.getGravityForce()
           
 Vector3f ParticleSystem.getInvScale()
           
 Vector3f ParticleSystem.getLeftVector()
           
 Vector3f FloorInfluence.getNormal()
           
 Vector3f ParticleSystem.getOriginCenter()
           
 Vector3f ParticleSystem.getOriginOffset()
          Get the offset point set in this manager.
 Vector3f FloorInfluence.getPos()
           
 Vector3f Particle.getPosition()
           
protected  Vector3f ParticleSystem.getRandomVelocity(Vector3f pSpeed)
          Generate a random velocity within the parameters of max angle and the rotation matrix.
 Vector3f SwarmInfluence.getSwarmOffset()
           
 Vector3f ParticleSystem.getUpVector()
           
 Vector3f Particle.getVelocity()
           
 Vector3f SimpleParticleInfluenceFactory.BasicWind.getWindDirection()
           
 Vector3f ParticleSystem.getWorldEmit()
           
 

Methods in com.jmex.effects.particles with parameters of type Vector3f
static ParticleInfluence SimpleParticleInfluenceFactory.createBasicGravity(Vector3f gravForce, boolean rotateWithScene)
          Create a basic gravitational force.
static ParticleInfluence SimpleParticleInfluenceFactory.createBasicWind(float windStr, Vector3f windDir, boolean addRandom, boolean rotateWithScene)
          Creates a basic wind that always blows in a single direction.
protected  Vector3f ParticleSystem.getRandomVelocity(Vector3f pSpeed)
          Generate a random velocity within the parameters of max angle and the rotation matrix.
 void Particle.init(Vector3f velocity, Vector3f position, float lifeSpan)
          Cause this particle to reset it's color, age and size per the parent's settings.
protected  void ParticleSystem.rotateVectorSpeed(Vector3f pSpeed)
          Apply the rotation matrix to a given vector representing a particle velocity.
 void ParticleSystem.setEmissionDirection(Vector3f emissionDirection)
           
 void SimpleParticleInfluenceFactory.BasicGravity.setGravityForce(Vector3f gravForce)
           
 void ParticleSystem.setInvScale(Vector3f invScale)
           
 void ParticleSystem.setLeftVector(Vector3f leftVector)
           
 void FloorInfluence.setNormal(Vector3f normal)
           
 void ParticleSystem.setOriginOffset(Vector3f offset)
          Set the offset for any new particles created (or recreated) by this manager.
 void FloorInfluence.setPos(Vector3f pos)
           
 void Particle.setPosition(Vector3f position)
          Set the position of the particle in space.
 void SwarmInfluence.setSwarmOffset(Vector3f offset)
           
 void ParticleSystem.setUpVector(Vector3f upVector)
           
 void Particle.setVelocity(Vector3f velocity)
          Set the current velocity of this particle
 void SimpleParticleInfluenceFactory.BasicWind.setWindDirection(Vector3f windDir)
           
 void ParticleSystem.setWorldEmit(Vector3f worldEmit)
           
 

Constructors in com.jmex.effects.particles with parameters of type Vector3f
FloorInfluence(Vector3f pos, Vector3f normal, float bouncyness)
           
SimpleParticleInfluenceFactory.BasicGravity(Vector3f gravForce, boolean rotateWithScene)
           
SimpleParticleInfluenceFactory.BasicWind(float windStr, Vector3f windDir, boolean addRandom, boolean rotateWithScene)
           
SwarmInfluence(Vector3f offset, float swarmRange)
           
 

Uses of Vector3f in com.jmex.effects.water
 

Fields in com.jmex.effects.water declared as Vector3f
(package private)  Vector3f ProjectedGrid.adjacentPoint
           
protected  Vector3f WaterRenderPass.binormal
           
protected  Vector3f WaterRenderPass.calcVect
           
(package private)  Vector3f ProjectedGrid.oppositePoint
          buildNormals calculates the normals of each vertex that makes up the block of terrain.
(package private)  Vector3f ProjectedGrid.rootPoint
           
protected  Vector3f WaterRenderPass.tangent
           
(package private)  Vector3f ProjectedGrid.tempNorm
           
 

Methods in com.jmex.effects.water that return Vector3f
 Vector3f WaterRenderPass.getBinormal()
           
 Vector3f WaterRenderPass.getNormal()
           
 Vector3f ProjectedGrid.getSurfaceNormal(float x, float z, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f ProjectedGrid.getSurfaceNormal(Vector2f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f ProjectedGrid.getSurfaceNormal(Vector3f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f WaterRenderPass.getTangent()
           
 

Methods in com.jmex.effects.water with parameters of type Vector3f
 Vector3f ProjectedGrid.getSurfaceNormal(float x, float z, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f ProjectedGrid.getSurfaceNormal(Vector2f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f ProjectedGrid.getSurfaceNormal(Vector3f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 void WaterRenderPass.setBinormal(Vector3f binormal)
           
 void WaterRenderPass.setNormal(Vector3f normal)
          Set the normal of the waterplane(Used for reflecting the camera for rendering reflection)
 void WaterRenderPass.setTangent(Vector3f tangent)
           
 

Uses of Vector3f in com.jmex.font3d
 

Fields in com.jmex.font3d declared as Vector3f
(package private)  Vector3f[] Glyph3D.outline_normals
           
 

Methods in com.jmex.font3d that return Vector3f
 Vector3f[] Glyph3D.getOutlineNormals()
           
 

Methods in com.jmex.font3d with parameters of type Vector3f
 void JmeText.setLocalScale(Vector3f trans)
           
 void JmeText.setLocalTranslation(Vector3f trans)
           
 

Uses of Vector3f in com.jmex.font3d.effects
 

Constructors in com.jmex.font3d.effects with parameters of type Vector3f
Font3DGradient(Vector3f direction, ColorRGBA start_color, ColorRGBA end_color)
           
 

Uses of Vector3f in com.jmex.font3d.math
 

Fields in com.jmex.font3d.math declared as Vector3f
(package private)  Vector3f PlanarVertex.point
           
 

Methods in com.jmex.font3d.math that return Vector3f
 Vector3f PlanarVertex.getPoint()
           
 

Methods in com.jmex.font3d.math that return types with arguments of type Vector3f
 java.util.List<Vector3f> ClosedPolygon.getPoints()
           
 

Methods in com.jmex.font3d.math with parameters of type Vector3f
 void ClosedPolygon.addPoint(Vector3f point)
           
 Vertex DoublyConnectedEdgeList.addVertex(Vector3f p)
           
abstract  Vertex DoublyConnectedEdgeList.createVertex(int index, Vector3f p)
           
 TriangulationVertex Triangulator.createVertex(int index, Vector3f p)
           
 

Constructors in com.jmex.font3d.math with parameters of type Vector3f
PlanarVertex(int i, Vector3f p)
           
TriangulationVertex(int i, Vector3f p)
           
 

Uses of Vector3f in com.jmex.model
 

Fields in com.jmex.model declared as Vector3f
 Vector3f[] JointMesh.originalNormal
           
 Vector3f[] JointMesh.originalVertex
           
 

Methods in com.jmex.model that return Vector3f
static Vector3f XMLUtil.getVec3Attribute(org.w3c.dom.Node node, java.lang.String name)
           
static Vector3f XMLUtil.getVec3Attribute(org.w3c.dom.Node node, java.lang.String name, Vector3f defVal)
           
 

Methods in com.jmex.model with parameters of type Vector3f
static Vector3f XMLUtil.getVec3Attribute(org.w3c.dom.Node node, java.lang.String name, Vector3f defVal)
           
 

Uses of Vector3f in com.jmex.model.animation
 

Fields in com.jmex.model.animation declared as Vector3f
 Vector3f[] PointInTime.jointTranslation
          Array of translations for this PointInTime.
 

Methods in com.jmex.model.animation with parameters of type Vector3f
 void JointController.setTranslation(int jointNumber, float time, Vector3f trans)
          Tells JointController that at time time the joint jointNumber will translate to x,y,z relative to its parent
(package private)  void PointInTime.setTranslation(int jointIndex, Vector3f v)
           
 

Uses of Vector3f in com.jmex.model.converters
 

Methods in com.jmex.model.converters with parameters of type Vector3f
(package private)  void Md3ToJme.readVecFloat(Vector3f in)
           
 

Uses of Vector3f in com.jmex.model.converters.maxutils
 

Fields in com.jmex.model.converters.maxutils declared as Vector3f
(package private)  Vector3f KeyframeInfoChunk.BBoxMax
           
(package private)  Vector3f KeyframeInfoChunk.BBoxMin
           
(package private)  Vector3f CameraChunk.camPos
           
(package private)  Vector3f LightChunk.myLoc
           
(package private)  Vector3f EditableObjectChunk.oConstPlanes
           
(package private)  Vector3f TriMeshChunk.origin
           
(package private)  Vector3f KeyframeInfoChunk.pivot
          pivot location relative to object origin
 Vector3f KeyframeInfoChunk.KeyPointInTime.position
           
 Vector3f KeyframeInfoChunk.KeyPointInTime.scale
           
(package private)  Vector3f SpotLightChunk.target
           
(package private)  Vector3f CameraChunk.targetLoc
           
(package private)  Vector3f[] TriMeshChunk.vertexes
           
 

Uses of Vector3f in com.jmex.model.ogrexml.anim
 

Methods in com.jmex.model.ogrexml.anim with parameters of type Vector3f
(package private)  void Bone.setAnimTransforms(Vector3f translation, Quaternion rotation)
           
(package private)  void Bone.setAnimTransforms(Vector3f translation, Quaternion rotation, Vector3f scale)
          Sets the local animation transform of this bone.
(package private)  void Bone.setBindTransforms(Vector3f translation, Quaternion rotation)
           
(package private)  void Bone.setBindTransforms(Vector3f translation, Quaternion rotation, Vector3f scale)
          Sets local bind transform for bone.
 void Bone.setUserTransforms(Vector3f translation, Quaternion rotation, Vector3f scale)
          Set user transform.
 

Constructors in com.jmex.model.ogrexml.anim with parameters of type Vector3f
BoneTrack(int targetBoneIndex, float[] times, Vector3f[] translations, Quaternion[] rotations)
           
Pose(java.lang.String name, int targetMeshIndex, Vector3f[] offsets, int[] indices)
           
 

Uses of Vector3f in com.jmex.terrain
 

Methods in com.jmex.terrain that return Vector3f
 Vector3f TerrainBlock.getStepScale()
          Returns the step scale that stretches the height map.
 Vector3f TerrainPage.getStepScale()
          Returns the step scale that stretches the height map.
 Vector3f TerrainBlock.getSurfaceNormal(float x, float z, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainPage.getSurfaceNormal(float x, float z, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainBlock.getSurfaceNormal(Vector2f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainPage.getSurfaceNormal(Vector2f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainBlock.getSurfaceNormal(Vector3f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainPage.getSurfaceNormal(Vector3f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 

Methods in com.jmex.terrain with parameters of type Vector3f
 float TerrainBlock.getHeight(Vector3f position)
          getHeight returns the height of an arbitrary point on the terrain.
 float TerrainPage.getHeight(Vector3f position)
          getHeight returns the height of an arbitrary point on the terrain.
 float TerrainBlock.getHeightFromWorld(Vector3f position)
          getHeightFromWorld returns the height of an arbitrary point on the terrain when given world coordinates.
 float TerrainPage.getHeightFromWorld(Vector3f position)
          getHeightFromWorld returns the height of an arbitrary point on the terrain when given world coordinates.
 Vector3f TerrainBlock.getSurfaceNormal(float x, float z, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainPage.getSurfaceNormal(float x, float z, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainBlock.getSurfaceNormal(Vector2f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainPage.getSurfaceNormal(Vector2f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainBlock.getSurfaceNormal(Vector3f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 Vector3f TerrainPage.getSurfaceNormal(Vector3f position, Vector3f store)
          getSurfaceNormal returns the normal of an arbitrary point on the terrain.
 void TerrainBlock.setStepScale(Vector3f stepScale)
          Sets the step scale of this terrain block's height map.
 void TerrainPage.setStepScale(Vector3f stepScale)
          Sets the step scale of this terrain page's height map.
 

Constructors in com.jmex.terrain with parameters of type Vector3f
TerrainBlock(java.lang.String name, int size, Vector3f stepScale, float[] heightMap, Vector3f origin)
          Constructor instantiates a new TerrainBlock object.
TerrainBlock(java.lang.String name, int size, Vector3f stepScale, float[] heightMap, Vector3f origin, int totalSize, Vector2f offset, float offsetAmount)
          Constructor instantiates a new TerrainBlock object.
TerrainPage(java.lang.String name, int blockSize, int size, Vector3f stepScale, float[] heightMap)
          Constructor instantiates a new TerrainPage object.
TerrainPage(java.lang.String name, int blockSize, int size, Vector3f stepScale, float[] heightMap, int totalSize, Vector2f offset, float offsetAmount)
          Constructor instantiates a new TerrainPage object.
 

Uses of Vector3f in com.jmex.terrain.util
 

Fields in com.jmex.terrain.util declared as Vector3f
protected  Vector3f AbstractBresenhamTracer._gridOrigin
           
protected  Vector3f AbstractBresenhamTracer._gridSpacing
           
protected  Vector3f AbstractBresenhamTracer._rayLocation
           
 

Methods in com.jmex.terrain.util that return Vector3f
 Vector3f AbstractBresenhamTracer.getGridOrigin()
           
 Vector3f AbstractBresenhamTracer.getGridSpacing()
           
 Vector3f BresenhamTerrainPicker.getTerrainIntersection(Ray worldPick, Vector3f store)
          Ask for the point of intersection between the given ray and the terrain.
 

Methods in com.jmex.terrain.util with parameters of type Vector3f
protected  boolean BresenhamTerrainPicker.checkTriangles(float gridX, float gridY, Ray pick, Vector3f intersection, TerrainBlock block)
          Check the two triangles of a given grid space for intersection.
protected  int BresenhamTerrainPicker.findClosestHeightIndex(Vector3f position, TerrainBlock block)
          Finds the closest height point to a position.
 Vector3f BresenhamTerrainPicker.getTerrainIntersection(Ray worldPick, Vector3f store)
          Ask for the point of intersection between the given ray and the terrain.
 void AbstractBresenhamTracer.setGridOrigin(Vector3f origin)
          Set the world origin of our grid.
 void AbstractBresenhamTracer.setGridSpacing(Vector3f spacing)
          Set the world spacing (scale) of our grid.