AuroraMiddleware/OpenSubdiv
1
0
Fork 0
mirror of https://github.com/PixarAnimationStudios/OpenSubdiv synced 2024-12-22 16:00:07 +00:00
Code Issues Releases Wiki Activity

Fixing some typos in comments.

Browse Source
This commit is contained in:
Thomas Thomassen 2016-02-15 16:48:39 +01:00
parent a6fe9261ae
commit d73b089c05
21 changed files with 54 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
opensubdiv/far/endCapBSplineBasisPatchFactory.cpp
View File

@ -96,7 +96,7 @@ EndCapBSplineBasisPatchFactory::GetPatchPoints(
int valence = level->getVertexFaces(facePoints[i]).size();
if (valence != 4) {
if (irregular != -1) {
// more than one extraoridinary vertices.
// more than one extraordinary vertices.
// fallback to use GregoryBasis
return getPatchPointsFromGregoryBasis(
level, thisFace, facePoints, levelVertOffset);
@ -279,12 +279,12 @@ EndCapBSplineBasisPatchFactory::getPatchPoints(
//
// This function assumes the patch is not on boundary
// and it contains only 1 extraordinary vertex.
// The location of the extraoridnary vertex can be one of
// The location of the extraordinary vertex can be one of
// 0-ring quad corner.
//
// B-Spline control point gathering indice
// B-Spline control point gathering indices
//
// [5] (4)---(15)--(14) 0 : extraoridnary vertex
// [5] (4)---(15)--(14) 0 : extraordinary vertex
// | | |
// | | | 1,2,3,9,10,11,12,13 :
// (6)----0-----3-----13 B-Spline control points, gathered by
@ -448,7 +448,7 @@ EndCapBSplineBasisPatchFactory::getPatchPoints(
X5.AddWithWeight(X7, -1.0f);
X5.AddWithWeight(X15, -1.0f);
// [5] (4)---(15)--(14) 0 : extraoridnary vertex
// [5] (4)---(15)--(14) 0 : extraordinary vertex
// | | |
// | | | 1,2,3,9,10,11,12,13 :
// (6)----0-----3-----13 B-Spline control points, gathered by

2
opensubdiv/far/endCapBSplineBasisPatchFactory.h
View File

@ -68,7 +68,7 @@ public:
/// \brief Returns end patch point indices for \a faceIndex of \a level.
/// Note that end patch points are not included in the vertices in
/// the topologyRefiner, they're expected to come after the end.
/// The returning indices are offsetted by refiner->GetNumVerticesTotal.
/// The returning indices are offset by refiner->GetNumVerticesTotal.
///
/// @param level vtr refinement level
///

4
opensubdiv/far/endCapGregoryBasisPatchFactory.cpp
View File

@ -186,7 +186,7 @@ EndCapGregoryBasisPatchFactory::GetPatchPoints(
int srcBasisIdx = (int)(ptr - &_faceIndices[0]);
if (!ptr) {
// if the adjface is hole, it won't be found
// if the adjacent is hole, it won't be found
break;
}
assert(ptr
@ -202,7 +202,7 @@ EndCapGregoryBasisPatchFactory::GetPatchPoints(
Index * src = &_patchPoints[srcBasisIdx*20];
for (int j=0; j<4; ++j) {
// invert direction
// note that src indices have already been offsetted.
// note that src indices have already been offset.
dest[gregoryEdgeVerts[i][3-j]] = src[gregoryEdgeVerts[aedge][j]];
}
}

4
opensubdiv/far/endCapGregoryBasisPatchFactory.h
View File

@ -93,7 +93,7 @@ public:
/// \brief Returns end patch point indices for \a faceIndex of \a level.
/// Note that end patch points are not included in the vertices in
/// the topologyRefiner, they're expected to come after the end.
/// The returning indices are offsetted by refiner->GetNumVerticesTotal.
/// The returning indices are offset by refiner->GetNumVerticesTotal.
///
/// @param level vtr refinement level
///
@ -111,7 +111,7 @@ public:
private:
/// Creates a basis for the vertices specified in mask on the face and
/// accumates it
/// accumulates it
bool addPatchBasis(Index faceIndex, bool newVerticesMask[4][5],
int levelVertOffset);

2
opensubdiv/far/endCapLegacyGregoryPatchFactory.h
View File

@ -49,7 +49,7 @@ public:
/// \brief Returns end patch point indices for \a faceIndex of \a level.
/// Note that legacy gregory patch points exist in the max level
/// of subdivision in the topologyRefiner.
/// The returning indices are offsetted by levelVertOffset
/// The returning indices are offset by levelVertOffset
///
/// @param level vtr refinement level
///

2
opensubdiv/far/patchTable.h
View File

@ -292,7 +292,7 @@ public:
/// \brief Evaluate basis functions for position and first derivatives at a
/// given (s,t) parametric location of a patch.
///
/// @param handle A patch handle indentifying the sub-patch containing the
/// @param handle A patch handle identifying the sub-patch containing the
/// (s,t) location
///
/// @param s Patch coordinate (in coarse face normalized space)

16
opensubdiv/far/primvarRefiner.h
View File

@ -99,7 +99,7 @@ public:
///
/// \brief Apply vertex interpolation weights to a primvar buffer for a single
/// level level of refinement.
/// level of refinement.
///
/// The destination buffer must allocate an array of data for all the
/// refined vertices, i.e. at least refiner.GetLevel(level).GetNumVertices()
@ -113,7 +113,7 @@ public:
template <class T, class U> void Interpolate(int level, T const & src, U & dst) const;
/// \brief Apply only varying interpolation weights to a primvar buffer
/// for a single level level of refinement.
/// for a single level of refinement.
///
/// This method can useful if the varying primvar data does not need to be
/// re-computed over time.
@ -207,7 +207,7 @@ private:
private:
//
// Local class to fulfil interface for <typename MASK> in the Scheme mask queries:
// Local class to fulfill interface for <typename MASK> in the Scheme mask queries:
//
class Mask {
public:
@ -410,7 +410,7 @@ PrimvarRefiner::InterpolateVarying(int level, T const & src, U & dst) const {
Vtr::internal::Level const & parent = refinement.parent();
//
// Group values to interolate based on origin -- note that there may
// Group values to interpolate based on origin -- note that there may
// be none originating from faces:
//
if (refinement.getNumChildVerticesFromFaces() > 0) {
@ -705,7 +705,7 @@ PrimvarRefiner::interpFVarFromEdges(int level, T const & src, U & dst, int chann
Vtr::internal::FVarLevel const & childFVar = childLevel.getFVarLevel(channel);
//
// Allocate and intialize (if linearly interpolated) interpolation weights for
// Allocate and initialize (if linearly interpolated) interpolation weights for
// the edge mask:
//
float eVertWeights[2];
@ -978,7 +978,7 @@ PrimvarRefiner::interpFVarFromVerts(int level, T const & src, U & dst, int chann
float eWeight = 0.125f;
//
// If semisharp we need to apply fractional weighting -- if made sharp because
// If semi-sharp we need to apply fractional weighting -- if made sharp because
// of the other sibling (dependent-sharp) use the fractional weight from that
// other sibling (should only occur when there are 2):
//
@ -1093,7 +1093,7 @@ PrimvarRefiner::limit(T const & src, U & dstPos, U1 * dstTan1Ptr, U2 * dstTan2Pt
//
// Combine the weights and indices for position and tangents. As with applying
// refinment masks to vertex data, in order to improve numerical precision, its
// refinement masks to vertex data, in order to improve numerical precision, its
// better to apply smaller weights first, so begin with the face-weights followed
// by the edge-weights and the vertex weight last.
//
@ -1108,7 +1108,7 @@ PrimvarRefiner::limit(T const & src, U & dstPos, U1 * dstTan1Ptr, U2 * dstTan2Pt
//
// Apply the tangent masks -- both will have the same number of weights and
// indices (one tangent may be "padded" to accomodate the other), but these
// indices (one tangent may be "padded" to accommodate the other), but these
// may differ from those of the position:
//
if (hasTangents) {

4
opensubdiv/far/ptexIndices.cpp
View File

@ -163,7 +163,7 @@ PtexIndices::GetAdjacency(
adjEdges[2] = 1;
}
{ // resolve neighbor outisde the sub-face (edge 0)
{ // resolve neighbor outside the sub-face (edge 0)
int edge0 = fedges[quadrant];
Index adjface0 = getAdjacentFace(level, edge0, face);
if (adjface0==-1) {
@ -182,7 +182,7 @@ PtexIndices::GetAdjacency(
assert(adjFaces[0]!=-1);
}
// resolve neighbor outisde the sub-face (edge 3)
// resolve neighbor outside the sub-face (edge 3)
int edge3 = fedges[prevQuadrant];
Index adjface3 = getAdjacentFace(level, edge3, face);
if (adjface3==-1) {

4
opensubdiv/far/stencilTable.h
View File

@ -224,7 +224,7 @@ protected:
int _numControlVertices; // number of control vertices
std::vector<int> _sizes; // number of coeffiecient for each stencil
std::vector<int> _sizes; // number of coefficient for each stencil
std::vector<Index> _offsets, // offset to the start of each stencil
_indices; // indices of contributing coarse vertices
std::vector<float> _weights; // stencil weight coefficients
@ -360,7 +360,7 @@ private:
};
// Update values by appling cached stencil weights to new control values
// Update values by applying cached stencil weights to new control values
template <class T> void
StencilTable::update(T const *controlValues, T *values,
std::vector<float> const &valueWeights, Index start, Index end) const {

4
opensubdiv/far/stencilTableFactory.h
View File

@ -168,11 +168,11 @@ public:
///
/// @param cvStencils A set of StencilTable generated from the
/// TopologyRefiner (optional: prevents redundant
/// instanciation of the table if available)
/// instantiation of the table if available)
///
/// @param patchTable A set of PatchTable generated from the
/// TopologyRefiner (optional: prevents redundant
/// instanciation of the table if available)
/// instantiation of the table if available)
///
static LimitStencilTable const * Create(TopologyRefiner const & refiner,
LocationArrayVec const & locationArrays,

12
opensubdiv/far/topologyRefinerFactory.h
View File

@ -161,7 +161,7 @@ protected:
/// the vertices for that face.
///
/// If a full boundary representation with all neighborhood information is not
/// available, e.g. faces and vertices are avaible but not edges, only the
/// available, e.g. faces and vertices are available but not edges, only the
/// face-vertices should be specified. The remaining topological relationships
/// will be constructed later in the assembly (though at greater cost than if
/// specified directly).
@ -170,13 +170,13 @@ protected:
/// specified in order, i.e. the number of face-vertices for each successive face.
///
/// \brief Specify the number of vertices to be accomodated
/// \brief Specify the number of vertices to be accommodated
static void setNumBaseVertices(TopologyRefiner & newRefiner, int count);
/// \brief Specify the number of faces to be accomodated
/// \brief Specify the number of faces to be accommodated
static void setNumBaseFaces(TopologyRefiner & newRefiner, int count);
/// \brief Specify the number of edges to be accomodated
/// \brief Specify the number of edges to be accommodated
static void setNumBaseEdges(TopologyRefiner & newRefiner, int count);
/// \brief Specify the number of vertices incident each face
@ -263,7 +263,7 @@ protected:
/// posses a feature of interest need be explicitly assigned.
///
/// Since topological construction is largely complete by this point, a method is
/// availble to identify an edge for sharpness assignment given a pair of vertices.
/// available to identify an edge for sharpness assignment given a pair of vertices.
///
/// \brief Identify an edge to be assigned a sharpness value given a vertex pair
@ -628,7 +628,7 @@ TopologyRefinerFactory<MESH>::assignComponentTopology(TopologyRefiner& /* refine
// void setBaseVertexNonManifold(TopologyRefiner& newRefiner, Index vertex, bool b);
//
// Also consider using TopologyLevel::ValidateTopology() when debugging to ensure
// that topolology has been completely and correctly specified.
// that topology has been completely and correctly specified.
//
return false;
}

2
opensubdiv/osd/cpuVertexBuffer.h
View File

@ -34,7 +34,7 @@ namespace OPENSUBDIV_VERSION {
namespace Osd {
/// \brief Concrete vertex buffer class for cpu subvision.
/// \brief Concrete vertex buffer class for CPU subdivision.
///
/// CpuVertexBuffer implements the VertexBufferInterface. An instance
/// of this buffer class can be passed to CpuEvaluator

2
opensubdiv/sdc/bilinearScheme.h
View File

@ -109,7 +109,7 @@ Scheme<SCHEME_BILINEAR>::assignSmoothLimitMask(VERTEX const& vertex, MASK& posMa
}
//
// Limit masks for tangents -- these are ambibuous around all vertices. Provide
// Limit masks for tangents -- these are ambiguous around all vertices. Provide
// the tangents based on the incident edges of the first face.
//
template <>

2
opensubdiv/sdc/catmarkScheme.h
View File

@ -362,7 +362,7 @@ Scheme<SCHEME_CATMARK>::assignCreaseLimitTangentMasks(VERTEX const& vertex,
//
// Second, the tangent across the interior faces:
// Note this is ambigous for an interior vertex. We currently return
// Note this is ambiguous for an interior vertex. We currently return
// the tangent for the surface in the counter-clockwise span between the
// leading and trailing edges that form the crease. Given the expected
// computation of a surface normal as Tan1 X Tan2, this tangent should be

6
opensubdiv/sdc/crease.h
View File

@ -53,7 +53,7 @@ namespace Sdc {
/// users will be expected to provided them -- particularly when they expect the mask queries
/// to do all of the work (just determining if a vertex is smooth will require inspection of
/// incident edge sharpness).
/// Mask queries will occassionally require the subdivided sharpness values around the
/// Mask queries will occasionally require the subdivided sharpness values around the
/// child vertex. So users will be expected to either provide them up front when known, or to be
/// gathered on demand. Any implementation of subdivision with creasing cannot avoid subdividing
/// the sharpness values first, so keeping them available for re-use is a worthwhile consideration.
@ -97,7 +97,7 @@ public:
//@{
/// Optional sharp features:
/// Since options treat certain topological features as infinitely sharp -- boundaries
/// or (in future) nonmanifold features -- sharpness values should be adjust before use.
/// or (in future) non-manifold features -- sharpness values should be adjust before use.
/// The following methods will adjust (by return) specific values according to the options
/// applied.
///
@ -190,7 +190,7 @@ Crease::SharpenBoundaryEdge(float /* edgeSharpness */) const {
//
// Despite the presence of the BOUNDARY_NONE option, boundary edges are always sharpened.
// Much of the code relies on sharpess to indicate boundaries to avoid the more complex
// Much of the code relies on sharpness to indicate boundaries to avoid the more complex
// topological inspection
//
return SHARPNESS_INFINITE;

10
opensubdiv/sdc/loopScheme.h
View File

@ -132,7 +132,7 @@ Scheme<SCHEME_LOOP>::assignSmoothMaskForEdge(EDGE const& edge, MASK& mask) const
// Protected methods to assign the three types of masks for a vertex-vertex --
// Corner, Crease and Smooth (Dart is the same as Smooth).
//
// Corner and Crease do not really need to be speciailized, though it may be
// Corner and Crease do not really need to be specialized, though it may be
// preferable to define all explicitly here.
//
template <>
@ -313,7 +313,7 @@ Scheme<SCHEME_LOOP>::assignSmoothLimitMask(VERTEX const& vertex, MASK& posMask)
//
// A note on tangent magnitudes:
//
// Several formulae exist for limit tangents at a vertex to accomodate the
// Several formulas exist for limit tangents at a vertex to accommodate the
// different topological configurations around the vertex. While these produce
// the desired direction, there is inconsistency in the resulting magnitudes.
// Ideally a regular mesh of uniformly shaped triangles with similar edge lengths
@ -322,7 +322,7 @@ Scheme<SCHEME_LOOP>::assignSmoothLimitMask(VERTEX const& vertex, MASK& posMask)
// scale factors.
//
// For uses where magnitude does not matter, this scaling should be irrelevant.
// But just as with patches, where the magnitudes of partial derivates are
// But just as with patches, where the magnitudes of partial derivatives are
// consistent between similar patches, the magnitudes of limit tangents should
// also be similar.
//
@ -349,7 +349,7 @@ Scheme<SCHEME_LOOP>::assignSmoothLimitMask(VERTEX const& vertex, MASK& posMask)
// where v5 = v0 + (v4 - v3) and v6 = v0 + v1 - v2.
//
// When the standard limit tangent mask is applied, the cosines of increments
// of pi/3 gives us coefficients that are mutliples of 1/2, leading to the first
// of pi/3 gives us coefficients that are multiples of 1/2, leading to the first
// tangent T1 = 3/2 * (v1 - v4), rather than the widely used T1 = v1 - v4. So
// this scale factor of 3/2 is applied to insure tangents along the boundaries
// are of similar magnitude as tangents in the immediate interior (which may be
@ -442,7 +442,7 @@ Scheme<SCHEME_LOOP>::assignCreaseLimitTangentMasks(VERTEX const& vertex,
//
// Second, the tangent across the interior faces:
// Note this is ambigous for an interior vertex. We currently return
// Note this is ambiguous for an interior vertex. We currently return
// the tangent for the surface in the counter-clockwise span between the
// leading and trailing edges that form the crease. Given the expected
// computation of a surface normal as Tan1 X Tan2, this tangent should be

4
opensubdiv/sdc/options.h
View File

@ -101,10 +101,10 @@ public:
/// \brief Set edge crease rule
void SetCreasingMethod(CreasingMethod c) { _creasingMethod = c; }
/// \brief Get triangle subdivsion weights rule (Catmark scheme only !)
/// \brief Get triangle subdivision weights rule (Catmark scheme only !)
TriangleSubdivision GetTriangleSubdivision() const { return (TriangleSubdivision) _triangleSub; }
/// \brief Set triangle subdivsion weights rule (Catmark scheme only !)
/// \brief Set triangle subdivision weights rule (Catmark scheme only !)
void SetTriangleSubdivision(TriangleSubdivision t) { _triangleSub = t; }
private:

4
opensubdiv/sdc/scheme.h
View File

@ -131,7 +131,7 @@ public:
/// edge while T2 points inward across the limit surface.
///
/// As for magnitude, no assumptions should be made of the magnitudes of the resulting
/// tanget vectors. Common formulae often factor out scale factors that contribute to
/// tangent vectors. Common formulae often factor out scale factors that contribute to
/// magnitude. While some attempt has been made to make magnitudes more consistent
/// between regular corners, boundaries and the interior, the same has not been done at
/// irregular vertices -- at least not yet. This may be addressed in future, as having
@ -484,7 +484,7 @@ Scheme<SCHEME>::ComputeEdgeVertexMask(EDGE const& edge,
// provided though, there are cases where the parent and child sharpness values need to be
// identified, so accounting for the unknown Rules too is not much of an added complication.
//
// The benefit of supporting specified Rules is that they can often often be trivially
// The benefit of supporting specified Rules is that they can often be trivially
// determined from context (e.g. a vertex derived from a face at a previous level will always
// be smooth) rather than more generally, and at greater cost, inspecting neighboring and
// they are often the same for parent and child.

2
opensubdiv/vtr/componentInterfaces.h
View File

@ -46,7 +46,7 @@ namespace internal {
//
// These are not used with Vtr but arguably belong with it as the details to
// write these efficiently depends very much on intimate details of Vtr's
// implmentation, e.g. the use of tag bits, subdivision Rules, etc.
// implementation, e.g. the use of tag bits, subdivision Rules, etc.
//

2
opensubdiv/vtr/fvarLevel.h
View File

@ -66,7 +66,7 @@ namespace internal {
// take up almost half the memory of this representation, so if memory does
// become a concern, we do not need to store them. The only reason we do so now
// is that the face-value interface for specifying base topology and inspecting
// subsequent levels is very familar to that of face-vertices for clients. So
// subsequent levels is very familiar to that of face-vertices for clients. So
// having them available for such access is convenient.
//
// Regarding scope and access...

10
opensubdiv/vtr/level.h
View File

@ -59,11 +59,11 @@ class FVarLevel;
// the topology (i.e. all quads or all tris if not level 0).
//
// This class is intended for private use within the library. There are still
// opportunities to specialize levels -- e.g. those supporing N-sided faces vs
// those are are purely quads or tris -- so we prefer to insulate it from public
// opportunities to specialize levels -- e.g. those supporting N-sided faces vs
// those are purely quads or tris -- so we prefer to insulate it from public
// access.
//
// The represenation of topology here is to store six topological relationships
// The representation of topology here is to store six topological relationships
// in tables of integers. Each is stored in its own array(s) so the result is
// a SOA representation of the topology. The six relations are:
//
@ -75,7 +75,7 @@ class FVarLevel;
// - vert-edges: edges incident a vertex
//
// There is some redundancy here but the intent is not that this be a minimal
// represenation, the intent is that it be amenable to refinement. Classes in
// representation, the intent is that it be amenable to refinement. Classes in
// the Far layer essentially store 5 of these 6 in a permuted form -- we add
// the face-edges here to simplify refinement.
//
@ -91,7 +91,7 @@ public:
//
// Most of these properties are passed down to child components during
// refinement, but some -- notably the designation of a component as semi-
// sharp -- require re-determination as sharpnes values are reduced at each
// sharp -- require re-determination as sharpness values are reduced at each
// level.
//
struct VTag {