[14] 齿轮(Gear Wheel)图形的生成算法

顶点数据的生成

 bool                        YfBuildGearwheelVertices
 (
     Yreal                   radius,
     Yreal                   assistRadius,
     Yreal                   height,
     Yuint                   slices,
     YeOriginPose            originPose,
     Yuint                   vertexStriding,
     Yuint                   vertexPos,
     void*                   pVerticesBuffer
 )
 {
     if (slices <  || !pVerticesBuffer)
     {
         return false;
     }

     Yuint numVertices  = slices* + ;

     // 顶点赋值
     char* vertexPtr = (char*)pVerticesBuffer + vertexPos;
     YsVector3* curVertexPtr   = NULL;
     Yuint nOffset = ;

     Yreal originOffsetY = 0.0f;
     if (originPose == YE_ORIGIN_POSE_TOP)
     {
         originOffsetY = -height;
     }
     else if (originPose == YE_ORIGIN_POSE_CENTER)
     {
         originOffsetY = -height * 0.5f;
     }

     // 柱顶顶点赋值
     {
         nOffset = ;
         curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
         curVertexPtr->x = 0.0f;
         curVertexPtr->y = height + originOffsetY;
         curVertexPtr->z = 0.0f;
     }

     // 柱底顶点赋值
     {
         nOffset = (numVertices - ) * vertexStriding;
         curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
         curVertexPtr->x = 0.0f;
         curVertexPtr->y = originOffsetY;
         curVertexPtr->z = 0.0f;
     }

     Yreal angleXZ;
     Yreal posX, posZ;
     Yreal fRadius;
     for (Yuint i = ; i < *slices; i++)
     {
         angleXZ = YD_REAL_TWAIN_PI * i / (slices*);
         posX = yf_sin(angleXZ);
         posZ = yf_cos(angleXZ);
         fRadius = (i% == ) ? radius : assistRadius;

         // 上顶点
         {
             nOffset = ( + i) * vertexStriding;
             curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
             curVertexPtr->x = fRadius * posX;
             curVertexPtr->y = height + originOffsetY;
             curVertexPtr->z = fRadius * posZ;
         }

         // 下顶点
         {
             nOffset = ( + *slices + i) * vertexStriding;
             curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
             curVertexPtr->x = fRadius * posX;
             curVertexPtr->y = originOffsetY;
             curVertexPtr->z = fRadius * posZ;
         }
     }

     return true;
 } 

三角形索引数据的生成

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

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

     // 索引赋值
     char* indexPtr = (char*)pTriIndicesBuffer + indexPos;
     Yuint nOffset = ;
     if (indexType == YE_INDEX_16_BIT)
     {
         YsTriIndex16* triIndexPtr = NULL;
         for (Yuint i = ; i <  * slices; i++)
         {
             nOffset = (i * ) * indexStriding;
             triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
             triIndexPtr->index0 = ;
             triIndexPtr->index1 =  + i;
             triIndexPtr->index2 =  + (i + ) % (*slices);

             nOffset += indexStriding;
             triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
             triIndexPtr->index0 = numVertices - ;
             triIndexPtr->index1 =  + slices* + (i + ) % (*slices);
             triIndexPtr->index2 =  + slices* + i;

             nOffset += indexStriding;
             triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
             triIndexPtr->index0 =  + i;
             triIndexPtr->index1 =  + slices* + i;
             triIndexPtr->index2 =  + (i + ) % (*slices);

             nOffset += indexStriding;
             triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
             triIndexPtr->index0 =  + (i + ) % (*slices);
             triIndexPtr->index1 =  + slices* + i;
             triIndexPtr->index2 =  + slices* + (i + ) % (*slices);
         }
     }
     else
     {
         YsTriIndex32* triIndexPtr = NULL;
         for (Yuint i = ; i <  * slices; i++)
         {
             nOffset = (i * ) * indexStriding;
             triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
             triIndexPtr->index0 = ;
             triIndexPtr->index1 =  + i;
             triIndexPtr->index2 =  + (i + ) % (*slices);

             nOffset += indexStriding;
             triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
             triIndexPtr->index0 = numVertices - ;
             triIndexPtr->index1 =  + slices* + (i + ) % (*slices);
             triIndexPtr->index2 =  + slices* + i;

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

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

     return true;
 }

线框索引数据的生成

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

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

     // 索引赋值
     char* indexPtr = (char*)pWireIndicesBuffer + indexPos;
     Yuint nOffset = ;
     if (indexType == YE_INDEX_16_BIT)
     {
         YsLineIndex16* lineIndexPtr = NULL;
         for (Yuint i = ; i <  * slices; i++)
         {
             nOffset = (i * ) * indexStriding;
             lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
             lineIndexPtr->index0 =  + i;
             lineIndexPtr->index1 =  + (i + )%(slices*);

             nOffset += indexStriding;
             lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
             lineIndexPtr->index0 =  + slices* + i;
             lineIndexPtr->index1 =  + slices* + (i + )%(slices*);

             nOffset += indexStriding;
             lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
             lineIndexPtr->index0 =  + i;
             lineIndexPtr->index1 =  + slices* + i;
         }

         Yuint half =  * slices * indexStriding;
         for (Yuint i = ; i < slices; i++)
         {
             nOffset = half + (i * ) * indexStriding;
             lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
             lineIndexPtr->index0 = ;
             lineIndexPtr->index1 =  + i* + ;

             nOffset += indexStriding;
             lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
             lineIndexPtr->index0 = numVertices - ;
             lineIndexPtr->index1 =  + slices* + i* + ;
         }
     }
     else
     {
         YsLineIndex32* lineIndexPtr = NULL;
         for (Yuint i = ; i <  * slices; i++)
         {
             nOffset = (i * ) * indexStriding;
             lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
             lineIndexPtr->index0 =  + i;
             lineIndexPtr->index1 =  + (i + )%(slices*);

             nOffset += indexStriding;
             lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
             lineIndexPtr->index0 =  + slices* + i;
             lineIndexPtr->index1 =  + slices* + (i + )%(slices*);

             nOffset += indexStriding;
             lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
             lineIndexPtr->index0 =  + i;
             lineIndexPtr->index1 =  + slices* + i;
         }

         Yuint half =  * slices * indexStriding;
         for (Yuint i = ; i < slices; i++)
         {
             nOffset = half + (i * ) * indexStriding;
             lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
             lineIndexPtr->index0 = ;
             lineIndexPtr->index1 =  + i* + ;

             nOffset += indexStriding;
             lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
             lineIndexPtr->index0 = numVertices - ;
             lineIndexPtr->index1 =  + slices* + i* + ;
         }
     }

     return true;
 }