TDME2  1.9.200
Primitives.cpp
Go to the documentation of this file.
1 #include <tdme/utilities/Primitives.h>
2 
3 #include <array>
4 #include <memory>
5 #include <string>
6 #include <unordered_map>
7 #include <vector>
8 
9 #include <tdme/tdme.h>
10 #include <tdme/engine/Color4.h>
11 #include <tdme/engine/model/Face.h>
12 #include <tdme/engine/model/FacesEntity.h>
13 #include <tdme/engine/model/Material.h>
14 #include <tdme/engine/model/Model.h>
15 #include <tdme/engine/model/Node.h>
16 #include <tdme/engine/model/RotationOrder.h>
17 #include <tdme/engine/model/SpecularMaterialProperties.h>
18 #include <tdme/engine/model/UpVector.h>
19 #include <tdme/engine/primitives/BoundingBox.h>
20 #include <tdme/engine/primitives/BoundingVolume.h>
21 #include <tdme/engine/primitives/Capsule.h>
22 #include <tdme/engine/primitives/ConvexMesh.h>
23 #include <tdme/engine/primitives/OrientedBoundingBox.h>
24 #include <tdme/engine/primitives/Sphere.h>
25 #include <tdme/math/Math.h>
26 #include <tdme/math/Quaternion.h>
27 #include <tdme/math/Vector3.h>
28 #include <tdme/utilities/Console.h>
29 #include <tdme/utilities/ModelTools.h>
30 
31 using std::array;
32 using std::make_unique;
33 using std::string;
34 using std::to_string;
35 using std::unordered_map;
36 using std::vector;
37 
38 using tdme::engine::Color4;
39 using tdme::engine::model::Face;
40 using tdme::engine::model::FacesEntity;
41 using tdme::engine::model::Material;
42 using tdme::engine::model::Model;
43 using tdme::engine::model::Node;
44 using tdme::engine::model::RotationOrder;
45 using tdme::engine::model::SpecularMaterialProperties;
46 using tdme::engine::model::UpVector;
47 using tdme::engine::primitives::BoundingBox;
48 using tdme::engine::primitives::BoundingVolume;
49 using tdme::engine::primitives::Capsule;
50 using tdme::engine::primitives::ConvexMesh;
51 using tdme::engine::primitives::OrientedBoundingBox;
52 using tdme::engine::primitives::Sphere;
53 using tdme::math::Math;
54 using tdme::math::Quaternion;
55 using tdme::math::Vector3;
56 using tdme::utilities::Console;
57 using tdme::utilities::ModelTools;
58 using tdme::utilities::Primitives;
59 
60 Model* Primitives::createBoundingBoxModel(BoundingBox* boundingBox, const string& id)
61 {
62  // model
63  auto model = make_unique<Model>(id, id, UpVector::Y_UP, RotationOrder::XYZ, nullptr);
64  // material
65  auto material = make_unique<Material>("primitive");
66  auto specularMaterialProperties = make_unique<SpecularMaterialProperties>();
67  specularMaterialProperties->setAmbientColor(
68  Color4(
69  245.0f / 255.0f * 0.5f,
70  40.0f / 255.0f * 0.5f,
71  135.0f / 255.0f * 0.5f,
72  1.0f
73  )
74  );
75  specularMaterialProperties->setDiffuseColor(
76  Color4(
77  245.0f / 255.0f * 0.5f,
78  40.0f / 255.0f * 0.5f,
79  135.0f / 255.0f * 0.5f,
80  0.5f
81  )
82  );
83  specularMaterialProperties->setSpecularColor(Color4(0.0f, 0.0f, 0.0f, 1.0f));
84  material->setSpecularMaterialProperties(specularMaterialProperties.release());
85  // node
86  auto node = make_unique<Node>(model.get(), nullptr, "primitive", "primitive");
87  // triangle vertices indexes
88  auto fvi = BoundingBox::getFacesVerticesIndexes();
89  // vertices
90  vector<Vector3> vertices;
91  for (const auto& vertex : boundingBox->getVertices()) {
92  vertices.push_back(vertex);
93  }
94  // normals
95  vector<Vector3> normals;
96  normals.emplace_back(-1.0f, 0.0f, 0.0f);
97  normals.emplace_back(+1.0f, 0.0f, 0.0f);
98  normals.emplace_back(0.0f, -1.0f, 0.0f);
99  normals.emplace_back(0.0f, +1.0f, 0.0f);
100  normals.emplace_back(0.0f, 0.0f, -1.0f);
101  normals.emplace_back(0.0f, 0.0f, +1.0f);
102  // faces
103  vector<Face> faces;
104  // left
105  faces.emplace_back(node.get(), (*fvi)[0][0], (*fvi)[0][1], (*fvi)[0][2], 0, 0, 0);
106  faces.emplace_back(node.get(), (*fvi)[1][0], (*fvi)[1][1], (*fvi)[1][2], 0, 0, 0);
107  // right
108  faces.emplace_back(node.get(), (*fvi)[2][0], (*fvi)[2][1], (*fvi)[2][2], 1, 1, 1);
109  faces.emplace_back(node.get(), (*fvi)[3][0], (*fvi)[3][1], (*fvi)[3][2], 1, 1, 1);
110  // top
111  faces.emplace_back(node.get(), (*fvi)[4][0], (*fvi)[4][1], (*fvi)[4][2], 2, 2, 2);
112  faces.emplace_back(node.get(), (*fvi)[5][0], (*fvi)[5][1], (*fvi)[5][2], 2, 2, 2);
113  // bottom
114  faces.emplace_back(node.get(), (*fvi)[6][0], (*fvi)[6][1], (*fvi)[6][2], 3, 3, 3);
115  faces.emplace_back(node.get(), (*fvi)[7][0], (*fvi)[7][1], (*fvi)[7][2], 3, 3, 3);
116  // near
117  faces.emplace_back(node.get(), (*fvi)[8][0], (*fvi)[8][1], (*fvi)[8][2], 4, 4, 4);
118  faces.emplace_back(node.get(), (*fvi)[9][0], (*fvi)[9][1], (*fvi)[9][2], 4, 4, 4);
119  // far
120  faces.emplace_back(node.get(), (*fvi)[10][0], (*fvi)[10][1], (*fvi)[10][2], 5, 5, 5);
121  faces.emplace_back(node.get(), (*fvi)[11][0], (*fvi)[11][1], (*fvi)[11][2], 5, 5, 5);
122  // faces entity
123  FacesEntity nodeFacesEntity(node.get(), "primitive.facesentity");
124  nodeFacesEntity.setMaterial(material.get());
125  nodeFacesEntity.setFaces(faces);
126  // set up faces entity
127  vector<FacesEntity> nodeFacesEntities;
128  nodeFacesEntities.push_back(nodeFacesEntity);
129  // setup node vertex data
130  node->setVertices(vertices);
131  node->setNormals(normals);
132  node->setFacesEntities(nodeFacesEntities);
133  // register node
134  model->getNodes()["node"] = node.get();
135  model->getSubNodes()["node"] = node.get();
136  node.release();
137  //
138  model->getMaterials()[material->getId()] = material.get();
139  material.release();
140  // prepare for indexed rendering
141  ModelTools::prepareForIndexedRendering(model.get());
142  //
143  return model.release();
144 }
145 
146 Model* Primitives::createOrientedBoundingBoxModel(OrientedBoundingBox* orientedBoundingBox, const string& id)
147 {
148  // model
149  auto model = make_unique<Model>(id, id, UpVector::Y_UP, RotationOrder::XYZ, nullptr);
150  // material
151  auto material = make_unique<Material>("primitive");
152  auto specularMaterialProperties = make_unique<SpecularMaterialProperties>();
153  specularMaterialProperties->setAmbientColor(
154  Color4(
155  245.0f / 255.0f * 0.5f,
156  40.0f / 255.0f * 0.5f,
157  135.0f / 255.0f * 0.5f,
158  1.0f
159  )
160  );
161  specularMaterialProperties->setDiffuseColor(
162  Color4(
163  245.0f / 255.0f * 0.5f,
164  40.0f / 255.0f * 0.5f,
165  135.0f / 255.0f * 0.5f,
166  0.5f
167  )
168  );
169  specularMaterialProperties->setSpecularColor(Color4(0.0f, 0.0f, 0.0f, 1.0f));
170  material->setSpecularMaterialProperties(specularMaterialProperties.release());
171  // node
172  auto node = make_unique<Node>(model.get(), nullptr, "primitive", "primitive");
173  // triangle vertices indexes
174  auto fvi = OrientedBoundingBox::getFacesVerticesIndexes();
175  // vertices
176  vector<Vector3> vertices;
177  for (const auto& vertex : orientedBoundingBox->getVertices()) {
178  vertices.push_back(transformVector3(orientedBoundingBox, toRP3DVector3(vertex)));
179  }
180  // normals
181  auto axes = orientedBoundingBox->getAxes();
182  vector<Vector3> normals;
183  normals.push_back(transformVector3Normal(orientedBoundingBox, toRP3DVector3(axes[0].clone().scale(-1.0f))));
184  normals.push_back(transformVector3Normal(orientedBoundingBox, toRP3DVector3(axes[0].clone())));
185  normals.push_back(transformVector3Normal(orientedBoundingBox, toRP3DVector3(axes[1].clone().scale(-1.0f))));
186  normals.push_back(transformVector3Normal(orientedBoundingBox, toRP3DVector3(axes[1].clone())));
187  normals.push_back(transformVector3Normal(orientedBoundingBox, toRP3DVector3(axes[2].clone().scale(-1.0f))));
188  normals.push_back(transformVector3Normal(orientedBoundingBox, toRP3DVector3(axes[2].clone())));
189  // faces
190  vector<Face> faces;
191  // left
192  faces.emplace_back(node.get(), fvi[0][0], fvi[0][1], fvi[0][2], 0, 0, 0);
193  faces.emplace_back(node.get(), fvi[1][0], fvi[1][1], fvi[1][2], 0, 0, 0);
194  // right
195  faces.emplace_back(node.get(), fvi[2][0], fvi[2][1], fvi[2][2], 1, 1, 1);
196  faces.emplace_back(node.get(), fvi[3][0], fvi[3][1], fvi[3][2], 1, 1, 1);
197  // top
198  faces.emplace_back(node.get(), fvi[4][0], fvi[4][1], fvi[4][2], 2, 2, 2);
199  faces.emplace_back(node.get(), fvi[5][0], fvi[5][1], fvi[5][2], 2, 2, 2);
200  // bottom
201  faces.emplace_back(node.get(), fvi[6][0], fvi[6][1], fvi[6][2], 3, 3, 3);
202  faces.emplace_back(node.get(), fvi[7][0], fvi[7][1], fvi[7][2], 3, 3, 3);
203  // near
204  faces.emplace_back(node.get(), fvi[8][0], fvi[8][1], fvi[8][2], 4, 4, 4);
205  faces.emplace_back(node.get(), fvi[9][0], fvi[9][1], fvi[9][2], 4, 4, 4);
206  // far
207  faces.emplace_back(node.get(), fvi[10][0], fvi[10][1], fvi[10][2], 5, 5, 5);
208  faces.emplace_back(node.get(), fvi[11][0], fvi[11][1], fvi[11][2], 5, 5, 5);
209  // faces entity
210  FacesEntity nodeFacesEntity(node.get(), "primitive.facesentity");
211  nodeFacesEntity.setMaterial(material.get());
212  nodeFacesEntity.setFaces(faces);
213  // set up faces entity
214  vector<FacesEntity> nodeFacesEntities;
215  nodeFacesEntities.push_back(nodeFacesEntity);
216  // setup node vertex data
217  node->setVertices(vertices);
218  node->setNormals(normals);
219  node->setFacesEntities(nodeFacesEntities);
220  // register node
221  model->getNodes()["node"] = node.get();
222  model->getSubNodes()["node"] = node.get();
223  node.release();
224  //
225  model->getMaterials()[material->getId()] = material.get();
226  material.release();
227  //
228  // prepare for indexed rendering
229  ModelTools::prepareForIndexedRendering(model.get());
230  //
231  return model.release();
232 }
233 
234 Model* Primitives::createSphereModel(Sphere* sphere, const string& id, int32_t segmentsX, int32_t segmentsY)
235 {
236  // sphere properties
237  auto radius = sphere->getRadius();
238  // model
239  auto model = make_unique<Model>(id, id, UpVector::Y_UP, RotationOrder::XYZ, nullptr);
240  // material
241  auto material = make_unique<Material>("primitive");
242  auto specularMaterialProperties = make_unique<SpecularMaterialProperties>();
243  specularMaterialProperties->setAmbientColor(
244  Color4(
245  245.0f / 255.0f * 0.5f,
246  40.0f / 255.0f * 0.5f,
247  135.0f / 255.0f * 0.5f,
248  1.0f
249  )
250  );
251  specularMaterialProperties->setDiffuseColor(
252  Color4(
253  245.0f / 255.0f * 0.5f,
254  40.0f / 255.0f * 0.5f,
255  135.0f / 255.0f * 0.5f,
256  0.5f
257  )
258  );
259  specularMaterialProperties->setSpecularColor(Color4(0.0f, 0.0f, 0.0f, 1.0f));
260  material->setSpecularMaterialProperties(specularMaterialProperties.release());
261  // node
262  auto node = make_unique<Node>(model.get(), nullptr, "primitive", "primitive");
263  // vertices
264  vector<Vector3> vertices;
265  for (auto ySegment = 0; ySegment < segmentsY + 1; ySegment++)
266  for (auto xSegment = 0; xSegment < segmentsX; xSegment++) {
267  auto vertex = (
268  Vector3(
269  ((Math::sin(Math::PI * ySegment / segmentsY) * Math::cos(Math::PI * 2 * xSegment / segmentsX))),
270  ((Math::cos(Math::PI * ySegment / segmentsY))),
271  ((Math::sin(Math::PI * ySegment / segmentsY) * Math::sin(Math::PI * 2 * xSegment / segmentsX))))
272  ).scale(radius);
273  vertices.push_back(transformVector3(sphere, toRP3DVector3(vertex)));
274  }
275  // normals
276  vector<Vector3> normals;
277  // faces
278  vector<Face> faces;
279  int32_t vi0, vi1, vi2;
280  int32_t ni;
281  for (auto y = 0; y < segmentsY + 1; y++) {
282  for (auto x = 0; x < segmentsX; x++) {
283  vi0 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
284  vi1 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
285  vi2 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
286  ni = normals.size();
287  {
288  array<Vector3, 3> faceVertices = {
289  vertices[vi0],
290  vertices[vi1],
291  vertices[vi2]
292  };
293  for (const auto& normal: ModelTools::computeNormals(faceVertices)) {
294  normals.push_back(normal);
295  }
296  }
297  faces.emplace_back(node.get(), vi0, vi1, vi2, ni + 0, ni + 1, ni + 2);
298  vi0 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
299  vi1 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
300  vi2 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
301  ni = normals.size();
302  {
303  array<Vector3, 3> faceVertices = {
304  vertices[vi0],
305  vertices[vi1],
306  vertices[vi2]
307  };
308  for (const auto& normal: ModelTools::computeNormals(faceVertices)) {
309  normals.push_back(normal);
310  }
311  }
312  faces.emplace_back(node.get(), vi0, vi1, vi2, ni + 0, ni + 1, ni + 2);
313  }
314  }
315  // set up faces entity
316  FacesEntity nodeFacesEntity(node.get(), "primitive.facesentity");
317  nodeFacesEntity.setMaterial(material.get());
318  nodeFacesEntity.setFaces(faces);
319  // node faces entities
320  vector<FacesEntity> nodeFacesEntities;
321  nodeFacesEntities.push_back(nodeFacesEntity);
322  // setup node vertex data
323  node->setVertices(vertices);
324  node->setNormals(normals);
325  node->setFacesEntities(nodeFacesEntities);
326  // register node
327  model->getNodes()["node"] = node.get();
328  model->getSubNodes()["node"] = node.get();
329  node.release();
330  //
331  model->getMaterials()[material->getId()] = material.get();
332  material.release();
333  // prepare for indexed rendering
334  ModelTools::computeNormals(model.get());
335  ModelTools::prepareForIndexedRendering(model.get());
336  //
337  return model.release();
338 }
339 
340 Model* Primitives::createCapsuleModel(Capsule* capsule, const string& id, int32_t segmentsX, int32_t segmentsY)
341 {
342  // capsule properties
343  const auto radius = capsule->getRadius();
344  const auto& a = capsule->getA();
345  const auto& b = capsule->getB();
346  const auto& center = capsule->getCenter();
347  // rotation quaternion
348  Quaternion rotationQuaternion;
349  rotationQuaternion.identity();
350  // angle between a and b
351  Vector3 yAxis(0.0f, -1.0f, 0.0f);
352  Vector3 abNormalized = a.clone().sub(b).normalize();
353  Vector3 rotationAxis;
354  if (Math::abs(abNormalized[0]) < Math::EPSILON && Math::abs(abNormalized[2]) < Math::EPSILON) {
355  rotationAxis.set(abNormalized[1], 0.0f, 0.0f);
356  } else {
357  rotationAxis = Vector3::computeCrossProduct(yAxis, abNormalized).normalize();
358  }
359  auto angle = Vector3::computeAngle(yAxis, abNormalized, yAxis);
360  rotationQuaternion.rotate(rotationAxis, angle);
361  auto rotationQuaternionMatrixInverted = rotationQuaternion.computeMatrix();
362  rotationQuaternionMatrixInverted.invert();
363  auto aInverted = a.clone().sub(center);
364  auto bInverted = b.clone().sub(center);
365  aInverted = rotationQuaternionMatrixInverted.multiply(aInverted);
366  bInverted = rotationQuaternionMatrixInverted.multiply(bInverted);
367  // model
368  auto model = make_unique<Model>(id, id, UpVector::Y_UP, RotationOrder::XYZ, nullptr);
369  // material
370  auto material = make_unique<Material>("primitive");
371  auto specularMaterialProperties = make_unique<SpecularMaterialProperties>();
372  specularMaterialProperties->setAmbientColor(
373  Color4(
374  245.0f / 255.0f * 0.5f,
375  40.0f / 255.0f * 0.5f,
376  135.0f / 255.0f * 0.5f,
377  1.0f
378  )
379  );
380  specularMaterialProperties->setDiffuseColor(
381  Color4(
382  245.0f / 255.0f * 0.5f,
383  40.0f / 255.0f * 0.5f,
384  135.0f / 255.0f * 0.5f,
385  0.5f
386  )
387  );
388  specularMaterialProperties->setSpecularColor(Color4(0.0f, 0.0f, 0.0f, 1.0f));
389  material->setSpecularMaterialProperties(specularMaterialProperties.release());
390  // node
391  auto node = make_unique<Node>(model.get(), nullptr, "primitive", "primitive");
392  // vertices
393  vector<Vector3> vertices;
394  // bottom half sphere
395  for (auto ySegment = 0; ySegment < segmentsY / 2; ySegment++)
396  for (auto xSegment = 0; xSegment < segmentsX; xSegment++) {
397  auto vertex =
398  rotationQuaternion.multiply(
399  Vector3(
400  ((Math::sin(Math::PI * ySegment / segmentsY) * Math::cos(Math::PI * 2 * xSegment / segmentsX))),
401  ((Math::cos(Math::PI * ySegment / segmentsY))),
402  ((Math::sin(Math::PI * ySegment / segmentsY) * Math::sin(Math::PI * 2 * xSegment / segmentsX)))
403  )
404  );
405  vertex.scale(radius);
406  vertex = rotationQuaternionMatrixInverted.multiply(vertex);
407  vertex.add(bInverted);
408  vertices.push_back(transformVector3(capsule, toRP3DVector3(vertex)));
409  }
410  // top half sphere
411  for (auto ySegment = segmentsY / 2; ySegment < segmentsY + 1; ySegment++)
412  for (auto xSegment = 0; xSegment < segmentsX; xSegment++) {
413  auto vertex =
414  rotationQuaternion.multiply(
415  Vector3(
416  ((Math::sin(Math::PI * ySegment / segmentsY) * Math::cos(Math::PI * 2 * xSegment / segmentsX))),
417  ((Math::cos(Math::PI * ySegment / segmentsY))),
418  ((Math::sin(Math::PI * ySegment / segmentsY) * Math::sin(Math::PI * 2 * xSegment / segmentsX)))
419  )
420  );
421  vertex.scale(radius);
422  vertex = rotationQuaternionMatrixInverted.multiply(vertex);
423  vertex.add(aInverted);
424  vertices.push_back(transformVector3(capsule, toRP3DVector3(vertex)));
425  }
426  // normals
427  vector<Vector3> normals;
428  // faces
429  vector<Face> faces;
430  int32_t vi0, vi1, vi2;
431  int32_t ni;
432  for (auto y = 0; y < segmentsY + 1; y++) {
433  for (auto x = 0; x < segmentsX; x++) {
434  vi0 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
435  vi1 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
436  vi2 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
437  ni = normals.size();
438  {
439  array<Vector3, 3> faceVertices = {
440  vertices[vi0],
441  vertices[vi1],
442  vertices[vi2]
443  };
444  for (const auto& normal: ModelTools::computeNormals(faceVertices)) {
445  normals.push_back(normal);
446  }
447  }
448  faces.emplace_back(node.get(), vi0, vi1, vi2, ni + 0, ni + 1, ni + 2);
449  vi0 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
450  vi1 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
451  vi2 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
452  {
453  array<Vector3, 3> faceVertices = {
454  vertices.at(vi0),
455  vertices.at(vi1),
456  vertices.at(vi2)
457  };
458  for (const auto& normal: ModelTools::computeNormals(faceVertices)) {
459  normals.push_back(normal);
460  }
461  }
462  faces.emplace_back(node.get(), vi0, vi1, vi2, ni + 0, ni + 1, ni + 2);
463  }
464  }
465  // node faces entities
466  FacesEntity nodeFacesEntity(node.get(), "primitive.facesentity");
467  nodeFacesEntity.setMaterial(material.get());
468  nodeFacesEntity.setFaces(faces);
469  // set up faces entity
470  vector<FacesEntity> nodeFacesEntities;
471  nodeFacesEntities.push_back(nodeFacesEntity);
472  // setup node vertex data
473  node->setVertices(vertices);
474  node->setNormals(normals);
475  node->setFacesEntities(nodeFacesEntities);
476  // register node
477  model->getNodes()["node"] = node.get();
478  model->getSubNodes()["node"] = node.get();
479  node.release();
480  //
481  model->getMaterials()[material->getId()] = material.get();
482  material.release();
483  // prepare for indexed rendering
484  ModelTools::computeNormals(model.get());
485  ModelTools::prepareForIndexedRendering(model.get());
486  //
487  return model.release();
488 }
489 
490 Model* Primitives::createConvexMeshModel(ConvexMesh* mesh, const string& id) {
491  Console::println("Primitives::createConvexMeshModel(): This is not supported. Rather load the model and use Primitives::setupConvexMeshModel().");
492  return nullptr;
493 }
494 
495 void Primitives::setupConvexMeshModel(Model* model)
496 {
497  // TODO: take bounding volume scale into account
498  // Note: there is no hurry as LE and ME do not do scaling of bounding volumes
499  model->setImportTransformMatrix(model->getImportTransformMatrix().clone().scale(1.01f));
500  auto material = make_unique<Material>("primitive");
501  auto specularMaterialProperties = make_unique<SpecularMaterialProperties>();
502  specularMaterialProperties->setAmbientColor(
503  Color4(
504  245.0f / 255.0f * 0.5f,
505  40.0f / 255.0f * 0.5f,
506  135.0f / 255.0f * 0.5f,
507  1.0f
508  )
509  );
510  specularMaterialProperties->setDiffuseColor(
511  Color4(
512  245.0f / 255.0f * 0.5f,
513  40.0f / 255.0f * 0.5f,
514  135.0f / 255.0f * 0.5f,
515  0.5f
516  )
517  );
518  specularMaterialProperties->setSpecularColor(Color4(0.0f, 0.0f, 0.0f, 1.0f));
519  material->setSpecularMaterialProperties(specularMaterialProperties.release());
520  model->getMaterials()[material->getId()] = material.get();
521  setupConvexMeshMaterial(model->getSubNodes(), material.release());
522 }
523 
524 void Primitives::setupConvexMeshMaterial(const unordered_map<string, Node*>& nodes, Material* material)
525 {
526  for (const auto& [nodeId, node]: nodes) {
527  auto facesEntities = node->getFacesEntities();
528  for (auto& faceEntity : facesEntities) {
529  faceEntity.setMaterial(material);
530  }
531  node->setFacesEntities(facesEntities);
532  setupConvexMeshMaterial(node->getSubNodes(), material);
533  }
534 }
535 
536 Model* Primitives::createModel(BoundingBox* boundingVolume, const string& id)
537 {
538  return Primitives::createBoundingBoxModel(boundingVolume, id);
539 }
540 
541 Model* Primitives::createModel(BoundingVolume* boundingVolume, const string& id)
542 {
543  if (dynamic_cast<OrientedBoundingBox*>(boundingVolume) != nullptr) {
544  return Primitives::createOrientedBoundingBoxModel(dynamic_cast< OrientedBoundingBox* >(boundingVolume), id);
545  } else
546  if (dynamic_cast<Sphere*>(boundingVolume) != nullptr) {
547  return Primitives::createSphereModel(dynamic_cast< Sphere* >(boundingVolume), id, SPHERE_SEGMENTS_X, SPHERE_SEGMENTS_Y);
548  } else
549  if (dynamic_cast<Capsule*>(boundingVolume) != nullptr) {
550  return Primitives::createCapsuleModel(dynamic_cast< Capsule* >(boundingVolume), id, CAPSULE_SEGMENTS_X, CAPSULE_SEGMENTS_Y);
551  } else
552  if (dynamic_cast<ConvexMesh*>(boundingVolume) != nullptr) {
553  return Primitives::createConvexMeshModel(dynamic_cast< ConvexMesh* >(boundingVolume), id);
554  } else {
555  Console::println(string("Primitives::createModel(): unsupported bounding volume"));
556  return nullptr;
557  }
558 }
tdme::engine::Color4
Color 4 definition class.
Definition: Color4.h:18
tdme::engine::model::Face
Represents a model face, consisting of vertex, normal, tangent and bitangent vectors,...
Definition: Face.h:18
tdme::engine::model::FacesEntity
Node faces entity A node can have multiple entities containing faces and a applied material.
Definition: FacesEntity.h:23
tdme::engine::model::FacesEntity::setMaterial
void setMaterial(Material *material)
Set up the entity's material.
Definition: FacesEntity.h:67
tdme::engine::model::FacesEntity::setFaces
void setFaces(const vector< Face > &faces)
Set up entity's faces.
Definition: FacesEntity.cpp:43
tdme::engine::model::Material
Represents a material.
Definition: Material.h:23
tdme::engine::model::Model
Representation of a 3D model.
Definition: Model.h:35
tdme::engine::model::Model::getSubNodes
unordered_map< string, Node * > & getSubNodes()
Returns object's sub nodes.
Definition: Model.h:220
tdme::engine::model::Model::getMaterials
unordered_map< string, Material * > & getMaterials()
Returns all object materials.
Definition: Model.h:185
tdme::engine::model::Model::setImportTransformMatrix
void setImportTransformMatrix(const Matrix4x4 &importTransformMatrix)
Set import transform matrix.
Definition: Model.h:348
tdme::engine::model::Model::getImportTransformMatrix
const Matrix4x4 & getImportTransformMatrix()
Definition: Model.h:340
tdme::engine::model::Node
Model node.
Definition: Node.h:32
tdme::engine::model::RotationOrder
Represents rotation orders of a model.
Definition: RotationOrder.h:23
tdme::engine::model::SpecularMaterialProperties
Represents specular material properties.
Definition: SpecularMaterialProperties.h:22
tdme::engine::model::UpVector
Model up vector.
Definition: UpVector.h:20
tdme::engine::primitives::BoundingBox
Axis aligned bounding box used for frustum, this is not directly connectable with physics engine.
Definition: BoundingBox.h:26
tdme::engine::primitives::BoundingBox::getVertices
const vector< Vector3 > & getVertices() const
Returns bounding box vertices.
Definition: BoundingBox.h:107
tdme::engine::primitives::Capsule
Capsule physics primitive.
Definition: Capsule.h:19
tdme::engine::primitives::Capsule::getB
const Vector3 & getB() const
Definition: Capsule.cpp:47
tdme::engine::primitives::Capsule::getA
const Vector3 & getA() const
Definition: Capsule.cpp:42
tdme::engine::primitives::ConvexMesh
Convex mesh physics primitive.
Definition: ConvexMesh.h:37
tdme::engine::primitives::OrientedBoundingBox
Oriented bounding box physics primitive.
Definition: OrientedBoundingBox.h:24
tdme::engine::primitives::OrientedBoundingBox::getVertices
const array< Vector3, 8 > getVertices() const
Definition: OrientedBoundingBox.cpp:82
tdme::engine::primitives::OrientedBoundingBox::getAxes
const array< Vector3, 3 > & getAxes() const
Definition: OrientedBoundingBox.cpp:148
tdme::engine::primitives::Sphere
Sphere physics primitive.
Definition: Sphere.h:19
tdme::math::Math
Standard math functions.
Definition: Math.h:19
tdme::math::Matrix4x4::clone
Matrix4x4 clone() const
Clones this matrix.
Definition: Matrix4x4.h:619
tdme::math::Matrix4x4::scale
Matrix4x4 & scale(float scalar)
Scales by scalar.
Definition: Matrix4x4.h:183
tdme::math::Matrix4x4::multiply
Vector3 multiply(const Vector3 &vector3) const
Multiplies this matrix with vector3.
Definition: Matrix4x4.h:225
tdme::math::Matrix4x4::invert
Matrix4x4 & invert()
Inverts this matrix.
Definition: Matrix4x4.h:479
tdme::math::Quaternion
Quaternion class representing quaternion mathematical structure and operations with x,...
Definition: Quaternion.h:24
tdme::math::Quaternion::identity
Quaternion & identity()
Creates identity quaternion.
Definition: Quaternion.h:226
tdme::math::Quaternion::add
Quaternion & add(const Quaternion &quaternion)
Adds quaternion.
Definition: Quaternion.h:239
tdme::math::Quaternion::scale
Quaternion & scale(float scalar)
Scales by scalar.
Definition: Quaternion.h:265
tdme::math::Quaternion::computeMatrix
Matrix4x4 computeMatrix() const
Computes a rotation matrix4x4 from this quaternion.
Definition: Quaternion.h:379
tdme::math::Quaternion::multiply
Quaternion & multiply(const Quaternion quaternion)
Multiplies this quaternion with given quaternion.
Definition: Quaternion.h:278
tdme::math::Quaternion::rotate
Quaternion & rotate(const Vector3 &axis, float angle)
Creates rotation quaternion.
Definition: Quaternion.h:361
tdme::math::Vector3
Vector3 class representing vector3 mathematical structure and operations with x, y,...
Definition: Vector3.h:20
tdme::math::Vector3::clone
Vector3 clone() const
Clones this vector3.
Definition: Vector3.h:374
tdme::math::Vector3::sub
Vector3 & sub(float scalar)
Subtracts a scalar.
Definition: Vector3.h:177
tdme::math::Vector3::set
Vector3 & set(float x, float y, float z)
Sets this vector3 by its components.
Definition: Vector3.h:70
tdme::math::Vector3::normalize
Vector3 & normalize()
Normalizes this vector3.
Definition: Vector3.h:239
tdme::utilities::Console
Console class.
Definition: Console.h:29
tdme::utilities::Console::println
static void println()
Print new line to console.
Definition: Console.cpp:92
tdme::utilities::ModelTools
Model tools functions class.
Definition: ModelTools.h:42
tdme::utilities::ModelTools::computeNormals
static array< Vector3, 3 > computeNormals(const array< Vector3, 3 > &vertices)
Computes face normals for given face vertices these normals will not be smooth.
Definition: ModelTools.h:115
tdme::utilities::ModelTools::prepareForIndexedRendering
static void prepareForIndexedRendering(Model *model)
Prepare for indexed rendering.
Definition: ModelTools.cpp:86
tdme::utilities::Primitives
Helper class to create models from physics primitive bounding volumes.
Definition: Primitives.h:33
tdme::utilities::Primitives::setupConvexMeshMaterial
static void setupConvexMeshMaterial(const unordered_map< string, Node * > &nodes, Material *material)
Set up convex mesh material.
Definition: Primitives.cpp:524
tdme::utilities::Primitives::SPHERE_SEGMENTS_X
static constexpr int32_t SPHERE_SEGMENTS_X
Definition: Primitives.h:35
tdme::utilities::Primitives::transformVector3
static Vector3 transformVector3(BoundingVolume *boundingVolume, const reactphysics3d::Vector3 &vector)
Transforms a given ReactPhysics3D vector with bounding volume transform.
Definition: Primitives.h:55
tdme::utilities::Primitives::setupConvexMeshModel
static void setupConvexMeshModel(Model *model)
Set up a convex mesh model.
Definition: Primitives.cpp:495
tdme::utilities::Primitives::createBoundingBoxModel
static Model * createBoundingBoxModel(BoundingBox *boundingBox, const string &id)
Creates a model from bounding box.
Definition: Primitives.cpp:60
tdme::utilities::Primitives::createSphereModel
static Model * createSphereModel(Sphere *sphere, const string &id, int32_t segmentsX, int32_t segmentsY)
Creates a model from oriented bounding box.
Definition: Primitives.cpp:234
tdme::utilities::Primitives::transformVector3Normal
static Vector3 transformVector3Normal(BoundingVolume *boundingVolume, const reactphysics3d::Vector3 &normal)
Transforms a given ReactPhysics3D vector with bounding volume transform.
Definition: Primitives.h:67
tdme::utilities::Primitives::SPHERE_SEGMENTS_Y
static constexpr int32_t SPHERE_SEGMENTS_Y
Definition: Primitives.h:36
tdme::utilities::Primitives::createModel
static Model * createModel(BoundingBox *boundingVolume, const string &id)
Creates a model from bounding volume.
Definition: Primitives.cpp:536
tdme::utilities::Primitives::createConvexMeshModel
static Model * createConvexMeshModel(ConvexMesh *mesh, const string &id)
Creates a model from convex mesh.
Definition: Primitives.cpp:490
tdme::utilities::Primitives::createOrientedBoundingBoxModel
static Model * createOrientedBoundingBoxModel(OrientedBoundingBox *orientedBoundingBox, const string &id)
Creates a model from oriented bounding box.
Definition: Primitives.cpp:146
tdme::utilities::Primitives::CAPSULE_SEGMENTS_Y
static constexpr int32_t CAPSULE_SEGMENTS_Y
Definition: Primitives.h:38
tdme::utilities::Primitives::CAPSULE_SEGMENTS_X
static constexpr int32_t CAPSULE_SEGMENTS_X
Definition: Primitives.h:37
tdme::utilities::Primitives::createCapsuleModel
static Model * createCapsuleModel(Capsule *capsule, const string &id, int32_t segmentsX, int32_t segmentsY)
Creates a model from capsule.
Definition: Primitives.cpp:340
tdme::utilities::Primitives::toRP3DVector3
static reactphysics3d::Vector3 toRP3DVector3(const Vector3 &vector)
Converts a TDME2 vector to ReactPhysics3D vector.
Definition: Primitives.h:45
Generated by doxygen 1.9.1