TAMSVIZ
Visualization and annotation tool for ROS
mesh.cpp
1 // TAMSVIZ
2 // (c) 2020 Philipp Ruppel
3 
4 #include "mesh.h"
5 
6 #include "../core/log.h"
7 #include "../core/profiler.h"
8 #include "shader.h"
9 
10 #include <map>
11 
12 MeshData operator+(const MeshData &a, const MeshData &b) {
13  MeshData r = a;
14  r.append(b);
15  return r;
16 }
17 
18 MeshData &MeshData::colorize(float r, float g, float b, float a) {
19  return colorize(Eigen::Vector4f(r, g, b, a));
20 }
21 
22 MeshData &MeshData::operator+=(const MeshData &other) { return append(other); }
23 
24 MeshData &MeshData::translate(float x, float y, float z) {
25  return translate(Eigen::Vector3f(x, y, z));
26 }
27 
28 MeshData &MeshData::scale(const Eigen::Vector3f &v) {
29  return transform(Eigen::Scaling(v));
30 }
31 
32 MeshData &MeshData::scale(float x, float y, float z) {
33  return scale(Eigen::Vector3f(x, y, z));
34 }
35 
36 MeshData &MeshData::scale(float s) { return scale(s, s, s); }
37 
38 MeshData &MeshData::rotate(float angle, const Eigen::Vector3f &axis) {
39  return transform(Eigen::AngleAxisf(angle, axis));
40 }
41 
42 void MeshData::_transform(const Eigen::Affine3f &transform) {
43  for (auto &p : positions) {
44  p = transform * p;
45  }
46  Eigen::Matrix3f normal_matrix = transform.linear().inverse().transpose();
47  for (auto *component : {&normals, &tangents, &bitangents}) {
48  for (auto &n : *component) {
49  n = (normal_matrix * n).eval();
50  }
51  }
52 }
53 
54 template <class T>
55 static void appendMeshComponent(const MeshData &mesh, std::vector<T> &a,
56  const std::vector<T> &b, const T &def) {
57  if (!b.empty()) {
58  if (a.size() < mesh.positions.size()) {
59  a.resize(mesh.positions.size(), def);
60  }
61  a.insert(a.end(), b.begin(), b.end());
62  }
63 }
64 
65 MeshData &MeshData::append(const MeshData &other) {
66  for (auto i : other.indices) {
67  indices.push_back(i + positions.size());
68  }
69  appendMeshComponent(*this, normals, other.normals, Eigen::Vector3f(0, 0, 0));
70  appendMeshComponent(*this, texcoords, other.texcoords, Eigen::Vector2f(0, 0));
71  appendMeshComponent(*this, tangents, other.tangents,
72  Eigen::Vector3f(0, 0, 0));
73  appendMeshComponent(*this, bitangents, other.bitangents,
74  Eigen::Vector3f(0, 0, 0));
75  appendMeshComponent(*this, colors, other.colors, Eigen::Vector4f(0, 0, 0, 1));
76  appendMeshComponent(*this, colors8, other.colors8, uint32_t(0xff000000));
77  appendMeshComponent(*this, extras, other.extras, Eigen::Vector4f(0, 0, 0, 1));
78  appendMeshComponent(*this, positions, other.positions,
79  Eigen::Vector3f(0, 0, 0));
80  return *this;
81 }
82 
83 MeshData &MeshData::translate(const Eigen::Vector3f &v) {
84  for (auto &p : positions) {
85  p += v;
86  }
87  return *this;
88 }
89 
90 MeshData &MeshData::colorize(const Eigen::Vector4f &color) {
91  colors.resize(positions.size());
92  for (auto &c : colors) {
93  c = color;
94  }
95  return *this;
96 }
97 
98 MeshData &MeshData::computeNormals() {
99  if (positions.empty()) {
100  return *this;
101  }
102  if (indices.empty() && !positions.empty()) {
103  while (indices.size() < positions.size()) {
104  indices.push_back(indices.size());
105  }
106  }
107  normals.clear();
108  normals.resize(positions.size(), Eigen::Vector3f::Zero());
109  for (size_t face_index = 0; face_index < indices.size() / 3; face_index++) {
110  auto &A = positions.at(indices.at(face_index * 3 + 0));
111  auto &B = positions.at(indices.at(face_index * 3 + 1));
112  auto &C = positions.at(indices.at(face_index * 3 + 2));
113  Eigen::Vector3f face_normal = (B - A).cross(C - A);
114  for (size_t edge_index = 0; edge_index < 3; edge_index++) {
115  size_t index = face_index * 3 + edge_index;
116  normals.at(indices.at(index)) += face_normal;
117  }
118  }
119  for (auto &n : normals) {
120  n.normalize();
121  }
122  return *this;
123 }
124 
125 Mesh::Mesh(const MeshData &data) : _data(data) { init(); }
126 
127 Mesh::Mesh(const std::function<void(MeshData &)> &loader) : _loader(loader) {}
128 
129 Mesh::Mesh(const std::function<MeshData()> &loader)
130  : _loader([loader](MeshData &d) { d = loader(); }) {}
131 
132 void Mesh::init() {
133  {
134  PROFILER("check mesh transparency");
135  _transparent = false;
136  if (!_data.colors.empty()) {
137  auto *alpha_begin = &(_data.colors[0].w());
138  auto *alpha_end = alpha_begin + _data.colors.size() * 4;
139  for (auto *alpha_pointer = alpha_begin; alpha_pointer < alpha_end;
140  alpha_pointer += 4) {
141  if ((*alpha_pointer) < 1.0) {
142  _transparent = true;
143  break;
144  }
145  }
146  }
147  }
148 }
149 
150 void Mesh::createBuffer(GLenum type, GLuint index, const void *data,
151  size_t size, size_t stride, size_t element_size,
152  GLenum datatype, bool normalized) {
153  GLuint vbo = 0;
154  V_GL(glBindVertexArray(_vao));
155  V_GL(glGenBuffers(1, &vbo));
156  V_GL(glBindBuffer(type, vbo));
157  V_GL(glBufferData(type, size, data, GL_STATIC_DRAW));
158  if (type == GL_ARRAY_BUFFER) {
159  V_GL(glEnableVertexAttribArray(index));
160  V_GL(glVertexAttribPointer(index, stride / element_size, datatype,
161  normalized, stride, 0));
162  }
163  V_GL(glBindVertexArray(0));
164  V_GL(glDeleteBuffers(1, &vbo));
165 }
166 
167 void Mesh::create() {
168  if (!_vao) {
169  if (_loader) {
170  PROFILER("mesh callback");
171  _data = MeshData();
172  _loader(_data);
173  _loader = nullptr;
174  init();
175  }
176  PROFILER("create mesh buffers");
177  V_GL(glGenVertexArrays(1, &_vao));
178  if (!_data.positions.empty()) {
179  createBuffer(GL_ARRAY_BUFFER, (GLuint)VertexAttributes::position,
180  _data.positions.data(),
181  _data.positions.size() * sizeof(_data.positions[0]),
182  sizeof(_data.positions[0]));
183  if (!_data.normals.empty()) {
184  createBuffer(GL_ARRAY_BUFFER, (GLuint)VertexAttributes::normal,
185  _data.normals.data(),
186  _data.normals.size() * sizeof(_data.normals[0]),
187  sizeof(_data.normals[0]));
188  }
189  if (!_data.texcoords.empty()) {
190  createBuffer(GL_ARRAY_BUFFER, (GLuint)VertexAttributes::texcoord,
191  _data.texcoords.data(),
192  _data.texcoords.size() * sizeof(_data.texcoords[0]),
193  sizeof(_data.texcoords[0]));
194  }
195  if (!_data.tangents.empty()) {
196  createBuffer(GL_ARRAY_BUFFER, (GLuint)VertexAttributes::tangent,
197  _data.tangents.data(),
198  _data.tangents.size() * sizeof(_data.tangents[0]),
199  sizeof(_data.tangents[0]));
200  }
201  if (!_data.bitangents.empty()) {
202  createBuffer(GL_ARRAY_BUFFER, (GLuint)VertexAttributes::bitangent,
203  _data.bitangents.data(),
204  _data.bitangents.size() * sizeof(_data.bitangents[0]),
205  sizeof(_data.bitangents[0]));
206  }
207  if (!_data.extras.empty()) {
208  createBuffer(GL_ARRAY_BUFFER, (GLuint)VertexAttributes::extra,
209  _data.extras.data(),
210  _data.extras.size() * sizeof(_data.extras[0]),
211  sizeof(_data.extras[0]));
212  }
213  if (!_data.colors.empty()) {
214  createBuffer(GL_ARRAY_BUFFER, (GLuint)VertexAttributes::color,
215  _data.colors.data(),
216  _data.colors.size() * sizeof(_data.colors[0]),
217  sizeof(_data.colors[0]));
218  } else if (!_data.colors8.empty()) {
219  createBuffer(GL_ARRAY_BUFFER, (GLuint)VertexAttributes::color,
220  _data.colors8.data(),
221  _data.colors8.size() * sizeof(_data.colors8[0]),
222  sizeof(_data.colors8[0]), 1, GL_UNSIGNED_BYTE, true);
223  } else {
224  V_GL(glVertexAttrib4f((GLuint)VertexAttributes::color, 1, 1, 1, 1));
225  }
226  if (!_data.indices.empty()) {
227  createBuffer(GL_ELEMENT_ARRAY_BUFFER, 0, _data.indices.data(),
228  _data.indices.size() * sizeof(_data.indices[0]),
229  sizeof(_data.indices[0]));
230  }
231  }
232  }
233 }
234 
235 void Mesh::destroy() {
236  if (_vao) {
237  GLuint vao = _vao;
238  cleanup([vao]() {
239  PROFILER("mesh cleanup");
240  V_GL(glDeleteVertexArrays(1, &vao));
241  });
242  _vao = 0;
243  }
244 }
245 
246 Mesh::~Mesh() {
247  if (_destructed) {
248  throw std::runtime_error("mesh already destructed");
249  }
250  _destructed = true;
251  destroy();
252 }
253 
254 bool Mesh::transparent() {
255  if (!_vao) {
256  create();
257  }
258  return _transparent;
259 }
260 
261 GLuint Mesh::vertexArrayObject() {
262  if (!_vao) {
263  create();
264  }
265  return _vao;
266 }
267 
268 void Mesh::bind() {
269  if (!_vao) {
270  create();
271  }
272  V_GL(glBindVertexArray(_vao));
273 }
MeshData
Definition: mesh.h:11
Generated by   doxygen 1.8.11