ハードウェア レンダリング用のジオメトリ リマッピング

v0 = quad vertex 0
v1 = quad vertex 1
v2 = quad vertex 2
v3 = quad vertex 3

dist02 = distance between v0 and v2
dist13 = distance between v1 and v3

// Use small tolerance so exact squares triangulate consistently
// one way rather than randomly due to rounding errors
fudgeFactor = 0.999f
canSplit = false
split02 = false

if( dist02 < fudgeFactor*dist13 )
{
    n1 = normal of triangle 1, 2, 0
    n2 = normal of triangle 2, 3, 0

    if( angle between n1 and n2 is less than 90 degrees )
    {
        if( area of triangle1 < 7 * area of triangle2 &&
                    area of triangle2 < 7 * area of triangle1 )
        {
            canSplit = true
            split02 = true
        } 
    }
}
else
{
    n1 = normal of triangle 0, 1, 3
    n2 = normal of triangle 3, 1, 2

    if( angle between n1 and n2 is less than 90 degrees )
    {
        if( area of triangle1 < 7 * area of triangle2 &&
                area of triangle2 < 7 * area of triangle1 )
        {
            canSplit = true
            split02 = false
        } 
    }
}

if( canSplit )
{
    if( split02 )
    {
        set triangle 1 = 1,2,0
        set triangle 2 = 0,2,3
    }
    else
    { 
        set triangle 1 = 0,1,3
        set triangle 2 = 3,1,2
    }
}
else 
{
   // Fall back to general triangulation algorithm    
}

// Get the UV of the bottom-left corner of the subdivided face.
//
// - subdFaceIndex, the index of subdivided face within a base face.
// - subdLevel, the Catmull-Clark subdivision level 
//
// such that: 
//
// - subdLevel >= 1 
// - 0 <= subdFaceIndex <= 4^subdLevel
// - the UV value is encoded as an integer within [0, 2^subdLevel].
//
getSubFaceUV(subdFaceIndex, subdLevel) 
{
    uv = (0,0);

    count = pow(4, subdLevel - 1);
    ofs = pow(2, subdLevel - 1);

    // Iteratively find the index of a parent face in each subdivision level,
    // and offset the UV accordingly.
    faceIndex = subdFaceIndex;
    while (count > 0) {        
        start = faceIndex / count;
        switch (start) {
            case 0:                  break;
            case 1: uv += (ofs,0);   break;
            case 2: uv += (ofs,ofs); break;
            case 3: uv += (0,ofs);   break;
        }

        faceIndex %= count;
        ofs >>= 1;
        count >>= 2;
    }    
    return uv;
}

// Get the UV of the vertex on the subdivided face.
//
// - subdFaceStartUV: the UV of the bottom-left corner of the subd face.
// - subdVertexIndex: vertex index on the subdivided face, 0~3.
//
getSubVertexUV(subdFaceStartUV, subdVertexIndex) {
    uv = (0,0);
    switch (subdVertexIndex) {
        case 0:              break;
        case 1: uv += (1,0); break;
        case 2: uv += (1,1); break;
        case 3: uv += (0,1); break;    
    }
    return subdFaceStartUV + uv;
}

subdFaceStartUV = getSubFaceUV(subdFaceIndex, subdLevel);
subdVertexUV = getSubVertexUV (subdFaceStartUV, subdVertexIndex);
subdVertexUV /= pow(2, subdLevel);

// Get the UV of the bottom-left corner of the subdivided face.
// 
// - subdFaceIndex, the index of subdivided face within a base face
// - subdLevel, the Catmull-Clark subdivision level
// 
// such that:
//
// - subdLevel >= 1. 
// - 0 <= subdFaceIndex <= 4^subdLevel,
// - the uv is encoded as integer within [0, 2^subdLevel].
//
getSubFaceUV(subdFaceIndex, subdLevel) {
    uv = (0,0);    
    start = 1;

    count = pow(4, subdLevel - 1);
    ofs = pow(2, subdLevel - 1);

    // Iteratively find the index of parent face in each subdivision level,
    // and offset the UV's accordingly.
    faceIndex = subdFaceIndex;
    while (count > 0) {
        // Unlike OSD subdivided topology, the start position of the child face 
        // is related to that of the parent face.
        start = (start + faceIndex / count) % 4;
        switch (start) {
            case 0:                  break;
            case 1: uv += (ofs,0);   break;
            case 2: uv += (ofs,ofs); break;
            case 3: uv += (0,ofs);   break;
        }

        faceIndex %= count;
        ofs >>= 1;
        count >>= 2;
    }
    // The start position of the face is also returned.
    return (uv, start);
}

// Get the uv of the vertex on the subdivided face.
//
// - subdFaceStartUV, the UV of the bottom-left corner of the subdivided face.
// - subdVertexIndex, vertex index on the subdivided face, 0~3.
//
getSubVertexUV(subFaceStartIndex, subFaceStartUV, subdVertexIndex) {
    uv = (0,0);
    // Unlike OSD subdivided topology, the start of the vertex relies on 
    // the start position of the face.
    start = (subdFaceIndex - 1 + 4) % 4;
    switch ((start + subdVertexIndex) % 4) {
        case 0:              break;
        case 1: uv += (1,0); break;
        case 2: uv += (1,1); break;
        case 3: uv += (0,1); break;    
    }
    return subFaceStartUV + uv;
}

(subdFaceStartUV, start) = getSubFaceUV(subdFaceIndex, subdLevel);
subdVertexUV = getSubVertexUV(start, subdFaceStartUV, subdVertexIndex);
subdVertexUV /= pow(2, subdLevel);

MStatus MPxHwShaderNode::glGeometry( const MDagPath& shapePath,
    int prim,
    unsigned int writable,
    int indexCount,
    const unsigned int * indexArray,
    int vertexCount,
    const int * vertexIDs,
    const float* vertexArray,
    int normalCount,
    floatArrayPtr normalArrays,
    int colorCount,
    floatArrayPtr colorArrays,
    int texCoordCount,
    floatArrayPtr texCoordArrays,
    const int * faceIDs,
    const float * localUVCoord)

// Dump out vertexIDs
if (vertexIDs)
{
    for (int i=0; i<vertexCount; i++)
    {
        printf("%d\n", vertexIDs[i]);
    }
}

// Dump out face IDs
if (faceIDs)
{
    for (int i=0; i<vertexCount; i++)
    {
        printf("%d\n", faceIDs[i]);
    }
}
}

// Dump out float pairs for the local parameterization (UV)
if (localUVCoord)
{
    for (int i = 0; i < vertexCount; i++)
    {
        printf("(%g, %g)\n", localUVCoord[i*2], localUVCoord[i*2 + 1]);
    }
}

// Ask for vertex IDs
MHWRender::MVertexBufferDescriptor vertexIdDesc(
    empty,
    MHWRender::MGeometry::kTexture,
    MHWRender::MGeometry::kFloat,
    1);
vertexIdDesc.setSemanticName("vertexid");
addGeometryRequirement(vertexIdDesc);

// Ask for face IDs
MHWRender::MVertexBufferDescriptor faceIdDesc(
    empty,
    MHWRender::MGeometry::kTexture,
    MHWRender::MGeometry::kFloat,
    1);
faceIdDesc.setSemanticName("faceid");
addGeometryRequirement(faceIdDesc);

// Ask for local parameterization data
MHWRender::MVertexBufferDescriptor localUvCoordDesc(
    empty,
    MHWRender::MGeometry::kTexture,
    MHWRender::MGeometry::kFloat,
    1);
faceIdDesc.setSemanticName("localuvcoord");
addGeometryRequirement(localUvCoordDesc);

for (int vbIdx=0; vbIdx<geometry->vertexBufferCount(); vbIdx++)
{
    const MHWRender::MVertexBuffer* vb = geometry->vertexBuffer(vbIdx);
    if (!vb) continue;

    const MHWRender::MVertexBufferDescriptor& desc = vb->descriptor();
    if (desc.dimension() != 1) continue;

    // Check if semantic is for the streams we’re looking for.
    MString semanticName = desc.semanticName();

    // Dump out local parameterization. Each pair of float values gives
    // a local UV on the base face.
    if (semanticName == "localuvcoord")
    {
        // Cancel constness to map buffer and dump data.
        MHWRender::MVertexBuffer* 
        nonConstVB = const_cast<MHWRender::MVertexBuffer*>(vb);
    
        const float *ptr = (const float*)nonConstVB->map();
        for (unsigned int k = 0; k < vb->vertexCount(); k++)
        {
            printf("%s[%d] = (%g, %g)\n", semanticName.asChar(), 
                k, ptr[2*k], ptr[2*k + 1]);
        }
        nonConstVB->unmap();
    }

    // Dump out vertex or face identifiers. If smoothed the vertex ids will be
    // the smoothed ids, but the face ids are always the base face ids.
    //
    if (semanticName != "vertexid" && semanticName != "faceid") continue;

    MHWRender::MVertexBuffer* nonConstVB = const_cast<MHWRender::MVertexBuffer*>(vb);
    const float *ptr = (const float*)nonConstVB->map();
    for (unsigned int k=0; k<vb->vertexCount(); k++)
    {
        printf("%s[%d] = %f\n", semanticName.asChar(), k, ptr[k] );
    }
    nonConstVB->unmap();
}

MStatus status;
MHWRender::MPolyGeomOptions options = MHWRender::kPolyGeom_Normal;
if (requiresUnsharedGeometricStreams(requirements))
{
    options = options | MHWRender::kPolyGeom_NotSharing;
}
MHWRender::MGeometryExtractor extractor(requirements, fPath, options, &status);

bool requiresUnsharedGeometricStreams(const MHWRender::MGeometryRequirements& requirements)
{
    // Only when vertexid, faceid or localuvcoord is required do the unshared geometric
    // streams need to be extracted
    const MHWRender::MVertexBufferDescriptorList& descList = requirements.vertexRequirements();
    for (int reqNum = 0; reqNum < descList.length(); ++reqNum)
    {
        MHWRender::MVertexBufferDescriptor desc;
        if (descList.getDescriptor(reqNum, desc) &&
            desc.semantic() == MHWRender::MGeometry::kTexture)
        {
            const MString semanticName = desc.semanticName();
            if (semanticName == "vertexid" ||
                semanticName == "faceid" ||
                semanticName == "localuvcoord")
            {
                    return true;
            }
        }
    }
    return false;
}

// Request vertex IDs (or face IDs, local parameterization)
MHWRender::MVertexBufferDescriptor vertexIdDesc(
    empty,
    MHWRender::MGeometry::kTexture,
    MHWRender::MGeometry::kFloat,
    1);
vertexIdDesc.setSemanticName("vertexid");

// Create a vertex buffer via MGeometry interface, extract and fill the data.
MHWRender::MVertexBuffer vertexBuffer = geometry.createVertexBuffer(vertexIdDesc);
unsigned int vertexCount = extractor.vertexCount();
float* data = (float*)vertexBuffer->acquire(vertexCount, true);
if (data && extractor.populateVertexBuffer(data, vertexCount, vertexIdDesc))
{
    vertexBuffer->commit(data);
}