クラス
com.jme3.math.Vector3f の使用

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.shape   
com.jme3.shadow   
com.jme3.terrain   
com.jme3.terrain.geomipmap   
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   
 

com.jme3.animation での Vector3f の使用
 

Vector3f を返す com.jme3.animation のメソッド
 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[] BoneTrack.getTranslations()
          returns the array of translations of this track
 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.
 

Vector3f 型のパラメータを持つ com.jme3.animation のメソッド
 Transform Bone.getCombinedTransform(Vector3f position, Quaternion rotation)
          Returns the local transform of this bone combined with the given position and rotation
 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 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.
 

Vector3f 型のパラメータを持つ com.jme3.animation のコンストラクタ
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)
           
 

com.jme3.audio での Vector3f の使用
 

Vector3f を返す com.jme3.audio のメソッド
 Vector3f AudioNode.getDirection()
           
 Vector3f Listener.getDirection()
           
 Vector3f Listener.getLeft()
           
 Vector3f Listener.getLocation()
           
 Vector3f Listener.getUp()
           
 Vector3f AudioNode.getVelocity()
           
 Vector3f Listener.getVelocity()
           
 

Vector3f 型のパラメータを持つ com.jme3.audio のメソッド
 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)
           
 

com.jme3.bounding での Vector3f の使用
 

Vector3f を返す com.jme3.bounding のメソッド
 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)
           
 

Vector3f 型のパラメータを持つ com.jme3.bounding のメソッド
 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)
           
 

Vector3f 型のパラメータを持つ com.jme3.bounding のコンストラクタ
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)
           
 

com.jme3.bullet での Vector3f の使用
 

Vector3f を返す com.jme3.bullet のメソッド
 Vector3f PhysicsSpace.getWorldMax()
           
 Vector3f PhysicsSpace.getWorldMin()
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet のメソッド
 java.util.List<PhysicsRayTestResult> 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 BulletAppState.setWorldMax(Vector3f worldMax)
          Use before attaching state
 void PhysicsSpace.setWorldMax(Vector3f worldMax)
          only applies for AXIS_SWEEP broadphase
 void BulletAppState.setWorldMin(Vector3f worldMin)
          Use before attaching state
 void PhysicsSpace.setWorldMin(Vector3f worldMin)
          only applies for AXIS_SWEEP broadphase
 

Vector3f 型のパラメータを持つ com.jme3.bullet のコンストラクタ
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)
           
 

com.jme3.bullet.collision での Vector3f の使用
 

Vector3f を返す com.jme3.bullet.collision のメソッド
 Vector3f PhysicsRayTestResult.getHitNormalLocal()
           
 Vector3f PhysicsSweepTestResult.getHitNormalLocal()
           
 Vector3f PhysicsCollisionEvent.getLateralFrictionDir1()
           
 Vector3f PhysicsCollisionEvent.getLateralFrictionDir2()
           
 Vector3f PhysicsCollisionEvent.getLocalPointA()
           
 Vector3f PhysicsCollisionEvent.getLocalPointB()
           
 Vector3f PhysicsCollisionEvent.getNormalWorldOnB()
           
 Vector3f PhysicsCollisionEvent.getPositionWorldOnA()
           
 Vector3f PhysicsCollisionEvent.getPositionWorldOnB()
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.collision のメソッド
 void PhysicsRayTestResult.fill(PhysicsCollisionObject collisionObject, Vector3f hitNormalLocal, float hitFraction, boolean normalInWorldSpace)
           
 void PhysicsSweepTestResult.fill(PhysicsCollisionObject collisionObject, Vector3f hitNormalLocal, float hitFraction, boolean normalInWorldSpace)
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.collision のコンストラクタ
PhysicsRayTestResult(PhysicsCollisionObject collisionObject, Vector3f hitNormalLocal, float hitFraction, boolean normalInWorldSpace)
           
PhysicsSweepTestResult(PhysicsCollisionObject collisionObject, Vector3f hitNormalLocal, float hitFraction, boolean normalInWorldSpace)
           
 

com.jme3.bullet.collision.shapes での Vector3f の使用
 

Vector3f を返す com.jme3.bullet.collision.shapes のメソッド
 Vector3f BoxCollisionShape.getHalfExtents()
           
 Vector3f CylinderCollisionShape.getHalfExtents()
           
 Vector3f CollisionShape.getScale()
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.collision.shapes のメソッド
 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
 void CollisionShape.setScale(Vector3f scale)
           
 void CompoundCollisionShape.setScale(Vector3f scale)
          WARNING - CompoundCollisionShape scaling has no effect.
 

Vector3f 型のパラメータを持つ com.jme3.bullet.collision.shapes のコンストラクタ
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)
           
 

com.jme3.bullet.collision.shapes.infos での Vector3f の使用
 

Vector3f として宣言されている com.jme3.bullet.collision.shapes.infos のフィールド
 Vector3f ChildCollisionShape.location
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.collision.shapes.infos のコンストラクタ
ChildCollisionShape(Vector3f location, Matrix3f rotation, CollisionShape shape)
           
 

com.jme3.bullet.control での Vector3f の使用
 

Vector3f を返す com.jme3.bullet.control のメソッド
 Vector3f CharacterControl.getViewDirection()
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.control のメソッド
 void CharacterControl.setViewDirection(Vector3f vec)
           
 

com.jme3.bullet.control.ragdoll での Vector3f の使用
 

Vector3f 型のパラメータを持つ com.jme3.bullet.control.ragdoll のメソッド
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.
 

com.jme3.bullet.joints での Vector3f の使用
 

Vector3f を返す com.jme3.bullet.joints のメソッド
 Vector3f PhysicsJoint.getPivotA()
           
 Vector3f PhysicsJoint.getPivotB()
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.joints のメソッド
 void SixDofJoint.setAngularLowerLimit(Vector3f vector)
           
 void SixDofJoint.setAngularUpperLimit(Vector3f vector)
           
 void SixDofJoint.setLinearLowerLimit(Vector3f vector)
           
 void SixDofJoint.setLinearUpperLimit(Vector3f vector)
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.joints のコンストラクタ
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)
           
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)
           
 

com.jme3.bullet.joints.motors での Vector3f の使用
 

Vector3f を返す com.jme3.bullet.joints.motors のメソッド
 Vector3f TranslationalLimitMotor.getAccumulatedImpulse()
           
 Vector3f TranslationalLimitMotor.getLowerLimit()
           
 Vector3f TranslationalLimitMotor.getUpperLimit()
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.joints.motors のメソッド
 void TranslationalLimitMotor.setAccumulatedImpulse(Vector3f accumulatedImpulse)
           
 void TranslationalLimitMotor.setLowerLimit(Vector3f lowerLimit)
           
 void TranslationalLimitMotor.setUpperLimit(Vector3f upperLimit)
           
 

com.jme3.bullet.objects での Vector3f の使用
 

Vector3f を返す com.jme3.bullet.objects のメソッド
 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.getInterpolatedPhysicsLocation(Vector3f location)
          Gets the physics object location
 Vector3f PhysicsRigidBody.getLinearVelocity()
          Get the current linear velocity of this PhysicsRigidBody
 Vector3f VehicleWheel.getLocation()
           
 Vector3f PhysicsCharacter.getPhysicsLocation()
           
 Vector3f PhysicsGhostObject.getPhysicsLocation()
           
 Vector3f PhysicsRigidBody.getPhysicsLocation()
          Gets the physics object location, instantiates a new Vector3f object
 Vector3f PhysicsCharacter.getPhysicsLocation(Vector3f trans)
           
 Vector3f PhysicsGhostObject.getPhysicsLocation(Vector3f trans)
           
 Vector3f PhysicsRigidBody.getPhysicsLocation(Vector3f location)
          Gets the physics object location, no object instantiation
 Vector3f PhysicsCharacter.getWalkDirection()
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.objects のメソッド
 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.
 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.
 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.
 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)
           
 Vector3f PhysicsRigidBody.getInterpolatedPhysicsLocation(Vector3f location)
          Gets the physics object location
 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 location)
          Gets the physics object location, no object instantiation
 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
 

Vector3f 型のパラメータを持つ com.jme3.bullet.objects のコンストラクタ
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)
           
 

com.jme3.bullet.objects.infos での Vector3f の使用
 

Vector3f を返す com.jme3.bullet.objects.infos のメソッド
 Vector3f RigidBodyMotionState.getWorldLocation()
           
 

com.jme3.bullet.util での Vector3f の使用
 

Vector3f を返す com.jme3.bullet.util のメソッド
static Vector3f Converter.convert(javax.vecmath.Vector3f oldVec)
           
static Vector3f Converter.convert(javax.vecmath.Vector3f oldVec, Vector3f newVec)
           
 

Vector3f 型のパラメータを持つ com.jme3.bullet.util のメソッド
static javax.vecmath.Vector3f Converter.convert(Vector3f oldVec)
           
static Vector3f Converter.convert(javax.vecmath.Vector3f oldVec, Vector3f newVec)
           
static javax.vecmath.Vector3f Converter.convert(Vector3f oldVec, javax.vecmath.Vector3f newVec)
           
static void CollisionShapeFactory.shiftCompoundShapeContents(CompoundCollisionShape compoundShape, Vector3f vector)
          This method moves each child shape of a compound shape by the given vector
 

com.jme3.cinematic での Vector3f の使用
 

Vector3f を返す com.jme3.cinematic のメソッド
 Vector3f MotionPath.getWayPoint(int i)
          returns the waypoint at the given index
 Vector3f MotionPath.interpolatePath(float tpf, MotionTrack control)
          interpolate the path giving the tpf and the motionControl
 

Vector3f 型の引数を持つ型を返す com.jme3.cinematic のメソッド
 java.util.Iterator<Vector3f> MotionPath.iterator()
          returns an iterator on the waypoints collection
 

Vector3f 型のパラメータを持つ com.jme3.cinematic のメソッド
 void MotionPath.addWayPoint(Vector3f wayPoint)
          Addsa waypoint to the path
 void MotionPath.removeWayPoint(Vector3f wayPoint)
          remove the waypoint from the path
 

com.jme3.cinematic.events での Vector3f の使用
 

Vector3f を返す com.jme3.cinematic.events のメソッド
 Vector3f MotionTrack.getDirection()
          returns the direction the spatial is moving
 

Vector3f 型のパラメータを持つ com.jme3.cinematic.events のメソッド
 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
 

Vector3f 型のパラメータを持つ com.jme3.cinematic.events のコンストラクタ
PositionTrack(Spatial spatial, Vector3f endPosition)
           
PositionTrack(Spatial spatial, Vector3f endPosition, float initialDuration)
           
PositionTrack(Spatial spatial, Vector3f endPosition, float initialDuration, LoopMode loopMode)
           
PositionTrack(Spatial spatial, Vector3f endPosition, LoopMode loopMode)
           
ScaleTrack(Spatial spatial, Vector3f endScale)
           
ScaleTrack(Spatial spatial, Vector3f endScale, float initialDuration)
           
ScaleTrack(Spatial spatial, Vector3f endScale, float initialDuration, LoopMode loopMode)
           
ScaleTrack(Spatial spatial, Vector3f endScale, LoopMode loopMode)
           
 

com.jme3.collision での Vector3f の使用
 

Vector3f を返す com.jme3.collision のメソッド
 Vector3f CollisionResult.getContactNormal()
           
 Vector3f CollisionResult.getContactPoint()
           
 

Vector3f 型のパラメータを持つ com.jme3.collision のメソッド
 void MotionAllowedListener.checkMotionAllowed(Vector3f position, Vector3f velocity)
          Check if motion allowed.
 void CollisionResult.setContactNormal(Vector3f norm)
           
 void CollisionResult.setContactPoint(Vector3f point)
           
 

Vector3f 型のパラメータを持つ com.jme3.collision のコンストラクタ
CollisionResult(Geometry geometry, Vector3f contactPoint, float distance, int triangleIndex)
           
CollisionResult(Vector3f contactPoint, float distance)
           
 

com.jme3.collision.bih での Vector3f の使用
 

Vector3f を返す com.jme3.collision.bih のメソッド
 Vector3f BIHTriangle.get1()
           
 Vector3f BIHTriangle.get2()
           
 Vector3f BIHTriangle.get3()
           
 Vector3f BIHTriangle.getCenter()
           
 Vector3f BIHTriangle.getNormal()
           
 

Vector3f 型のパラメータを持つ com.jme3.collision.bih のメソッド
 void BIHTree.getTriangle(int index, Vector3f v1, Vector3f v2, Vector3f v3)
           
 

Vector3f 型のパラメータを持つ com.jme3.collision.bih のコンストラクタ
BIHTriangle(Vector3f p1, Vector3f p2, Vector3f p3)
           
 

com.jme3.effect での Vector3f の使用
 

Vector3f として宣言されている com.jme3.effect のフィールド
 Vector3f Particle.position
          Current particle position
 Vector3f Particle.velocity
          Particle velocity.
 

Vector3f を返す com.jme3.effect のメソッド
 Vector3f ParticleEmitter.getFaceNormal()
          Get the normal which particles are facing.
 Vector3f ParticleEmitter.getGravity()
          Get the gravity vector.
 Vector3f ParticleEmitter.getInitialVelocity()
          推奨されていません。 Use ParticleEmitter.getParticleInfluencer().getInitialVelocity() instead.
 

Vector3f 型のパラメータを持つ com.jme3.effect のメソッド
 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)
          推奨されていません。 This method is deprecated. Use ParticleEmitter.getParticleInfluencer().setInitialVelocity(initialVelocity); instead.
 

com.jme3.effect.influencers での Vector3f の使用
 

Vector3f を返す com.jme3.effect.influencers のメソッド
 Vector3f DefaultParticleInfluencer.getInitialVelocity()
           
 Vector3f EmptyParticleInfluencer.getInitialVelocity()
           
 Vector3f ParticleInfluencer.getInitialVelocity()
          This method returns the initial velocity.
 

Vector3f 型のパラメータを持つ com.jme3.effect.influencers のメソッド
 void DefaultParticleInfluencer.setInitialVelocity(Vector3f initialVelocity)
           
 void EmptyParticleInfluencer.setInitialVelocity(Vector3f initialVelocity)
           
 void ParticleInfluencer.setInitialVelocity(Vector3f initialVelocity)
           
 

com.jme3.effect.shapes での Vector3f の使用
 

Vector3f を返す com.jme3.effect.shapes のメソッド
 Vector3f EmitterSphereShape.getCenter()
           
 Vector3f EmitterBoxShape.getLen()
           
 Vector3f EmitterBoxShape.getMin()
           
 Vector3f EmitterPointShape.getPoint()
           
 

Vector3f 型のパラメータを持つ com.jme3.effect.shapes のメソッド
 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)
           
 

Vector3f 型のパラメータを持つ com.jme3.effect.shapes のコンストラクタ
EmitterBoxShape(Vector3f min, Vector3f max)
           
EmitterPointShape(Vector3f point)
           
EmitterSphereShape(Vector3f center, float radius)
           
 

com.jme3.input での Vector3f の使用
 

Vector3f を返す com.jme3.input のメソッド
 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
 

Vector3f 型のパラメータを持つ com.jme3.input のメソッド
 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.
 

com.jme3.light での Vector3f の使用
 

Vector3f を返す com.jme3.light のメソッド
 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()
           
 

Vector3f 型のパラメータを持つ com.jme3.light のメソッド
 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)
           
 

com.jme3.material での Vector3f の使用
 

Vector3f 型のパラメータを持つ com.jme3.material のメソッド
 void Material.setVector3(java.lang.String name, Vector3f value)
          Pass a Vector3f to the material shader.
 

com.jme3.math での Vector3f の使用
 

Vector3f として宣言されている com.jme3.math のフィールド
 Vector3f Ray.direction
          The direction of the ray.
static Vector3f Vector3f.NAN
           
static Vector3f Vector3f.NEGATIVE_INFINITY
           
 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
           
 

Vector3f を返す com.jme3.math のメソッド
 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 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.
 

Vector3f 型の引数を持つ型を返す com.jme3.math のメソッド
 java.util.List<Vector3f> Spline.getControlPoints()
          returns this spline control points
 

Vector3f 型のパラメータを持つ com.jme3.math のメソッド
 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... if it is null or its floats are NaN or infinite, return false.
 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 triangles 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.
 

Vector3f 型のパラメータを持つ com.jme3.math のコンストラクタ
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)
           
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
 

Vector3f 型の型引数を持つ com.jme3.math のコンストラクタパラメータ
Spline(Spline.SplineType splineType, java.util.List<Vector3f> controlPoints, float curveTension, boolean cycle)
          Create a spline
 

com.jme3.network.serializing.serializers での Vector3f の使用
 

Vector3f を返す com.jme3.network.serializing.serializers のメソッド
 Vector3f Vector3Serializer.readObject(java.nio.ByteBuffer data, java.lang.Class c)
           
 

com.jme3.post.filters での Vector3f の使用
 

Vector3f を返す com.jme3.post.filters のメソッド
 Vector3f LightScatteringFilter.getLightPosition()
          returns the light position
 

Vector3f 型のパラメータを持つ com.jme3.post.filters のメソッド
 void LightScatteringFilter.setLightPosition(Vector3f lightPosition)
          sets the light position
 

Vector3f 型のパラメータを持つ com.jme3.post.filters のコンストラクタ
LightScatteringFilter(Vector3f lightPosition)
          Creates a lightScatteringFilter
 

com.jme3.renderer での Vector3f の使用
 

Vector3f を返す com.jme3.renderer のメソッド
 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)
           
 

Vector3f 型のパラメータを持つ com.jme3.renderer のメソッド
 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.
 

com.jme3.scene での Vector3f の使用
 

Vector3f を返す com.jme3.scene のメソッド
 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.
 

Vector3f 型のパラメータを持つ com.jme3.scene のメソッド
 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.
 

com.jme3.scene.debug での Vector3f の使用
 

Vector3f 型のパラメータを持つ com.jme3.scene.debug のメソッド
 void Arrow.setArrowExtent(Vector3f extent)
          Sets the arrow's extent.
 void WireFrustum.update(Vector3f[] points)
           
 

Vector3f 型のパラメータを持つ com.jme3.scene.debug のコンストラクタ
Arrow(Vector3f extent)
          Creates an arrow mesh with the given extent.
WireFrustum(Vector3f[] points)
           
 

com.jme3.scene.shape での Vector3f の使用
 

Vector3f として宣言されている com.jme3.scene.shape のフィールド
 Vector3f AbstractBox.center
           
 

Vector3f を返す com.jme3.scene.shape のメソッド
 Vector3f AbstractBox.getCenter()
          Get the center point of this box.
 Vector3f Dome.getCenter()
           
 Vector3f Line.getEnd()
           
 Vector3f Line.getStart()
           
 

Vector3f 型のパラメータを持つ com.jme3.scene.shape のメソッド
 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 outsideView)
          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.
 void Line.updatePoints(Vector3f start, Vector3f end)
          Update the start and end points of the line.
 

Vector3f 型のパラメータを持つ com.jme3.scene.shape のコンストラクタ
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.
Dome(Vector3f center, int planes, int radialSamples, float radius, boolean outsideView)
          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.
 

com.jme3.shadow での Vector3f の使用
 

Vector3f を返す com.jme3.shadow のメソッド
 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
 

Vector3f 型のパラメータを持つ com.jme3.shadow のメソッド
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.
 

com.jme3.terrain での Vector3f の使用
 

Vector3f を返す com.jme3.terrain のメソッド
 Vector3f GeoMap.getNormal(int x, int y, Vector3f store)
          Returns the normal at a point If store is null, then a new vector is returned, otherwise, the result is stored in the provided vector and then returned from this method
 Vector3f GeoMap.getNormal(int i, Vector3f store)
          Returns the normal at an index If store is null, then a new vector is returned, otherwise, the result is stored in the provided vector and then returned from this method See getHeight(int) for information about index lookup
 

Vector3f 型のパラメータを持つ com.jme3.terrain のメソッド
 Mesh GeoMap.createMesh(Vector3f scale, Vector2f tcScale, boolean center)
           
 Vector3f GeoMap.getNormal(int x, int y, Vector3f store)
          Returns the normal at a point If store is null, then a new vector is returned, otherwise, the result is stored in the provided vector and then returned from this method
 Vector3f GeoMap.getNormal(int i, Vector3f store)
          Returns the normal at an index If store is null, then a new vector is returned, otherwise, the result is stored in the provided vector and then returned from this method See getHeight(int) for information about index lookup
 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.
 

Vector3f 型の型引数を持つ com.jme3.terrain のメソッドパラメータ
 void Terrain.update(java.util.List<Vector3f> location)
          Called by an LodControl.
 

com.jme3.terrain.geomipmap での Vector3f の使用
 

Vector3f を返す com.jme3.terrain.geomipmap のメソッド
 Vector3f TerrainGrid.getCell(Vector3f location)
           
 Vector3f TerrainGrid.getCurrentCell()
           
 Vector3f TerrainPatch.getStepScale()
          Returns the step scale that stretches the height map.
 

Vector3f 型のパラメータを持つ com.jme3.terrain.geomipmap のメソッド
 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.getCell(Vector3f location)
           
 void TerrainGridListener.gridMoved(Vector3f newCenter)
           
 void TerrainGrid.initialize(Vector3f location)
           
 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)
           
 java.nio.FloatBuffer LODGeomap.writeNormalArray(java.nio.FloatBuffer store, Vector3f scale)
           
 

Vector3f 型の型引数を持つ com.jme3.terrain.geomipmap のメソッドパラメータ
 void TerrainQuad.getAllTerrainPatchesWithTranslation(java.util.Map<TerrainPatch,Vector3f> holder, Vector3f translation)
           
 void TerrainGrid.update(java.util.List<Vector3f> locations)
           
 void TerrainQuad.update(java.util.List<Vector3f> locations)
          Call from the update() method of a terrain controller to update the LOD values of each patch.
 

Vector3f 型のパラメータを持つ com.jme3.terrain.geomipmap のコンストラクタ
TerrainGrid(java.lang.String name, int patchSize, int maxVisibleSize, Vector3f scale, HeightMapGrid heightMapGrid, LodCalculatorFactory lodCalculatorFactory)
           
TerrainGrid(java.lang.String name, int patchSize, int maxVisibleSize, Vector3f scale, HeightMapGrid heightMapGrid, Vector2f offset, float offsetAmount, LodCalculatorFactory lodCalculatorFactory)
           
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 size, Vector3f scale, float[] heightMap, LodCalculatorFactory lodCalculatorFactory)
           
 

com.jme3.terrain.geomipmap.lodcalc での Vector3f の使用
 

Vector3f を返す com.jme3.terrain.geomipmap.lodcalc のメソッド
 Vector3f DistanceLodCalculator.getCenterLocation()
           
 Vector3f PerspectiveLodCalculator.getCenterLocation()
           
 

Vector3f 型の型引数を持つ com.jme3.terrain.geomipmap.lodcalc のメソッドパラメータ
 boolean DistanceLodCalculator.calculateLod(java.util.List<Vector3f> locations, java.util.HashMap<java.lang.String,UpdatedTerrainPatch> updates)
           
 boolean LodCalculator.calculateLod(java.util.List<Vector3f> locations, java.util.HashMap<java.lang.String,UpdatedTerrainPatch> updates)
           
 boolean PerspectiveLodCalculator.calculateLod(java.util.List<Vector3f> locations, java.util.HashMap<java.lang.String,UpdatedTerrainPatch> updates)
           
 

com.jme3.terrain.geomipmap.picking での Vector3f の使用
 

Vector3f を返す com.jme3.terrain.geomipmap.picking のメソッド
 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.
 

Vector3f 型のパラメータを持つ com.jme3.terrain.geomipmap.picking のメソッド
 void BresenhamYUpGridTracer.setGridOrigin(Vector3f gridOrigin)
           
 void BresenhamYUpGridTracer.setGridSpacing(Vector3f gridSpacing)
           
 

com.jme3.terrain.heightmap での Vector3f の使用
 

Vector3f 型のパラメータを持つ com.jme3.terrain.heightmap のメソッド
 HeightMap FractalHeightMapGrid.getHeightMapAt(Vector3f location)
           
 HeightMap HeightMapGrid.getHeightMapAt(Vector3f location)
           
 HeightMap ImageBasedHeightMapGrid.getHeightMapAt(Vector3f location)
           
 

com.jme3.util での Vector3f の使用
 

Vector3f として宣言されている com.jme3.util のフィールド
 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
           
 

Vector3f を返す com.jme3.util のメソッド
static Vector3f[] BufferUtils.getVector3Array(java.nio.FloatBuffer buff)
          Generates a Vector3f array from the given FloatBuffer.
 

Vector3f 型のパラメータを持つ com.jme3.util のメソッド
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)
           
static Spatial SkyFactory.createSky(AssetManager assetManager, Texture texture, Vector3f normalScale, boolean sphereMap, int sphereRadius)
           
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.
 

Vector3f 型のパラメータを持つ com.jme3.util のコンストラクタ
TangentBinormalGenerator.TriangleData(Vector3f tangent, Vector3f binormal, Vector3f normal, int index0, int index1, int index2)
           
 

com.jme3.util.xml での Vector3f の使用
 

Vector3f を返す com.jme3.util.xml のメソッド
static Vector3f SAXUtil.parseVector3(org.xml.sax.Attributes attribs)
           
 

com.jme3.water での Vector3f の使用
 

Vector3f を返す com.jme3.water のメソッド
 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
 

Vector3f 型のパラメータを持つ com.jme3.water のメソッド
 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).
 

Vector3f 型のパラメータを持つ com.jme3.water のコンストラクタ
WaterFilter(Node reflectionScene, Vector3f lightDirection)
           
 

jme3tools.navigation での Vector3f の使用
 

Vector3f を返す jme3tools.navigation のメソッド
 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.
 

Vector3f 型のパラメータを持つ jme3tools.navigation のメソッド
 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.
 

jme3tools.optimize での Vector3f の使用
 

Vector3f を返す jme3tools.optimize のメソッド
 Vector3f OCTTriangle.get1()
           
 Vector3f OCTTriangle.get2()
           
 Vector3f OCTTriangle.get3()
           
 Vector3f OCTTriangle.getNormal()
           
 

Vector3f 型のパラメータを持つ jme3tools.optimize のコンストラクタ
OCTTriangle(Vector3f p1, Vector3f p2, Vector3f p3, int index, int geomIndex)