zoukankan html css js c++ java

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

顶点数据的生成

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

三角形索引数据的生成

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

线框索引数据的生成

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

查看全文

相关阅读:
LeetCode 81 Search in Rotated Sorted Array II（循环有序数组中的查找问题）
LeetCode 80 Remove Duplicates from Sorted Array II（移除数组中出现两次以上的元素）
LeetCode 79 Word Search（单词查找）
LeetCode 78 Subsets （所有子集）
LeetCode 77 Combinations(排列组合)
LeetCode 50 Pow(x, n) （实现幂运算）
LeetCode 49 Group Anagrams（字符串分组）
LeetCode 48 Rotate Image（2D图像旋转问题）
LeetCode 47 Permutations II（全排列）
LeetCode 46 Permutations（全排列问题）

原文地址：https://www.cnblogs.com/WhyEngine/p/3415252.html