Uses of Class
com.jme3.math.Vector2f

Packages that use Vector2f
com.jme3.cinematic   
com.jme3.input The com.jme3.input package is used for all input handling in jMonkeyEngine. 
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.renderer The com.jme3.renderer package provides classes responsible for rendering. 
com.jme3.renderer.lwjgl   
com.jme3.scene The com.jme3.input package contains the scene graph implementation in jMonkeyEngine. 
com.jme3.scene.plugins   
com.jme3.scene.plugins.blender.materials   
com.jme3.scene.plugins.blender.textures   
com.jme3.terrain   
com.jme3.terrain.geomipmap   
com.jme3.terrain.geomipmap.picking   
com.jme3.util   
com.jme3.water   
jme3tools.optimize   
 

Uses of Vector2f in com.jme3.cinematic
 

Methods in com.jme3.cinematic that return Vector2f
 Vector2f MotionPath.getWayPointIndexForDistance(float distance)
          compute the index of the waypoint and the interpolation value according to a distance returns a vector 2 containing the index in the x field and the interpolation value in the y field
 

Uses of Vector2f in com.jme3.input
 

Methods in com.jme3.input that return Vector2f
 Vector2f InputManager.getCursorPosition()
          Returns the current cursor position.
 

Uses of Vector2f in com.jme3.material
 

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

Uses of Vector2f in com.jme3.math
 

Fields in com.jme3.math declared as Vector2f
static Vector2f Vector2f.UNIT_XY
           
static Vector2f Vector2f.ZERO
           
 

Methods in com.jme3.math that return Vector2f
 Vector2f Vector2f.add(Vector2f vec)
          add adds a provided vector to this vector creating a resultant vector which is returned.
 Vector2f Vector2f.add(Vector2f vec, Vector2f result)
          add adds this vector by vec and stores the result in result.
 Vector2f Vector2f.addLocal(float addX, float addY)
          addLocal adds the provided values to this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector2f Vector2f.addLocal(Vector2f vec)
          addLocal adds a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector2f Vector2f.clone()
           
 Vector2f Vector2f.divide(float scalar)
          divide divides the values of this vector by a scalar and returns the result.
 Vector2f Vector2f.divideLocal(float scalar)
          divideLocal divides this vector by a scalar internally, and returns a handle to this vector for easy chaining of calls.
 Vector2f Vector2f.interpolate(Vector2f finalVec, float changeAmnt)
          Sets this vector to the interpolation by changeAmnt from this to the finalVec this=(1-changeAmnt)*this + changeAmnt * finalVec
 Vector2f Vector2f.interpolate(Vector2f beginVec, Vector2f finalVec, float changeAmnt)
          Sets this vector to the interpolation by changeAmnt from beginVec to finalVec this=(1-changeAmnt)*beginVec + changeAmnt * finalVec
 Vector2f Vector2f.mult(float scalar)
          mult multiplies this vector by a scalar.
 Vector2f Vector2f.mult(float scalar, Vector2f product)
          Multiplies this Vector2f's x and y by the scalar and stores the result in product.
 Vector2f Vector2f.multLocal(float scalar)
          multLocal multiplies this vector by a scalar internally, and returns a handle to this vector for easy chaining of calls.
 Vector2f Vector2f.multLocal(Vector2f vec)
          multLocal multiplies a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector2f Vector2f.negate()
          negate returns the negative of this vector.
 Vector2f Vector2f.negateLocal()
          negateLocal negates the internal values of this vector.
 Vector2f Vector2f.normalize()
          normalize returns the unit vector of this vector.
 Vector2f Vector2f.normalizeLocal()
          normalizeLocal makes this vector into a unit vector of itself.
 Vector2f Vector2f.set(float x, float y)
          set the x and y values of the vector
 Vector2f Vector2f.set(Vector2f vec)
          set the x and y values of the vector from another vector
 Vector2f Vector2f.setX(float x)
           
 Vector2f Vector2f.setY(float y)
           
 Vector2f Vector2f.subtract(float valX, float valY)
          subtract subtracts the given x,y values from those of this vector creating a new vector object.
 Vector2f Vector2f.subtract(Vector2f vec)
          subtract subtracts the values of a given vector from those of this vector creating a new vector object.
 Vector2f Vector2f.subtract(Vector2f vec, Vector2f store)
          subtract subtracts the values of a given vector from those of this vector storing the result in the given vector object.
 Vector2f Vector2f.subtractLocal(float valX, float valY)
          subtractLocal subtracts the provided values from this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector2f Vector2f.subtractLocal(Vector2f vec)
          subtractLocal subtracts a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 Vector2f Vector2f.zero()
          zero resets this vector's data to zero internally.
 

Methods in com.jme3.math with parameters of type Vector2f
 Vector2f Vector2f.add(Vector2f vec)
          add adds a provided vector to this vector creating a resultant vector which is returned.
 Vector2f Vector2f.add(Vector2f vec, Vector2f result)
          add adds this vector by vec and stores the result in result.
 Vector2f Vector2f.addLocal(Vector2f vec)
          addLocal adds a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 float Vector2f.angleBetween(Vector2f otherVector)
          angleBetween returns (in radians) the angle required to rotate a ray represented by this vector to lie colinear to a ray described by the given vector.
static int FastMath.counterClockwise(Vector2f p0, Vector2f p1, Vector2f p2)
          Given 3 points in a 2d plane, this function computes if the points going from A-B-C are moving counter clock wise.
 Vector3f Vector2f.cross(Vector2f v)
          cross calculates the cross product of this vector with a parameter vector v.
 float Vector2f.determinant(Vector2f v)
           
 float Vector2f.distance(Vector2f v)
          distance calculates the distance between this vector and vector v.
 float Vector2f.distanceSquared(Vector2f v)
          distanceSquared calculates the distance squared between this vector and vector v.
 float Vector2f.dot(Vector2f vec)
          dot calculates the dot product of this vector with a provided vector.
 Vector2f Vector2f.interpolate(Vector2f finalVec, float changeAmnt)
          Sets this vector to the interpolation by changeAmnt from this to the finalVec this=(1-changeAmnt)*this + changeAmnt * finalVec
 Vector2f Vector2f.interpolate(Vector2f beginVec, Vector2f finalVec, float changeAmnt)
          Sets this vector to the interpolation by changeAmnt from beginVec to finalVec this=(1-changeAmnt)*beginVec + changeAmnt * finalVec
static boolean Vector2f.isValidVector(Vector2f vector)
          Check a vector...
 Vector2f Vector2f.mult(float scalar, Vector2f product)
          Multiplies this Vector2f's x and y by the scalar and stores the result in product.
 Vector2f Vector2f.multLocal(Vector2f vec)
          multLocal multiplies a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
static int FastMath.pointInsideTriangle(Vector2f t0, Vector2f t1, Vector2f t2, Vector2f p)
          Test if a point is inside a triangle.
 Vector2f Vector2f.set(Vector2f vec)
          set the x and y values of the vector from another vector
 float Vector2f.smallestAngleBetween(Vector2f otherVector)
          smallestAngleBetween returns (in radians) the minimum angle between two vectors.
 Vector2f Vector2f.subtract(Vector2f vec)
          subtract subtracts the values of a given vector from those of this vector creating a new vector object.
 Vector2f Vector2f.subtract(Vector2f vec, Vector2f store)
          subtract subtracts the values of a given vector from those of this vector storing the result in the given vector object.
 Vector2f Vector2f.subtractLocal(Vector2f vec)
          subtractLocal subtracts a provided vector to this vector internally, and returns a handle to this vector for easy chaining of calls.
 

Constructors in com.jme3.math with parameters of type Vector2f
Vector2f(Vector2f vector2f)
          Creates a new Vector2f that contains the passed vector's information
 

Uses of Vector2f in com.jme3.renderer
 

Methods in com.jme3.renderer with parameters of type Vector2f
 Vector3f Camera.getWorldCoordinates(Vector2f screenPos, float zPos)
           
 Vector3f Camera.getWorldCoordinates(Vector2f screenPosition, float zPos, Vector3f store)
           
 

Uses of Vector2f in com.jme3.renderer.lwjgl
 

Methods in com.jme3.renderer.lwjgl that return Vector2f
 Vector2f[] LwjglRenderer.getFrameBufferSamplePositions(FrameBuffer fb)
           
 

Uses of Vector2f in com.jme3.scene
 

Methods in com.jme3.scene with parameters of type Vector2f
 void Mesh.scaleTextureCoordinates(Vector2f scaleFactor)
          Scales the texture coordinate buffer on this mesh by the given scale factor.
 

Uses of Vector2f in com.jme3.scene.plugins
 

Fields in com.jme3.scene.plugins with type parameters of type Vector2f
protected  java.util.ArrayList<Vector2f> OBJLoader.texCoords
           
 

Methods in com.jme3.scene.plugins that return Vector2f
protected  Vector2f OBJLoader.readVector2()
           
 

Uses of Vector2f in com.jme3.scene.plugins.blender.materials
 

Method parameters in com.jme3.scene.plugins.blender.materials with type arguments of type Vector2f
 void MaterialContext.applyMaterial(Geometry geometry, java.lang.Long geometriesOMA, java.util.List<Vector2f> userDefinedUVCoordinates, BlenderContext blenderContext)
           
 

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

Methods in com.jme3.scene.plugins.blender.textures that return types with arguments of type Vector2f
static java.util.List<Vector2f> UVCoordinatesGenerator.generateUVCoordinatesFor2DTexture(Mesh mesh, UVCoordinatesGenerator.UVCoordinatesType texco, com.jme3.scene.plugins.blender.textures.UVProjectionGenerator.UVProjectionType projection, java.util.List<Geometry> geometries)
          Generates a UV coordinates for 2D texture.
 java.util.List<Vector2f> CombinedTexture.getResultUVS()
           
 

Method parameters in com.jme3.scene.plugins.blender.textures with type arguments of type Vector2f
 void CombinedTexture.flatten(Geometry geometry, java.lang.Long geometriesOMA, java.util.List<Vector2f> userDefinedUVCoordinates, BlenderContext blenderContext)
          This method flattens the texture and creates a single result of Texture2D type.
 

Uses of Vector2f in com.jme3.terrain
 

Methods in com.jme3.terrain that return Vector2f
 Vector2f GeoMap.getUV(int x, int y, Vector2f store)
           
 Vector2f GeoMap.getUV(int i, Vector2f store)
           
 

Methods in com.jme3.terrain with parameters of type Vector2f
 void Terrain.adjustHeight(Vector2f xzCoordinate, float delta)
          Raise/lower the height in one call (instead of getHeight then setHeight).
 Mesh GeoMap.createMesh(Vector3f scale, Vector2f tcScale, boolean center)
           
 float Terrain.getHeight(Vector2f xz)
          Get the real-world height of the terrain at the specified X-Z coorindate.
 float Terrain.getHeightmapHeight(Vector2f xz)
          Get the heightmap height at the specified X-Z coordinate.
 Vector3f Terrain.getNormal(Vector2f xz)
          Get the normal vector for the surface of the terrain at the specified X-Z coordinate.
 Vector2f GeoMap.getUV(int x, int y, Vector2f store)
           
 Vector2f GeoMap.getUV(int i, Vector2f store)
           
 void Terrain.setHeight(Vector2f xzCoordinate, float height)
          Set the height at the specified X-Z coordinate.
 java.nio.FloatBuffer GeoMap.writeTexCoordArray(java.nio.FloatBuffer store, Vector2f offset, Vector2f scale)
           
 

Method parameters in com.jme3.terrain with type arguments of type Vector2f
 void Terrain.adjustHeight(java.util.List<Vector2f> xz, java.util.List<java.lang.Float> height)
          Raise/lower the height at many points.
 void Terrain.setHeight(java.util.List<Vector2f> xz, java.util.List<java.lang.Float> height)
          Set the height at many points.
 

Uses of Vector2f in com.jme3.terrain.geomipmap
 

Fields in com.jme3.terrain.geomipmap declared as Vector2f
protected  Vector2f TerrainPatch.offset
           
protected  Vector2f TerrainQuad.offset
           
 

Methods in com.jme3.terrain.geomipmap that return Vector2f
 Vector2f TerrainPatch.getOffset()
          Returns the current offset amount.
 Vector2f TerrainPatch.getTex(float x, float z, Vector2f store)
           
 Vector2f LODGeomap.getUV(int x, int y, Vector2f store, Vector2f offset, float offsetAmount, int totalSize)
           
 

Methods in com.jme3.terrain.geomipmap with parameters of type Vector2f
 void TerrainQuad.adjustHeight(Vector2f xz, float delta)
           
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)
           
 float TerrainQuad.getHeight(Vector2f xz)
          Get the interpolated height of the terrain at the specified point.
 float TerrainQuad.getHeightmapHeight(Vector2f xz)
           
protected  Vector3f TerrainQuad.getNormal(float x, float z, Vector2f xz)
           
 Vector3f TerrainQuad.getNormal(Vector2f xz)
           
 Vector2f TerrainPatch.getTex(float x, float z, Vector2f store)
           
 Vector2f LODGeomap.getUV(int x, int y, Vector2f store, Vector2f offset, float offsetAmount, int totalSize)
           
 void TerrainQuad.setHeight(Vector2f xz, float height)
           
protected  void TerrainQuad.setNormalRecalcNeeded(Vector2f changedPoint)
          Signal if the normal vectors for the terrain need to be recalculated.
 void TerrainPatch.setOffset(Vector2f offset)
          Sets the value for the current offset amount to use when building texture coordinates.
 java.nio.FloatBuffer LODGeomap.writeTexCoordArray(java.nio.FloatBuffer store, Vector2f offset, Vector2f scale, float offsetAmount, int totalSize)
           
 

Method parameters in com.jme3.terrain.geomipmap with type arguments of type Vector2f
 void TerrainGrid.adjustHeight(java.util.List<Vector2f> xz, java.util.List<java.lang.Float> height)
           
 void TerrainQuad.adjustHeight(java.util.List<Vector2f> xz, java.util.List<java.lang.Float> height)
           
 void TerrainQuad.setHeight(java.util.List<Vector2f> xz, java.util.List<java.lang.Float> height)
           
protected  void TerrainQuad.setHeight(java.util.List<Vector2f> xz, java.util.List<java.lang.Float> height, boolean overrideHeight)
           
 

Constructors in com.jme3.terrain.geomipmap with parameters of type Vector2f
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, Vector2f offset, float offsetAmount)
           
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 quadSize, Vector3f scale, float[] heightMap, int totalSize, Vector2f offset, float offsetAmount)
           
 

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

Fields in com.jme3.terrain.geomipmap.picking declared as Vector2f
protected  Vector2f BresenhamYUpGridTracer.gridLocation
           
 

Methods in com.jme3.terrain.geomipmap.picking that return Vector2f
 Vector2f BresenhamYUpGridTracer.getGridLocation()
           
 

Methods in com.jme3.terrain.geomipmap.picking with parameters of type Vector2f
 void BresenhamYUpGridTracer.setGridLocation(Vector2f gridLocation)
           
 

Uses of Vector2f in com.jme3.util
 

Fields in com.jme3.util declared as Vector2f
 Vector2f TempVars.vect2d
          2D vector
 Vector2f TempVars.vect2d2
           
 

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

Methods in com.jme3.util with parameters of type Vector2f
static void BufferUtils.addInBuffer(Vector2f toAdd, java.nio.FloatBuffer buf, int index)
          Add to a Vector2f in-buffer.
static java.nio.FloatBuffer BufferUtils.createFloatBuffer(Vector2f... data)
          Generate a new FloatBuffer using the given array of Vector2f objects.
static boolean BufferUtils.equals(Vector2f check, java.nio.FloatBuffer buf, int index)
          Checks to see if the given Vector2f is equals to the data stored in the buffer at the given data index.
static void BufferUtils.multInBuffer(Vector2f toMult, java.nio.FloatBuffer buf, int index)
          Multiply and store a Vector2f in-buffer.
static void BufferUtils.populateFromBuffer(Vector2f 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(Vector2f vector, java.nio.FloatBuffer buf, int index)
          Sets the data contained in the given Vector2F into the FloatBuffer at the specified index.
 

Uses of Vector2f in com.jme3.water
 

Methods in com.jme3.water that return Vector2f
 Vector2f WaterFilter.getWindDirection()
          returns the wind direction
 

Methods in com.jme3.water with parameters of type Vector2f
 void WaterFilter.setWindDirection(Vector2f windDirection)
          sets the wind direction the direction where the waves move default is (0.0f, -1.0f)
 

Uses of Vector2f in jme3tools.optimize
 

Methods in jme3tools.optimize that return Vector2f
 Vector2f TextureAtlas.TextureAtlasTile.getLocation(Vector2f previousLocation)
          Get the transformed texture coordinate for a given input location.
 

Methods in jme3tools.optimize with parameters of type Vector2f
 Vector2f TextureAtlas.TextureAtlasTile.getLocation(Vector2f previousLocation)
          Get the transformed texture coordinate for a given input location.