Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
toxi.geom.Vec3D

Packages that use Vec3D
toxi.geom |
toxi.geom.mesh |
toxi.geom.mesh.subdiv |

Uses of Vec3D in toxi.geom

Subclasses of Vec3D in toxi.geom
`class` | `AABB` Axis-aligned bounding box with basic intersection features for Ray, AABB and Sphere classes.
`class` | `Cone` A geometric definition of a cone (and cylinder as a special case) with support for mesh creation/representation.
`class` | `Plane` Class to describe and work with infinite generic 3D planes.
`class` | `PointOctree` Implements a spatial subdivision tree to work efficiently with large numbers of 3D particles.
`class` | `Ray3D` A simple 3D ray datatype
`class` | `Sphere`

Fields in toxi.geom declared as Vec3D
`Vec3D` | `Triangle3D.a`
`Vec3D` | `Line3D.a`
`Vec3D` | `Triangle3D.b`
`Vec3D` | `Line3D.b`
`Vec3D` | `Triangle3D.c`
`Vec3D` | `Triangle3D.centroid`
`Vec3D[]` | `Spline3D.coeffA`
`Vec3D[]` | `Spline3D.delta`
`Vec3D` | `Cone.dir`
`Vec3D` | `Triangle3D.normal`
`Vec3D` | `Plane.normal`

Fields in toxi.geom with type parameters of type Vec3D
`java.util.List<Vec3D>` | `Spline3D.pointList`
`java.util.List<Vec3D>` | `Spline3D.vertices`

Methods in toxi.geom that return Vec3D
`Vec3D` | `Vec3D.abs()` Abs.
`Vec3D` | `Vec3D.add(float a, float b, float c)`
`Vec3D` | `ReadonlyVec3D.add(float a, float b, float c)` Adds vector {a,b,c} and returns result as new vector.
`Vec3D` | `Vec3D.add(ReadonlyVec3D v)`
`Vec3D` | `ReadonlyVec3D.add(ReadonlyVec3D v)`
`Vec3D` | `Vec3D.add(Vec3D v)`
`Vec3D` | `ReadonlyVec3D.add(Vec3D v)` Add vector v and returns result as new vector.
`Vec3D` | `Vec3D.addSelf(Vec3D v)` Adds vector v and overrides coordinates with result.
`Vec3D` | `Matrix4x4.applyTo(ReadonlyVec3D v)` Creates a copy of the given vector, transformed by this matrix.
`Vec3D` | `Matrix4x4.applyToSelf(Vec3D v)`
`Vec3D` | `Vec2D.bisect(Vec2D b)`
`Vec3D` | `ReadonlyVec2D.bisect(Vec2D p)` Computes the perpendicular bisector of two points.
`Vec3D` | `Triangle3D.closestPointOnSurface(Vec3D p)` Computes the the point closest to the current vector on the surface of triangle abc.
`Vec3D` | `Line3D.closestPointTo(ReadonlyVec3D p)` Computes the closest point on this line to the given one.
`Vec3D` | `Triangle3D.computeCentroid()`
`Vec3D` | `Triangle3D.computeNormal()`
`Vec3D` | `Vec3D.constrain(AABB box)` Forcefully fits the vector in the given AABB.
`Vec3D` | `Vec3D.constrain(Vec3D min, Vec3D max)` Forcefully fits the vector in the given AABB specified by the 2 given points.
`Vec3D` | `Vec3D.copy()`
`Vec3D` | `ReadonlyVec3D.copy()` Copy.
`Vec3D` | `Vec3D.cross(ReadonlyVec3D v)`
`Vec3D` | `ReadonlyVec3D.cross(ReadonlyVec3D v)` Calculates cross-product with vector v.
`Vec3D` | `Vec3D.cross(Vec3D v)`
`Vec3D` | `Vec3D.crossInto(ReadonlyVec3D v, Vec3D result)`
`Vec3D` | `ReadonlyVec3D.crossInto(ReadonlyVec3D v, Vec3D result)` Calculates cross-product with vector v.
`Vec3D` | `Vec3D.crossSelf(Vec3D v)` Calculates cross-product with vector v.
`Vec3D` | `Vec3D.floor()` Replaces the vector components with integer values of their current values.
`Vec3D` | `Vec3D.frac()` Replaces the vector components with the fractional part of their current values.
`Vec3D` | `Triangle3D.fromBarycentric(ReadonlyVec3D p)`
`static Vec3D` | `Vec3D.fromXYTheta(float theta)` Creates a new vector from the given angle in the XY plane.
`static Vec3D` | `Vec3D.fromXZTheta(float theta)` Creates a new vector from the given angle in the XZ plane.
`static Vec3D` | `Vec3D.fromYZTheta(float theta)` Creates a new vector from the given angle in the YZ plane.
`Vec3D` | `Vec3D.getAbs()`
`Vec3D` | `ReadonlyVec3D.getAbs()` Gets the abs.
`Vec3D` | `PointCloud.getCentroid()`
`Vec3D` | `Triangle3D.getClosestPointTo(ReadonlyVec3D p)` Finds and returns the closest point on any of the triangle edges to the point given.
`Vec3D` | `Vec3D.getConstrained(AABB box)`
`Vec3D` | `ReadonlyVec3D.getConstrained(AABB box)` Creates a copy of the vector which forcefully fits in the given AABB.
`Vec3D` | `Ray3D.getDirection()` Returns a copy of the ray's direction vector.
`Vec3D` | `Line3D.getDirection()`
`Vec3D` | `AABB.getExtent()` Returns the current box size as new Vec3D instance (updating this vector will NOT update the box size! Use `AABB.setExtent(ReadonlyVec3D)` for those purposes)
`Vec3D` | `Vec3D.getFloored()`
`Vec3D` | `ReadonlyVec3D.getFloored()` Creates a new vector whose components are the integer value of their current values.
`Vec3D` | `Vec3D.getFrac()`
`Vec3D` | `ReadonlyVec3D.getFrac()` Creates a new vector whose components are the fractional part of their current values.
`Vec3D` | `Vec3D.getInverted()`
`Vec3D` | `ReadonlyVec3D.getInverted()` Scales vector uniformly by factor -1 ( v = -v ).
`Vec3D` | `Vec3D.getLimited(float lim)`
`Vec3D` | `ReadonlyVec3D.getLimited(float lim)` Creates a copy of the vector with its magnitude limited to the length given.
`Vec3D` | `AABB.getMax()`
`Vec3D` | `Line3D.getMidPoint()`
`Vec3D` | `AABB.getMin()`
`Vec3D` | `Line3D.getNormal()`
`Vec3D` | `AABB.getNormalForPoint(ReadonlyVec3D p)`
`Vec3D` | `Vec3D.getNormalized()`
`Vec3D` | `ReadonlyVec3D.getNormalized()` Produces the normalized version as a new vector.
`Vec3D` | `Vec3D.getNormalizedTo(float len)`
`Vec3D` | `ReadonlyVec3D.getNormalizedTo(float len)` Produces a new vector normalized to the given length.
`Vec3D` | `Ray3D.getPointAtDistance(float dist)` Returns the point at the given distance on the ray.
`Vec3D` | `AxisAlignedCylinder.getPosition()` Returns the cylinder's position (centroid).
`Vec3D` | `Plane.getProjectedPoint(Vec3D p)`
`Vec3D` | `Vec3D.getReciprocal()`
`Vec3D` | `ReadonlyVec3D.getReciprocal()` Returns a multiplicative inverse copy of the vector.
`Vec3D` | `Vec3D.getReflected(ReadonlyVec3D normal)`
`Vec3D` | `ReadonlyVec3D.getReflected(ReadonlyVec3D normal)`
`Vec3D` | `Vec3D.getRotatedAroundAxis(ReadonlyVec3D axis, float theta)`
`Vec3D` | `ReadonlyVec3D.getRotatedAroundAxis(ReadonlyVec3D axis, float theta)` Gets the rotated around axis.
`Vec3D` | `Vec3D.getRotatedX(float theta)`
`Vec3D` | `ReadonlyVec3D.getRotatedX(float theta)` Creates a new vector rotated by the given angle around the X axis.
`Vec3D` | `Vec3D.getRotatedY(float theta)`
`Vec3D` | `ReadonlyVec3D.getRotatedY(float theta)` Creates a new vector rotated by the given angle around the Y axis.
`Vec3D` | `Vec3D.getRotatedZ(float theta)`
`Vec3D` | `ReadonlyVec3D.getRotatedZ(float theta)` Creates a new vector rotated by the given angle around the Z axis.
`Vec3D` | `Vec3D.getSignum()`
`Vec3D` | `ReadonlyVec3D.getSignum()` Creates a new vector in which all components are replaced with the signum of their original values.
`Vec3D` | `Vec3D.interpolateTo(ReadonlyVec3D v, float f)`
`Vec3D` | `ReadonlyVec3D.interpolateTo(ReadonlyVec3D v, float f)` Interpolates the vector towards the given target vector, using linear interpolation.
`Vec3D` | `Vec3D.interpolateTo(ReadonlyVec3D v, float f, InterpolateStrategy s)`
`Vec3D` | `ReadonlyVec3D.interpolateTo(ReadonlyVec3D v, float f, InterpolateStrategy s)` Interpolates the vector towards the given target vector, using the given `InterpolateStrategy`.
`Vec3D` | `Vec3D.interpolateTo(Vec3D v, float f)`
`Vec3D` | `Vec3D.interpolateTo(Vec3D v, float f, InterpolateStrategy s)`
`Vec3D` | `Vec3D.interpolateToSelf(ReadonlyVec3D v, float f)` Interpolates the vector towards the given target vector, using linear interpolation.
`Vec3D` | `Vec3D.interpolateToSelf(ReadonlyVec3D v, float f, InterpolateStrategy s)` Interpolates the vector towards the given target vector, using the given `InterpolateStrategy`.
`Vec3D` | `AABB.intersectsRay(Ray3D ray, float minDist, float maxDist)` Calculates intersection with the given ray between a certain distance interval.
`Vec3D` | `Vec3D.invert()` Scales vector uniformly by factor -1 ( v = -v ), overrides coordinates with result.
`Vec3D` | `Vec3D.jitter(float j)` Add random jitter to the vector in the range -j ...
`Vec3D` | `Vec3D.jitter(float jx, float jy, float jz)` Adds random jitter to the vector in the range -j ...
`Vec3D` | `Vec3D.jitter(java.util.Random rnd, float j)`
`Vec3D` | `Vec3D.jitter(java.util.Random rnd, float jx, float jy, float jz)`
`Vec3D` | `Vec3D.jitter(java.util.Random rnd, Vec3D jitterVec)`
`Vec3D` | `Vec3D.jitter(Vec3D jitterVec)` Adds random jitter to the vector in the range defined by the given vector components and using the default `Random` generator of `MathUtils`.
`Vec3D` | `Vec3D.limit(float lim)` Limits the vector's magnitude to the length given.
`static Vec3D` | `Vec3D.max(ReadonlyVec3D a, ReadonlyVec3D b)` Constructs a new vector consisting of the largest components of both vectors.
`Vec3D` | `Vec3D.maxSelf(ReadonlyVec3D b)` Max self.
`static Vec3D` | `Vec3D.min(ReadonlyVec3D a, ReadonlyVec3D b)` Constructs a new vector consisting of the smallest components of both vectors.
`Vec3D` | `Vec3D.minSelf(ReadonlyVec3D b)` Min self.
`Vec3D` | `Vec3D.modSelf(float base)` Applies a uniform modulo operation to the vector, using the same base for all components.
`Vec3D` | `Vec3D.modSelf(float bx, float by, float bz)` Calculates modulo operation for each vector component separately.
`Vec3D` | `Vec3D.normalize()` Normalizes the vector so that its magnitude = 1.
`Vec3D` | `Vec3D.normalizeTo(float len)` Normalizes the vector to the given length.
`static Vec3D` | `Vec3D.randomVector()` Static factory method.
`static Vec3D` | `Vec3D.randomVector(java.util.Random rnd)` Static factory method.
`Vec3D` | `Vec3D.reciprocal()` Replaces the vector components with their multiplicative inverse.
`Vec3D` | `Vec3D.reflect(ReadonlyVec3D normal)`
`Vec3D` | `Vec3D.rotateAroundAxis(ReadonlyVec3D axis, float theta)` Rotates the vector around the giving axis.
`Vec3D` | `Vec3D.rotateX(float theta)` Rotates the vector by the given angle around the X axis.
`Vec3D` | `Vec3D.rotateY(float theta)` Rotates the vector by the given angle around the Y axis.
`Vec3D` | `Vec3D.rotateZ(float theta)` Rotates the vector by the given angle around the Z axis.
`Vec3D` | `Vec3D.roundToAxis()` Rounds the vector to the closest major axis.
`Vec3D` | `Vec3D.scale(float s)`
`Vec3D` | `ReadonlyVec3D.scale(float s)` Scales vector uniformly and returns result as new vector.
`Vec3D` | `Vec3D.scale(float a, float b, float c)`
`Vec3D` | `ReadonlyVec3D.scale(float a, float b, float c)` Scales vector non-uniformly and returns result as new vector.
`Vec3D` | `Vec3D.scale(ReadonlyVec3D s)`
`Vec3D` | `ReadonlyVec3D.scale(ReadonlyVec3D s)` Scales vector non-uniformly by vector v and returns result as new vector.
`Vec3D` | `Vec3D.scale(Vec3D s)`
`Vec3D` | `Vec3D.scaleSelf(float s)` Scales vector uniformly and overrides coordinates with result.
`Vec3D` | `Vec3D.scaleSelf(float a, float b, float c)` Scales vector non-uniformly by vector {a,b,c} and overrides coordinates with result.
`Vec3D` | `Vec3D.scaleSelf(Vec3D s)` Scales vector non-uniformly by vector v and overrides coordinates with result.
`Vec3D` | `Vec3D.set(float x, float y, float z)` Overrides coordinates with the given values.
`Vec3D` | `AABB.set(float x, float y, float z)` Updates the position of the box in space and calls `AABB.updateBounds()` immediately
`Vec3D` | `Vec3D.set(ReadonlyVec3D v)`
`Vec3D` | `Vec3D.set(Vec3D v)` Overrides coordinates with the ones of the given vector.
`Vec3D` | `Vec3D.setComponent(int id, float val)`
`Vec3D` | `Vec3D.setComponent(Vec3D.Axis id, float val)`
`Vec3D` | `Vec3D.setXY(Vec2D v)` Overrides XY coordinates with the ones of the given 2D vector.
`Vec3D` | `Vec3D.shuffle(int iterations)`
`Vec3D` | `Vec3D.signum()` Replaces all vector components with the signum of their original values.
`Vec3D` | `Vec3D.sub(float a, float b, float c)`
`Vec3D` | `ReadonlyVec3D.sub(float a, float b, float c)` Subtracts vector {a,b,c} and returns result as new vector.
`Vec3D` | `Vec3D.sub(ReadonlyVec3D v)`
`Vec3D` | `ReadonlyVec3D.sub(ReadonlyVec3D v)` Subtracts vector v and returns result as new vector.
`Vec3D` | `Vec3D.sub(Vec3D v)`
`Vec3D` | `Vec3D.subSelf(float a, float b, float c)` Subtracts vector {a,b,c} and overrides coordinates with result.
`Vec3D` | `Vec3D.subSelf(Vec3D v)` Subtracts vector v and overrides coordinates with result.
`Vec3D` | `Sphere.tangentPlaneNormalAt(ReadonlyVec3D q)` Calculates the normal vector on the sphere in the direction of the current point.
`Vec3D` | `Vec2D.to3DXY()`
`Vec3D` | `ReadonlyVec2D.to3DXY()` Creates a 3D version of this vector in the XY plane.
`Vec3D` | `Vec2D.to3DXZ()`
`Vec3D` | `ReadonlyVec2D.to3DXZ()` Creates a 3D version of this vector in the XZ plane.
`Vec3D` | `Vec2D.to3DYZ()`
`Vec3D` | `ReadonlyVec2D.to3DYZ()` Creates a 3D version of this vector in the YZ plane.
`Vec3D` | `Triangle3D.toBarycentric(ReadonlyVec3D p)`
`Vec3D` | `Vec3D.toCartesian()`
`Vec3D` | `ReadonlyVec3D.toCartesian()` Converts the spherical vector back into cartesian coordinates.
`Vec3D` | `Vec3D.toSpherical()`
`Vec3D` | `ReadonlyVec3D.toSpherical()` Converts the vector into spherical coordinates.

Methods in toxi.geom that return types with arguments of type Vec3D
`java.util.List<Vec3D>` | `Spline3D.computeVertices(int res)` Computes all curve vertices based on the resolution/number of subdivisions requested.
`java.util.List<Vec3D>` | `Spline3D.getDecimatedVertices(float step)` Computes a list of points along the spline which are uniformly separated by the given step distance.
`java.util.List<Vec3D>` | `Spline3D.getDecimatedVertices(float step, boolean doAddFinalVertex)` Computes a list of points along the spline which are uniformly separated by the given step distance.
`java.util.List<Vec3D>` | `Spline3D.getPointList()`
`java.util.List<Vec3D>` | `PointOctree.getPoints()`
`java.util.ArrayList<Vec3D>` | `PointOctree.getPointsWithinBox(AABB b)` Selects all stored points within the given axis-aligned bounding box.
`java.util.ArrayList<Vec3D>` | `PointOctree.getPointsWithinSphere(Sphere s)` Selects all stored points within the given sphere volume
`java.util.ArrayList<Vec3D>` | `PointOctree.getPointsWithinSphere(Vec3D sphereOrigin, float clipRadius)` Selects all stored points within the given sphere volume
`java.util.Iterator<Vec3D>` | `PointCloud.iterator()`
`java.util.List<Vec3D>` | `Line3D.splitIntoSegments(java.util.List<Vec3D> segments, float stepLength, boolean addFirst)`
`static java.util.List<Vec3D>` | `Line3D.splitIntoSegments(Vec3D a, Vec3D b, float stepLength, java.util.List<Vec3D> segments, boolean addFirst)` Splits the line between A and B into segments of the given length, starting at point A.

Methods in toxi.geom with parameters of type Vec3D
`Vec3D` | `Vec3D.add(Vec3D v)`
`Vec3D` | `ReadonlyVec3D.add(Vec3D v)` Add vector v and returns result as new vector.
`boolean` | `PointOctree.addPoint(Vec3D p)` Adds a new point/particle to the tree structure.
`PointCloud` | `PointCloud.addPoint(Vec3D p)`
`Vec3D` | `Vec3D.addSelf(Vec3D v)` Adds vector v and overrides coordinates with result.
`Vec3D` | `Matrix4x4.applyToSelf(Vec3D v)`
`Vec3D` | `Triangle3D.closestPointOnSurface(Vec3D p)` Computes the the point closest to the current vector on the surface of triangle abc.
`Vec3D` | `Vec3D.constrain(Vec3D min, Vec3D max)` Forcefully fits the vector in the given AABB specified by the 2 given points.
`static Triangle3D` | `Triangle3D.createEquilateralFrom(Vec3D a, Vec3D b)`
`Vec3D` | `Vec3D.cross(Vec3D v)`
`Vec3D` | `Vec3D.crossInto(ReadonlyVec3D v, Vec3D result)`
`Vec3D` | `ReadonlyVec3D.crossInto(ReadonlyVec3D v, Vec3D result)` Calculates cross-product with vector v.
`Vec3D` | `Vec3D.crossSelf(Vec3D v)` Calculates cross-product with vector v.
`float` | `Vec3D.dot(Vec3D v)`
`static AABB` | `AABB.fromMinMax(Vec3D min, Vec3D max)` Creates a new instance from two vectors specifying opposite corners of the box
`float` | `Ray3D.getDistanceToPoint(Vec3D p)` Calculates the distance between the given point and the infinite line coinciding with this ray.
`float` | `Plane.getDistanceToPoint(Vec3D p)` Calculates distance from the plane to point P.
`java.util.ArrayList<Vec3D>` | `PointOctree.getPointsWithinSphere(Vec3D sphereOrigin, float clipRadius)` Selects all stored points within the given sphere volume
`Vec3D` | `Plane.getProjectedPoint(Vec3D p)`
`boolean` | `Line3D.hasEndPoint(Vec3D p)`
`Vec3D` | `Vec3D.interpolateTo(Vec3D v, float f)`
`Vec3D` | `Vec3D.interpolateTo(Vec3D v, float f, InterpolateStrategy s)`
`boolean` | `Sphere.intersectSphereTriangle(Triangle3D t, Vec3D result)` Considers the current vector as centre of a collision sphere with radius r and checks if the triangle abc intersects with this sphere.
`boolean` | `AABB.intersectsSphere(Vec3D c, float r)`
`static boolean` | `Triangle3D.isClockwiseInXY(Vec3D a, Vec3D b, Vec3D c)`
`static boolean` | `Triangle3D.isClockwiseInXZ(Vec3D a, Vec3D b, Vec3D c)`
`static boolean` | `Triangle3D.isClockwiseInYZ(Vec3D a, Vec3D b, Vec3D c)`
`boolean` | `Vec3D.isInAABB(Vec3D boxOrigin, Vec3D boxExtent)`
`boolean` | `ReadonlyVec3D.isInAABB(Vec3D boxOrigin, Vec3D boxExtent)` Checks if the point is inside the given axis-aligned bounding box.
`Vec3D` | `Vec3D.jitter(java.util.Random rnd, Vec3D jitterVec)`
`Vec3D` | `Vec3D.jitter(Vec3D jitterVec)` Adds random jitter to the vector in the range defined by the given vector components and using the default `Random` generator of `MathUtils`.
`Line3D` | `Line3D.offsetAndGrowBy(float offset, float scale, Vec3D ref)`
`Vec3D` | `Vec3D.scale(Vec3D s)`
`Vec3D` | `Vec3D.scaleSelf(Vec3D s)` Scales vector non-uniformly by vector v and overrides coordinates with result.
`Quaternion` | `Quaternion.set(float w, Vec3D v)`
`Vec3D` | `Vec3D.set(Vec3D v)` Overrides coordinates with the ones of the given vector.
`Line3D` | `Line3D.set(Vec3D a, Vec3D b)`
`void` | `Triangle3D.set(Vec3D a2, Vec3D b2, Vec3D c2)`
`void` | `AxisAlignedCylinder.setPosition(Vec3D pos)`
`static java.util.List<Vec3D>` | `Line3D.splitIntoSegments(Vec3D a, Vec3D b, float stepLength, java.util.List<Vec3D> segments, boolean addFirst)` Splits the line between A and B into segments of the given length, starting at point A.
`Vec3D` | `Vec3D.sub(Vec3D v)`
`Vec3D` | `Vec3D.subSelf(Vec3D v)` Subtracts vector v and overrides coordinates with result.

Method parameters in toxi.geom with type arguments of type Vec3D
`boolean` | `PointOctree.addAll(java.util.Collection<Vec3D> points)` Adds all points of the collection to the octree.
`PointCloud` | `PointCloud.addAll(java.util.List<? extends Vec3D> plist)`
`void` | `PointOctree.removeAll(java.util.Collection<Vec3D> points)`
`Spline3D` | `Spline3D.setPointList(java.util.List<Vec3D> plist)`
`java.util.List<Vec3D>` | `Line3D.splitIntoSegments(java.util.List<Vec3D> segments, float stepLength, boolean addFirst)`
`static java.util.List<Vec3D>` | `Line3D.splitIntoSegments(Vec3D a, Vec3D b, float stepLength, java.util.List<Vec3D> segments, boolean addFirst)` Splits the line between A and B into segments of the given length, starting at point A.

Constructors in toxi.geom with parameters of type Vec3D
`Line3D(Vec3D a, Vec3D b)`
`Plane(Vec3D origin, ReadonlyVec3D norm)`
`PointOctree(Vec3D o, float size)` Constructs a new PointOctree node within the AABB cube volume: {o.x, o.y, o.z} ...
`SphereIntersectorReflector(Vec3D o, float r)`
`Spline3D(Vec3D[] pointArray)`
`Spline3D(Vec3D[] pointArray, BernsteinPolynomial b, float tightness)`
`Triangle3D(Vec3D a, Vec3D b, Vec3D c)`

Constructor parameters in toxi.geom with type arguments of type Vec3D
`Spline3D(java.util.List<Vec3D> rawPoints)`
`Spline3D(java.util.List<Vec3D> rawPoints, BernsteinPolynomial b, float tightness)`

Uses of Vec3D in toxi.geom.mesh

Subclasses of Vec3D in toxi.geom.mesh
`class` | `Vertex`
`class` | `WEVertex`

Fields in toxi.geom.mesh declared as Vec3D
`Vec3D` | `Vertex.normal`
`Vec3D` | `Face.normal`
`Vec3D[][]` | `BezierPatch.points`

Fields in toxi.geom.mesh with type parameters of type Vec3D
`java.util.LinkedHashMap<Vec3D,Vertex>` | `TriangleMesh.vertices` Vertex buffer & lookup index when adding new faces

Methods in toxi.geom.mesh that return Vec3D
`Vec3D` | `TriangleMesh.computeCentroid()`
`Vec3D` | `Mesh3D.computeCentroid()` Computes the mesh centroid, the average position of all vertices.
`Vec3D` | `BezierPatch.computePointAt(float u, float v)`
`static Vec3D` | `BezierPatch.computePointAt(float u, float v, Vec3D[][] points)` Computes a single point on the bezier surface given by the 2d array of control points.
`Vec3D` | `SurfaceFunction.computeVertexFor(Vec3D p, float phi, float theta)`
`Vec3D` | `SuperEllipsoid.computeVertexFor(Vec3D p, float phi, float theta)`
`Vec3D` | `SphericalHarmonics.computeVertexFor(Vec3D p, float phi, float theta)`
`Vec3D` | `SphereFunction.computeVertexFor(Vec3D p, float phi, float theta)`
`Vec3D` | `Face.getCentroid()`

Methods in toxi.geom.mesh with parameters of type Vec3D
`WETriangleMesh` | `WETriangleMesh.addFace(Vec3D a, Vec3D b, Vec3D c)`
`TriangleMesh` | `TriangleMesh.addFace(Vec3D a, Vec3D b, Vec3D c)`
`Mesh3D` | `Mesh3D.addFace(Vec3D a, Vec3D b, Vec3D c)` Adds the given 3 points as triangle face to the mesh.
`WETriangleMesh` | `WETriangleMesh.addFace(Vec3D a, Vec3D b, Vec3D c, Vec2D uvA, Vec2D uvB, Vec2D uvC)`
`TriangleMesh` | `TriangleMesh.addFace(Vec3D a, Vec3D b, Vec3D c, Vec2D uvA, Vec2D uvB, Vec2D uvC)`
`Mesh3D` | `Mesh3D.addFace(Vec3D a, Vec3D b, Vec3D c, Vec2D uvA, Vec2D uvB, Vec2D uvC)` Adds the given 3 points as triangle face to the mesh and assigns the given texture coordinates to each vertex.
`WETriangleMesh` | `WETriangleMesh.addFace(Vec3D a, Vec3D b, Vec3D c, Vec3D n)`
`TriangleMesh` | `TriangleMesh.addFace(Vec3D a, Vec3D b, Vec3D c, Vec3D n)`
`Mesh3D` | `Mesh3D.addFace(Vec3D a, Vec3D b, Vec3D c, Vec3D n)`
`WETriangleMesh` | `WETriangleMesh.addFace(Vec3D a, Vec3D b, Vec3D c, Vec3D n, Vec2D uvA, Vec2D uvB, Vec2D uvC)`
`TriangleMesh` | `TriangleMesh.addFace(Vec3D a, Vec3D b, Vec3D c, Vec3D n, Vec2D uvA, Vec2D uvB, Vec2D uvC)`
`Mesh3D` | `Mesh3D.addFace(Vec3D a, Vec3D b, Vec3D c, Vec3D n, Vec2D uvA, Vec2D uvB, Vec2D uvC)`
`static Vec3D` | `BezierPatch.computePointAt(float u, float v, Vec3D[][] points)` Computes a single point on the bezier surface given by the 2d array of control points.
`Vec3D` | `SurfaceFunction.computeVertexFor(Vec3D p, float phi, float theta)`
`Vec3D` | `SuperEllipsoid.computeVertexFor(Vec3D p, float phi, float theta)`
`Vec3D` | `SphericalHarmonics.computeVertexFor(Vec3D p, float phi, float theta)`
`Vec3D` | `SphereFunction.computeVertexFor(Vec3D p, float phi, float theta)`
`void` | `STLWriter.face(Vec3D a, Vec3D b, Vec3D c)`
`void` | `STLWriter.face(Vec3D a, Vec3D b, Vec3D c, int rgb)`
`void` | `STLWriter.face(Vec3D a, Vec3D b, Vec3D c, Vec3D normal, int rgb)`
`WETriangleMesh` | `WETriangleMesh.getRotatedAroundAxis(Vec3D axis, float theta)`
`TriangleMesh` | `TriangleMesh.getRotatedAroundAxis(Vec3D axis, float theta)`
`WETriangleMesh` | `WETriangleMesh.getScaled(Vec3D scale)`
`TriangleMesh` | `TriangleMesh.getScaled(Vec3D scale)`
`WETriangleMesh` | `WETriangleMesh.getTranslated(Vec3D trans)`
`TriangleMesh` | `TriangleMesh.getTranslated(Vec3D trans)`
`WEVertex` | `WETriangleMesh.getVertexAtPoint(Vec3D v)`
`Vertex` | `TriangleMesh.getVertexAtPoint(Vec3D v)`
`void` | `OBJWriter.normal(Vec3D n)`
`WETriangleMesh` | `WETriangleMesh.rotateAroundAxis(Vec3D axis, float theta)`
`TriangleMesh` | `TriangleMesh.rotateAroundAxis(Vec3D axis, float theta)`
`WETriangleMesh` | `WETriangleMesh.scale(Vec3D scale)`
`TriangleMesh` | `TriangleMesh.scale(Vec3D scale)`
`BezierPatch` | `BezierPatch.set(int x, int y, Vec3D p)`
`void` | `STLWriter.setScale(Vec3D s)`
`WETriangleMesh` | `WETriangleMesh.translate(Vec3D trans)`
`TriangleMesh` | `TriangleMesh.translate(Vec3D trans)`
`TriangleMesh` | `TriangleMesh.updateVertex(Vec3D orig, Vec3D newPos)`
`void` | `OBJWriter.vertex(Vec3D v)`

Method parameters in toxi.geom.mesh with type arguments of type Vec3D
`VertexSelector` | `VertexSelector.selectSimilar(java.util.Collection<? extends Vec3D> points)` Selects vertices identical or closest to the ones given in the list of points.

Constructors in toxi.geom.mesh with parameters of type Vec3D
`BezierPatch(Vec3D[][] points)`
`Vertex(Vec3D v, int id)`
`WEVertex(Vec3D v, int id)`

Uses of Vec3D in toxi.geom.mesh.subdiv

Fields in toxi.geom.mesh.subdiv declared as Vec3D
`Vec3D` | `MidpointDisplacementSubdivision.centroid`
`Vec3D` | `DualDisplacementSubdivision.centroid`

Methods in toxi.geom.mesh.subdiv that return types with arguments of type Vec3D
`java.util.List<Vec3D>` | `TriSubdivision.computeSplitPoints(WingedEdge edge)`
`abstract java.util.List<Vec3D>` | `SubdivisionStrategy.computeSplitPoints(WingedEdge edge)` Computes a number of points on (or near) the given edge which are used for splitting the edge in smaller segments.
`java.util.List<Vec3D>` | `NormalDisplacementSubdivision.computeSplitPoints(WingedEdge edge)`
`java.util.List<Vec3D>` | `MidpointSubdivision.computeSplitPoints(WingedEdge edge)`
`java.util.List<Vec3D>` | `MidpointDisplacementSubdivision.computeSplitPoints(WingedEdge edge)`
`java.util.List<Vec3D>` | `DualSubdivision.computeSplitPoints(WingedEdge edge)`
`java.util.List<Vec3D>` | `DualDisplacementSubdivision.computeSplitPoints(WingedEdge edge)`

Constructors in toxi.geom.mesh.subdiv with parameters of type Vec3D
`DualDisplacementSubdivision(Vec3D centroid, float ampA, float ampB)`
`MidpointDisplacementSubdivision(Vec3D centroid, float amount)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES