PolyVox  0.2.1
Open source voxel management library
SurfaceMesh.inl
Go to the documentation of this file.
1 /*******************************************************************************
2 Copyright (c) 2005-2009 David Williams
3 
4 This software is provided 'as-is', without any express or implied
5 warranty. In no event will the authors be held liable for any damages
6 arising from the use of this software.
7 
8 Permission is granted to anyone to use this software for any purpose,
9 including commercial applications, and to alter it and redistribute it
10 freely, subject to the following restrictions:
11 
12  1. The origin of this software must not be misrepresented; you must not
13  claim that you wrote the original software. If you use this software
14  in a product, an acknowledgment in the product documentation would be
15  appreciated but is not required.
16 
17  2. Altered source versions must be plainly marked as such, and must not be
18  misrepresented as being the original software.
19 
20  3. This notice may not be removed or altered from any source
21  distribution.
22 *******************************************************************************/
23 
24 namespace PolyVox
25 {
26  template <typename VertexType>
27  SurfaceMesh<VertexType>::SurfaceMesh()
28  {
29  m_iTimeStamp = -1;
30  }
31 
32  template <typename VertexType>
33  SurfaceMesh<VertexType>::~SurfaceMesh()
34  {
35  }
36 
37  template <typename VertexType>
38  const std::vector<uint32_t>& SurfaceMesh<VertexType>::getIndices(void) const
39  {
40  return m_vecTriangleIndices;
41  }
42 
43  template <typename VertexType>
44  uint32_t SurfaceMesh<VertexType>::getNoOfIndices(void) const
45  {
46  return m_vecTriangleIndices.size();
47  }
48 
49  template <typename VertexType>
50  uint32_t SurfaceMesh<VertexType>::getNoOfNonUniformTrianges(void) const
51  {
52  uint32_t result = 0;
53  for(uint32_t i = 0; i < m_vecTriangleIndices.size() - 2; i += 3)
54  {
55  if((m_vecVertices[m_vecTriangleIndices[i]].getMaterial() == m_vecVertices[m_vecTriangleIndices[i+1]].getMaterial())
56  && (m_vecVertices[m_vecTriangleIndices[i]].getMaterial() == m_vecVertices[m_vecTriangleIndices[i+2]].getMaterial()))
57  {
58  }
59  else
60  {
61  result++;
62  }
63  }
64  return result;
65  }
66 
67  template <typename VertexType>
68  uint32_t SurfaceMesh<VertexType>::getNoOfUniformTrianges(void) const
69  {
70  uint32_t result = 0;
71  for(uint32_t i = 0; i < m_vecTriangleIndices.size() - 2; i += 3)
72  {
73  if((m_vecVertices[m_vecTriangleIndices[i]].getMaterial() == m_vecVertices[m_vecTriangleIndices[i+1]].getMaterial())
74  && (m_vecVertices[m_vecTriangleIndices[i]].getMaterial() == m_vecVertices[m_vecTriangleIndices[i+2]].getMaterial()))
75  {
76  result++;
77  }
78  }
79  return result;
80  }
81 
82  template <typename VertexType>
83  uint32_t SurfaceMesh<VertexType>::getNoOfVertices(void) const
84  {
85  return m_vecVertices.size();
86  }
87 
88  template <typename VertexType>
89  std::vector<VertexType>& SurfaceMesh<VertexType>::getRawVertexData(void)
90  {
91  return m_vecVertices;
92  }
93 
94  template <typename VertexType>
95  const std::vector<VertexType>& SurfaceMesh<VertexType>::getVertices(void) const
96  {
97  return m_vecVertices;
98  }
99 
100  template <typename VertexType>
101  void SurfaceMesh<VertexType>::addTriangle(uint32_t index0, uint32_t index1, uint32_t index2)
102  {
103  //Make sure the specified indices correspond to valid vertices.
104  assert(index0 < m_vecVertices.size());
105  assert(index1 < m_vecVertices.size());
106  assert(index2 < m_vecVertices.size());
107 
108  m_vecTriangleIndices.push_back(index0);
109  m_vecTriangleIndices.push_back(index1);
110  m_vecTriangleIndices.push_back(index2);
111  }
112 
113  template <typename VertexType>
114  void SurfaceMesh<VertexType>::addTriangleCubic(uint32_t index0, uint32_t index1, uint32_t index2)
115  {
116  //Make sure the specified indices correspond to valid vertices.
117  assert(index0 < m_vecVertices.size());
118  assert(index1 < m_vecVertices.size());
119  assert(index2 < m_vecVertices.size());
120 
121  m_vecTriangleIndices.push_back(index0);
122  m_vecTriangleIndices.push_back(index1);
123  m_vecTriangleIndices.push_back(index2);
124  }
125 
126  template <typename VertexType>
127  uint32_t SurfaceMesh<VertexType>::addVertex(const VertexType& vertex)
128  {
129  m_vecVertices.push_back(vertex);
130  return m_vecVertices.size() - 1;
131  }
132 
133  template <typename VertexType>
134  void SurfaceMesh<VertexType>::clear(void)
135  {
136  m_vecVertices.clear();
137  m_vecTriangleIndices.clear();
138  m_vecLodRecords.clear();
139  }
140 
141  template <typename VertexType>
142  bool SurfaceMesh<VertexType>::isEmpty(void) const
143  {
144  return (getNoOfVertices() == 0) || (getNoOfIndices() == 0);
145  }
146 
155  /*template <typename VertexType>
156  void SurfaceMesh<VertexType>::sumNearbyNormals(bool bNormaliseResult)
157  {
158  if(m_vecVertices.size() == 0) //FIXME - I don't think we should need this test, but I have seen crashes otherwise...
159  {
160  return;
161  }
162 
163  std::vector<Vector3DFloat> summedNormals(m_vecVertices.size());
164 
165  //Initialise all normals to zero. Should be ok as the vector should store all elements contiguously.
166  memset(&summedNormals[0], 0, summedNormals.size() * sizeof(Vector3DFloat));
167 
168  for(vector<uint32_t>::iterator iterIndex = m_vecTriangleIndices.begin(); iterIndex != m_vecTriangleIndices.end();)
169  {
170  PositionMaterialNormal& v0 = m_vecVertices[*iterIndex];
171  Vector3DFloat& v0New = summedNormals[*iterIndex];
172  iterIndex++;
173  PositionMaterialNormal& v1 = m_vecVertices[*iterIndex];
174  Vector3DFloat& v1New = summedNormals[*iterIndex];
175  iterIndex++;
176  PositionMaterialNormal& v2 = m_vecVertices[*iterIndex];
177  Vector3DFloat& v2New = summedNormals[*iterIndex];
178  iterIndex++;
179 
180  Vector3DFloat sumOfNormals = v0.getNormal() + v1.getNormal() + v2.getNormal();
181 
182  v0New += sumOfNormals;
183  v1New += sumOfNormals;
184  v2New += sumOfNormals;
185  }
186 
187  for(uint32_t uIndex = 0; uIndex < summedNormals.size(); uIndex++)
188  {
189  if(bNormaliseResult)
190  {
191  summedNormals[uIndex].normalise();
192  }
193  m_vecVertices[uIndex].setNormal(summedNormals[uIndex]);
194  }
195  }*/
196 
197  /*template <typename VertexType>
198  void SurfaceMesh<VertexType>::generateAveragedFaceNormals(bool bNormalise, bool bIncludeEdgeVertices)
199  {
200  Vector3DFloat offset = static_cast<Vector3DFloat>(m_Region.getLowerCorner());
201 
202  //Initially zero the normals
203  for(vector<PositionMaterialNormal>::iterator iterVertex = m_vecVertices.begin(); iterVertex != m_vecVertices.end(); iterVertex++)
204  {
205  if(m_Region.containsPoint(iterVertex->getPosition() + offset, 0.001))
206  {
207  iterVertex->setNormal(Vector3DFloat(0.0f,0.0f,0.0f));
208  }
209  }
210 
211  for(vector<uint32_t>::iterator iterIndex = m_vecTriangleIndices.begin(); iterIndex != m_vecTriangleIndices.end();)
212  {
213  PositionMaterialNormal& v0 = m_vecVertices[*iterIndex];
214  iterIndex++;
215  PositionMaterialNormal& v1 = m_vecVertices[*iterIndex];
216  iterIndex++;
217  PositionMaterialNormal& v2 = m_vecVertices[*iterIndex];
218  iterIndex++;
219 
220  Vector3DFloat triangleNormal = (v1.getPosition()-v0.getPosition()).cross(v2.getPosition()-v0.getPosition());
221 
222  if(m_Region.containsPoint(v0.getPosition() + offset, 0.001))
223  {
224  v0.setNormal(v0.getNormal() + triangleNormal);
225  }
226  if(m_Region.containsPoint(v1.getPosition() + offset, 0.001))
227  {
228  v1.setNormal(v1.getNormal() + triangleNormal);
229  }
230  if(m_Region.containsPoint(v2.getPosition() + offset, 0.001))
231  {
232  v2.setNormal(v2.getNormal() + triangleNormal);
233  }
234  }
235 
236  if(bNormalise)
237  {
238  for(vector<PositionMaterialNormal>::iterator iterVertex = m_vecVertices.begin(); iterVertex != m_vecVertices.end(); iterVertex++)
239  {
240  Vector3DFloat normal = iterVertex->getNormal();
241  normal.normalise();
242  iterVertex->setNormal(normal);
243  }
244  }
245  }*/
246 
247  /*template <typename VertexType>
248  polyvox_shared_ptr< SurfaceMesh<VertexType> > SurfaceMesh<VertexType>::extractSubset(std::set<uint8_t> setMaterials)
249  {
250  polyvox_shared_ptr< SurfaceMesh<VertexType> > result(new SurfaceMesh<VertexType>);
251 
252  if(m_vecVertices.size() == 0) //FIXME - I don't think we should need this test, but I have seen crashes otherwise...
253  {
254  return result;
255  }
256 
257  assert(m_vecLodRecords.size() == 1);
258  if(m_vecLodRecords.size() != 1)
259  {
260  //If we have done progressive LOD then it's too late to split into subsets.
261  return result;
262  }
263 
264  std::vector<int32_t> indexMap(m_vecVertices.size());
265  std::fill(indexMap.begin(), indexMap.end(), -1);
266 
267  for(uint32_t triCt = 0; triCt < m_vecTriangleIndices.size(); triCt += 3)
268  {
269 
270  PositionMaterialNormal& v0 = m_vecVertices[m_vecTriangleIndices[triCt]];
271  PositionMaterialNormal& v1 = m_vecVertices[m_vecTriangleIndices[triCt + 1]];
272  PositionMaterialNormal& v2 = m_vecVertices[m_vecTriangleIndices[triCt + 2]];
273 
274  if(
275  (setMaterials.find(v0.getMaterial()) != setMaterials.end()) ||
276  (setMaterials.find(v1.getMaterial()) != setMaterials.end()) ||
277  (setMaterials.find(v2.getMaterial()) != setMaterials.end()))
278  {
279  uint32_t i0;
280  if(indexMap[m_vecTriangleIndices[triCt]] == -1)
281  {
282  indexMap[m_vecTriangleIndices[triCt]] = result->addVertex(v0);
283  }
284  i0 = indexMap[m_vecTriangleIndices[triCt]];
285 
286  uint32_t i1;
287  if(indexMap[m_vecTriangleIndices[triCt+1]] == -1)
288  {
289  indexMap[m_vecTriangleIndices[triCt+1]] = result->addVertex(v1);
290  }
291  i1 = indexMap[m_vecTriangleIndices[triCt+1]];
292 
293  uint32_t i2;
294  if(indexMap[m_vecTriangleIndices[triCt+2]] == -1)
295  {
296  indexMap[m_vecTriangleIndices[triCt+2]] = result->addVertex(v2);
297  }
298  i2 = indexMap[m_vecTriangleIndices[triCt+2]];
299 
300  result->addTriangle(i0,i1,i2);
301  }
302  }
303 
304  result->m_vecLodRecords.clear();
305  LodRecord lodRecord;
306  lodRecord.beginIndex = 0;
307  lodRecord.endIndex = result->getNoOfIndices();
308  result->m_vecLodRecords.push_back(lodRecord);
309 
310  return result;
311  }*/
312 
313  template <typename VertexType>
314  int SurfaceMesh<VertexType>::noOfDegenerateTris(void)
315  {
316  int count = 0;
317  for(uint32_t triCt = 0; triCt < m_vecTriangleIndices.size();)
318  {
319  int v0 = m_vecTriangleIndices[triCt];
320  triCt++;
321  int v1 = m_vecTriangleIndices[triCt];
322  triCt++;
323  int v2 = m_vecTriangleIndices[triCt];
324  triCt++;
325 
326  if((v0 == v1) || (v1 == v2) || (v2 == v0))
327  {
328  count++;
329  }
330  }
331  return count;
332  }
333 
334  template <typename VertexType>
335  void SurfaceMesh<VertexType>::removeDegenerateTris(void)
336  {
337  int noOfNonDegenerate = 0;
338  int targetCt = 0;
339  for(uint32_t triCt = 0; triCt < m_vecTriangleIndices.size();)
340  {
341  int v0 = m_vecTriangleIndices[triCt];
342  triCt++;
343  int v1 = m_vecTriangleIndices[triCt];
344  triCt++;
345  int v2 = m_vecTriangleIndices[triCt];
346  triCt++;
347 
348  if((v0 != v1) && (v1 != v2) & (v2 != v0))
349  {
350  m_vecTriangleIndices[targetCt] = v0;
351  targetCt++;
352  m_vecTriangleIndices[targetCt] = v1;
353  targetCt++;
354  m_vecTriangleIndices[targetCt] = v2;
355  targetCt++;
356 
357  noOfNonDegenerate++;
358  }
359  }
360 
361  m_vecTriangleIndices.resize(noOfNonDegenerate * 3);
362  }
363 
364  template <typename VertexType>
365  void SurfaceMesh<VertexType>::removeUnusedVertices(void)
366  {
367  std::vector<bool> isVertexUsed(m_vecVertices.size());
368  fill(isVertexUsed.begin(), isVertexUsed.end(), false);
369 
370  for(uint32_t triCt = 0; triCt < m_vecTriangleIndices.size(); triCt++)
371  {
372  int v = m_vecTriangleIndices[triCt];
373  isVertexUsed[v] = true;
374  }
375 
376  int noOfUsedVertices = 0;
377  std::vector<uint32_t> newPos(m_vecVertices.size());
378  for(uint32_t vertCt = 0; vertCt < m_vecVertices.size(); vertCt++)
379  {
380  if(isVertexUsed[vertCt])
381  {
382  m_vecVertices[noOfUsedVertices] = m_vecVertices[vertCt];
383  newPos[vertCt] = noOfUsedVertices;
384  noOfUsedVertices++;
385  }
386  }
387 
388  m_vecVertices.resize(noOfUsedVertices);
389 
390  for(uint32_t triCt = 0; triCt < m_vecTriangleIndices.size(); triCt++)
391  {
392  m_vecTriangleIndices[triCt] = newPos[m_vecTriangleIndices[triCt]];
393  }
394  }
395 
396  //Currently a free function - think where this needs to go.
397  template <typename VertexType>
398  polyvox_shared_ptr< SurfaceMesh<VertexType> > extractSubset(SurfaceMesh<VertexType>& inputMesh, std::set<uint8_t> setMaterials)
399  {
400  polyvox_shared_ptr< SurfaceMesh<VertexType> > result(new SurfaceMesh<VertexType>);
401 
402  result->m_Region = inputMesh.m_Region;
403 
404  if(inputMesh.m_vecVertices.size() == 0) //FIXME - I don't think we should need this test, but I have seen crashes otherwise...
405  {
406  return result;
407  }
408 
409  assert(inputMesh.m_vecLodRecords.size() == 1);
410  if(inputMesh.m_vecLodRecords.size() != 1)
411  {
412  //If we have done progressive LOD then it's too late to split into subsets.
413  return result;
414  }
415 
416  std::vector<int32_t> indexMap(inputMesh.m_vecVertices.size());
417  std::fill(indexMap.begin(), indexMap.end(), -1);
418 
419  for(uint32_t triCt = 0; triCt < inputMesh.m_vecTriangleIndices.size(); triCt += 3)
420  {
421 
422  VertexType& v0 = inputMesh.m_vecVertices[inputMesh.m_vecTriangleIndices[triCt]];
423  VertexType& v1 = inputMesh.m_vecVertices[inputMesh.m_vecTriangleIndices[triCt + 1]];
424  VertexType& v2 = inputMesh.m_vecVertices[inputMesh.m_vecTriangleIndices[triCt + 2]];
425 
426  if(
427  (setMaterials.find(v0.getMaterial()) != setMaterials.end()) ||
428  (setMaterials.find(v1.getMaterial()) != setMaterials.end()) ||
429  (setMaterials.find(v2.getMaterial()) != setMaterials.end()))
430  {
431  uint32_t i0;
432  if(indexMap[inputMesh.m_vecTriangleIndices[triCt]] == -1)
433  {
434  indexMap[inputMesh.m_vecTriangleIndices[triCt]] = result->addVertex(v0);
435  }
436  i0 = indexMap[inputMesh.m_vecTriangleIndices[triCt]];
437 
438  uint32_t i1;
439  if(indexMap[inputMesh.m_vecTriangleIndices[triCt+1]] == -1)
440  {
441  indexMap[inputMesh.m_vecTriangleIndices[triCt+1]] = result->addVertex(v1);
442  }
443  i1 = indexMap[inputMesh.m_vecTriangleIndices[triCt+1]];
444 
445  uint32_t i2;
446  if(indexMap[inputMesh.m_vecTriangleIndices[triCt+2]] == -1)
447  {
448  indexMap[inputMesh.m_vecTriangleIndices[triCt+2]] = result->addVertex(v2);
449  }
450  i2 = indexMap[inputMesh.m_vecTriangleIndices[triCt+2]];
451 
452  result->addTriangle(i0,i1,i2);
453  }
454  }
455 
456  result->m_vecLodRecords.clear();
457  LodRecord lodRecord;
458  lodRecord.beginIndex = 0;
459  lodRecord.endIndex = result->getNoOfIndices();
460  result->m_vecLodRecords.push_back(lodRecord);
461 
462  return result;
463  }
464 
465  template <typename VertexType>
466  void SurfaceMesh<VertexType>::scaleVertices(float amount)
467  {
468  for(uint32_t ct = 0; ct < m_vecVertices.size(); ct++)
469  {
470  //TODO: Should rethink accessors here to provide faster access
471  Vector3DFloat position = m_vecVertices[ct].getPosition();
472  position *= amount;
473  m_vecVertices[ct].setPosition(position);
474  }
475  }
476 
477  template <typename VertexType>
478  void SurfaceMesh<VertexType>::translateVertices(const Vector3DFloat& amount)
479  {
480  for(uint32_t ct = 0; ct < m_vecVertices.size(); ct++)
481  {
482  //TODO: Should rethink accessors here to provide faster access
483  Vector3DFloat position = m_vecVertices[ct].getPosition();
484  position += amount;
485  m_vecVertices[ct].setPosition(position);
486  }
487  }
488 }
Generated by   doxygen 1.8.1