Esempio n. 1
0
//------------------------------------------------------------------------------
// generate display IDs for Far faces
static void
createFaceNumbers(OpenSubdiv::Far::TopologyRefiner const & refiner,
    std::vector<Vertex> const & vertexBuffer) {

    static char buf[16];

    if (refiner.IsUniform()) {
        int maxlevel = refiner.GetMaxLevel(),
            firstvert = 0;

        for (int i=0; i<maxlevel; ++i) {
            firstvert += refiner.GetLevel(i).GetNumVertices();
        }

        OpenSubdiv::Far::TopologyLevel const & refLastLevel = refiner.GetLevel(maxlevel);

        for (int face=0; face<refLastLevel.GetNumFaces(); ++face) {

            Vertex center(0.0f, 0.0f, 0.0f);

            OpenSubdiv::Far::ConstIndexArray const verts = refLastLevel.GetFaceVertices(face);

            float weight = 1.0f / (float)verts.size();

            for (int vert=0; vert<verts.size(); ++vert) {
                center.AddWithWeight(vertexBuffer[firstvert+verts[vert]], weight);
            }

            snprintf(buf, 16, "%d", face);
            g_font->Print3D(center.GetPos(), buf, 2);
        }
    } else {
        int maxlevel = refiner.GetMaxLevel(),
//            patch = refiner.GetLevel(0).GetNumFaces(),
            firstvert = refiner.GetLevel(0).GetNumVertices();

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

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

            int nfaces = refLevel.GetNumFaces();

            for (int face=0; face<nfaces; ++face /*, ++patch */) {

                Vertex center(0.0f, 0.0f, 0.0f);

                OpenSubdiv::Far::ConstIndexArray const verts = refLevel.GetFaceVertices(face);

                float weight = 1.0f / (float)verts.size();

                for (int vert=0; vert<verts.size(); ++vert) {
                    center.AddWithWeight(vertexBuffer[firstvert+verts[vert]], weight);
                }
                snprintf(buf, 16, "%d", face);
                g_font->Print3D(center.GetPos(), buf, 2);
            }
            firstvert+=refLevel.GetNumVertices();
        }
    }
}
Esempio n. 2
0
//------------------------------------------------------------------------------
// generate display vert IDs for the selected Far patch
static void
createPatchNumbers(OpenSubdiv::Far::PatchTable const & patchTable,
    std::vector<Vertex> const & vertexBuffer) {

    if (not g_currentPatch)
        return;

    int patchID = g_currentPatch-1,
        patchArray = -1;

    // Find PatchArray containing our patch
    for (int array=0; array<(int)patchTable.GetNumPatchArrays(); ++array) {
        int npatches = patchTable.GetNumPatches(array);
        if (patchID >= npatches) {
            patchID -= npatches;
        } else {
            patchArray = array;
            break;
        }
    }
    if (patchArray==-1) {
        return;
    }

    g_currentPatchDesc = patchTable.GetPatchArrayDescriptor(patchArray);

    OpenSubdiv::Far::ConstIndexArray const cvs =
        patchTable.GetPatchVertices(patchArray, patchID);

    static char buf[16];
    for (int i=0; i<cvs.size(); ++i) {
        snprintf(buf, 16, "%d", i);
        g_font->Print3D(vertexBuffer[cvs[i]].GetPos(), buf, 1);
    }
}
Esempio n. 3
0
//------------------------------------------------------------------------------
// generate display IDs for Far edges
static void
createEdgeNumbers(OpenSubdiv::Far::TopologyRefiner const & refiner,
    std::vector<Vertex> const & vertexBuffer, bool ids=false, bool sharpness=false) {

    if (ids or sharpness) {

        int maxlevel = refiner.GetMaxLevel(),
            firstvert = 0;

        for (int i=0; i<maxlevel; ++i) {
            firstvert += refiner.GetLevel(i).GetNumVertices();
        }

        OpenSubdiv::Far::TopologyLevel const & refLastLevel = refiner.GetLevel(maxlevel);

        static char buf[16];
        for (int i=0; i<refLastLevel.GetNumEdges(); ++i) {

            Vertex center(0.0f, 0.0f, 0.0f);

            OpenSubdiv::Far::ConstIndexArray const verts = refLastLevel.GetEdgeVertices(i);
            assert(verts.size()==2);

            center.AddWithWeight(vertexBuffer[firstvert+verts[0]], 0.5f);
            center.AddWithWeight(vertexBuffer[firstvert+verts[1]], 0.5f);

            if (ids) {
                snprintf(buf, 16, "%d", i);
                g_font->Print3D(center.GetPos(), buf, 3);
            }

            if (sharpness) {
                float sharpness = refLastLevel.GetEdgeSharpness(i);
                if (sharpness>0.0f) {
                    snprintf(buf, 16, "%g", sharpness);
                    g_font->Print3D(center.GetPos(), buf, std::min(8,(int)sharpness+4));
                }
            }
        }
    }
}
Esempio n. 4
0
//------------------------------------------------------------------------------
// generate display vert IDs for the selected Far FVar patch
static void
createFVarPatchNumbers(OpenSubdiv::Far::PatchTable const & patchTable,
    std::vector<Vertex> const & fvarBuffer) {

    static int channel = 0;

    int patch = g_currentPatch-1;
    static char buf[16];

    if (patch>=0 and patch<patchTable.GetNumPatchesTotal()) {

        OpenSubdiv::Far::PatchTable::PatchHandle handle;
        handle.patchIndex = patch;

        OpenSubdiv::Far::ConstIndexArray const cvs =
            patchTable.GetPatchFVarValues(handle, channel);

        for (int i=0; i<cvs.size(); ++i) {
            snprintf(buf, 16, "%d", i);
            g_font->Print3D(fvarBuffer[cvs[i]].GetPos(), buf, 2);
        }

    }
}
Esempio n. 5
0
bool
PxOsdUniformEvaluator::Initialize(
    PxOsdTopologyRefinerSharedPtr refiner,
    const PxOsdMeshTopology &topology,
    int level,
    string *errorMessage)    
{    
    TRACE_FUNCTION();

    _topology = topology;

    refiner->RefineUniform(level);
    
    Far::StencilTableFactory::Options options;
    options.generateOffsets = true;
    options.generateIntermediateLevels = false;
    _vertexStencils =
        Far::StencilTableFactory::Create(*refiner, options);

    Far::PatchTable const *patchTable  =
        Far::PatchTableFactory::Create(*refiner);

    if (not (TF_VERIFY(_vertexStencils) and TF_VERIFY(patchTable))) {
        return false;
    }
    
    // populate refined quad indices, note that four indices are packed
    // for each quad.
    int numRefinedQuadIndices = refiner->GetLevel(level).GetNumFaceVertices();
    
    _refinedQuadIndices.resize(numRefinedQuadIndices);
    for (int i=0; i<numRefinedQuadIndices/4; ++i) {
        OpenSubdiv::Far::ConstIndexArray faceVertices =
            refiner->GetLevel(level).GetFaceVertices(i);
        int baseIndex = i*4;
        if (faceVertices.size() != 4) {
            TF_WARN("Non-quad found after subdivision, bailing");
            delete patchTable;            
            return false;
        }
        for (int j=0; j<4; ++j) {
            _refinedQuadIndices[baseIndex+j] = faceVertices[j];
        }
    }
    

    int numRefinedQuads = _refinedQuadIndices.size()/4;
    _subfaceUvs.resize(_refinedQuadIndices.size());
    vector<float>::iterator uvIt = _subfaceUvs.begin();

    _ptexIndices.resize(numRefinedQuads);
    vector<int>::iterator idIt = _ptexIndices.begin();

    const Far::PatchParamTable &patchParamTable =
        patchTable->GetPatchParamTable();
    
    for (int refinedIndex = 0; refinedIndex < numRefinedQuads; ++refinedIndex) {
        
        const Far::PatchParam& param =
            patchParamTable[refinedIndex];
        
        float u0 = 0;
        float v0 = 0;
        _InverseNormalize(param, u0, v0);
        
        float u1 = 1;
        float v1 = 1;
        _InverseNormalize(param, u1, v1);
        
        *idIt++ = param.GetFaceId();
        *uvIt++ = u0;
        *uvIt++ = v0;
        *uvIt++ = u1;
        *uvIt++ = v1;
    }
    
    delete patchTable;

    return true;
}