Uses of Class
artofillusion.math.Vec3

Packages that use Vec3
artofillusion   
artofillusion.animation   
artofillusion.animation.distortion   
artofillusion.material   
artofillusion.math   
artofillusion.object   
artofillusion.procedural   
artofillusion.texture   
artofillusion.ui   
artofillusion.view   
 

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.
 



Copyright © 1999-2011 by Peter Eastman.