Uses of Class
com.jme3.math.Vector3f

Packages that use Vector3f
com.jme3.animation The com.jme3.animation package contains various classes for managing animation inside a jME3 application. 
com.jme3.audio   
com.jme3.bounding   
com.jme3.bullet   
com.jme3.bullet.collision   
com.jme3.bullet.collision.shapes   
com.jme3.bullet.collision.shapes.infos   
com.jme3.bullet.control   
com.jme3.bullet.control.ragdoll   
com.jme3.bullet.joints   
com.jme3.bullet.joints.motors   
com.jme3.bullet.objects   
com.jme3.bullet.objects.infos   
com.jme3.bullet.util   
com.jme3.cinematic   
com.jme3.cinematic.events   
com.jme3.collision   
com.jme3.collision.bih   
com.jme3.effect The com.jme3.effect package allows particle emitter effects to be used with a jME3 application. 
com.jme3.effect.influencers   
com.jme3.effect.shapes   
com.jme3.input The com.jme3.input package is used for all input handling in jMonkeyEngine. 
com.jme3.light The com.jme3.light package contains various lights that can be placed in a scene. 
com.jme3.material The com.jme3.material package contains classes for manipulating jMonkeyEngine materials. 
com.jme3.math The com.jme3.math package provides mathematic data structures and utilities which are used by the rest of the engine. 
com.jme3.network.serializing.serializers   
com.jme3.post.filters   
com.jme3.renderer The com.jme3.renderer package provides classes responsible for rendering. 
com.jme3.scene The com.jme3.input package contains the scene graph implementation in jMonkeyEngine. 
com.jme3.scene.debug   
com.jme3.scene.plugins   
com.jme3.scene.plugins.blender.animations   
com.jme3.scene.plugins.blender.curves   
com.jme3.scene.plugins.blender.objects   
com.jme3.scene.plugins.blender.textures   
com.jme3.scene.shape   
com.jme3.shadow   
com.jme3.terrain   
com.jme3.terrain.geomipmap   
com.jme3.terrain.geomipmap.grid   
com.jme3.terrain.geomipmap.lodcalc   
com.jme3.terrain.geomipmap.picking   
com.jme3.terrain.heightmap   
com.jme3.util   
com.jme3.util.xml   
com.jme3.water   
jme3tools.navigation   
jme3tools.optimize   
 

Uses of Vector3f in com.jme3.animation
 

Fields in com.jme3.animation declared as Vector3f
protected  Vector3f[] AnimationFactory.keyFramesScale
           
protected  Vector3f[] AnimationFactory.keyFramesTranslation
          The map of keyFrames to compute the animation.
protected  Vector3f[] AnimationFactory.scales
          scales array for this animation
protected  Vector3f[] AnimationFactory.translations
          Translation array for this animation
 

Methods in com.jme3.animation that return Vector3f
protected  Vector3f CompactVector3Array.deserialize(int i, Vector3f store)
           
 Vector3f Bone.getLocalPosition()
          Returns the local position of the bone, relative to the parent bone.
 Vector3f Bone.getLocalScale()
          Returns the local scale of the bone, relative to the parent bone.
 Vector3f Bone.getModelSpacePosition()
          Returns the position of the bone in model space.
 Vector3f Bone.getModelSpaceScale()
          Returns the scale of the bone in model space.
 Vector3f[] BoneTrack.getScales()
          returns the array of scales for this track
 Vector3f[] SpatialTrack.getScales()
           
 Vector3f[] BoneTrack.getTranslations()
          returns the array of translations of this track
 Vector3f[] SpatialTrack.getTranslations()
           
 Vector3f Bone.getWorldBindInversePosition()
          Returns the inverse world bind pose position.
 Vector3f Bone.getWorldBindInverseScale()
          Returns the inverse world bind pose scale.
 Vector3f Bone.getWorldBindPosition()
          Returns the world bind pose position.
 Vector3f Bone.getWorldBindScale()
          Returns the world bind pose scale.
 

Methods in com.jme3.animation that return types with arguments of type Vector3f
protected  java.lang.Class<Vector3f> CompactVector3Array.getElementClass()
           
 

Methods in com.jme3.animation with parameters of type Vector3f
 void AnimationFactory.addKeyFrameScale(int keyFrameIndex, Vector3f scale)
          Adds a key frame for the given scale at the given keyFrame index
 void AnimationFactory.addKeyFrameTranslation(int keyFrameIndex, Vector3f translation)
          Adds a key frame for the given translation at the given keyFrame index
 void AnimationFactory.addTimeScale(float time, Vector3f scale)
          Adds a key frame for the given scale at the given time
 void AnimationFactory.addTimeTranslation(float time, Vector3f translation)
          Adds a key frame for the given translation at the given time
protected  Vector3f CompactVector3Array.deserialize(int i, Vector3f store)
           
 Transform Bone.getCombinedTransform(Vector3f position, Quaternion rotation)
          Returns the local transform of this bone combined with the given position and rotation
protected  void CompactVector3Array.serialize(int i, Vector3f store)
           
 void Bone.setBindTransforms(Vector3f translation, Quaternion rotation, Vector3f scale)
          Sets local bind transform for bone.
 void BoneTrack.setKeyframes(float[] times, Vector3f[] translations, Quaternion[] rotations)
          Set the translations and rotations for this bone track
 void BoneTrack.setKeyframes(float[] times, Vector3f[] translations, Quaternion[] rotations, Vector3f[] scales)
          Set the translations, rotations and scales for this bone track
 void BoneTrack.setKeyframes(float[] times, Vector3f[] translations, Quaternion[] rotations, Vector3f[] scales)
          Set the translations, rotations and scales for this bone track
 void SpatialTrack.setKeyframes(float[] times, Vector3f[] translations, Quaternion[] rotations, Vector3f[] scales)
          Set the translations, rotations and scales for this track.
 void SpatialTrack.setKeyframes(float[] times, Vector3f[] translations, Quaternion[] rotations, Vector3f[] scales)
          Set the translations, rotations and scales for this track.
 void Bone.setUserTransforms(Vector3f translation, Quaternion rotation, Vector3f scale)
          Sets user transform.
 void Bone.setUserTransformsWorld(Vector3f translation, Quaternion rotation)
          Must update all bones in skeleton for this to work.
 

Constructors in com.jme3.animation with parameters of type Vector3f
BoneTrack(int targetBoneIndex, float[] times, Vector3f[] translations, Quaternion[] rotations)
          Creates a bone track for the given bone index
BoneTrack(int targetBoneIndex, float[] times, Vector3f[] translations, Quaternion[] rotations, Vector3f[] scales)
          Creates a bone track for the given bone index
BoneTrack(int targetBoneIndex, float[] times, Vector3f[] translations, Quaternion[] rotations, Vector3f[] scales)
          Creates a bone track for the given bone index
Pose(java.lang.String name, int targetMeshIndex, Vector3f[] offsets, int[] indices)
           
SpatialTrack(float[] times, Vector3f[] translations, Quaternion[] rotations, Vector3f[] scales)
          Creates a spatial track for the given track data.
SpatialTrack(float[] times, Vector3f[] translations, Quaternion[] rotations, Vector3f[] scales)
          Creates a spatial track for the given track data.
 

Uses of Vector3f in com.jme3.audio
 

Fields in com.jme3.audio declared as Vector3f
protected  Vector3f AudioNode.direction
           
protected  Vector3f AudioNode.velocity
           
 

Methods in com.jme3.audio that return Vector3f
 Vector3f AudioNode.getDirection()
           
 Vector3f Listener.getDirection()
           
 Vector3f Listener.getLeft()
           
 Vector3f Listener.getLocation()
           
 Vector3f Listener.getUp()
           
 Vector3f AudioNode.getVelocity()
           
 Vector3f Listener.getVelocity()
           
 

Methods in com.jme3.audio with parameters of type Vector3f
 void AudioNode.setDirection(Vector3f direction)
          Set the direction of this audio node.
 void Listener.setLocation(Vector3f location)
           
 void AudioNode.setVelocity(Vector3f velocity)
          Set the velocity of the audio node.
 void Listener.setVelocity(Vector3f velocity)
           
 

Uses of Vector3f in com.jme3.bounding
 

Fields in com.jme3.bounding declared as Vector3f
protected  Vector3f BoundingVolume.center
           
 

Methods in com.jme3.bounding that return Vector3f
 Vector3f BoundingVolume.getCenter()
           
 Vector3f BoundingVolume.getCenter(Vector3f store)
           
 Vector3f BoundingBox.getExtent(Vector3f store)
          Query extent.
 Vector3f BoundingBox.getMax(Vector3f store)
           
 Vector3f BoundingBox.getMin(Vector3f store)
           
 

Methods in com.jme3.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.
static void BoundingBox.checkMinMax(Vector3f min, Vector3f max, Vector3f point)
           
 boolean BoundingBox.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.
 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 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.
 Vector3f BoundingVolume.getCenter(Vector3f store)
           
 Vector3f BoundingBox.getExtent(Vector3f store)
          Query extent.
 Vector3f BoundingBox.getMax(Vector3f store)
           
 Vector3f BoundingBox.getMin(Vector3f store)
           
static boolean Intersection.intersect(BoundingBox bbox, Vector3f v1, Vector3f v2, Vector3f v3)
           
 boolean BoundingBox.intersects(Vector3f point)
           
 boolean BoundingSphere.intersects(Vector3f point)
           
abstract  boolean BoundingVolume.intersects(Vector3f point)
          Determines if a given point intersects (touches or is inside) this bounding volume.
 boolean BoundingBox.intersects(Vector3f v1, Vector3f v2, Vector3f v3)
          C code ported from http://www.cs.lth.se/home/Tomas_Akenine_Moller/code/tribox3.txt
 void BoundingVolume.setCenter(Vector3f newCenter)
           
 void BoundingBox.setMinMax(Vector3f min, Vector3f max)
           
 

Constructors in com.jme3.bounding with parameters of type Vector3f
BoundingBox(Vector3f c, float x, float y, float z)
          Contstructor instantiates a new BoundingBox object with given specs.
BoundingBox(Vector3f min, Vector3f max)
           
BoundingSphere(float r, Vector3f c)
          Constructor instantiates a new BoundingSphere object.
BoundingVolume(Vector3f center)
           
 

Uses of Vector3f in com.jme3.bullet
 

Fields in com.jme3.bullet declared as Vector3f
protected  Vector3f BulletAppState.worldMax
           
protected  Vector3f BulletAppState.worldMin
           
 

Methods in com.jme3.bullet that return Vector3f
 Vector3f PhysicsSpace.getWorldMax()
           
 Vector3f PhysicsSpace.getWorldMin()
           
 

Methods in com.jme3.bullet with parameters of type Vector3f
 void PhysicsSpace.rayTest_native(Vector3f from, Vector3f to, long physicsSpaceId, java.util.List<PhysicsRayTestResult> results)
           
 java.util.List PhysicsSpace.rayTest(Vector3f from, Vector3f to)
          Performs a ray collision test and returns the results as a list of PhysicsRayTestResults
 java.util.List<PhysicsRayTestResult> PhysicsSpace.rayTest(Vector3f from, Vector3f to, java.util.List<PhysicsRayTestResult> results)
          Performs a ray collision test and returns the results as a list of PhysicsRayTestResults
 void PhysicsSpace.setGravity(Vector3f gravity)
          Sets the gravity of the PhysicsSpace, set before adding physics objects!
 void PhysicsSpace.setWorldMax(Vector3f worldMax)
          only applies for AXIS_SWEEP broadphase
 void BulletAppState.setWorldMax(Vector3f worldMax)
          Use before attaching state
 void PhysicsSpace.setWorldMin(Vector3f worldMin)
          only applies for AXIS_SWEEP broadphase
 void BulletAppState.setWorldMin(Vector3f worldMin)
          Use before attaching state
 

Constructors in com.jme3.bullet with parameters of type Vector3f
BulletAppState(Vector3f worldMin, Vector3f worldMax)
          Creates a new BulletAppState running a PhysicsSpace for physics simulation, use getStateManager().addState(bulletAppState) to enable physics for an Application.
BulletAppState(Vector3f worldMin, Vector3f worldMax, PhysicsSpace.BroadphaseType broadphaseType)
           
PhysicsSpace(Vector3f worldMin, Vector3f worldMax)
           
PhysicsSpace(Vector3f worldMin, Vector3f worldMax, PhysicsSpace.BroadphaseType broadphaseType)
           
 

Uses of Vector3f in com.jme3.bullet.collision
 

Methods in com.jme3.bullet.collision that return Vector3f
 Vector3f PhysicsRayTestResult.getHitNormalLocal()
           
 Vector3f PhysicsSweepTestResult.getHitNormalLocal()
           
 Vector3f PhysicsCollisionEvent.getLateralFrictionDir1()
           
 Vector3f PhysicsCollisionEvent.getLateralFrictionDir1(Vector3f lateralFrictionDir1)
           
 Vector3f PhysicsCollisionEvent.getLateralFrictionDir2()
           
 Vector3f PhysicsCollisionEvent.getLateralFrictionDir2(Vector3f lateralFrictionDir2)
           
 Vector3f PhysicsCollisionEvent.getLocalPointA()
           
 Vector3f PhysicsCollisionEvent.getLocalPointA(Vector3f localPointA)
           
 Vector3f PhysicsCollisionEvent.getLocalPointB()
           
 Vector3f PhysicsCollisionEvent.getLocalPointB(Vector3f localPointB)
           
 Vector3f PhysicsCollisionEvent.getNormalWorldOnB()
           
 Vector3f PhysicsCollisionEvent.getNormalWorldOnB(Vector3f normalWorldOnB)
           
 Vector3f PhysicsCollisionEvent.getPositionWorldOnA()
           
 Vector3f PhysicsCollisionEvent.getPositionWorldOnA(Vector3f positionWorldOnA)
           
 Vector3f PhysicsCollisionEvent.getPositionWorldOnB()
           
 Vector3f PhysicsCollisionEvent.getPositionWorldOnB(Vector3f positionWorldOnB)
           
 

Methods in com.jme3.bullet.collision with parameters of type Vector3f
 void PhysicsSweepTestResult.fill(PhysicsCollisionObject collisionObject, Vector3f hitNormalLocal, float hitFraction, boolean normalInWorldSpace)
           
 Vector3f PhysicsCollisionEvent.getLateralFrictionDir1(Vector3f lateralFrictionDir1)
           
 Vector3f PhysicsCollisionEvent.getLateralFrictionDir2(Vector3f lateralFrictionDir2)
           
 Vector3f PhysicsCollisionEvent.getLocalPointA(Vector3f localPointA)
           
 Vector3f PhysicsCollisionEvent.getLocalPointB(Vector3f localPointB)
           
 Vector3f PhysicsCollisionEvent.getNormalWorldOnB(Vector3f normalWorldOnB)
           
 Vector3f PhysicsCollisionEvent.getPositionWorldOnA(Vector3f positionWorldOnA)
           
 Vector3f PhysicsCollisionEvent.getPositionWorldOnB(Vector3f positionWorldOnB)
           
 

Constructors in com.jme3.bullet.collision with parameters of type Vector3f
PhysicsSweepTestResult(PhysicsCollisionObject collisionObject, Vector3f hitNormalLocal, float hitFraction, boolean normalInWorldSpace)
           
 

Uses of Vector3f in com.jme3.bullet.collision.shapes
 

Fields in com.jme3.bullet.collision.shapes declared as Vector3f
protected  Vector3f CylinderCollisionShape.halfExtents
           
protected  Vector3f CollisionShape.scale
           
 

Methods in com.jme3.bullet.collision.shapes that return Vector3f
 Vector3f BoxCollisionShape.getHalfExtents()
           
 Vector3f CylinderCollisionShape.getHalfExtents()
           
 Vector3f CollisionShape.getScale()
           
 

Methods in com.jme3.bullet.collision.shapes with parameters of type Vector3f
 void CompoundCollisionShape.addChildShape(CollisionShape shape, Vector3f location)
          adds a child shape at the given local translation
 void CompoundCollisionShape.addChildShape(CollisionShape shape, Vector3f location, Matrix3f rotation)
          adds a child shape at the given local translation
protected  void HeightfieldCollisionShape.createCollisionHeightfield(float[] heightmap, Vector3f worldScale)
           
 void CollisionShape.setScale(Vector3f scale)
           
 void CompoundCollisionShape.setScale(Vector3f scale)
          WARNING - CompoundCollisionShape scaling has no effect.
 

Constructors in com.jme3.bullet.collision.shapes with parameters of type Vector3f
BoxCollisionShape(Vector3f halfExtents)
          creates a collision box from the given halfExtents
CylinderCollisionShape(Vector3f halfExtents)
          creates a cylinder shape from the given halfextents
CylinderCollisionShape(Vector3f halfExtents, int axis)
          Creates a cylinder shape around the given axis from the given halfextents
HeightfieldCollisionShape(float[] heightmap, Vector3f scale)
           
SimplexCollisionShape(Vector3f point1)
           
SimplexCollisionShape(Vector3f point1, Vector3f point2)
           
SimplexCollisionShape(Vector3f point1, Vector3f point2, Vector3f point3)
           
SimplexCollisionShape(Vector3f point1, Vector3f point2, Vector3f point3, Vector3f point4)
           
 

Uses of Vector3f in com.jme3.bullet.collision.shapes.infos
 

Fields in com.jme3.bullet.collision.shapes.infos declared as Vector3f
 Vector3f ChildCollisionShape.location
           
 

Constructors in com.jme3.bullet.collision.shapes.infos with parameters of type Vector3f
ChildCollisionShape(Vector3f location, Matrix3f rotation, CollisionShape shape)
           
 

Uses of Vector3f in com.jme3.bullet.control
 

Fields in com.jme3.bullet.control declared as Vector3f
protected  Vector3f KinematicRagdollControl.initScale
           
protected  Vector3f KinematicRagdollControl.modelPosition
           
protected  Vector3f KinematicRagdollControl.PhysicsBoneLink.startBlendingPos
           
protected  Vector3f CharacterControl.viewDirection
           
 

Methods in com.jme3.bullet.control that return Vector3f
 Vector3f CharacterControl.getViewDirection()
           
 

Methods in com.jme3.bullet.control with parameters of type Vector3f
 void CharacterControl.setViewDirection(Vector3f vec)
           
 

Uses of Vector3f in com.jme3.bullet.control.ragdoll
 

Methods in com.jme3.bullet.control.ragdoll with parameters of type Vector3f
static HullCollisionShape RagdollUtils.makeShapeFromPointMap(java.util.Map<java.lang.Integer,java.util.List<java.lang.Float>> pointsMap, java.util.List<java.lang.Integer> boneIndices, Vector3f initialScale, Vector3f initialPosition)
          Create a hull collision shape from linked vertices to this bone.
static HullCollisionShape RagdollUtils.makeShapeFromVerticeWeights(Spatial model, java.util.List<java.lang.Integer> boneIndices, Vector3f initialScale, Vector3f initialPosition, float weightThreshold)
          Create a hull collision shape from linked vertices to this bone.
static void RagdollUtils.setTransform(Bone bone, Vector3f pos, Quaternion rot, boolean restoreBoneControl, java.util.Set<java.lang.String> boneList)
          Updates a bone position and rotation.
 

Uses of Vector3f in com.jme3.bullet.joints
 

Fields in com.jme3.bullet.joints declared as Vector3f
protected  Vector3f HingeJoint.axisA
           
protected  Vector3f HingeJoint.axisB
           
protected  Vector3f PhysicsJoint.pivotA
           
protected  Vector3f PhysicsJoint.pivotB
           
 

Methods in com.jme3.bullet.joints that return Vector3f
 Vector3f PhysicsJoint.getPivotA()
           
 Vector3f PhysicsJoint.getPivotB()
           
 

Methods in com.jme3.bullet.joints with parameters of type Vector3f
 void SixDofJoint.setAngularLowerLimit(Vector3f vector)
           
 void SixDofJoint.setAngularUpperLimit(Vector3f vector)
           
 void SixDofJoint.setLinearLowerLimit(Vector3f vector)
           
 void SixDofJoint.setLinearUpperLimit(Vector3f vector)
           
 

Constructors in com.jme3.bullet.joints with parameters of type Vector3f
ConeJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB)
           
ConeJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Matrix3f rotA, Matrix3f rotB)
           
HingeJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Vector3f axisA, Vector3f axisB)
          Creates a new HingeJoint
PhysicsJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB)
           
Point2PointJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB)
           
SixDofJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, boolean useLinearReferenceFrameA)
           
SixDofJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Matrix3f rotA, Matrix3f rotB, boolean useLinearReferenceFrameA)
           
SixDofSpringJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Matrix3f rotA, Matrix3f rotB, boolean useLinearReferenceFrameA)
           
SliderJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, boolean useLinearReferenceFrameA)
           
SliderJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Matrix3f rotA, Matrix3f rotB, boolean useLinearReferenceFrameA)
           
 

Uses of Vector3f in com.jme3.bullet.joints.motors
 

Methods in com.jme3.bullet.joints.motors that return Vector3f
 Vector3f TranslationalLimitMotor.getAccumulatedImpulse()
           
 Vector3f TranslationalLimitMotor.getLowerLimit()
           
 Vector3f TranslationalLimitMotor.getUpperLimit()
           
 

Methods in com.jme3.bullet.joints.motors with parameters of type Vector3f
 void TranslationalLimitMotor.setAccumulatedImpulse(Vector3f accumulatedImpulse)
           
 void TranslationalLimitMotor.setLowerLimit(Vector3f lowerLimit)
           
 void TranslationalLimitMotor.setUpperLimit(Vector3f upperLimit)
           
 

Uses of Vector3f in com.jme3.bullet.objects
 

Fields in com.jme3.bullet.objects declared as Vector3f
protected  Vector3f VehicleWheel.axle
           
protected  Vector3f VehicleWheel.direction
           
protected  Vector3f VehicleWheel.location
           
protected  Vector3f PhysicsCharacter.walkDirection
           
protected  Vector3f VehicleWheel.wheelWorldLocation
           
 

Methods in com.jme3.bullet.objects that return Vector3f
 Vector3f PhysicsRigidBody.getAngularVelocity()
          Get the current angular velocity of this PhysicsRigidBody
 Vector3f VehicleWheel.getAxle()
           
 Vector3f VehicleWheel.getCollisionLocation()
          returns the location where the wheel collides with the ground (world space)
 Vector3f VehicleWheel.getCollisionLocation(Vector3f vec)
          returns the location where the wheel collides with the ground (world space)
 Vector3f VehicleWheel.getCollisionNormal()
          returns the normal where the wheel collides with the ground (world space)
 Vector3f VehicleWheel.getCollisionNormal(Vector3f vec)
          returns the normal where the wheel collides with the ground (world space)
 Vector3f VehicleWheel.getDirection()
           
 Vector3f PhysicsVehicle.getForwardVector(Vector3f vector)
          Get the current forward vector of the vehicle in world coordinates
 Vector3f PhysicsRigidBody.getGravity()
           
 Vector3f PhysicsRigidBody.getGravity(Vector3f gravity)
           
 Vector3f PhysicsRigidBody.getLinearVelocity()
          Get the current linear velocity of this PhysicsRigidBody
 Vector3f VehicleWheel.getLocation()
           
 Vector3f PhysicsCharacter.getPhysicsLocation()
           
 Vector3f PhysicsGhostObject.getPhysicsLocation()
           
 Vector3f PhysicsRigidBody.getPhysicsLocation()
           
 Vector3f PhysicsCharacter.getPhysicsLocation(Vector3f trans)
           
 Vector3f PhysicsGhostObject.getPhysicsLocation(Vector3f trans)
           
 Vector3f PhysicsRigidBody.getPhysicsLocation(Vector3f trans)
           
 Vector3f PhysicsCharacter.getWalkDirection()
           
 

Methods in com.jme3.bullet.objects with parameters of type Vector3f
 VehicleWheel PhysicsVehicle.addWheel(Spatial spat, Vector3f connectionPoint, Vector3f direction, Vector3f axle, float suspensionRestLength, float wheelRadius, boolean isFrontWheel)
          Add a wheel to this vehicle
 VehicleWheel PhysicsVehicle.addWheel(Vector3f connectionPoint, Vector3f direction, Vector3f axle, float suspensionRestLength, float wheelRadius, boolean isFrontWheel)
          Add a wheel to this vehicle
 void PhysicsRigidBody.applyCentralForce(Vector3f force)
          Apply a force to the PhysicsRigidBody, only applies force if the next physics update call updates the physics space.
To apply an impulse, use applyImpulse.
 void PhysicsRigidBody.applyForce(Vector3f force, Vector3f location)
          Apply a force to the PhysicsRigidBody, only applies force if the next physics update call updates the physics space.
To apply an impulse, use applyImpulse, use applyContinuousForce to apply continuous force.
 void PhysicsRigidBody.applyImpulse(Vector3f impulse, Vector3f rel_pos)
          Apply an impulse to the PhysicsRigidBody in the next physics update.
 void PhysicsRigidBody.applyTorque(Vector3f torque)
          Apply a force to the PhysicsRigidBody, only applies force if the next physics update call updates the physics space.
To apply an impulse, use applyImpulse.
 void PhysicsRigidBody.applyTorqueImpulse(Vector3f vec)
          Apply a torque impulse to the PhysicsRigidBody in the next physics update.
 void PhysicsRigidBody.getAngularVelocity(Vector3f vec)
          Get the current angular velocity of this PhysicsRigidBody
 Vector3f VehicleWheel.getCollisionLocation(Vector3f vec)
          returns the location where the wheel collides with the ground (world space)
 Vector3f VehicleWheel.getCollisionNormal(Vector3f vec)
          returns the normal where the wheel collides with the ground (world space)
 Vector3f PhysicsVehicle.getForwardVector(Vector3f vector)
          Get the current forward vector of the vehicle in world coordinates
 Vector3f PhysicsRigidBody.getGravity(Vector3f gravity)
           
 void PhysicsRigidBody.getLinearVelocity(Vector3f vec)
          Get the current linear velocity of this PhysicsRigidBody
 Vector3f PhysicsCharacter.getPhysicsLocation(Vector3f trans)
           
 Vector3f PhysicsGhostObject.getPhysicsLocation(Vector3f trans)
           
 Vector3f PhysicsRigidBody.getPhysicsLocation(Vector3f trans)
           
 void PhysicsRigidBody.setAngularVelocity(Vector3f vec)
          Sets the angular velocity of this PhysicsRigidBody
 void PhysicsRigidBody.setGravity(Vector3f gravity)
          Set the local gravity of this PhysicsRigidBody
Set this after adding the node to the PhysicsSpace, the PhysicsSpace assigns its current gravity to the physics node when its added.
 void PhysicsRigidBody.setLinearVelocity(Vector3f vec)
          Sets the linear velocity of this PhysicsRigidBody
 void PhysicsCharacter.setPhysicsLocation(Vector3f location)
          Set the physics location (same as warp())
 void PhysicsGhostObject.setPhysicsLocation(Vector3f location)
          Sets the physics object location
 void PhysicsRigidBody.setPhysicsLocation(Vector3f location)
          Sets the physics object location
 void PhysicsCharacter.setWalkDirection(Vector3f vec)
          Set the walk direction, works continuously.
 void PhysicsCharacter.warp(Vector3f location)
          Sets the location of this physics character
 

Constructors in com.jme3.bullet.objects with parameters of type Vector3f
VehicleWheel(Spatial spat, Vector3f location, Vector3f direction, Vector3f axle, float restLength, float radius, boolean frontWheel)
           
VehicleWheel(Vector3f location, Vector3f direction, Vector3f axle, float restLength, float radius, boolean frontWheel)
           
 

Uses of Vector3f in com.jme3.bullet.objects.infos
 

Methods in com.jme3.bullet.objects.infos that return Vector3f
 Vector3f RigidBodyMotionState.getWorldLocation()
           
 

Uses of Vector3f in com.jme3.bullet.util
 

Methods in com.jme3.bullet.util with parameters of type Vector3f
static void CollisionShapeFactory.shiftCompoundShapeContents(CompoundCollisionShape compoundShape, Vector3f vector)
          This method moves each child shape of a compound shape by the given vector
 

Uses of Vector3f in com.jme3.cinematic
 

Methods in com.jme3.cinematic that return Vector3f
 Vector3f MotionPath.getWayPoint(int i)
          returns the waypoint at the given index
 

Methods in com.jme3.cinematic that return types with arguments of type Vector3f
 java.util.Iterator<Vector3f> MotionPath.iterator()
          returns an iterator on the waypoints collection
 

Methods in com.jme3.cinematic with parameters of type Vector3f
 void MotionPath.addWayPoint(Vector3f wayPoint)
          Addsa waypoint to the path
 void MotionPath.removeWayPoint(Vector3f wayPoint)
          remove the waypoint from the path
 

Uses of Vector3f in com.jme3.cinematic.events
 

Fields in com.jme3.cinematic.events declared as Vector3f
protected  Vector3f MotionTrack.direction
           
protected  Vector3f MotionTrack.lookAt
           
protected  Vector3f MotionTrack.upVector
           
 

Methods in com.jme3.cinematic.events that return Vector3f
 Vector3f MotionTrack.getDirection()
          returns the direction the spatial is moving
 

Methods in com.jme3.cinematic.events with parameters of type Vector3f
 void MotionTrack.setDirection(Vector3f direction)
          Sets the direction of the spatial This method is used by the motion path.
 void MotionTrack.setLookAt(Vector3f lookAt, Vector3f upVector)
          Set the lookAt for the target This can be used only if direction Type is Direction.LookAt
 

Constructors in com.jme3.cinematic.events with parameters of type Vector3f
PositionTrack(Spatial spatial, Vector3f endPosition)
          Deprecated.  
PositionTrack(Spatial spatial, Vector3f endPosition, float initialDuration)
          Deprecated.  
PositionTrack(Spatial spatial, Vector3f endPosition, float initialDuration, LoopMode loopMode)
          Deprecated.  
PositionTrack(Spatial spatial, Vector3f endPosition, LoopMode loopMode)
          Deprecated.  
ScaleTrack(Spatial spatial, Vector3f endScale)
          Deprecated.  
ScaleTrack(Spatial spatial, Vector3f endScale, float initialDuration)
          Deprecated.  
ScaleTrack(Spatial spatial, Vector3f endScale, float initialDuration, LoopMode loopMode)
          Deprecated.  
ScaleTrack(Spatial spatial, Vector3f endScale, LoopMode loopMode)
          Deprecated.  
 

Uses of Vector3f in com.jme3.collision
 

Methods in com.jme3.collision that return Vector3f
 Vector3f CollisionResult.getContactNormal()
           
 Vector3f CollisionResult.getContactPoint()
           
 

Methods in com.jme3.collision with parameters of type Vector3f
 void MotionAllowedListener.checkMotionAllowed(Vector3f position, Vector3f velocity)
          Check if motion allowed.
 void CollisionResult.setContactNormal(Vector3f norm)
           
 void CollisionResult.setContactPoint(Vector3f point)
           
 

Constructors in com.jme3.collision with parameters of type Vector3f
CollisionResult(Geometry geometry, Vector3f contactPoint, float distance, int triangleIndex)
           
CollisionResult(Vector3f contactPoint, float distance)
           
 

Uses of Vector3f in com.jme3.collision.bih
 

Methods in com.jme3.collision.bih that return Vector3f
 Vector3f BIHTriangle.get1()
           
 Vector3f BIHTriangle.get2()
           
 Vector3f BIHTriangle.get3()
           
 Vector3f BIHTriangle.getCenter()
           
 Vector3f BIHTriangle.getNormal()
           
 

Methods in com.jme3.collision.bih with parameters of type Vector3f
 void BIHTree.getTriangle(int index, Vector3f v1, Vector3f v2, Vector3f v3)
           
 

Constructors in com.jme3.collision.bih with parameters of type Vector3f
BIHTriangle(Vector3f p1, Vector3f p2, Vector3f p3)
           
 

Uses of Vector3f in com.jme3.effect
 

Fields in com.jme3.effect declared as Vector3f
 Vector3f Particle.position
          Current particle position
 Vector3f Particle.velocity
          Particle velocity.
 

Methods in com.jme3.effect that return Vector3f
 Vector3f ParticleEmitter.getFaceNormal()
          Get the normal which particles are facing.
 Vector3f ParticleEmitter.getGravity()
          Get the gravity vector.
 Vector3f ParticleEmitter.getInitialVelocity()
          Deprecated. Use ParticleEmitter.getParticleInfluencer().getInitialVelocity() instead.
 

Methods in com.jme3.effect with parameters of type Vector3f
 void ParticleEmitter.setFaceNormal(Vector3f faceNormal)
          Sets the normal which particles are facing.
 void ParticleEmitter.setGravity(Vector3f gravity)
          This method sets the gravity vector.
 void ParticleEmitter.setInitialVelocity(Vector3f initialVelocity)
          Deprecated. This method is deprecated. Use ParticleEmitter.getParticleInfluencer().setInitialVelocity(initialVelocity); instead.
 

Uses of Vector3f in com.jme3.effect.influencers
 

Fields in com.jme3.effect.influencers declared as Vector3f
protected  Vector3f DefaultParticleInfluencer.startVelocity
          The initial velocity of the particles.
protected  Vector3f DefaultParticleInfluencer.temp
          Temporary variable used to help with calculations.
 

Methods in com.jme3.effect.influencers that return Vector3f
 Vector3f DefaultParticleInfluencer.getInitialVelocity()
           
 Vector3f EmptyParticleInfluencer.getInitialVelocity()
           
 Vector3f ParticleInfluencer.getInitialVelocity()
          This method returns the initial velocity.
 

Methods in com.jme3.effect.influencers with parameters of type Vector3f
 void DefaultParticleInfluencer.setInitialVelocity(Vector3f initialVelocity)
           
 void EmptyParticleInfluencer.setInitialVelocity(Vector3f initialVelocity)
           
 void ParticleInfluencer.setInitialVelocity(Vector3f initialVelocity)
           
 

Uses of Vector3f in com.jme3.effect.shapes
 

Fields in com.jme3.effect.shapes with type parameters of type Vector3f
protected  java.util.List<java.util.List<Vector3f>> EmitterMeshVertexShape.normals
           
protected  java.util.List<java.util.List<Vector3f>> EmitterMeshVertexShape.vertices
           
 

Methods in com.jme3.effect.shapes that return Vector3f
 Vector3f EmitterSphereShape.getCenter()
           
 Vector3f EmitterBoxShape.getLen()
           
 Vector3f EmitterBoxShape.getMin()
           
 Vector3f EmitterPointShape.getPoint()
           
 

Methods in com.jme3.effect.shapes with parameters of type Vector3f
 void EmitterBoxShape.getRandomPoint(Vector3f store)
           
 void EmitterMeshConvexHullShape.getRandomPoint(Vector3f store)
          This method fills the point with coordinates of randomly selected point inside a convex hull of randomly selected mesh.
 void EmitterMeshFaceShape.getRandomPoint(Vector3f store)
          This method fills the point with coordinates of randomly selected point on a random face.
 void EmitterMeshVertexShape.getRandomPoint(Vector3f store)
          This method fills the point with coordinates of randomly selected mesh vertex.
 void EmitterPointShape.getRandomPoint(Vector3f store)
           
 void EmitterShape.getRandomPoint(Vector3f store)
          This method fills in the initial position of the particle.
 void EmitterSphereShape.getRandomPoint(Vector3f store)
           
 void EmitterBoxShape.getRandomPointAndNormal(Vector3f store, Vector3f normal)
          This method fills the point with data.
 void EmitterMeshConvexHullShape.getRandomPointAndNormal(Vector3f store, Vector3f normal)
          This method fills the point with coordinates of randomly selected point inside a convex hull of randomly selected mesh.
 void EmitterMeshFaceShape.getRandomPointAndNormal(Vector3f store, Vector3f normal)
          This method fills the point with coordinates of randomly selected point on a random face.
 void EmitterMeshVertexShape.getRandomPointAndNormal(Vector3f store, Vector3f normal)
          This method fills the point with coordinates of randomly selected mesh vertex.
 void EmitterPointShape.getRandomPointAndNormal(Vector3f store, Vector3f normal)
          This method fills the point with data.
 void EmitterShape.getRandomPointAndNormal(Vector3f store, Vector3f normal)
          This method fills in the initial position of the particle and its normal vector.
 void EmitterSphereShape.getRandomPointAndNormal(Vector3f store, Vector3f normal)
           
 void EmitterSphereShape.setCenter(Vector3f center)
           
 void EmitterBoxShape.setLen(Vector3f len)
           
 void EmitterBoxShape.setMin(Vector3f min)
           
 void EmitterPointShape.setPoint(Vector3f point)
           
 

Constructors in com.jme3.effect.shapes with parameters of type Vector3f
EmitterBoxShape(Vector3f min, Vector3f max)
           
EmitterPointShape(Vector3f point)
           
EmitterSphereShape(Vector3f center, float radius)
           
 

Uses of Vector3f in com.jme3.input
 

Fields in com.jme3.input declared as Vector3f
protected  Vector3f ChaseCamera.initialUpVec
           
protected  Vector3f FlyByCamera.initialUpVec
           
protected  Vector3f ChaseCamera.lookAtOffset
           
protected  Vector3f ChaseCamera.pos
           
protected  Vector3f ChaseCamera.prevPos
           
protected  Vector3f ChaseCamera.targetDir
           
protected  Vector3f ChaseCamera.targetLocation
           
protected  Vector3f ChaseCamera.temp
           
 

Methods in com.jme3.input that return Vector3f
 Vector3f ChaseCamera.getLookAtOffset()
          returns the offset from the target's position where the camera looks at
 Vector3f ChaseCamera.getUpVector()
          Returns the up vector of the camera used for the lookAt on the target
 

Methods in com.jme3.input with parameters of type Vector3f
protected  void FlyByCamera.rotateCamera(float value, Vector3f axis)
           
 void ChaseCamera.setLookAtOffset(Vector3f lookAtOffset)
          Sets the offset from the target's position where the camera looks at
 void ChaseCamera.setUpVector(Vector3f up)
          Sets the up vector of the camera used for the lookAt on the target
 void FlyByCamera.setUpVector(Vector3f upVec)
          Sets the up vector that should be used for the camera.
 

Uses of Vector3f in com.jme3.light
 

Fields in com.jme3.light declared as Vector3f
protected  Vector3f DirectionalLight.direction
           
protected  Vector3f SpotLight.direction
           
protected  Vector3f PointLight.position
           
protected  Vector3f SpotLight.position
           
 

Methods in com.jme3.light that return Vector3f
 Vector3f DirectionalLight.getDirection()
          Returns the direction vector of the light.
 Vector3f SpotLight.getDirection()
           
 Vector3f PointLight.getPosition()
          Returns the world space position of the light.
 Vector3f SpotLight.getPosition()
           
 

Methods in com.jme3.light with parameters of type Vector3f
 void DirectionalLight.setDirection(Vector3f dir)
          Sets the direction of the light.
 void SpotLight.setDirection(Vector3f direction)
           
 void PointLight.setPosition(Vector3f position)
          Set the world space position of the light.
 void SpotLight.setPosition(Vector3f position)
           
 

Uses of Vector3f in com.jme3.material
 

Methods in com.jme3.material with parameters of type Vector3f
 void Material.setVector3(java.lang.String name, Vector3f value)
          Pass a Vector3f to the material shader.
 

Uses of Vector3f in com.jme3.math
 

Fields in com.jme3.math declared as Vector3f
 Vector3f Ray.direction
          The direction of the ray.
static Vector3f Vector3f.NAN
           
static Vector3f Vector3f.NEGATIVE_INFINITY
           
protected  Vector3f Plane.normal
          Vector normal to the plane.
 Vector3f Ray.origin
          The ray's begining point.
static Vector3f Vector3f.POSITIVE_INFINITY
           
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.jme3.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()
           
static Vector3f FastMath.computeNormal(Vector3f v1, Vector3f v2, Vector3f v3)
          A method that computes normal for a triangle defined by three vertices.
static Vector3f Triangle.computeTriangleNormal(Vector3f v1, Vector3f v2, Vector3f v3, Vector3f store)
           
 Vector3f Vector3f.cross(float otherX, float otherY, float otherZ, Vector3f result)
          cross calculates the cross product of this vector with a parameter vector v.
 Vector3f Vector2f.cross(Vector2f v)
          cross calculates the cross product of this vector with a parameter vector v.
 Vector3f Vector3f.cross(Vector3f v)
          cross calculates the cross product of this vector with a parameter vector v.
 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.
static Vector3f FastMath.extrapolateLinear(float scale, Vector3f startValue, Vector3f endValue)
          Linear extrapolation from startValue to endValue by the given scale.
static Vector3f FastMath.extrapolateLinear(float scale, Vector3f startValue, Vector3f endValue, Vector3f store)
          Linear extrapolation from startValue to endValue by the given scale.
 Vector3f Triangle.get(int i)
          get retrieves a point on the triangle denoted by the index supplied.
abstract  Vector3f AbstractTriangle.get1()
           
 Vector3f Triangle.get1()
           
abstract  Vector3f AbstractTriangle.get2()
           
 Vector3f Triangle.get2()
           
abstract  Vector3f AbstractTriangle.get3()
           
 Vector3f Triangle.get3()
           
 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 Plane.getClosestPoint(Vector3f point)
           
 Vector3f Plane.getClosestPoint(Vector3f point, Vector3f store)
           
 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 Transform.getScale()
          Return the scale vector in this matrix.
 Vector3f Transform.getScale(Vector3f scale)
          Stores this scale value into the given vector3f.
 Vector3f Transform.getTranslation()
          Return the translation vector in this matrix.
 Vector3f Transform.getTranslation(Vector3f trans)
          Stores this translation value into the given vector3f.
 Vector3f Ring.getUp()
          getUp returns the ring's up vector.
 Vector3f Spline.interpolate(float value, int currentControlPoint, Vector3f store)
          Iterpolate a position on the spline
 Vector3f 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
 Vector3f 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
static Vector3f FastMath.interpolateBezier(float u, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3)
          Interpolate a spline between at least 4 control points following the Bezier equation.
static Vector3f FastMath.interpolateBezier(float u, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, Vector3f store)
          Interpolate a spline between at least 4 control points following the Bezier equation.
static Vector3f FastMath.interpolateCatmullRom(float u, float T, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3)
          Interpolate a spline between at least 4 control points following the Catmull-Rom equation.
static Vector3f FastMath.interpolateCatmullRom(float u, float T, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, Vector3f store)
          Interpolate a spline between at least 4 control points following the Catmull-Rom equation.
static Vector3f FastMath.interpolateLinear(float scale, Vector3f startValue, Vector3f endValue)
          Linear interpolation from startValue to endValue by the given percent.
static Vector3f FastMath.interpolateLinear(float scale, Vector3f startValue, Vector3f endValue, Vector3f store)
          Linear interpolation from startValue to endValue by the given percent.
 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)
          multLocal multiplies a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 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)
          multLocal multiplies a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 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 Vector3f.multLocal(float x, float y, float z)
          multLocal multiplies this vector by 3 scalars 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 Matrix4f.multNormal(Vector3f vec, Vector3f store)
          multNormal multiplies a vector about a rotation matrix, but does not add translation.
 Vector3f Matrix4f.multNormalAcross(Vector3f vec, Vector3f store)
          multNormal multiplies a vector about a rotation matrix, but does not add translation.
 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 Vector3f.project(Vector3f other)
           
 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 Plane.reflect(Vector3f point, Vector3f store)
           
 Vector3f Vector3f.scaleAdd(float scalar, Vector3f add)
          scaleAdd multiplies this vector by a scalar then adds the given Vector3f.
 Vector3f Vector3f.scaleAdd(float scalar, Vector3f mult, Vector3f add)
          scaleAdd multiplies the given vector by a scalar then adds the given vector.
 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.
 Vector3f Vector3f.setX(float x)
           
 Vector3f Vector3f.setY(float y)
           
 Vector3f Vector3f.setZ(float z)
           
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()
           
 Vector3f ColorRGBA.toVector3f()
          Transform the current ColorRGBA to a Vector3f using x = r, y = g, z = b.
 Vector3f Transform.transformInverseVector(Vector3f in, Vector3f store)
           
 Vector3f Transform.transformVector(Vector3f in, Vector3f store)
           
 Vector3f Vector3f.zero()
          zero resets this vector's data to zero internally.
 

Methods in com.jme3.math that return types with arguments of type Vector3f
 java.util.List<Vector3f> Spline.getControlPoints()
          returns this spline control points
 

Methods in com.jme3.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.
 void Spline.addControlPoint(Vector3f controlPoint)
          Adds a controlPoint to the spline
 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.
static Vector3f FastMath.computeNormal(Vector3f v1, Vector3f v2, Vector3f v3)
          A method that computes normal for a triangle defined by three vertices.
static Vector3f Triangle.computeTriangleNormal(Vector3f v1, Vector3f v2, Vector3f v3, Vector3f store)
           
 Vector3f Vector3f.cross(float otherX, float otherY, float otherZ, Vector3f result)
          cross calculates the cross product of this vector with a parameter vector v.
 Vector3f Vector3f.cross(Vector3f v)
          cross calculates the cross product of this vector with a parameter vector v.
 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.
static Vector3f FastMath.extrapolateLinear(float scale, Vector3f startValue, Vector3f endValue)
          Linear extrapolation from startValue to endValue by the given scale.
static Vector3f FastMath.extrapolateLinear(float scale, Vector3f startValue, Vector3f endValue, Vector3f store)
          Linear extrapolation from startValue to endValue by the given scale.
 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 Matrix4f.fromFrame(Vector3f location, Vector3f direction, Vector3f up, Vector3f left)
           
 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)
           
static float FastMath.getBezierP1toP2Length(Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3)
          Compute the lenght on a bezier spline between control point 1 and 2
static float FastMath.getCatmullRomP1toP2Length(Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, float startRange, float endRange, float curveTension)
          Compute the lenght on a catmull rom spline between control point 1 and 2
 Vector3f Plane.getClosestPoint(Vector3f point)
           
 Vector3f Plane.getClosestPoint(Vector3f point, Vector3f store)
           
 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 Transform.getScale(Vector3f scale)
          Stores this scale value into the given vector3f.
 Vector3f Transform.getTranslation(Vector3f trans)
          Stores this translation value into the given vector3f.
static void CurveAndSurfaceMath.interpolate(float u, float v, java.util.List<java.util.List<Vector4f>> controlPoints, java.util.List<java.lang.Float>[] knots, int basisUFunctionDegree, int basisVFunctionDegree, Vector3f store)
          This method interpolates tha data for the nurbs surface.
 Vector3f Spline.interpolate(float value, int currentControlPoint, Vector3f store)
          Iterpolate a position on the spline
 Vector3f 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
 Vector3f 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
static Vector3f FastMath.interpolateBezier(float u, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3)
          Interpolate a spline between at least 4 control points following the Bezier equation.
static Vector3f FastMath.interpolateBezier(float u, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, Vector3f store)
          Interpolate a spline between at least 4 control points following the Bezier equation.
static Vector3f FastMath.interpolateCatmullRom(float u, float T, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3)
          Interpolate a spline between at least 4 control points following the Catmull-Rom equation.
static Vector3f FastMath.interpolateCatmullRom(float u, float T, Vector3f p0, Vector3f p1, Vector3f p2, Vector3f p3, Vector3f store)
          Interpolate a spline between at least 4 control points following the Catmull-Rom equation.
static Vector3f FastMath.interpolateLinear(float scale, Vector3f startValue, Vector3f endValue)
          Linear interpolation from startValue to endValue by the given percent.
static Vector3f FastMath.interpolateLinear(float scale, Vector3f startValue, Vector3f endValue, Vector3f store)
          Linear interpolation from startValue to endValue by the given percent.
static void CurveAndSurfaceMath.interpolateNurbs(float u, Spline nurbSpline, Vector3f store)
          This method interpolates tha data for the nurbs curve.
 float Ray.intersects(Vector3f v0, Vector3f v1, Vector3f v2)
           
 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 Plane.isOnPlane(Vector3f point)
           
 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.
 void Vector3f.maxLocal(Vector3f other)
          maxLocal computes the maximum value for each component in this and other vector.
 void Vector3f.minLocal(Vector3f other)
          minLocal computes the minimum value for each component in this and other 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)
          multLocal multiplies a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 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)
          multLocal multiplies a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector3f Matrix4f.multAcross(Vector3f vec, Vector3f store)
          mult multiplies a vector about a rotation matrix.
 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 Matrix4f.multNormal(Vector3f vec, Vector3f store)
          multNormal multiplies a vector about a rotation matrix, but does not add translation.
 Vector3f Matrix4f.multNormalAcross(Vector3f vec, Vector3f store)
          multNormal multiplies a vector about a rotation matrix, but does not add translation.
 float Matrix4f.multProj(Vector3f vec, Vector3f store)
          mult multiplies a vector about a rotation matrix and adds translation.
 Vector3f Vector3f.project(Vector3f other)
           
 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.
 Vector3f Plane.reflect(Vector3f point, Vector3f store)
           
 void Spline.removeControlPoint(Vector3f controlPoint)
          remove the controlPoint from the spline
 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.
 Vector3f Vector3f.scaleAdd(float scalar, Vector3f add)
          scaleAdd multiplies this vector by a scalar then adds the given Vector3f.
 Vector3f 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 triangle's points to that specified as a parameter.
 Vector3f Vector3f.set(Vector3f vect)
          set sets the x,y,z values of the vector by copying the supplied vector.
abstract  void AbstractTriangle.set(Vector3f v1, Vector3f v2, Vector3f v3)
           
 void Triangle.set(Vector3f v1, Vector3f v2, Vector3f v3)
           
 void Triangle.set1(Vector3f v)
           
 void Triangle.set2(Vector3f v)
           
 void Triangle.set3(Vector3f v)
           
 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)
 Matrix3f 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 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.setOriginNormal(Vector3f origin, Vector3f normal)
          Initialize this plane using a point of origin and a normal.
 void Plane.setPlanePoints(Vector3f v1, Vector3f v2, Vector3f v3)
          Initialize the Plane using the given 3 points as coplanar.
 Matrix3f Matrix3f.setRow(int i, Vector3f row)
          setRow sets a particular row of this matrix to that represented by the provided vector.
 void Matrix4f.setScale(Vector3f scale)
           
 Transform Transform.setScale(Vector3f scale)
          Sets this scale to the given value.
 void Matrix4f.setTransform(Vector3f position, Vector3f scale, Matrix3f rotMat)
           
 void Matrix4f.setTranslation(Vector3f translation)
          setTranslation will set the matrix's translation values.
 Transform Transform.setTranslation(Vector3f trans)
          Sets this translation to the given value.
 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)
           
 Vector3f Transform.transformInverseVector(Vector3f in, Vector3f store)
           
 Vector3f Transform.transformVector(Vector3f in, Vector3f store)
           
 void Matrix4f.translateVect(Vector3f data)
          inverseTranslateVect translates a given Vector3f by the translation part of this matrix.
 Plane.Side Plane.whichSide(Vector3f point)
          whichSide returns the side at which a point lies on the plane.
 

Constructors in com.jme3.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.
Spline(Spline.SplineType splineType, Vector3f[] controlPoints, float curveTension, boolean cycle)
          Create a spline
Transform(Vector3f translation)
           
Transform(Vector3f translation, Quaternion rot)
           
Transform(Vector3f translation, Quaternion rot, Vector3f scale)
           
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
 

Constructor parameters in com.jme3.math with type arguments of type Vector3f
Spline(Spline.SplineType splineType, java.util.List<Vector3f> controlPoints, float curveTension, boolean cycle)
          Create a spline
 

Uses of Vector3f in com.jme3.network.serializing.serializers
 

Methods in com.jme3.network.serializing.serializers that return Vector3f
 Vector3f Vector3Serializer.readObject(java.nio.ByteBuffer data, java.lang.Class c)
           
 

Uses of Vector3f in com.jme3.post.filters
 

Methods in com.jme3.post.filters that return Vector3f
 Vector3f LightScatteringFilter.getLightPosition()
          returns the light position
 

Methods in com.jme3.post.filters with parameters of type Vector3f
 void LightScatteringFilter.setLightPosition(Vector3f lightPosition)
          sets the light position
 

Constructors in com.jme3.post.filters with parameters of type Vector3f
LightScatteringFilter(Vector3f lightPosition)
          Creates a lightScatteringFilter
 

Uses of Vector3f in com.jme3.renderer
 

Fields in com.jme3.renderer declared as Vector3f
protected  Vector3f Camera.location
          Camera's location
 

Methods in com.jme3.renderer that return Vector3f
 Vector3f Camera.getDirection()
          getDirection retrieves the direction vector the camera is facing.
 Vector3f Camera.getDirection(Vector3f store)
          getDirection retrieves the direction vector the camera is facing.
 Vector3f Camera.getLeft()
          getLeft retrieves the left axis of the camera.
 Vector3f Camera.getLeft(Vector3f store)
          getLeft retrieves the left axis of the camera.
 Vector3f Camera.getLocation()
          getLocation retrieves the location vector of the camera.
 Vector3f Camera.getScreenCoordinates(Vector3f worldPos)
          Converts the given position from world space to screen space.
 Vector3f Camera.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
          Converts the given position from world space to screen space.
 Vector3f Camera.getUp()
          getUp retrieves the up axis of the camera.
 Vector3f Camera.getUp(Vector3f store)
          getUp retrieves the up axis of the camera.
 Vector3f Camera.getWorldCoordinates(Vector2f screenPos, float zPos)
           
 Vector3f Camera.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
           
 

Methods in com.jme3.renderer with parameters of type Vector3f
 float Camera.distanceToNearPlane(Vector3f pos)
          Returns the pseudo distance from the given position to the near plane of the camera.
 Vector3f Camera.getDirection(Vector3f store)
          getDirection retrieves the direction vector the camera is facing.
 Vector3f Camera.getLeft(Vector3f store)
          getLeft retrieves the left axis of the camera.
 Vector3f Camera.getScreenCoordinates(Vector3f worldPos)
          Converts the given position from world space to screen space.
 Vector3f Camera.getScreenCoordinates(Vector3f worldPosition, Vector3f store)
          Converts the given position from world space to screen space.
 Vector3f Camera.getUp(Vector3f store)
          getUp retrieves the up axis of the camera.
 Vector3f Camera.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
           
 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 Camera.lookAtDirection(Vector3f direction, Vector3f up)
          lookAtDirection sets the direction the camera is facing given a direction and an up vector.
 void Camera.setAxes(Vector3f left, Vector3f up, Vector3f direction)
          setAxes sets the axes (left, up and direction) for this camera.
 void Camera.setFrame(Vector3f location, Quaternion axes)
          setFrame sets the orientation and location of the camera.
 void Camera.setFrame(Vector3f location, Vector3f left, Vector3f up, Vector3f direction)
          setFrame sets the orientation and location of the camera.
 void Camera.setLocation(Vector3f location)
          setLocation sets the position of the camera.
 

Uses of Vector3f in com.jme3.scene
 

Methods in com.jme3.scene that return Vector3f
 Vector3f Spatial.getLocalScale()
          getLocalScale retrieves the local scale of this node.
 Vector3f Spatial.getLocalTranslation()
          getLocalTranslation retrieves the local translation of this node.
 Vector3f Spatial.getWorldScale()
          getWorldScale retrieves the absolute scale factor of the spatial.
 Vector3f Spatial.getWorldTranslation()
          getWorldTranslation retrieves the absolute translation of the spatial.
 Vector3f Spatial.localToWorld(Vector3f in, Vector3f store)
          Convert a vector (in) from this spatials' local coordinate space to world coordinate space.
 Vector3f Spatial.worldToLocal(Vector3f in, Vector3f store)
          Convert a vector (in) from world coordinate space to this spatials' local coordinate space.
 

Methods in com.jme3.scene with parameters of type Vector3f
 void Mesh.getTriangle(int index, Vector3f v1, Vector3f v2, Vector3f v3)
          Gets the triangle vertex positions at the given triangle index and stores them into the v1, v2, v3 arguments.
 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 convenience method for auto-setting the local rotation based on a position and an up vector.
 Spatial Spatial.move(Vector3f offset)
          Translates the spatial by the given translation vector.
 void Spatial.rotateUpTo(Vector3f newUp)
          rotateUpTo is a utility function that alters the local rotation to point the Y axis in the direction given by newUp.
 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 spatial.
 Vector3f Spatial.worldToLocal(Vector3f in, Vector3f store)
          Convert a vector (in) from world coordinate space to this spatials' local coordinate space.
 

Uses of Vector3f in com.jme3.scene.debug
 

Methods in com.jme3.scene.debug with parameters of type Vector3f
 void Arrow.setArrowExtent(Vector3f extent)
          Sets the arrow's extent.
 void WireFrustum.update(Vector3f[] points)
           
 

Constructors in com.jme3.scene.debug with parameters of type Vector3f
Arrow(Vector3f extent)
          Creates an arrow mesh with the given extent.
WireFrustum(Vector3f[] points)
           
 

Uses of Vector3f in com.jme3.scene.plugins
 

Fields in com.jme3.scene.plugins with type parameters of type Vector3f
protected  java.util.ArrayList<Vector3f> OBJLoader.norms
           
protected  java.util.ArrayList<Vector3f> OBJLoader.verts
           
 

Methods in com.jme3.scene.plugins that return Vector3f
protected  Vector3f OBJLoader.readVector3()
           
 

Uses of Vector3f in com.jme3.scene.plugins.blender.animations
 

Methods in com.jme3.scene.plugins.blender.animations that return Vector3f
 Vector3f CalculationBone.getEndPoint()
          This method returns the end point of the bone.
 

Uses of Vector3f in com.jme3.scene.plugins.blender.curves
 

Methods in com.jme3.scene.plugins.blender.curves that return Vector3f
protected  Vector3f CurvesHelper.getLoc(Structure curveStructure)
          This method returns the translation of the curve.
 

Methods in com.jme3.scene.plugins.blender.curves that return types with arguments of type Vector3f
 java.util.List<Vector3f> BezierCurve.getControlPoints()
          This method returns a list of control points for this curve.
 

Methods in com.jme3.scene.plugins.blender.curves with parameters of type Vector3f
protected  java.util.List<Geometry> CurvesHelper.loadBezierCurve(Vector3f loc, Structure nurb, java.util.List<Geometry> bevelObject, Curve taperObject, BlenderContext blenderContext)
          This method loads the bezier curve.
protected  java.util.List<Geometry> CurvesHelper.loadNurb(Vector3f loc, Structure nurb, java.util.List<Geometry> bevelObject, Curve taperObject, BlenderContext blenderContext)
          This method loads the NURBS curve or surface.
 

Uses of Vector3f in com.jme3.scene.plugins.blender.objects
 

Methods in com.jme3.scene.plugins.blender.objects that return Vector3f
 Vector3f ObjectHelper.getScale(Matrix4f matrix)
          This method returns the scale from the given matrix.
 

Uses of Vector3f in com.jme3.scene.plugins.blender.textures
 

Methods in com.jme3.scene.plugins.blender.textures that return types with arguments of type Vector3f
static java.util.List<Vector3f> UVCoordinatesGenerator.generateUVCoordinatesFor3DTexture(Mesh mesh, UVCoordinatesGenerator.UVCoordinatesType texco, int[] coordinatesSwappingIndexes, java.util.List<Geometry> geometries)
          Generates a UV coordinates for 3D texture.
 

Uses of Vector3f in com.jme3.scene.shape
 

Fields in com.jme3.scene.shape declared as Vector3f
 Vector3f AbstractBox.center
           
 

Methods in com.jme3.scene.shape that return Vector3f
protected  Vector3f[] AbstractBox.computeVertices()
          Gets the array or vectors representing the 8 vertices of the box.
 Vector3f AbstractBox.getCenter()
          Get the center point of this box.
 Vector3f Dome.getCenter()
           
 Vector3f Line.getEnd()
           
 Vector3f Line.getStart()
           
 

Methods in com.jme3.scene.shape with parameters of type Vector3f
 void AbstractBox.updateGeometry(Vector3f center, float x, float y, float z)
          Rebuilds this box based on a new set of parameters.
 void Dome.updateGeometry(Vector3f center, int planes, int radialSamples, float radius, boolean insideView)
          Rebuilds the dome with a new set of parameters.
 void AbstractBox.updateGeometry(Vector3f minPoint, Vector3f maxPoint)
          Rebuilds this box based on a new set of parameters.
protected  void Line.updateGeometry(Vector3f start, Vector3f end)
           
 void Line.updatePoints(Vector3f start, Vector3f end)
          Update the start and end points of the line.
 

Constructors in com.jme3.scene.shape with parameters of type Vector3f
Box(Vector3f center, float x, float y, float z)
          Creates a new box.
Box(Vector3f min, Vector3f max)
          Constructor instantiates a new Box object.
Curve(Vector3f[] controlPoints, int nbSubSegments)
          Create a curve mesh.
Dome(Vector3f center, int planes, int radialSamples, float radius)
          Constructs a dome visible from the inside, e.g.
Dome(Vector3f center, int planes, int radialSamples, float radius, boolean insideView)
          Constructs a dome.
Line(Vector3f start, Vector3f end)
           
StripBox(Vector3f center, float x, float y, float z)
          Creates a new box.
StripBox(Vector3f min, Vector3f max)
          Constructor instantiates a new Box object.
 

Uses of Vector3f in com.jme3.shadow
 

Methods in com.jme3.shadow that return Vector3f
 Vector3f BasicShadowRenderer.getDirection()
          returns the light direction used for this processor
 Vector3f PssmShadowRenderer.getDirection()
          returns the light direction used by the processor
 Vector3f[] BasicShadowRenderer.getPoints()
          debug only
 

Methods in com.jme3.shadow with parameters of type Vector3f
static BoundingBox ShadowUtil.computeBoundForPoints(Vector3f[] pts, Matrix4f mat)
          Compute bounds from an array of points
static BoundingBox ShadowUtil.computeBoundForPoints(Vector3f[] pts, Transform transform)
          Compute bounds from an array of points
 void BasicShadowRenderer.setDirection(Vector3f direction)
          sets the light direction to use to computs shadows
 void PssmShadowRenderer.setDirection(Vector3f direction)
          Sets the light direction to use to compute shadows
static void ShadowUtil.updateFrustumPoints(Camera viewCam, float nearOverride, float farOverride, float scale, Vector3f[] points)
          Updates the points array to contain the frustum corners of the given camera.
static void ShadowUtil.updateFrustumPoints2(Camera viewCam, Vector3f[] points)
          Updates a points arrays with the frustum corners of the provided camera.
static void ShadowUtil.updateShadowCamera(Camera shadowCam, Vector3f[] points)
          Updates the shadow camera to properly contain the given points (which contain the eye camera frustum corners)
static void ShadowUtil.updateShadowCamera(GeometryList occluders, GeometryList receivers, Camera shadowCam, Vector3f[] points)
          Updates the shadow camera to properly contain the given points (which contain the eye camera frustum corners) and the shadow occluder objects.
static void ShadowUtil.updateShadowCamera(GeometryList occluders, GeometryList receivers, Camera shadowCam, Vector3f[] points, GeometryList splitOccluders)
          Updates the shadow camera to properly contain the given points (which contain the eye camera frustum corners) and the shadow occluder objects.
 

Uses of Vector3f in com.jme3.terrain
 

Methods in com.jme3.terrain that return Vector3f
 Vector3f Terrain.getNormal(Vector2f xz)
          Get the normal vector for the surface of the terrain at the specified X-Z coordinate.
 

Methods in com.jme3.terrain with parameters of type Vector3f
 Mesh GeoMap.createMesh(Vector3f scale, Vector2f tcScale, boolean center)
           
 Material Terrain.getMaterial(Vector3f worldLocation)
          Returns the material that this terrain uses.
 java.nio.FloatBuffer GeoMap.writeNormalArray(java.nio.FloatBuffer store, Vector3f scale)
          Creates a normal array from the normal data in this Geomap
 java.nio.FloatBuffer GeoMap.writeVertexArray(java.nio.FloatBuffer store, Vector3f scale, boolean center)
          Creates a vertex array from the height data in this Geomap The scale argument specifies the scale to use for the vertex buffer.
 

Uses of Vector3f in com.jme3.terrain.geomipmap
 

Fields in com.jme3.terrain.geomipmap declared as Vector3f
protected  Vector3f TerrainGrid.currentCamCell
           
protected  Vector3f TerrainGrid.UpdateQuadCache.location
           
protected  Vector3f[] TerrainGrid.quadIndex
           
protected  Vector3f TerrainPatch.stepScale
           
protected  Vector3f TerrainQuad.stepScale
           
protected  Vector3f TerrainPatch.worldScaleCached
           
protected  Vector3f TerrainPatch.worldTranslationCached
           
 

Fields in com.jme3.terrain.geomipmap with type parameters of type Vector3f
protected  LRUCache<Vector3f,TerrainQuad> TerrainGrid.cache
           
protected  java.util.List<Vector3f> TerrainLodControl.UpdateLOD.camLocations
           
protected  java.util.List<Vector3f> TerrainLodControl.lastCameraLocations
           
 

Methods in com.jme3.terrain.geomipmap that return Vector3f
static Vector3f LODGeomap.calculateTangent(Vector3f[] v, Vector2f[] t, Vector3f tangent, Vector3f binormal)
           
 Vector3f TerrainGrid.getCamCell(Vector3f location)
           
 Vector3f TerrainGrid.getCurrentCell()
           
protected  Vector3f TerrainPatch.getMeshNormal(int x, int z)
           
protected  Vector3f TerrainQuad.getMeshNormal(int x, int z)
           
protected  Vector3f TerrainQuad.getNormal(float x, float z, Vector2f xz)
           
 Vector3f TerrainQuad.getNormal(Vector2f xz)
           
 Vector3f TerrainPatch.getStepScale()
          Returns the step scale that stretches the height map.
 Vector3f TerrainGrid.getTileCell(Vector3f location)
          Centered at 0,0.
 Vector3f TerrainPatch.getWorldScaleCached()
           
 Vector3f TerrainPatch.getWorldTranslationCached()
           
protected  Vector3f TerrainPatch.worldCoordinateToLocal(Vector3f loc)
           
 

Methods in com.jme3.terrain.geomipmap with parameters of type Vector3f
protected  void TerrainGrid.attachQuadAt(TerrainQuad q, int quadrant, Vector3f quadCell)
          Runs on the rendering thread
protected  void TerrainPatch.averageNormalsTangents(Vector3f topPoint, Vector3f rootPoint, Vector3f leftPoint, Vector3f bottomPoint, Vector3f rightPoint, Vector3f normal, Vector3f tangent, Vector3f binormal)
           
static Vector3f LODGeomap.calculateTangent(Vector3f[] v, Vector2f[] t, Vector3f tangent, Vector3f binormal)
           
static Vector3f LODGeomap.calculateTangent(Vector3f[] v, Vector2f[] t, Vector3f tangent, Vector3f binormal)
           
 Mesh LODGeomap.createMesh(Vector3f scale, Vector2f tcScale, Vector2f tcOffset, float offsetAmount, int totalSize, boolean center)
           
 Mesh LODGeomap.createMesh(Vector3f scale, Vector2f tcScale, Vector2f tcOffset, float offsetAmount, int totalSize, boolean center, int lod, boolean rightLod, boolean topLod, boolean leftLod, boolean bottomLod)
           
 void TerrainQuad.getAllTerrainPatchesWithTranslation(java.util.Map<TerrainPatch,Vector3f> holder, Vector3f translation)
           
 Vector3f TerrainGrid.getCamCell(Vector3f location)
           
protected  Triangle[] LODGeomap.getGridTrianglesAtPoint(float x, float z, Vector3f scale, Vector3f translation)
          Get the two triangles that make up the grid section at the specified point, translated to world coordinates.
 Material TerrainGrid.getMaterial(Vector3f worldLocation)
           
 Material TerrainQuad.getMaterial(Vector3f worldLocation)
           
 TerrainQuad TerrainGridTileLoader.getTerrainQuadAt(Vector3f location)
           
 Vector3f TerrainGrid.getTileCell(Vector3f location)
          Centered at 0,0.
protected  Triangle LODGeomap.getTriangleAtPoint(float x, float z, Vector3f scale, Vector3f translation)
          Get a representation of the underlying triangle at the given point, translated to world coordinates.
 void TerrainGridListener.gridMoved(Vector3f newCenter)
           
 void TerrainPatch.setStepScale(Vector3f stepScale)
          Sets the step scale of this terrain patch's height map.
 void TerrainGridListener.tileAttached(Vector3f cell, TerrainQuad quad)
           
 void TerrainGridListener.tileDetached(Vector3f cell, TerrainQuad quad)
           
protected  void TerrainGrid.updateChildren(Vector3f camCell)
          Called when the camera has moved into a new cell.
protected  Vector3f TerrainPatch.worldCoordinateToLocal(Vector3f loc)
           
 java.nio.FloatBuffer LODGeomap.writeNormalArray(java.nio.FloatBuffer store, Vector3f scale)
           
 java.nio.FloatBuffer[] LODGeomap.writeTangentArray(java.nio.FloatBuffer normalBuffer, java.nio.FloatBuffer tangentStore, java.nio.FloatBuffer binormalStore, java.nio.FloatBuffer textureBuffer, Vector3f scale)
           
 

Method parameters in com.jme3.terrain.geomipmap with type arguments of type Vector3f
protected  boolean TerrainQuad.calculateLod(java.util.List<Vector3f> location, java.util.HashMap<java.lang.String,UpdatedTerrainPatch> updates, LodCalculator lodCalculator)
           
 void TerrainQuad.getAllTerrainPatchesWithTranslation(java.util.Map<TerrainPatch,Vector3f> holder, Vector3f translation)
           
protected  TerrainLodControl.UpdateLOD MultiTerrainLodControl.getLodThread(java.util.List<Vector3f> locations, LodCalculator lodCalculator)
           
protected  TerrainLodControl.UpdateLOD TerrainLodControl.getLodThread(java.util.List<Vector3f> locations, LodCalculator lodCalculator)
           
protected  void TerrainGridLodControl.updateLOD(java.util.List<Vector3f> locations, LodCalculator lodCalculator)
           
protected  void TerrainLodControl.updateLOD(java.util.List<Vector3f> locations, LodCalculator lodCalculator)
           
 

Constructors in com.jme3.terrain.geomipmap with parameters of type Vector3f
TerrainGrid.UpdateQuadCache(Vector3f location)
           
TerrainGrid(java.lang.String name, int patchSize, int maxVisibleSize, Vector3f scale, HeightMapGrid heightMapGrid)
          Deprecated. 
TerrainGrid(java.lang.String name, int patchSize, int maxVisibleSize, Vector3f scale, HeightMapGrid heightMapGrid, Vector2f offset, float offsetAmount)
          Deprecated. 
TerrainGrid(java.lang.String name, int patchSize, int maxVisibleSize, Vector3f scale, TerrainGridTileLoader terrainQuadGrid)
           
TerrainGrid(java.lang.String name, int patchSize, int maxVisibleSize, Vector3f scale, TerrainGridTileLoader terrainQuadGrid, Vector2f offset, float offsetAmount)
           
TerrainPatch(java.lang.String name, int size, Vector3f stepScale, float[] heightMap, Vector3f origin)
          Constructor instantiates a new TerrainPatch object.
TerrainPatch(java.lang.String name, int size, Vector3f stepScale, float[] heightMap, Vector3f origin, int totalSize, Vector2f offset, float offsetAmount)
          Constructor instantiates a new TerrainPatch object.
TerrainQuad(java.lang.String name, int patchSize, int totalSize, int quadSize, Vector3f scale, float[] heightMap)
           
TerrainQuad(java.lang.String name, int patchSize, int size, Vector3f scale, float[] heightMap)
           
TerrainQuad(java.lang.String name, int patchSize, int quadSize, Vector3f scale, float[] heightMap, int totalSize, Vector2f offset, float offsetAmount)
           
 

Constructor parameters in com.jme3.terrain.geomipmap with type arguments of type Vector3f
MultiTerrainLodControl.UpdateMultiLOD(java.util.List<Vector3f> camLocations, LodCalculator lodCalculator)
           
TerrainLodControl.UpdateLOD(java.util.List<Vector3f> camLocations, LodCalculator lodCalculator)
           
 

Uses of Vector3f in com.jme3.terrain.geomipmap.grid
 

Methods in com.jme3.terrain.geomipmap.grid with parameters of type Vector3f
 TerrainQuad AssetTileLoader.getTerrainQuadAt(Vector3f location)
           
 TerrainQuad FractalTileLoader.getTerrainQuadAt(Vector3f location)
           
 TerrainQuad ImageTileLoader.getTerrainQuadAt(Vector3f location)
           
 

Uses of Vector3f in com.jme3.terrain.geomipmap.lodcalc
 

Methods in com.jme3.terrain.geomipmap.lodcalc that return Vector3f
protected  Vector3f DistanceLodCalculator.getCenterLocation(TerrainPatch terrainPatch)
           
 Vector3f PerspectiveLodCalculator.getCenterLocation(TerrainPatch patch)
           
 

Method parameters in com.jme3.terrain.geomipmap.lodcalc with type arguments of type Vector3f
 boolean PerspectiveLodCalculator.calculateLod(java.util.List<Vector3f> locations, java.util.HashMap<java.lang.String,UpdatedTerrainPatch> updates)
           
 boolean DistanceLodCalculator.calculateLod(TerrainPatch terrainPatch, java.util.List<Vector3f> locations, java.util.HashMap<java.lang.String,UpdatedTerrainPatch> updates)
           
 boolean LodCalculator.calculateLod(TerrainPatch terrainPatch, java.util.List<Vector3f> locations, java.util.HashMap<java.lang.String,UpdatedTerrainPatch> updates)
           
 boolean PerspectiveLodCalculator.calculateLod(TerrainPatch terrainPatch, java.util.List<Vector3f> locations, java.util.HashMap<java.lang.String,UpdatedTerrainPatch> updates)
           
 

Uses of Vector3f in com.jme3.terrain.geomipmap.picking
 

Fields in com.jme3.terrain.geomipmap.picking declared as Vector3f
protected  Vector3f BresenhamYUpGridTracer.gridOrigin
           
protected  Vector3f BresenhamYUpGridTracer.gridSpacing
           
protected  Vector3f BresenhamYUpGridTracer.rayLocation
           
 

Methods in com.jme3.terrain.geomipmap.picking that return Vector3f
 Vector3f BresenhamYUpGridTracer.getGridOrigin()
           
 Vector3f BresenhamYUpGridTracer.getGridSpacing()
           
 Vector3f BresenhamTerrainPicker.getTerrainIntersection(Ray worldPick, CollisionResults results)
           
 Vector3f TerrainPicker.getTerrainIntersection(Ray worldPick, CollisionResults results)
          Ask for the point of intersection between the given ray and the terrain.
 

Methods in com.jme3.terrain.geomipmap.picking with parameters of type Vector3f
protected  boolean BresenhamTerrainPicker.checkTriangles(float gridX, float gridY, Ray pick, Vector3f intersection, TerrainPatch patch, Triangle store)
           
protected  int BresenhamTerrainPicker.findClosestHeightIndex(Vector3f position, TerrainPatch patch)
          Finds the closest height point to a position.
 void BresenhamYUpGridTracer.setGridOrigin(Vector3f gridOrigin)
           
 void BresenhamYUpGridTracer.setGridSpacing(Vector3f gridSpacing)
           
 

Uses of Vector3f in com.jme3.terrain.heightmap
 

Methods in com.jme3.terrain.heightmap with parameters of type Vector3f
 HeightMap HeightMapGrid.getHeightMapAt(Vector3f location)
          Deprecated.  
 HeightMap ImageBasedHeightMapGrid.getHeightMapAt(Vector3f location)
          Deprecated.  
 

Uses of Vector3f in com.jme3.util
 

Fields in com.jme3.util declared as Vector3f
 Vector3f TangentBinormalGenerator.TriangleData.binormal
           
 Vector3f TangentBinormalGenerator.TriangleData.normal
           
 Vector3f TangentBinormalGenerator.TriangleData.tangent
           
 Vector3f[] TempVars.tri
           
 Vector3f TempVars.vect1
          General vectors.
 Vector3f TempVars.vect10
           
 Vector3f TempVars.vect2
           
 Vector3f TempVars.vect3
           
 Vector3f TempVars.vect4
           
 Vector3f TempVars.vect5
           
 Vector3f TempVars.vect6
           
 Vector3f TempVars.vect7
           
 Vector3f TempVars.vect8
           
 Vector3f TempVars.vect9
           
 

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

Methods in com.jme3.util 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 Spatial SkyFactory.createSky(AssetManager assetManager, Texture west, Texture east, Texture north, Texture south, Texture up, Texture down, Vector3f normalScale)
           
static Spatial SkyFactory.createSky(AssetManager assetManager, Texture west, Texture east, Texture north, Texture south, Texture up, Texture down, Vector3f normalScale, int sphereRadius)
           
static Spatial SkyFactory.createSky(AssetManager assetManager, Texture texture, Vector3f normalScale, boolean sphereMap)
          Creates a sky using the given texture (cubemap or spheremap).
static Spatial SkyFactory.createSky(AssetManager assetManager, Texture texture, Vector3f normalScale, boolean sphereMap, int sphereRadius)
          Creates a sky using the given texture (cubemap or spheremap).
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 TangentBinormalGenerator.TriangleData TangentBinormalGenerator.processTriangle(int[] index, Vector3f[] v, Vector2f[] t)
           
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.jme3.util with parameters of type Vector3f
TangentBinormalGenerator.TriangleData(Vector3f tangent, Vector3f binormal, Vector3f normal)
           
 

Uses of Vector3f in com.jme3.util.xml
 

Methods in com.jme3.util.xml that return Vector3f
static Vector3f SAXUtil.parseVector3(org.xml.sax.Attributes attribs)
           
 

Uses of Vector3f in com.jme3.water
 

Fields in com.jme3.water declared as Vector3f
protected  Vector3f SimpleWaterProcessor.targetLocation
           
 

Methods in com.jme3.water that return Vector3f
 Vector3f WaterFilter.getCenter()
          returns the center of this effect
 Vector3f WaterFilter.getColorExtinction()
          Returns the color exctinction vector of the water
 Vector3f WaterFilter.getFoamExistence()
          returns the foam existance vector
 Vector3f WaterFilter.getLightDirection()
          gets the light direction
 

Methods in com.jme3.water with parameters of type Vector3f
 void WaterFilter.setCenter(Vector3f center)
          Set the center of the effect.
 void WaterFilter.setColorExtinction(Vector3f colorExtinction)
          Return at what depth the refraction color extinct the first value is for red the second is for green the third is for blue Play with thos parameters to "trouble" the water default is (5.0, 20.0, 30.0f);
 void WaterFilter.setFoamExistence(Vector3f foamExistence)
          Describes at what depth foam starts to fade out and at what it is completely invisible.
 void WaterFilter.setLightDirection(Vector3f lightDirection)
          Sets the light direction
 void SimpleWaterProcessor.setLightPosition(Vector3f position)
          Set the light Position for the processor
 void SimpleWaterProcessor.setPlane(Vector3f origin, Vector3f normal)
          Set the water plane using an origin (location) and a normal (reflection direction).
 

Constructors in com.jme3.water with parameters of type Vector3f
WaterFilter(Node reflectionScene, Vector3f lightDirection)
           
 

Uses of Vector3f in jme3tools.navigation
 

Methods in jme3tools.navigation that return Vector3f
 Vector3f MapModel3D.getCentreWu()
          Returns the WU (x,y,z) centre of the map.
 Vector3f MapModel3D.toWorldUnit(Position position)
          Converts a latitude/longitude position into a WU coordinate.
 

Methods in jme3tools.navigation with parameters of type Vector3f
 void MapModel3D.setCentre(Vector3f posVec)
          Defines the centre of the map in pixels.
 Position MapModel3D.toPosition(Vector3f posVec)
          Converts a world position into a Mercator position.
 

Uses of Vector3f in jme3tools.optimize
 

Methods in jme3tools.optimize that return Vector3f
 Vector3f OCTTriangle.get1()
           
 Vector3f OCTTriangle.get2()
           
 Vector3f OCTTriangle.get3()
           
 Vector3f OCTTriangle.getNormal()
           
 

Constructors in jme3tools.optimize with parameters of type Vector3f
OCTTriangle(Vector3f p1, Vector3f p2, Vector3f p3, int index, int geomIndex)