顶点数据的生成

  1.  bool                        YfBuildArcVertices
  2.  (
  3.      Yreal                   radius,
  4.      Yreal                   degree,
  5.      Yreal                   height,
  6.      Yuint                   slices,
  7.      Yuint                   stacks,
  8.      YeOriginPose            originPose,
  9.      Yuint                   vertexStriding,
  10.      Yuint                   vertexPos,
  11.      void*                   pVerticesBuffer
  12.  )
  13.  {
  14.      if (degree <  || degree >  || !pVerticesBuffer)
  15.      {
  16.          return false;
  17.      }
  18.      if (slices <  || stacks <  || !pVerticesBuffer)
  19.      {
  20.          return false;
  21.      }
  22.  
  23.      Yuint numVertices  = slices * (stacks - ) + ;
  24.  
  25.      char* vertexPtr = (char*)pVerticesBuffer + vertexPos;
  26.      YsVector3* curVertexPtr = NULL;
  27.      Yuint nOffset = ;
  28.  
  29.      Yreal originOffsetY = 0.0f;
  30.      if (originPose == YE_ORIGIN_POSE_TOP)
  31.      {
  32.          originOffsetY = -radius;
  33.      }
  34.      else if (originPose == YE_ORIGIN_POSE_BOTTOM)
  35.      {
  36.          originOffsetY = radius;
  37.      }
  38.  
  39.      Yreal* pSinList = YD_NEW_ARRAY(Yreal, slices);
  40.      Yreal* pCosList = YD_NEW_ARRAY(Yreal, slices);
  41.      Yreal angleXZ;
  42.      for (Yuint j = ; j < slices; j++)
  43.      {
  44.          angleXZ = YD_REAL_TWAIN_PI * j / slices;
  45.          pSinList[j] = yf_sin(angleXZ);
  46.          pCosList[j] = yf_cos(angleXZ);
  47.      }
  48.  
  49.      // 赋值
  50.      {
  51.          Yreal radian = YD_DEGREE_TO_RADIAN(degree);
  52.          for (Yuint i = ; i < stacks; i++)
  53.          {
  54.              if (i == )                         // 第一个顶点
  55.              {
  56.                  nOffset = ;
  57.                  curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
  58.                  curVertexPtr->x = 0.0f;
  59.                  curVertexPtr->y = radius + originOffsetY;
  60.                  curVertexPtr->z = 0.0f;
  61.                  continue;
  62.              }
  63.  
  64.              Yreal angleY = radian * i / (stacks - );
  65.              Yreal posY = radius * yf_cos(angleY);
  66.              Yreal radiusXZ = radius * yf_sin(angleY);
  67.              Yreal posX, posZ;
  68.  
  69.              for (Yuint j = ; j < slices; j++)
  70.              {
  71.                  posX = radiusXZ * pSinList[j % slices];
  72.                  posZ = radiusXZ * pCosList[j % slices];
  73.  
  74.                  nOffset = ( + (i - ) * slices + j) * vertexStriding;
  75.                  curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
  76.                  curVertexPtr->x = posX;
  77.                  curVertexPtr->y = posY + originOffsetY;
  78.                  curVertexPtr->z = posZ;
  79.              }
  80.          }
  81.      }
  82.  
  83.      YD_SAFE_DELETE_ARRAY(pSinList);
  84.      YD_SAFE_DELETE_ARRAY(pCosList);
  85.  
  86.      return true;
  87.  }

三角形索引数据的生成

  1.  bool                        YfBuildArcTriIndices
  2.  (
  3.      Yuint                   slices,
  4.      Yuint                   stacks,
  5.      YeIndexType             indexType,
  6.      Yuint                   indexStriding,
  7.      Yuint                   indexPos,
  8.      void*                   pTriIndicesBuffer
  9.  )
  10.  {
  11.      if (slices <  || stacks <  || !pTriIndicesBuffer)
  12.      {
  13.          return false;
  14.      }
  15.  
  16.      Yuint numVertices  = slices * (stacks - ) + ;
  17.      Yuint numTriangles = slices * (stacks - ) *  + slices;
  18.  
  19.      if (indexType == YE_INDEX_16_BIT &&
  20.          numVertices > YD_MAX_UNSIGNED_INT16)
  21.      {
  22.          return false;
  23.      }
  24.  
  25.      // 索引赋值
  26.      char* indexPtr = (char*)pTriIndicesBuffer + indexPos;
  27.      Yuint nOffset = ;
  28.      if (indexType == YE_INDEX_16_BIT)
  29.      {
  30.          YsTriIndex16* triIndexPtr = NULL;
  31.  
  32.          // 赋值
  33.          for (Yuint i = ; i < stacks - ; i++)
  34.          {
  35.              if (i == )                                 // 第一层
  36.              {
  37.                  for (Yuint j = ; j < slices; j++)
  38.                  {
  39.                      nOffset = j * indexStriding;
  40.                      triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
  41.                      triIndexPtr->index0 = ;
  42.                      triIndexPtr->index1 =  + j;
  43.                      triIndexPtr->index2 =  + (j + )%slices;
  44.                  }
  45.              }
  46.              else
  47.              {
  48.                  for (Yuint j = ; j < slices; j++)
  49.                  {
  50.                      nOffset = ((i - )*slices *  + slices + j * ) * indexStriding;
  51.                      triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
  52.                      triIndexPtr->index0 =  + slices * (i - ) + j;
  53.                      triIndexPtr->index1 =  + slices * i + j;
  54.                      triIndexPtr->index2 =  + slices * (i - ) + (j + )%slices;
  55.  
  56.                      nOffset += indexStriding;
  57.                      triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
  58.                      triIndexPtr->index0 =  + slices * (i - ) + (j + )%slices;
  59.                      triIndexPtr->index1 =  + slices * i + j;
  60.                      triIndexPtr->index2 =  + slices * i + (j + )%slices;
  61.                  }
  62.              }
  63.          }
  64.      }
  65.      else
  66.      {
  67.          YsTriIndex32* triIndexPtr = NULL;
  68.  
  69.          // 赋值
  70.          for (Yuint i = ; i < stacks - ; i++)
  71.          {
  72.              if (i == )                                 // 第一层
  73.              {
  74.                  for (Yuint j = ; j < slices; j++)
  75.                  {
  76.                      nOffset = j * indexStriding;
  77.                      triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
  78.                      triIndexPtr->index0 = ;
  79.                      triIndexPtr->index1 =  + j;
  80.                      triIndexPtr->index2 =  + (j + )%slices;
  81.                  }
  82.              }
  83.              else
  84.              {
  85.                  for (Yuint j = ; j < slices; j++)
  86.                  {
  87.                      nOffset = ((i - )*slices *  + slices + j * ) * indexStriding;
  88.                      triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
  89.                      triIndexPtr->index0 =  + slices * (i - ) + j;
  90.                      triIndexPtr->index1 =  + slices * i + j;
  91.                      triIndexPtr->index2 =  + slices * (i - ) + (j + )%slices;
  92.  
  93.                      nOffset += indexStriding;
  94.                      triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
  95.                      triIndexPtr->index0 =  + slices * (i - ) + (j + )%slices;
  96.                      triIndexPtr->index1 =  + slices * i + j;
  97.                      triIndexPtr->index2 =  + slices * i + (j + )%slices;
  98.                  }
  99.              }
  100.          }
  101.      }
  102.  
  103.      return true;
  104.  }

线框索引数据的生成

  1. bool                        YfBuildArcWireIndices
  2. (
  3.     Yuint                   slices,
  4.     Yuint                   stacks,
  5.     YeIndexType             indexType,
  6.     Yuint                   indexStriding,
  7.     Yuint                   indexPos,
  8.     void*                   pWireIndicesBuffer
  9. )
  10. {
  11.     if (slices <  || !pWireIndicesBuffer)
  12.     {
  13.         return false;
  14.     }
  15.  
  16.     Yuint numVertices = slices * (stacks - ) + ;
  17.     Yuint numLines    = slices * (stacks - ) + slices * (stacks - );
  18.     if (indexType == YE_INDEX_16_BIT &&
  19.         numVertices > YD_MAX_UNSIGNED_INT16)
  20.    {
  21.         return false;
  22.     }
  23.  
  24.     // 索引赋值
  25.     char* indexPtr = (char*)pWireIndicesBuffer + indexPos;
  26.     Yuint nOffset = ;
  27.     if (indexType == YE_INDEX_16_BIT)
  28.     {
  29.         YsLineIndex16* lineIndexPtr = NULL;
  30.  
  31.         // 行
  32.         for (Yuint j = ; j < stacks; j++)
  33.         {
  34.             for (Yuint i = ; i < slices; i++)
  35.             {
  36.                 nOffset = ((j - )*slices + i) * indexStriding;
  37.                 lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
  38.                 lineIndexPtr->index0 =  + (j - )*slices + i;
  39.                 lineIndexPtr->index1 =  + (j - )*slices + (i + )%slices;
  40.             }
  41.         }
  42.  
  43.         // 列
  44.         Yuint half = slices * (stacks - );
  45.         for (Yuint i = ; i < slices; i++)
  46.         {
  47.             nOffset = (half + i) * indexStriding;
  48.             lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
  49.             lineIndexPtr->index0 = ;
  50.             lineIndexPtr->index1 =  + i;
  51.         }
  52.         half += slices;
  53.  
  54.         for (Yuint j = ; j < stacks - ; j++)
  55.         {
  56.             for (Yuint i = ; i < slices; i++)
  57.             {
  58.                 nOffset = (half + (j - )*slices + i) * indexStriding;
  59.                 lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
  60.                 lineIndexPtr->index0 =  + (j - )*slices + i;
  61.                 lineIndexPtr->index1 =  + j*slices + i;
  62.             }
  63.         }
  64.  
  65.         //// 列
  66.         //Yuint half = slices * (stacks - 1);
  67.         //for (Yuint i = 0; i < slices; i++)
  68.         //{
  69.         //    for (Yuint j = 0; j < stacks - 2; j++)
  70.         //    {
  71.         //        nOffset = (half + (i*(stacks - 1) + j)) * indexStriding;
  72.         //        lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
  73.         //        if (j == 0)
  74.         //        {
  75.         //            lineIndexPtr->index0 = 0;
  76.         //        }
  77.         //        else
  78.         //        {
  79.         //            lineIndexPtr->index0 = 1 + (j - 1)*slices + i;
  80.         //        }
  81.  
  82.         //        lineIndexPtr->index1 = 1 + j*slices + i;
  83.         //    }
  84.         //}
  85.     }
  86.     else
  87.     {
  88.         YsLineIndex32* lineIndexPtr = NULL;
  89.  
  90.         // 行
  91.         for (Yuint j = ; j < stacks; j++)
  92.        {
  93.             for (Yuint i = ; i < slices; i++)
  94.             {
  95.                 nOffset = ((j - )*slices + i) * indexStriding;
  96.                 lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
  97.                 lineIndexPtr->index0 =  + (j - )*slices + i;
  98.                 lineIndexPtr->index1 =  + (j - )*slices + (i + )%slices;
  99.             }
  100.         }
  101.  
  102.         // 列
  103.         Yuint half = slices * (stacks - );
  104.         for (Yuint i = ; i < slices; i++)
  105.         {
  106.             nOffset = (half + i) * indexStriding;
  107.             lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
  108.             lineIndexPtr->index0 = ;
  109.             lineIndexPtr->index1 =  + i;
  110.         }
  111.         half += slices;
  112.  
  113.         for (Yuint j = ; j < stacks - ; j++)
  114.         {
  115.             for (Yuint i = ; i < slices; i++)
  116.             {
  117.                 nOffset = (half + (j - )*slices + i) * indexStriding;
  118.                 lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
  119.                 lineIndexPtr->index0 =  + (j - )*slices + i;
  120.                 lineIndexPtr->index1 =  + j*slices + i;
  121.             }
  122.         }
  123.  
  124.         // 列
  125.         //Yuint half = slices * (stacks - 1);
  126.         //for (Yuint i = 0; i < slices; i++)
  127.         //{
  128.         //    for (Yuint j = 0; j < stacks - 2; j++)
  129.         //    {
  130.         //        nOffset = (half + (i*(stacks - 1) + j)) * indexStriding;
  131.         //        lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
  132.         //        if (j == 0)
  133.         //        {
  134.         //            lineIndexPtr->index0 = 0;
  135.         //        }
  136.         //        else
  137.         //        {
  138.         //            lineIndexPtr->index0 = 1 + (j - 1)*slices + i;
  139.         //        }
  140.  
  141.         //        lineIndexPtr->index1 = 1 + j*slices + i;
  142.         //    }
  143.         //}
  144.     }
  145.  
  146.     return true;
  147. }

[13] 弧面(Arc)图形的生成算法的更多相关文章

  1. [20] 鼓状物(Drum)图形的生成算法

    顶点数据的生成 bool YfBuildDrumVertices ( Yreal radius, Yreal assistRadius, Yuint slices, Yuint stacks, YeO ...

  2. [17] 楼梯(Stairs)图形的生成算法

    感觉这图形怎么看怎么像搓衣板. 顶点数据的生成 bool YfBuildStairsVertices ( Yreal width, Yreal length, Yreal height, Yuint ...

  3. [19] 半球形(Hemisphere)图形的生成算法

    顶点数据的生成 bool YfBuildHemisphereVertices ( Yreal radius, Yuint slices, Yuint stacks, YeOriginPose orig ...

  4. [18] 螺旋楼梯(Spiral Stairs)图形的生成算法

    顶点数据的生成 bool YfBuildSpiralStairsVertices ( Yreal radius, Yreal assistRadius, Yreal height, Yuint sli ...

  5. [16] 螺旋面(Spire)图形的生成算法

    顶点数据的生成 bool YfBuildSpireVertices ( Yreal radius, Yreal assistRadius, Yreal height, Yuint slices, Yu ...

  6. [15] 星星(Star)图形的生成算法

    顶点数据的生成 bool YfBuildStarVertices ( Yreal radius, Yreal assistRadius, Yreal height, Yuint slices, YeO ...

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

    顶点数据的生成 bool YfBuildGearwheelVertices ( Yreal radius, Yreal assistRadius, Yreal height, Yuint slices ...

  8. [12] 扇形体(Fan)图形的生成算法

    顶点数据的生成 bool YfBuildFunVertices ( Yreal radius, Yreal degree, Yreal height, Yuint slices, YeOriginPo ...

  9. [11] 楔形体(Wedge)图形的生成算法

    顶点数据的生成 bool YfBuildWedgeVertices ( Yreal width, Yreal length, Yreal height, YeOriginPose originPose ...

随机推荐

  1. Python之路【第十篇】: python基础之socket编程

    阅读目录 一 客户端/服务器架构 二 osi七层 三 socket层 四 socket是什么 五 套接字发展史及分类 六 套接字工作流程 七 基于TCP的套接字 八 基于UDP的套接字 九 recv与 ...

  2. 深入理解Git - Git底层对象

    前篇: 深入理解Git - 一切皆commit 如何从稍微底层一点的角度,从底层实现理解一切皆commit ? 配合希沃白板课件食用,效果更佳: [希沃白板5]课件分享 : <Git 进阶 - ...

  3. CSUOJ 1021 组合数末尾的零 二进制

    Description 从m个不同元素中取出n (n ≤ m)个元素的所有组合的个数,叫做从m个不同元素中取出n个元素的组合数.组合数的计算公式如下: C(m, n) = m!/((m - n)!n! ...

  4. [ 原创 ] Java基础9--final throw throws finally的区别

    final修饰的类不可被继承,final修饰的方法可以被继承但不能被重写(覆盖) final用于可以声明属性和方法,分别表示属性的不可变及方法的不可覆盖.不是方法的不可继承 throw是用来明确地抛出 ...

  5. [ 原创 ]linux centos下配置java环境教程

    一.环境 centos 7.2 二.目标 在CentOS7.2上安装jdk1.8(tar.gz安装包),并配置环境变量 jdk安装在/home/soft/jdk1.8.0-131目录下 具体步骤 1. ...

  6. Linux驱动之PCI

    <背景> PCI设备有许多地址配置的寄存器,初始化时这寄存器来配置设备的总线地址,配置好后CPU就可以访问该设备的各项资源了.(提炼:配置总线地址)   <配置寄存器>   ( ...

  7. php 安全模式限制函数

    表 42-2. 安全模式限制函数 函数名 限制 dbmopen() 检查被操作的文件或目录是否与正在执行的脚本有相同的 UID(所有者). dbase_open() 检查被操作的文件或目录是否与正在执 ...

  8. Gunicorn配置部分的翻译

    写在前面,虽然翻译得很烂,但也是我的劳动成果,转载请注明出处,谢谢. Gunicorn版本号19.7.1 Gunicorn配置 概述 三种配置方式 优先级如下,越后的优先级越大 1.框架的设置(现在只 ...

  9. 安装gitlab管理自己的代码

    安装gitlab的资料网上搜索很多,但发现很多都是比较老的资料了.我把我安装的过程记录一下,应该是最简单的过程了 1. 到 https://about.gitlab.com/downloads/ 下载 ...

  10. C#高级编程9-第4章 继承

    继承是面向对象的一大特征.要深刻学习继承,需要学会使用调试的技巧来学习它,因为它比较抽象. 继承 继承是指一个具体的类型直接使用另一类型的某些数据成员或函数成员,继承的类是基类(父类),被继承的类是派 ...