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

顶点数据的生成

bool                        YfBuildStairsVertices
(Yreal                   width, Yreal                   length, Yreal                   height, Yuint                   stacks, YeOriginPose            originPose,Yuint                   vertexStriding, Yuint                   vertexPos, void*                   pVerticesBuffer
)
{if (stacks < 1 || !pVerticesBuffer){return false;}Yuint numVertices  = 2 + stacks * 4;//Yuint numTriangles = stacks * 8;char* vertexPtr = (char*)pVerticesBuffer + vertexPos;YsVector3* curVertexPtr = NULL;Yuint nOffset = 0;YsVector3 vOriginOffset(-width / 2, -height / 2, -length / 2);if (originPose == YE_ORIGIN_POSE_TOP){vOriginOffset.y = -height;}else if (originPose == YE_ORIGIN_POSE_BOTTOM){vOriginOffset.y = 0.0f;}Yreal fStepLength = length / stacks;Yreal fStepHeight = height / stacks;for (Yuint i = 0; i <= stacks; i++){nOffset = i * 4 * vertexStriding; curVertexPtr = (YsVector3*)(vertexPtr + nOffset);curVertexPtr->x = vOriginOffset.x;curVertexPtr->y = i * fStepHeight + vOriginOffset.y;curVertexPtr->z = i * fStepLength + vOriginOffset.z;nOffset += vertexStriding;  curVertexPtr = (YsVector3*)(vertexPtr + nOffset);curVertexPtr->x = width + vOriginOffset.x;curVertexPtr->y = i * fStepHeight + vOriginOffset.y;curVertexPtr->z = i * fStepLength + vOriginOffset.z;if (i == stacks){continue;}nOffset += vertexStriding;  curVertexPtr = (YsVector3*)(vertexPtr + nOffset);curVertexPtr->x = vOriginOffset.x;curVertexPtr->y = (i+1) * fStepHeight + vOriginOffset.y;curVertexPtr->z = i * fStepLength + vOriginOffset.z;nOffset += vertexStriding;  curVertexPtr = (YsVector3*)(vertexPtr + nOffset);curVertexPtr->x = width + vOriginOffset.x;curVertexPtr->y = (i+1) * fStepHeight + vOriginOffset.y;curVertexPtr->z = i * fStepLength + vOriginOffset.z;}return true;
}

三角形索引数据的生成

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

转载于:https://www.cnblogs.com/WhyEngine/p/3415262.html

[17] 楼梯(Stairs)图形的生成算法相关推荐

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

    顶点数据的生成 1 bool YfBuildSpiralStairsVertices 2 ( 3 Yreal radius, 4 Yreal assistRadius, 5 Yreal height, ...

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

    顶点数据的生成 1 bool YfBuildDrumVertices 2 ( 3 Yreal radius, 4 Yreal assistRadius, 5 Yuint slices, 6 Yuint ...

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

    顶点数据的生成 1 bool YfBuildSpireVertices 2 ( 3 Yreal radius, 4 Yreal assistRadius, 5 Yreal height, 6 Yuin ...

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

    顶点数据的生成 1 bool YfBuildStarVertices 2 ( 3 Yreal radius, 4 Yreal assistRadius, 5 Yreal height, 6 Yuint ...

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

    顶点数据的生成 1 bool YfBuildArcVertices 2 ( 3 Yreal radius, 4 Yreal degree, 5 Yreal height, 6 Yuint slices ...

  6. 3D几何图形的生成算法

    在之前的博客上,发布了一个我写的3D几何图形生成的DEMO: http://www.cnblogs.com/WhyEngine/p/3415040.html DEMO下载地址: http://file ...

  7. 计算机地图制图原理与算法,计算机地图制图原理与方法-基本图形生成算法.ppt...

    <计算机地图制图原理与方法-基本图形生成算法.ppt>由会员分享,可在线阅读,更多相关<计算机地图制图原理与方法-基本图形生成算法.ppt(35页珍藏版)>请在人人文库网上搜索 ...

  8. 图形算法:圆形生成算法

    图形算法:圆形生成算法 标签(空格分隔): 算法 版本:2 作者:陈小默 声明:禁止商用,禁止转载 发布于:作业部落.CSDN博客 圆的定义为所有距离中心位置 (xc,yc) 为定值 r 的点的集合1 ...

  9. 计算机图形生成的基本单位是,第五章 基本图形生成算法

    如何在指定的输出设备上根据坐标描述构造基本二维几何图形(点.直线.圆.椭圆.多边形域.字符串及其相关属性等). 图形生成的概念 图形的生成:是在指定的输出设备上,根据坐标描述构造二维几何图形. 图形的 ...

最新文章

  1. 【npm第4期】文件系统操作的跨平台兼容
  2. [转]数据结构:图的存储结构之邻接矩阵
  3. linux 为什么有时用killall指令找不到要杀死的进程?(no process found)
  4. mysql int number_Oracle/MySQL decimal/int/number 转字符串
  5. android 三星 拍照,安卓里面拍照最好的三个品牌,OPPO华为三星怎么选
  6. THINKPHP3.2视频教程
  7. VR全景可视化制作小程序功能模块源码v1.0.28
  8. JDK安装 Java环境配置
  9. 字节跳动财务报表_【实锤】这一波疫情过后,字节跳动要上市了
  10. c语言分形程序,C语言实现分形图形
  11. 【Mathematica】 曲面的绘制
  12. matlab中符号检验,配对符号秩和检验,配对资料的符号检验,符号
  13. Intent简单介绍
  14. wireshark抓包:分析阿里小蜜网络通信方式
  15. Laravel5.5 项目开发文档,精简版,不适合新手使用。
  16. AWS知识图谱大赛之python数据处理和图数据库导入
  17. php spry文本域_SPRY验证文本域之用户名称
  18. 祖传代码如何优化性能?
  19. 查找:update $push failed with “Resulting document after update is larger than 16777216”问题引起的原因
  20. 高仿人人网客户端安卓源码

热门文章

  1. spingMVC 请求参数绑定
  2. 【Vue】—Vue组件基本介绍
  3. 零基础带你学习MySQL—修改表(六)
  4. 计算机网络—时延相关真题练习(三)
  5. 有没有四十多岁快五十的女人突然想逃离家庭?
  6. 和媳妇加一起月薪三万五想换车了不知道x5养的起吗?
  7. 人的烦恼大部分来自于没钱
  8. 静心的最好的方法是什么?
  9. 人跟人的格局真的是不一样的
  10. Rust 语言本身的问题