Uses of Class
org.vizzini.math.Vector

Packages that use Vector
org.vizzini.game Provides core game classes for the game framework. 
org.vizzini.game.simulation Provides simulation classes for games in the game framework. 
org.vizzini.game.simulation.force Provides force classes for simulations in the game framework. 
org.vizzini.math Provides math classes for the game framework. 
org.vizzini.math.orbit Provides math classes for orbit mechanics in the game framework. 
org.vizzini.ui.game.boardgame Provides board game user interface classes for the game framework. 
org.vizzini.ui.game.boardgame.chess Provides user interface classes for 3D chess for the game framework. 
org.vizzini.ui.graphics Provides graphics classes for the game framework. 
org.vizzini.ui.graphics.shape Provides graphics shape classes for the game framework. 
 

Uses of Vector in org.vizzini.game
 

Methods in org.vizzini.game that return Vector
 Vector VectorPosition.getVector()
           
 

Constructors in org.vizzini.game with parameters of type Vector
VectorPosition(Vector vector)
          Construct this object with the given parameters.
 

Uses of Vector in org.vizzini.game.simulation
 

Methods in org.vizzini.game.simulation that return Vector
 Vector AbstractPhysicalObject.computeForce(IForceConsumer consumer)
          Return the force (kN) created by this system.
protected  Vector AbstractPhysicalObject.computeGravity(Vector position, double mass)
          Return the force (kN) created by this object at the mass at the given position.
protected  Vector AbstractPhysicalObject.convertToLocal(Vector v)
          Return the given vector converted to local coordinates.
 

Methods in org.vizzini.game.simulation with parameters of type Vector
 void AbstractPhysicalObject.applyForce(Vector force)
          Apply the given force through the center of mass to this object.
 void AbstractPhysicalObject.applyForce(Vector force, Vector position)
          Apply the given force at the given position to this object.
 void AbstractPhysicalObject.applyForceLocal(Vector force, Vector position)
          Apply the given force at the given position to this object where these vectors are expressed in local coordinates.
protected  Vector AbstractPhysicalObject.computeGravity(Vector position, double mass)
          Return the force (kN) created by this object at the mass at the given position.
protected  Vector AbstractPhysicalObject.convertToLocal(Vector v)
          Return the given vector converted to local coordinates.
 

Uses of Vector in org.vizzini.game.simulation.force
 

Methods in org.vizzini.game.simulation.force that return Vector
 Vector IForceProducer.computeForce(IForceConsumer consumer)
          Return the force (kN) created by this system.
 

Methods in org.vizzini.game.simulation.force with parameters of type Vector
 void IForceConsumer.applyForce(Vector force)
          Apply the given force through the center of mass to this object.
 void IForceConsumer.applyForce(Vector force, Vector position)
          Apply the given force at the given position to this object.
 void IForceConsumer.applyForceLocal(Vector force, Vector position)
          Apply the given force at the given position to this object where these vectors are expressed in local coordinates.
 

Uses of Vector in org.vizzini.math
 

Fields in org.vizzini.math declared as Vector
static Vector Vector.X_AXIS
          X axis.
static Vector Vector.Y_AXIS
          Y axis.
static Vector Vector.Z_AXIS
          Z axis.
static Vector Vector.ZERO
          Zero vector.
 

Methods in org.vizzini.math that return Vector
 Vector Vector.add(Vector v)
          Return a new Vector which is the sum of this and the given vector..
 Vector DynamicState.convertLocalToWorld(Vector v)
          Convert the given vector from local coordinates to world coordinates.
 Vector IState.convertLocalToWorld(Vector v)
          Convert the given vector from local coordinates to world coordinates.
 Vector State.convertLocalToWorld(Vector v)
          Convert the given vector from local coordinates to world coordinates.
 Vector DynamicState.convertWorldToLocal(Vector v)
          Convert the given vector from world coordinates to local coordinates.
 Vector IState.convertWorldToLocal(Vector v)
          Convert the given vector from world coordinates to local coordinates.
 Vector State.convertWorldToLocal(Vector v)
          Convert the given vector from world coordinates to local coordinates.
 Vector Vector.cross(Vector v)
          Return a new vector which is the cross between the given vectors.
 Vector Vector.cross(Vector v, boolean force)
          Return a new vector which is the cross between this and the given vector.
 Vector Vector.divide(double m)
          Return a new vector divided by the given scalar.
 Vector DynamicState.getAcceleration()
          Return the acceleration in length time^-2 units.
 Vector IDynamicState.getAcceleration()
          Return the acceleration in length time^-2 units.
 Vector DynamicState.getPosition()
          Return the position vector.
 Vector IState.getPosition()
          Return the position vector.
 Vector State.getPosition()
          Return the position vector.
 Vector DynamicState.getPreviousPosition()
          Return the previous position vector.
 Vector IState.getPreviousPosition()
          Return the previous position vector.
 Vector State.getPreviousPosition()
          Return the previous position vector.
 Vector Quaternion.getVector()
          Return the rotation vector.
 Vector DynamicState.getVelocity()
          Return the velocity in length time^-1 units.
 Vector IDynamicState.getVelocity()
          Return the velocity in length time^-1 units.
 Vector[] Ellipsoid.intersections(Ellipsoid other)
          Return the intersection point(s) of the given ellipsoid and this.
 Vector[] Ellipsoid.intersections(Vector v0, Vector v1)
          Return the intersection point(s) of the line described by the input vectors.
 Vector[] Ellipsoid.intersections(Vector v0, Vector v1, boolean beforeStart, boolean afterEnd)
          Return the intersection point(s) of the line described by the input vectors.
 Vector Vector.multiply(double m)
          Return a new vector multiplied by the given scalar.
 Vector DynamicState.orientLocalToWorld(Vector v)
          Orient the given vector from local coordinates to world coordinates.
 Vector IState.orientLocalToWorld(Vector v)
          Orient the given vector from local coordinates to world coordinates.
 Vector State.orientLocalToWorld(Vector v)
          Orient the given vector from local coordinates to world coordinates.
 Vector DynamicState.orientWorldToLocal(Vector v)
          Orient the given vector from world coordinates to local coordinates.
 Vector IState.orientWorldToLocal(Vector v)
          Orient the given vector from world coordinates to local coordinates.
 Vector State.orientWorldToLocal(Vector v)
          Orient the given vector from world coordinates to local coordinates.
static Vector Vector.parseVector(String vectorString)
          Parse the given string into a Vector.
 Vector Quaternion.postMultiply(Vector v)
          Return a new Vector which is the result of multiplying the given vector with this quaternion.
 Vector Quaternion.preMultiply(Vector v)
          Return a new Vector which is the result of multiplying this quaternion with the given vector.
 Vector Vector.subtract(Vector v)
          Return a new Vector which is this minus the given vector..
 Vector Vector.unit()
          Return a new vector which is a unit vector of this.
 

Methods in org.vizzini.math with parameters of type Vector
 Vector Vector.add(Vector v)
          Return a new Vector which is the sum of this and the given vector..
 void DynamicState.addAcceleration(Vector acceleration)
          Add a positional acceleration.
 void IDynamicState.addAcceleration(Vector acceleration)
          Add a positional acceleration.
 double Vector.angle(Vector v)
          Return the angle between this vector and the given vector, in radians.
 void DynamicState.applyForce(Vector force)
          Apply the given force through the center of mass to this object.
 void IDynamicState.applyForce(Vector force)
          Apply the given force through the center of mass to this object.
 void DynamicState.applyForce(Vector force, Vector position)
          Apply the given force at the given position to this object.
 void IDynamicState.applyForce(Vector force, Vector position)
          Apply the given force at the given position to this object.
 void DynamicState.applyForceLocal(Vector force, Vector position)
          Apply the given force at the given position to this object where these vectors are expressed in local coordinates.
 void IDynamicState.applyForceLocal(Vector force, Vector position)
          Apply the given force at the given position to this object where these vectors are expressed in local coordinates.
protected  void DynamicState.applyTorque(Vector force, Vector position)
          Apply the given torque to this object where these vectors are expressed in local coordinates.
 boolean Ellipsoid.contains(Vector v)
          Return true if the given point is inside or on the surface of this ellipsoid.
 Vector DynamicState.convertLocalToWorld(Vector v)
          Convert the given vector from local coordinates to world coordinates.
 Vector IState.convertLocalToWorld(Vector v)
          Convert the given vector from local coordinates to world coordinates.
 Vector State.convertLocalToWorld(Vector v)
          Convert the given vector from local coordinates to world coordinates.
 Vector DynamicState.convertWorldToLocal(Vector v)
          Convert the given vector from world coordinates to local coordinates.
 Vector IState.convertWorldToLocal(Vector v)
          Convert the given vector from world coordinates to local coordinates.
 Vector State.convertWorldToLocal(Vector v)
          Convert the given vector from world coordinates to local coordinates.
 Vector Vector.cross(Vector v)
          Return a new vector which is the cross between the given vectors.
 Vector Vector.cross(Vector v, boolean force)
          Return a new vector which is the cross between this and the given vector.
 double Vector.dot(Vector v)
          Return the vector dot product.
 double Ellipsoid.ellipsoidEquation(Vector v)
          Return the result of using the given vector in the ellipsoid equation x^2/A^2 + y^2/B^2 + z^2/C^2.
 String VectorFormat.format(Vector vector)
          Return a formatted string version of the given Vector.
 double[] Ellipsoid.intersectionParameters(Vector v0, Vector v1)
          Return the intersection parameter(s) of the line described by the input vectors.
 double[] Ellipsoid.intersectionParameters(Vector v0, Vector v1, boolean beforeStart, boolean afterEnd)
          Return the intersection parameter(s) of the line described by the input vectors.
 Vector[] Ellipsoid.intersections(Vector v0, Vector v1)
          Return the intersection point(s) of the line described by the input vectors.
 Vector[] Ellipsoid.intersections(Vector v0, Vector v1, boolean beforeStart, boolean afterEnd)
          Return the intersection point(s) of the line described by the input vectors.
 boolean Ellipsoid.intersects(Vector v0, Vector v1)
          Return true if the line described by the parameters intersects this ellipsoid.
 void DynamicState.move(Vector movement)
          Move using the given vector.
 void IState.move(Vector movement)
          Move using the given vector.
 void State.move(Vector movement)
          Move using the given vector.
 Vector DynamicState.orientLocalToWorld(Vector v)
          Orient the given vector from local coordinates to world coordinates.
 Vector IState.orientLocalToWorld(Vector v)
          Orient the given vector from local coordinates to world coordinates.
 Vector State.orientLocalToWorld(Vector v)
          Orient the given vector from local coordinates to world coordinates.
 Vector DynamicState.orientWorldToLocal(Vector v)
          Orient the given vector from world coordinates to local coordinates.
 Vector IState.orientWorldToLocal(Vector v)
          Orient the given vector from world coordinates to local coordinates.
 Vector State.orientWorldToLocal(Vector v)
          Orient the given vector from world coordinates to local coordinates.
 Vector Quaternion.postMultiply(Vector v)
          Return a new Vector which is the result of multiplying the given vector with this quaternion.
 Vector Quaternion.preMultiply(Vector v)
          Return a new Vector which is the result of multiplying this quaternion with the given vector.
 void DynamicState.setAcceleration(Vector acceleration)
          Set the acceleration.
 void IDynamicState.setAcceleration(Vector acceleration)
          Set the acceleration.
 void DynamicState.setPosition(Vector position)
          Set the position.
 void IState.setPosition(Vector position)
          Set the position.
 void State.setPosition(Vector position)
          Set the position.
 void DynamicState.setVelocity(Vector velocity)
          Set the velocity.
 void IDynamicState.setVelocity(Vector velocity)
          Set the velocity.
 Vector Vector.subtract(Vector v)
          Return a new Vector which is this minus the given vector..
 

Constructors in org.vizzini.math with parameters of type Vector
Quaternion(Vector v, double angle)
          Construct this object with the given parameters.
Vector(double t, Vector v0, Vector v1)
          Construct a vector from v0 to v1 at t.
 

Uses of Vector in org.vizzini.math.orbit
 

Methods in org.vizzini.math.orbit that return Vector
 Vector OrbitMechanic.computeE(double mu, Vector r, Vector v)
          Compute the eccentricity vector E.
 Vector OrbitMechanic.computeH(Vector r, Vector v)
          Compute the angular momentum vector H.
 Vector OrbitMechanic.computeN(Vector h)
          Compute the node vector N.
 Vector OrbitMechanic.computeR(double mu, double a, double ecc, double i, double omega, double w, double nu)
          Compute the position vector for the given orbit elements.
 Vector[] OrbitMechanic.computeRAndV(double mu, double a, double ecc, double i, double omega, double w, double nu)
          Compute the position and velocity vectors for the given orbit elements.
 Vector OrbitMechanic.computeV(double mu, double a, double ecc, double i, double omega, double w, double nu)
          Compute the velocity vector for the given orbit elements.
 Vector AbstractOrbit.getE()
          Return the eccentricity vector.
 Vector CircularOrbit.getE()
          Return the eccentricity vector.
 Vector IOrbit.getE()
          Return the eccentricity vector.
 Vector AbstractOrbit.getH()
          Return the angular momentum vector.
 Vector IOrbit.getH()
          Return the angular momentum vector.
 Vector AbstractOrbit.getN()
          Return the node vector.
 Vector IOrbit.getN()
          Return the node vector.
 Vector AbstractOrbit.getR(double t)
          Return the position vector.
 Vector IOrbit.getR(double t)
          Return the position vector.
 Vector AbstractOrbit.getR0()
          Return the position vector at epoch.
 Vector IOrbit.getR0()
          Return the position vector at epoch.
 Vector AbstractOrbit.getV(double t)
          Return the velocity vector.
 Vector IOrbit.getV(double t)
          Return the velocity vector.
 Vector AbstractOrbit.getV0()
          Return the velocity vector at epoch.
 Vector IOrbit.getV0()
          Return the velocity vector at epoch.
 

Methods in org.vizzini.math.orbit with parameters of type Vector
 Vector OrbitMechanic.computeE(double mu, Vector r, Vector v)
          Compute the eccentricity vector E.
 double OrbitMechanic.computeEcc(double mu, Vector r, Vector v)
          Compute the eccentricity.
 Vector OrbitMechanic.computeH(Vector r, Vector v)
          Compute the angular momentum vector H.
 Vector OrbitMechanic.computeN(Vector h)
          Compute the node vector N.
 double OrbitMechanic.computeOmega(Vector n)
          Compute the longitude of the ascending node.
 double OrbitMechanic.computeTrueAnomaly(Vector e, Vector n, Vector r, Vector v)
          Compute the true anomaly from the given parameters.
 double OrbitMechanic.computeW(Vector e, Vector n)
          Compute the argument of periapsis.
 IOrbit OrbitFactory.create(double mu, Vector r0, Vector v0, double t0)
          Return an orbit instance for the given parameters.
protected  void AbstractOrbit.setR0(Vector r0)
           
protected  void AbstractOrbit.setV0(Vector v0)
           
 

Constructors in org.vizzini.math.orbit with parameters of type Vector
AbstractOrbit(double mu, Vector r, Vector v)
          Construct this object using the given parameters.
AbstractOrbit(double mu, Vector r0, Vector v0, double t0)
          Construct this object using the given parameters.
CircularOrbit(double mu, Vector r0, Vector v0)
          Construct this object using the given parameters.
CircularOrbit(double mu, Vector r0, Vector v0, double t0)
          Construct this object using the given parameters.
EllipticOrbit(double mu, Vector r, Vector v)
          Construct this object using the given parameters.
EllipticOrbit(double mu, Vector r, Vector v, double t0)
          Construct this object using the given parameters.
HyperbolicOrbit(double mu, Vector r, Vector v)
          Construct this object using the given parameters.
HyperbolicOrbit(double mu, Vector r, Vector v, double t0)
          Construct this object using the given parameters.
ParabolicOrbit(double mu, Vector r, Vector v)
          Construct this object using the given parameters.
ParabolicOrbit(double mu, Vector r, Vector v, double t0)
          Construct this object using the given parameters.
 

Uses of Vector in org.vizzini.ui.game.boardgame
 

Methods in org.vizzini.ui.game.boardgame that return Vector
protected  Vector[][] BoardShape.getCenters()
          Return the offset.
 

Methods in org.vizzini.ui.game.boardgame with parameters of type Vector
 void BoardShape.computeScreenPoints(Quaternion q, Vector v, double magnify, int offsetX, int offsetY, double d)
          Compute the points of this shape in screen coordinates.
 

Uses of Vector in org.vizzini.ui.game.boardgame.chess
 

Methods in org.vizzini.ui.game.boardgame.chess that return Vector
protected  Vector[] PieceShape.preprocessSpine(Vector[] spine)
          Process the spine to adjust to the BoardShape.
 

Methods in org.vizzini.ui.game.boardgame.chess with parameters of type Vector
 void PieceShape.initPoints(double width, double height, double depth, Vector[] spine, double[] scale)
          Initialize the points of this shape.
protected  Vector[] PieceShape.preprocessSpine(Vector[] spine)
          Process the spine to adjust to the BoardShape.
 

Uses of Vector in org.vizzini.ui.graphics
 

Methods in org.vizzini.ui.graphics that return Vector
 Vector IShape.getDimensions()
          Return the dimensions in world coordinates.
 Vector ShapeCanvasJava3D.getPositionOffset()
           
 Vector IShape.getScreenCenter()
          Return this shape's center in screen coordinates.
 

Methods in org.vizzini.ui.graphics with parameters of type Vector
 void IShape.computeScreenPoints(Quaternion q, Vector v, double magnify, int offsetX, int offsetY, double d)
          Compute the points of this shape in screen coordinates.
 void ShapeGroup.computeScreenPoints(Quaternion q, Vector v, double magnify, int offsetX, int offsetY, double d)
          Compute the screen points of all the shapes.
 void ShapeSortList.computeScreenPoints(Quaternion q, Vector v, double magnify, int offsetX, int offsetY, double d)
          Compute the screen points for all shapes.
 void ShapeCanvasJava3D.setPositionOffset(Vector positionOffset)
           
 

Uses of Vector in org.vizzini.ui.graphics.shape
 

Fields in org.vizzini.ui.graphics.shape declared as Vector
protected  Vector[] AbstractShape._points
          The absolute point relative to the center.
protected  Vector AbstractShape._screenCenter
          The center in screen coordinates.
protected  Vector[] AbstractShape._screenPoints
          The shape's points in screen coordinates.
 

Methods in org.vizzini.ui.graphics.shape that return Vector
protected  Vector AbstractShape.computeScreenCenter(Quaternion q, Vector v, double magnify, int offsetX, int offsetY)
          Compute the center in screen coordinates.
protected  Vector Ellipse.computeScreenCenter(Quaternion q, Vector v, double magnify, int offsetX, int offsetY)
          Compute the center in screen coordinates.
 Vector AbstractShape.getDimensions()
          Return the dimensions in world coordinates.
 Vector AbstractShape.getScreenCenter()
          Return this shape's center in screen coordinates.
 

Methods in org.vizzini.ui.graphics.shape with parameters of type Vector
protected  Vector AbstractShape.computeScreenCenter(Quaternion q, Vector v, double magnify, int offsetX, int offsetY)
          Compute the center in screen coordinates.
protected  Vector Ellipse.computeScreenCenter(Quaternion q, Vector v, double magnify, int offsetX, int offsetY)
          Compute the center in screen coordinates.
 void AbstractShape.computeScreenPoints(Quaternion q, Vector v, double magnify, int offsetX, int offsetY, double d)
          Compute the points of this shape in screen coordinates.
 void ExtrudedShape.computeScreenPoints(Quaternion q, Vector v, double magnify, int offsetX, int offsetY, double d)
          Compute the points of this shape in screen coordinates.
 void PolygonShape.computeScreenPoints(Quaternion q, Vector v, double magnify, int offsetX, int offsetY, double d)
          Compute the points of this shape in screen coordinates.
protected  void ExtrudedShape.initPoints(double width, double height, double depth, Vector[] spine, double[] crossSection, double[] scale, double[] orientation)
          Calculate the points from the given description of an extruded object.
 



Copyright © 2007 Vizzini.org. All Rights Reserved. 2007.12.25.03.00.02