感觉这图形怎么看怎么像搓衣板.

顶点数据的生成

  1. bool                        YfBuildStairsVertices
  2. (
  3.     Yreal                   width,
  4.     Yreal                   length,
  5.     Yreal                   height,
  6.     Yuint                   stacks,
  7.     YeOriginPose            originPose,
  8.     Yuint                   vertexStriding,
  9.     Yuint                   vertexPos,
  10.     void*                   pVerticesBuffer
  11. )
  12. {
  13.     if (stacks <  || !pVerticesBuffer)
  14.     {
  15.         return false;
  16.     }
  17.     Yuint numVertices  =  + stacks * ;
  18.     //Yuint numTriangles = stacks * 8;
  19.  
  20.     char* vertexPtr = (char*)pVerticesBuffer + vertexPos;
  21.     YsVector3* curVertexPtr = NULL;
  22.     Yuint nOffset = ;
  23.  
  24.     YsVector3 vOriginOffset(-width / , -height / , -length / );
  25.     if (originPose == YE_ORIGIN_POSE_TOP)
  26.     {
  27.         vOriginOffset.y = -height;
  28.     }
  29.     else if (originPose == YE_ORIGIN_POSE_BOTTOM)
  30.     {
  31.         vOriginOffset.y = 0.0f;
  32.     }
  33.  
  34.     Yreal fStepLength = length / stacks;
  35.     Yreal fStepHeight = height / stacks;
  36.  
  37.     for (Yuint i = ; i <= stacks; i++)
  38.     {
  39.         nOffset = i *  * vertexStriding;
  40.         curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
  41.         curVertexPtr->x = vOriginOffset.x;
  42.         curVertexPtr->y = i * fStepHeight + vOriginOffset.y;
  43.         curVertexPtr->z = i * fStepLength + vOriginOffset.z;
  44.  
  45.         nOffset += vertexStriding;
  46.         curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
  47.         curVertexPtr->x = width + vOriginOffset.x;
  48.         curVertexPtr->y = i * fStepHeight + vOriginOffset.y;
  49.         curVertexPtr->z = i * fStepLength + vOriginOffset.z;
  50.  
  51.         if (i == stacks)
  52.         {
  53.             continue;
  54.         }
  55.  
  56.         nOffset += vertexStriding;
  57.         curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
  58.         curVertexPtr->x = vOriginOffset.x;
  59.         curVertexPtr->y = (i+) * fStepHeight + vOriginOffset.y;
  60.         curVertexPtr->z = i * fStepLength + vOriginOffset.z;
  61.  
  62.         nOffset += vertexStriding;
  63.         curVertexPtr = (YsVector3*)(vertexPtr + nOffset);
  64.         curVertexPtr->x = width + vOriginOffset.x;
  65.         curVertexPtr->y = (i+) * fStepHeight + vOriginOffset.y;
  66.         curVertexPtr->z = i * fStepLength + vOriginOffset.z;
  67.     }
  68.  
  69.     return true;
  70. }

三角形索引数据的生成

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

线框索引数据的生成

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

[17] 楼梯(Stairs)图形的生成算法的更多相关文章

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

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

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

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

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

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

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

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

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

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

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

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

  7. [13] 弧面(Arc)图形的生成算法

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

  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. mysql分布式集群实现原理

    做MySQL集群,例如:利用mysql cluster ,mysql proxy,mysql replication,drdb等等 有人会问mysql集群,根分表有什么关系吗?虽然它不是实际意义上的分 ...

  2. 使用 Python 读取火狐的 cookies

    这事本来是有个 browsercookie 库可以做的,但是初看它就有不少问题: 不能指定要使用的火狐 profile(后来发现可以指定数据库文件). 找不到 sessionstore.js 文件时会 ...

  3. [ 原创 ] Java基础8--什么叫做重载

    重载是在同一个类中,有多个方法名相同,参数列表不同(参数个数不同,参数类型不同),与方法的返回值无关,与权限修饰符无关,B中的参数列表和题目的方法完全一样了.

  4. flask使用flask_sqlalchemy连接数据库(python2.7)

    1.出现编码问题 解决方法: #连接数据库时出现编码问题,需要pip install mysql-connector-python,并且数据库配置修改为 import mysql.connector ...

  5. C# 集合类-接口

    所谓,程序=数据结构+算法. 我目前的日常工作就是繁琐的业务流程和增删改查之类的. 其实繁琐的业务流程也不过是改变一下数据的状态.怪不得叫,面向数据库编程.哈哈. 所以呢,了解一下各种 .net内置的 ...

  6. Navicat Premium 激活码 序列号。破解版。

    韩梦飞沙  韩亚飞  313134555@qq.com  yue31313  han_meng_fei_sha Navicat Premium 激活码  序列号.破解版.

  7. luoguP4466 [国际集训队]和与积 莫比乌斯反演

    自然想到枚举\(gcd(a, b)\),不妨设其为\(d\),并且\(a = di, b = dj(a > b)\) 那么\(\frac{ab}{a + b} = \frac{dij}{i + ...

  8. Atcoder681 Typical DP Contest E.数 数位dp

    写什么递归....非递归多好写 令$f[i][j]$表示前$i$位的和在模$d$意义下为$j$的方案数,然后转移即可 复杂度$O(10000 * 100 * 10)$ 注意非递归建议高位摆第$n$位. ...

  9. mysql长连接

    长连接是干嘛的:  它是做连接复用的: 在openresty中的lua-resty-mysql 里 connect方法去连接mysql时会去ngx_lua cosocket连接池中寻找是否有可用连接 ...

  10. HDU 5698 瞬间移动 数学

    瞬间移动 题目连接: http://acm.hdu.edu.cn/showproblem.php?pid=5698 Description 有一个无限大的矩形,初始时你在左上角(即第一行第一列),每次 ...