顶点数据的生成

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

三角形索引数据的生成

  1.  bool                        YfBuildSphereTriIndices
  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 - ) * ;
  18.      if (indexType == YE_INDEX_16_BIT &&
  19.          numVertices > YD_MAX_UNSIGNED_INT16)
  20.      {
  21.          return false;
  22.      }
  23.  
  24.      // 索引赋值
  25.      char* indexPtr = (char*)pTriIndicesBuffer + indexPos;
  26.      Yuint nOffset = ;
  27.      if (indexType == YE_INDEX_16_BIT)
  28.      {
  29.          YsTriIndex16* triIndexPtr = NULL;
  30.  
  31.          for (Yuint i = ; i < stacks - ; i++)
  32.          {
  33.              if (i == )                                 // 第一层
  34.              {
  35.                  for (Yuint j = ; j < slices; j++)
  36.                  {
  37.                      nOffset = j * indexStriding;
  38.                      triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
  39.                      triIndexPtr->index0 = ;
  40.                      triIndexPtr->index1 =  + j;
  41.                      triIndexPtr->index2 =  + (j + )%slices;
  42.                  }
  43.              }
  44.              else if (i == stacks - )                   // 最后一层
  45.              {
  46.                  for (Yuint j = ; j < slices; j++)
  47.                  {
  48.                      nOffset = (numTriangles - slices + j) * indexStriding;
  49.                      triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
  50.                      triIndexPtr->index0 = numVertices - ;
  51.                      triIndexPtr->index1 = numVertices -  - slices + (j + )%slices;
  52.                      triIndexPtr->index2 = numVertices -  - slices + j;
  53.                  }
  54.              }
  55.              else
  56.              {
  57.                  for (Yuint j = ; j < slices; j++)
  58.                  {
  59.                      nOffset = ((i - )*slices *  + slices + j * ) * indexStriding;
  60.                      triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
  61.                      triIndexPtr->index0 =  + slices * (i - ) + j;
  62.                      triIndexPtr->index1 =  + slices * i + j;
  63.                      triIndexPtr->index2 =  + slices * (i - ) + (j + )%slices;
  64.  
  65.                      nOffset += indexStriding;
  66.                      triIndexPtr = (YsTriIndex16*)(indexPtr + nOffset);
  67.                      triIndexPtr->index0 =  + slices * (i - ) + (j + )%slices;
  68.                      triIndexPtr->index1 =  + slices * i + j;
  69.                      triIndexPtr->index2 =  + slices * i + (j + )%slices;
  70.                  }
  71.              }
  72.          }
  73.      }
  74.      else
  75.      {
  76.          YsTriIndex32* triIndexPtr = NULL;
  77.  
  78.          // 赋值
  79.          for (Yuint i = ; i < stacks - ; i++)
  80.          {
  81.              if (i == )                                 // 第一层
  82.              {
  83.                  for (Yuint j = ; j < slices; j++)
  84.                  {
  85.                      nOffset = j * indexStriding;
  86.                      triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
  87.                      triIndexPtr->index0 = ;
  88.                      triIndexPtr->index1 =  + j;
  89.                      triIndexPtr->index2 =  + (j + )%slices;
  90.                  }
  91.              }
  92.              else if (i == stacks - )                   // 最后一层
  93.              {
  94.                  for (Yuint j = ; j < slices; j++)
  95.                  {
  96.                      nOffset = (numTriangles - slices + j) * indexStriding;
  97.                      triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
  98.                      triIndexPtr->index0 = numVertices - ;
  99.                      triIndexPtr->index1 = numVertices -  - slices + (j + )%slices;
  100.                      triIndexPtr->index2 = numVertices -  - slices + j;
  101.                  }
  102.              }
  103.              else
  104.              {
  105.                  for (Yuint j = ; j < slices; j++)
  106.                  {
  107.                      nOffset = ((i - )*slices *  + slices + j * ) * indexStriding;
  108.                      triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
  109.                      triIndexPtr->index0 =  + slices * (i - ) + j;
  110.                      triIndexPtr->index1 =  + slices * i + j;
  111.                      triIndexPtr->index2 =  + slices * (i - ) + (j + )%slices;
  112.  
  113.                      nOffset += indexStriding;
  114.                      triIndexPtr = (YsTriIndex32*)(indexPtr + nOffset);
  115.                      triIndexPtr->index0 =  + slices * (i - ) + (j + )%slices;
  116.                      triIndexPtr->index1 =  + slices * i + j;
  117.                      triIndexPtr->index2 =  + slices * i + (j + )%slices;
  118.                  }
  119.              }
  120.          }
  121.      }
  122.  
  123.      return true;
  124.  }

线框索引数据的生成

  1.  bool                        YfBuildSphereWireIndices
  2.  (
  3.      Yuint                   slices,
  4.      Yuint                   stacks,
  5.      YeIndexType             indexType,
  6.      Yuint                   indexStriding,
  7.      Yuint                   indexPos,
  8.      void*                   pWireIndicesBuffer
  9.  )
  10.  {
  11.      if (slices <  || stacks <  || !pWireIndicesBuffer)
  12.      {
  13.          return false;
  14.      }
  15.  
  16.      Yuint numVertices = slices * (stacks - ) + ;
  17.      if (indexType == YE_INDEX_16_BIT &&
  18.          numVertices > YD_MAX_UNSIGNED_INT16)
  19.      {
  20.          return false;
  21.      }
  22.      Yuint numLines = slices * (stacks - ) + slices * (stacks - );
  23.  
  24.      char* indexPtr = (char*)pWireIndicesBuffer + indexPos;
  25.      Yuint nOffset = ;
  26.  
  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.              for (Yuint j = ; j < stacks - ; j++)
  48.              {
  49.                  nOffset = (half + (i*(stacks - ) + j)) * indexStriding;
  50.                  lineIndexPtr = (YsLineIndex16*)(indexPtr + nOffset);
  51.                  if (j == )
  52.                  {
  53.                      lineIndexPtr->index0 = ;
  54.                  }
  55.                  else
  56.                  {
  57.                      lineIndexPtr->index0 =  + (j - )*slices + i;
  58.                  }
  59.                  if (j == stacks - )
  60.                  {
  61.                      lineIndexPtr->index1 = numVertices - ;
  62.                  }
  63.                  else
  64.                  {
  65.                      lineIndexPtr->index1 =  + j*slices + i;
  66.                  }
  67.              }
  68.          }
  69.      }
  70.      else
  71.      {
  72.          YsLineIndex32* lineIndexPtr = NULL;
  73.  
  74.          // 行
  75.          for (Yuint j = ; j < stacks - ; j++)
  76.          {
  77.              for (Yuint i = ; i < slices; i++)
  78.              {
  79.                  nOffset = ((j - )*slices + i) * indexStriding;
  80.                  lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
  81.                  lineIndexPtr->index0 =  + j*slices + i;
  82.                  lineIndexPtr->index1 =  + j*slices + (i + )%slices;
  83.              }
  84.          }
  85.  
  86.          // 列
  87.          Yuint half = slices * (stacks - );
  88.          for (Yuint i = ; i < slices; i++)
  89.          {
  90.              for (Yuint j = ; j < stacks - ; j++)
  91.              {
  92.                  nOffset = (half + (i*(stacks - ) + j)) * indexStriding;
  93.                  lineIndexPtr = (YsLineIndex32*)(indexPtr + nOffset);
  94.                  if (j == )
  95.                  {
  96.                      lineIndexPtr->index0 = ;
  97.                  }
  98.                  else
  99.                  {
  100.                      lineIndexPtr->index0 =  + (j - )*slices + i;
  101.                  }
  102.                  if (j == stacks - )
  103.                  {
  104.                      lineIndexPtr->index1 = numVertices - ;
  105.                  }
  106.                  else
  107.                  {
  108.                      lineIndexPtr->index1 =  + j*slices + i;
  109.                  }
  110.              }
  111.          }
  112.      }
  113.  
  114.      return true;
  115.  }

[3] 球(Sphere)图形的生成算法的更多相关文章

  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. [13] 弧面(Arc)图形的生成算法

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

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

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

随机推荐

  1. poj1611 The Suspects（并查集）

    题目链接 http://poj.org/problem?id=1611 题意 有n个学生,编号0~n-1,m个社团,每个社团有k个学生,如果社团里有1个学生是SARS的疑似患者,则该社团所有人都要被隔 ...

  2. Bootstrap入门六：表单

    表单主要包含表单域.输入框.下拉框.单选框.多选框和按钮等控件. 1.基本实例 单独的表单控件会被自动赋予一些全局样式.所有设置了 .form-control 类的 <input>.< ...

  3. 《Android源码设计模式》--工厂方法模式

    No1: 对于一个应用程序来说,其真正的入口是在ActivityThread类中,ActivityThread中含有我们熟悉的main方法.ActivityThread是一个final类,不能被继承. ...

  4. 前端-JS-BOM和DOM

    前戏 到目前为止,我们已经学过了JavaScript的一些简单的语法.但是这些简单的语法,并没有和浏览器有任何交互. 也就是我们还不能制作一些我们经常看到的网页的一些交互,我们需要继续学习BOM和DO ...

  5. My blog in AI -- 梯度下降算法

    人工神经网络是对生物神经网络的模仿,神经网络对一个问题的学习,需要经历数据输入.网络参数的训练.超参数的调节等部分. 这次我们来详细讨论一下神经网络的学习过程. 假设我们要训练一个神经网络去识别一张图 ...

  6. MySQL服务器 IO 100%的案例分析

    [问题] 有台MySQL 5.6.21的数据库实例以写入为主,IO %util接近100% 写入IOPS很高 [分析过程] 1.通过iotop工具可以看到当前IO消耗最高的mysql线程 2.查看线程 ...

  7. 深度学习基础系列（五）| 深入理解交叉熵函数及其在tensorflow和keras中的实现

    在统计学中,损失函数是一种衡量损失和错误(这种损失与“错误地”估计有关,如费用或者设备的损失)程度的函数.假设某样本的实际输出为a,而预计的输出为y,则y与a之间存在偏差,深度学习的目的即是通过不断地 ...

  8. Python 递归删除非空目录（包括子目录以及文件）

    Python的OS模块自带rmdir和removedirs函数用于删除目录,但是两者都不能删除非空目录,以下代码定义了一个函数 remove_dir 用于删除非空目录. #作者官网 http://ww ...

  9. iOS 9应用开发教程之编辑界面与编写代码

    iOS 9应用开发教程之编辑界面与编写代码 编辑界面 在1.2.2小节中提到过编辑界面(Interface builder),编辑界面是用来设计用户界面的,单击打开Main.storyboard文件就 ...

  10. android 单位 什么是屏幕密度？

    韩梦飞沙  韩亚飞  313134555@qq.com  yue31313  han_meng_fei_sha sp dp px in in 表示英寸, 是屏幕的物理尺寸.1英寸是2.54厘米. dp ...