|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |