If true this object may not be modified. Any properties or functions that attempt to modify this object when it is set to "IsReadOnly" will throw a NotSupportedException.
Is this instance a 'shallow copy'. Shallow copies are no different than regular instances with the exception that they will convert to complete independent 'deep' copies if a non const operation is perform on the instance (something that mutates the internal data)
Ngons represent groups of Faces (triangles + quads).
Faces are used to tessellate an Ngon internally.
When a triangle or quad is referenced in the Ngon list, it is no longer visualized and conceived as a single entity, but takes part of the Ngon.
If you need to get access to both Ngons and the faces that are not referenced by Ngons, that is, all polygons that are visible in the mesh, then use the GetNgonAndFacesEnumerable() helper method.
Append a list of meshes. This function is much more efficient than making repeated calls to Mesh.Append(Mesh) when lots of meshes are being joined into a single large mesh.
Examines the mesh and logs a description of what it finds right or wrong. The various properties the function checks for are described in MeshCheckParameters.
Gets the point on the mesh that is closest to a given test point. Similar to the ClosestPoint function except this returns a MeshPoint class which includes extra information beyond just the location of the closest point.
Optional upper bound on the distance from test point to the mesh. If you are only interested in finding a point Q on the mesh when testPoint.DistanceTo(Q) < maximumDistance, then set maximumDistance to that value. This parameter is ignored if you pass 0.0 for a maximumDistance.
Returns: closest point information on success. null on failure.
Optional upper bound on the distance from test point to the mesh. If you are only interested in finding a point Q on the mesh when testPoint.DistanceTo(Q) < maximumDistance, then set maximumDistance to that value. This parameter is ignored if you pass 0.0 for a maximumDistance.
Returns: Index of face that the closest point lies on if successful. -1 if not successful; the value of pointOnMesh is undefined.
Optional upper bound on the distance from test point to the mesh. If you are only interested in finding a point Q on the mesh when testPoint.DistanceTo(Q) < maximumDistance, then set maximumDistance to that value. This parameter is ignored if you pass 0.0 for a maximumDistance.
Returns: Index of face that the closest point lies on if successful. -1 if not successful; the value of pointOnMesh is undefined.
Collapses multiple mesh faces, with areas less than LessThanArea and greater than GreaterThanArea, based on the principles found in Stan Melax's mesh reduction PDF, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf
Remarks: This number may differ from the initial number of faces that meet the input criteria because the areas of some initial faces may be altered as other faces are collapsed. The face area must be both less than LessThanArea AND greater than GreaterThanArea in order to be considered. Use large numbers for lessThanArea or zero for greaterThanArea to simulate an OR.
Collapses a multiple mesh faces, determined by face aspect ratio, based on criteria found in Stan Melax's polygon reduction, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf
Remarks: This number may differ from the initial number of faces that meet the input criteria because the aspect ratios of some initial faces may be altered as other faces are collapsed.
Collapses multiple mesh faces, with greater/less than edge length, based on the principles found in Stan Melax's mesh reduction PDF, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf
Remarks: This number may differ from the initial number of edges that meet the input criteria because the lengths of some initial edges may be altered as other edges are collapsed.
Returns: Number of edges (faces) that were collapsed, -1 for general failure (like bad topology or index out of range) or -2 if all of the edges would be collapsed and the resulting mesh would be invalid.
Evaluate a mesh normal at a set of barycentric coordinates. Barycentric coordinates must be assigned in accordance with the rules as defined by MeshPoint.T.
Remarks: Coordinate 0,0,0,0 is not a valid set of barycentric coordinates. The sum of t0 to t3 should be 1.
Fourth barycentric coordinate. If the face is a triangle, this coordinate will be ignored.
Returns: The interpolated vertex color on the mesh or Color.Transparent if the faceIndex is not valid, if the barycentric coordinates could not be evaluated, or if there are no colors defined on the mesh.
MeshPoint instance containing a valid Face Index and Barycentric coordinates.
Returns: The interpolated vertex color on the mesh or Color.Transparent if the faceIndex is not valid, if the barycentric coordinates could not be evaluated, or if there are no colors defined on the mesh.
Returns: This object's component index. If this object is not a sub-piece of a larger geometric entity, then the returned index has m_type = ComponentIndex.InvalidType and m_index = -1.
Compute an approximation of the discrete curvatures of the mesh vertices, according to which type of curvature information is requested. This method will not yield meaningful values on nonmanifold vertices, and nan on naked vertices. For now, this method operates solely on the mesh topology (the fully welded mesh), but distribtes the result across all the ordinary vertices. This method is a const and thread-safe method and will leave the m_K array untouched. An integer indicating which curvature is desired. gaussian_curvature = 1, mean_curvature = 2, minimum unsigned radius of curvature = 3, maximum unsigned radius of curvature = 4 Resulting curvature array on success, null on failure. On success, the length of the array is the number of vertices.
On success, one array per output mesh (parallel to the returned array), listing the indices of the input meshes that contributed faces to that output. The index space is flat-concatenated: firstSet occupies 0..n0-1 and secondSet occupies n0..n0+n1-1, in enumeration order; null inputs are skipped and not assigned an index. Null when the function fails.
Returns: An array of Mesh results or null on failure.
On success, one array per output mesh (parallel to the returned array), listing the indices of the input meshes that contributed faces to that output. The index space is flat-concatenated: firstSet occupies 0..n0-1 and secondSet occupies n0..n0+n1-1, in enumeration order; null inputs are skipped and not assigned an index. Null when the function fails.
Returns: An array of Mesh results or null on failure.
On success, one array per output mesh (parallel to the returned array), listing the indices of the input meshes that contributed faces to that output. The index space is flat-concatenated: meshesToSplit occupies 0..n0-1 and meshSplitters occupies n0..n0+n1-1, in enumeration order; null inputs are skipped and not assigned an index. Null when the function fails.
On success, one array per output mesh (parallel to the returned array), listing the indices of the input meshes that contributed faces to that output. Indices refer to meshes in enumeration order; null inputs are skipped and not assigned an index. Null when the function fails.
Returns: An array of Mesh results or null on failure.
A tolerance value. If negative, the positive value will be used. WARNING! Good tolerance values are in the magnitude of 10^-7, or RhinoMath.SqrtEpsilon*10. See comments at Intersection.MeshIntersectionsTolerancesCoefficient
Returns: An array of curves. This array can be empty.
A tolerance value. If negative, the positive value will be used. WARNING! Good tolerance values are in the magnitude of 10^-7, or RhinoMath.SqrtEpsilon*10. See comments at Intersection.MeshIntersectionsTolerancesCoefficient
Returns: An array of curves. This array can be empty.
An out parameter of jagged array of indices into the argument point enumerable. Each list item specifies the indices that make up a facet of the convex hull. These indices are not indices into the resulting mesh's indices. Can be the empty jagged array if the resulting mesh is null.
The angle tolerance used for merging coplanar points into facets. Use the document's angle tolerance in radians if in doubt.
Returns: A valid mesh if successful. If there were too few input points, or the input was coplanar up to the specified tolerance, the result can be null.
Constructs a mesh from an extruded curve. This method is designed for projecting curves onto a mesh. In most cases, a better to use CreateExtrusion(Curve, Vector3d).
The number of mesh faces that surround the curve. For example with three segments, the cross-section of the pipe looks like an equilateral triangle. The more segments there are, the rounder the pipe is.
The accuracy of the pipe. Changes the visual fidelity of the pipe along the curve. Higher value means that the center of the pipe is closer to the curve. By increasing the accuracy, the mesh will get more faces along the curve.
A series of true and false values, that determine if each face is used in the new mesh. If null or empty, a non-filtered copy of the original mesh is returned.
If the amount does not match the length of the face list, the pattern is repeated. If it exceeds the amount of faces in the mesh face list, the pattern is truncated.
Returns: A copy of the original mesh with its faces filtered, or null on failure.
An enumeration of component indexes from the input mesh. This can be one following combinations: 1 vertex (MeshVertex or MeshTopologyVertex) and 1 edge (MeshTopologyEdge), 2 edges (MeshTopologyEdge), or 3 vertices (MeshVertex or MeshTopologyVertex).
Returns: A new mesh if successful, null otherwise.
Constructs a icospherical mesh. A mesh icosphere differs from a standard UV mesh sphere in that it's vertices are evenly distributed. A mesh icosphere starts from an icosahedron (a regular polyhedron with 20 equilateral triangles). It is then refined by splitting each triangle into 4 smaller triangles. This splitting can be done several times.
In ancient times (or modern smart phone times), some rendering engines were only able to process small batches of triangles and the CreatePartitions() function was provided to partition the mesh into subsets of vertices and faces that those rendering engines could handle.
(optional: can be null) Outer boundary polyline, if provided this will become the outer boundary of the resulting mesh. Any of the input that is completely outside the outer boundary will be ignored and have no impact on the result. If any of the input intersects the outer boundary the result will be unpredictable and is likely to not include the entire outer boundary.
(optional: can be null) Initial surface where 3d input will be pulled to make a 2d representation used by the function that generates the mesh. Providing a pullbackSurface can be helpful when it is similar in shape to the pattern of the input, the pulled 2d points will be a better representation of the 3d points. If all of the input is more or less coplanar to start with, providing pullbackSurface has no real benefit.
(optional: can be null) Polylines to create holes in the output mesh. If innerBoundaryCurves are the only input then the result may be null if trimback is set to false (see comments for trimback) because the resulting mesh could be invalid (all faces created contained vertices from the perimeter boundary).
(optional: can be null) These polylines will create faces on both sides of the edge. If there are only input points(innerPoints) there is no way to guarantee a triangulation that will create an edge between two particular points. Adding a line, or polyline, to innerBothsideCurves that includes points from innerPoints will help guide the triangulation.
(optional: can be null) Points to be used to generate the mesh. If outerBoundary is not null, points outside of that boundary after it has been pulled to pullbackSurface (or the best plane through the input if pullbackSurface is null) will be ignored.
Only used when a outerBoundary has not been provided. When that is the case, the function uses the perimeter of the surface as the outer boundary instead. If true, any face of the resulting triangulated mesh that contains a vertex of the perimeter boundary will be removed.
Only used when a outerBoundary has not been provided. When that is the case, division becomes the number of divisions each side of the surface's perimeter will be divided into to create an outer boundary to work with.
Constructs a quad mesh sphere. A quad mesh sphere differs from a standard UV mesh sphere in that it's vertices are evenly distributed. A quad mesh sphere starts from a cube (a regular polyhedron with 6 square sides). It is then refined by splitting each quad into 4 smaller quads. This splitting can be done several times.
Attempts to create a 3d convex hull mesh from input points using the QuickHull algorithm. Hull faces whose shared edges are not clearly convex are merged, so faces of the resulting mesh may be triangles, quads, or larger convex polygons (returned as mesh ngons).
List of integer arrays, one for each hull face, containing the indices into the input points enumerable that make up that face. Note, this can be null.
Returns: A valid mesh if successful. If there were too few input points, or the input was degenerate (coincident, colinear, or coplanar), the result is null.
Attempts to create a 3d convex hull mesh from input points using the QuickHull algorithm. Hull faces whose shared edges are not clearly convex are merged, so faces of the resulting mesh may be triangles, quads, or larger convex polygons (returned as mesh ngons).
The 3D input points to be covered with the convex hull. At least four points are required, and they must not be coincident, colinear, or coplanar.
Returns: A valid mesh if successful. If there were too few input points, or the input was degenerate (coincident, colinear, or coplanar), the result is null.
Attempts to create a 3d convex hull mesh from an input point cloud using the QuickHull algorithm, also returning the input points that make up each hull face.
List of integer arrays, one for each hull face, containing the indices into the point cloud that make up that face. Note, this can be null.
Returns: A valid mesh if successful. If there were too few input points, or the input was degenerate (coincident, colinear, or coplanar), the result is null.
Attempts to create a 3d convex hull mesh from an input point cloud using the QuickHull algorithm. Hull faces whose shared edges are not clearly convex are merged, so faces of the resulting mesh may be triangles, quads, or larger convex polygons (returned as mesh ngons).
The point cloud to be covered with the convex hull. At least four points are required, and they must not be coincident, colinear, or coplanar.
Returns: A valid mesh if successful. If there were too few input points, or the input was degenerate (coincident, colinear, or coplanar), the result is null.
Constructs a light copy of this object. By "light", it is meant that the same underlying data is used until something is done to attempt to change it. For example, you could have a shallow copy of a very heavy mesh object and the same underlying data will be used when doing things like inspecting the number of faces on the mesh. If you modify the location of one of the mesh vertices, the shallow copy will create a full duplicate of the underlying mesh data and the shallow copy will become a deep copy.
Returns: An object of the same type as this object.
This behavior is overridden by implementing classes.
EnsurePrivateCopy
publicvoidEnsurePrivateCopy()
If you want to keep a copy of this class around by holding onto it in a variable after a command completes, call EnsurePrivateCopy to make sure that this class is not tied to the document. You can call this function as many times as you want.
Explode the mesh into sub-meshes where a sub-mesh is a collection of faces that are contained within a closed loop of "unwelded" edges. Unwelded edges are edges where the faces that share the edge have unique mesh vertices (not mesh topology vertices) at both ends of the edge.
Returns: Array of sub-meshes on success; null on error. If the count in the returned array is 1, then nothing happened and the output is essentially a copy of the input.
Given a starting "naked" edge index, this function attempts to determine a "hole" by chaining additional naked edges together until if returns to the start index. Then it triangulates the closed polygon and either adds the faces to the mesh.
If true, a physically accurate bounding box will be computed. If not, a bounding box estimate will be computed. For some geometry types there is no difference between the estimate and the accurate bounding box. Estimated bounding boxes can be computed much (much) faster than accurate (or "tight") bounding boxes. Estimated bounding boxes are always similar to or larger than accurate bounding boxes.
Returns: The bounding box of the geometry in world coordinates or BoundingBox.Empty if not bounding box could be found.
Returns cached texture coordinate set based on the texture. Make sure to set up cached texture coordinates for all textures in the material first by calling SetCachedTextureCoordinatesFromMaterial(File3dm file, Guid objectId, Rhino.DocObjects.Material material) If this function returns null then there are no texture coordinates available.
Returns cached texture coordinate set based on the texture. Make sure to set up cached texture coordinates for all textures in the material first by calling SetCachedTextureCoordinatesFromMaterial(RhinoObject rhinoObject, Rhino.DocObjects.Material material) If this function returns null then there are no texture coordinates available.
Returns an array of Boolean values equal in length to the number of vertices in this mesh. Each value corresponds to a mesh vertex and is set to true if the vertex is not completely surrounded by faces.
Returns: An array of true/false flags that, at each index, reveals if the corresponding vertex is completely surrounded by faces.
Retrieves a complete enumerable, i.e., one that provides an iterator over every face that is present, no matter if defined as a triangle, a quad, or a strictly over-four-sided ngon.
Returns: The enumerator capable of enumerating through Ngons> Mesh.Ngons and Faces
A tolerance value. If negative, the positive value will be used. WARNING! Good tolerance values are in the magnitude of 10^-7, or RhinoMath.SqrtEpsilon*10.
Allows to obtain unsafe pointers to the underlying unmanaged data structures of the mesh.
Remarks: The lock implements the IDisposable interface, and one call of its IDisposable.Dispose() or ReleaseUnsafeLock(MeshUnsafeLock) will update the data structure as required. This can be achieved with a using statement (Using in Vb.Net).
Attempts to "heal" naked edges in a mesh based on a given distance. First attempts to move vertices to neighboring vertices that are within that distance away. Then it finds edges that have a closest point to the vertex within the distance and splits the edge. When it finds one it splits the edge and makes two new edges using that point.
Remarks: The mesh must be closed and manifold; this function returns false for any other mesh. Inside means enclosed by the mesh, so a consistent face orientation is not required and reversing the faces does not change the answer.
If strictlyIn is true, then point must be inside mesh by at least tolerance in order for this function to return true. If strictlyIn is false, then this function will return true if point is inside or the distance from point to a mesh face is <= tolerance.
Returns: true if point is inside the mesh, false if not.
If possible, converts the object into a form that can be accurately modified with "squishy" transformations like projections, shears, an non-uniform scaling.
Moves face edges of an open mesh to meet adjacent face edges. The method will first try to match vertices, and then it will try to split edges to make the edges match.
If true, matching the mesh takes place in four passes starting at a tolerance that is smaller than your specified tolerance and working up to the specified tolerance with successive passes. This matches small edges first and works up to larger edges. If false, then a single pass is made.
Returns: True of edges were matched, false otherwise.
Moves face edges of open meshes to meet near face edges. The method will first try to match vertices, and then then it will try to split edges to make the edges match.
When this is true and there is only one split in a face the code just divides the face at that vertex. If it is false or there are multiple splits on the same face TL_Triangulate3dPolygon is called and the resulting faces replace the existing face.
If true, matching the mesh takes place in four passes starting at a tolerance that is smaller than your specified tolerance and working up to the specified tolerance with successive passes. This matches small edges first and works up to larger edges. If false, then a single pass is made.
Evaluate a mesh normal at a set of barycentric coordinates. Barycentric coordinates must be assigned in accordance with the rules as defined by MeshPoint.T.
Makes a new mesh with vertices offset a distance along the direction parameter. Optionally, based on the value of solidify, adds the input mesh and a ribbon of faces along any naked edges. If solidify is false it acts exactly as the Offset(distance) function. Returns list of wall faces, i.e. the faces that connect original and offset mesh when solidified.
Makes a new mesh with vertices offset a distance along the direction parameter. Optionally, based on the value of solidify, adds the input mesh and a ribbon of faces along any naked edges. If solidify is false it acts exactly as the Offset(distance) function.
Makes a new mesh with vertices offset a distance in the opposite direction of the existing vertex normals. Optionally, based on the value of solidify, adds the input mesh and a ribbon of faces along any naked edges. If solidify is false it acts exactly as the Offset(distance) function.
Some file formats and rendering engines are only able to process small batches of triangles. Use this function to partition the mesh into subsets of vertices and faces that those file formats and rendering engines can handle.
Remarks: The resulting sub-meshes tend to be less disjoint than the output of SplitMesh(Mesh, int, bool, bool). The less disjoint meshes will take more time to compute.
An enumeration of component indexes from this mesh. This can be one following combinations: 1 vertex (MeshVertex or MeshTopologyVertex) and 1 edge (MeshTopologyEdge), 2 edges (MeshTopologyEdge), or 3 vertices (MeshVertex or MeshTopologyVertex).
Gets a polyline approximation of the input curve and then moves its control points to the closest point on the mesh. Then it "connects the points" over edges so that a polyline on the mesh is formed.
A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
A curve array used to influence mesh face layout The curves should touch the input mesh Set Guide Curve Influence by using QuadRemeshParameters.GuideCurveInfluence
Use this function to rebuild meshes that are not acting properly. Vertices and faces are kept. Face normals and vertex normals are recalculated. Surface curvatures, and surfaces parameters are not replaced.
Use this function to rebuild meshes that are not acting properly. Vertices and faces are kept. Face normals and vertex normals are recalculated. Texture coordinates, vertex colors, surface curvatures, and surfaces parameters are not replaced.
If true, faces are removed until desiredPolygonCount is reached, distorting the shape as needed. If false, only flat (coplanar) regions are simplified, which leaves the shape unchanged and ignores desiredPolygonCount.
If True then will run computation inside a worker thread and ignore any provided CancellationTokens and ProgressReporters. If False then will run on main thread.
Returns: True if mesh is successfully reduced and false if mesh could not be reduced for some reason.
If true, faces are removed until desiredPolygonCount is reached, distorting the shape as needed. If false, only flat (coplanar) regions are simplified, which leaves the shape unchanged and ignores desiredPolygonCount.
If True then will run computation inside a worker thread and ignore any provided CancellationTokens and ProgressReporters. If False then will run on main thread.
Returns: True if mesh is successfully reduced and false if mesh could not be reduced for some reason.
If true, faces are removed until desiredPolygonCount is reached, distorting the shape as needed. If false, only flat (coplanar) regions are simplified, which leaves the shape unchanged and ignores desiredPolygonCount.
If true, faces are removed until desiredPolygonCount is reached, distorting the shape as needed. If false, only flat (coplanar) regions are simplified, which leaves the shape unchanged and ignores desiredPolygonCount.
If True then will run computation inside a worker thread and ignore any provided CancellationTokens and ProgressReporters. If False then will run on main thread.
Returns: True if mesh is successfully reduced and false if mesh could not be reduced for some reason.
Sets up cached texture coordinate set for each texture in the material. Textures in the Material define which mapping channels are used and the object with the specified id in the file defines what texture mapping is used for each mapping channel. After this method is called all necessary texture coordinate sets are cached and correct texture coordinates for each texture can be fetched using GetCachedTextureCoordinates(File3dm file, Guid objectId, Rhino.DocObjects.Texture texture) If any texture coordinates are already cached they will not be re-computed.
Sets up cached texture coordinate set for each texture in the material. Textures in the Material define which mapping channels are used and the RhinoObject defines what texture mapping is used for each mapping channel. After this method is called all necessary texture coordinate sets are cached and correct texture coordinates for each texture can be fetched using GetCachedTextureCoordinates(RhinoObject rhinoObject, Rhino.DocObjects.Texture texture) If any texture coordinates are already cached they will not be re-computed.
If the mesh does not have surface evaluation parameters, has texture coordinates, and the surface parameters can be set in a way so the existing texture coordinates can be computed from the surface parameters, then this function sets the surface parameters. This is useful when meshes that have texture coordinates and do not have surface parameters want to set the surface parameters in a way so that the texture mapping of type TextureMappingType.SurfaceParameters will restore the texture coordinates.
Returns: true - successful false - failure - no changes made to the mesh
If true and the mesh's texture coordinates were already computed from this same mapping and transform, no calculation is performed. If false, texture coordinates are always recalculated.
If true then some mesh edges might be unwelded to better represent UV discontinuities in the texture mapping. This only happens for the following mappings: Box, Sphere, Cylinder
If true and the mesh's texture coordinates were already computed from this same mapping and transform, no calculation is performed. If false, texture coordinates are always recalculated.
Creates a unified ShrinkWrap mesh from a collection of GeometryBase objects. returns null or error on failure Supports cancellation during volumetric calculations. geometryBase mesh creation is not cancellable
Creates a unified ShrinkWrap mesh from a collection of input meshes. Returns null on error or failure. Supports cancellation during volumetric calculations.
Some file formats and rendering engines are only able to process small batches of triangles. Use this function to split the mesh into subsets of vertices and faces that those file formats and rendering engines can handle.
Splits a mesh by adding edges in correspondence with input polylines, and divides the mesh at partitioned areas. Polyline segments that are measured not to be on the mesh will be ignored.
Splits a mesh by adding edges in correspondence with input polylines, and divides the mesh at partitioned areas. Polyline segments that are measured not to be on the mesh will be ignored.
Transforms the geometry. If the input Transform has a SimilarityType of OrientationReversing, you may want to consider flipping the transformed geometry after calling this function when it makes sense. For example, you may want to call Flip() on a Brep after transforming it.
Attempts to fix inconsistencies in the directions of mesh faces in a mesh. This function does not modify mesh vertex normals, it rearranges the mesh face winding and face normals to make them all consistent. Note, you may want to call Mesh.Normals.ComputeNormals() to recompute vertex normals after calling this functions.
Attempts to fix inconsistencies in the directions of mesh faces in a mesh. This function does not modify mesh vertex normals, it rearranges the mesh face winding and face normals to make them all consistent. Note, you may want to call Mesh.Normals.ComputeNormals() to recompute vertex normals after calling this functions.
Makes sure that faces sharing an edge and having a difference of normal greater than or equal to angleToleranceRadians have unique vertices along that edge, adding vertices if necessary.
Determines whether new vertex normals will have the same vertex normal as the original (false) or vertex normals made from the corresponding face normals (true)
If true, the vertex normals on each side of the edge take the same value as the face to which they belong, giving the mesh a hard edge look. If false, each of the vertex normals on either side of the edge is assigned the same value as the original normal that the pair is replacing, keeping a smooth look.
Makes sure that faces sharing an edge and having a difference of normal less than or equal to angleToleranceRadians share vertices along that edge, vertex normals are averaged.
If true, vertex copies whose surface parameters differ are never merged into a single vertex - the edge between them is left unwelded instead of averaging or discarding one side's parameters. Vertex copies whose surface parameters already match are still merged normally.
Makes sure that faces sharing an edge and having a difference of normal less than or equal to angleToleranceRadians share vertices along that edge, vertex normals are averaged.