Uses of Class
jme.math.Vector

Packages that use Vector
jme.controller   
jme.entity   
jme.entity.camera   
jme.entity.effects   
jme.geometry   
jme.geometry.bounding   
jme.geometry.hud   
jme.geometry.model.md3   
jme.geometry.model.ms   
jme.geometry.primitive   
jme.lighting   
jme.locale   
jme.locale.external.feature   
jme.math   
jme.physics   
jme.physics.mobile   
 

Uses of Vector in jme.controller
 

Methods in jme.controller that return Vector
 Vector AbstractGameController.getEntityPosition()
           
 Vector BaseFPSController.getEntityView()
          getEntityView returns the point that the camera is viewing.
 Vector BaseFPSController.getEntityUp()
          getEntityUp return the orientation of the camera.
 Vector EntityController.getEntityPosition()
          getEntityPosition returns the current location in three dimensional space of the Entity.
 

Methods in jme.controller with parameters of type Vector
 void AbstractGameController.setEntityPosition(Vector position)
           
 void BaseFPSController.setEntityView(Vector view)
          setEntityView sets the point at which the camera is pointed at.
 void BaseFPSController.setEntityUp(Vector up)
          setEntityUp sets the vector that represents the up or orientation of the entity.
 void BaseFPSController.rotate(float angle, Vector axis)
          rotate rotates the camera's view about a given axis.
 void EntityController.setEntityPosition(Vector position)
          setEntityPosition sets the position of the Entity to the vector passed.
 

Uses of Vector in jme.entity
 

Methods in jme.entity that return Vector
 Vector Entity.getPosition()
          getPosition returns the position of the entity in three dimensional space.
 

Methods in jme.entity with parameters of type Vector
 void Entity.setPosition(Vector position)
          setPosition sets the position of this entity.
 

Uses of Vector in jme.entity.camera
 

Methods in jme.entity.camera that return Vector
 Vector Camera.getStrafe()
          getStrafe returns the strafe vector of the camera.
 Vector Camera.getView()
          getView returns the three dimensional point that the camera is looking at.
 Vector Camera.getUp()
          getUp returns the "up" orientation of the camera.
 

Methods in jme.entity.camera with parameters of type Vector
 void Camera.set(Vector position, Vector view, Vector up)
          set sets the camera's attributes to the three Vector3 parameters and sets them to the camera's attributes.
 void Camera.setView(Vector view)
          setView sets the point vector at which the camera is looking.
 void Camera.setUp(Vector up)
          setUp sets the orienation of the camera.
 void Camera.setStrafe(Vector strafe)
          setStrafe sets the strafe vector of the entity.
 

Constructors in jme.entity.camera with parameters of type Vector
Camera(int id, Vector position, Vector view, Vector up)
          Constructor takes three Vector3 parameters and sets them to the camera's attributes.
 

Uses of Vector in jme.entity.effects
 

Fields in jme.entity.effects declared as Vector
 Vector Particle.color
          the color of the particle in RGB format.
 Vector Particle.position
          the location in 3D space of the particle.
 Vector Particle.velocity
          the direction the particle is traveling in.
 Vector Particle.size
          the size of the particle.
 

Methods in jme.entity.effects with parameters of type Vector
 void ParticleEmitter.setEndColor(Vector endColor)
          setEndColor sets the final color of the particle just before it dies.
 void ParticleEmitter.setEndSize(Vector endSize)
          setEndSize sets the final size of the particle just before it dies.
 void ParticleEmitter.setGravity(Vector gravity)
          setGravity sets the value of the forces that will be acting upon the particles.
 void ParticleEmitter.setStartColor(Vector startColor)
          setStartColor sets the starting color of the particle.
 void ParticleEmitter.setStartSize(Vector startSize)
          setStartSize sets the starting size of the particle.
 void ParticleEmitter.setPosition(Vector position)
          setPosition sets the position of the emitter.
 void ParticleSystem.setPosition(Vector position)
           
 

Uses of Vector in jme.geometry
 

Methods in jme.geometry that return Vector
 Vector[] Geometry.getPoints()
          getPoints returns an array of Vectors that represents each point that makes up the piece of geometry.
 

Uses of Vector in jme.geometry.bounding
 

Methods in jme.geometry.bounding that return Vector
 Vector BoundingBox.getMinPoint()
          getMinPoint returns the minPoint or minimum point of the bounding box.
 Vector BoundingBox.getCenter()
          getCenter returns the center (in relation to the parent entity) of the bounding box.
 Vector BoundingBox.getMaxPoint()
          getMaxPoint returns the maxPoint of maximum point of the box.
 Vector BoundingCapsule.getOrigin()
          getOrigin gets the origin of the line segment that makes up the capsule.
 Vector BoundingCapsule.getDirection()
          getDirection gets the direction vector of the line segment that makes up the capsule.
 Vector BoundingSphere.getCenter()
          getCenter returns the center of the bounding sphere.
 

Methods in jme.geometry.bounding with parameters of type Vector
 void BoundingBox.axisAligned(Vector[] points)
          axisAligned creates a minimal box around all supplied points.
 void BoundingBox.setMinPoint(Vector minPoint)
          setMinPoint sets the minPoint or maximum point of the bounding box.
 void BoundingBox.setCenter(Vector center)
          setCenter sets the center of the bounding box.
 void BoundingBox.setMaxPoint(Vector maxPoint)
          setMaxPoint sets the new maximum point of the box.
 void BoundingCapsule.leastSquaresFit(Vector[] points)
          leastSquaresFit selects a parameterized equation that represents a discrete set of points in a continuous manner.
 void BoundingCylinder.leastSquaresFit(Vector[] points)
          leastSquaresFit builds a cylinder from a collection of points where the radius is the distance from a line approximation to the furthest point and the height is the direction(max) - direction(min).
 void BoundingEllipsoid.gaussianDistribution(Vector[] points)
          gaussianDistribution creates an ellipsoid using the mean of the points for the center and the eigenvectors for the axes.
 void BoundingLozenge.guassianDistribution(Vector[] points)
          guassianDistribution calculates the average of the points, and a covariance matrix to determine the rectangle of the lozenge.
 void BoundingSphere.setCenter(Vector center)
          setCenter sets the center of the bounding sphere.
 void BoundingSphere.containAABB(Vector[] points)
          containAABB creates a minimum-volume axis-aligned bounding box of the points, then selects the smallest enclosing sphere of the box with the sphere centered at the boxes center.
 void BoundingSphere.averagePoints(Vector[] 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.
 

Constructors in jme.geometry.bounding with parameters of type Vector
BoundingBox(Vector center, Vector minPoint, Vector maxPoint)
          Constructor creates a new BoundingBox object with the defined attributes.
BoundingCylinder(Vector center, Vector direction, Vector u, Vector v, float height, float radius)
          Constructor instantiates a new BoundingCylinder with set attributes.
BoundingEllipsoid(Vector center, Matrix a, Matrix inverseA)
          Constructor instantiates a new BoundingEllipsoid with given parameters.
BoundingSphere(float radius, Vector center)
          Constructor instantiates a new BoundingSphere object.
 

Uses of Vector in jme.geometry.hud
 

Fields in jme.geometry.hud declared as Vector
protected  Vector AbstractComponent.color
           
 

Uses of Vector in jme.geometry.model.md3
 

Methods in jme.geometry.model.md3 that return Vector
 Vector[] Md3Model.getPoints()
          getPoints returns all the points of the MD3 model.
 

Methods in jme.geometry.model.md3 with parameters of type Vector
 void Md3Model.setScale(Vector scale)
          setScale sets the scale factor for the model.
 

Uses of Vector in jme.geometry.model.ms
 

Methods in jme.geometry.model.ms that return Vector
 Vector[] MilkshapeModel.getPoints()
           
 

Uses of Vector in jme.geometry.primitive
 

Fields in jme.geometry.primitive declared as Vector
(package private)  Vector[] Quad.points
           
(package private)  Vector[] Triangle.points
           
 

Methods in jme.geometry.primitive that return Vector
 Vector[] Box.getPoints()
           
 Vector[] Cylinder.getPoints()
           
 Vector[] Disk.getPoints()
           
 Vector[] Pyramid.getPoints()
           
 Vector[] Quad.getPoints()
           
 Vector[] Sphere.getPoints()
           
 Vector[] Triangle.getPoints()
           
 

Methods in jme.geometry.primitive with parameters of type Vector
 void Box.setCorners(Vector[] corners)
          setCorners sets the points of the box.
 void Box.setCorner(int corner, Vector point)
          setCorner sets a single point of the box.
 void Quad.setPoints(Vector[] points)
          setPoints sets the points that define the quad shape.
 void Quad.setPoint(int index, Vector point)
          setPoint sets a specific corner to the given point.
 void Triangle.setPoints(Vector[] points)
          setPoints sets the points that define the triangle shape.
 void Triangle.setPoint(int index, Vector point)
          setPoint sets a specific corner to the given point.
 

Constructors in jme.geometry.primitive with parameters of type Vector
Box(Vector[] corners)
          Constructor instantiates a new Box object with the defined points defining the dimensions.
Quad(Vector[] points)
          Constructor instantiates a new Quad with the given set of points.
Triangle(Vector[] points)
          Constructor instantiates a new Triangle with the given set of points.
 

Uses of Vector in jme.lighting
 

Fields in jme.lighting declared as Vector
protected  Vector AbstractLightMap.color
          the vector that defines the color the light is casting.
 

Methods in jme.lighting that return Vector
 Vector AbstractLightMap.getColor()
          getColor returns the color vector of the lightmap.
 

Methods in jme.lighting with parameters of type Vector
 void AbstractLightMap.setColor(Vector color)
          setColor sets the color vector of the lightmap.
 

Uses of Vector in jme.locale
 

Methods in jme.locale that return Vector
 Vector SimpleLocale.getCenter()
          getCenter returns the center of the locale.
 

Methods in jme.locale with parameters of type Vector
 void SimpleLocale.setCenter(Vector center)
          setCenter sets the center of the locale.
 

Constructors in jme.locale with parameters of type Vector
SimpleLocale(Vector center, float length)
          Constructor builds a new SimpleLocale with the defined, center and length of each side.
 

Uses of Vector in jme.locale.external.feature
 

Methods in jme.locale.external.feature with parameters of type Vector
 void SkyBox.setColor(Vector color)
          setColor sets the color tint of the skybox.
 void WaterPlane.setColor(Vector color)
          setColor sets the color of the water texture.
 

Uses of Vector in jme.math
 

Methods in jme.math that return Vector
 Vector Line.getDirection()
          getDirection returns the direction of the line.
 Vector Line.getOrigin()
          getOrigin retrieves the direction of the line.
 Vector Rectangle.getFirstEdge()
          getFirstEdge returns the first extent vector.
 Vector Rectangle.getOrigin()
          getOrigin returns the origin point of the rectangle.
 Vector Rectangle.getSecondEdge()
          getSecondEdge returns the second extent vector.
 Vector Vector.divide(float scalar)
          divide divides the values of this vector by a scalar and returns the result.
 Vector Vector.mult(float scalar)
          mult multiplies the values of this vector by a scalar and returns the result.
 Vector Vector.add(Vector v)
          add adds the values of this vector by another vector and returns the result.
 Vector Vector.subtract(Vector v)
          subtract subtracts the values of this vector by another vector and returns the result.
 Vector Vector.cross(Vector v)
          cross calculates the cross product of this vector with a parameter vector v.
 Vector Vector.rotate(Matrix m)
          rotate rotates a vector about a rotation matrix.
 Vector Vector.inverseRotate(Matrix m)
           
 Vector Vector.normalize()
          normalize returns the unit vector of this vector.
 

Methods in jme.math with parameters of type Vector
static Line Approximation.orthogonalLineFit(Vector[] points)
          orthogonalLineFit creates a line that uses least squares and measures errors orthogonally rather than linearly.
static void Approximation.gaussPointsFit(Vector[] points, Vector center, Vector[] axis, float[] extent)
          gaussPointsFit generates a rectangle based on supplied points such that the center is calculated as the average of points and the extents are determined by the eigenvectors.
static float Distance.distancePointPoint(Vector point1, Vector point2)
          distancePointPoint calculates the distance between two points.
static float Distance.distancePointPointSquared(Vector point1, Vector point2)
          distancePointPointSquared calculates the distance squared between two points.
static float Distance.distancePointLineSquared(Vector point, Line line)
          distancePointLineSquared calculates the distance squared between a point and a line.
static float Distance.distancePointRaySquared(Vector point, Line ray)
          distancePointRaySquared calculates the distance squared between a point and a ray.
static float Distance.distancePointSegmentSquared(Vector point, Line seg)
          distancePointSegmentSquared calculates the distance squared between a point and a line segment.
static float Distance.distancePointRectangle(Vector point, Rectangle rect)
          distancePointRectangle calculates the distance squared between a point and a rectangle.
 void Line.setDirection(Vector direction)
          setDirection sets the direction of the line.
 void Line.setOrigin(Vector origin)
          setOrigin sets the new origin of the line.
 void Matrix.angleRotationRadians(Vector angles)
           
 void Matrix.angleRotationDegrees(Vector angles)
           
 void Matrix.tensorProduct(Vector u, Vector v)
           
 void Quaternion.fromAngleAxis(float angle, Vector axis)
          fromAngleAxis sets this quaternion to the values specified by an angle and an axis of rotation.
 float Quaternion.toAngleAxis(Vector axis)
          toAngleAxis sets a given angle and axis to that represented by the current quaternion.
 void Rectangle.setFirstEdge(Vector firstEdge)
          setFirstEdge sets the first extent vector.
 void Rectangle.setOrigin(Vector origin)
          setOrigin sets the origin point of the rectangle.
 void Rectangle.setSecondEdge(Vector secondEdge)
          setSecondEdge sets the second edge vector.
 Vector Vector.add(Vector v)
          add adds the values of this vector by another vector and returns the result.
 Vector Vector.subtract(Vector v)
          subtract subtracts the values of this vector by another vector and returns the result.
 float Vector.dot(Vector v)
          dot calculates the dot product of this vector with the parameter vector.
 Vector Vector.cross(Vector v)
          cross calculates the cross product of this vector with a parameter vector v.
static void Vector.generateOrthonormalBasis(Vector u, Vector v, Vector w, boolean isUnitLength)
          generateOrthonormalBasis generates a vector that satisfies u and v are perpendicular in respect to w.
 

Constructors in jme.math with parameters of type Vector
Line(Vector origin, Vector direction)
          Constructor instantiates a new Line that is supplied an origin and direction.
Rectangle(Vector origin, Vector firstEdge, Vector secondEdge)
          Constructor instantiates a new Rectangle object.
Vector(Vector v)
          Constructor builds a new Vector as a copy of a passed in vector.
 

Uses of Vector in jme.physics
 

Methods in jme.physics with parameters of type Vector
 void PhysicsModule.updatePosition(Vector position)
          updatePosition sets the position (supplied as a parameter) to the new position defined by the module's attributes.
 

Uses of Vector in jme.physics.mobile
 

Methods in jme.physics.mobile with parameters of type Vector
 void LandMobility.updatePosition(Vector position)
          updatePosition sets the entities new position based on it's current velocity and angle.