OpenSubdiv/opensubdiv/far/patchTableFactory.cpp

//
//   Copyright 2013 Pixar
//
//   Licensed under the Apache License, Version 2.0 (the "Apache License")
//   with the following modification; you may not use this file except in
//   compliance with the Apache License and the following modification to it:
//   Section 6. Trademarks. is deleted and replaced with:
//
//   6. Trademarks. This License does not grant permission to use the trade
//      names, trademarks, service marks, or product names of the Licensor
//      and its affiliates, except as required to comply with Section 4(c) of
//      the License and to reproduce the content of the NOTICE file.
//
//   You may obtain a copy of the Apache License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the Apache License with the above modification is
//   distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//   KIND, either express or implied. See the Apache License for the specific
//   language governing permissions and limitations under the Apache License.
//
#include "../far/patchTableFactory.h"
#include "../far/error.h"
#include "../far/ptexIndices.h"
#include "../far/topologyRefiner.h"
#include "../vtr/level.h"
#include "../vtr/fvarLevel.h"
#include "../vtr/refinement.h"
#include "../vtr/stackBuffer.h"
#include "../far/endCapBSplineBasisPatchFactory.h"
#include "../far/endCapGregoryBasisPatchFactory.h"
#include "../far/endCapLegacyGregoryPatchFactory.h"

#include <algorithm>
#include <cassert>
#include <cstring>

namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
namespace Far {

using Vtr::internal::Refinement;
using Vtr::internal::Level;
using Vtr::internal::FVarLevel;

namespace {

//  Helpers for compiler warnings and floating point equality tests
#ifdef __INTEL_COMPILER
#pragma warning (push)
#pragma warning disable 1572
#endif

inline bool isSharpnessEqual(float s1, float s2) { return (s1 == s2); }

#ifdef __INTEL_COMPILER
#pragma warning (pop)
#endif

//
//  Local helper functions for identifying the subset of a ring around a
//  corner that contributes to a patch -- parameterized by a mask that
//  indicates what kind of edge is to delimit the span.
//
//  Note that the two main methods need both face-verts and face-edges for
//  each corner, and that we don't really need the face-index once we have
//  them -- consider passing the fVerts and fEdges as arguments as they
//  will otherwise be retrieved repeatedly for each corner.
//
//  (As these mature it is likely they will be moved to Vtr, as a method
//  to identify a VSpan would complement the existing method to gather
//  the vertex/values associated with it.  The manifold vs non-manifold
//  choice would then also be encapsulated -- provided both remain free
//  of PatchTable-specific logic.)
//
inline Level::ETag
getSingularEdgeMask(bool includeAllInfSharpEdges = false) {

    Level::ETag eTagMask;
    eTagMask.clear();
    eTagMask._boundary = true;
    eTagMask._nonManifold = true;
    eTagMask._infSharp = includeAllInfSharpEdges;
    return eTagMask;
}

inline bool
isEdgeSingular(Level const & level, FVarLevel const * fvarLevel, Index eIndex,
               Level::ETag eTagMask)
{
    Level::ETag eTag = level.getEdgeTag(eIndex);
    if (fvarLevel) {
        eTag = fvarLevel->getEdgeTag(eIndex).combineWithLevelETag(eTag);
    }

    Level::ETag::ETagSize * iTag  = reinterpret_cast<Level::ETag::ETagSize*>(&eTag);
    Level::ETag::ETagSize * iMask = reinterpret_cast<Level::ETag::ETagSize*>(&eTagMask);
    return (*iTag & *iMask) > 0;
}

void
identifyManifoldCornerSpan(Level const & level, Index fIndex,
                           int fCorner, Level::ETag eTagMask,
                           Level::VSpan & vSpan, int fvc = -1)
{
    FVarLevel const * fvarLevel = (fvc < 0) ? 0 : &level.getFVarLevel(fvc);

    ConstIndexArray fVerts = level.getFaceVertices(fIndex);
    ConstIndexArray fEdges = level.getFaceEdges(fIndex);

    ConstIndexArray vEdges = level.getVertexEdges(fVerts[fCorner]);
    int             nEdges = vEdges.size();

    int iLeadingStart  = vEdges.FindIndex(fEdges[fCorner]);
    int iTrailingStart = (iLeadingStart + 1) % nEdges;

    vSpan.clear();
    vSpan._numFaces = 1;

    int iLeading  = iLeadingStart;
    while (! isEdgeSingular(level, fvarLevel, vEdges[iLeading], eTagMask)) {
        ++vSpan._numFaces;
        iLeading = (iLeading + nEdges - 1) % nEdges;
        if (iLeading == iTrailingStart) break;
    }

    int iTrailing = iTrailingStart;
    while (! isEdgeSingular(level, fvarLevel, vEdges[iTrailing], eTagMask)) {
        ++vSpan._numFaces;
        iTrailing = (iTrailing + 1) % nEdges;
        if (iTrailing == iLeadingStart) break;
    }
    vSpan._startFace = (LocalIndex) iLeading;
}

void
identifyNonManifoldCornerSpan(Level const & level, Index fIndex,
                              int fCorner, Level::ETag /* eTagMask */,
                              Level::VSpan & vSpan, int /* fvc */ = -1)
{
    //  For now, non-manifold patches revert to regular patches -- just identify
    //  the single face now for a sharp corner patch.
    //
    //  Remember that the face may be incident the vertex multiple times when
    //  non-manifold, so make sure the local index of the corner vertex in the
    //  face identified additionally matches the corner.
    //
    //FVarLevel const * fvarLevel = (fvc < 0) ? 0 : &level.getFVarChannel(fvc);

    Index vIndex = level.getFaceVertices(fIndex)[fCorner];

    ConstIndexArray      vFaces  = level.getVertexFaces(vIndex);
    ConstLocalIndexArray vInFace = level.getVertexFaceLocalIndices(vIndex);

    vSpan.clear();
    for (int i = 0; i < vFaces.size(); ++i) {
        if ((vFaces[i] == fIndex) && ((int)vInFace[i] == fCorner)) {
            vSpan._startFace = (LocalIndex) i;
            vSpan._numFaces = 1;
            vSpan._sharp = true;
            break;
        }
    }
    assert(vSpan._numFaces == 1);
}

//
//  Additional anonymous helper functions:
//
static inline void
offsetAndPermuteIndices(Far::Index const indices[], int count,
                        Far::Index offset, int const permutation[],
                        Far::Index result[]) {

    // The patch vertices for boundary and corner patches
    // are assigned index values even though indices will
    // be undefined along boundary and corner edges.
    // When the resulting patch table is going to be used
    // as indices for drawing, it is convenient for invalid
    // indices to be replaced with known good values, such
    // as the first un-permuted index, which is the index
    // of the first vertex of the patch face.
    Far::Index knownGoodIndex = indices[0];

    if (permutation) {
        for (int i = 0; i < count; ++i) {
            if (permutation[i] < 0) {
                result[i] = offset + knownGoodIndex;
            } else {
                result[i] = offset + indices[permutation[i]];
            }
        }
    } else if (offset) {
        for (int i = 0; i < count; ++i) {
            result[i] = offset + indices[i];
        }
    } else {
        std::memcpy(result, indices, count * sizeof(Far::Index));
    }
}

inline int
assignSharpnessIndex(float sharpness, std::vector<float> & sharpnessValues) {

    // linear search
    for (int i=0; i<(int)sharpnessValues.size(); ++i) {
        if (isSharpnessEqual(sharpnessValues[i], sharpness)) {
            return i;
        }
    }
    sharpnessValues.push_back(sharpness);
    return (int)sharpnessValues.size()-1;
}

} // namespace anon


//
// Builder Context
//
// Helper class aggregating transient contextual data structures during
// the creation of a patch table.
// This helps keeping the factory class stateless.
//
// Note : struct members are not re-entrant nor are they intended to be !
//
struct PatchTableFactory::BuilderContext {

public:
    // Simple struct to store <level,face> (and more?) info for a patch:
    struct PatchTuple {
        PatchTuple()
            : faceIndex(Vtr::INDEX_INVALID), levelIndex(-1) { }
        PatchTuple(PatchTuple const & p)
            : faceIndex(p.faceIndex), levelIndex(p.levelIndex) { }
        PatchTuple(Index faceIndex, int levelIndex)
            : faceIndex(faceIndex), levelIndex(levelIndex) { }

        Index faceIndex;
        int   levelIndex;
    };
    typedef std::vector<PatchTuple> PatchTupleVector;

public:
    BuilderContext(TopologyRefiner const & refiner, Options options);

    // Methods to query patch properties for classification and construction.
    bool IsPatchEligible(int levelIndex, Index faceIndex) const;

    bool IsPatchSmoothCorner(int levelIndex, Index faceIndex,
                             int fvcFactory = -1) const;

    bool IsPatchRegular(int levelIndex, Index faceIndex,
                        int fvcFactory = -1) const;

    int GetRegularPatchBoundaryMask(int levelIndex, Index faceIndex,
                                    int fvcFactory = -1) const;

    void GetIrregularPatchCornerSpans(int levelIndex, Index faceIndex,
                                      Level::VSpan cornerSpans[4],
                                      int fvcFactory = -1) const;

    // Methods to gather points associated with the different patch types
    int GatherLinearPatchPoints(Index * iptrs,
                                PatchTuple const & patch,
                                int fvcFactory = -1) const;
    int GatherRegularPatchPoints(Index * iptrs,
                                 PatchTuple const & patch,
                                 int boundaryMask,
                                 int fvcFactory = -1) const;
    template <class END_CAP_FACTORY_TYPE>
    int GatherIrregularPatchPoints(END_CAP_FACTORY_TYPE *endCapFactory,
                                   Index * iptrs,
                                   PatchTuple const & patch,
                                   Level::VSpan cornerSpans[4],
                                   int fvcFactory = -1) const;

    // Additional simple queries -- most regarding face-varying channels that hide
    // the mapping between channels in the source Refiner and corresponding channels
    // in the Factory and PatchTable
    //
    // True if face-varying patches need to be generated for this topology
    bool RequiresFVarPatches() const {
        return (! fvarChannelIndices.empty());
    }

    int GetRefinerFVarChannel(int fvcFactory) const {
        return (fvcFactory >= 0) ? fvarChannelIndices[fvcFactory] : -1;
    }

    bool DoesFaceVaryingPatchMatch(int levelIndex, Index faceIndex, int fvcFactory) const {
        return refiner.getLevel(levelIndex).doesFaceFVarTopologyMatch(faceIndex,
                        GetRefinerFVarChannel(fvcFactory));
    }

    int GetDistinctRefinerFVarChannel(int levelIndex, int faceIndex, int fvcFactory) const {
        return ((fvcFactory >= 0) &&
                !DoesFaceVaryingPatchMatch(levelIndex, faceIndex, fvcFactory)) ?
            GetRefinerFVarChannel(fvcFactory) : -1;
    }

    int GetTransitionMask(int levelIndex, Index faceIndex) const {
        return (levelIndex == refiner.GetMaxLevel()) ? 0 :
            refiner.getRefinement(levelIndex).
                       getParentFaceSparseTag(faceIndex)._transitional;
    }

public:
    TopologyRefiner const & refiner;

    Options const options;

    //  Additional options eventually to be made public in Options above:
    bool options_approxSmoothCornerWithSharp;

    PtexIndices const ptexIndices;

    // Counters accumulating each type of patch during topology traversal
    int numRegularPatches;
    int numIrregularPatches;
    int numIrregularBoundaryPatches;

    // Tuple for each patch identified during topology traversal
    PatchTupleVector patches;

    std::vector<int> levelVertOffsets;
    std::vector< std::vector<int> > levelFVarValueOffsets;

    // These are the indices of face-varying channels in the refiner
    // or empty if we are not populating face-varying data.
    std::vector<int> fvarChannelIndices;
};

// Constructor
PatchTableFactory::BuilderContext::BuilderContext(
    TopologyRefiner const & ref, Options opts) :
    refiner(ref), options(opts), ptexIndices(refiner),
    numRegularPatches(0), numIrregularPatches(0),
    numIrregularBoundaryPatches(0) {

    //  Eventually to be passed in as Options and assigned to member...
    options_approxSmoothCornerWithSharp = true;

    if (options.generateFVarTables) {
        // If client-code does not select specific channels, default to all
        // the channels in the refiner.
        if (options.numFVarChannels==-1) {
            fvarChannelIndices.resize(refiner.GetNumFVarChannels());
            for (int fvc=0;fvc<(int)fvarChannelIndices.size(); ++fvc) {
                fvarChannelIndices[fvc] = fvc; // std::iota
            }
        } else {
            fvarChannelIndices.assign(
                options.fvarChannelIndices,
                options.fvarChannelIndices+options.numFVarChannels);
        }
    }
}

int
PatchTableFactory::BuilderContext::GatherLinearPatchPoints(
        Index * iptrs, PatchTuple const & patch, int fvcFactory) const {

    Level const & level = refiner.getLevel(patch.levelIndex);

    int levelVertOffset = (fvcFactory < 0)
                        ? levelVertOffsets[patch.levelIndex]
                        : levelFVarValueOffsets[fvcFactory][patch.levelIndex];

    int fvcRefiner = GetRefinerFVarChannel(fvcFactory);

    ConstIndexArray cvs = (fvcRefiner < 0)
                        ? level.getFaceVertices(patch.faceIndex)
                        : level.getFaceFVarValues(patch.faceIndex, fvcRefiner);

    for (int i = 0; i < cvs.size(); ++i) iptrs[i] = levelVertOffset + cvs[i];
    return cvs.size();
}

int
PatchTableFactory::BuilderContext::GatherRegularPatchPoints(
        Index * iptrs, PatchTuple const & patch, int boundaryMask,
        int fvcFactory) const {

    Level const & level = refiner.getLevel(patch.levelIndex);

    int levelVertOffset = (fvcFactory < 0)
                        ? levelVertOffsets[patch.levelIndex]
                        : levelFVarValueOffsets[fvcFactory][patch.levelIndex];

    int fvcRefiner = GetRefinerFVarChannel(fvcFactory);

    Index patchVerts[16];

    int bType  = 0;
    int bIndex = 0;
    if (boundaryMask) {
        static int const boundaryEdgeMaskToType[16] =
            { 0, 1, 1, 2, 1, -1, 2, -1, 1, 2, -1, -1, 2, -1, -1, -1 };
        static int const boundaryEdgeMaskToFeature[16] =
            { -1, 0, 1, 1, 2, -1, 2, -1, 3, 0, -1, -1, 3, -1, -1,-1 };

        bType  = boundaryEdgeMaskToType[boundaryMask];
        bIndex = boundaryEdgeMaskToFeature[boundaryMask];
    }

    int const * permutation = 0;

    if (bType == 0) {
        static int const permuteRegular[16] =
            { 5, 6, 7, 8, 4, 0, 1, 9, 15, 3, 2, 10, 14, 13, 12, 11 };
        permutation = permuteRegular;
        level.gatherQuadRegularInteriorPatchPoints(
                patch.faceIndex, patchVerts, /*rotation=*/0, fvcRefiner);
    } else if (bType == 1) {
        // Expand boundary patch vertices and rotate to
        // restore correct orientation.
        static int const permuteBoundary[4][16] = {
            { -1, -1, -1, -1, 11, 3, 0, 4, 10, 2, 1, 5, 9, 8, 7, 6 },
            { 9, 10, 11, -1, 8, 2, 3, -1, 7, 1, 0, -1, 6, 5, 4, -1 },
            { 6, 7, 8, 9, 5, 1, 2, 10, 4, 0, 3, 11, -1, -1, -1, -1 },
            { -1, 4, 5, 6, -1, 0, 1, 7, -1, 3, 2, 8, -1, 11, 10, 9 } };
        permutation = permuteBoundary[bIndex];
        level.gatherQuadRegularBoundaryPatchPoints(
                patch.faceIndex, patchVerts, bIndex, fvcRefiner);
    } else if (bType == 2) {
        // Expand corner patch vertices and rotate to
        // restore correct orientation.
        static int const permuteCorner[4][16] = {
            { -1, -1, -1, -1, -1, 0, 1, 4, -1, 3, 2, 5, -1, 8, 7, 6 },
            { -1, -1, -1, -1, 8, 3, 0, -1, 7, 2, 1, -1, 6, 5, 4, -1 },
            { 6, 7, 8, -1, 5, 2, 3, -1, 4, 1, 0, -1, -1, -1, -1, -1 },
            { -1, 4, 5, 6, -1, 1, 2, 7, -1, 0, 3, 8, -1, -1, -1, -1 } };
        permutation = permuteCorner[bIndex];
        level.gatherQuadRegularCornerPatchPoints(
                patch.faceIndex, patchVerts, bIndex, fvcRefiner);
    } else {
        assert(bType <= 2);
    }

    offsetAndPermuteIndices( patchVerts, 16, levelVertOffset, permutation, iptrs);
    return 16;
}

template <class END_CAP_FACTORY_TYPE>
int
PatchTableFactory::BuilderContext::GatherIrregularPatchPoints(
        END_CAP_FACTORY_TYPE *endCapFactory,
        Index * iptrs, PatchTuple const & patch,
        Level::VSpan cornerSpans[4],
        int fvcFactory) const {

    Level const & level = refiner.getLevel(patch.levelIndex);

    int levelVertOffset = (fvcFactory < 0)
                        ? levelVertOffsets[patch.levelIndex]
                        : levelFVarValueOffsets[fvcFactory][patch.levelIndex];

    int fvcRefiner = GetRefinerFVarChannel(fvcFactory);

    ConstIndexArray cvs = endCapFactory->GetPatchPoints(
        &level, patch.faceIndex, cornerSpans, levelVertOffset, fvcRefiner);

    for (int i = 0; i < cvs.size(); ++i) iptrs[i] = cvs[i];
    return cvs.size();
}

bool
PatchTableFactory::BuilderContext::IsPatchEligible(
        int levelIndex, Index faceIndex) const {

    //
    //  Patches that are not eligible correpond to the following faces:
    //      - holes
    //      - those in intermediate levels that are further refined (not leaves)
    //      - those without complete neighborhoods that supporting other patches
    //
    Level const & level = refiner.getLevel(levelIndex);

    if (level.isFaceHole(faceIndex)) {
        return false;
    }

    if (levelIndex < refiner.GetMaxLevel()) {
        if (refiner.getRefinement(levelIndex).getParentFaceSparseTag(faceIndex)._selected) {
            return false;
        }
    }

    //
    //  Faces that exist solely to support faces intended for patches will not have
    //  their full neighborhood available and so are considered "incomplete":
    //
    Vtr::ConstIndexArray fVerts = level.getFaceVertices(faceIndex);
    assert(fVerts.size() == 4);

    if (level.getFaceCompositeVTag(fVerts)._incomplete) {
        return false;
    }
    return true;
}

bool
PatchTableFactory::BuilderContext::IsPatchSmoothCorner(
        int levelIndex, Index faceIndex, int fvcFactory) const
{
    Level const & level = refiner.getLevel(levelIndex);

    //  Ignore the face-varying channel if the topology for the face is not distinct
    int fvcRefiner = GetDistinctRefinerFVarChannel(levelIndex, faceIndex, fvcFactory);

    Vtr::ConstIndexArray fVerts = level.getFaceVertices(faceIndex);
    if (fVerts.size() != 4) return false;

    Level::VTag vTags[4];
    level.getFaceVTags(faceIndex, vTags, fvcRefiner);

    //
    //  Test the subdivision rules for the corners, rather than just the boundary/interior
    //  tags, to ensure that inf-sharp vertices or edges are properly accounted for (and
    //  the cases appropriately excluded) if inf-sharp patches are enabled:
    //
    int boundaryCount = 0;
    if (options.useInfSharpPatch) {
        boundaryCount = (vTags[0]._infSharpEdges && (vTags[0]._rule == Sdc::Crease::RULE_CREASE))
                      + (vTags[1]._infSharpEdges && (vTags[1]._rule == Sdc::Crease::RULE_CREASE))
                      + (vTags[2]._infSharpEdges && (vTags[2]._rule == Sdc::Crease::RULE_CREASE))
                      + (vTags[3]._infSharpEdges && (vTags[3]._rule == Sdc::Crease::RULE_CREASE));
    } else {
        boundaryCount = (vTags[0]._boundary && (vTags[0]._rule == Sdc::Crease::RULE_CREASE))
                      + (vTags[1]._boundary && (vTags[1]._rule == Sdc::Crease::RULE_CREASE))
                      + (vTags[2]._boundary && (vTags[2]._rule == Sdc::Crease::RULE_CREASE))
                      + (vTags[3]._boundary && (vTags[3]._rule == Sdc::Crease::RULE_CREASE));
    }
    int xordinaryCount = vTags[0]._xordinary
                       + vTags[1]._xordinary
                       + vTags[2]._xordinary
                       + vTags[3]._xordinary;

    if ((boundaryCount == 3) && (xordinaryCount == 1)) {
        //  This must be an isolated xordinary corner above level 1, otherwise we still
        //  need to assure the xordinary vertex is opposite a smooth interior vertex:
        //
        if (levelIndex > 1) return true;

        if (vTags[0]._xordinary) return (vTags[2]._rule == Sdc::Crease::RULE_SMOOTH);
        if (vTags[1]._xordinary) return (vTags[3]._rule == Sdc::Crease::RULE_SMOOTH);
        if (vTags[2]._xordinary) return (vTags[0]._rule == Sdc::Crease::RULE_SMOOTH);
        if (vTags[3]._xordinary) return (vTags[1]._rule == Sdc::Crease::RULE_SMOOTH);
    }
    return false;
}

bool
PatchTableFactory::BuilderContext::IsPatchRegular(
        int levelIndex, Index faceIndex, int fvcFactory) const
{
    Level const & level = refiner.getLevel(levelIndex);

    //  Ignore the face-varying channel if the topology for the face is not distinct
    int fvcRefiner = GetDistinctRefinerFVarChannel(levelIndex, faceIndex, fvcFactory);

    //  Retrieve the composite VTag for the four corners:
    Level::VTag fCompVTag = level.getFaceCompositeVTag(faceIndex, fvcRefiner);

    //
    //  Patches around non-manifold features are currently regular -- will need to revise
    //  this when infinitely sharp patches are introduced later:
    //
    bool isRegular = ! fCompVTag._xordinary || fCompVTag._nonManifold;

    //  Reconsider when using inf-sharp patches in presence of inf-sharp features:
    if (options.useInfSharpPatch && (fCompVTag._infSharp || fCompVTag._infSharpEdges)) {
        if (fCompVTag._nonManifold || !fCompVTag._infIrregular) {
            isRegular = true;
        } else if (!fCompVTag._infSharpEdges) {
            isRegular = false;
        } else {
            //
            //   This is unfortunately a relatively complex case to determine... if a corner
            //   vertex has been tagged has having an inf-sharp irregularity about it, the
            //   neighborhood of the corner is partitioned into both regular and irregular
            //   regions and the face must be more closely inspected to determine in which
            //   it lies.
            //
            //   There could be a simpler test here to quickly accept/reject regularity given
            //   how local it is -- involving no more than one or two (in the case of Loop)
            //   adjacent faces -- but it will likely be messy and will need to inspect
            //   adjacent faces and/or edges.  In the meantime, gathering and inspecting the
            //   subset of the neighborhood delimited by inf-sharp edges will suffice (and
            //   be comparable in all but cases of high valence)
            //
            Level::VTag vTags[4];
            level.getFaceVTags(faceIndex, vTags, fvcRefiner);

            Level::VSpan vSpan;
            Level::ETag eMask = getSingularEdgeMask(true);

            isRegular = true;
            for (int i = 0; i < 4; ++i) {
                if (vTags[i]._infIrregular) {
                    identifyManifoldCornerSpan(level, faceIndex, i, eMask, vSpan, fvcRefiner);

                    isRegular = (vSpan._numFaces == (vTags[i]._infSharpCrease ? 2 : 1));
                    if (!isRegular) break;
                }
            }
        }

        //  When inf-sharp and extra-ordinary features are not isolated, need to inspect more
        //  closely -- any smooth extra-ordinary corner makes the patch irregular:
        if (fCompVTag._xordinary && (levelIndex < 2)) {
            Level::VTag vTags[4];
            level.getFaceVTags(faceIndex, vTags, fvcRefiner);
            for (int i = 0; i < 4; ++i) {
                if (vTags[i]._xordinary && (vTags[i]._rule == Sdc::Crease::RULE_SMOOTH)) {
                    isRegular = false;
                }
            }
        }
    }

    //  Legacy option -- reinterpret an irregular smooth corner as sharp if specified:
    if (!isRegular && options_approxSmoothCornerWithSharp) {
        if (fCompVTag._xordinary && fCompVTag._boundary && !fCompVTag._nonManifold) {
            isRegular = IsPatchSmoothCorner(levelIndex, faceIndex, fvcRefiner);
        }
    }
    return isRegular;
}

int
PatchTableFactory::BuilderContext::GetRegularPatchBoundaryMask(
        int levelIndex, Index faceIndex, int fvcFactory) const
{
    Level const & level = refiner.getLevel(levelIndex);

    //  Ignore the face-varying channel if the topology for the face is not distinct
    int fvcRefiner = GetDistinctRefinerFVarChannel(levelIndex, faceIndex, fvcFactory);

    //  Gather the VTags for the four corners.  Regardless of the options for
    //  treating non-manifold or inf-sharp patches, for a regular patch we can
    //  infer all that we need need from tags for the corner vertices:
    //
    Level::VTag vTags[4];
    level.getFaceVTags(faceIndex, vTags, fvcRefiner);

    Level::VTag fTag = Level::VTag::BitwiseOr(vTags);

    //
    //  Identify vertex tags for inf-sharp edges and/or boundaries, depending on
    //  whether or not inf-sharp patches are in use:
    //
    int vBoundaryMask = 0;
    if (fTag._infSharpEdges) {
        if (options.useInfSharpPatch) {
            vBoundaryMask |= (vTags[0]._infSharpEdges << 0) |
                             (vTags[1]._infSharpEdges << 1) |
                             (vTags[2]._infSharpEdges << 2) |
                             (vTags[3]._infSharpEdges << 3);
        } else if (fTag._boundary) {
            vBoundaryMask |= (vTags[0]._boundary << 0) |
                             (vTags[1]._boundary << 1) |
                             (vTags[2]._boundary << 2) |
                             (vTags[3]._boundary << 3);
        }
    }

    //
    //  Non-manifold patches have been historically represented as regular in all
    //  cases -- when a non-manifold vertex is sharp, it requires a regular corner
    //  patch, and so both of its neighboring corners need to be re-interpreted as
    //  boundaries.
    //
    //  With the introduction of inf-sharp patches, this may soon change...
    //
    if (fTag._nonManifold && (fvcRefiner < 0)) {
        if (vTags[0]._nonManifold) vBoundaryMask |= (1 << 0) | (vTags[0]._infSharp ? 10 : 0);
        if (vTags[1]._nonManifold) vBoundaryMask |= (1 << 1) | (vTags[1]._infSharp ?  5 : 0);
        if (vTags[2]._nonManifold) vBoundaryMask |= (1 << 2) | (vTags[2]._infSharp ? 10 : 0);
        if (vTags[3]._nonManifold) vBoundaryMask |= (1 << 3) | (vTags[3]._infSharp ?  5 : 0);
    }

    //  Convert directly from a vertex- to edge-mask (no need to inspect edges):
    int eBoundaryMask = 0;
    if (vBoundaryMask) {
        static int const vBoundaryMaskToEMask[16] =
                { 0, -1, -1, 1, -1, -1, 2, 3, -1, 8, -1, 9, 4, 12, 6, -1 };
        eBoundaryMask = vBoundaryMaskToEMask[vBoundaryMask];
        assert(eBoundaryMask != -1);
    }
    return eBoundaryMask;
}

void
PatchTableFactory::BuilderContext::GetIrregularPatchCornerSpans(
        int levelIndex, Index faceIndex,
        Level::VSpan cornerSpans[4],
        int fvcFactory) const
{
    Level const & level = refiner.getLevel(levelIndex);

    //  Ignore the face-varying channel if the topology for the face is not distinct
    int fvcRefiner = GetDistinctRefinerFVarChannel(levelIndex, faceIndex, fvcFactory);

    //  Retrieve tags and identify other information for the corner vertices:
    Level::VTag vTags[4];
    level.getFaceVTags(faceIndex, vTags, fvcRefiner);

    FVarLevel::ValueTag fvarTags[4];
    if (fvcRefiner >= 0) {
        level.getFVarLevel(fvcRefiner).getFaceValueTags(faceIndex, fvarTags);
    }

    //
    //  For each corner vertex, use the complete neighborhood when possible (which
    //  does not require a search, otherwise identify the span of interest around
    //  the vertex:
    //
    ConstIndexArray fVerts = level.getFaceVertices(faceIndex);

    Level::ETag singularEdgeMask = getSingularEdgeMask(options.useInfSharpPatch);

    for (int i = 0; i < fVerts.size(); ++i) {
        bool noFVarMisMatch = (fvcRefiner < 0) || !fvarTags[i]._mismatch;
        bool testInfSharp   = options.useInfSharpPatch &&
                                (vTags[i]._infSharpEdges && (vTags[i]._rule != Sdc::Crease::RULE_DART));

        if (noFVarMisMatch && !testInfSharp) {
            cornerSpans[i].clear();
        } else {
            if (!vTags[i]._nonManifold) {
                identifyManifoldCornerSpan(
                        level, faceIndex, i, singularEdgeMask, cornerSpans[i], fvcRefiner);
            } else {
                identifyNonManifoldCornerSpan(
                        level, faceIndex, i, singularEdgeMask, cornerSpans[i], fvcRefiner);
            }
        }
        if (vTags[i]._corner) {
            cornerSpans[i]._sharp = true;
        } else if (options.useInfSharpPatch) {
            cornerSpans[i]._sharp = vTags[i]._infIrregular && (vTags[i]._rule == Sdc::Crease::RULE_CORNER);
        }

        //  Legacy option -- reinterpret an irregular smooth corner as sharp if specified:
        if (!cornerSpans[i]._sharp && options_approxSmoothCornerWithSharp) {
            if (vTags[i]._xordinary && vTags[i]._boundary && !vTags[i]._nonManifold) {
                    int nFaces = cornerSpans[i].isAssigned() ? cornerSpans[i]._numFaces
                               : level.getVertexFaces(fVerts[i]).size();
                    cornerSpans[i]._sharp = (nFaces == 1);
            }
        }
    }
}

//
//  Reserves tables based on the contents of the PatchArrayVector in the PatchTable:
//
void
PatchTableFactory::allocateVertexTables(
        BuilderContext const & context, PatchTable * table) {

    int ncvs = 0, npatches = 0;
    for (int i=0; i<table->GetNumPatchArrays(); ++i) {
        npatches += table->GetNumPatches(i);
        ncvs += table->GetNumControlVertices(i);
    }

    if (ncvs==0 || npatches==0)
        return;

    table->_patchVerts.resize( ncvs );

    table->_paramTable.resize( npatches );

    if (! context.refiner.IsUniform()) {
        table->allocateVaryingVertices(
            PatchDescriptor(PatchDescriptor::QUADS), npatches);
    }

    if (context.options.useSingleCreasePatch) {
        table->_sharpnessIndices.resize( npatches, Vtr::INDEX_INVALID );
    }
}

//
//  Allocate face-varying tables
//
void
PatchTableFactory::allocateFVarChannels(
        BuilderContext const & context, PatchTable * table) {

    TopologyRefiner const & refiner = context.refiner;

    int npatches = table->GetNumPatchesTotal();

    table->allocateFVarPatchChannels((int)context.fvarChannelIndices.size());

    // Initialize each channel
    for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {
        int refinerChannel = context.fvarChannelIndices[fvc];

        Sdc::Options::FVarLinearInterpolation interpolation =
            refiner.GetFVarLinearInterpolation(refinerChannel);

        table->setFVarPatchChannelLinearInterpolation(interpolation, fvc);

        if (refiner.IsUniform()) {
            PatchDescriptor::Type uniformType = context.options.triangulateQuads
                ? PatchDescriptor::TRIANGLES
                : PatchDescriptor::QUADS;

            table->allocateFVarPatchChannelValues(
                PatchDescriptor(uniformType), npatches, fvc);

        } else {
            bool allLinear = context.options.generateFVarLegacyLinearPatches ||
                (interpolation == Sdc::Options::FVAR_LINEAR_ALL);

            PatchDescriptor::Type adaptiveType = allLinear
                    ? PatchDescriptor::QUADS
                    : ((context.options.GetEndCapType() == Options::ENDCAP_GREGORY_BASIS)
                        ? PatchDescriptor::GREGORY_BASIS
                        : PatchDescriptor::REGULAR);

            table->allocateFVarPatchChannelValues(
                PatchDescriptor(adaptiveType), npatches, fvc);
        }
    }
}

//
//  Populates the PatchParam for the given face, returning
//  a pointer to the next entry
//
PatchParam
PatchTableFactory::computePatchParam(
    BuilderContext const & context,
    int depth, Index faceIndex,
    int boundaryMask, int transitionMask) {

    TopologyRefiner const & refiner = context.refiner;

    // Move up the hierarchy accumulating u,v indices to the coarse level:
    int childIndexInParent = 0,
        u = 0,
        v = 0,
        ofs = 1;

    bool nonquad = (refiner.GetLevel(depth).GetFaceVertices(faceIndex).size() != 4);

    for (int i = depth; i > 0; --i) {
        Refinement const& refinement  = refiner.getRefinement(i-1);
        Level const&      parentLevel = refiner.getLevel(i-1);

        Index parentFaceIndex = refinement.getChildFaceParentFace(faceIndex);

        if (parentLevel.getFaceVertices(parentFaceIndex).size() == 4) {
            childIndexInParent = refinement.getChildFaceInParentFace(faceIndex);
            switch ( childIndexInParent ) {
                case 0 :                     break;
                case 1 : { u+=ofs;         } break;
                case 2 : { u+=ofs; v+=ofs; } break;
                case 3 : {         v+=ofs; } break;
            }
            ofs = (unsigned short)(ofs << 1);
        } else {
            nonquad = true;
            // If the root face is not a quad, we need to offset the ptex index
            // CCW to match the correct child face
            Vtr::ConstIndexArray children = refinement.getFaceChildFaces(parentFaceIndex);
            for (int j=0; j<children.size(); ++j) {
                if (children[j]==faceIndex) {
                    childIndexInParent = j;
                    break;
                }
            }
        }
        faceIndex = parentFaceIndex;
    }

    Index ptexIndex = context.ptexIndices.GetFaceId(faceIndex);
    assert(ptexIndex!=-1);

    if (nonquad) {
        ptexIndex+=childIndexInParent;
    }

    PatchParam param;
    param.Set(ptexIndex, (short)u, (short)v, (unsigned short) depth, nonquad,
              (unsigned short) boundaryMask, (unsigned short) transitionMask);
    return param;
}

//
//  We should be able to use a single Create() method for both the adaptive and uniform
//  cases.  In the past, more additional arguments were passed to the uniform version,
//  but that may no longer be necessary (see notes in the uniform version below)...
//
PatchTable *
PatchTableFactory::Create(TopologyRefiner const & refiner, Options options) {

    if (refiner.IsUniform()) {
        return createUniform(refiner, options);
    } else {
        return createAdaptive(refiner, options);
    }
}

PatchTable *
PatchTableFactory::createUniform(TopologyRefiner const & refiner, Options options) {

    assert(refiner.IsUniform());

    BuilderContext context(refiner, options);

    // ensure that triangulateQuads is only set for quadrilateral schemes
    options.triangulateQuads &= (refiner.GetSchemeType()==Sdc::SCHEME_BILINEAR ||
                                 refiner.GetSchemeType()==Sdc::SCHEME_CATMARK);

    // level=0 may contain n-gons, which are not supported in PatchTable.
    // even if generateAllLevels = true, we start from level 1.

    int maxvalence = refiner.GetMaxValence(),
        maxlevel = refiner.GetMaxLevel(),
        firstlevel = options.generateAllLevels ? 1 : maxlevel,
        nlevels = maxlevel-firstlevel+1;

    PatchDescriptor::Type ptype = PatchDescriptor::NON_PATCH;
    if (options.triangulateQuads) {
        ptype = PatchDescriptor::TRIANGLES;
    } else {
        switch (refiner.GetSchemeType()) {
            case Sdc::SCHEME_BILINEAR :
            case Sdc::SCHEME_CATMARK  : ptype = PatchDescriptor::QUADS; break;
            case Sdc::SCHEME_LOOP     : ptype = PatchDescriptor::TRIANGLES; break;
        }
    }
    assert(ptype!=PatchDescriptor::NON_PATCH);

    //
    //  Create the instance of the table and allocate and initialize its members.
    PatchTable * table = new PatchTable(maxvalence);

    table->_numPtexFaces = context.ptexIndices.GetNumFaces();

    table->reservePatchArrays(nlevels);

    PatchDescriptor desc(ptype);

    // generate patch arrays
    for (int level=firstlevel, poffset=0, voffset=0; level<=maxlevel; ++level) {

        TopologyLevel const & refLevel = refiner.GetLevel(level);

        int npatches = refLevel.GetNumFaces();
        if (refiner.HasHoles()) {
            for (int i = npatches - 1; i >= 0; --i) {
                npatches -= refLevel.IsFaceHole(i);
            }
        }
        assert(npatches>=0);

        if (options.triangulateQuads)
            npatches *= 2;

        table->pushPatchArray(desc, npatches, &voffset, &poffset, 0);
    }

    // Allocate various tables
    allocateVertexTables(context, table);

    if (context.RequiresFVarPatches()) {
        allocateFVarChannels(context, table);
    }

    //
    //  Now populate the patches:
    //

    Index          * iptr = &table->_patchVerts[0];
    PatchParam     * pptr = &table->_paramTable[0];
    Index         ** fptr = 0;

    // we always skip level=0 vertices (control cages)
    Index levelVertOffset = refiner.GetLevel(0).GetNumVertices();

    Index * levelFVarVertOffsets = 0;
    if (context.RequiresFVarPatches()) {

        levelFVarVertOffsets = (Index *)alloca(context.fvarChannelIndices.size()*sizeof(Index));
        memset(levelFVarVertOffsets, 0, context.fvarChannelIndices.size()*sizeof(Index));

        fptr = (Index **)alloca(context.fvarChannelIndices.size()*sizeof(Index *));
        for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {
            fptr[fvc] = table->getFVarValues(fvc).begin();
        }
    }

    for (int level=1; level<=maxlevel; ++level) {

        TopologyLevel const & refLevel = refiner.GetLevel(level);

        int nfaces = refLevel.GetNumFaces();
        if (level>=firstlevel) {
            for (int face=0; face<nfaces; ++face) {

                if (refiner.HasHoles() && refLevel.IsFaceHole(face)) {
                    continue;
                }

                ConstIndexArray fverts = refLevel.GetFaceVertices(face);
                for (int vert=0; vert<fverts.size(); ++vert) {
                    *iptr++ = levelVertOffset + fverts[vert];
                }

                *pptr++ = computePatchParam(context, level, face, /*boundary*/0, /*transition*/0);

                if (context.RequiresFVarPatches()) {
                    for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {
                        int refinerChannel = context.fvarChannelIndices[fvc];

                        ConstIndexArray fvalues = refLevel.GetFaceFVarValues(face, refinerChannel);
                        for (int vert=0; vert<fvalues.size(); ++vert) {
                            assert((levelVertOffset + fvalues[vert]) < (int)table->getFVarValues(fvc).size());
                            fptr[fvc][vert] = levelFVarVertOffsets[fvc] + fvalues[vert];
                        }
                        fptr[fvc]+=fvalues.size();
                    }
                }

                if (options.triangulateQuads) {
                    // Triangulate the quadrilateral: {v0,v1,v2,v3} -> {v0,v1,v2},{v3,v0,v2}.
                    *iptr = *(iptr - 4); // copy v0 index
                    ++iptr;
                    *iptr = *(iptr - 3); // copy v2 index
                    ++iptr;

                    *pptr = *(pptr - 1); // copy first patch param
                    ++pptr;

                    if (context.RequiresFVarPatches()) {
                        for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {
                            *fptr[fvc] = *(fptr[fvc]-4); // copy fv0 index
                            ++fptr[fvc];
                            *fptr[fvc] = *(fptr[fvc]-3); // copy fv2 index
                            ++fptr[fvc];
                        }
                    }
                }
            }
        }

        if (options.generateAllLevels) {
            levelVertOffset += refiner.GetLevel(level).GetNumVertices();
            for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {
                int refinerChannel = context.fvarChannelIndices[fvc];
                levelFVarVertOffsets[fvc] += refiner.GetLevel(level).GetNumFVarValues(refinerChannel);
            }
        }
    }
    return table;
}

PatchTable *
PatchTableFactory::createAdaptive(TopologyRefiner const & refiner, Options options) {

    assert(! refiner.IsUniform());

    BuilderContext context(refiner, options);

    //
    //  First identify the patches -- accumulating an inventory of
    //  information about each resulting patch:
    //
    identifyAdaptivePatches(context);

    //
    //  Create and initialize the instance of the table:
    //
    int maxValence = refiner.GetMaxValence();

    PatchTable * table = new PatchTable(maxValence);

    table->_numPtexFaces = context.ptexIndices.GetNumFaces();

    //
    //  Now populate the patches:
    //
    populateAdaptivePatches(context, table);

    return table;
}

//
//  Identify all patches required for faces at all levels -- accumulating the number of patches
//  for each type, and retaining enough information for the patch for each face to populate it
//  later with no additional analysis.
//
void
PatchTableFactory::identifyAdaptivePatches(BuilderContext & context) {

    TopologyRefiner const & refiner = context.refiner;

    //
    //  Iterate through the levels of refinement to inspect and tag components with information
    //  relative to patch generation.  We allocate all of the tags locally and use them to
    //  populate the patches once a complete inventory has been taken and all tables appropriately
    //  allocated and initialized:
    //
    //  The first Level may have no Refinement if it is the only level -- similarly the last Level
    //  has no Refinement, so a single level is effectively the last, but with less information
    //  available in some cases, as it was not generated by refinement.
    //
    int reservePatches = refiner.GetNumFacesTotal();
    context.patches.reserve(reservePatches);

    context.levelVertOffsets.push_back(0);
    context.levelFVarValueOffsets.resize(context.fvarChannelIndices.size());
    for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {
        context.levelFVarValueOffsets[fvc].push_back(0);
    }

    for (int levelIndex=0; levelIndex<refiner.GetNumLevels(); ++levelIndex) {
        Level const & level = refiner.getLevel(levelIndex);

        context.levelVertOffsets.push_back(
                context.levelVertOffsets.back() + level.getNumVertices());

        for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {
            int refinerChannel = context.fvarChannelIndices[fvc];
            context.levelFVarValueOffsets[fvc].push_back(
                context.levelFVarValueOffsets[fvc].back()
                + level.getNumFVarValues(refinerChannel));
        }

        for (int faceIndex = 0; faceIndex < level.getNumFaces(); ++faceIndex) {

            if (context.IsPatchEligible(levelIndex, faceIndex)) {

                context.patches.push_back(BuilderContext::PatchTuple(faceIndex, levelIndex));

                // Count the patches here to simplify subsequent allocation.
                if (context.IsPatchRegular(levelIndex, faceIndex)) {
                    ++context.numRegularPatches;
                } else {
                    ++context.numIrregularPatches;

                    // For legacy gregory patches we need to know how many
                    // irregular patches are also boundary patches.
                    if (context.options.GetEndCapType() == Options::ENDCAP_LEGACY_GREGORY) {
                        bool isBoundaryPatch = level.getFaceCompositeVTag(faceIndex)._boundary;
                        context.numIrregularBoundaryPatches += isBoundaryPatch;
                    }
                }
            }
        }
    }
}

//
//  Populate adaptive patches that we've previously identified.
//
void
PatchTableFactory::populateAdaptivePatches(
    BuilderContext & context, PatchTable * table) {

    TopologyRefiner const & refiner = context.refiner;

    // State needed to populate an array in the patch table.
    // Pointers in this structure are initialized after the patch array
    // data buffers have been allocated and are then incremented as we
    // populate data into the patch table. Currently, we'll have at
    // most 3 patch arrays: Regular, Irregular, and IrregularBoundary.
    struct PatchArrayBuilder {
        PatchArrayBuilder()
            : patchType(PatchDescriptor::REGULAR), numPatches(0)
            , iptr(NULL), pptr(NULL), sptr(NULL) { }

        PatchDescriptor::Type patchType;
        int numPatches;

        Far::Index *iptr;
        Far::PatchParam *pptr;
        Far::Index *sptr;
        Vtr::internal::StackBuffer<Far::Index*,1> fptr;
        Vtr::internal::StackBuffer<Far::PatchParam*,1> fpptr;

    private:
        // Non-copyable
        PatchArrayBuilder(PatchArrayBuilder const &) {}
        PatchArrayBuilder & operator=(PatchArrayBuilder const &) {return *this;}

    } arrayBuilders[3];
    int R = 0, IR = 1, IRB = 2; // Regular, Irregular, IrregularBoundary

    // Regular patches patches will be packed into the first patch array
    arrayBuilders[R].patchType = PatchDescriptor::REGULAR;
    arrayBuilders[R].numPatches = context.numRegularPatches;
    int numPatchArrays = (arrayBuilders[R].numPatches > 0);

    switch(context.options.GetEndCapType()) {
    case Options::ENDCAP_BSPLINE_BASIS:
        // Irregular patches are converted to bspline basis and
        // will be packed into the same patch array as regular patches
        IR = IRB = R;
        arrayBuilders[R].numPatches += context.numIrregularPatches;
        // Make sure we've counted this array even when
        // there are no regular patches.
        numPatchArrays = (arrayBuilders[R].numPatches > 0);
        break;
    case Options::ENDCAP_GREGORY_BASIS:
        // Irregular patches (both interior and boundary) are converted
        // to Gregory basis and will be packed into an additional patch array
        IR = IRB = numPatchArrays;
        arrayBuilders[IR].patchType = PatchDescriptor::GREGORY_BASIS;
        arrayBuilders[IR].numPatches += context.numIrregularPatches;
        numPatchArrays += (arrayBuilders[IR].numPatches > 0);
        break;
    case Options::ENDCAP_LEGACY_GREGORY:
        // Irregular interior and irregular boundary patches each will be
        // packed into separate additional patch arrays.
        IR = numPatchArrays;
        arrayBuilders[IR].patchType = PatchDescriptor::GREGORY;
        arrayBuilders[IR].numPatches = context.numIrregularPatches
                                     - context.numIrregularBoundaryPatches;
        numPatchArrays += (arrayBuilders[IR].numPatches > 0);

        IRB = numPatchArrays;
        arrayBuilders[IRB].patchType = PatchDescriptor::GREGORY_BOUNDARY;
        arrayBuilders[IRB].numPatches = context.numIrregularBoundaryPatches;
        numPatchArrays += (arrayBuilders[IRB].numPatches > 0);
        break;
    default:
        break;
    }

    // Create patch arrays
    table->reservePatchArrays(numPatchArrays);

    int voffset=0, poffset=0, qoffset=0;
    for (int arrayIndex=0; arrayIndex<numPatchArrays; ++arrayIndex) {
        PatchArrayBuilder & arrayBuilder = arrayBuilders[arrayIndex];
        table->pushPatchArray(PatchDescriptor(arrayBuilder.patchType),
            arrayBuilder.numPatches, &voffset, &poffset, &qoffset );
    }

    // Allocate patch array data buffers
    bool hasSharpness = context.options.useSingleCreasePatch;
    allocateVertexTables(context, table);

    if (context.RequiresFVarPatches()) {
        allocateFVarChannels(context, table);
    }

    // Initialize pointers used while populating patch array data buffers
    for (int arrayIndex=0; arrayIndex<numPatchArrays; ++arrayIndex) {
        PatchArrayBuilder & arrayBuilder = arrayBuilders[arrayIndex];

        arrayBuilder.iptr = table->getPatchArrayVertices(arrayIndex).begin();
        arrayBuilder.pptr = table->getPatchParams(arrayIndex).begin();
        if (hasSharpness) {
            arrayBuilder.sptr = table->getSharpnessIndices(arrayIndex);
        }

        if (context.RequiresFVarPatches()) {
            arrayBuilder.fptr.SetSize((int)context.fvarChannelIndices.size());
            arrayBuilder.fpptr.SetSize((int)context.fvarChannelIndices.size());

            for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {

                PatchDescriptor desc = table->GetFVarPatchDescriptor(fvc);

                Index pidx = table->getPatchIndex(arrayIndex, 0);
                int   ofs  = pidx * desc.GetNumControlVertices();

                arrayBuilder.fptr[fvc] = &table->getFVarValues(fvc)[ofs];
                arrayBuilder.fpptr[fvc] = &table->getFVarPatchParams(fvc)[pidx];
            }
        }
    }

    // endcap factories
    // XXX
    EndCapBSplineBasisPatchFactory *endCapBSpline = NULL;
    EndCapGregoryBasisPatchFactory *endCapGregoryBasis = NULL;
    EndCapLegacyGregoryPatchFactory *endCapLegacyGregory = NULL;
    Vtr::internal::StackBuffer<EndCapBSplineBasisPatchFactory*,1> fvarEndCapBSpline;
    Vtr::internal::StackBuffer<EndCapGregoryBasisPatchFactory*,1> fvarEndCapGregoryBasis;

    StencilTable *localPointStencils = NULL;
    StencilTable *localPointVaryingStencils = NULL;
    Vtr::internal::StackBuffer<StencilTable*,1> localPointFVarStencils;

    switch(context.options.GetEndCapType()) {
    case Options::ENDCAP_GREGORY_BASIS:
        localPointStencils = new StencilTable(0);
        localPointVaryingStencils = new StencilTable(0);
        endCapGregoryBasis = new EndCapGregoryBasisPatchFactory(
            refiner,
            localPointStencils,
            localPointVaryingStencils,
            context.options.shareEndCapPatchPoints);
        break;
    case Options::ENDCAP_BSPLINE_BASIS:
        localPointStencils = new StencilTable(0);
        localPointVaryingStencils = new StencilTable(0);
        endCapBSpline = new EndCapBSplineBasisPatchFactory(
            refiner,
            localPointStencils,
            localPointVaryingStencils);
        break;
    case Options::ENDCAP_LEGACY_GREGORY:
        endCapLegacyGregory = new EndCapLegacyGregoryPatchFactory(refiner);
        break;
    default:
        break;
    }

    if (context.RequiresFVarPatches()) {
        fvarEndCapBSpline.SetSize((int)context.fvarChannelIndices.size());
        fvarEndCapGregoryBasis.SetSize((int)context.fvarChannelIndices.size());
        localPointFVarStencils.SetSize((int)context.fvarChannelIndices.size());

        for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {
            switch(context.options.GetEndCapType()) {
            case Options::ENDCAP_GREGORY_BASIS:
                localPointFVarStencils[fvc] = new StencilTable(0);
                fvarEndCapGregoryBasis[fvc] = new EndCapGregoryBasisPatchFactory(
                    refiner,
                    localPointFVarStencils[fvc],
                    NULL,
                    context.options.shareEndCapPatchPoints);
                break;
            case Options::ENDCAP_BSPLINE_BASIS:
                localPointFVarStencils[fvc] = new StencilTable(0);
                fvarEndCapBSpline[fvc] = new EndCapBSplineBasisPatchFactory(
                    refiner,
                    localPointFVarStencils[fvc],
                    NULL);
                break;
            default:
                break;
            }
        }
    }

    // Populate patch data buffers
    for (int patchIndex=0; patchIndex<(int)context.patches.size(); ++patchIndex) {

        BuilderContext::PatchTuple const & patch = context.patches[patchIndex];

        Level const & level = refiner.getLevel(patch.levelIndex);

        Level::VTag faceVTags = level.getFaceCompositeVTag(patch.faceIndex);

        PatchArrayBuilder * arrayBuilder = 0;

        // Properties to potentially be shared across vertex and face-varying patches:
        int          regBoundaryMask = 0;
        bool         isRegSingleCrease = false;
        Level::VSpan irregCornerSpans[4];
        float        sharpness = 0.0f;

        bool isRegular = context.IsPatchRegular(patch.levelIndex, patch.faceIndex);
        if (isRegular) {
            // Build the regular patch array
            arrayBuilder = &arrayBuilders[R];

            regBoundaryMask = context.GetRegularPatchBoundaryMask(patch.levelIndex, patch.faceIndex);

            // Test regular interior patches for a single-crease patch when specified:
            if (hasSharpness && (regBoundaryMask == 0) && (faceVTags._semiSharpEdges ||
                                                           faceVTags._infSharpEdges)) {
                float edgeSharpness = 0.0f;
                int   edgeInFace = 0;
                if (level.isSingleCreasePatch(patch.faceIndex, &edgeSharpness, &edgeInFace)) {
                    // cap sharpness to the max isolation level
                    edgeSharpness = std::min(edgeSharpness,
                        float(context.options.maxIsolationLevel - patch.levelIndex));

                    if (edgeSharpness > 0.0f) {
                        isRegSingleCrease = true;
                        regBoundaryMask = (1 << edgeInFace);
                        sharpness = edgeSharpness;
                    }
                }
            }
            
            //  The single-crease patch is an interior patch so ignore boundary mask when gathering:
            if (isRegSingleCrease) {
                arrayBuilder->iptr +=
                    context.GatherRegularPatchPoints(arrayBuilder->iptr, patch, 0);
            } else {
                arrayBuilder->iptr +=
                    context.GatherRegularPatchPoints(arrayBuilder->iptr, patch, regBoundaryMask);
            }
        } else {
            // Build the irregular patch array
            arrayBuilder = &arrayBuilders[IR];

            context.GetIrregularPatchCornerSpans(patch.levelIndex, patch.faceIndex, irregCornerSpans);

            // switch endcap patchtype by option
            switch(context.options.GetEndCapType()) {
            case Options::ENDCAP_GREGORY_BASIS:
                arrayBuilder->iptr +=
                    context.GatherIrregularPatchPoints(
                        endCapGregoryBasis, arrayBuilder->iptr, patch, irregCornerSpans);
                break;
            case Options::ENDCAP_BSPLINE_BASIS:
                arrayBuilder->iptr +=
                    context.GatherIrregularPatchPoints(
                        endCapBSpline, arrayBuilder->iptr, patch, irregCornerSpans);
                break;
            case Options::ENDCAP_LEGACY_GREGORY:
                // For legacy gregory patches we may need to switch to
                // the irregular boundary patch array.
                if (!faceVTags._boundary) {
                    arrayBuilder->iptr +=
                        context.GatherIrregularPatchPoints(
                            endCapLegacyGregory, arrayBuilder->iptr, patch, irregCornerSpans);
                } else {
                    arrayBuilder = &arrayBuilders[IRB];
                    arrayBuilder->iptr +=
                        context.GatherIrregularPatchPoints(
                            endCapLegacyGregory, arrayBuilder->iptr, patch, irregCornerSpans);
                }
                break;
            case Options::ENDCAP_BILINEAR_BASIS:
                // not implemented yet
                assert(false);
                break;
            default:
                // no endcap
                break;
            }
        }

        // Assign the patch param (why is transition mask 0 if not regular?)
        int paramBoundaryMask = regBoundaryMask;
        int paramTransitionMask = isRegular ?
                context.GetTransitionMask(patch.levelIndex, patch.faceIndex) : 0;

        PatchParam patchParam =
            computePatchParam(context,
                              patch.levelIndex, patch.faceIndex,
                              paramBoundaryMask, paramTransitionMask);
        *arrayBuilder->pptr++ = patchParam;

        if (hasSharpness) {
            *arrayBuilder->sptr++ =
                assignSharpnessIndex(sharpness, table->_sharpnessValues);
        }

        if (context.RequiresFVarPatches()) {
            for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {

                BuilderContext::PatchTuple fvarPatch(patch);

                PatchDescriptor desc = table->GetFVarPatchDescriptor(fvc);

                PatchParam fvarPatchParam = patchParam;

                // Deal with the linear cases trivially first
                if (desc.GetType() == PatchDescriptor::QUADS) {
                    arrayBuilder->fptr[fvc] +=
                        context.GatherLinearPatchPoints(
                            arrayBuilder->fptr[fvc], fvarPatch, fvc);
                    *arrayBuilder->fpptr[fvc]++ = fvarPatchParam;
                    continue;
                }

                // For non-linear patches, reuse patch information when the topology
                // of the face in face-varying space matches the original patch:
                //
                bool fvarTopologyMatches = context.DoesFaceVaryingPatchMatch(
                        patch.levelIndex, patch.faceIndex, fvc);

                bool fvarIsRegular = fvarTopologyMatches ? isRegular :
                        context.IsPatchRegular(patch.levelIndex, patch.faceIndex, fvc);

                int fvarBoundaryMask = 0;
                if (fvarIsRegular) {
                    fvarBoundaryMask = fvarTopologyMatches ? regBoundaryMask :
                        context.GetRegularPatchBoundaryMask(patch.levelIndex, patch.faceIndex, fvc);

                    if (isRegSingleCrease && fvarTopologyMatches) {
                        context.GatherRegularPatchPoints(
                                arrayBuilder->fptr[fvc], fvarPatch, 0, fvc);
                    } else {
                        context.GatherRegularPatchPoints(
                                arrayBuilder->fptr[fvc], fvarPatch, fvarBoundaryMask, fvc);
                    }
                } else {
                    Level::VSpan  localCornerSpans[4];
                    Level::VSpan* fvarCornerSpans = localCornerSpans;
                    if (fvarTopologyMatches) {
                        fvarCornerSpans = irregCornerSpans;
                    } else {
                        context.GetIrregularPatchCornerSpans(
                                patch.levelIndex, patch.faceIndex, fvarCornerSpans, fvc);
                    }

                    if (desc.GetType() == PatchDescriptor::REGULAR) {
                        context.GatherIrregularPatchPoints(
                                fvarEndCapBSpline[fvc],
                                arrayBuilder->fptr[fvc], fvarPatch, fvarCornerSpans, fvc);
                    } else if (desc.GetType() == PatchDescriptor::GREGORY_BASIS) {
                        context.GatherIrregularPatchPoints(
                                fvarEndCapGregoryBasis[fvc],
                                arrayBuilder->fptr[fvc], fvarPatch, fvarCornerSpans, fvc);
                    } else {
                        assert("Unknown Descriptor for FVar patch" == 0);
                    }
                }
                arrayBuilder->fptr[fvc] += desc.GetNumControlVertices();

                fvarPatchParam.Set(
                    patchParam.GetFaceId(),
                    patchParam.GetU(), patchParam.GetV(),
                    patchParam.GetDepth(),
                    patchParam.NonQuadRoot(),
                    (fvarIsRegular ? fvarBoundaryMask : 0),
                    patchParam.GetTransition(),
                    fvarIsRegular);
                *arrayBuilder->fpptr[fvc]++ = fvarPatchParam;
            }
        }
    }

    table->populateVaryingVertices();

    // finalize end patches
    if (localPointStencils && localPointStencils->GetNumStencils() > 0) {
        localPointStencils->finalize();
    } else {
        delete localPointStencils;
        localPointStencils = NULL;
    }

    if (localPointVaryingStencils && localPointVaryingStencils->GetNumStencils() > 0) {
        localPointVaryingStencils->finalize();
    } else {
        delete localPointVaryingStencils;
        localPointVaryingStencils = NULL;
    }

    switch(context.options.GetEndCapType()) {
    case Options::ENDCAP_GREGORY_BASIS:
        table->_localPointStencils = localPointStencils;
        table->_localPointVaryingStencils = localPointVaryingStencils;
        delete endCapGregoryBasis;
        break;
    case Options::ENDCAP_BSPLINE_BASIS:
        table->_localPointStencils = localPointStencils;
        table->_localPointVaryingStencils = localPointVaryingStencils;
        delete endCapBSpline;
        break;
    case Options::ENDCAP_LEGACY_GREGORY:
        endCapLegacyGregory->Finalize(
            table->GetMaxValence(),
            &table->_quadOffsetsTable,
            &table->_vertexValenceTable);
        delete endCapLegacyGregory;
        break;
    default:
        break;
    }

    if (context.RequiresFVarPatches()) {
        table->_localPointFaceVaryingStencils.resize(
                                        context.fvarChannelIndices.size());

        for (int fvc=0; fvc<(int)context.fvarChannelIndices.size(); ++fvc) {
            if (localPointFVarStencils[fvc]->GetNumStencils() > 0) {
                localPointFVarStencils[fvc]->finalize();
            } else {
                delete localPointFVarStencils[fvc];
                localPointFVarStencils[fvc] = NULL;
            }

            switch(context.options.GetEndCapType()) {
            case Options::ENDCAP_GREGORY_BASIS:
                delete fvarEndCapGregoryBasis[fvc];
                break;
            case Options::ENDCAP_BSPLINE_BASIS:
                delete fvarEndCapBSpline[fvc];
                break;
            default:
                break;
            }

            table->_localPointFaceVaryingStencils[fvc] =
                                        localPointFVarStencils[fvc];
        }
    }
}

//
//  Implementation of the PatchFaceTag:
//
void
PatchTableFactory::PatchFaceTag::clear() {
    std::memset(this, 0, sizeof(*this));
}

void
PatchTableFactory::PatchFaceTag::assignTransitionPropertiesFromEdgeMask(int tMask) {
    _transitionMask = tMask;
}

void
PatchTableFactory::PatchFaceTag::assignBoundaryPropertiesFromEdgeMask(int eMask) {

    static int const edgeMaskToCount[16] =
        { 0, 1, 1, 2, 1, -1, 2, -1, 1, 2, -1, -1, 2, -1, -1, -1 };
    static int const edgeMaskToIndex[16] =
        { -1, 0, 1, 1, 2, -1, 2, -1, 3, 0, -1, -1, 3, -1, -1,-1 };

    assert(edgeMaskToCount[eMask] != -1);
    assert(edgeMaskToIndex[eMask] != -1);

    _boundaryMask    = eMask;
    _hasBoundaryEdge = (eMask > 0);

    _boundaryCount = edgeMaskToCount[eMask];
    _boundaryIndex = edgeMaskToIndex[eMask];
}

void
PatchTableFactory::PatchFaceTag::assignBoundaryPropertiesFromVertexMask(int vMask) {

    // This is only intended to support the case of a single boundary vertex with no
    // boundary edges, which can only occur with an irregular vertex

    static int const singleBitVertexMaskToCount[16] =
        { 0, 1, 1, -1, 1, -1 , -1, -1, 1, -1 , -1, -1, -1, -1 , -1, -1 };
    static int const singleBitVertexMaskToIndex[16] =
        { 0, 0, 1, -1, 2, -1 , -1, -1, 3, -1 , -1, -1, -1, -1 , -1, -1 };

    assert(_hasBoundaryEdge == false);
    assert(singleBitVertexMaskToCount[vMask] != -1);
    assert(singleBitVertexMaskToIndex[vMask] != -1);

    _boundaryMask = vMask;

    _boundaryCount = singleBitVertexMaskToCount[vMask];
    _boundaryIndex = singleBitVertexMaskToIndex[vMask];
}

} // end namespace Far

} // end namespace OPENSUBDIV_VERSION
} // end namespace OpenSubdiv