|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of Vec3 in artofillusion |
---|
Fields in artofillusion declared as Vec3 | |
---|---|
Vec3[] |
RenderingMesh.faceNorm
|
Vec3[] |
RenderingMesh.norm
|
Vec3[] |
WireframeMesh.vert
|
Vec3[] |
RenderingMesh.vert
|
Methods in artofillusion that return Vec3 | |
---|---|
Vec3 |
Camera.convertScreenToWorld(java.awt.Point p,
double depth)
Given a point in screen coordinates, find the corresponding point in world coordinates which is at a specified depth from the viewpoint. |
Vec3 |
Camera.convertScreenToWorld(java.awt.Point p,
double depth,
boolean snapToGrid)
Given a point in screen coordinates, find the corresponding point in world coordinates which is at a specified depth from the viewpoint. |
Vec3 |
Camera.convertScreenToWorld(Vec2 p,
double depth,
boolean snapToGrid)
Given a point in screen coordinates, find the corresponding point in world coordinates which is at a specified depth from the viewpoint. |
Vec3 |
Camera.findDragVector(Vec3 p,
double dx,
double dy)
The following routine is used for dragging objects on the screen. |
Vec3 |
Camera.findDragVector(Vec3 p,
int dx,
int dy)
This is provided for backward compatibility. |
Vec3 |
ViewerCanvas.getDefaultRotationCenter()
Get the default location around which the view should be rotated. |
Vec3 |
SceneViewer.getDefaultRotationCenter()
|
Vec3 |
ViewerCanvas.getRotationCenter()
Get the location around which the view should be rotated. |
Methods in artofillusion with parameters of type Vec3 | |
---|---|
void |
TriMeshEditorWindow.adjustDeltas(Vec3[] delta)
Given a list of deltas which will be added to the selected vertices, calculate the corresponding deltas for the unselected vertices according to the mesh tension. |
void |
SplineMeshEditorWindow.adjustDeltas(Vec3[] delta)
|
abstract void |
MeshEditorWindow.adjustDeltas(Vec3[] delta)
Given a list of deltas which will be added to the selected vertices, calculate the corresponding deltas for the unselected vertices according to the mesh tension. |
void |
CurveEditorWindow.adjustDeltas(Vec3[] delta)
Given a list of deltas which will be added to the selected vertices, calculate the corresponding deltas for the unselected vertices according to the mesh tension. |
void |
Camera.drawBezier(java.awt.Graphics g,
Vec3 v1,
Vec3 v2,
Vec3 v3,
Vec3 v4)
Draw a cubic Bezier curve, using the four specified control vertices. |
void |
Camera.drawBezier2(java.awt.Graphics g,
Vec3 v1,
Vec3 v2,
Vec3 v3,
Vec3 v4)
Draw a cubic Bezier curve, using the four specified control vertices. |
void |
Camera.drawClippedBezier(java.awt.Graphics g,
Vec3 v1,
Vec3 v2,
Vec3 v3,
Vec3 v4)
Same as above, except clip the curve to the front clipping plane. |
void |
Camera.drawClippedLine(java.awt.Graphics g,
Vec3 from,
Vec3 to)
Same as above, except clip the line to the front clipping plane. |
void |
Camera.drawClippedLineTo(java.awt.Graphics g,
Vec3 to)
Same as above, except clip the line to the front clipping plane. |
void |
Camera.drawLine(java.awt.Graphics g,
Vec3 from,
Vec3 to)
Draw a line between two points (specified in object coordinates). |
void |
Camera.drawLineTo(java.awt.Graphics g,
Vec3 to)
Draw a line from the endpoint of the previous line to a new point. |
int |
TriMeshViewer.findClickTarget(java.awt.Point pos,
Vec3 uvw)
Determine which vertex, edge, or face (depending on the current selection mode) the mouse was clicked on. |
Vec3 |
Camera.findDragVector(Vec3 p,
double dx,
double dy)
The following routine is used for dragging objects on the screen. |
Vec3 |
Camera.findDragVector(Vec3 p,
int dx,
int dy)
This is provided for backward compatibility. |
void |
ViewerCanvas.renderImage(java.awt.Image image,
Vec3 p1,
Vec3 p2,
Vec3 p3,
Vec3 p4)
Render an image onto the canvas. |
void |
ViewerCanvas.renderLine(Vec3 p1,
Vec3 p2,
Camera cam,
java.awt.Color color)
Render a line into the image. |
void |
ViewerCanvas.renderMeshTransparent(RenderingMesh mesh,
VertexShader shader,
Camera cam,
Vec3 viewDir,
boolean[] hideFace)
Render an object with flat shading in subtractive (transparent) mode. |
void |
ViewerCanvas.setRotationCenter(Vec3 rotationCenter)
Set the location around which the view should be rotated. |
Constructors in artofillusion with parameters of type Vec3 | |
---|---|
RenderingMesh(Vec3[] vert,
Vec3[] norm,
RenderingTriangle[] triangle,
TextureMapping mapping,
MaterialMapping matMapping)
Construct a rendering mesh. |
|
RenderingMesh(Vec3[] vert,
Vec3[] norm,
RenderingTriangle[] triangle,
TextureMapping mapping,
MaterialMapping matMapping)
Construct a rendering mesh. |
|
WireframeMesh(Vec3[] vert,
int[] from,
int[] to)
|
Uses of Vec3 in artofillusion.animation |
---|
Subclasses of Vec3 in artofillusion.animation | |
---|---|
class |
VectorKeyframe
This class is a vector valued keyframe. |
Methods in artofillusion.animation with parameters of type Vec3 | |
---|---|
boolean |
IKSolver.solve(Vec3[] target,
int maxSteps)
Solve for the new joint positions, given the target positions. |
Constructors in artofillusion.animation with parameters of type Vec3 | |
---|---|
VectorKeyframe(Vec3 v)
|
Uses of Vec3 in artofillusion.animation.distortion |
---|
Methods in artofillusion.animation.distortion with parameters of type Vec3 | |
---|---|
void |
SkeletonShapeEditorWindow.adjustDeltas(Vec3[] delta)
Given a list of deltas which will be added to the selected vertices, calculate the corresponding deltas for the unselected vertices according to the mesh tension. |
Constructors in artofillusion.animation.distortion with parameters of type Vec3 | |
---|---|
IKDistortion(boolean[] locked,
Vec3[] target,
double weight,
Actor actor)
|
Uses of Vec3 in artofillusion.material |
---|
Methods in artofillusion.material that return Vec3 | |
---|---|
Vec3 |
LinearMaterialMapping.getCenter()
Get a vector whose components contain the center position for the mapping. |
Vec3 |
LinearMaterialMapping.getRotations()
Get a vector whose components contain the rotation angles for the mapping. |
Vec3 |
LinearMaterialMapping.getScale()
Get a vector whose components contain the scale factors for the mapping. |
Methods in artofillusion.material with parameters of type Vec3 | |
---|---|
void |
UniformMaterialMapping.getMaterialSpec(Vec3 pos,
MaterialSpec spec,
double size,
double t)
|
abstract void |
MaterialMapping.getMaterialSpec(Vec3 pos,
MaterialSpec spec,
double size,
double t)
Given a point inside the object for which this mapping is being used, find the corresponding material properties. |
void |
LinearMaterialMapping.getMaterialSpec(Vec3 pos,
MaterialSpec spec,
double size,
double time)
|
void |
LinearMaterialMapping.setCenter(Vec3 center)
Set the center position for the mapping. |
void |
LinearMaterialMapping.setRotations(Vec3 angles)
Set the rotation angles for the mapping. |
void |
LinearMaterialMapping.setScale(Vec3 scale)
Set the scale factors for the mapping. |
Uses of Vec3 in artofillusion.math |
---|
Methods in artofillusion.math that return Vec3 | |
---|---|
Vec3 |
Vec3.cross(Vec3 v)
Calculate the cross product of this vector with another one. |
Vec3 |
BoundingBox.getCenter()
Get a vector to the center of the box. |
Vec3[] |
BoundingBox.getCorners()
Get an array containing the coordinates of the corners of the box. |
Vec3 |
CoordinateSystem.getOrigin()
Get the origin of this CoordinateSystem. |
Vec3 |
BoundingBox.getSize()
Get a vector containing the dimensions of the box. |
Vec3 |
CoordinateSystem.getUpDirection()
Get the vector used to define "up" in this CoordinateSystem (usually but not always the y axis direction). |
Vec3 |
CoordinateSystem.getZDirection()
Get this CoordinateSystem's z axis direction. |
Vec3 |
Vec3.minus(Vec3 v)
Calculate the difference between this vector and another one. |
Vec3 |
Vec3.plus(Vec3 v)
Calculate the sum of this vector and another one. |
Vec3 |
Vec3.times(double d)
Create a new Vec3 by multiplying each component of this one by a constant. |
Vec3 |
Mat4.times(Vec3 v)
Multiply this matrix (M) by a vector (v) and return the product Mv. |
Vec3 |
Mat4.timesDirection(Vec3 v)
This method is identical to times(), except that v is assumed to be a direction vector. |
static Vec3 |
Vec3.vx()
Create a unit vector which points in the X direction. |
static Vec3 |
Vec3.vy()
Create a unit vector which points in the Y direction. |
static Vec3 |
Vec3.vz()
Create a unit vector which points in the Z direction. |
Methods in artofillusion.math with parameters of type Vec3 | |
---|---|
void |
Vec3.add(Vec3 v)
Add another Vec3 to this one. |
static Mat4 |
Mat4.axisRotation(Vec3 axis,
double angle)
This routine creates a matrix to rotate a vector around an arbitrary axis. |
void |
Cells.calcFunctions(Vec3 p,
double[] value,
Vec3[] grad,
int[] id)
Calculate the various functions at a specified point. |
void |
Cells.calcFunctions(Vec3 p,
double[] value,
Vec3[] grad,
int[] id)
Calculate the various functions at a specified point. |
static void |
PerlinNoise.calcGradient(Vec3 gradient,
double x,
double y,
double z)
Given a point in 3D space, calculate the gradient of the scalar noise function at that point. |
static void |
Noise.calcGradient(Vec3 gradient,
double x,
double y,
double z)
Given a point in 3D space, calculate the gradient of the scalar noise function at that point. |
static void |
PerlinNoise.calcVector(Vec3 v,
double x,
double y,
double z)
Given a point (x,y,z) in 3D space, set v to the value of the vector noise function at that point. |
static void |
Noise.calcVector(Vec3 v,
double x,
double y,
double z)
Given a point (x,y,z) in 3D space, set v to the value of the vector noise function at that point. |
boolean |
BoundingBox.contains(Vec3 p)
Determine whether the given point lies inside the box. |
Vec3 |
Vec3.cross(Vec3 v)
Calculate the cross product of this vector with another one. |
double |
Vec3.distance(Vec3 v)
Calculate the Euclidean distance between this vector and another one. |
double |
Vec3.distance2(Vec3 v)
Calculate the square of the Euclidean distance between this vector and another one. |
double |
BoundingBox.distanceToPoint(Vec3 p)
Determine the distance between a point and the closest point in the box. |
double |
Vec3.dot(Vec3 v)
Calculate the dot product of this vector with another one. |
double |
CoordinateSystem.getAxisAngleRotation(Vec3 axis)
A rotation can also be described by specifying a rotation axis, and a rotation angle about that axis. |
void |
Noise.NoiseGenerator.getGradient(Vec3 gradient,
double x,
double y,
double z)
|
void |
Noise.NoiseGenerator.getVector(Vec3 v,
double x,
double y,
double z)
|
Vec3 |
Vec3.minus(Vec3 v)
Calculate the difference between this vector and another one. |
void |
Vec3.multiply(Vec3 v)
Multiply each component of this vector by the corresponding component of another vector. |
static void |
SimplexNoise.noiseGradient(Vec3 gradient,
double xin,
double yin,
double zin)
Calculate the gradient of the noise function at a point in 3D space. |
static void |
SimplexNoise.noiseVector(Vec3 v,
double xin,
double yin,
double zin)
Calculate a vector valued noise function at a point in 3D space. |
static Mat4 |
Mat4.objectTransform(Vec3 orig,
Vec3 zdir,
Vec3 updir)
Create a matrix which is the inverse of the viewTransform matrix. |
Vec3 |
Vec3.plus(Vec3 v)
Calculate the sum of this vector and another one. |
void |
Vec3.set(Vec3 v)
Set this Vec3 to be identical to another one. |
void |
CoordinateSystem.setOrientation(Vec3 zdir,
Vec3 updir)
Set the orientation of this CoordinateSystem. |
void |
CoordinateSystem.setOrigin(Vec3 orig)
Set the position of this CoordinateSystem's origin. |
void |
Vec3.subtract(Vec3 v)
Subtract another Vec3 from this one. |
Vec3 |
Mat4.times(Vec3 v)
Multiply this matrix (M) by a vector (v) and return the product Mv. |
Vec3 |
Mat4.timesDirection(Vec3 v)
This method is identical to times(), except that v is assumed to be a direction vector. |
Vec2 |
Mat4.timesXY(Vec3 v)
This method works exactly like the times() method, except that it only calculates the x and y components of the output vector. |
Vec2 |
Mat4.timesXY(Vec3 v,
Vec2 result)
This method works exactly like the times() method, except that it only calculates the x and y components of the output vector. |
double |
Mat4.timesZ(Vec3 v)
This method works like the times() method, except that it only calculates the z component of the output vector. |
void |
Mat4.transform(Vec3 v)
This method works like times(), except that the calculation is done in place. |
void |
Mat4.transformDirection(Vec3 v)
This method works like timesDirection(), except that the calculation is done in place. |
static Mat4 |
Mat4.viewTransform(Vec3 orig,
Vec3 zdir,
Vec3 updir)
Create a matrix for transforming from world coordinates to viewing coordinates. |
Constructors in artofillusion.math with parameters of type Vec3 | |
---|---|
BoundingBox(Vec3 p1,
Vec3 p2)
Create a BoundingBox by specifying two opposite corners. |
|
CoordinateSystem(Vec3 orig,
double x,
double y,
double z)
Create a new coordinate system. |
|
CoordinateSystem(Vec3 orig,
Vec3 zdir,
Vec3 updir)
Create a new coordinate system. |
|
Vec3(Vec3 v)
Create a new Vec3 identical to another one. |
Uses of Vec3 in artofillusion.object |
---|
Fields in artofillusion.object declared as Vec3 | |
---|---|
Vec3 |
MeshVertex.r
|
Methods in artofillusion.object that return Vec3 | |
---|---|
static Vec3 |
Curve.calcApproxPoint(Vec3[] v,
float[] s,
int i,
int j,
int k)
|
static Vec3 |
Curve.calcInterpPoint(Vec3[] v,
float[] s,
int i,
int j,
int k,
int m)
The following two routines are used by subdivideCurve to calculate new point positions for interpolating and approximating subdivision. |
Vec3 |
CSGObject.centerObjects()
Center the component objects, and return the vector by which they were displaced. |
Vec3[] |
TriangleMesh.getNormals()
Get an array of normal vectors. |
Vec3[] |
SplineMesh.getNormals()
Get an array of normal vectors. |
Vec3[] |
Mesh.getNormals()
Get an array of normal vectors, one for each vertex. |
Vec3[] |
Curve.getNormals()
Normal vectors do not make sense for a curve, since it does not define a surface. |
Vec3 |
Sphere.getRadii()
|
Vec3[] |
TriangleMesh.getVertexPositions()
Get a list of the positions of all vertices which define the mesh. |
Vec3[] |
SplineMesh.getVertexPositions()
Get a list of the positions of all vertices which define the mesh. |
Vec3[] |
Mesh.getVertexPositions()
Get a list of the positions of all vertices which define the mesh. |
Vec3[] |
Curve.getVertexPositions()
Get a list of the positions of all vertices which define the mesh. |
Methods in artofillusion.object with parameters of type Vec3 | |
---|---|
static Vec3 |
Curve.calcApproxPoint(Vec3[] v,
float[] s,
int i,
int j,
int k)
|
static Vec3 |
Curve.calcInterpPoint(Vec3[] v,
float[] s,
int i,
int j,
int k,
int m)
The following two routines are used by subdivideCurve to calculate new point positions for interpolating and approximating subdivision. |
void |
ImplicitSphere.getFieldGradient(double x,
double y,
double z,
double size,
double time,
Vec3 grad)
|
void |
ImplicitObject.getFieldGradient(double x,
double y,
double z,
double size,
double time,
Vec3 grad)
Get the gradient of the field function at a point specified in object coordinates. |
void |
CompoundImplicitObject.getFieldGradient(double x,
double y,
double z,
double size,
double time,
Vec3 grad)
|
void |
SpotLight.getLight(RGBColor light,
Vec3 position)
Get the attenuated light at a given position relative to the light source. |
void |
ProceduralPointLight.getLight(RGBColor light,
Vec3 position)
Evaluate the Procedure to determine the light color at a point. |
void |
ProceduralDirectionalLight.getLight(RGBColor light,
Vec3 position)
Evaluate the Procedure to determine the light color at a point. |
void |
PointLight.getLight(RGBColor light,
Vec3 position)
Get the attenuated light at a given position relative to the light source. |
abstract void |
Light.getLight(RGBColor light,
Vec3 position)
Get the attenuated light at a given position relative to the light source. |
void |
DirectionalLight.getLight(RGBColor light,
Vec3 position)
Directional lights are not attenuated with distance, since the light source is far outside the scene. |
void |
SceneCamera.getRayFromCamera(double x,
double y,
double dof1,
double dof2,
Vec3 origin,
Vec3 direction)
Compute a ray from the camera location through a point in its field of, represented in the camera's local coordinate system. |
void |
Curve.movePoint(int which,
Vec3 pos)
Move a single control vertex. |
void |
ReferenceImage.renderObject(ObjectInfo obj,
ViewerCanvas canvas,
Vec3 viewDir)
This method is overridden to render the reference image into the ViewerCanvas. |
void |
ObjectWrapper.renderObject(ObjectInfo obj,
ViewerCanvas canvas,
Vec3 viewDir)
|
void |
ObjectCollection.renderObject(ObjectInfo obj,
ViewerCanvas canvas,
Vec3 viewDir)
RenderObject is overridden to render each component object individually. |
void |
Object3D.renderObject(ObjectInfo obj,
ViewerCanvas canvas,
Vec3 viewDir)
Render this object into a ViewerCanvas. |
void |
Curve.setShape(Vec3[] v,
float[] smoothness)
Set both the positions and smoothness values for all points. |
void |
TriangleMesh.setVertexPositions(Vec3[] v)
Set the positions for all the vertices of the mesh. |
void |
SplineMesh.setVertexPositions(Vec3[] v)
Set the positions for all the vertices of the mesh. |
void |
Mesh.setVertexPositions(Vec3[] v)
Set the positions for all the vertices of the mesh. |
void |
Curve.setVertexPositions(Vec3[] v)
Set new positions for all vertices. |
Method parameters in artofillusion.object with type arguments of type Vec3 | |
---|---|
void |
ImplicitObject.generateMesh(double tol,
java.util.List<Vec3> vertices,
java.util.List<int[]> faces)
Construct a mesh from the implicit function. |
Constructors in artofillusion.object with parameters of type Vec3 | |
---|---|
Curve(Vec3[] v,
float[] smoothness,
int smoothingMethod,
boolean isClosed)
|
|
MeshVertex(Vec3 p)
|
|
SplineMesh(Vec3[][] v,
float[] usmoothness,
float[] vsmoothness,
int smoothingMethod,
boolean uclosed,
boolean vclosed)
v is an array containing the points of the control mesh, with the first index corresponding to the U direction, and the second to the V direction. |
|
TriangleMesh.Vertex(Vec3 p)
|
|
TriangleMesh(Vec3[] v,
int[][] faces)
The constructor takes three arguments. |
|
Tube(Vec3[] v,
double thickness,
int smoothingMethod,
int endsStyle)
Create a tube with uniform thickness and a smoothness of 1 at all vertices. |
|
Tube(Vec3[] v,
float[] smoothness,
double[] thickness,
int smoothingMethod,
int endsStyle)
Create a tube, explicitly specifying all parameters. |
Uses of Vec3 in artofillusion.procedural |
---|
Methods in artofillusion.procedural with parameters of type Vec3 | |
---|---|
void |
Procedure.getOutputGradient(int which,
Vec3 grad)
This routine returns the gradient of the specified output module. |
void |
WoodModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
ViewAngleModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
TurbulenceModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
TransformModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
SumModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
SqrtModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
SphericalModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
SineModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
ScaleShiftModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
RatioModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
RandomModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
ProductModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
PowerModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
PolarModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
OutputModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
NoiseModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
Module.getValueGradient(int which,
Vec3 grad,
double blur)
Get the gradient of the value of the specified output port. |
void |
ModModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
MinModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
MaxModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
MarbleModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
LogModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
JitterModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
InterpModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
ImageModule.getValueGradient(int which,
Vec3 grad,
double blur)
Get the gradient of one of the components. |
void |
GridModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
GainModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
FunctionModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
ExprModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
ExpModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
DifferenceModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
CosineModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
CoordinateModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
CompareModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
ClipModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
CheckerModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
CellsModule.getValueGradient(int which,
Vec3 grad,
double blur)
Calculate the gradient of an output. |
void |
BrickModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
BlurModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
BiasModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
AbsModule.getValueGradient(int which,
Vec3 grad,
double blur)
|
void |
NumberModule.getValueGradient(Vec3 grad,
double blur)
|
Uses of Vec3 in artofillusion.texture |
---|
Fields in artofillusion.texture declared as Vec3 | |
---|---|
Vec3 |
TextureSpec.bumpGrad
|
Methods in artofillusion.texture that return Vec3 | |
---|---|
Vec3 |
LinearMapping3D.getCenter()
Get a vector whose components contain the center position for the mapping. |
Vec3 |
SphericalMapping.getRotations()
Get a vector whose components contain the rotation angles for the mapping. |
Vec3 |
ProjectionMapping.getRotations()
Get a vector whose components contain the rotation angles for the mapping. |
Vec3 |
LinearMapping3D.getRotations()
Get a vector whose components contain the rotation angles for the mapping. |
Vec3 |
CylindricalMapping.getRotations()
Get a vector whose components contain the rotation angles for the mapping. |
Vec3 |
LinearMapping3D.getScale()
Get a vector whose components contain the scale factors for the mapping. |
Methods in artofillusion.texture with parameters of type Vec3 | |
---|---|
double |
UVMapping.getDisplacement(Vec3 pos,
double size,
double time,
double[] param)
This method should not generally be called. |
double |
UniformMapping.getDisplacement(Vec3 pos,
double size,
double t,
double[] param)
|
abstract double |
TextureMapping.getDisplacement(Vec3 pos,
double size,
double t,
double[] param)
Given a point on the surface, evaluate the displacement function. |
double |
SphericalMapping.getDisplacement(Vec3 pos,
double size,
double time,
double[] param)
|
double |
ProjectionMapping.getDisplacement(Vec3 pos,
double size,
double time,
double[] param)
|
double |
LinearMapping3D.getDisplacement(Vec3 pos,
double size,
double time,
double[] param)
|
double |
LayeredMapping.getDisplacement(Vec3 pos,
double size,
double t,
double[] param)
Determine the displacement height by adding up all of the layers. |
double |
CylindricalMapping.getDisplacement(Vec3 pos,
double size,
double t,
double[] param)
|
void |
UVMapping.getTextureSpec(Vec3 pos,
TextureSpec spec,
double angle,
double size,
double time,
double[] param)
This method should not generally be called. |
void |
UniformMapping.getTextureSpec(Vec3 pos,
TextureSpec spec,
double angle,
double size,
double t,
double[] param)
|
abstract void |
TextureMapping.getTextureSpec(Vec3 pos,
TextureSpec spec,
double angle,
double size,
double t,
double[] param)
Given a point on the surface for which this mapping is being used, find the corresponding surface properties. |
void |
SphericalMapping.getTextureSpec(Vec3 pos,
TextureSpec spec,
double angle,
double size,
double time,
double[] param)
|
void |
ProjectionMapping.getTextureSpec(Vec3 pos,
TextureSpec spec,
double angle,
double size,
double time,
double[] param)
|
void |
LinearMapping3D.getTextureSpec(Vec3 pos,
TextureSpec spec,
double angle,
double size,
double time,
double[] param)
|
void |
LayeredMapping.getTextureSpec(Vec3 pos,
TextureSpec spec,
double angle,
double size,
double t,
double[] param)
Determine the surface properties by adding up the properties of all of the layers. |
void |
CylindricalMapping.getTextureSpec(Vec3 pos,
TextureSpec spec,
double angle,
double size,
double t,
double[] param)
|
void |
UVMapping.getTransparency(Vec3 pos,
RGBColor trans,
double angle,
double size,
double time,
double[] param)
This method should not generally be called. |
void |
UniformMapping.getTransparency(Vec3 pos,
RGBColor trans,
double angle,
double size,
double t,
double[] param)
|
abstract void |
TextureMapping.getTransparency(Vec3 pos,
RGBColor trans,
double angle,
double size,
double t,
double[] param)
Same as above, except only return the transparent color. |
void |
SphericalMapping.getTransparency(Vec3 pos,
RGBColor trans,
double angle,
double size,
double time,
double[] param)
|
void |
ProjectionMapping.getTransparency(Vec3 pos,
RGBColor trans,
double angle,
double size,
double time,
double[] param)
|
void |
LinearMapping3D.getTransparency(Vec3 pos,
RGBColor trans,
double angle,
double size,
double time,
double[] param)
|
void |
LayeredMapping.getTransparency(Vec3 pos,
RGBColor trans,
double angle,
double size,
double t,
double[] param)
Determine the transparency by adding up all of the layers. |
void |
CylindricalMapping.getTransparency(Vec3 pos,
RGBColor trans,
double angle,
double size,
double t,
double[] param)
|
RenderingTriangle |
UVMapping.mapTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
Vec3[] vert)
Create a UV mapped triangle. |
RenderingTriangle |
UniformMapping.mapTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
Vec3[] vert)
|
RenderingTriangle |
TextureMapping.mapTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
Vec3[] vert)
Given the vertices to be mapped and their normal vectors, generate a RenderingTriangle. |
RenderingTriangle |
SphericalMapping.mapTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
Vec3[] vert)
|
RenderingTriangle |
ProjectionMapping.mapTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
Vec3[] vert)
Create a rendering triangle with this mapping. |
RenderingTriangle |
LinearMapping3D.mapTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
Vec3[] vert)
|
RenderingTriangle |
LayeredMapping.mapTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
Vec3[] vert)
|
RenderingTriangle |
CylindricalMapping.mapTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
Vec3[] vert)
|
void |
LinearMapping3D.setCenter(Vec3 center)
Set the center position for the mapping. |
void |
SphericalMapping.setRotations(Vec3 angles)
Set the rotation angles for the mapping. |
void |
ProjectionMapping.setRotations(Vec3 angles)
Set the rotation angles for the mapping. |
void |
LinearMapping3D.setRotations(Vec3 angles)
Set the rotation angles for the mapping. |
void |
CylindricalMapping.setRotations(Vec3 angles)
Set the rotation angles for the mapping. |
void |
LinearMapping3D.setScale(Vec3 scale)
Set the scale factors for the mapping. |
void |
UVWMappedTriangle.setTextureCoordinates(float r1,
float s1,
float t1,
float r2,
float s2,
float t2,
float r3,
float s3,
float t3,
Vec3 vert1,
Vec3 vert2,
Vec3 vert3)
Set the texture coordinates for this triangle and update various internal parameters. |
void |
UVMappedTriangle.setTextureCoordinates(float s1,
float t1,
float s2,
float t2,
float s3,
float t3,
Vec3 vert1,
Vec3 vert2,
Vec3 vert3)
Set the texture coordinates for this triangle and update various internal parameters. |
Constructors in artofillusion.texture with parameters of type Vec3 | |
---|---|
LayeredTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
double t1x,
double t1y,
double t1z,
double t2x,
double t2y,
double t2z,
double t3x,
double t3y,
double t3z,
LayeredMapping theMapping,
LayeredTexture theTexture,
Vec3[] vert)
|
|
Nonlinear2DTriangle(int v1,
int v2,
int v3,
int n1,
int n2,
int n3,
Vec3 t1,
Vec3 t2,
Vec3 t3)
|
Uses of Vec3 in artofillusion.ui |
---|
Methods in artofillusion.ui that return Vec3 | |
---|---|
Vec3 |
Compound3DManipulator.getAxisDirection(Compound3DManipulator.Axis axis,
ViewerCanvas view)
Get the direction of a particular axis. |
Methods in artofillusion.ui with parameters of type Vec3 | |
---|---|
void |
Compound3DManipulator.mousePressedOnHandle(WidgetMouseEvent ev,
ViewerCanvas view,
BoundingBox selectionBounds,
Vec3 handleLocation)
|
void |
Compound3DManipulator.setNPQAxes(Vec3 nDir,
Vec3 pDir,
Vec3 qDir)
Set the axis directions to be used in NPQ mode. |
Uses of Vec3 in artofillusion.view |
---|
Methods in artofillusion.view with parameters of type Vec3 | |
---|---|
void |
SoftwareCanvasDrawer.renderImage(java.awt.Image image,
Vec3 p1,
Vec3 p2,
Vec3 p3,
Vec3 p4,
Camera camera)
Render an image onto the canvas. |
void |
GLCanvasDrawer.renderImage(java.awt.Image image,
Vec3 p1,
Vec3 p2,
Vec3 p3,
Vec3 p4,
Camera camera)
Render an image onto the canvas. |
void |
CanvasDrawer.renderImage(java.awt.Image image,
Vec3 p1,
Vec3 p2,
Vec3 p3,
Vec3 p4,
Camera camera)
Render an image onto the canvas. |
void |
SoftwareCanvasDrawer.renderLine(Vec3 p1,
Vec3 p2,
Camera cam,
java.awt.Color color)
Render a line into the image. |
void |
GLCanvasDrawer.renderLine(Vec3 p1,
Vec3 p2,
Camera cam,
java.awt.Color color)
Render a line into the image. |
void |
CanvasDrawer.renderLine(Vec3 p1,
Vec3 p2,
Camera cam,
java.awt.Color color)
Render a line into the image. |
void |
SoftwareCanvasDrawer.renderMeshTransparent(RenderingMesh mesh,
VertexShader shader,
Camera cam,
Vec3 viewDir,
boolean[] hideFace)
Render an object with flat shading in subtractive (transparent) mode. |
void |
GLCanvasDrawer.renderMeshTransparent(RenderingMesh mesh,
VertexShader shader,
Camera cam,
Vec3 viewDir,
boolean[] hideFace)
Render an object with flat shading in subtractive (transparent) mode. |
void |
CanvasDrawer.renderMeshTransparent(RenderingMesh mesh,
VertexShader shader,
Camera cam,
Vec3 viewDir,
boolean[] hideFace)
Render an object with flat shading in subtractive (transparent) mode. |
Constructors in artofillusion.view with parameters of type Vec3 | |
---|---|
FlatVertexShader(RenderingMesh mesh,
Object3D object,
double time,
Vec3 viewDir)
Create a FlatVertexShader for a mesh. |
|
FlatVertexShader(RenderingMesh mesh,
RGBColor color,
Vec3 viewDir)
Create a FlatVertexShader for a mesh. |
|
ParameterVertexShader(RenderingMesh mesh,
ParameterValue param,
RGBColor lowColor,
RGBColor highColor,
double minValue,
double maxValue,
Vec3 viewDir)
Create a ParameterVertexShader for a mesh. |
|
SmoothVertexShader(RenderingMesh mesh,
Object3D object,
double time,
Vec3 viewDir)
Create a SmoothVertexShader for a mesh. |
|
SmoothVertexShader(RenderingMesh mesh,
RGBColor color,
Vec3 viewDir)
Create a SmoothVertexShader for a mesh. |
|
TexturedVertexShader(RenderingMesh mesh,
Object3D object,
double time,
Vec3 viewDir)
Create a TexturedVertexShader for a mesh. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |