[1] 平面(Plane)图形的生成算法

顶点数据的生成

bool                        YfBuildPlaneVertices
(
    Yreal                   width, 
    Yreal                   length, 
    Yreal                   height, 
    Yuint                   slices, 
    Yuint                   stacks, 
    YeOriginPose            originPose,     
    Yuint                   vertexStriding, 
    Yuint                   vertexPos,    
    void*                   pVerticesBuffer
)
{
    if (slices < 2 || stacks < 2 || !pVerticesBuffer)
    {
        return false;
    }

    // 顶点赋值
    char* vertexPtr = (char*)pVerticesBuffer + vertexPos;
    YsVector3* curVertexPtr = NULL;
    Yuint nOffset = 0;
  
    Yreal xStep = width  / slices;
    Yreal zStep = length / stacks;
    YsVector3 vOrigin;
    if (originPose == YE_ORIGIN_POSE_CENTER)
    {
        vOrigin.x = -width * 0.5f;
        vOrigin.z = -length * 0.5f;
    }

    for (Yuint j = 0; j < stacks; j++)             // Z方向
    {
        for (Yuint i = 0; i < slices; i++)         // X方向
        {
            nOffset =  (j*slices + i) * vertexStriding;
            curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
            curVertexPtr->x = vOrigin.x + i*xStep;
            curVertexPtr->y = height;
            curVertexPtr->z = vOrigin.z + j*zStep;
        }
    }

    return true;
}

三角形索引数据的生成

bool                        YfBuildPlaneTriIndices
(
    Yuint                   slices,
    Yuint                   stacks, 
    YeIndexType             indexType,
    Yuint                   indexStriding,  
    Yuint                   indexPos,
    void*                   pTriIndicesBuffer
)
{
    if (slices < 2 || stacks < 2 || !pTriIndicesBuffer)
    {
        return false;
    }

    Yuint numVertices  = slices * stacks;
    if (indexType == YE_INDEX_16_BIT && 
        numVertices > YD_MAX_UNSIGNED_INT16)
    {
        return false;
    }

    Yuint numTriangles = (slices - 1) * (stacks - 1) * 2;

    char* indexPtr = (char*)pTriIndicesBuffer + indexPos;
    Yuint nOffset = 0;

    if (indexType == YE_INDEX_16_BIT)
    {
        YsTriIndex16* triIndexPtr = NULL;

        for (Yuint j = 0; j < stacks - 1; j++)             // Z方向
        {
            for (Yuint i = 0; i < slices - 1; i++)         // X方向
            {
                nOffset = (2 * (j*(slices - 1) + i)) * indexStriding;
                triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
                triIndexPtr->index0 = j*slices + i;
                triIndexPtr->index1 = (j + 1)*slices + i + 1;
                triIndexPtr->index2 = j*slices + i + 1;

                nOffset += indexStriding;                
                triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
                triIndexPtr->index0 = j*slices + i;
                triIndexPtr->index1 = (j + 1)*slices + i;
                triIndexPtr->index2 = (j + 1)*slices + i + 1;
            }
        }
    }
    else
    {
        YsTriIndex32* triIndexPtr = NULL;

        for (Yuint j = 0; j < stacks - 1; j++)             // Z方向
        {
            for (Yuint i = 0; i < slices - 1; i++)         // X方向
            {
                nOffset = (2 * (j*(slices - 1) + i)) * indexStriding;
                triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
                triIndexPtr->index0 = j*slices + i;
                triIndexPtr->index1 = (j + 1)*slices + i + 1;
                triIndexPtr->index2 = j*slices + i + 1;

                nOffset += indexStriding;                
                triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
                triIndexPtr->index0 = j*slices + i;
                triIndexPtr->index1 = (j + 1)*slices + i;
                triIndexPtr->index2 = (j + 1)*slices + i + 1;
            }
        }
    }

    return true;
}

线框索引数据的生成

bool                        YfBuildPlaneWireIndices
(
    Yuint                   slices,
    Yuint                   stacks, 
    YeIndexType             indexType,
    Yuint                   indexStriding,  
    Yuint                   indexPos,
    void*                   pWireIndicesBuffer
)
{
    if (slices < 2 || stacks < 2 || !pWireIndicesBuffer)
    {
        return false;
    }

    Yuint numVertices  = slices * stacks;
    if (indexType == YE_INDEX_16_BIT && 
        numVertices > YD_MAX_UNSIGNED_INT16)
    {
        return false;
    }

    Yuint numLines = slices * (stacks - 1) +(slices - 1) * stacks;

    char* indexPtr = (char*)pWireIndicesBuffer + indexPos;
    Yuint nOffset = 0;

    if (indexType == YE_INDEX_16_BIT)
    {
        YsLineIndex16* lineIndexPtr = NULL;

        // 行
        for (Yuint j = 0; j < stacks; j++)                 
        {
            for (Yuint i = 0; i < slices - 1; i++)         
            {
                nOffset = ((j*(slices - 1) + i)) * indexStriding;
                lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
                lineIndexPtr->index0 = j*slices + i;
                lineIndexPtr->index1 = j*slices + i + 1;
            }
        }

        // 列
        Yuint half = (slices - 1) * stacks;
        for (Yuint i = 0; i < slices; i++)                 
        {
            for (Yuint j = 0; j < stacks - 1; j++)         
            {
                nOffset = (half + (i*(stacks - 1) + j)) * indexStriding;
                lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
                lineIndexPtr->index0 = j*slices + i;
                lineIndexPtr->index1 = (j + 1)*slices + i;
            }
        }
    }
    else
    {
        YsLineIndex32* lineIndexPtr = NULL;

        // 行
        for (Yuint j = 0; j < stacks; j++)                 
        {
            for (Yuint i = 0; i < slices - 1; i++)         
            {
                nOffset = ((j*(slices - 1) + i)) * indexStriding;
                lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
                lineIndexPtr->index0 = j*slices + i;
                lineIndexPtr->index1 = j*slices + i + 1;
            }
        }

        // 列
        Yuint half = (slices - 1) * stacks;
        for (Yuint i = 0; i < slices; i++)                 
        {
            for (Yuint j = 0; j < stacks - 1; j++)         
            {
                nOffset = (half + (i*(stacks - 1) + j)) * indexStriding;
                lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
                lineIndexPtr->index0 = j*slices + i;
                lineIndexPtr->index1 = (j + 1)*slices + i;
            }
        }
    }

    return true;
}