[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 }

posted on 2013-11-09 08:45 叶飞影阅读(920) 评论(0) 编辑收藏举报