atria-soft/ephysics
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] continue removing stl

Browse Source
This commit is contained in:
Edouard DUPIN 2017-08-28 00:09:59 +02:00
parent 8b4f2f2865
commit d22ad84b61
99 changed files with 503 additions and 503 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ephysics/collision/CollisionDetection.cpp
View File

@ -168,7 +168,7 @@ void CollisionDetection::computeNarrowPhase() {
(shape1->getCollisionCategoryBits() & shape2->getCollideWithMaskBits()) == 0) || (shape1->getCollisionCategoryBits() & shape2->getCollideWithMaskBits()) == 0) ||
!m_broadPhaseAlgorithm.testOverlappingShapes(shape1, shape2)) { !m_broadPhaseAlgorithm.testOverlappingShapes(shape1, shape2)) {
std::map<overlappingpairid, OverlappingPair*>::iterator itToRemove = it; etk::Map<overlappingpairid, OverlappingPair*>::iterator itToRemove = it;
++it; ++it;
// TODO : Remove all the contact manifold of the overlapping pair from the contact manifolds list of the two bodies involved // TODO : Remove all the contact manifold of the overlapping pair from the contact manifolds list of the two bodies involved
@ -271,7 +271,7 @@ void CollisionDetection::computeNarrowPhaseBetweenShapes(CollisionCallback* call
(shape1->getCollisionCategoryBits() & shape2->getCollideWithMaskBits()) == 0) || (shape1->getCollisionCategoryBits() & shape2->getCollideWithMaskBits()) == 0) ||
!m_broadPhaseAlgorithm.testOverlappingShapes(shape1, shape2)) { !m_broadPhaseAlgorithm.testOverlappingShapes(shape1, shape2)) {
std::map<overlappingpairid, OverlappingPair*>::iterator itToRemove = it; etk::Map<overlappingpairid, OverlappingPair*>::iterator itToRemove = it;
++it; ++it;
// TODO : Remove all the contact manifold of the overlapping pair from the contact manifolds list of the two bodies involved // TODO : Remove all the contact manifold of the overlapping pair from the contact manifolds list of the two bodies involved
@ -357,7 +357,7 @@ void CollisionDetection::broadPhaseNotifyOverlappingPair(ProxyShape* shape1, Pro
assert(newPair != NULL); assert(newPair != NULL);
#ifndef NDEBUG #ifndef NDEBUG
std::pair<map<overlappingpairid, OverlappingPair*>::iterator, bool> check = etk::Pair<map<overlappingpairid, OverlappingPair*>::iterator, bool> check =
#endif #endif
m_overlappingPairs.insert(make_pair(pairID, newPair)); m_overlappingPairs.insert(make_pair(pairID, newPair));
assert(check.second); assert(check.second);
@ -371,11 +371,11 @@ void CollisionDetection::broadPhaseNotifyOverlappingPair(ProxyShape* shape1, Pro
void CollisionDetection::removeProxyCollisionShape(ProxyShape* proxyShape) { void CollisionDetection::removeProxyCollisionShape(ProxyShape* proxyShape) {
// Remove all the overlapping pairs involving this proxy shape // Remove all the overlapping pairs involving this proxy shape
std::map<overlappingpairid, OverlappingPair*>::iterator it; etk::Map<overlappingpairid, OverlappingPair*>::iterator it;
for (it = m_overlappingPairs.begin(); it != m_overlappingPairs.end(); ) { for (it = m_overlappingPairs.begin(); it != m_overlappingPairs.end(); ) {
if (it->second->getShape1()->m_broadPhaseID == proxyShape->m_broadPhaseID|| if (it->second->getShape1()->m_broadPhaseID == proxyShape->m_broadPhaseID||
it->second->getShape2()->m_broadPhaseID == proxyShape->m_broadPhaseID) { it->second->getShape2()->m_broadPhaseID == proxyShape->m_broadPhaseID) {
std::map<overlappingpairid, OverlappingPair*>::iterator itToRemove = it; etk::Map<overlappingpairid, OverlappingPair*>::iterator itToRemove = it;
++it; ++it;
// TODO : Remove all the contact manifold of the overlapping pair from the contact manifolds list of the two bodies involved // TODO : Remove all the contact manifold of the overlapping pair from the contact manifolds list of the two bodies involved
@ -431,7 +431,7 @@ void CollisionDetection::createContact(OverlappingPair* overlappingPair,
void CollisionDetection::addAllContactManifoldsToBodies() { void CollisionDetection::addAllContactManifoldsToBodies() {
// For each overlapping pairs in contact during the narrow-phase // For each overlapping pairs in contact during the narrow-phase
std::map<overlappingpairid, OverlappingPair*>::iterator it; etk::Map<overlappingpairid, OverlappingPair*>::iterator it;
for (it = m_contactOverlappingPairs.begin(); it != m_contactOverlappingPairs.end(); ++it) { for (it = m_contactOverlappingPairs.begin(); it != m_contactOverlappingPairs.end(); ++it) {
// Add all the contact manifolds of the pair int32_to the list of contact manifolds // Add all the contact manifolds of the pair int32_to the list of contact manifolds
@ -479,7 +479,7 @@ void CollisionDetection::addContactManifoldToBody(OverlappingPair* pair) {
void CollisionDetection::clearContactPoints() { void CollisionDetection::clearContactPoints() {
// For each overlapping pair // For each overlapping pair
std::map<overlappingpairid, OverlappingPair*>::iterator it; etk::Map<overlappingpairid, OverlappingPair*>::iterator it;
for (it = m_overlappingPairs.begin(); it != m_overlappingPairs.end(); ++it) { for (it = m_overlappingPairs.begin(); it != m_overlappingPairs.end(); ++it) {
it->second->clearContactPoints(); it->second->clearContactPoints();
} }

8
ephysics/collision/CollisionDetection.hpp
View File

@ -12,8 +12,8 @@
#include <ephysics/collision/narrowphase/DefaultCollisionDispatch.hpp> #include <ephysics/collision/narrowphase/DefaultCollisionDispatch.hpp>
#include <ephysics/memory/MemoryAllocator.hpp> #include <ephysics/memory/MemoryAllocator.hpp>
#include <ephysics/constraint/ContactPoint.hpp> #include <ephysics/constraint/ContactPoint.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <map> #include <etk/Map.hpp>
#include <set> #include <set>
#include <utility> #include <utility>
@ -51,8 +51,8 @@ namespace ephysics {
NarrowPhaseAlgorithm* m_collisionMatrix[NB_COLLISION_SHAPE_TYPES][NB_COLLISION_SHAPE_TYPES]; //!< Collision detection matrix (algorithms to use) NarrowPhaseAlgorithm* m_collisionMatrix[NB_COLLISION_SHAPE_TYPES][NB_COLLISION_SHAPE_TYPES]; //!< Collision detection matrix (algorithms to use)
MemoryAllocator& m_memoryAllocator; //!< Reference to the memory allocator MemoryAllocator& m_memoryAllocator; //!< Reference to the memory allocator
CollisionWorld* m_world; //!< Pointer to the physics world CollisionWorld* m_world; //!< Pointer to the physics world
std::map<overlappingpairid, OverlappingPair*> m_overlappingPairs; //!< Broad-phase overlapping pairs etk::Map<overlappingpairid, OverlappingPair*> m_overlappingPairs; //!< Broad-phase overlapping pairs
std::map<overlappingpairid, OverlappingPair*> m_contactOverlappingPairs; //!< Overlapping pairs in contact (during the current Narrow-phase collision detection) etk::Map<overlappingpairid, OverlappingPair*> m_contactOverlappingPairs; //!< Overlapping pairs in contact (during the current Narrow-phase collision detection)
BroadPhaseAlgorithm m_broadPhaseAlgorithm; //!< Broad-phase algorithm BroadPhaseAlgorithm m_broadPhaseAlgorithm; //!< Broad-phase algorithm
// TODO : Delete this // TODO : Delete this
GJKAlgorithm m_narrowPhaseGJKAlgorithm; //!< Narrow-phase GJK algorithm GJKAlgorithm m_narrowPhaseGJKAlgorithm; //!< Narrow-phase GJK algorithm

2
ephysics/collision/ContactManifold.hpp
View File

@ -5,7 +5,7 @@
*/ */
#pragma once #pragma once
#include <vector> #include <etk/Vector.hpp>
#include <ephysics/body/CollisionBody.hpp> #include <ephysics/body/CollisionBody.hpp>
#include <ephysics/collision/ProxyShape.hpp> #include <ephysics/collision/ProxyShape.hpp>
#include <ephysics/constraint/ContactPoint.hpp> #include <ephysics/constraint/ContactPoint.hpp>

6
ephysics/collision/TriangleMesh.hpp
View File

@ -4,7 +4,7 @@
* @license BSD 3 clauses (see license file) * @license BSD 3 clauses (see license file)
*/ */
#pragma once #pragma once
#include <vector> #include <etk/Vector.hpp>
#include <cassert> #include <cassert>
#include <ephysics/collision/TriangleVertexArray.hpp> #include <ephysics/collision/TriangleVertexArray.hpp>
@ -18,7 +18,7 @@ namespace ephysics {
*/ */
class TriangleMesh { class TriangleMesh {
protected: protected:
std::vector<TriangleVertexArray*> m_triangleArrays; //!< All the triangle arrays of the mesh (one triangle array per part) etk::Vector<TriangleVertexArray*> m_triangleArrays; //!< All the triangle arrays of the mesh (one triangle array per part)
public: public:
/** /**
* @brief Constructor * @brief Constructor
@ -32,7 +32,7 @@ namespace ephysics {
* @brief Add a subpart of the mesh * @brief Add a subpart of the mesh
*/ */
void addSubpart(TriangleVertexArray* _triangleVertexArray) { void addSubpart(TriangleVertexArray* _triangleVertexArray) {
m_triangleArrays.push_back(_triangleVertexArray ); m_triangleArrays.pushBack(_triangleVertexArray );
} }
/** /**
* @brief Get a pointer to a given subpart (triangle vertex array) of the mesh * @brief Get a pointer to a given subpart (triangle vertex array) of the mesh

6
ephysics/collision/TriangleVertexArray.cpp
View File

@ -8,7 +8,7 @@
#include <ephysics/collision/TriangleVertexArray.hpp> #include <ephysics/collision/TriangleVertexArray.hpp>
ephysics::TriangleVertexArray::TriangleVertexArray(const std::vector<vec3>& _vertices, std::vector<size_t> _triangles): ephysics::TriangleVertexArray::TriangleVertexArray(const etk::Vector<vec3>& _vertices, etk::Vector<size_t> _triangles):
m_vertices(_vertices), m_vertices(_vertices),
m_triangles(_triangles) { m_triangles(_triangles) {
@ -22,11 +22,11 @@ size_t ephysics::TriangleVertexArray::getNbTriangles() const {
return m_triangles.size()/3; return m_triangles.size()/3;
} }
const std::vector<vec3>& ephysics::TriangleVertexArray::getVertices() const { const etk::Vector<vec3>& ephysics::TriangleVertexArray::getVertices() const {
return m_vertices; return m_vertices;
} }
const std::vector<size_t>& ephysics::TriangleVertexArray::getIndices() const{ const etk::Vector<size_t>& ephysics::TriangleVertexArray::getIndices() const{
return m_triangles; return m_triangles;
} }

12
ephysics/collision/TriangleVertexArray.hpp
View File

@ -27,16 +27,16 @@ namespace ephysics {
*/ */
class TriangleVertexArray { class TriangleVertexArray {
protected: protected:
std::vector<vec3> m_vertices; //!< Vertice list etk::Vector<vec3> m_vertices; //!< Vertice list
std::vector<size_t> m_triangles; //!< List of triangle (3 pos for each triangle) etk::Vector<size_t> m_triangles; //!< List of triangle (3 pos for each triangle)
public: public:
/** /**
* @brief Constructor * @brief Constructor
* @param[in] _vertices List Of all vertices * @param[in] _vertices List Of all vertices
* @param[in] _triangles List of all linked points * @param[in] _triangles List of all linked points
*/ */
TriangleVertexArray(const std::vector<vec3>& _vertices, TriangleVertexArray(const etk::Vector<vec3>& _vertices,
std::vector<size_t> _triangles); etk::Vector<size_t> _triangles);
/** /**
* @brief Get the number of vertices * @brief Get the number of vertices
* @return Number of vertices * @return Number of vertices
@ -51,12 +51,12 @@ namespace ephysics {
* @brief Get The table of the vertices * @brief Get The table of the vertices
* @return reference on the vertices * @return reference on the vertices
*/ */
const std::vector<vec3>& getVertices() const; const etk::Vector<vec3>& getVertices() const;
/** /**
* @brief Get The table of the triangle indice * @brief Get The table of the triangle indice
* @return reference on the triangle indice * @return reference on the triangle indice
*/ */
const std::vector<size_t>& getIndices() const; const etk::Vector<size_t>& getIndices() const;
/** /**
* @brief Get a triangle at the specific ID * @brief Get a triangle at the specific ID
* @return Buffer of 3 points * @return Buffer of 3 points

4
ephysics/collision/broadphase/BroadPhaseAlgorithm.cpp
View File

@ -225,8 +225,8 @@ void BroadPhaseAlgorithm::notifyOverlappingNodes(int32_t node1ID, int32_t node2I
} }
// Add the new potential pair int32_to the array of potential overlapping pairs // Add the new potential pair int32_to the array of potential overlapping pairs
m_potentialPairs[m_numberPotentialPairs].collisionShape1ID = std::min(node1ID, node2ID); m_potentialPairs[m_numberPotentialPairs].collisionShape1ID = etk::min(node1ID, node2ID);
m_potentialPairs[m_numberPotentialPairs].collisionShape2ID = std::max(node1ID, node2ID); m_potentialPairs[m_numberPotentialPairs].collisionShape2ID = etk::max(node1ID, node2ID);
m_numberPotentialPairs++; m_numberPotentialPairs++;
} }

2
ephysics/collision/broadphase/BroadPhaseAlgorithm.hpp
View File

@ -5,7 +5,7 @@
*/ */
#pragma once #pragma once
#include <vector> #include <etk/Vector.hpp>
#include <ephysics/body/CollisionBody.hpp> #include <ephysics/body/CollisionBody.hpp>
#include <ephysics/collision/ProxyShape.hpp> #include <ephysics/collision/ProxyShape.hpp>
#include <ephysics/collision/broadphase/DynamicAABBTree.hpp> #include <ephysics/collision/broadphase/DynamicAABBTree.hpp>

24
ephysics/collision/broadphase/DynamicAABBTree.cpp
View File

@ -314,7 +314,7 @@ void DynamicAABBTree::insertLeafNode(int32_t _nodeID) {
assert(rightChild != TreeNode::NULL_TREE_NODE); assert(rightChild != TreeNode::NULL_TREE_NODE);
// Recompute the height of the node in the tree // Recompute the height of the node in the tree
m_nodes[currentNodeID].height = std::max(m_nodes[leftChild].height, m_nodes[currentNodeID].height = etk::max(m_nodes[leftChild].height,
m_nodes[rightChild].height) + 1; m_nodes[rightChild].height) + 1;
assert(m_nodes[currentNodeID].height > 0); assert(m_nodes[currentNodeID].height > 0);
@ -380,7 +380,7 @@ void DynamicAABBTree::removeLeafNode(int32_t _nodeID) {
// Recompute the AABB and the height of the current node // Recompute the AABB and the height of the current node
m_nodes[currentNodeID].aabb.mergeTwoAABBs(m_nodes[leftChildID].aabb, m_nodes[currentNodeID].aabb.mergeTwoAABBs(m_nodes[leftChildID].aabb,
m_nodes[rightChildID].aabb); m_nodes[rightChildID].aabb);
m_nodes[currentNodeID].height = std::max(m_nodes[leftChildID].height, m_nodes[currentNodeID].height = etk::max(m_nodes[leftChildID].height,
m_nodes[rightChildID].height) + 1; m_nodes[rightChildID].height) + 1;
assert(m_nodes[currentNodeID].height > 0); assert(m_nodes[currentNodeID].height > 0);
@ -468,8 +468,8 @@ int32_t DynamicAABBTree::balanceSubTreeAtNode(int32_t _nodeID) {
nodeC->aabb.mergeTwoAABBs(nodeA->aabb, nodeF->aabb); nodeC->aabb.mergeTwoAABBs(nodeA->aabb, nodeF->aabb);
// Recompute the height of node A and C // Recompute the height of node A and C
nodeA->height = std::max(nodeB->height, nodeG->height) + 1; nodeA->height = etk::max(nodeB->height, nodeG->height) + 1;
nodeC->height = std::max(nodeA->height, nodeF->height) + 1; nodeC->height = etk::max(nodeA->height, nodeF->height) + 1;
assert(nodeA->height > 0); assert(nodeA->height > 0);
assert(nodeC->height > 0); assert(nodeC->height > 0);
} }
@ -483,8 +483,8 @@ int32_t DynamicAABBTree::balanceSubTreeAtNode(int32_t _nodeID) {
nodeC->aabb.mergeTwoAABBs(nodeA->aabb, nodeG->aabb); nodeC->aabb.mergeTwoAABBs(nodeA->aabb, nodeG->aabb);
// Recompute the height of node A and C // Recompute the height of node A and C
nodeA->height = std::max(nodeB->height, nodeF->height) + 1; nodeA->height = etk::max(nodeB->height, nodeF->height) + 1;
nodeC->height = std::max(nodeA->height, nodeG->height) + 1; nodeC->height = etk::max(nodeA->height, nodeG->height) + 1;
assert(nodeA->height > 0); assert(nodeA->height > 0);
assert(nodeC->height > 0); assert(nodeC->height > 0);
} }
@ -538,8 +538,8 @@ int32_t DynamicAABBTree::balanceSubTreeAtNode(int32_t _nodeID) {
nodeB->aabb.mergeTwoAABBs(nodeA->aabb, nodeF->aabb); nodeB->aabb.mergeTwoAABBs(nodeA->aabb, nodeF->aabb);
// Recompute the height of node A and B // Recompute the height of node A and B
nodeA->height = std::max(nodeC->height, nodeG->height) + 1; nodeA->height = etk::max(nodeC->height, nodeG->height) + 1;
nodeB->height = std::max(nodeA->height, nodeF->height) + 1; nodeB->height = etk::max(nodeA->height, nodeF->height) + 1;
assert(nodeA->height > 0); assert(nodeA->height > 0);
assert(nodeB->height > 0); assert(nodeB->height > 0);
} }
@ -553,8 +553,8 @@ int32_t DynamicAABBTree::balanceSubTreeAtNode(int32_t _nodeID) {
nodeB->aabb.mergeTwoAABBs(nodeA->aabb, nodeG->aabb); nodeB->aabb.mergeTwoAABBs(nodeA->aabb, nodeG->aabb);
// Recompute the height of node A and B // Recompute the height of node A and B
nodeA->height = std::max(nodeC->height, nodeF->height) + 1; nodeA->height = etk::max(nodeC->height, nodeF->height) + 1;
nodeB->height = std::max(nodeA->height, nodeG->height) + 1; nodeB->height = etk::max(nodeA->height, nodeG->height) + 1;
assert(nodeA->height > 0); assert(nodeA->height > 0);
assert(nodeB->height > 0); assert(nodeB->height > 0);
} }
@ -781,7 +781,7 @@ void DynamicAABBTree::checkNode(int32_t _nodeID) const {
assert(m_nodes[rightChild].parentID == _nodeID); assert(m_nodes[rightChild].parentID == _nodeID);
// Check the height of node // Check the height of node
int32_t height = 1 + std::max(m_nodes[leftChild].height, m_nodes[rightChild].height); int32_t height = 1 + etk::max(m_nodes[leftChild].height, m_nodes[rightChild].height);
assert(m_nodes[_nodeID].height == height); assert(m_nodes[_nodeID].height == height);
// Check the AABB of the node // Check the AABB of the node
@ -816,7 +816,7 @@ int32_t DynamicAABBTree::computeHeight(int32_t _nodeID) {
int32_t rightHeight = computeHeight(node->children[1]); int32_t rightHeight = computeHeight(node->children[1]);
// Return the height of the node // Return the height of the node
return 1 + std::max(leftHeight, rightHeight); return 1 + etk::max(leftHeight, rightHeight);
} }
#endif #endif

8
ephysics/collision/narrowphase/ConcaveVsConvexAlgorithm.cpp
View File

@ -63,7 +63,7 @@ void ConcaveVsConvexAlgorithm::testCollision(const CollisionShapeInfo& shape1Inf
// If smooth mesh collision is enabled for the concave mesh // If smooth mesh collision is enabled for the concave mesh
if (concaveShape->getIsSmoothMeshCollisionEnabled()) { if (concaveShape->getIsSmoothMeshCollisionEnabled()) {
std::vector<SmoothMeshContactInfo> contactPoints; etk::Vector<SmoothMeshContactInfo> contactPoints;
SmoothCollisionNarrowPhaseCallback smoothNarrowPhaseCallback(contactPoints); SmoothCollisionNarrowPhaseCallback smoothNarrowPhaseCallback(contactPoints);
@ -116,7 +116,7 @@ void ConvexVsTriangleCallback::testTriangle(const vec3* trianglePoints) {
// by Pierre Terdiman (http://www.codercorner.com/MeshContacts.pdf). This is used to avoid the collision // by Pierre Terdiman (http://www.codercorner.com/MeshContacts.pdf). This is used to avoid the collision
// issue with some int32_ternal edges. // issue with some int32_ternal edges.
void ConcaveVsConvexAlgorithm::processSmoothMeshCollision(OverlappingPair* overlappingPair, void ConcaveVsConvexAlgorithm::processSmoothMeshCollision(OverlappingPair* overlappingPair,
std::vector<SmoothMeshContactInfo> contactPoints, etk::Vector<SmoothMeshContactInfo> contactPoints,
NarrowPhaseCallback* narrowPhaseCallback) { NarrowPhaseCallback* narrowPhaseCallback) {
// Set with the triangle vertices already processed to void further contacts with same triangle // Set with the triangle vertices already processed to void further contacts with same triangle
@ -126,7 +126,7 @@ void ConcaveVsConvexAlgorithm::processSmoothMeshCollision(OverlappingPair* overl
std::sort(contactPoints.begin(), contactPoints.end(), ContactsDepthCompare()); std::sort(contactPoints.begin(), contactPoints.end(), ContactsDepthCompare());
// For each contact point (from smaller penetration depth to larger) // For each contact point (from smaller penetration depth to larger)
std::vector<SmoothMeshContactInfo>::const_iterator it; etk::Vector<SmoothMeshContactInfo>::const_iterator it;
for (it = contactPoints.begin(); it != contactPoints.end(); ++it) { for (it = contactPoints.begin(); it != contactPoints.end(); ++it) {
const SmoothMeshContactInfo info = *it; const SmoothMeshContactInfo info = *it;
@ -268,5 +268,5 @@ void SmoothCollisionNarrowPhaseCallback::notifyContact(OverlappingPair* overlapp
// Add the narrow-phase contact int32_to the list of contact to process for // Add the narrow-phase contact int32_to the list of contact to process for
// smooth mesh collision // smooth mesh collision
m_contactPoints.push_back(smoothContactInfo); m_contactPoints.pushBack(smoothContactInfo);
} }

8
ephysics/collision/narrowphase/ConcaveVsConvexAlgorithm.hpp
View File

@ -94,10 +94,10 @@ namespace ephysics {
*/ */
class SmoothCollisionNarrowPhaseCallback : public NarrowPhaseCallback { class SmoothCollisionNarrowPhaseCallback : public NarrowPhaseCallback {
private: private:
std::vector<SmoothMeshContactInfo>& m_contactPoints; etk::Vector<SmoothMeshContactInfo>& m_contactPoints;
public: public:
// Constructor // Constructor
SmoothCollisionNarrowPhaseCallback(std::vector<SmoothMeshContactInfo>& _contactPoints): SmoothCollisionNarrowPhaseCallback(etk::Vector<SmoothMeshContactInfo>& _contactPoints):
m_contactPoints(_contactPoints) { m_contactPoints(_contactPoints) {
} }
@ -119,11 +119,11 @@ namespace ephysics {
ConcaveVsConvexAlgorithm& operator=(const ConcaveVsConvexAlgorithm& _algorithm); ConcaveVsConvexAlgorithm& operator=(const ConcaveVsConvexAlgorithm& _algorithm);
/// Process the concave triangle mesh collision using the smooth mesh collision algorithm /// Process the concave triangle mesh collision using the smooth mesh collision algorithm
void processSmoothMeshCollision(OverlappingPair* _overlappingPair, void processSmoothMeshCollision(OverlappingPair* _overlappingPair,
std::vector<SmoothMeshContactInfo> _contactPoints, etk::Vector<SmoothMeshContactInfo> _contactPoints,
NarrowPhaseCallback* _narrowPhaseCallback); NarrowPhaseCallback* _narrowPhaseCallback);
/// Add a triangle vertex int32_to the set of processed triangles /// Add a triangle vertex int32_to the set of processed triangles
void addProcessedVertex(std::unordered_multimap<int32_t, vec3>& _processTriangleVertices, const vec3& _vertex) { void addProcessedVertex(std::unordered_multimap<int32_t, vec3>& _processTriangleVertices, const vec3& _vertex) {
_processTriangleVertices.insert(std::make_pair(int32_t(_vertex.x() * _vertex.y() * _vertex.z()), _vertex)); _processTriangleVertices.insert(etk::makePair(int32_t(_vertex.x() * _vertex.y() * _vertex.z()), _vertex));
} }
/// Return true if the vertex is in the set of already processed vertices /// Return true if the vertex is in the set of already processed vertices
bool hasVertexBeenProcessed(const std::unordered_multimap<int32_t, vec3>& _processTriangleVertices, bool hasVertexBeenProcessed(const std::unordered_multimap<int32_t, vec3>& _processTriangleVertices,

2
ephysics/collision/narrowphase/EPA/EPAAlgorithm.cpp
View File

@ -377,7 +377,7 @@ void EPAAlgorithm::computePenetrationDepthAndContactPoints(const Simplex& simple
// Compute the error // Compute the error
float error = wDotv - triangle->getDistSquare(); float error = wDotv - triangle->getDistSquare();
if (error <= std::max(tolerance, REL_ERROR_SQUARE * wDotv) || if (error <= etk::max(tolerance, REL_ERROR_SQUARE * wDotv) ||
points[indexNewVertex] == points[(*triangle)[0]] || points[indexNewVertex] == points[(*triangle)[0]] ||
points[indexNewVertex] == points[(*triangle)[1]] || points[indexNewVertex] == points[(*triangle)[1]] ||
points[indexNewVertex] == points[(*triangle)[2]]) { points[indexNewVertex] == points[(*triangle)[2]]) {

2
ephysics/collision/narrowphase/GJK/Simplex.hpp
View File

@ -7,7 +7,7 @@
// Libraries // Libraries
#include <ephysics/mathematics/mathematics.hpp> #include <ephysics/mathematics/mathematics.hpp>
#include <vector> #include <etk/Vector.hpp>
/// ReactPhysics3D namespace /// ReactPhysics3D namespace
namespace ephysics { namespace ephysics {

24
ephysics/collision/shapes/AABB.cpp
View File

@ -32,21 +32,21 @@ AABB::AABB(const AABB& _aabb):
} }
void AABB::mergeWithAABB(const AABB& _aabb) { void AABB::mergeWithAABB(const AABB& _aabb) {
m_minCoordinates.setX(std::min(m_minCoordinates.x(), _aabb.m_minCoordinates.x())); m_minCoordinates.setX(etk::min(m_minCoordinates.x(), _aabb.m_minCoordinates.x()));
m_minCoordinates.setY(std::min(m_minCoordinates.y(), _aabb.m_minCoordinates.y())); m_minCoordinates.setY(etk::min(m_minCoordinates.y(), _aabb.m_minCoordinates.y()));
m_minCoordinates.setZ(std::min(m_minCoordinates.z(), _aabb.m_minCoordinates.z())); m_minCoordinates.setZ(etk::min(m_minCoordinates.z(), _aabb.m_minCoordinates.z()));
m_maxCoordinates.setX(std::max(m_maxCoordinates.x(), _aabb.m_maxCoordinates.x())); m_maxCoordinates.setX(etk::max(m_maxCoordinates.x(), _aabb.m_maxCoordinates.x()));
m_maxCoordinates.setY(std::max(m_maxCoordinates.y(), _aabb.m_maxCoordinates.y())); m_maxCoordinates.setY(etk::max(m_maxCoordinates.y(), _aabb.m_maxCoordinates.y()));
m_maxCoordinates.setZ(std::max(m_maxCoordinates.z(), _aabb.m_maxCoordinates.z())); m_maxCoordinates.setZ(etk::max(m_maxCoordinates.z(), _aabb.m_maxCoordinates.z()));
} }
void AABB::mergeTwoAABBs(const AABB& _aabb1, const AABB& _aabb2) { void AABB::mergeTwoAABBs(const AABB& _aabb1, const AABB& _aabb2) {
m_minCoordinates.setX(std::min(_aabb1.m_minCoordinates.x(), _aabb2.m_minCoordinates.x())); m_minCoordinates.setX(etk::min(_aabb1.m_minCoordinates.x(), _aabb2.m_minCoordinates.x()));
m_minCoordinates.setY(std::min(_aabb1.m_minCoordinates.y(), _aabb2.m_minCoordinates.y())); m_minCoordinates.setY(etk::min(_aabb1.m_minCoordinates.y(), _aabb2.m_minCoordinates.y()));
m_minCoordinates.setZ(std::min(_aabb1.m_minCoordinates.z(), _aabb2.m_minCoordinates.z())); m_minCoordinates.setZ(etk::min(_aabb1.m_minCoordinates.z(), _aabb2.m_minCoordinates.z()));
m_maxCoordinates.setX(std::max(_aabb1.m_maxCoordinates.x(), _aabb2.m_maxCoordinates.x())); m_maxCoordinates.setX(etk::max(_aabb1.m_maxCoordinates.x(), _aabb2.m_maxCoordinates.x()));
m_maxCoordinates.setY(std::max(_aabb1.m_maxCoordinates.y(), _aabb2.m_maxCoordinates.y())); m_maxCoordinates.setY(etk::max(_aabb1.m_maxCoordinates.y(), _aabb2.m_maxCoordinates.y()));
m_maxCoordinates.setZ(std::max(_aabb1.m_maxCoordinates.z(), _aabb2.m_maxCoordinates.z())); m_maxCoordinates.setZ(etk::max(_aabb1.m_maxCoordinates.z(), _aabb2.m_maxCoordinates.z()));
} }
bool AABB::contains(const AABB& _aabb) const { bool AABB::contains(const AABB& _aabb) const {

4
ephysics/collision/shapes/BoxShape.cpp
View File

@ -8,7 +8,7 @@
#include <ephysics/collision/shapes/BoxShape.hpp> #include <ephysics/collision/shapes/BoxShape.hpp>
#include <ephysics/collision/ProxyShape.hpp> #include <ephysics/collision/ProxyShape.hpp>
#include <ephysics/configuration.hpp> #include <ephysics/configuration.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <cassert> #include <cassert>
using namespace ephysics; using namespace ephysics;
@ -83,7 +83,7 @@ bool BoxShape::raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* pro
tMin = t1; tMin = t1;
normalDirection = currentNormal; normalDirection = currentNormal;
} }
tMax = std::min(tMax, t2); tMax = etk::min(tMax, t2);
// If tMin is larger than the maximum raycasting fraction, we return no hit // If tMin is larger than the maximum raycasting fraction, we return no hit
if (tMin > ray.maxFraction) return false; if (tMin > ray.maxFraction) return false;

4
ephysics/collision/shapes/ConcaveMeshShape.cpp
View File

@ -74,12 +74,12 @@ bool ConcaveMeshShape::raycast(const Ray& _ray, RaycastInfo& _raycastInfo, Proxy
float ConcaveMeshRaycastCallback::raycastBroadPhaseShape(int32_t _nodeId, const Ray& _ray) { float ConcaveMeshRaycastCallback::raycastBroadPhaseShape(int32_t _nodeId, const Ray& _ray) {
// Add the id of the hit AABB node int32_to // Add the id of the hit AABB node int32_to
m_hitAABBNodes.push_back(_nodeId); m_hitAABBNodes.pushBack(_nodeId);
return _ray.maxFraction; return _ray.maxFraction;
} }
void ConcaveMeshRaycastCallback::raycastTriangles() { void ConcaveMeshRaycastCallback::raycastTriangles() {
std::vector<int32_t>::const_iterator it; etk::Vector<int32_t>::const_iterator it;
float smallestHitFraction = m_ray.maxFraction; float smallestHitFraction = m_ray.maxFraction;
for (it = m_hitAABBNodes.begin(); it != m_hitAABBNodes.end(); ++it) { for (it = m_hitAABBNodes.begin(); it != m_hitAABBNodes.end(); ++it) {
// Get the node data (triangle index and mesh subpart index) // Get the node data (triangle index and mesh subpart index)

2
ephysics/collision/shapes/ConcaveMeshShape.hpp
View File

@ -35,7 +35,7 @@ namespace ephysics {
class ConcaveMeshRaycastCallback : public DynamicAABBTreeRaycastCallback { class ConcaveMeshRaycastCallback : public DynamicAABBTreeRaycastCallback {
private : private :
std::vector<int32_t> m_hitAABBNodes; etk::Vector<int32_t> m_hitAABBNodes;
const DynamicAABBTree& m_dynamicAABBTree; const DynamicAABBTree& m_dynamicAABBTree;
const ConcaveMeshShape& m_concaveMeshShape; const ConcaveMeshShape& m_concaveMeshShape;
ProxyShape* m_proxyShape; ProxyShape* m_proxyShape;

10
ephysics/collision/shapes/ConvexMeshShape.cpp
View File

@ -30,7 +30,7 @@ ConvexMeshShape::ConvexMeshShape(const float* arrayVertices, uint32_t nbVertices
// Copy all the vertices int32_to the int32_ternal array // Copy all the vertices int32_to the int32_ternal array
for (uint32_t i=0; i<m_numberVertices; i++) { for (uint32_t i=0; i<m_numberVertices; i++) {
const float* newPoint = (const float*) vertexPointer; const float* newPoint = (const float*) vertexPointer;
m_vertices.push_back(vec3(newPoint[0], newPoint[1], newPoint[2])); m_vertices.pushBack(vec3(newPoint[0], newPoint[1], newPoint[2]));
vertexPointer += stride; vertexPointer += stride;
} }
@ -45,7 +45,7 @@ ConvexMeshShape::ConvexMeshShape(TriangleVertexArray* _triangleVertexArray, bool
m_isEdgesInformationUsed(_isEdgesInformationUsed) { m_isEdgesInformationUsed(_isEdgesInformationUsed) {
// For each vertex of the mesh // For each vertex of the mesh
for (auto &it: _triangleVertexArray->getVertices()) { for (auto &it: _triangleVertexArray->getVertices()) {
m_vertices.push_back(it*m_scaling); m_vertices.pushBack(it*m_scaling);
} }
// If we need to use the edges information of the mesh // If we need to use the edges information of the mesh
if (m_isEdgesInformationUsed) { if (m_isEdgesInformationUsed) {
@ -256,7 +256,7 @@ void ConvexMeshShape::computeLocalInertiaTensor(etk::Matrix3x3& tensor, float ma
void ConvexMeshShape::addVertex(const vec3& vertex) { void ConvexMeshShape::addVertex(const vec3& vertex) {
// Add the vertex in to vertices array // Add the vertex in to vertices array
m_vertices.push_back(vertex); m_vertices.pushBack(vertex);
m_numberVertices++; m_numberVertices++;
// Update the bounds of the mesh // Update the bounds of the mesh
@ -292,12 +292,12 @@ void ConvexMeshShape::addEdge(uint32_t v1, uint32_t v2) {
// If the entry for vertex v1 does not exist in the adjacency list // If the entry for vertex v1 does not exist in the adjacency list
if (m_edgesAdjacencyList.count(v1) == 0) { if (m_edgesAdjacencyList.count(v1) == 0) {
m_edgesAdjacencyList.insert(std::make_pair(v1, std::set<uint32_t>())); m_edgesAdjacencyList.insert(etk::makePair(v1, std::set<uint32_t>()));
} }
// If the entry for vertex v2 does not exist in the adjacency list // If the entry for vertex v2 does not exist in the adjacency list
if (m_edgesAdjacencyList.count(v2) == 0) { if (m_edgesAdjacencyList.count(v2) == 0) {
m_edgesAdjacencyList.insert(std::make_pair(v2, std::set<uint32_t>())); m_edgesAdjacencyList.insert(etk::makePair(v2, std::set<uint32_t>()));
} }
// Add the edge in the adjacency list // Add the edge in the adjacency list

8
ephysics/collision/shapes/ConvexMeshShape.hpp
View File

@ -10,9 +10,9 @@
#include <ephysics/mathematics/mathematics.hpp> #include <ephysics/mathematics/mathematics.hpp>
#include <ephysics/collision/TriangleMesh.hpp> #include <ephysics/collision/TriangleMesh.hpp>
#include <ephysics/collision/narrowphase/GJK/GJKAlgorithm.hpp> #include <ephysics/collision/narrowphase/GJK/GJKAlgorithm.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <set> #include <set>
#include <map> #include <etk/Map.hpp>
namespace ephysics { namespace ephysics {
class CollisionWorld; class CollisionWorld;
@ -33,12 +33,12 @@ namespace ephysics {
*/ */
class ConvexMeshShape : public ConvexShape { class ConvexMeshShape : public ConvexShape {
protected : protected :
std::vector<vec3> m_vertices; //!< Array with the vertices of the mesh etk::Vector<vec3> m_vertices; //!< Array with the vertices of the mesh
uint32_t m_numberVertices; //!< Number of vertices in the mesh uint32_t m_numberVertices; //!< Number of vertices in the mesh
vec3 m_minBounds; //!< Mesh minimum bounds in the three local x, y and z directions vec3 m_minBounds; //!< Mesh minimum bounds in the three local x, y and z directions
vec3 m_maxBounds; //!< Mesh maximum bounds in the three local x, y and z directions vec3 m_maxBounds; //!< Mesh maximum bounds in the three local x, y and z directions
bool m_isEdgesInformationUsed; //!< True if the shape contains the edges of the convex mesh in order to make the collision detection faster bool m_isEdgesInformationUsed; //!< True if the shape contains the edges of the convex mesh in order to make the collision detection faster
std::map<uint32_t, std::set<uint32_t> > m_edgesAdjacencyList; //!< Adjacency list representing the edges of the mesh etk::Map<uint32_t, std::set<uint32_t> > m_edgesAdjacencyList; //!< Adjacency list representing the edges of the mesh
/// Private copy-constructor /// Private copy-constructor
ConvexMeshShape(const ConvexMeshShape& _shape); ConvexMeshShape(const ConvexMeshShape& _shape);
/// Private assignment operator /// Private assignment operator

2
ephysics/configuration.hpp
View File

@ -15,7 +15,7 @@
namespace ephysics { namespace ephysics {
// ------------------- Type definitions ------------------- // // ------------------- Type definitions ------------------- //
typedef uint64_t bodyindex; typedef uint64_t bodyindex;
typedef std::pair<bodyindex, bodyindex> bodyindexpair; typedef etk::Pair<bodyindex, bodyindex> bodyindexpair;
// ------------------- Enumerations ------------------- // // ------------------- Enumerations ------------------- //

4
ephysics/constraint/HingeJoint.cpp
View File

@ -313,7 +313,7 @@ void HingeJoint::solveVelocityConstraint(const ConstraintSolverData& constraintS
// Compute the Lagrange multiplier lambda for the lower limit constraint // Compute the Lagrange multiplier lambda for the lower limit constraint
float deltaLambdaLower = m_inverseMassMatrixLimitMotor * (-JvLowerLimit -m_bLowerLimit); float deltaLambdaLower = m_inverseMassMatrixLimitMotor * (-JvLowerLimit -m_bLowerLimit);
float lambdaTemp = m_impulseLowerLimit; float lambdaTemp = m_impulseLowerLimit;
m_impulseLowerLimit = std::max(m_impulseLowerLimit + deltaLambdaLower, 0.0f); m_impulseLowerLimit = etk::max(m_impulseLowerLimit + deltaLambdaLower, 0.0f);
deltaLambdaLower = m_impulseLowerLimit - lambdaTemp; deltaLambdaLower = m_impulseLowerLimit - lambdaTemp;
// Compute the impulse P=J^T * lambda for the lower limit constraint of body 1 // Compute the impulse P=J^T * lambda for the lower limit constraint of body 1
@ -338,7 +338,7 @@ void HingeJoint::solveVelocityConstraint(const ConstraintSolverData& constraintS
// Compute the Lagrange multiplier lambda for the upper limit constraint // Compute the Lagrange multiplier lambda for the upper limit constraint
float deltaLambdaUpper = m_inverseMassMatrixLimitMotor * (-JvUpperLimit -m_bUpperLimit); float deltaLambdaUpper = m_inverseMassMatrixLimitMotor * (-JvUpperLimit -m_bUpperLimit);
float lambdaTemp = m_impulseUpperLimit; float lambdaTemp = m_impulseUpperLimit;
m_impulseUpperLimit = std::max(m_impulseUpperLimit + deltaLambdaUpper, 0.0f); m_impulseUpperLimit = etk::max(m_impulseUpperLimit + deltaLambdaUpper, 0.0f);
deltaLambdaUpper = m_impulseUpperLimit - lambdaTemp; deltaLambdaUpper = m_impulseUpperLimit - lambdaTemp;
// Compute the impulse P=J^T * lambda for the upper limit constraint of body 1 // Compute the impulse P=J^T * lambda for the upper limit constraint of body 1

4
ephysics/constraint/SliderJoint.cpp
View File

@ -330,7 +330,7 @@ void SliderJoint::solveVelocityConstraint(const ConstraintSolverData& constraint
// Compute the Lagrange multiplier lambda for the lower limit constraint // Compute the Lagrange multiplier lambda for the lower limit constraint
float deltaLambdaLower = m_inverseMassMatrixLimit * (-JvLowerLimit -m_bLowerLimit); float deltaLambdaLower = m_inverseMassMatrixLimit * (-JvLowerLimit -m_bLowerLimit);
float lambdaTemp = m_impulseLowerLimit; float lambdaTemp = m_impulseLowerLimit;
m_impulseLowerLimit = std::max(m_impulseLowerLimit + deltaLambdaLower, 0.0f); m_impulseLowerLimit = etk::max(m_impulseLowerLimit + deltaLambdaLower, 0.0f);
deltaLambdaLower = m_impulseLowerLimit - lambdaTemp; deltaLambdaLower = m_impulseLowerLimit - lambdaTemp;
// Compute the impulse P=J^T * lambda for the lower limit constraint of body 1 // Compute the impulse P=J^T * lambda for the lower limit constraint of body 1
@ -360,7 +360,7 @@ void SliderJoint::solveVelocityConstraint(const ConstraintSolverData& constraint
// Compute the Lagrange multiplier lambda for the upper limit constraint // Compute the Lagrange multiplier lambda for the upper limit constraint
float deltaLambdaUpper = m_inverseMassMatrixLimit * (-JvUpperLimit -m_bUpperLimit); float deltaLambdaUpper = m_inverseMassMatrixLimit * (-JvUpperLimit -m_bUpperLimit);
float lambdaTemp = m_impulseUpperLimit; float lambdaTemp = m_impulseUpperLimit;
m_impulseUpperLimit = std::max(m_impulseUpperLimit + deltaLambdaUpper, 0.0f); m_impulseUpperLimit = etk::max(m_impulseUpperLimit + deltaLambdaUpper, 0.0f);
deltaLambdaUpper = m_impulseUpperLimit - lambdaTemp; deltaLambdaUpper = m_impulseUpperLimit - lambdaTemp;
// Compute the impulse P=J^T * lambda for the upper limit constraint of body 1 // Compute the impulse P=J^T * lambda for the upper limit constraint of body 1

4
ephysics/engine/CollisionWorld.cpp
View File

@ -69,7 +69,7 @@ void CollisionWorld::destroyCollisionBody(CollisionBody* collisionBody) {
collisionBody->removeAllCollisionShapes(); collisionBody->removeAllCollisionShapes();
// Add the body ID to the list of free IDs // Add the body ID to the list of free IDs
m_freeBodiesIDs.push_back(collisionBody->getID()); m_freeBodiesIDs.pushBack(collisionBody->getID());
// Call the destructor of the collision body // Call the destructor of the collision body
collisionBody->~CollisionBody(); collisionBody->~CollisionBody();
@ -88,7 +88,7 @@ bodyindex CollisionWorld::computeNextAvailableBodyID() {
bodyindex bodyID; bodyindex bodyID;
if (!m_freeBodiesIDs.empty()) { if (!m_freeBodiesIDs.empty()) {
bodyID = m_freeBodiesIDs.back(); bodyID = m_freeBodiesIDs.back();
m_freeBodiesIDs.pop_back(); m_freeBodiesIDs.popBack();
} }
else { else {
bodyID = m_currentBodyID; bodyID = m_currentBodyID;

4
ephysics/engine/CollisionWorld.hpp
View File

@ -5,7 +5,7 @@
*/ */
#pragma once #pragma once
#include <vector> #include <etk/Vector.hpp>
#include <set> #include <set>
#include <list> #include <list>
#include <algorithm> #include <algorithm>
@ -32,7 +32,7 @@ namespace ephysics {
CollisionDetection m_collisionDetection; //!< Reference to the collision detection CollisionDetection m_collisionDetection; //!< Reference to the collision detection
std::set<CollisionBody*> m_bodies; //!< All the bodies (rigid and soft) of the world std::set<CollisionBody*> m_bodies; //!< All the bodies (rigid and soft) of the world
bodyindex m_currentBodyID; //!< Current body ID bodyindex m_currentBodyID; //!< Current body ID
std::vector<uint64_t> m_freeBodiesIDs; //!< List of free ID for rigid bodies etk::Vector<uint64_t> m_freeBodiesIDs; //!< List of free ID for rigid bodies
MemoryAllocator m_memoryAllocator; //!< Memory allocator MemoryAllocator m_memoryAllocator; //!< Memory allocator
EventListener* m_eventListener; //!< Pointer to an event listener object EventListener* m_eventListener; //!< Pointer to an event listener object
/// Private copy-constructor /// Private copy-constructor

2
ephysics/engine/ConstraintSolver.cpp
View File

@ -9,7 +9,7 @@
using namespace ephysics; using namespace ephysics;
ConstraintSolver::ConstraintSolver(const std::map<RigidBody*, uint32_t>& _mapBodyToVelocityIndex): ConstraintSolver::ConstraintSolver(const etk::Map<RigidBody*, uint32_t>& _mapBodyToVelocityIndex):
m_mapBodyToConstrainedVelocityIndex(_mapBodyToVelocityIndex), m_mapBodyToConstrainedVelocityIndex(_mapBodyToVelocityIndex),
m_isWarmStartingActive(true), m_isWarmStartingActive(true),
m_constraintSolverData(_mapBodyToVelocityIndex) { m_constraintSolverData(_mapBodyToVelocityIndex) {

10
ephysics/engine/ConstraintSolver.hpp
View File

@ -9,7 +9,7 @@
#include <ephysics/mathematics/mathematics.hpp> #include <ephysics/mathematics/mathematics.hpp>
#include <ephysics/constraint/Joint.hpp> #include <ephysics/constraint/Joint.hpp>
#include <ephysics/engine/Island.hpp> #include <ephysics/engine/Island.hpp>
#include <map> #include <etk/Map.hpp>
#include <set> #include <set>
namespace ephysics { namespace ephysics {
@ -24,10 +24,10 @@ namespace ephysics {
vec3* angularVelocities; //!< Array with the bodies angular velocities vec3* angularVelocities; //!< Array with the bodies angular velocities
vec3* positions; //!< Reference to the bodies positions vec3* positions; //!< Reference to the bodies positions
etk::Quaternion* orientations; //!< Reference to the bodies orientations etk::Quaternion* orientations; //!< Reference to the bodies orientations
const std::map<RigidBody*, uint32_t>& mapBodyToConstrainedVelocityIndex; //!< Reference to the map that associates rigid body to their index in the constrained velocities array const etk::Map<RigidBody*, uint32_t>& mapBodyToConstrainedVelocityIndex; //!< Reference to the map that associates rigid body to their index in the constrained velocities array
bool isWarmStartingActive; //!< True if warm starting of the solver is active bool isWarmStartingActive; //!< True if warm starting of the solver is active
/// Constructor /// Constructor
ConstraintSolverData(const std::map<RigidBody*, uint32_t>& refMapBodyToConstrainedVelocityIndex) ConstraintSolverData(const etk::Map<RigidBody*, uint32_t>& refMapBodyToConstrainedVelocityIndex)
:linearVelocities(NULL), angularVelocities(NULL), :linearVelocities(NULL), angularVelocities(NULL),
positions(NULL), orientations(NULL), positions(NULL), orientations(NULL),
mapBodyToConstrainedVelocityIndex(refMapBodyToConstrainedVelocityIndex){ mapBodyToConstrainedVelocityIndex(refMapBodyToConstrainedVelocityIndex){
@ -105,13 +105,13 @@ namespace ephysics {
*/ */
class ConstraintSolver { class ConstraintSolver {
private : private :
const std::map<RigidBody*, uint32_t>& m_mapBodyToConstrainedVelocityIndex; //!< Reference to the map that associates rigid body to their index in the constrained velocities array const etk::Map<RigidBody*, uint32_t>& m_mapBodyToConstrainedVelocityIndex; //!< Reference to the map that associates rigid body to their index in the constrained velocities array
float m_timeStep; //!< Current time step float m_timeStep; //!< Current time step
bool m_isWarmStartingActive; //!< True if the warm starting of the solver is active bool m_isWarmStartingActive; //!< True if the warm starting of the solver is active
ConstraintSolverData m_constraintSolverData; //!< Constraint solver data used to initialize and solve the constraints ConstraintSolverData m_constraintSolverData; //!< Constraint solver data used to initialize and solve the constraints
public : public :
/// Constructor /// Constructor
ConstraintSolver(const std::map<RigidBody*, uint32_t>& _mapBodyToVelocityIndex); ConstraintSolver(const etk::Map<RigidBody*, uint32_t>& _mapBodyToVelocityIndex);
/// Initialize the constraint solver for a given island /// Initialize the constraint solver for a given island
void initializeForIsland(float _dt, Island* _island); void initializeForIsland(float _dt, Island* _island);
/// Solve the constraints /// Solve the constraints

26
ephysics/engine/ContactSolver.cpp
View File

@ -20,7 +20,7 @@ const float ContactSolver::BETA_SPLIT_IMPULSE = float(0.2);
const float ContactSolver::SLOP= float(0.01); const float ContactSolver::SLOP= float(0.01);
// Constructor // Constructor
ContactSolver::ContactSolver(const std::map<RigidBody*, uint32_t>& mapBodyToVelocityIndex) ContactSolver::ContactSolver(const etk::Map<RigidBody*, uint32_t>& mapBodyToVelocityIndex)
:m_splitLinearVelocities(nullptr), m_splitAngularVelocities(nullptr), :m_splitLinearVelocities(nullptr), m_splitAngularVelocities(nullptr),
m_contactConstraints(nullptr), m_linearVelocities(nullptr), m_angularVelocities(nullptr), m_contactConstraints(nullptr), m_linearVelocities(nullptr), m_angularVelocities(nullptr),
m_mapBodyToConstrainedVelocityIndex(mapBodyToVelocityIndex), m_mapBodyToConstrainedVelocityIndex(mapBodyToVelocityIndex),
@ -534,7 +534,7 @@ void ContactSolver::solve() {
deltaLambda = - (Jv + b) * contactPoint.inversePenetrationMass; deltaLambda = - (Jv + b) * contactPoint.inversePenetrationMass;
} }
lambdaTemp = contactPoint.penetrationImpulse; lambdaTemp = contactPoint.penetrationImpulse;
contactPoint.penetrationImpulse = std::max(contactPoint.penetrationImpulse + contactPoint.penetrationImpulse = etk::max(contactPoint.penetrationImpulse +
deltaLambda, 0.0f); deltaLambda, 0.0f);
deltaLambda = contactPoint.penetrationImpulse - lambdaTemp; deltaLambda = contactPoint.penetrationImpulse - lambdaTemp;
@ -561,7 +561,7 @@ void ContactSolver::solve() {
float deltaLambdaSplit = - (JvSplit + biasPenetrationDepth) * float deltaLambdaSplit = - (JvSplit + biasPenetrationDepth) *
contactPoint.inversePenetrationMass; contactPoint.inversePenetrationMass;
float lambdaTempSplit = contactPoint.penetrationSplitImpulse; float lambdaTempSplit = contactPoint.penetrationSplitImpulse;
contactPoint.penetrationSplitImpulse = std::max( contactPoint.penetrationSplitImpulse = etk::max(
contactPoint.penetrationSplitImpulse + contactPoint.penetrationSplitImpulse +
deltaLambdaSplit, 0.0f); deltaLambdaSplit, 0.0f);
deltaLambda = contactPoint.penetrationSplitImpulse - lambdaTempSplit; deltaLambda = contactPoint.penetrationSplitImpulse - lambdaTempSplit;
@ -588,8 +588,8 @@ void ContactSolver::solve() {
float frictionLimit = contactManifold.frictionCoefficient * float frictionLimit = contactManifold.frictionCoefficient *
contactPoint.penetrationImpulse; contactPoint.penetrationImpulse;
lambdaTemp = contactPoint.friction1Impulse; lambdaTemp = contactPoint.friction1Impulse;
contactPoint.friction1Impulse = std::max(-frictionLimit, contactPoint.friction1Impulse = etk::max(-frictionLimit,
std::min(contactPoint.friction1Impulse etk::min(contactPoint.friction1Impulse
+ deltaLambda, frictionLimit)); + deltaLambda, frictionLimit));
deltaLambda = contactPoint.friction1Impulse - lambdaTemp; deltaLambda = contactPoint.friction1Impulse - lambdaTemp;
@ -612,8 +612,8 @@ void ContactSolver::solve() {
frictionLimit = contactManifold.frictionCoefficient * frictionLimit = contactManifold.frictionCoefficient *
contactPoint.penetrationImpulse; contactPoint.penetrationImpulse;
lambdaTemp = contactPoint.friction2Impulse; lambdaTemp = contactPoint.friction2Impulse;
contactPoint.friction2Impulse = std::max(-frictionLimit, contactPoint.friction2Impulse = etk::max(-frictionLimit,
std::min(contactPoint.friction2Impulse etk::min(contactPoint.friction2Impulse
+ deltaLambda, frictionLimit)); + deltaLambda, frictionLimit));
deltaLambda = contactPoint.friction2Impulse - lambdaTemp; deltaLambda = contactPoint.friction2Impulse - lambdaTemp;
@ -663,8 +663,8 @@ void ContactSolver::solve() {
float deltaLambda = -Jv * contactManifold.inverseFriction1Mass; float deltaLambda = -Jv * contactManifold.inverseFriction1Mass;
float frictionLimit = contactManifold.frictionCoefficient * sum_penetrationImpulse; float frictionLimit = contactManifold.frictionCoefficient * sum_penetrationImpulse;
lambdaTemp = contactManifold.friction1Impulse; lambdaTemp = contactManifold.friction1Impulse;
contactManifold.friction1Impulse = std::max(-frictionLimit, contactManifold.friction1Impulse = etk::max(-frictionLimit,
std::min(contactManifold.friction1Impulse + etk::min(contactManifold.friction1Impulse +
deltaLambda, frictionLimit)); deltaLambda, frictionLimit));
deltaLambda = contactManifold.friction1Impulse - lambdaTemp; deltaLambda = contactManifold.friction1Impulse - lambdaTemp;
@ -690,8 +690,8 @@ void ContactSolver::solve() {
deltaLambda = -Jv * contactManifold.inverseFriction2Mass; deltaLambda = -Jv * contactManifold.inverseFriction2Mass;
frictionLimit = contactManifold.frictionCoefficient * sum_penetrationImpulse; frictionLimit = contactManifold.frictionCoefficient * sum_penetrationImpulse;
lambdaTemp = contactManifold.friction2Impulse; lambdaTemp = contactManifold.friction2Impulse;
contactManifold.friction2Impulse = std::max(-frictionLimit, contactManifold.friction2Impulse = etk::max(-frictionLimit,
std::min(contactManifold.friction2Impulse + etk::min(contactManifold.friction2Impulse +
deltaLambda, frictionLimit)); deltaLambda, frictionLimit));
deltaLambda = contactManifold.friction2Impulse - lambdaTemp; deltaLambda = contactManifold.friction2Impulse - lambdaTemp;
@ -715,8 +715,8 @@ void ContactSolver::solve() {
deltaLambda = -Jv * (contactManifold.inverseTwistFrictionMass); deltaLambda = -Jv * (contactManifold.inverseTwistFrictionMass);
frictionLimit = contactManifold.frictionCoefficient * sum_penetrationImpulse; frictionLimit = contactManifold.frictionCoefficient * sum_penetrationImpulse;
lambdaTemp = contactManifold.frictionTwistImpulse; lambdaTemp = contactManifold.frictionTwistImpulse;
contactManifold.frictionTwistImpulse = std::max(-frictionLimit, contactManifold.frictionTwistImpulse = etk::max(-frictionLimit,
std::min(contactManifold.frictionTwistImpulse etk::min(contactManifold.frictionTwistImpulse
+ deltaLambda, frictionLimit)); + deltaLambda, frictionLimit));
deltaLambda = contactManifold.frictionTwistImpulse - lambdaTemp; deltaLambda = contactManifold.frictionTwistImpulse - lambdaTemp;

6
ephysics/engine/ContactSolver.hpp
View File

@ -11,7 +11,7 @@
#include <ephysics/collision/ContactManifold.hpp> #include <ephysics/collision/ContactManifold.hpp>
#include <ephysics/engine/Island.hpp> #include <ephysics/engine/Island.hpp>
#include <ephysics/engine/Impulse.hpp> #include <ephysics/engine/Impulse.hpp>
#include <map> #include <etk/Map.hpp>
#include <set> #include <set>
namespace ephysics { namespace ephysics {
@ -168,7 +168,7 @@ namespace ephysics {
uint32_t m_numberContactManifolds; //!< Number of contact constraints uint32_t m_numberContactManifolds; //!< Number of contact constraints
vec3* m_linearVelocities; //!< Array of linear velocities vec3* m_linearVelocities; //!< Array of linear velocities
vec3* m_angularVelocities; //!< Array of angular velocities vec3* m_angularVelocities; //!< Array of angular velocities
const std::map<RigidBody*, uint32_t>& m_mapBodyToConstrainedVelocityIndex; //!< Reference to the map of rigid body to their index in the constrained velocities array const etk::Map<RigidBody*, uint32_t>& m_mapBodyToConstrainedVelocityIndex; //!< Reference to the map of rigid body to their index in the constrained velocities array
bool m_isWarmStartingActive; //!< True if the warm starting of the solver is active bool m_isWarmStartingActive; //!< True if the warm starting of the solver is active
bool m_isSplitImpulseActive; //!< True if the split impulse position correction is active bool m_isSplitImpulseActive; //!< True if the split impulse position correction is active
bool m_isSolveFrictionAtContactManifoldCenterActive; //!< True if we solve 3 friction constraints at the contact manifold center only instead of 2 friction constraints at each contact point bool m_isSolveFrictionAtContactManifoldCenterActive; //!< True if we solve 3 friction constraints at the contact manifold center only instead of 2 friction constraints at each contact point
@ -208,7 +208,7 @@ namespace ephysics {
const ContactPointSolver& contactPoint) const; const ContactPointSolver& contactPoint) const;
public: public:
/// Constructor /// Constructor
ContactSolver(const std::map<RigidBody*, uint32_t>& mapBodyToVelocityIndex); ContactSolver(const etk::Map<RigidBody*, uint32_t>& mapBodyToVelocityIndex);
/// Destructor /// Destructor
virtual ~ContactSolver(); virtual ~ContactSolver();
/// Initialize the constraint solver for a given island /// Initialize the constraint solver for a given island

12
ephysics/engine/DynamicsWorld.cpp
View File

@ -267,7 +267,7 @@ void DynamicsWorld::initVelocityArrays() {
for (it = m_rigidBodies.begin(); it != m_rigidBodies.end(); ++it) { for (it = m_rigidBodies.begin(); it != m_rigidBodies.end(); ++it) {
// Add the body int32_to the map // Add the body int32_to the map
m_mapBodyToConstrainedVelocityIndex.insert(std::make_pair(*it, indexBody)); m_mapBodyToConstrainedVelocityIndex.insert(etk::makePair(*it, indexBody));
indexBody++; indexBody++;
} }
} }
@ -457,7 +457,7 @@ void DynamicsWorld::destroyRigidBody(RigidBody* rigidBody) {
rigidBody->removeAllCollisionShapes(); rigidBody->removeAllCollisionShapes();
// Add the body ID to the list of free IDs // Add the body ID to the list of free IDs
m_freeBodiesIDs.push_back(rigidBody->getID()); m_freeBodiesIDs.pushBack(rigidBody->getID());
// Destroy all the joints in which the rigid body to be destroyed is involved // Destroy all the joints in which the rigid body to be destroyed is involved
JointListElement* element; JointListElement* element;
@ -960,12 +960,12 @@ void DynamicsWorld::testCollision(CollisionCallback* callback) {
} }
/// Return the list of all contacts of the world /// Return the list of all contacts of the world
std::vector<const ContactManifold*> DynamicsWorld::getContactsList() const { etk::Vector<const ContactManifold*> DynamicsWorld::getContactsList() const {
std::vector<const ContactManifold*> contactManifolds; etk::Vector<const ContactManifold*> contactManifolds;
// For each currently overlapping pair of bodies // For each currently overlapping pair of bodies
std::map<overlappingpairid, OverlappingPair*>::const_iterator it; etk::Map<overlappingpairid, OverlappingPair*>::const_iterator it;
for (it = m_collisionDetection.m_overlappingPairs.begin(); for (it = m_collisionDetection.m_overlappingPairs.begin();
it != m_collisionDetection.m_overlappingPairs.end(); ++it) { it != m_collisionDetection.m_overlappingPairs.end(); ++it) {
@ -978,7 +978,7 @@ std::vector<const ContactManifold*> DynamicsWorld::getContactsList() const {
ContactManifold* manifold = manifoldSet.getContactManifold(i); ContactManifold* manifold = manifoldSet.getContactManifold(i);
// Get the contact manifold // Get the contact manifold
contactManifolds.push_back(manifold); contactManifolds.pushBack(manifold);
} }
} }

4
ephysics/engine/DynamicsWorld.hpp
View File

@ -37,7 +37,7 @@ namespace ephysics {
vec3* m_splitAngularVelocities; //!< Split angular velocities for the position contact solver (split impulse) vec3* m_splitAngularVelocities; //!< Split angular velocities for the position contact solver (split impulse)
vec3* m_constrainedPositions; //!< Array of constrained rigid bodies position (for position error correction) vec3* m_constrainedPositions; //!< Array of constrained rigid bodies position (for position error correction)
etk::Quaternion* m_constrainedOrientations; //!< Array of constrained rigid bodies orientation (for position error correction) etk::Quaternion* m_constrainedOrientations; //!< Array of constrained rigid bodies orientation (for position error correction)
std::map<RigidBody*, uint32_t> m_mapBodyToConstrainedVelocityIndex; //!< Map body to their index in the constrained velocities array etk::Map<RigidBody*, uint32_t> m_mapBodyToConstrainedVelocityIndex; //!< Map body to their index in the constrained velocities array
uint32_t m_numberIslands; //!< Number of islands in the world uint32_t m_numberIslands; //!< Number of islands in the world
uint32_t m_numberIslandsCapacity; //!< Current allocated capacity for the islands uint32_t m_numberIslandsCapacity; //!< Current allocated capacity for the islands
Island** m_islands; //!< Array with all the islands of awaken bodies Island** m_islands; //!< Array with all the islands of awaken bodies
@ -155,7 +155,7 @@ namespace ephysics {
/// Test and report collisions between all shapes of the world /// Test and report collisions between all shapes of the world
virtual void testCollision(CollisionCallback* _callback) override; virtual void testCollision(CollisionCallback* _callback) override;
/// Return the list of all contacts of the world /// Return the list of all contacts of the world
std::vector<const ContactManifold*> getContactsList() const; etk::Vector<const ContactManifold*> getContactsList() const;
friend class RigidBody; friend class RigidBody;
}; };

8
ephysics/engine/OverlappingPair.cpp
View File

@ -64,8 +64,8 @@ overlappingpairid OverlappingPair::computeID(ProxyShape* _shape1, ProxyShape* _s
// Construct the pair of body index // Construct the pair of body index
overlappingpairid pairID = _shape1->m_broadPhaseID < _shape2->m_broadPhaseID ? overlappingpairid pairID = _shape1->m_broadPhaseID < _shape2->m_broadPhaseID ?
std::make_pair(_shape1->m_broadPhaseID, _shape2->m_broadPhaseID) : etk::makePair(_shape1->m_broadPhaseID, _shape2->m_broadPhaseID) :
std::make_pair(_shape2->m_broadPhaseID, _shape1->m_broadPhaseID); etk::makePair(_shape2->m_broadPhaseID, _shape1->m_broadPhaseID);
assert(pairID.first != pairID.second); assert(pairID.first != pairID.second);
return pairID; return pairID;
} }
@ -76,8 +76,8 @@ bodyindexpair OverlappingPair::computeBodiesIndexPair(CollisionBody* _body1,
// Construct the pair of body index // Construct the pair of body index
bodyindexpair indexPair = _body1->getID() < _body2->getID() ? bodyindexpair indexPair = _body1->getID() < _body2->getID() ?
std::make_pair(_body1->getID(), _body2->getID()) : etk::makePair(_body1->getID(), _body2->getID()) :
std::make_pair(_body2->getID(), _body1->getID()); etk::makePair(_body2->getID(), _body1->getID());
assert(indexPair.first != indexPair.second); assert(indexPair.first != indexPair.second);
return indexPair; return indexPair;
} }

2
ephysics/engine/OverlappingPair.hpp
View File

@ -10,7 +10,7 @@
namespace ephysics { namespace ephysics {
// Type for the overlapping pair ID // Type for the overlapping pair ID
typedef std::pair<uint32_t, uint32_t> overlappingpairid; typedef etk::Pair<uint32_t, uint32_t> overlappingpairid;
/** /**
* @brief This class represents a pair of two proxy collision shapes that are overlapping * @brief This class represents a pair of two proxy collision shapes that are overlapping
* during the broad-phase collision detection. It is created when * during the broad-phase collision detection. It is created when

4
ephysics/engine/Profiler.cpp
View File

@ -171,7 +171,7 @@ void Profiler::reset() {
} }
// Print32_t the report of the profiler in a given output stream // Print32_t the report of the profiler in a given output stream
void Profiler::print32_tReport(std::ostream& outputStream) { void Profiler::print32_tReport(etk::Stream& outputStream) {
ProfileNodeIterator* iterator = Profiler::getIterator(); ProfileNodeIterator* iterator = Profiler::getIterator();
// Recursively print32_t the report of each node of the profiler tree // Recursively print32_t the report of each node of the profiler tree
@ -184,7 +184,7 @@ void Profiler::print32_tReport(std::ostream& outputStream) {
// Recursively print32_t the report of a given node of the profiler tree // Recursively print32_t the report of a given node of the profiler tree
void Profiler::print32_tRecursiveNodeReport(ProfileNodeIterator* iterator, void Profiler::print32_tRecursiveNodeReport(ProfileNodeIterator* iterator,
int32_t spacing, int32_t spacing,
std::ostream& outputStream) { etk::Stream& outputStream) {
iterator->first(); iterator->first();
// If we are at the end of a branch in the profiler tree // If we are at the end of a branch in the profiler tree

4
ephysics/engine/Profiler.hpp
View File

@ -99,7 +99,7 @@ namespace ephysics {
private: private:
static void print32_tRecursiveNodeReport(ProfileNodeIterator* iterator, static void print32_tRecursiveNodeReport(ProfileNodeIterator* iterator,
int32_t spacing, int32_t spacing,
std::ostream& outputStream); etk::Stream& outputStream);
public : public :
/// Method called when we want to start profiling a block of code. /// Method called when we want to start profiling a block of code.
static void startProfilingBlock(const char *name); static void startProfilingBlock(const char *name);
@ -117,7 +117,7 @@ namespace ephysics {
/// Return an iterator over the profiler tree starting at the root /// Return an iterator over the profiler tree starting at the root
static ProfileNodeIterator* getIterator(); static ProfileNodeIterator* getIterator();
/// Print32_t the report of the profiler in a given output stream /// Print32_t the report of the profiler in a given output stream
static void print32_tReport(std::ostream& outputStream); static void print32_tReport(etk::Stream& outputStream);
/// Destroy a previously allocated iterator /// Destroy a previously allocated iterator
static void destroyIterator(ProfileNodeIterator* iterator); static void destroyIterator(ProfileNodeIterator* iterator);
/// Destroy the profiler (release the memory) /// Destroy the profiler (release the memory)

2
ephysics/mathematics/mathematics.hpp
View File

@ -15,7 +15,7 @@
#include <ephysics/mathematics/Ray.hpp> #include <ephysics/mathematics/Ray.hpp>
#include <ephysics/configuration.hpp> #include <ephysics/configuration.hpp>
#include <ephysics/mathematics/mathematics_functions.hpp> #include <ephysics/mathematics/mathematics_functions.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <cstdio> #include <cstdio>
#include <cassert> #include <cassert>
#include <cmath> #include <cmath>

8
ephysics/mathematics/mathematics_functions.hpp
View File

@ -28,24 +28,24 @@ inline bool approxEqual(float a, float b, float epsilon = MACHINE_EPSILON) {
/// two others values "lowerLimit" and "upperLimit" /// two others values "lowerLimit" and "upperLimit"
inline int32_t clamp(int32_t value, int32_t lowerLimit, int32_t upperLimit) { inline int32_t clamp(int32_t value, int32_t lowerLimit, int32_t upperLimit) {
assert(lowerLimit <= upperLimit); assert(lowerLimit <= upperLimit);
return std::min(std::max(value, lowerLimit), upperLimit); return etk::min(etk::max(value, lowerLimit), upperLimit);
} }
/// Function that returns the result of the "value" clamped by /// Function that returns the result of the "value" clamped by
/// two others values "lowerLimit" and "upperLimit" /// two others values "lowerLimit" and "upperLimit"
inline float clamp(float value, float lowerLimit, float upperLimit) { inline float clamp(float value, float lowerLimit, float upperLimit) {
assert(lowerLimit <= upperLimit); assert(lowerLimit <= upperLimit);
return std::min(std::max(value, lowerLimit), upperLimit); return etk::min(etk::max(value, lowerLimit), upperLimit);
} }
/// Return the minimum value among three values /// Return the minimum value among three values
inline float min3(float a, float b, float c) { inline float min3(float a, float b, float c) {
return std::min(std::min(a, b), c); return etk::min(etk::min(a, b), c);
} }
/// Return the maximum value among three values /// Return the maximum value among three values
inline float max3(float a, float b, float c) { inline float max3(float a, float b, float c) {
return std::max(std::max(a, b), c); return etk::max(etk::max(a, b), c);
} }
/// Return true if two values have the same sign /// Return true if two values have the same sign

6
test/Test.cpp
View File

@ -31,7 +31,7 @@
using namespace ephysics; using namespace ephysics;
/// Constructor /// Constructor
Test::Test(const std::string& name, std::ostream* stream) Test::Test(const etk::String& name, etk::Stream* stream)
: m_name(name), mNbPassedTests(0), mNbFailedTests(0), mOutputStream(stream) { : m_name(name), mNbPassedTests(0), mNbFailedTests(0), mOutputStream(stream) {
} }
@ -43,7 +43,7 @@ Test::~Test() {
// Called to test a boolean condition. // Called to test a boolean condition.
// This method should not be called directly in your test but you should call test() instead (macro) // This method should not be called directly in your test but you should call test() instead (macro)
void Test::applyTest(bool condition, const std::string& testText, void Test::applyTest(bool condition, const etk::String& testText,
const char* filename, long lineNumber) { const char* filename, long lineNumber) {
// If the boolean condition is true // If the boolean condition is true
@ -61,7 +61,7 @@ void Test::applyTest(bool condition, const std::string& testText,
// Called when a test has failed. // Called when a test has failed.
// This method should not be called directly in your test buy you should call fail() instead (macro) // This method should not be called directly in your test buy you should call fail() instead (macro)
void Test::applyFail(const std::string& testText, const char* filename, long lineNumber) { void Test::applyFail(const etk::String& testText, const char* filename, long lineNumber) {
if (mOutputStream) { if (mOutputStream) {

20
test/Test.hpp
View File

@ -27,7 +27,7 @@
#define TEST_H #define TEST_H
// Libraries // Libraries
#include <string> #include <etk/String.hpp>
#include <iostream> #include <iostream>
#include <cassert> #include <cassert>
@ -51,7 +51,7 @@ class Test {
// ---------- Attributes ---------- // // ---------- Attributes ---------- //
/// Name of the test /// Name of the test
std::string m_name; etk::String m_name;
/// Number of tests that passed /// Number of tests that passed
long mNbPassedTests; long mNbPassedTests;
@ -60,7 +60,7 @@ class Test {
long mNbFailedTests; long mNbFailedTests;
/// Output stream /// Output stream
std::ostream* mOutputStream; etk::Stream* mOutputStream;
// ---------- Methods ---------- // // ---------- Methods ---------- //
@ -77,20 +77,20 @@ class Test {
/// Called to test a boolean condition. /// Called to test a boolean condition.
/// This method should not be called directly in your test but you should /// This method should not be called directly in your test but you should
/// call test() instead (macro) /// call test() instead (macro)
void applyTest(bool condition, const std::string& testText, void applyTest(bool condition, const etk::String& testText,
const char* filename, long lineNumber); const char* filename, long lineNumber);
/// Called when a test has failed. /// Called when a test has failed.
/// This method should not be called directly in your test buy you should /// This method should not be called directly in your test buy you should
/// call fail() instead (macro) /// call fail() instead (macro)
void applyFail(const std::string& testText, const char* filename, long lineNumber); void applyFail(const etk::String& testText, const char* filename, long lineNumber);
public : public :
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
Test(const std::string& name, std::ostream* stream = &std::cout); Test(const etk::String& name, etk::Stream* stream = &std::cout);
/// Destructor /// Destructor
virtual ~Test(); virtual ~Test();
@ -102,10 +102,10 @@ class Test {
long getNbFailedTests() const; long getNbFailedTests() const;
/// Return the output stream /// Return the output stream
const std::ostream* getOutputStream() const; const etk::Stream* getOutputStream() const;
/// Set the output stream /// Set the output stream
void setOutputStream(std::ostream *stream); void setOutputStream(etk::Stream *stream);
/// Run the unit test /// Run the unit test
virtual void run() = 0; virtual void run() = 0;
@ -142,12 +142,12 @@ inline long Test::getNbFailedTests() const {
} }
// Return the output stream // Return the output stream
inline const std::ostream* Test::getOutputStream() const { inline const etk::Stream* Test::getOutputStream() const {
return mOutputStream; return mOutputStream;
} }
// Set the output stream // Set the output stream
inline void Test::setOutputStream(std::ostream* stream) { inline void Test::setOutputStream(etk::Stream* stream) {
mOutputStream = stream; mOutputStream = stream;
} }

4
test/TestSuite.cpp
View File

@ -29,7 +29,7 @@
using namespace ephysics; using namespace ephysics;
// Constructor // Constructor
TestSuite::TestSuite(const std::string& name, std::ostream* outputStream) TestSuite::TestSuite(const etk::String& name, etk::Stream* outputStream)
: m_name(name), mOutputStream(outputStream) { : m_name(name), mOutputStream(outputStream) {
} }
@ -69,7 +69,7 @@ void TestSuite::addTest(Test* test) {
} }
// Add the test to the suite // Add the test to the suite
mTests.push_back(test); mTests.pushBack(test);
// Reset the added test // Reset the added test
test->reset(); test->reset();

22
test/TestSuite.hpp
View File

@ -28,7 +28,7 @@
// Libraries // Libraries
#include <test/Test.hpp> #include <test/Test.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <stdexcept> #include <stdexcept>
/// Reactphysics3D namespace /// Reactphysics3D namespace
@ -48,13 +48,13 @@ class TestSuite {
// ---------- Attributes ---------- // // ---------- Attributes ---------- //
/// Name of the test suite /// Name of the test suite
std::string m_name; etk::String m_name;
/// Output stream /// Output stream
std::ostream* mOutputStream; etk::Stream* mOutputStream;
/// All the tests of the test suite /// All the tests of the test suite
std::vector<Test*> mTests; etk::Vector<Test*> mTests;
// ---------- Methods ---------- // // ---------- Methods ---------- //
@ -72,10 +72,10 @@ class TestSuite {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
TestSuite(const std::string& name, std::ostream* outputStream = &std::cout); TestSuite(const etk::String& name, etk::Stream* outputStream = &std::cout);
/// Return the name of the test suite /// Return the name of the test suite
std::string getName() const; etk::String getName() const;
/// Return the number of passed tests /// Return the number of passed tests
long getNbPassedTests() const; long getNbPassedTests() const;
@ -84,10 +84,10 @@ class TestSuite {
long getNbFailedTests() const; long getNbFailedTests() const;
/// Return the output stream /// Return the output stream
const std::ostream* getOutputStream() const; const etk::Stream* getOutputStream() const;
/// Set the output stream /// Set the output stream
void setOutputStream(std::ostream* outputStream); void setOutputStream(etk::Stream* outputStream);
/// Add a unit test in the test suite /// Add a unit test in the test suite
void addTest(Test* test); void addTest(Test* test);
@ -107,17 +107,17 @@ class TestSuite {
}; };
// Return the name of the test suite // Return the name of the test suite
inline std::string TestSuite::getName() const { inline etk::String TestSuite::getName() const {
return m_name; return m_name;
} }
// Return the output stream // Return the output stream
inline const std::ostream* TestSuite::getOutputStream() const { inline const etk::Stream* TestSuite::getOutputStream() const {
return mOutputStream; return mOutputStream;
} }
// Set the output stream // Set the output stream
inline void TestSuite::setOutputStream(std::ostream* outputStream) { inline void TestSuite::setOutputStream(etk::Stream* outputStream) {
mOutputStream = outputStream; mOutputStream = outputStream;
} }

2
test/tests/collision/TestAABB.hpp
View File

@ -53,7 +53,7 @@ class TestAABB : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
TestAABB(const std::string& name) : Test(name) { TestAABB(const etk::String& name) : Test(name) {
m_AABB1.setMin(vec3(-10, -10, -10)); m_AABB1.setMin(vec3(-10, -10, -10));
m_AABB1.setMax(vec3(10, 10, 10)); m_AABB1.setMax(vec3(10, 10, 10));

2
test/tests/collision/TestCollisionWorld.hpp
View File

@ -133,7 +133,7 @@ class TestCollisionWorld : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
TestCollisionWorld(const std::string& name) : Test(name) { TestCollisionWorld(const etk::String& name) : Test(name) {
// Create the world // Create the world
m_world = new CollisionWorld(); m_world = new CollisionWorld();

12
test/tests/collision/TestDynamicAABBTree.hpp
View File

@ -29,7 +29,7 @@
// Libraries // Libraries
#include <test/Test.hpp> #include <test/Test.hpp>
#include <ephysics/collision/broadphase/DynamicAABBTree.hpp> #include <ephysics/collision/broadphase/DynamicAABBTree.hpp>
#include <vector> #include <etk/Vector.hpp>
/// Reactphysics3D namespace /// Reactphysics3D namespace
namespace ephysics { namespace ephysics {
@ -38,12 +38,12 @@ class OverlapCallback : public DynamicAABBTreeOverlapCallback {
public : public :
std::vector<int32_t> mOverlapNodes; etk::Vector<int32_t> mOverlapNodes;
// Called when a overlapping node has been found during the call to // Called when a overlapping node has been found during the call to
// DynamicAABBTree:reportAllShapesOverlappingWithAABB() // DynamicAABBTree:reportAllShapesOverlappingWithAABB()
virtual void notifyOverlappingNode(int32_t nodeId) { virtual void notifyOverlappingNode(int32_t nodeId) {
mOverlapNodes.push_back(nodeId); mOverlapNodes.pushBack(nodeId);
} }
void reset() { void reset() {
@ -59,11 +59,11 @@ class DynamicTreeRaycastCallback : public DynamicAABBTreeRaycastCallback {
public: public:
std::vector<int32_t> mHitNodes; etk::Vector<int32_t> mHitNodes;
// Called when the AABB of a leaf node is hit by a ray // Called when the AABB of a leaf node is hit by a ray
virtual float raycastBroadPhaseShape(int32_t nodeId, const Ray& ray) { virtual float raycastBroadPhaseShape(int32_t nodeId, const Ray& ray) {
mHitNodes.push_back(nodeId); mHitNodes.pushBack(nodeId);
return 1.0; return 1.0;
} }
@ -96,7 +96,7 @@ class TestDynamicAABBTree : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
TestDynamicAABBTree(const std::string& name): Test(name) { TestDynamicAABBTree(const etk::String& name): Test(name) {
} }

2
test/tests/collision/TestPointInside.hpp
View File

@ -90,7 +90,7 @@ class TestPointInside : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
TestPointInside(const std::string& name) : Test(name) { TestPointInside(const etk::String& name) : Test(name) {
// Create the world // Create the world
m_world = new CollisionWorld(); m_world = new CollisionWorld();

46
test/tests/collision/TestRaycast.hpp
View File

@ -155,8 +155,8 @@ class TestRaycast : public Test {
// Triangle meshes // Triangle meshes
TriangleMesh mConcaveTriangleMesh; TriangleMesh mConcaveTriangleMesh;
std::vector<vec3> mConcaveMeshVertices; etk::Vector<vec3> mConcaveMeshVertices;
std::vector<uint32_t> mConcaveMeshIndices; etk::Vector<uint32_t> mConcaveMeshIndices;
TriangleVertexArray* mConcaveMeshVertexArray; TriangleVertexArray* mConcaveMeshVertexArray;
float m_heightFieldData[100]; float m_heightFieldData[100];
@ -165,7 +165,7 @@ class TestRaycast : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
TestRaycast(const std::string& name) : Test(name) { TestRaycast(const etk::String& name) : Test(name) {
epsilon = float(0.0001); epsilon = float(0.0001);
@ -267,27 +267,27 @@ class TestRaycast : public Test {
mCompoundSphereProxyShape = mCompoundBody->addCollisionShape(mSphereShape, shapeTransform2); mCompoundSphereProxyShape = mCompoundBody->addCollisionShape(mSphereShape, shapeTransform2);
// Concave Mesh shape // Concave Mesh shape
mConcaveMeshVertices.push_back(vec3(-2, -3, -4)); mConcaveMeshVertices.pushBack(vec3(-2, -3, -4));
mConcaveMeshVertices.push_back(vec3(2, -3, -4)); mConcaveMeshVertices.pushBack(vec3(2, -3, -4));
mConcaveMeshVertices.push_back(vec3(2, -3, 4)); mConcaveMeshVertices.pushBack(vec3(2, -3, 4));
mConcaveMeshVertices.push_back(vec3(-2, -3, 4)); mConcaveMeshVertices.pushBack(vec3(-2, -3, 4));
mConcaveMeshVertices.push_back(vec3(-2, 3, -4)); mConcaveMeshVertices.pushBack(vec3(-2, 3, -4));
mConcaveMeshVertices.push_back(vec3(2, 3, -4)); mConcaveMeshVertices.pushBack(vec3(2, 3, -4));
mConcaveMeshVertices.push_back(vec3(2, 3, 4)); mConcaveMeshVertices.pushBack(vec3(2, 3, 4));
mConcaveMeshVertices.push_back(vec3(-2, 3, 4)); mConcaveMeshVertices.pushBack(vec3(-2, 3, 4));
mConcaveMeshIndices.push_back(0); mConcaveMeshIndices.push_back(1); mConcaveMeshIndices.push_back(2); mConcaveMeshIndices.pushBack(0); mConcaveMeshIndices.pushBack(1); mConcaveMeshIndices.push_back(2);
mConcaveMeshIndices.push_back(0); mConcaveMeshIndices.push_back(2); mConcaveMeshIndices.push_back(3); mConcaveMeshIndices.pushBack(0); mConcaveMeshIndices.pushBack(2); mConcaveMeshIndices.push_back(3);
mConcaveMeshIndices.push_back(1); mConcaveMeshIndices.push_back(5); mConcaveMeshIndices.push_back(2); mConcaveMeshIndices.pushBack(1); mConcaveMeshIndices.pushBack(5); mConcaveMeshIndices.push_back(2);
mConcaveMeshIndices.push_back(2); mConcaveMeshIndices.push_back(5); mConcaveMeshIndices.push_back(6); mConcaveMeshIndices.pushBack(2); mConcaveMeshIndices.pushBack(5); mConcaveMeshIndices.push_back(6);
mConcaveMeshIndices.push_back(2); mConcaveMeshIndices.push_back(7); mConcaveMeshIndices.push_back(3); mConcaveMeshIndices.pushBack(2); mConcaveMeshIndices.pushBack(7); mConcaveMeshIndices.push_back(3);
mConcaveMeshIndices.push_back(2); mConcaveMeshIndices.push_back(6); mConcaveMeshIndices.push_back(7); mConcaveMeshIndices.pushBack(2); mConcaveMeshIndices.pushBack(6); mConcaveMeshIndices.push_back(7);
mConcaveMeshIndices.push_back(0); mConcaveMeshIndices.push_back(3); mConcaveMeshIndices.push_back(4); mConcaveMeshIndices.pushBack(0); mConcaveMeshIndices.pushBack(3); mConcaveMeshIndices.push_back(4);
mConcaveMeshIndices.push_back(3); mConcaveMeshIndices.push_back(7); mConcaveMeshIndices.push_back(4); mConcaveMeshIndices.pushBack(3); mConcaveMeshIndices.pushBack(7); mConcaveMeshIndices.push_back(4);
mConcaveMeshIndices.push_back(0); mConcaveMeshIndices.push_back(4); mConcaveMeshIndices.push_back(1); mConcaveMeshIndices.pushBack(0); mConcaveMeshIndices.pushBack(4); mConcaveMeshIndices.push_back(1);
mConcaveMeshIndices.push_back(1); mConcaveMeshIndices.push_back(4); mConcaveMeshIndices.push_back(5); mConcaveMeshIndices.pushBack(1); mConcaveMeshIndices.pushBack(4); mConcaveMeshIndices.push_back(5);
mConcaveMeshIndices.push_back(5); mConcaveMeshIndices.push_back(7); mConcaveMeshIndices.push_back(6); mConcaveMeshIndices.pushBack(5); mConcaveMeshIndices.pushBack(7); mConcaveMeshIndices.push_back(6);
mConcaveMeshIndices.push_back(4); mConcaveMeshIndices.push_back(7); mConcaveMeshIndices.push_back(5); mConcaveMeshIndices.pushBack(4); mConcaveMeshIndices.pushBack(7); mConcaveMeshIndices.push_back(5);
TriangleVertexArray::VertexDataType vertexType = sizeof(float) == 4 ? TriangleVertexArray::VERTEX_FLOAT_TYPE : TriangleVertexArray::VertexDataType vertexType = sizeof(float) == 4 ? TriangleVertexArray::VERTEX_FLOAT_TYPE :
TriangleVertexArray::VERTEX_DOUBLE_TYPE; TriangleVertexArray::VERTEX_DOUBLE_TYPE;
mConcaveMeshVertexArray = mConcaveMeshVertexArray =

2
test/tests/mathematics/TestMathematicsFunctions.hpp
View File

@ -50,7 +50,7 @@ class TestMathematicsFunctions : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
TestMathematicsFunctions(const std::string& name): Test(name) {} TestMathematicsFunctions(const etk::String& name): Test(name) {}
/// Run the tests /// Run the tests
void run() { void run() {

2
test/tests/mathematics/TestMatrix2x2.h
View File

@ -54,7 +54,7 @@ class Testetk::Matrix2x2 : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
Testetk::Matrix2x2(const std::string& name) Testetk::Matrix2x2(const etk::String& name)
: Test(name), mIdentity(etk::Matrix2x2::identity()), mMatrix1(2, 24, -4, 5) { : Test(name), mIdentity(etk::Matrix2x2::identity()), mMatrix1(2, 24, -4, 5) {
} }

2
test/tests/mathematics/TestMatrix3x3.h
View File

@ -54,7 +54,7 @@ class Testetk::Matrix3x3 : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
Testetk::Matrix3x3(const std::string& name) Testetk::Matrix3x3(const etk::String& name)
: Test(name), mIdentity(etk::Matrix3x3::identity()), : Test(name), mIdentity(etk::Matrix3x3::identity()),
mMatrix1(2, 24, 4, 5, -6, 234, -15, 11, 66) { mMatrix1(2, 24, 4, 5, -6, 234, -15, 11, 66) {

2
test/tests/mathematics/TestQuaternion.h
View File

@ -54,7 +54,7 @@ class Testetk::Quaternion : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
Testetk::Quaternion(const std::string& name) : Test(name), mIdentity(Quaternion::identity()) { Testetk::Quaternion(const etk::String& name) : Test(name), mIdentity(Quaternion::identity()) {
float sinA = sin(float(PI/8.0)); float sinA = sin(float(PI/8.0));
float cosA = cos(float(PI/8.0)); float cosA = cos(float(PI/8.0));

2
test/tests/mathematics/TestTransform.h
View File

@ -57,7 +57,7 @@ class Testetk::Transform3D : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
Testetk::Transform3D(const std::string& name) : Test(name) { Testetk::Transform3D(const etk::String& name) : Test(name) {
mIdentityetk::Transform3D.setToIdentity(); mIdentityetk::Transform3D.setToIdentity();

2
test/tests/mathematics/TestVector2.h
View File

@ -54,7 +54,7 @@ class Testvec2 : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
Testvec2(const std::string& name) : Test(name), mVectorZero(0, 0), mvec34(3, 4) {} Testvec2(const etk::String& name) : Test(name), mVectorZero(0, 0), mvec34(3, 4) {}
/// Run the tests /// Run the tests
void run() { void run() {

2
test/tests/mathematics/TestVector3.h
View File

@ -54,7 +54,7 @@ class Testvec3 : public Test {
// ---------- Methods ---------- // // ---------- Methods ---------- //
/// Constructor /// Constructor
Testvec3(const std::string& name): Test(name),mVectorZero(0, 0, 0),mvec345(3, 4, 5) {} Testvec3(const etk::String& name): Test(name),mVectorZero(0, 0, 0),mvec345(3, 4, 5) {}
/// Run the tests /// Run the tests
void run() { void run() {

4
tools/testbed/common/Capsule.cpp
View File

@ -36,7 +36,7 @@ int32_t Capsule::totalNbCapsules = 0;
// Constructor // Constructor
Capsule::Capsule(float radius, float height, const openglframework::vec3& position, Capsule::Capsule(float radius, float height, const openglframework::vec3& position,
ephysics::CollisionWorld* world, ephysics::CollisionWorld* world,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: openglframework::Mesh(), mRadius(radius), mHeight(height) { : openglframework::Mesh(), mRadius(radius), mHeight(height) {
// Load the mesh from a file // Load the mesh from a file
@ -85,7 +85,7 @@ Capsule::Capsule(float radius, float height, const openglframework::vec3& positi
// Constructor // Constructor
Capsule::Capsule(float radius, float height, const openglframework::vec3& position, Capsule::Capsule(float radius, float height, const openglframework::vec3& position,
float mass, ephysics::DynamicsWorld* dynamicsWorld, float mass, ephysics::DynamicsWorld* dynamicsWorld,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: openglframework::Mesh(), mRadius(radius), mHeight(height) { : openglframework::Mesh(), mRadius(radius), mHeight(height) {
// Load the mesh from a file // Load the mesh from a file

4
tools/testbed/common/Capsule.h
View File

@ -83,12 +83,12 @@ class Capsule : public openglframework::Mesh, public PhysicsObject {
/// Constructor /// Constructor
Capsule(float radius, float height, const openglframework::vec3& position, Capsule(float radius, float height, const openglframework::vec3& position,
ephysics::CollisionWorld* world, const std::string& meshFolderPath); ephysics::CollisionWorld* world, const etk::String& meshFolderPath);
/// Constructor /// Constructor
Capsule(float radius, float height, const openglframework::vec3& position, Capsule(float radius, float height, const openglframework::vec3& position,
float mass, ephysics::DynamicsWorld* dynamicsWorld, float mass, ephysics::DynamicsWorld* dynamicsWorld,
const std::string& meshFolderPath); const etk::String& meshFolderPath);
/// Destructor /// Destructor
~Capsule(); ~Capsule();

4
tools/testbed/common/ConcaveMesh.cpp
View File

@ -29,7 +29,7 @@
// Constructor // Constructor
ConcaveMesh::ConcaveMesh(const openglframework::vec3 &position, ConcaveMesh::ConcaveMesh(const openglframework::vec3 &position,
ephysics::CollisionWorld* world, ephysics::CollisionWorld* world,
const std::string& meshPath) const etk::String& meshPath)
: openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER), : openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER),
mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER), mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER),
mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) { mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) {
@ -86,7 +86,7 @@ ConcaveMesh::ConcaveMesh(const openglframework::vec3 &position,
// Constructor // Constructor
ConcaveMesh::ConcaveMesh(const openglframework::vec3 &position, float mass, ConcaveMesh::ConcaveMesh(const openglframework::vec3 &position, float mass,
ephysics::DynamicsWorld* dynamicsWorld, ephysics::DynamicsWorld* dynamicsWorld,
const std::string& meshPath) const etk::String& meshPath)
: openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER), : openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER),
mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER), mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER),
mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) { mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) {

4
tools/testbed/common/ConcaveMesh.h
View File

@ -77,11 +77,11 @@ class ConcaveMesh : public openglframework::Mesh, public PhysicsObject {
/// Constructor /// Constructor
ConcaveMesh(const openglframework::vec3& position, ConcaveMesh(const openglframework::vec3& position,
ephysics::CollisionWorld* world, const std::string& meshPath); ephysics::CollisionWorld* world, const etk::String& meshPath);
/// Constructor /// Constructor
ConcaveMesh(const openglframework::vec3& position, float mass, ConcaveMesh(const openglframework::vec3& position, float mass,
ephysics::DynamicsWorld* dynamicsWorld, const std::string& meshPath); ephysics::DynamicsWorld* dynamicsWorld, const etk::String& meshPath);
/// Destructor /// Destructor
~ConcaveMesh(); ~ConcaveMesh();

4
tools/testbed/common/Cone.cpp
View File

@ -36,7 +36,7 @@ int32_t Cone::totalNbCones = 0;
// Constructor // Constructor
Cone::Cone(float radius, float height, const openglframework::vec3 &position, Cone::Cone(float radius, float height, const openglframework::vec3 &position,
ephysics::CollisionWorld* world, ephysics::CollisionWorld* world,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: openglframework::Mesh(), mRadius(radius), mHeight(height) { : openglframework::Mesh(), mRadius(radius), mHeight(height) {
// Load the mesh from a file // Load the mesh from a file
@ -84,7 +84,7 @@ Cone::Cone(float radius, float height, const openglframework::vec3 &position,
// Constructor // Constructor
Cone::Cone(float radius, float height, const openglframework::vec3 &position, Cone::Cone(float radius, float height, const openglframework::vec3 &position,
float mass, ephysics::DynamicsWorld* dynamicsWorld, float mass, ephysics::DynamicsWorld* dynamicsWorld,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: openglframework::Mesh(), mRadius(radius), mHeight(height) { : openglframework::Mesh(), mRadius(radius), mHeight(height) {
// Load the mesh from a file // Load the mesh from a file

4
tools/testbed/common/Cone.h
View File

@ -83,11 +83,11 @@ class Cone : public openglframework::Mesh, public PhysicsObject {
/// Constructor /// Constructor
Cone(float radius, float height, const openglframework::vec3& position, Cone(float radius, float height, const openglframework::vec3& position,
ephysics::CollisionWorld* world, const std::string& meshFolderPath); ephysics::CollisionWorld* world, const etk::String& meshFolderPath);
/// Constructor /// Constructor
Cone(float radius, float height, const openglframework::vec3& position, Cone(float radius, float height, const openglframework::vec3& position,
float mass, ephysics::DynamicsWorld* dynamicsWorld, const std::string& meshFolderPath); float mass, ephysics::DynamicsWorld* dynamicsWorld, const etk::String& meshFolderPath);
/// Destructor /// Destructor
~Cone(); ~Cone();

4
tools/testbed/common/ConvexMesh.cpp
View File

@ -29,7 +29,7 @@
// Constructor // Constructor
ConvexMesh::ConvexMesh(const openglframework::vec3 &position, ConvexMesh::ConvexMesh(const openglframework::vec3 &position,
ephysics::CollisionWorld* world, ephysics::CollisionWorld* world,
const std::string& meshPath) const etk::String& meshPath)
: openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER), : openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER),
mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER), mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER),
mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) { mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) {
@ -80,7 +80,7 @@ ConvexMesh::ConvexMesh(const openglframework::vec3 &position,
// Constructor // Constructor
ConvexMesh::ConvexMesh(const openglframework::vec3 &position, float mass, ConvexMesh::ConvexMesh(const openglframework::vec3 &position, float mass,
ephysics::DynamicsWorld* dynamicsWorld, ephysics::DynamicsWorld* dynamicsWorld,
const std::string& meshPath) const etk::String& meshPath)
: openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER), : openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER),
mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER), mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER),
mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) { mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) {

4
tools/testbed/common/ConvexMesh.h
View File

@ -76,11 +76,11 @@ class ConvexMesh : public openglframework::Mesh, public PhysicsObject {
/// Constructor /// Constructor
ConvexMesh(const openglframework::vec3& position, ConvexMesh(const openglframework::vec3& position,
ephysics::CollisionWorld* world, const std::string& meshPath); ephysics::CollisionWorld* world, const etk::String& meshPath);
/// Constructor /// Constructor
ConvexMesh(const openglframework::vec3& position, float mass, ConvexMesh(const openglframework::vec3& position, float mass,
ephysics::DynamicsWorld* dynamicsWorld, const std::string& meshPath); ephysics::DynamicsWorld* dynamicsWorld, const etk::String& meshPath);
/// Destructor /// Destructor
~ConvexMesh(); ~ConvexMesh();

4
tools/testbed/common/Cylinder.cpp
View File

@ -36,7 +36,7 @@ int32_t Cylinder::totalNbCylinders = 0;
// Constructor // Constructor
Cylinder::Cylinder(float radius, float height, const openglframework::vec3& position, Cylinder::Cylinder(float radius, float height, const openglframework::vec3& position,
ephysics::CollisionWorld* world, ephysics::CollisionWorld* world,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: openglframework::Mesh(), mRadius(radius), mHeight(height) { : openglframework::Mesh(), mRadius(radius), mHeight(height) {
// Load the mesh from a file // Load the mesh from a file
@ -84,7 +84,7 @@ Cylinder::Cylinder(float radius, float height, const openglframework::vec3& posi
// Constructor // Constructor
Cylinder::Cylinder(float radius, float height, const openglframework::vec3& position, Cylinder::Cylinder(float radius, float height, const openglframework::vec3& position,
float mass, ephysics::DynamicsWorld* dynamicsWorld, float mass, ephysics::DynamicsWorld* dynamicsWorld,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: openglframework::Mesh(), mRadius(radius), mHeight(height) { : openglframework::Mesh(), mRadius(radius), mHeight(height) {
// Load the mesh from a file // Load the mesh from a file

4
tools/testbed/common/Cylinder.h
View File

@ -83,11 +83,11 @@ class Cylinder : public openglframework::Mesh, public PhysicsObject {
/// Constructor /// Constructor
Cylinder(float radius, float height, const openglframework::vec3& position, Cylinder(float radius, float height, const openglframework::vec3& position,
ephysics::CollisionWorld* world, const std::string &meshFolderPath); ephysics::CollisionWorld* world, const etk::String &meshFolderPath);
/// Constructor /// Constructor
Cylinder(float radius, float height, const openglframework::vec3& position, Cylinder(float radius, float height, const openglframework::vec3& position,
float mass, ephysics::DynamicsWorld* dynamicsWorld, const std::string &meshFolderPath); float mass, ephysics::DynamicsWorld* dynamicsWorld, const etk::String &meshFolderPath);
/// Destructor /// Destructor
~Cylinder(); ~Cylinder();

4
tools/testbed/common/Dumbbell.cpp
View File

@ -35,7 +35,7 @@ int32_t Dumbbell::totalNbDumbbells = 0;
// Constructor // Constructor
Dumbbell::Dumbbell(const openglframework::vec3 &position, Dumbbell::Dumbbell(const openglframework::vec3 &position,
ephysics::DynamicsWorld* dynamicsWorld, const std::string& meshFolderPath) ephysics::DynamicsWorld* dynamicsWorld, const etk::String& meshFolderPath)
: openglframework::Mesh() { : openglframework::Mesh() {
// Load the mesh from a file // Load the mesh from a file
@ -106,7 +106,7 @@ Dumbbell::Dumbbell(const openglframework::vec3 &position,
// Constructor // Constructor
Dumbbell::Dumbbell(const openglframework::vec3 &position, Dumbbell::Dumbbell(const openglframework::vec3 &position,
ephysics::CollisionWorld* world, const std::string& meshFolderPath) ephysics::CollisionWorld* world, const etk::String& meshFolderPath)
: openglframework::Mesh() { : openglframework::Mesh() {
// Load the mesh from a file // Load the mesh from a file

4
tools/testbed/common/Dumbbell.h
View File

@ -83,11 +83,11 @@ class Dumbbell : public openglframework::Mesh, public PhysicsObject {
/// Constructor /// Constructor
Dumbbell(const openglframework::vec3& position, ephysics::DynamicsWorld* dynamicsWorld, Dumbbell(const openglframework::vec3& position, ephysics::DynamicsWorld* dynamicsWorld,
const std::string& meshFolderPath); const etk::String& meshFolderPath);
/// Constructor /// Constructor
Dumbbell(const openglframework::vec3& position, ephysics::CollisionWorld* world, Dumbbell(const openglframework::vec3& position, ephysics::CollisionWorld* world,
const std::string& meshFolderPath); const etk::String& meshFolderPath);
/// Destructor /// Destructor

18
tools/testbed/common/HeightField.cpp
View File

@ -224,7 +224,7 @@ void HeightField::generateHeightField() {
// Generate the graphics mesh to render the height field // Generate the graphics mesh to render the height field
void HeightField::generateGraphicsMesh() { void HeightField::generateGraphicsMesh() {
std::vector<uint32_t> indices; etk::Vector<uint32_t> indices;
int32_t vertexId = 0; int32_t vertexId = 0;
for (int32_t i=0; i<NB_POINTS_WIDTH; i++) { for (int32_t i=0; i<NB_POINTS_WIDTH; i++) {
@ -234,7 +234,7 @@ void HeightField::generateGraphicsMesh() {
float height = originHeight + mHeightData[j * NB_POINTS_WIDTH + i]; float height = originHeight + mHeightData[j * NB_POINTS_WIDTH + i];
openglframework::vec3 vertex(-(NB_POINTS_WIDTH - 1) * 0.5f + i, height, -(NB_POINTS_LENGTH - 1) * 0.5f + j); openglframework::vec3 vertex(-(NB_POINTS_WIDTH - 1) * 0.5f + i, height, -(NB_POINTS_LENGTH - 1) * 0.5f + j);
m_vertices.push_back(vertex); m_vertices.pushBack(vertex);
// Triangle indices // Triangle indices
if ((i < NB_POINTS_WIDTH - 1) && (j < NB_POINTS_LENGTH - 1)) { if ((i < NB_POINTS_WIDTH - 1) && (j < NB_POINTS_LENGTH - 1)) {
@ -245,21 +245,21 @@ void HeightField::generateGraphicsMesh() {
uint32_t v4 = vertexId + NB_POINTS_LENGTH + 1; uint32_t v4 = vertexId + NB_POINTS_LENGTH + 1;
// First triangle // First triangle
indices.push_back(v1); indices.pushBack(v1);
indices.push_back(v2); indices.pushBack(v2);
indices.push_back(v3); indices.pushBack(v3);
// Second triangle // Second triangle
indices.push_back(v2); indices.pushBack(v2);
indices.push_back(v4); indices.pushBack(v4);
indices.push_back(v3); indices.pushBack(v3);
} }
vertexId++; vertexId++;
} }
} }
mIndices.push_back(indices); mIndices.pushBack(indices);
calculateNormals(); calculateNormals();
} }

4
tools/testbed/common/Sphere.cpp
View File

@ -36,7 +36,7 @@ int32_t Sphere::totalNbSpheres = 0;
// Constructor // Constructor
Sphere::Sphere(float radius, const openglframework::vec3 &position, Sphere::Sphere(float radius, const openglframework::vec3 &position,
ephysics::CollisionWorld* world, ephysics::CollisionWorld* world,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: openglframework::Mesh(), mRadius(radius) { : openglframework::Mesh(), mRadius(radius) {
// Load the mesh from a file // Load the mesh from a file
@ -85,7 +85,7 @@ Sphere::Sphere(float radius, const openglframework::vec3 &position,
// Constructor // Constructor
Sphere::Sphere(float radius, const openglframework::vec3 &position, Sphere::Sphere(float radius, const openglframework::vec3 &position,
float mass, ephysics::DynamicsWorld* world, float mass, ephysics::DynamicsWorld* world,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: openglframework::Mesh(), mRadius(radius) { : openglframework::Mesh(), mRadius(radius) {
// Load the mesh from a file // Load the mesh from a file

4
tools/testbed/common/Sphere.h
View File

@ -80,11 +80,11 @@ class Sphere : public openglframework::Mesh, public PhysicsObject {
/// Constructor /// Constructor
Sphere(float radius, const openglframework::vec3& position, Sphere(float radius, const openglframework::vec3& position,
ephysics::CollisionWorld* world, const std::string& meshFolderPath); ephysics::CollisionWorld* world, const etk::String& meshFolderPath);
/// Constructor /// Constructor
Sphere(float radius, const openglframework::vec3& position, Sphere(float radius, const openglframework::vec3& position,
float mass, ephysics::DynamicsWorld* dynamicsWorld, const std::string& meshFolderPath); float mass, ephysics::DynamicsWorld* dynamicsWorld, const etk::String& meshFolderPath);
/// Destructor /// Destructor
~Sphere(); ~Sphere();

4
tools/testbed/common/VisualContactPoint.cpp
View File

@ -37,7 +37,7 @@ bool VisualContactPoint::mStaticDataCreated = false;
// Constructor // Constructor
VisualContactPoint::VisualContactPoint(const openglframework::vec3& position, VisualContactPoint::VisualContactPoint(const openglframework::vec3& position,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: mColor(1.0f, 0.0f, 0.0f, 1.0f) { : mColor(1.0f, 0.0f, 0.0f, 1.0f) {
// Initialize the position where the mesh will be rendered // Initialize the position where the mesh will be rendered
@ -50,7 +50,7 @@ VisualContactPoint::~VisualContactPoint() {
} }
// Load and initialize the mesh for all the contact points // Load and initialize the mesh for all the contact points
void VisualContactPoint::createStaticData(const std::string& meshFolderPath) { void VisualContactPoint::createStaticData(const etk::String& meshFolderPath) {
if (mStaticDataCreated) return; if (mStaticDataCreated) return;

4
tools/testbed/common/VisualContactPoint.h
View File

@ -73,13 +73,13 @@ class VisualContactPoint : public openglframework::Object3D {
/// Constructor /// Constructor
VisualContactPoint(const openglframework::vec3& position, VisualContactPoint(const openglframework::vec3& position,
const std::string &meshFolderPath); const etk::String &meshFolderPath);
/// Destructor /// Destructor
~VisualContactPoint(); ~VisualContactPoint();
/// Load and initialize the mesh for all the contact points /// Load and initialize the mesh for all the contact points
static void createStaticData(const std::string& meshFolderPath); static void createStaticData(const etk::String& meshFolderPath);
/// Destroy the mesh for the contact points /// Destroy the mesh for the contact points
static void destroyStaticData(); static void destroyStaticData();

4
tools/testbed/opengl-framework/src/Mesh.cpp
View File

@ -91,7 +91,7 @@ void Mesh::calculateNormals() {
// Compute the tangents of the mesh // Compute the tangents of the mesh
void Mesh::calculateTangents() { void Mesh::calculateTangents() {
mTangents = std::vector<vec3>(getNbVertices(), vec3(0, 0, 0)); mTangents = etk::Vector<vec3>(getNbVertices(), vec3(0, 0, 0));
// For each face // For each face
for (uint32_t i=0; i<getNbFaces(); i++) { for (uint32_t i=0; i<getNbFaces(); i++) {
@ -144,7 +144,7 @@ void Mesh::calculateBoundingBox(vec3& min, vec3& max) const {
min = m_vertices[0]; min = m_vertices[0];
max = m_vertices[0]; max = m_vertices[0];
std::vector<vec3>::const_iterator it(m_vertices.begin()); etk::Vector<vec3>::const_iterator it(m_vertices.begin());
// For each vertex of the mesh // For each vertex of the mesh
for (; it != m_vertices.end(); ++it) { for (; it != m_vertices.end(); ++it) {

56
tools/testbed/opengl-framework/src/Mesh.h
View File

@ -27,9 +27,9 @@
#define MESH_H #define MESH_H
// Libraries // Libraries
#include <string> #include <etk/String.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <map> #include <etk/Map.hpp>
#include <ephysics/definitions.hpp> #include <ephysics/definitions.hpp>
#include <ephysics/maths/vec2.hpp> #include <ephysics/maths/vec2.hpp>
#include <ephysics/maths/vec3.hpp> #include <ephysics/maths/vec3.hpp>
@ -49,25 +49,25 @@ class Mesh : public Object3D {
// -------------------- Attributes -------------------- // // -------------------- Attributes -------------------- //
// A triplet of vertex indices for each triangle // A triplet of vertex indices for each triangle
std::vector<std::vector<uint32_t> > mIndices; etk::Vector<etk::Vector<uint32_t> > mIndices;
// Vertices coordinates (local space) // Vertices coordinates (local space)
std::vector<vec3> m_vertices; etk::Vector<vec3> m_vertices;
// Normals coordinates // Normals coordinates
std::vector<vec3> mNormals; etk::Vector<vec3> mNormals;
// Tangents coordinates // Tangents coordinates
std::vector<vec3> mTangents; etk::Vector<vec3> mTangents;
// Color for each vertex // Color for each vertex
std::vector<Color> mColors; etk::Vector<Color> mColors;
// UV texture coordinates // UV texture coordinates
std::vector<vec2> mUVs; etk::Vector<vec2> mUVs;
// Textures of the mesh (one for each part of the mesh) // Textures of the mesh (one for each part of the mesh)
std::map<uint32_t, Texture2D> mTextures; etk::Map<uint32_t, Texture2D> mTextures;
public: public:
@ -104,28 +104,28 @@ class Mesh : public Object3D {
uint32_t getNbParts() const; uint32_t getNbParts() const;
// Return a reference to the vertices // Return a reference to the vertices
const std::vector<vec3>& getVertices() const; const etk::Vector<vec3>& getVertices() const;
// Set the vertices of the mesh // Set the vertices of the mesh
void setVertices(std::vector<vec3>& vertices); void setVertices(etk::Vector<vec3>& vertices);
// Return a reference to the normals // Return a reference to the normals
const std::vector<vec3>& getNormals() const; const etk::Vector<vec3>& getNormals() const;
// set the normals of the mesh // set the normals of the mesh
void setNormals(std::vector<vec3>& normals); void setNormals(etk::Vector<vec3>& normals);
// Return a reference to the UVs // Return a reference to the UVs
const std::vector<vec2>& getUVs() const; const etk::Vector<vec2>& getUVs() const;
// Set the UV texture coordinates of the mesh // Set the UV texture coordinates of the mesh
void setUVs(std::vector<vec2>& uvs); void setUVs(etk::Vector<vec2>& uvs);
// Return a reference to the vertex indices // Return a reference to the vertex indices
const std::vector<uint32_t>& getIndices(uint32_t part = 0) const; const etk::Vector<uint32_t>& getIndices(uint32_t part = 0) const;
// Set the vertices indices of the mesh // Set the vertices indices of the mesh
void setIndices(std::vector<std::vector<uint32_t> >& indices); void setIndices(etk::Vector<etk::Vector<uint32_t> >& indices);
// Return the coordinates of a given vertex // Return the coordinates of a given vertex
const vec3& getVertex(uint32_t i) const; const vec3& getVertex(uint32_t i) const;
@ -218,42 +218,42 @@ inline uint32_t Mesh::getNbParts() const {
} }
// Return a reference to the vertices // Return a reference to the vertices
inline const std::vector<vec3>& Mesh::getVertices() const { inline const etk::Vector<vec3>& Mesh::getVertices() const {
return m_vertices; return m_vertices;
} }
// Set the vertices of the mesh // Set the vertices of the mesh
inline void Mesh::setVertices(std::vector<vec3>& vertices) { inline void Mesh::setVertices(etk::Vector<vec3>& vertices) {
m_vertices = vertices; m_vertices = vertices;
} }
// Return a reference to the normals // Return a reference to the normals
inline const std::vector<vec3>& Mesh::getNormals() const { inline const etk::Vector<vec3>& Mesh::getNormals() const {
return mNormals; return mNormals;
} }
// set the normals of the mesh // set the normals of the mesh
inline void Mesh::setNormals(std::vector<vec3>& normals) { inline void Mesh::setNormals(etk::Vector<vec3>& normals) {
mNormals = normals; mNormals = normals;
} }
// Return a reference to the UVs // Return a reference to the UVs
inline const std::vector<vec2>& Mesh::getUVs() const { inline const etk::Vector<vec2>& Mesh::getUVs() const {
return mUVs; return mUVs;
} }
// Set the UV texture coordinates of the mesh // Set the UV texture coordinates of the mesh
inline void Mesh::setUVs(std::vector<vec2>& uvs) { inline void Mesh::setUVs(etk::Vector<vec2>& uvs) {
mUVs = uvs; mUVs = uvs;
} }
// Return a reference to the vertex indices // Return a reference to the vertex indices
inline const std::vector<uint32_t>& Mesh::getIndices(uint32_t part) const { inline const etk::Vector<uint32_t>& Mesh::getIndices(uint32_t part) const {
return mIndices[part]; return mIndices[part];
} }
// Set the vertices indices of the mesh // Set the vertices indices of the mesh
inline void Mesh::setIndices(std::vector<std::vector<uint32_t> >& indices) { inline void Mesh::setIndices(etk::Vector<etk::Vector<uint32_t> >& indices) {
mIndices = indices; mIndices = indices;
} }
@ -295,7 +295,7 @@ inline void Mesh::setVertexColor(uint32_t i, const Color& color) {
if (mColors.size() != m_vertices.size()) { if (mColors.size() != m_vertices.size()) {
// Create the color array with the same size // Create the color array with the same size
mColors = std::vector<Color>(m_vertices.size()); mColors = etk::Vector<Color>(m_vertices.size());
} }
mColors[i] = color; mColors[i] = color;
@ -309,7 +309,7 @@ inline void Mesh::setColorToAllVertices(const Color& color) {
if (mColors.size() != m_vertices.size()) { if (mColors.size() != m_vertices.size()) {
// Create the color array with the same size // Create the color array with the same size
mColors = std::vector<Color>(m_vertices.size()); mColors = etk::Vector<Color>(m_vertices.size());
} }
for (size_t v=0; v<m_vertices.size(); v++) { for (size_t v=0; v<m_vertices.size(); v++) {

108
tools/testbed/opengl-framework/src/MeshReaderWriter.cpp
View File

@ -29,7 +29,7 @@
#include <sstream> #include <sstream>
#include <locale> #include <locale>
#include <cctype> #include <cctype>
#include <map> #include <etk/Map.hpp>
#include <algorithm> #include <algorithm>
using namespace openglframework; using namespace openglframework;
@ -41,7 +41,7 @@ MeshReaderWriter::MeshReaderWriter() {
} }
// Load a mesh from a file and returns true if the mesh has been sucessfully loaded // Load a mesh from a file and returns true if the mesh has been sucessfully loaded
void MeshReaderWriter::loadMeshFromFile(const std::string& filename, Mesh& meshToCreate) { void MeshReaderWriter::loadMeshFromFile(const etk::String& filename, Mesh& meshToCreate) {
// Get the extension of the file // Get the extension of the file
uint32_t startPosExtension = filename.find_last_of("."); uint32_t startPosExtension = filename.find_last_of(".");
@ -62,7 +62,7 @@ void MeshReaderWriter::loadMeshFromFile(const std::string& filename, Mesh& meshT
} }
// Write a mesh to a file // Write a mesh to a file
void MeshReaderWriter::writeMeshToFile(const std::string& filename, const Mesh& meshToWrite) { void MeshReaderWriter::writeMeshToFile(const etk::String& filename, const Mesh& meshToWrite) {
// Get the extension of the file // Get the extension of the file
uint32_t startPosExtension = filename.find_last_of("."); uint32_t startPosExtension = filename.find_last_of(".");
@ -97,20 +97,20 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
throw runtime_error(errorMessage); throw runtime_error(errorMessage);
} }
std::string buffer; etk::String buffer;
string line, tmp; string line, tmp;
int32_t id1, id2, id3, id4; int32_t id1, id2, id3, id4;
int32_t nId1, nId2, nId3, nId4; int32_t nId1, nId2, nId3, nId4;
int32_t tId1, tId2, tId3, tId4; int32_t tId1, tId2, tId3, tId4;
float v1, v2, v3; float v1, v2, v3;
size_t found1, found2; size_t found1, found2;
std::vector<bool> isQuad; etk::Vector<bool> isQuad;
std::vector<vec3> vertices; etk::Vector<vec3> vertices;
std::vector<vec3> normals; etk::Vector<vec3> normals;
std::vector<vec2> uvs; etk::Vector<vec2> uvs;
std::vector<uint32_t> verticesIndices; etk::Vector<uint32_t> verticesIndices;
std::vector<uint32_t> normalsIndices; etk::Vector<uint32_t> normalsIndices;
std::vector<uint32_t> uvsIndices; etk::Vector<uint32_t> uvsIndices;
// ---------- Collect the data from the file ---------- // // ---------- Collect the data from the file ---------- //
@ -118,7 +118,7 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
while(std::getline(meshFile, buffer)) { while(std::getline(meshFile, buffer)) {
std::istringstream lineStream(buffer); std::istringstream lineStream(buffer);
std::string word; etk::String word;
lineStream >> word; lineStream >> word;
std::transform(word.begin(), word.end(), word.begin(), ::tolower); std::transform(word.begin(), word.end(), word.begin(), ::tolower);
if(word == "usemtl") { // Material definition if(word == "usemtl") { // Material definition
@ -128,15 +128,15 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
} }
else if(word == "v") { // Vertex position else if(word == "v") { // Vertex position
sscanf(buffer.c_str(), "%*s %f %f %f", &v1, &v2, &v3); sscanf(buffer.c_str(), "%*s %f %f %f", &v1, &v2, &v3);
vertices.push_back(vec3(v1, v2, v3)); vertices.pushBack(vec3(v1, v2, v3));
} }
else if(word == "vt") { // Vertex texture coordinate else if(word == "vt") { // Vertex texture coordinate
sscanf(buffer.c_str(), "%*s %f %f", &v1, &v2); sscanf(buffer.c_str(), "%*s %f %f", &v1, &v2);
uvs.push_back(vec2(v1,v2)); uvs.pushBack(vec2(v1,v2));
} }
else if(word == "vn") { // Vertex normal else if(word == "vn") { // Vertex normal
sscanf(buffer.c_str(), "%*s %f %f %f", &v1, &v2, &v3); sscanf(buffer.c_str(), "%*s %f %f %f", &v1, &v2, &v3);
normals.push_back(vec3(v1 ,v2, v3)); normals.pushBack(vec3(v1 ,v2, v3));
} }
else if (word == "f") { // Face else if (word == "f") { // Face
line = buffer; line = buffer;
@ -166,10 +166,10 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
if(found2 == string::npos) { if(found2 == string::npos) {
int32_t n = sscanf(buffer.c_str(), "%*s %d/%d %d/%d %d/%d %d/%d", &id1, &tId1, &id2, &tId2, &id3, &tId3, &id4, &tId4); int32_t n = sscanf(buffer.c_str(), "%*s %d/%d %d/%d %d/%d %d/%d", &id1, &tId1, &id2, &tId2, &id3, &tId3, &id4, &tId4);
if (n == 8) isFaceQuad = true; if (n == 8) isFaceQuad = true;
uvsIndices.push_back(tId1-1); uvsIndices.pushBack(tId1-1);
uvsIndices.push_back(tId2-1); uvsIndices.pushBack(tId2-1);
uvsIndices.push_back(tId3-1); uvsIndices.pushBack(tId3-1);
if (isFaceQuad) uvsIndices.push_back(tId4-1); if (isFaceQuad) uvsIndices.pushBack(tId4-1);
} }
else { else {
tmp = line.substr(found1+1); tmp = line.substr(found1+1);
@ -184,22 +184,22 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
else { else {
int32_t n = sscanf(buffer.c_str(), "%*s %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d", &id1, &tId1, &nId1, &id2, &tId2, &nId2, &id3, &tId3, &nId3, &id4, &tId4, &nId4); int32_t n = sscanf(buffer.c_str(), "%*s %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d", &id1, &tId1, &nId1, &id2, &tId2, &nId2, &id3, &tId3, &nId3, &id4, &tId4, &nId4);
if (n == 12) isFaceQuad = true; if (n == 12) isFaceQuad = true;
uvsIndices.push_back(tId1-1); uvsIndices.pushBack(tId1-1);
uvsIndices.push_back(tId2-1); uvsIndices.pushBack(tId2-1);
uvsIndices.push_back(tId3-1); uvsIndices.pushBack(tId3-1);
if (isFaceQuad) uvsIndices.push_back(tId4-1); if (isFaceQuad) uvsIndices.pushBack(tId4-1);
} }
normalsIndices.push_back(nId1-1); normalsIndices.pushBack(nId1-1);
normalsIndices.push_back(nId2-1); normalsIndices.pushBack(nId2-1);
normalsIndices.push_back(nId3-1); normalsIndices.pushBack(nId3-1);
if (isFaceQuad) normalsIndices.push_back(nId4-1); if (isFaceQuad) normalsIndices.pushBack(nId4-1);
} }
} }
verticesIndices.push_back(id1-1); verticesIndices.pushBack(id1-1);
verticesIndices.push_back(id2-1); verticesIndices.pushBack(id2-1);
verticesIndices.push_back(id3-1); verticesIndices.pushBack(id3-1);
if (isFaceQuad) verticesIndices.push_back((id4-1)); if (isFaceQuad) verticesIndices.pushBack((id4-1));
isQuad.push_back(isFaceQuad); isQuad.pushBack(isFaceQuad);
} }
} }
@ -214,7 +214,7 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
meshToCreate.destroy(); meshToCreate.destroy();
// Mesh data // Mesh data
vector<std::vector<uint32_t> > meshIndices; vector<etk::Vector<uint32_t> > meshIndices;
vector<vec3> meshNormals; vector<vec3> meshNormals;
if (!normals.empty()) meshNormals = vector<vec3>(vertices.size(), vec3(0, 0, 0)); if (!normals.empty()) meshNormals = vector<vec3>(vertices.size(), vec3(0, 0, 0));
vector<vec2> meshUVs; vector<vec2> meshUVs;
@ -225,7 +225,7 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
// Fill in the vertex indices // Fill in the vertex indices
// We also triangulate each quad face // We also triangulate each quad face
meshIndices.push_back(std::vector<uint32_t>()); meshIndices.pushBack(etk::Vector<uint32_t>());
for(size_t i = 0, j = 0; i < verticesIndices.size(); j++) { for(size_t i = 0, j = 0; i < verticesIndices.size(); j++) {
// Get the current vertex IDs // Get the current vertex IDs
@ -251,9 +251,9 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
if (!isQuad[j]) { if (!isQuad[j]) {
// Add the vertex indices // Add the vertex indices
meshIndices[meshPart].push_back(i1); meshIndices[meshPart].pushBack(i1);
meshIndices[meshPart].push_back(i2); meshIndices[meshPart].pushBack(i2);
meshIndices[meshPart].push_back(i3); meshIndices[meshPart].pushBack(i3);
i+=3; i+=3;
} }
@ -272,20 +272,20 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
float a1 = v13.dot(v12); float a1 = v13.dot(v12);
float a2 = v13.dot(v14); float a2 = v13.dot(v14);
if((a1 >= 0 && a2 <= 0) || (a1 <= 0 && a2 >= 0)) { if((a1 >= 0 && a2 <= 0) || (a1 <= 0 && a2 >= 0)) {
meshIndices[meshPart].push_back(i1); meshIndices[meshPart].pushBack(i1);
meshIndices[meshPart].push_back(i2); meshIndices[meshPart].pushBack(i2);
meshIndices[meshPart].push_back(i3); meshIndices[meshPart].pushBack(i3);
meshIndices[meshPart].push_back(i1); meshIndices[meshPart].pushBack(i1);
meshIndices[meshPart].push_back(i3); meshIndices[meshPart].pushBack(i3);
meshIndices[meshPart].push_back(i4); meshIndices[meshPart].pushBack(i4);
} }
else { else {
meshIndices[meshPart].push_back(i1); meshIndices[meshPart].pushBack(i1);
meshIndices[meshPart].push_back(i2); meshIndices[meshPart].pushBack(i2);
meshIndices[meshPart].push_back(i4); meshIndices[meshPart].pushBack(i4);
meshIndices[meshPart].push_back(i2); meshIndices[meshPart].pushBack(i2);
meshIndices[meshPart].push_back(i3); meshIndices[meshPart].pushBack(i3);
meshIndices[meshPart].push_back(i4); meshIndices[meshPart].pushBack(i4);
} }
// Add the vertex normal // Add the vertex normal
@ -313,13 +313,13 @@ void MeshReaderWriter::loadOBJFile(const string &filename, Mesh& meshToCreate) {
} }
// Store a mesh int32_to a OBJ file // Store a mesh int32_to a OBJ file
void MeshReaderWriter::writeOBJFile(const std::string& filename, const Mesh& meshToWrite) { void MeshReaderWriter::writeOBJFile(const etk::String& filename, const Mesh& meshToWrite) {
std::ofstream file(filename.c_str()); std::ofstream file(filename.c_str());
// Geth the mesh data // Geth the mesh data
const std::vector<vec3>& vertices = meshToWrite.getVertices(); const etk::Vector<vec3>& vertices = meshToWrite.getVertices();
const std::vector<vec3>& normals = meshToWrite.getNormals(); const etk::Vector<vec3>& normals = meshToWrite.getNormals();
const std::vector<vec2>& uvs = meshToWrite.getUVs(); const etk::Vector<vec2>& uvs = meshToWrite.getUVs();
// If we can open the file // If we can open the file
if (file.is_open()) { if (file.is_open()) {
@ -363,7 +363,7 @@ void MeshReaderWriter::writeOBJFile(const std::string& filename, const Mesh& mes
for (uint32_t p=0; p<meshToWrite.getNbParts(); p++) { for (uint32_t p=0; p<meshToWrite.getNbParts(); p++) {
// Get the indices of the part // Get the indices of the part
const std::vector<uint32_t>& indices = meshToWrite.getIndices(p); const etk::Vector<uint32_t>& indices = meshToWrite.getIndices(p);
// For each index of the part // For each index of the part
for (uint32_t i=0; i<indices.size(); i+=3) { for (uint32_t i=0; i<indices.size(); i+=3) {

10
tools/testbed/opengl-framework/src/MeshReaderWriter.h
View File

@ -27,7 +27,7 @@
#define MESH_LOADER_H #define MESH_LOADER_H
// Libraries // Libraries
#include <string> #include <etk/String.hpp>
#include <stdexcept> #include <stdexcept>
#include <ephysics/Mesh.hpp> #include <ephysics/Mesh.hpp>
@ -47,20 +47,20 @@ class MeshReaderWriter {
MeshReaderWriter(); MeshReaderWriter();
// Load an OBJ file with a triangular or quad mesh // Load an OBJ file with a triangular or quad mesh
static void loadOBJFile(const std::string& filename, Mesh& meshToCreate); static void loadOBJFile(const etk::String& filename, Mesh& meshToCreate);
// Store a mesh int32_to a OBJ file // Store a mesh int32_to a OBJ file
static void writeOBJFile(const std::string& filename, const Mesh &meshToWrite); static void writeOBJFile(const etk::String& filename, const Mesh &meshToWrite);
public : public :
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
// Read a mesh from a file // Read a mesh from a file
static void loadMeshFromFile(const std::string& filename, Mesh& meshToCreate); static void loadMeshFromFile(const etk::String& filename, Mesh& meshToCreate);
// Write a mesh to a file // Write a mesh to a file
static void writeMeshToFile(const std::string& filename, const Mesh& meshToWrite); static void writeMeshToFile(const etk::String& filename, const Mesh& meshToWrite);
}; };
// Class VertexMergingData // Class VertexMergingData

6
tools/testbed/opengl-framework/src/Shader.cpp
View File

@ -39,7 +39,7 @@ Shader::Shader() : mProgramObjectID(0) {
} }
// Constructor with arguments // Constructor with arguments
Shader::Shader(const std::string vertexShaderFilename, const std::string fragmentShaderFilename) Shader::Shader(const etk::String vertexShaderFilename, const etk::String fragmentShaderFilename)
: mProgramObjectID(0) { : mProgramObjectID(0) {
// Create the shader // Create the shader
@ -52,8 +52,8 @@ Shader::~Shader() {
} }
// Create the shader // Create the shader
bool Shader::create(const std::string vertexShaderFilename, bool Shader::create(const etk::String vertexShaderFilename,
const std::string fragmentShaderFilename) { const etk::String fragmentShaderFilename) {
// Set the shader filenames // Set the shader filenames
mFilenameVertexShader = vertexShaderFilename; mFilenameVertexShader = vertexShaderFilename;

54
tools/testbed/opengl-framework/src/Shader.h
View File

@ -32,7 +32,7 @@
#include <ephysics/maths/vec2.hpp> #include <ephysics/maths/vec2.hpp>
#include <ephysics/maths/vec3.hpp> #include <ephysics/maths/vec3.hpp>
#include <ephysics/maths/Vector4.hpp> #include <ephysics/maths/Vector4.hpp>
#include <string> #include <etk/String.hpp>
#include <iostream> #include <iostream>
#include <stdexcept> #include <stdexcept>
#include <exception> #include <exception>
@ -51,7 +51,7 @@ class Shader {
GLuint32_t mProgramObjectID; GLuint32_t mProgramObjectID;
// Filenames of the vertex and fragment shaders // Filenames of the vertex and fragment shaders
std::string mFilenameVertexShader, mFilenameFragmentShader; etk::String mFilenameVertexShader, mFilenameFragmentShader;
public : public :
@ -61,14 +61,14 @@ class Shader {
Shader(); Shader();
// Constructor with arguments // Constructor with arguments
Shader(const std::string vertexShaderFilename, const std::string fragmentShaderFilename); Shader(const etk::String vertexShaderFilename, const etk::String fragmentShaderFilename);
// Destructor // Destructor
~Shader(); ~Shader();
// Create the shader // Create the shader
bool create(const std::string vertexShaderFilename, bool create(const etk::String vertexShaderFilename,
const std::string fragmentShaderFilename); const etk::String fragmentShaderFilename);
// Clear the shader // Clear the shader
void destroy(); void destroy();
@ -80,57 +80,57 @@ class Shader {
void unbind() const; void unbind() const;
// Return the location of a uniform variable inside a shader program // Return the location of a uniform variable inside a shader program
GLint32_t getUniformLocation(const std::string& variableName, bool errorIfMissing = true) const; GLint32_t getUniformLocation(const etk::String& variableName, bool errorIfMissing = true) const;
// Return the location of an attribute variable inside a shader program // Return the location of an attribute variable inside a shader program
GLint32_t getAttribLocation(const std::string& variableName, bool errorIfMissing = true) const; GLint32_t getAttribLocation(const etk::String& variableName, bool errorIfMissing = true) const;
// Set a float uniform value to this shader (be careful if the uniform is not // Set a float uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
void setFloatUniform(const std::string& variableName, float value, bool errorIfMissing = true) const; void setFloatUniform(const etk::String& variableName, float value, bool errorIfMissing = true) const;
// Set an int32_t uniform value to this shader (be careful if the uniform is not // Set an int32_t uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
void setIntUniform(const std::string& variableName, int32_t value, bool errorIfMissing = true) const; void setIntUniform(const etk::String& variableName, int32_t value, bool errorIfMissing = true) const;
// Set a vector 2 uniform value to this shader (be careful if the uniform is not // Set a vector 2 uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
void setvec2Uniform(const std::string& variableName, const vec2& v, bool errorIfMissing = true) const; void setvec2Uniform(const etk::String& variableName, const vec2& v, bool errorIfMissing = true) const;
// Set a vector 3 uniform value to this shader (be careful if the uniform is not // Set a vector 3 uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
void setvec3Uniform(const std::string& variableName, const vec3& v, bool errorIfMissing = true) const; void setvec3Uniform(const etk::String& variableName, const vec3& v, bool errorIfMissing = true) const;
// Set a vector 4 uniform value to this shader (be careful if the uniform is not // Set a vector 4 uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
void setVector4Uniform(const std::string& variableName, const Vector4 &v, bool errorIfMissing = true) const; void setVector4Uniform(const etk::String& variableName, const Vector4 &v, bool errorIfMissing = true) const;
// Set a 3x3 matrix uniform value to this shader (be careful if the uniform is not // Set a 3x3 matrix uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
void setetk::Matrix3x3Uniform(const std::string& variableName, const float* matrix, void setetk::Matrix3x3Uniform(const etk::String& variableName, const float* matrix,
bool transpose = false, bool errorIfMissing = true) const; bool transpose = false, bool errorIfMissing = true) const;
// Set a 3x3 matrix uniform value to this shader (be careful if the uniform is not // Set a 3x3 matrix uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
void setetk::Matrix3x3Uniform(const std::string& variableName, const Matrix3& matrix, bool errorIfMissing = true) const; void setetk::Matrix3x3Uniform(const etk::String& variableName, const Matrix3& matrix, bool errorIfMissing = true) const;
// Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not // Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
void setMatrix4x4Uniform(const std::string& variableName, const float* matrix, void setMatrix4x4Uniform(const etk::String& variableName, const float* matrix,
bool transpose = false, bool errorIfMissing = true) const; bool transpose = false, bool errorIfMissing = true) const;
// Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not // Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
void setMatrix4x4Uniform(const std::string& variableName, const Matrix4& matrix, bool errorIfMissing = true) const; void setMatrix4x4Uniform(const etk::String& variableName, const Matrix4& matrix, bool errorIfMissing = true) const;
// Return the shader object program ID // Return the shader object program ID
GLuint32_t getProgramObjectId() const; GLuint32_t getProgramObjectId() const;
@ -152,7 +152,7 @@ inline void Shader::unbind() const {
} }
// Return the location of a uniform variable inside a shader program // Return the location of a uniform variable inside a shader program
inline GLint32_t Shader::getUniformLocation(const std::string& variableName, bool errorIfMissing) const { inline GLint32_t Shader::getUniformLocation(const etk::String& variableName, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLint32_t location = glGetUniformLocation(mProgramObjectID, variableName.c_str()); GLint32_t location = glGetUniformLocation(mProgramObjectID, variableName.c_str());
if (location == -1 && errorIfMissing) { if (location == -1 && errorIfMissing) {
@ -166,7 +166,7 @@ inline GLint32_t Shader::getUniformLocation(const std::string& variableName, boo
} }
// Return the location of an attribute variable inside a shader program // Return the location of an attribute variable inside a shader program
inline GLint32_t Shader::getAttribLocation(const std::string& variableName, bool errorIfMissing) const { inline GLint32_t Shader::getAttribLocation(const etk::String& variableName, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLint32_t location = glGetAttribLocation(mProgramObjectID, variableName.c_str()); GLint32_t location = glGetAttribLocation(mProgramObjectID, variableName.c_str());
if (location == -1 && errorIfMissing) { if (location == -1 && errorIfMissing) {
@ -190,7 +190,7 @@ inline void Shader::destroy() {
// Set a float uniform value to this shader (be careful if the uniform is not // Set a float uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
inline void Shader::setFloatUniform(const std::string& variableName, float value, bool errorIfMissing) const { inline void Shader::setFloatUniform(const etk::String& variableName, float value, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLint32_t location = getUniformLocation(variableName, errorIfMissing); GLint32_t location = getUniformLocation(variableName, errorIfMissing);
if (location != -1) { if (location != -1) {
@ -201,7 +201,7 @@ inline void Shader::setFloatUniform(const std::string& variableName, float value
// Set an int32_t uniform value to this shader (be careful if the uniform is not // Set an int32_t uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
inline void Shader::setIntUniform(const std::string& variableName, int32_t value, bool errorIfMissing) const { inline void Shader::setIntUniform(const etk::String& variableName, int32_t value, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLint32_t location = getUniformLocation(variableName, errorIfMissing); GLint32_t location = getUniformLocation(variableName, errorIfMissing);
if (location != -1) { if (location != -1) {
@ -212,7 +212,7 @@ inline void Shader::setIntUniform(const std::string& variableName, int32_t value
// Set a vector 2 uniform value to this shader (be careful if the uniform is not // Set a vector 2 uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
inline void Shader::setvec2Uniform(const std::string& variableName, const vec2& v, bool errorIfMissing) const { inline void Shader::setvec2Uniform(const etk::String& variableName, const vec2& v, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLint32_t location = getUniformLocation(variableName, errorIfMissing); GLint32_t location = getUniformLocation(variableName, errorIfMissing);
if (location != -1) { if (location != -1) {
@ -223,7 +223,7 @@ inline void Shader::setvec2Uniform(const std::string& variableName, const vec2&
// Set a vector 3 uniform value to this shader (be careful if the uniform is not // Set a vector 3 uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
inline void Shader::setvec3Uniform(const std::string& variableName, const vec3 &v, bool errorIfMissing) const { inline void Shader::setvec3Uniform(const etk::String& variableName, const vec3 &v, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLint32_t location = getUniformLocation(variableName, errorIfMissing); GLint32_t location = getUniformLocation(variableName, errorIfMissing);
if (location != -1) { if (location != -1) {
@ -234,7 +234,7 @@ inline void Shader::setvec3Uniform(const std::string& variableName, const vec3 &
// Set a vector 4 uniform value to this shader (be careful if the uniform is not // Set a vector 4 uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
inline void Shader::setVector4Uniform(const std::string& variableName, const Vector4& v, bool errorIfMissing) const { inline void Shader::setVector4Uniform(const etk::String& variableName, const Vector4& v, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLint32_t location = getUniformLocation(variableName, errorIfMissing); GLint32_t location = getUniformLocation(variableName, errorIfMissing);
if (location != -1) { if (location != -1) {
@ -245,7 +245,7 @@ inline void Shader::setVector4Uniform(const std::string& variableName, const Vec
// Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not // Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
inline void Shader::setetk::Matrix3x3Uniform(const std::string& variableName, const float* matrix, inline void Shader::setetk::Matrix3x3Uniform(const etk::String& variableName, const float* matrix,
bool transpose, bool errorIfMissing) const { bool transpose, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLint32_t location = getUniformLocation(variableName, errorIfMissing); GLint32_t location = getUniformLocation(variableName, errorIfMissing);
@ -257,7 +257,7 @@ inline void Shader::setetk::Matrix3x3Uniform(const std::string& variableName, co
// Set a 3x3 matrix uniform value to this shader (be careful if the uniform is not // Set a 3x3 matrix uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
inline void Shader::setetk::Matrix3x3Uniform(const std::string& variableName, const Matrix3& matrix, bool errorIfMissing) const { inline void Shader::setetk::Matrix3x3Uniform(const etk::String& variableName, const Matrix3& matrix, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLfloat mat[9]; GLfloat mat[9];
for (int32_t i=0; i<3; i++) { for (int32_t i=0; i<3; i++) {
@ -274,7 +274,7 @@ inline void Shader::setetk::Matrix3x3Uniform(const std::string& variableName, co
// Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not // Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
inline void Shader::setMatrix4x4Uniform(const std::string& variableName, const float* matrix, inline void Shader::setMatrix4x4Uniform(const etk::String& variableName, const float* matrix,
bool transpose, bool errorIfMissing) const { bool transpose, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLint32_t location = getUniformLocation(variableName, errorIfMissing); GLint32_t location = getUniformLocation(variableName, errorIfMissing);
@ -286,7 +286,7 @@ inline void Shader::setMatrix4x4Uniform(const std::string& variableName, const f
// Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not // Set a 4x4 matrix uniform value to this shader (be careful if the uniform is not
// used in the shader, the compiler will remove it, then when you will try // used in the shader, the compiler will remove it, then when you will try
// to set it, an assert will occur) // to set it, an assert will occur)
inline void Shader::setMatrix4x4Uniform(const std::string& variableName, const Matrix4& matrix, bool errorIfMissing) const { inline void Shader::setMatrix4x4Uniform(const etk::String& variableName, const Matrix4& matrix, bool errorIfMissing) const {
assert(mProgramObjectID != 0); assert(mProgramObjectID != 0);
GLfloat mat[16]; GLfloat mat[16];
for (int32_t i=0; i<4; i++) { for (int32_t i=0; i<4; i++) {

2
tools/testbed/opengl-framework/src/Texture2D.cpp
View File

@ -27,7 +27,7 @@
#include <ephysics/Texture2D.hpp> #include <ephysics/Texture2D.hpp>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <string> #include <etk/String.hpp>
// Namespaces // Namespaces
using namespace openglframework; using namespace openglframework;

2
tools/testbed/opengl-framework/src/Texture2D.h
View File

@ -27,7 +27,7 @@
#define TEXTURE2D_H #define TEXTURE2D_H
// Libraries // Libraries
#include <string> #include <etk/String.hpp>
#include <cassert> #include <cassert>
#include <ephysics/definitions.hpp> #include <ephysics/definitions.hpp>
#include <nanogui/opengl.hpp> #include <nanogui/opengl.hpp>

14
tools/testbed/opengl-framework/src/TextureReaderWriter.cpp
View File

@ -25,7 +25,7 @@
// Librairies // Librairies
#include <ephysics/TextureReaderWriter.hpp> #include <ephysics/TextureReaderWriter.hpp>
#include <string> #include <etk/String.hpp>
#ifdef USE_JPEG_TEXTURE #ifdef USE_JPEG_TEXTURE
#include <jpeglib.hpp> #include <jpeglib.hpp>
#include <jerror.hpp> #include <jerror.hpp>
@ -60,7 +60,7 @@ typedef struct {
#pragma pack(pop) #pragma pack(pop)
// Load a texture from a file // Load a texture from a file
void TextureReaderWriter::loadTextureFromFile(const std::string& filename, void TextureReaderWriter::loadTextureFromFile(const etk::String& filename,
Texture2D& textureToCreate) { Texture2D& textureToCreate) {
// Get the extension of the file // Get the extension of the file
@ -87,7 +87,7 @@ void TextureReaderWriter::loadTextureFromFile(const std::string& filename,
} }
// Write a texture to a file // Write a texture to a file
void TextureReaderWriter::writeTextureToFile(const std::string& filename,const Texture2D& texture) { void TextureReaderWriter::writeTextureToFile(const etk::String& filename,const Texture2D& texture) {
// Get the extension of the file // Get the extension of the file
uint32_t startPosExtension = filename.find_last_of("."); uint32_t startPosExtension = filename.find_last_of(".");
@ -113,7 +113,7 @@ void TextureReaderWriter::writeTextureToFile(const std::string& filename,const T
} }
// Load a TGA picture // Load a TGA picture
void TextureReaderWriter::readTGAPicture(const std::string &filename, Texture2D& textureToCreate) { void TextureReaderWriter::readTGAPicture(const etk::String &filename, Texture2D& textureToCreate) {
// Open the file // Open the file
std::ifstream stream(filename.c_str(), std::ios::binary); std::ifstream stream(filename.c_str(), std::ios::binary);
@ -158,7 +158,7 @@ void TextureReaderWriter::readTGAPicture(const std::string &filename, Texture2D&
// Write a TGA picture // Write a TGA picture
void TextureReaderWriter::writeTGAPicture(const std::string& filename, const Texture2D& texture) { void TextureReaderWriter::writeTGAPicture(const etk::String& filename, const Texture2D& texture) {
assert(texture.getID() != 0); assert(texture.getID() != 0);
// Bind the corresponding texture // Bind the corresponding texture
@ -223,7 +223,7 @@ void TextureReaderWriter::writeTGAPicture(const std::string& filename, const Tex
#ifdef USE_JPEG_TEXTURE #ifdef USE_JPEG_TEXTURE
// Read a JPEG picture // Read a JPEG picture
void TextureReaderWriter::readJPEGPicture(const std::string& filename, Texture2D& textureToCreate) { void TextureReaderWriter::readJPEGPicture(const etk::String& filename, Texture2D& textureToCreate) {
struct jpeg_decompress_struct info; struct jpeg_decompress_struct info;
struct jpeg_error_mgr error; struct jpeg_error_mgr error;
@ -278,7 +278,7 @@ void TextureReaderWriter::readJPEGPicture(const std::string& filename, Texture2D
} }
// Write a JPEG picture // Write a JPEG picture
void TextureReaderWriter::writeJPEGPicture(const std::string& filename, const Texture2D& texture) { void TextureReaderWriter::writeJPEGPicture(const etk::String& filename, const Texture2D& texture) {
struct jpeg_compress_struct info; struct jpeg_compress_struct info;
struct jpeg_error_mgr error; struct jpeg_error_mgr error;

12
tools/testbed/opengl-framework/src/TextureReaderWriter.h
View File

@ -52,26 +52,26 @@ class TextureReaderWriter {
TextureReaderWriter(); TextureReaderWriter();
// Read a TGA picture // Read a TGA picture
static void readTGAPicture(const std::string& filename, Texture2D& textureToCreate); static void readTGAPicture(const etk::String& filename, Texture2D& textureToCreate);
// Write a TGA picture // Write a TGA picture
static void writeTGAPicture(const std::string& filename, const Texture2D& texture); static void writeTGAPicture(const etk::String& filename, const Texture2D& texture);
// Read a JPEG picture // Read a JPEG picture
static void readJPEGPicture(const std::string& filename, Texture2D& textureToCreate); static void readJPEGPicture(const etk::String& filename, Texture2D& textureToCreate);
// Write a JPEG picture // Write a JPEG picture
static void writeJPEGPicture(const std::string& filename, const Texture2D& texture); static void writeJPEGPicture(const etk::String& filename, const Texture2D& texture);
public : public :
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
// Load a texture from a file // Load a texture from a file
static void loadTextureFromFile(const std::string& filename, Texture2D& textureToCreate); static void loadTextureFromFile(const etk::String& filename, Texture2D& textureToCreate);
// Write a texture to a file // Write a texture to a file
static void writeTextureToFile(const std::string& filename, const Texture2D& texture); static void writeTextureToFile(const etk::String& filename, const Texture2D& texture);
}; };
} }

60
tools/testbed/scenes/collisionshapes/CollisionShapesScene.cpp
View File

@ -31,10 +31,10 @@ using namespace openglframework;
using namespace collisionshapesscene; using namespace collisionshapesscene;
// Constructor // Constructor
CollisionShapesScene::CollisionShapesScene(const std::string& name) CollisionShapesScene::CollisionShapesScene(const etk::String& name)
: SceneDemo(name, SCENE_RADIUS) { : SceneDemo(name, SCENE_RADIUS) {
std::string meshFolderPath("meshes/"); etk::String meshFolderPath("meshes/");
// Compute the radius and the center of the scene // Compute the radius and the center of the scene
openglframework::vec3 center(0, 5, 0); openglframework::vec3 center(0, 5, 0);
@ -73,7 +73,7 @@ CollisionShapesScene::CollisionShapesScene(const std::string& name)
material.setBounciness(ephysics::float(0.2)); material.setBounciness(ephysics::float(0.2));
// Add the mesh the list of dumbbells in the scene // Add the mesh the list of dumbbells in the scene
mDumbbells.push_back(dumbbell); mDumbbells.pushBack(dumbbell);
} }
// Create all the boxes of the scene // Create all the boxes of the scene
@ -97,7 +97,7 @@ CollisionShapesScene::CollisionShapesScene(const std::string& name)
material.setBounciness(ephysics::float(0.2)); material.setBounciness(ephysics::float(0.2));
// Add the sphere the list of sphere in the scene // Add the sphere the list of sphere in the scene
mBoxes.push_back(box); mBoxes.pushBack(box);
} }
// Create all the spheres of the scene // Create all the spheres of the scene
@ -125,7 +125,7 @@ CollisionShapesScene::CollisionShapesScene(const std::string& name)
material.setBounciness(ephysics::float(0.2)); material.setBounciness(ephysics::float(0.2));
// Add the sphere the list of sphere in the scene // Add the sphere the list of sphere in the scene
mSpheres.push_back(sphere); mSpheres.pushBack(sphere);
} }
// Create all the cones of the scene // Create all the cones of the scene
@ -153,7 +153,7 @@ CollisionShapesScene::CollisionShapesScene(const std::string& name)
material.setBounciness(ephysics::float(0.2)); material.setBounciness(ephysics::float(0.2));
// Add the cone the list of sphere in the scene // Add the cone the list of sphere in the scene
mCones.push_back(cone); mCones.pushBack(cone);
} }
// Create all the cylinders of the scene // Create all the cylinders of the scene
@ -181,7 +181,7 @@ CollisionShapesScene::CollisionShapesScene(const std::string& name)
material.setBounciness(ephysics::float(0.2)); material.setBounciness(ephysics::float(0.2));
// Add the cylinder the list of sphere in the scene // Add the cylinder the list of sphere in the scene
mCylinders.push_back(cylinder); mCylinders.pushBack(cylinder);
} }
// Create all the capsules of the scene // Create all the capsules of the scene
@ -208,7 +208,7 @@ CollisionShapesScene::CollisionShapesScene(const std::string& name)
material.setBounciness(ephysics::float(0.2)); material.setBounciness(ephysics::float(0.2));
// Add the cylinder the list of sphere in the scene // Add the cylinder the list of sphere in the scene
mCapsules.push_back(capsule); mCapsules.pushBack(capsule);
} }
// Create all the convex meshes of the scene // Create all the convex meshes of the scene
@ -232,7 +232,7 @@ CollisionShapesScene::CollisionShapesScene(const std::string& name)
material.setBounciness(ephysics::float(0.2)); material.setBounciness(ephysics::float(0.2));
// Add the mesh the list of sphere in the scene // Add the mesh the list of sphere in the scene
mConvexMeshes.push_back(mesh); mConvexMeshes.pushBack(mesh);
} }
// ---------- Create the floor --------- // ---------- Create the floor ---------
@ -290,7 +290,7 @@ CollisionShapesScene::CollisionShapesScene(const std::string& name)
CollisionShapesScene::~CollisionShapesScene() { CollisionShapesScene::~CollisionShapesScene() {
// Destroy all the boxes of the scene // Destroy all the boxes of the scene
for (std::vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) { for (etk::Vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) {
// Destroy the corresponding rigid body from the dynamics world // Destroy the corresponding rigid body from the dynamics world
mDynamicsWorld->destroyRigidBody((*it)->getRigidBody()); mDynamicsWorld->destroyRigidBody((*it)->getRigidBody());
@ -300,7 +300,7 @@ CollisionShapesScene::~CollisionShapesScene() {
} }
// Destroy all the sphere of the scene // Destroy all the sphere of the scene
for (std::vector<Sphere*>::iterator it = mSpheres.begin(); it != mSpheres.end(); ++it) { for (etk::Vector<Sphere*>::iterator it = mSpheres.begin(); it != mSpheres.end(); ++it) {
// Destroy the corresponding rigid body from the dynamics world // Destroy the corresponding rigid body from the dynamics world
mDynamicsWorld->destroyRigidBody((*it)->getRigidBody()); mDynamicsWorld->destroyRigidBody((*it)->getRigidBody());
@ -310,7 +310,7 @@ CollisionShapesScene::~CollisionShapesScene() {
} }
// Destroy all the cones of the scene // Destroy all the cones of the scene
for (std::vector<Cone*>::iterator it = mCones.begin(); it != mCones.end(); ++it) { for (etk::Vector<Cone*>::iterator it = mCones.begin(); it != mCones.end(); ++it) {
// Destroy the corresponding rigid body from the dynamics world // Destroy the corresponding rigid body from the dynamics world
mDynamicsWorld->destroyRigidBody((*it)->getRigidBody()); mDynamicsWorld->destroyRigidBody((*it)->getRigidBody());
@ -320,7 +320,7 @@ CollisionShapesScene::~CollisionShapesScene() {
} }
// Destroy all the cylinders of the scene // Destroy all the cylinders of the scene
for (std::vector<Cylinder*>::iterator it = mCylinders.begin(); it != mCylinders.end(); ++it) { for (etk::Vector<Cylinder*>::iterator it = mCylinders.begin(); it != mCylinders.end(); ++it) {
// Destroy the corresponding rigid body from the dynamics world // Destroy the corresponding rigid body from the dynamics world
mDynamicsWorld->destroyRigidBody((*it)->getRigidBody()); mDynamicsWorld->destroyRigidBody((*it)->getRigidBody());
@ -330,7 +330,7 @@ CollisionShapesScene::~CollisionShapesScene() {
} }
// Destroy all the capsules of the scene // Destroy all the capsules of the scene
for (std::vector<Capsule*>::iterator it = mCapsules.begin(); it != mCapsules.end(); ++it) { for (etk::Vector<Capsule*>::iterator it = mCapsules.begin(); it != mCapsules.end(); ++it) {
// Destroy the corresponding rigid body from the dynamics world // Destroy the corresponding rigid body from the dynamics world
mDynamicsWorld->destroyRigidBody((*it)->getRigidBody()); mDynamicsWorld->destroyRigidBody((*it)->getRigidBody());
@ -340,7 +340,7 @@ CollisionShapesScene::~CollisionShapesScene() {
} }
// Destroy all the convex meshes of the scene // Destroy all the convex meshes of the scene
for (std::vector<ConvexMesh*>::iterator it = mConvexMeshes.begin(); for (etk::Vector<ConvexMesh*>::iterator it = mConvexMeshes.begin();
it != mConvexMeshes.end(); ++it) { it != mConvexMeshes.end(); ++it) {
// Destroy the corresponding rigid body from the dynamics world // Destroy the corresponding rigid body from the dynamics world
@ -351,7 +351,7 @@ CollisionShapesScene::~CollisionShapesScene() {
} }
// Destroy all the dumbbell of the scene // Destroy all the dumbbell of the scene
for (std::vector<Dumbbell*>::iterator it = mDumbbells.begin(); for (etk::Vector<Dumbbell*>::iterator it = mDumbbells.begin();
it != mDumbbells.end(); ++it) { it != mDumbbells.end(); ++it) {
// Destroy the corresponding rigid body from the dynamics world // Destroy the corresponding rigid body from the dynamics world
@ -400,42 +400,42 @@ void CollisionShapesScene::update() {
SceneDemo::update(); SceneDemo::update();
// Update the position and orientation of the boxes // Update the position and orientation of the boxes
for (std::vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) { for (etk::Vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) {
// Update the transform used for the rendering // Update the transform used for the rendering
(*it)->updateetk::Transform3D(mInterpolationFactor); (*it)->updateetk::Transform3D(mInterpolationFactor);
} }
// Update the position and orientation of the sphere // Update the position and orientation of the sphere
for (std::vector<Sphere*>::iterator it = mSpheres.begin(); it != mSpheres.end(); ++it) { for (etk::Vector<Sphere*>::iterator it = mSpheres.begin(); it != mSpheres.end(); ++it) {
// Update the transform used for the rendering // Update the transform used for the rendering
(*it)->updateetk::Transform3D(mInterpolationFactor); (*it)->updateetk::Transform3D(mInterpolationFactor);
} }
// Update the position and orientation of the cones // Update the position and orientation of the cones
for (std::vector<Cone*>::iterator it = mCones.begin(); it != mCones.end(); ++it) { for (etk::Vector<Cone*>::iterator it = mCones.begin(); it != mCones.end(); ++it) {
// Update the transform used for the rendering // Update the transform used for the rendering
(*it)->updateetk::Transform3D(mInterpolationFactor); (*it)->updateetk::Transform3D(mInterpolationFactor);
} }
// Update the position and orientation of the cylinders // Update the position and orientation of the cylinders
for (std::vector<Cylinder*>::iterator it = mCylinders.begin(); it != mCylinders.end(); ++it) { for (etk::Vector<Cylinder*>::iterator it = mCylinders.begin(); it != mCylinders.end(); ++it) {
// Update the transform used for the rendering // Update the transform used for the rendering
(*it)->updateetk::Transform3D(mInterpolationFactor); (*it)->updateetk::Transform3D(mInterpolationFactor);
} }
// Update the position and orientation of the capsules // Update the position and orientation of the capsules
for (std::vector<Capsule*>::iterator it = mCapsules.begin(); it != mCapsules.end(); ++it) { for (etk::Vector<Capsule*>::iterator it = mCapsules.begin(); it != mCapsules.end(); ++it) {
// Update the transform used for the rendering // Update the transform used for the rendering
(*it)->updateetk::Transform3D(mInterpolationFactor); (*it)->updateetk::Transform3D(mInterpolationFactor);
} }
// Update the position and orientation of the convex meshes // Update the position and orientation of the convex meshes
for (std::vector<ConvexMesh*>::iterator it = mConvexMeshes.begin(); for (etk::Vector<ConvexMesh*>::iterator it = mConvexMeshes.begin();
it != mConvexMeshes.end(); ++it) { it != mConvexMeshes.end(); ++it) {
// Update the transform used for the rendering // Update the transform used for the rendering
@ -443,7 +443,7 @@ void CollisionShapesScene::update() {
} }
// Update the position and orientation of the dumbbells // Update the position and orientation of the dumbbells
for (std::vector<Dumbbell*>::iterator it = mDumbbells.begin(); for (etk::Vector<Dumbbell*>::iterator it = mDumbbells.begin();
it != mDumbbells.end(); ++it) { it != mDumbbells.end(); ++it) {
// Update the transform used for the rendering // Update the transform used for the rendering
@ -463,38 +463,38 @@ void CollisionShapesScene::renderSinglePass(openglframework::Shader& shader,
shader.bind(); shader.bind();
// Render all the boxes of the scene // Render all the boxes of the scene
for (std::vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) { for (etk::Vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) {
(*it)->render(shader, worldToCameraMatrix); (*it)->render(shader, worldToCameraMatrix);
} }
// Render all the sphere of the scene // Render all the sphere of the scene
for (std::vector<Sphere*>::iterator it = mSpheres.begin(); it != mSpheres.end(); ++it) { for (etk::Vector<Sphere*>::iterator it = mSpheres.begin(); it != mSpheres.end(); ++it) {
(*it)->render(shader, worldToCameraMatrix); (*it)->render(shader, worldToCameraMatrix);
} }
// Render all the cones of the scene // Render all the cones of the scene
for (std::vector<Cone*>::iterator it = mCones.begin(); it != mCones.end(); ++it) { for (etk::Vector<Cone*>::iterator it = mCones.begin(); it != mCones.end(); ++it) {
(*it)->render(shader, worldToCameraMatrix); (*it)->render(shader, worldToCameraMatrix);
} }
// Render all the cylinders of the scene // Render all the cylinders of the scene
for (std::vector<Cylinder*>::iterator it = mCylinders.begin(); it != mCylinders.end(); ++it) { for (etk::Vector<Cylinder*>::iterator it = mCylinders.begin(); it != mCylinders.end(); ++it) {
(*it)->render(shader, worldToCameraMatrix); (*it)->render(shader, worldToCameraMatrix);
} }
// Render all the capsules of the scene // Render all the capsules of the scene
for (std::vector<Capsule*>::iterator it = mCapsules.begin(); it != mCapsules.end(); ++it) { for (etk::Vector<Capsule*>::iterator it = mCapsules.begin(); it != mCapsules.end(); ++it) {
(*it)->render(shader, worldToCameraMatrix); (*it)->render(shader, worldToCameraMatrix);
} }
// Render all the convex meshes of the scene // Render all the convex meshes of the scene
for (std::vector<ConvexMesh*>::iterator it = mConvexMeshes.begin(); for (etk::Vector<ConvexMesh*>::iterator it = mConvexMeshes.begin();
it != mConvexMeshes.end(); ++it) { it != mConvexMeshes.end(); ++it) {
(*it)->render(shader, worldToCameraMatrix); (*it)->render(shader, worldToCameraMatrix);
} }
// Render all the dumbbells of the scene // Render all the dumbbells of the scene
for (std::vector<Dumbbell*>::iterator it = mDumbbells.begin(); for (etk::Vector<Dumbbell*>::iterator it = mDumbbells.begin();
it != mDumbbells.end(); ++it) { it != mDumbbells.end(); ++it) {
(*it)->render(shader, worldToCameraMatrix); (*it)->render(shader, worldToCameraMatrix);
} }

20
tools/testbed/scenes/collisionshapes/CollisionShapesScene.h
View File

@ -76,21 +76,21 @@ class CollisionShapesScene : public SceneDemo {
// -------------------- Attributes -------------------- // // -------------------- Attributes -------------------- //
/// All the spheres of the scene /// All the spheres of the scene
std::vector<Box*> mBoxes; etk::Vector<Box*> mBoxes;
std::vector<Sphere*> mSpheres; etk::Vector<Sphere*> mSpheres;
std::vector<Cone*> mCones; etk::Vector<Cone*> mCones;
std::vector<Cylinder*> mCylinders; etk::Vector<Cylinder*> mCylinders;
std::vector<Capsule*> mCapsules; etk::Vector<Capsule*> mCapsules;
/// All the convex meshes of the scene /// All the convex meshes of the scene
std::vector<ConvexMesh*> mConvexMeshes; etk::Vector<ConvexMesh*> mConvexMeshes;
/// All the dumbbell of the scene /// All the dumbbell of the scene
std::vector<Dumbbell*> mDumbbells; etk::Vector<Dumbbell*> mDumbbells;
/// Box for the floor /// Box for the floor
Box* mFloor; Box* mFloor;
@ -103,7 +103,7 @@ class CollisionShapesScene : public SceneDemo {
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
/// Constructor /// Constructor
CollisionShapesScene(const std::string& name); CollisionShapesScene(const etk::String& name);
/// Destructor /// Destructor
virtual ~CollisionShapesScene(); virtual ~CollisionShapesScene();
@ -123,11 +123,11 @@ class CollisionShapesScene : public SceneDemo {
virtual void reset(); virtual void reset();
/// Return all the contact points of the scene /// Return all the contact points of the scene
virtual std::vector<ContactPoint> getContactPoints() const; virtual etk::Vector<ContactPoint> getContactPoints() const;
}; };
// Return all the contact points of the scene // Return all the contact points of the scene
inline std::vector<ContactPoint> CollisionShapesScene::getContactPoints() const { inline etk::Vector<ContactPoint> CollisionShapesScene::getContactPoints() const {
return computeContactPointsOfWorld(mDynamicsWorld); return computeContactPointsOfWorld(mDynamicsWorld);
} }

4
tools/testbed/scenes/concavemesh/ConcaveMeshScene.cpp
View File

@ -31,10 +31,10 @@ using namespace openglframework;
using namespace trianglemeshscene; using namespace trianglemeshscene;
// Constructor // Constructor
ConcaveMeshScene::ConcaveMeshScene(const std::string& name) ConcaveMeshScene::ConcaveMeshScene(const etk::String& name)
: SceneDemo(name, SCENE_RADIUS) { : SceneDemo(name, SCENE_RADIUS) {
std::string meshFolderPath("meshes/"); etk::String meshFolderPath("meshes/");
// Compute the radius and the center of the scene // Compute the radius and the center of the scene
openglframework::vec3 center(0, 5, 0); openglframework::vec3 center(0, 5, 0);

6
tools/testbed/scenes/concavemesh/ConcaveMeshScene.h
View File

@ -63,7 +63,7 @@ class ConcaveMeshScene : public SceneDemo {
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
/// Constructor /// Constructor
ConcaveMeshScene(const std::string& name); ConcaveMeshScene(const etk::String& name);
/// Destructor /// Destructor
virtual ~ConcaveMeshScene(); virtual ~ConcaveMeshScene();
@ -83,11 +83,11 @@ class ConcaveMeshScene : public SceneDemo {
virtual void reset(); virtual void reset();
/// Return all the contact points of the scene /// Return all the contact points of the scene
virtual std::vector<ContactPoint> getContactPoints() const; virtual etk::Vector<ContactPoint> getContactPoints() const;
}; };
// Return all the contact points of the scene // Return all the contact points of the scene
inline std::vector<ContactPoint> ConcaveMeshScene::getContactPoints() const { inline etk::Vector<ContactPoint> ConcaveMeshScene::getContactPoints() const {
return computeContactPointsOfWorld(mDynamicsWorld); return computeContactPointsOfWorld(mDynamicsWorld);
} }

10
tools/testbed/scenes/cubes/CubesScene.cpp
View File

@ -31,7 +31,7 @@ using namespace openglframework;
using namespace cubesscene; using namespace cubesscene;
// Constructor // Constructor
CubesScene::CubesScene(const std::string& name) CubesScene::CubesScene(const etk::String& name)
: SceneDemo(name, SCENE_RADIUS) { : SceneDemo(name, SCENE_RADIUS) {
// Compute the radius and the center of the scene // Compute the radius and the center of the scene
@ -72,7 +72,7 @@ CubesScene::CubesScene(const std::string& name)
material.setBounciness(ephysics::float(0.4)); material.setBounciness(ephysics::float(0.4));
// Add the box the list of box in the scene // Add the box the list of box in the scene
mBoxes.push_back(cube); mBoxes.pushBack(cube);
} }
// Create the floor // Create the floor
@ -104,7 +104,7 @@ CubesScene::CubesScene(const std::string& name)
CubesScene::~CubesScene() { CubesScene::~CubesScene() {
// Destroy all the cubes of the scene // Destroy all the cubes of the scene
for (std::vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) { for (etk::Vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) {
// Destroy the corresponding rigid body from the dynamics world // Destroy the corresponding rigid body from the dynamics world
m_dynamicsWorld->destroyRigidBody((*it)->getRigidBody()); m_dynamicsWorld->destroyRigidBody((*it)->getRigidBody());
@ -148,7 +148,7 @@ void CubesScene::update() {
SceneDemo::update(); SceneDemo::update();
// Update the position and orientation of the boxes // Update the position and orientation of the boxes
for (std::vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) { for (etk::Vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) {
// Update the transform used for the rendering // Update the transform used for the rendering
(*it)->updateetk::Transform3D(mInterpolationFactor); (*it)->updateetk::Transform3D(mInterpolationFactor);
@ -164,7 +164,7 @@ void CubesScene::renderSinglePass(Shader& shader, const openglframework::Matrix4
shader.bind(); shader.bind();
// Render all the cubes of the scene // Render all the cubes of the scene
for (std::vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) { for (etk::Vector<Box*>::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) {
(*it)->render(shader, worldToCameraMatrix); (*it)->render(shader, worldToCameraMatrix);
} }

6
tools/testbed/scenes/cubes/CubesScene.h
View File

@ -44,14 +44,14 @@ namespace cubesscene {
class CubesScene : public SceneDemo { class CubesScene : public SceneDemo {
protected : protected :
/// All the boxes of the scene /// All the boxes of the scene
std::vector<Box*> mBoxes; etk::Vector<Box*> mBoxes;
/// Box for the floor /// Box for the floor
Box* mFloor; Box* mFloor;
/// Dynamics world used for the physics simulation /// Dynamics world used for the physics simulation
ephysics::DynamicsWorld* m_dynamicsWorld; ephysics::DynamicsWorld* m_dynamicsWorld;
public: public:
/// Constructor /// Constructor
CubesScene(const std::string& name); CubesScene(const etk::String& name);
/// Destructor /// Destructor
virtual ~CubesScene(); virtual ~CubesScene();
/// Update the physics world (take a simulation step) /// Update the physics world (take a simulation step)
@ -65,7 +65,7 @@ namespace cubesscene {
/// Reset the scene /// Reset the scene
virtual void reset(); virtual void reset();
/// Return all the contact points of the scene /// Return all the contact points of the scene
virtual std::vector<ContactPoint> getContactPoints() const { virtual etk::Vector<ContactPoint> getContactPoints() const {
return computeContactPointsOfWorld(m_dynamicsWorld); return computeContactPointsOfWorld(m_dynamicsWorld);
} }
}; };

2
tools/testbed/scenes/heightfield/HeightFieldScene.cpp
View File

@ -31,7 +31,7 @@ using namespace openglframework;
using namespace heightfieldscene; using namespace heightfieldscene;
// Constructor // Constructor
HeightFieldScene::HeightFieldScene(const std::string& name) : SceneDemo(name, SCENE_RADIUS) { HeightFieldScene::HeightFieldScene(const etk::String& name) : SceneDemo(name, SCENE_RADIUS) {
// Compute the radius and the center of the scene // Compute the radius and the center of the scene
openglframework::vec3 center(0, 5, 0); openglframework::vec3 center(0, 5, 0);

6
tools/testbed/scenes/heightfield/HeightFieldScene.h
View File

@ -60,7 +60,7 @@ class HeightFieldScene : public SceneDemo {
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
/// Constructor /// Constructor
HeightFieldScene(const std::string& name); HeightFieldScene(const etk::String& name);
/// Destructor /// Destructor
virtual ~HeightFieldScene(); virtual ~HeightFieldScene();
@ -80,11 +80,11 @@ class HeightFieldScene : public SceneDemo {
virtual void reset(); virtual void reset();
/// Return all the contact points of the scene /// Return all the contact points of the scene
virtual std::vector<ContactPoint> getContactPoints() const; virtual etk::Vector<ContactPoint> getContactPoints() const;
}; };
// Return all the contact points of the scene // Return all the contact points of the scene
inline std::vector<ContactPoint> HeightFieldScene::getContactPoints() const { inline etk::Vector<ContactPoint> HeightFieldScene::getContactPoints() const {
return computeContactPointsOfWorld(mDynamicsWorld); return computeContactPointsOfWorld(mDynamicsWorld);
} }

2
tools/testbed/scenes/joints/JointsScene.cpp
View File

@ -32,7 +32,7 @@ using namespace openglframework;
using namespace jointsscene; using namespace jointsscene;
// Constructor // Constructor
JointsScene::JointsScene(const std::string& name) JointsScene::JointsScene(const etk::String& name)
: SceneDemo(name, SCENE_RADIUS) { : SceneDemo(name, SCENE_RADIUS) {
// Compute the radius and the center of the scene // Compute the radius and the center of the scene

6
tools/testbed/scenes/joints/JointsScene.h
View File

@ -117,7 +117,7 @@ class JointsScene : public SceneDemo {
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
/// Constructor /// Constructor
JointsScene(const std::string& name); JointsScene(const etk::String& name);
/// Destructor /// Destructor
virtual ~JointsScene(); virtual ~JointsScene();
@ -137,11 +137,11 @@ class JointsScene : public SceneDemo {
virtual void reset(); virtual void reset();
/// Return all the contact points of the scene /// Return all the contact points of the scene
virtual std::vector<ContactPoint> getContactPoints() const; virtual etk::Vector<ContactPoint> getContactPoints() const;
}; };
// Return all the contact points of the scene // Return all the contact points of the scene
inline std::vector<ContactPoint> JointsScene::getContactPoints() const { inline etk::Vector<ContactPoint> JointsScene::getContactPoints() const {
return computeContactPointsOfWorld(mDynamicsWorld); return computeContactPointsOfWorld(mDynamicsWorld);
} }

12
tools/testbed/scenes/raycast/RaycastScene.cpp
View File

@ -31,7 +31,7 @@ using namespace openglframework;
using namespace raycastscene; using namespace raycastscene;
// Constructor // Constructor
RaycastScene::RaycastScene(const std::string& name) RaycastScene::RaycastScene(const etk::String& name)
: SceneDemo(name, SCENE_RADIUS, false), mMeshFolderPath("meshes/"), : SceneDemo(name, SCENE_RADIUS, false), mMeshFolderPath("meshes/"),
m_raycastManager(mPhongShader, mMeshFolderPath), mCurrentBodyIndex(-1), m_raycastManager(mPhongShader, mMeshFolderPath), mCurrentBodyIndex(-1),
mAreNormalsDisplayed(false), mVBOVertices(GL_ARRAY_BUFFER) { mAreNormalsDisplayed(false), mVBOVertices(GL_ARRAY_BUFFER) {
@ -172,10 +172,10 @@ void RaycastScene::createLines() {
openglframework::vec3 point1(x, y, z); openglframework::vec3 point1(x, y, z);
openglframework::vec3 point2(0.0f, 0.0f, 0.0f); openglframework::vec3 point2(0.0f, 0.0f, 0.0f);
Line* line = new Line(point1, point2); Line* line = new Line(point1, point2);
mLines.push_back(line); mLines.pushBack(line);
mLinePoints.push_back(point1); mLinePoints.pushBack(point1);
mLinePoints.push_back(point2); mLinePoints.pushBack(point2);
} }
} }
} }
@ -287,7 +287,7 @@ RaycastScene::~RaycastScene() {
delete mCollisionWorld; delete mCollisionWorld;
// Destroy the lines // Destroy the lines
for (std::vector<Line*>::iterator it = mLines.begin(); it != mLines.end(); for (etk::Vector<Line*>::iterator it = mLines.begin(); it != mLines.end();
++it) { ++it) {
delete (*it); delete (*it);
} }
@ -309,7 +309,7 @@ void RaycastScene::update() {
m_raycastManager.resetPoints(); m_raycastManager.resetPoints();
// For each line of the scene // For each line of the scene
for (std::vector<Line*>::iterator it = mLines.begin(); it != mLines.end(); for (etk::Vector<Line*>::iterator it = mLines.begin(); it != mLines.end();
++it) { ++it) {
Line* line = *it; Line* line = *it;

28
tools/testbed/scenes/raycast/RaycastScene.h
View File

@ -67,18 +67,18 @@ class RaycastManager : public ephysics::RaycastCallback {
private: private:
/// All the visual contact points /// All the visual contact points
std::vector<ContactPoint> mHitPoints; etk::Vector<ContactPoint> mHitPoints;
/// All the normals at hit points /// All the normals at hit points
std::vector<Line*> mNormals; etk::Vector<Line*> mNormals;
/// Contact point mesh folder path /// Contact point mesh folder path
std::string mMeshFolderPath; etk::String mMeshFolderPath;
public: public:
RaycastManager(openglframework::Shader& shader, RaycastManager(openglframework::Shader& shader,
const std::string& meshFolderPath) const etk::String& meshFolderPath)
: mMeshFolderPath(meshFolderPath) { : mMeshFolderPath(meshFolderPath) {
} }
@ -86,13 +86,13 @@ class RaycastManager : public ephysics::RaycastCallback {
virtual ephysics::float notifyRaycastHit(const ephysics::RaycastInfo& raycastInfo) { virtual ephysics::float notifyRaycastHit(const ephysics::RaycastInfo& raycastInfo) {
ephysics::vec3 hitPos = raycastInfo.worldPoint; ephysics::vec3 hitPos = raycastInfo.worldPoint;
openglframework::vec3 position(hitPos.x(), hitPos.y(), hitPos.z()); openglframework::vec3 position(hitPos.x(), hitPos.y(), hitPos.z());
mHitPoints.push_back(ContactPoint(position)); mHitPoints.pushBack(ContactPoint(position));
// Create a line to display the normal at hit point // Create a line to display the normal at hit point
ephysics::vec3 n = raycastInfo.worldNormal; ephysics::vec3 n = raycastInfo.worldNormal;
openglframework::vec3 normal(n.x(), n.y(), n.z()); openglframework::vec3 normal(n.x(), n.y(), n.z());
Line* normalLine = new Line(position, position + normal); Line* normalLine = new Line(position, position + normal);
mNormals.push_back(normalLine); mNormals.pushBack(normalLine);
return raycastInfo.hitFraction; return raycastInfo.hitFraction;
} }
@ -102,14 +102,14 @@ class RaycastManager : public ephysics::RaycastCallback {
mHitPoints.clear(); mHitPoints.clear();
// Destroy all the normals // Destroy all the normals
for (std::vector<Line*>::iterator it = mNormals.begin(); for (etk::Vector<Line*>::iterator it = mNormals.begin();
it != mNormals.end(); ++it) { it != mNormals.end(); ++it) {
delete (*it); delete (*it);
} }
mNormals.clear(); mNormals.clear();
} }
std::vector<ContactPoint> getHitPoints() const { etk::Vector<ContactPoint> getHitPoints() const {
return mHitPoints; return mHitPoints;
} }
}; };
@ -122,13 +122,13 @@ class RaycastScene : public SceneDemo {
// -------------------- Attributes -------------------- // // -------------------- Attributes -------------------- //
/// Contact point mesh folder path /// Contact point mesh folder path
std::string mMeshFolderPath; etk::String mMeshFolderPath;
/// Raycast manager /// Raycast manager
RaycastManager m_raycastManager; RaycastManager m_raycastManager;
/// All the raycast lines /// All the raycast lines
std::vector<Line*> mLines; etk::Vector<Line*> mLines;
/// Current body index /// Current body index
int32_t mCurrentBodyIndex; int32_t mCurrentBodyIndex;
@ -153,7 +153,7 @@ class RaycastScene : public SceneDemo {
ephysics::CollisionWorld* mCollisionWorld; ephysics::CollisionWorld* mCollisionWorld;
/// All the points to render the lines /// All the points to render the lines
std::vector<openglframework::vec3> mLinePoints; etk::Vector<openglframework::vec3> mLinePoints;
/// Vertex Buffer Object for the vertices data /// Vertex Buffer Object for the vertices data
openglframework::VertexBufferObject mVBOVertices; openglframework::VertexBufferObject mVBOVertices;
@ -173,7 +173,7 @@ class RaycastScene : public SceneDemo {
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
/// Constructor /// Constructor
RaycastScene(const std::string& name); RaycastScene(const etk::String& name);
/// Destructor /// Destructor
virtual ~RaycastScene(); virtual ~RaycastScene();
@ -208,7 +208,7 @@ class RaycastScene : public SceneDemo {
void virtual setIsContactPointsDisplayed(bool display); void virtual setIsContactPointsDisplayed(bool display);
/// Return all the contact points of the scene /// Return all the contact points of the scene
virtual std::vector<ContactPoint> getContactPoints() const; virtual etk::Vector<ContactPoint> getContactPoints() const;
}; };
// Display or not the surface normals at hit points // Display or not the surface normals at hit points
@ -227,7 +227,7 @@ inline void RaycastScene::setIsContactPointsDisplayed(bool display) {
} }
// Return all the contact points of the scene // Return all the contact points of the scene
inline std::vector<ContactPoint> RaycastScene::getContactPoints() const { inline etk::Vector<ContactPoint> RaycastScene::getContactPoints() const {
return m_raycastManager.getHitPoints(); return m_raycastManager.getHitPoints();
} }

34
tools/testbed/src/Gui.cpp
View File

@ -79,13 +79,13 @@ void Gui::update() {
} }
// Framerate (FPS) // Framerate (FPS)
mFPSLabel->setCaption(std::string("FPS : ") + floatToString(mCachedFPS, 0)); mFPSLabel->setCaption(etk::String("FPS : ") + floatToString(mCachedFPS, 0));
// Frame time // Frame time
mFrameTimeLabel->setCaption(std::string("Frame time : ") + floatToString(mCachedUpdateTime * 1000.0, 1) + std::string(" ms")); mFrameTimeLabel->setCaption(etk::String("Frame time : ") + floatToString(mCachedUpdateTime * 1000.0, 1) + etk::String(" ms"));
// Physics time // Physics time
mPhysicsTimeLabel->setCaption(std::string("Physics time : ") + floatToString(mCachedPhysicsUpdateTime * 1000.0, 1) + std::string(" ms")); mPhysicsTimeLabel->setCaption(etk::String("Physics time : ") + floatToString(mCachedPhysicsUpdateTime * 1000.0, 1) + etk::String(" ms"));
} }
void Gui::createSimulationPanel() { void Gui::createSimulationPanel() {
@ -122,10 +122,10 @@ void Gui::createSimulationPanel() {
}); });
// Scenes // Scenes
std::vector<Scene*> scenes = mApp->getScenes(); etk::Vector<Scene*> scenes = mApp->getScenes();
std::vector<std::string> scenesNames; etk::Vector<etk::String> scenesNames;
for (uint32_t i=0; i<scenes.size(); i++) { for (uint32_t i=0; i<scenes.size(); i++) {
scenesNames.push_back(scenes[i]->getName().c_str()); scenesNames.pushBack(scenes[i]->getName().c_str());
} }
new Label(mSimulationPanel, "Scene","sans-bold"); new Label(mSimulationPanel, "Scene","sans-bold");
ComboBox* comboBoxScenes = new ComboBox(mSimulationPanel, scenesNames, [&, scenes](int32_t index) { ComboBox* comboBoxScenes = new ComboBox(mSimulationPanel, scenesNames, [&, scenes](int32_t index) {
@ -191,7 +191,7 @@ void Gui::createSettingsPanel() {
out << std::setprecision(1) << std::fixed << (mApp->mEngineSettings.timeStep * 1000); out << std::setprecision(1) << std::fixed << (mApp->mEngineSettings.timeStep * 1000);
textboxTimeStep->setValue(out.str()); textboxTimeStep->setValue(out.str());
textboxTimeStep->setUnits("ms"); textboxTimeStep->setUnits("ms");
textboxTimeStep->setCallback([&, textboxTimeStep](const std::string &str) { textboxTimeStep->setCallback([&, textboxTimeStep](const etk::String &str) {
try { try {
float value = std::stof(str); float value = std::stof(str);
@ -221,9 +221,9 @@ void Gui::createSettingsPanel() {
TextBox* textboxVelocityIterations = new TextBox(panelVelocityIterations); TextBox* textboxVelocityIterations = new TextBox(panelVelocityIterations);
textboxVelocityIterations->setFixedSize(vec2i(70, 25)); textboxVelocityIterations->setFixedSize(vec2i(70, 25));
textboxVelocityIterations->setEditable(true); textboxVelocityIterations->setEditable(true);
textboxVelocityIterations->setValue(std::to_string(mApp->mEngineSettings.nbVelocitySolverIterations)); textboxVelocityIterations->setValue(etk::toString(mApp->mEngineSettings.nbVelocitySolverIterations));
textboxVelocityIterations->setUnits("iter"); textboxVelocityIterations->setUnits("iter");
textboxVelocityIterations->setCallback([&, textboxVelocityIterations](const std::string &str) { textboxVelocityIterations->setCallback([&, textboxVelocityIterations](const etk::String &str) {
try { try {
float value = std::stof(str); float value = std::stof(str);
@ -252,9 +252,9 @@ void Gui::createSettingsPanel() {
TextBox* textboxPositionIterations = new TextBox(panelPositionIterations); TextBox* textboxPositionIterations = new TextBox(panelPositionIterations);
textboxPositionIterations->setFixedSize(vec2i(70, 25)); textboxPositionIterations->setFixedSize(vec2i(70, 25));
textboxPositionIterations->setEditable(true); textboxPositionIterations->setEditable(true);
textboxPositionIterations->setValue(std::to_string(mApp->mEngineSettings.nbPositionSolverIterations)); textboxPositionIterations->setValue(etk::toString(mApp->mEngineSettings.nbPositionSolverIterations));
textboxPositionIterations->setUnits("iter"); textboxPositionIterations->setUnits("iter");
textboxPositionIterations->setCallback([&, textboxPositionIterations](const std::string &str) { textboxPositionIterations->setCallback([&, textboxPositionIterations](const etk::String &str) {
try { try {
float value = std::stof(str); float value = std::stof(str);
@ -287,7 +287,7 @@ void Gui::createSettingsPanel() {
textboxTimeSleep->setEditable(true); textboxTimeSleep->setEditable(true);
textboxTimeSleep->setValue(out.str()); textboxTimeSleep->setValue(out.str());
textboxTimeSleep->setUnits("ms"); textboxTimeSleep->setUnits("ms");
textboxTimeSleep->setCallback([&, textboxTimeSleep](const std::string &str) { textboxTimeSleep->setCallback([&, textboxTimeSleep](const etk::String &str) {
try { try {
float value = std::stof(str); float value = std::stof(str);
@ -321,7 +321,7 @@ void Gui::createSettingsPanel() {
textboxSleepLinearVel->setEditable(true); textboxSleepLinearVel->setEditable(true);
textboxSleepLinearVel->setValue(out.str()); textboxSleepLinearVel->setValue(out.str());
textboxSleepLinearVel->setUnits("m/s"); textboxSleepLinearVel->setUnits("m/s");
textboxSleepLinearVel->setCallback([&, textboxSleepLinearVel](const std::string &str) { textboxSleepLinearVel->setCallback([&, textboxSleepLinearVel](const etk::String &str) {
try { try {
float value = std::stof(str); float value = std::stof(str);
@ -355,7 +355,7 @@ void Gui::createSettingsPanel() {
textboxSleepAngularVel->setEditable(true); textboxSleepAngularVel->setEditable(true);
textboxSleepAngularVel->setValue(out.str()); textboxSleepAngularVel->setValue(out.str());
textboxSleepAngularVel->setUnits("rad/s"); textboxSleepAngularVel->setUnits("rad/s");
textboxSleepAngularVel->setCallback([&, textboxSleepAngularVel](const std::string &str) { textboxSleepAngularVel->setCallback([&, textboxSleepAngularVel](const etk::String &str) {
try { try {
float value = std::stof(str); float value = std::stof(str);
@ -415,13 +415,13 @@ void Gui::createProfilingPanel() {
profilingPanel->setFixedWidth(220); profilingPanel->setFixedWidth(220);
// Framerate (FPS) // Framerate (FPS)
mFPSLabel = new Label(profilingPanel, std::string("FPS : ") + floatToString(mCachedFPS, 0),"sans-bold"); mFPSLabel = new Label(profilingPanel, etk::String("FPS : ") + floatToString(mCachedFPS, 0),"sans-bold");
// Update time // Update time
mFrameTimeLabel = new Label(profilingPanel, std::string("Frame time : ") + floatToString(mCachedUpdateTime * 1000.0, 1) + std::string(" ms"),"sans-bold"); mFrameTimeLabel = new Label(profilingPanel, etk::String("Frame time : ") + floatToString(mCachedUpdateTime * 1000.0, 1) + etk::String(" ms"),"sans-bold");
// Update time // Update time
mPhysicsTimeLabel = new Label(profilingPanel, std::string("Physics time : ") + floatToString(mCachedPhysicsUpdateTime * 1000.0, 1) + std::string(" ms"),"sans-bold"); mPhysicsTimeLabel = new Label(profilingPanel, etk::String("Physics time : ") + floatToString(mCachedPhysicsUpdateTime * 1000.0, 1) + etk::String(" ms"),"sans-bold");
profilingPanel->setVisible(true); profilingPanel->setVisible(true);
} }

8
tools/testbed/src/Gui.h
View File

@ -71,7 +71,7 @@ class Gui {
Label* mFrameTimeLabel; Label* mFrameTimeLabel;
Label* mPhysicsTimeLabel; Label* mPhysicsTimeLabel;
std::vector<CheckBox*> mCheckboxesScenes; etk::Vector<CheckBox*> mCheckboxesScenes;
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
@ -98,7 +98,7 @@ class Gui {
void createProfilingPanel(); void createProfilingPanel();
// Convert float value to string // Convert float value to string
std::string floatToString(float value, int32_t precision); etk::String floatToString(float value, int32_t precision);
public : public :
@ -132,8 +132,8 @@ inline void Gui::setScroll(double scrollX, double scrollY) {
mScrollY = scrollY; mScrollY = scrollY;
} }
inline std::string Gui::floatToString(float value, int32_t precision) { inline etk::String Gui::floatToString(float value, int32_t precision) {
std::stringstream ss; etk::Stringstream ss;
ss << std::fixed << std::setprecision(precision) << value; ss << std::fixed << std::setprecision(precision) << value;
return ss.str(); return ss.str();
} }

2
tools/testbed/src/Scene.cpp
View File

@ -30,7 +30,7 @@
using namespace openglframework; using namespace openglframework;
// Constructor // Constructor
Scene::Scene(const std::string& name, bool isShadowMappingEnabled) Scene::Scene(const etk::String& name, bool isShadowMappingEnabled)
: m_name(name), mInterpolationFactor(0.0f), mViewportX(0), mViewportY(0), : m_name(name), mInterpolationFactor(0.0f), mViewportX(0), mViewportY(0),
mViewportWidth(0), mViewportHeight(0), mIsShadowMappingEnabled(isShadowMappingEnabled), mViewportWidth(0), mViewportHeight(0), mIsShadowMappingEnabled(isShadowMappingEnabled),
mIsContactPointsDisplayed(true) { mIsContactPointsDisplayed(true) {

14
tools/testbed/src/Scene.h
View File

@ -73,7 +73,7 @@ class Scene {
// -------------------- Attributes -------------------- // // -------------------- Attributes -------------------- //
/// Scene name /// Scene name
std::string m_name; etk::String m_name;
/// Physics engine settings /// Physics engine settings
EngineSettings mEngineSettings; EngineSettings mEngineSettings;
@ -134,7 +134,7 @@ class Scene {
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
/// Constructor /// Constructor
Scene(const std::string& name, bool isShadowMappingEnabled = false); Scene(const etk::String& name, bool isShadowMappingEnabled = false);
/// Destructor /// Destructor
virtual ~Scene(); virtual ~Scene();
@ -188,7 +188,7 @@ class Scene {
void setInterpolationFactor(float int32_terpolationFactor); void setInterpolationFactor(float int32_terpolationFactor);
/// Return the name of the scene /// Return the name of the scene
std::string getName() const; etk::String getName() const;
/// Return true if the shadow mapping is enabled /// Return true if the shadow mapping is enabled
bool getIsShadowMappingEnabled() const; bool getIsShadowMappingEnabled() const;
@ -200,7 +200,7 @@ class Scene {
void virtual setIsContactPointsDisplayed(bool display); void virtual setIsContactPointsDisplayed(bool display);
/// Return all the contact points of the scene /// Return all the contact points of the scene
std::vector<ContactPoint> virtual getContactPoints() const; etk::Vector<ContactPoint> virtual getContactPoints() const;
}; };
// Called when a keyboard event occurs // Called when a keyboard event occurs
@ -248,7 +248,7 @@ inline void Scene::setInterpolationFactor(float int32_terpolationFactor) {
} }
// Return the name of the scene // Return the name of the scene
inline std::string Scene::getName() const { inline etk::String Scene::getName() const {
return m_name; return m_name;
} }
@ -268,10 +268,10 @@ inline void Scene::setIsContactPointsDisplayed(bool display) {
} }
// Return all the contact points of the scene // Return all the contact points of the scene
inline std::vector<ContactPoint> Scene::getContactPoints() const { inline etk::Vector<ContactPoint> Scene::getContactPoints() const {
// Return an empty list of contact points // Return an empty list of contact points
return std::vector<ContactPoint>(); return etk::Vector<ContactPoint>();
} }
#endif #endif

22
tools/testbed/src/SceneDemo.cpp
View File

@ -41,7 +41,7 @@ openglframework::Color SceneDemo::mDemoColors[] = {SceneDemo::mYellowColorDemo,
SceneDemo::mOrangeColorDemo, SceneDemo::mPinkColorDemo}; SceneDemo::mOrangeColorDemo, SceneDemo::mPinkColorDemo};
// Constructor // Constructor
SceneDemo::SceneDemo(const std::string& name, float sceneRadius, bool isShadowMappingEnabled) SceneDemo::SceneDemo(const etk::String& name, float sceneRadius, bool isShadowMappingEnabled)
: Scene(name, isShadowMappingEnabled), mIsShadowMappingInitialized(false), : Scene(name, isShadowMappingEnabled), mIsShadowMappingInitialized(false),
mDepthShader("shaders/depth.vert", "shaders/depth.frag"), mDepthShader("shaders/depth.vert", "shaders/depth.frag"),
mPhongShader("shaders/phong.vert", "shaders/phong.frag"), mPhongShader("shaders/phong.vert", "shaders/phong.frag"),
@ -282,15 +282,15 @@ void SceneDemo::updateContactPoints() {
if (mIsContactPointsDisplayed) { if (mIsContactPointsDisplayed) {
// Get the current contact points of the scene // Get the current contact points of the scene
std::vector<ContactPoint> contactPoints = getContactPoints(); etk::Vector<ContactPoint> contactPoints = getContactPoints();
// For each contact point // For each contact point
std::vector<ContactPoint>::const_iterator it; etk::Vector<ContactPoint>::const_iterator it;
for (it = contactPoints.begin(); it != contactPoints.end(); ++it) { for (it = contactPoints.begin(); it != contactPoints.end(); ++it) {
// Create a visual contact point for rendering // Create a visual contact point for rendering
VisualContactPoint* point = new VisualContactPoint(it->point, mMeshFolderPath); VisualContactPoint* point = new VisualContactPoint(it->point, mMeshFolderPath);
m_contactPoints.push_back(point); m_contactPoints.pushBack(point);
} }
} }
} }
@ -300,7 +300,7 @@ void SceneDemo::renderContactPoints(openglframework::Shader& shader,
const openglframework::Matrix4& worldToCameraMatrix) { const openglframework::Matrix4& worldToCameraMatrix) {
// Render all the raycast hit points // Render all the raycast hit points
for (std::vector<VisualContactPoint*>::iterator it = m_contactPoints.begin(); for (etk::Vector<VisualContactPoint*>::iterator it = m_contactPoints.begin();
it != m_contactPoints.end(); ++it) { it != m_contactPoints.end(); ++it) {
(*it)->render(shader, worldToCameraMatrix); (*it)->render(shader, worldToCameraMatrix);
} }
@ -309,7 +309,7 @@ void SceneDemo::renderContactPoints(openglframework::Shader& shader,
void SceneDemo::removeAllContactPoints() { void SceneDemo::removeAllContactPoints() {
// Destroy all the visual contact points // Destroy all the visual contact points
for (std::vector<VisualContactPoint*>::iterator it = m_contactPoints.begin(); for (etk::Vector<VisualContactPoint*>::iterator it = m_contactPoints.begin();
it != m_contactPoints.end(); ++it) { it != m_contactPoints.end(); ++it) {
delete (*it); delete (*it);
} }
@ -317,15 +317,15 @@ void SceneDemo::removeAllContactPoints() {
} }
// Return all the contact points of the scene // Return all the contact points of the scene
std::vector<ContactPoint> SceneDemo::computeContactPointsOfWorld(const ephysics::DynamicsWorld* world) const { etk::Vector<ContactPoint> SceneDemo::computeContactPointsOfWorld(const ephysics::DynamicsWorld* world) const {
std::vector<ContactPoint> contactPoints; etk::Vector<ContactPoint> contactPoints;
// Get the list of contact manifolds from the world // Get the list of contact manifolds from the world
std::vector<const ephysics::ContactManifold*> manifolds = world->getContactsList(); etk::Vector<const ephysics::ContactManifold*> manifolds = world->getContactsList();
// For each contact manifold // For each contact manifold
std::vector<const ephysics::ContactManifold*>::const_iterator it; etk::Vector<const ephysics::ContactManifold*>::const_iterator it;
for (it = manifolds.begin(); it != manifolds.end(); ++it) { for (it = manifolds.begin(); it != manifolds.end(); ++it) {
const ephysics::ContactManifold* manifold = *it; const ephysics::ContactManifold* manifold = *it;
@ -336,7 +336,7 @@ std::vector<ContactPoint> SceneDemo::computeContactPointsOfWorld(const ephysics:
ephysics::ContactPoint* contactPoint = manifold->getContactPoint(i); ephysics::ContactPoint* contactPoint = manifold->getContactPoint(i);
ephysics::vec3 point = contactPoint->getWorldPointOnBody1(); ephysics::vec3 point = contactPoint->getWorldPointOnBody1();
ContactPoint contact(openglframework::vec3(point.x(), point.y(), point.z())); ContactPoint contact(openglframework::vec3(point.x(), point.y(), point.z()));
contactPoints.push_back(contact); contactPoints.pushBack(contact);
} }
} }

8
tools/testbed/src/SceneDemo.h
View File

@ -59,7 +59,7 @@ class SceneDemo : public Scene {
static int32_t shadowMapTextureLevel; static int32_t shadowMapTextureLevel;
/// All the visual contact points /// All the visual contact points
std::vector<VisualContactPoint*> m_contactPoints; etk::Vector<VisualContactPoint*> m_contactPoints;
/// Shadow map bias matrix /// Shadow map bias matrix
openglframework::Matrix4 mShadowMapBiasMatrix; openglframework::Matrix4 mShadowMapBiasMatrix;
@ -90,7 +90,7 @@ class SceneDemo : public Scene {
static openglframework::Color mDemoColors[]; static openglframework::Color mDemoColors[];
static int32_t mNbDemoColors; static int32_t mNbDemoColors;
std::string mMeshFolderPath; etk::String mMeshFolderPath;
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
@ -117,7 +117,7 @@ class SceneDemo : public Scene {
// -------------------- Methods -------------------- // // -------------------- Methods -------------------- //
/// Constructor /// Constructor
SceneDemo(const std::string& name, float sceneRadius, bool isShadowMappingEnabled = true); SceneDemo(const etk::String& name, float sceneRadius, bool isShadowMappingEnabled = true);
/// Destructor /// Destructor
virtual ~SceneDemo(); virtual ~SceneDemo();
@ -136,7 +136,7 @@ class SceneDemo : public Scene {
void virtual setIsShadowMappingEnabled(bool isShadowMappingEnabled); void virtual setIsShadowMappingEnabled(bool isShadowMappingEnabled);
/// Return all the contact points of the scene /// Return all the contact points of the scene
std::vector<ContactPoint> computeContactPointsOfWorld(const ephysics::DynamicsWorld* world) const; etk::Vector<ContactPoint> computeContactPointsOfWorld(const ephysics::DynamicsWorld* world) const;
}; };
// Enabled/Disable the shadow mapping // Enabled/Disable the shadow mapping

14
tools/testbed/src/TestbedApplication.cpp
View File

@ -95,27 +95,27 @@ void TestbedApplication::createScenes() {
// Cubes scene // Cubes scene
CubesScene* cubeScene = new CubesScene("Cubes"); CubesScene* cubeScene = new CubesScene("Cubes");
mScenes.push_back(cubeScene); mScenes.pushBack(cubeScene);
// Joints scene // Joints scene
JointsScene* jointsScene = new JointsScene("Joints"); JointsScene* jointsScene = new JointsScene("Joints");
mScenes.push_back(jointsScene); mScenes.pushBack(jointsScene);
// Collision shapes scene // Collision shapes scene
CollisionShapesScene* collisionShapesScene = new CollisionShapesScene("Collision Shapes"); CollisionShapesScene* collisionShapesScene = new CollisionShapesScene("Collision Shapes");
mScenes.push_back(collisionShapesScene); mScenes.pushBack(collisionShapesScene);
// Heightfield shape scene // Heightfield shape scene
HeightFieldScene* heightFieldScene = new HeightFieldScene("Heightfield"); HeightFieldScene* heightFieldScene = new HeightFieldScene("Heightfield");
mScenes.push_back(heightFieldScene); mScenes.pushBack(heightFieldScene);
// Raycast scene // Raycast scene
RaycastScene* raycastScene = new RaycastScene("Raycast"); RaycastScene* raycastScene = new RaycastScene("Raycast");
mScenes.push_back(raycastScene); mScenes.pushBack(raycastScene);
// Raycast scene // Raycast scene
ConcaveMeshScene* concaveMeshScene = new ConcaveMeshScene("Concave Mesh"); ConcaveMeshScene* concaveMeshScene = new ConcaveMeshScene("Concave Mesh");
mScenes.push_back(concaveMeshScene); mScenes.pushBack(concaveMeshScene);
assert(mScenes.size() > 0); assert(mScenes.size() > 0);
mCurrentScene = mScenes[0]; mCurrentScene = mScenes[0];
@ -270,7 +270,7 @@ void TestbedApplication::checkOpenGLErrorsInternal(const char* file, int32_t lin
// While there are errors // While there are errors
while (glError != GL_NO_ERROR) { while (glError != GL_NO_ERROR) {
std::string error; etk::String error;
switch(glError) { switch(glError) {
case GL_INVALID_OPERATION: error="INVALID_OPERATION"; break; case GL_INVALID_OPERATION: error="INVALID_OPERATION"; break;

6
tools/testbed/src/TestbedApplication.h
View File

@ -60,7 +60,7 @@ class TestbedApplication : public Screen {
Timer mTimer; Timer mTimer;
/// List of 3D scenes /// List of 3D scenes
std::vector<Scene*> mScenes; etk::Vector<Scene*> mScenes;
/// Current 3D scene /// Current 3D scene
Scene* mCurrentScene; Scene* mCurrentScene;
@ -142,7 +142,7 @@ class TestbedApplication : public Screen {
void destroyScenes(); void destroyScenes();
/// Return the list of the scenes /// Return the list of the scenes
std::vector<Scene*> getScenes(); etk::Vector<Scene*> getScenes();
/// Start/stop the simulation /// Start/stop the simulation
void togglePlayPauseSimulation(); void togglePlayPauseSimulation();
@ -208,7 +208,7 @@ class TestbedApplication : public Screen {
}; };
// Return the list of the scenes // Return the list of the scenes
inline std::vector<Scene*> TestbedApplication::getScenes() { inline etk::Vector<Scene*> TestbedApplication::getScenes() {
return mScenes; return mScenes;
} }