mrq/reactphysics3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'develop' into 'master'

Browse Source
This commit is contained in:
Daniel Chappuis 2020-05-29 00:03:44 +02:00
commit 6d75edd782
2401 changed files with 35805 additions and 481051 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
.gitignore vendored
View File

@ -25,3 +25,21 @@ Thumbs.db
# vim swap files
#####################
*.*sw*
# documentation
#####################
documentation/API/html/
documentation/UserManual/html/
documentation/UserManual/*.4ct
documentation/UserManual/*.4tc
documentation/UserManual/*.aux
documentation/UserManual/*.dvi
documentation/UserManual/*.css
documentation/UserManual/*.html
documentation/UserManual/*.idv
documentation/UserManual/*.lg
documentation/UserManual/*.out
documentation/UserManual/*.tmp
documentation/UserManual/*.toc
documentation/UserManual/*.xref
documentation/UserManual/*.xref

3
.gitmodules vendored Normal file
View File

@ -0,0 +1,3 @@
[submodule "testbed/extern/nanogui"]
path = testbed/extern/nanogui
url = https://github.com/mitsuba-renderer/nanogui.git

145
.travis.yml
View File

@ -9,113 +9,126 @@ matrix:
# ----- Linux / GCC -----
include:
- os: linux
name: "Linux / GCC (Debug)"
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-7
- g++-8
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Debug" DOUBLE_PRECISION="False"
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Debug" DOUBLE_PRECISION="False"
- os: linux
name: "Linux / GCC (Release)"
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-7
- g++-8
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Release" DOUBLE_PRECISION="False"
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Release" DOUBLE_PRECISION="False"
- os: linux
name: "Linux / GCC (Debug, Double Precision)"
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-7
- g++-8
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Debug" DOUBLE_PRECISION="True"
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Debug" DOUBLE_PRECISION="True"
- os: linux
name: "Linux / GCC (Release, Double Precision)"
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-7
- g++-8
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Release" DOUBLE_PRECISION="True"
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Release" DOUBLE_PRECISION="True"
- os: linux
name: "Linux / GCC (Debug, Profiler)"
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-7
- g++-8
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Debug" DOUBLE_PRECISION="False" LOGGER="True" Profiler="True"
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Debug" DOUBLE_PRECISION="False" Profiler="True"
- os: linux
name: "Linux / GCC (Release, Profiler)"
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-7
- g++-8
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Release" DOUBLE_PRECISION="False" LOGGER="True" Profiler="True"
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Release" DOUBLE_PRECISION="False" Profiler="True"
- os: linux
name: "Linux / GCC (Debug, Code Coverage)"
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-7
- g++-8
- lcov
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Release" DOUBLE_PRECISION="False" CODE_COVERAGE="True"
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Debug" DOUBLE_PRECISION="False" CODE_COVERAGE="True"
- os: linux
name: "Linux / GCC (Debug, Valgrind)"
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-7
- g++-8
- valgrind
env:
- MATRIX_EVAL="CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Debug" DOUBLE_PRECISION="False" VALGRIND="True"
- MATRIX_EVAL="CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Debug" DOUBLE_PRECISION="False" VALGRIND="True"
# This is commented until Travis fixes this issue with GCC install in OSX: https://github.com/travis-ci/travis-ci/issues/8826
# ----- OS X / GCC -----
#- os: osx
#- osx_image: xcode9.3
#- env:
# - MATRIX_EVAL="brew update && brew install gcc && CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Debug" DOUBLE_PRECISION="False"
#- os: osx
# osx_image: xcode9.3
# env:
# - MATRIX_EVAL="brew update && brew install gcc && CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Release" DOUBLE_PRECISION="False"
#- os: osx
# osx_image: xcode9.3
# env:
# - MATRIX_EVAL="brew update && brew install gcc && CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Debug" DOUBLE_PRECISION="True"
#- os: osx
# osx_image: xcode9.3
# env:
# - MATRIX_EVAL="brew update && brew install gcc && CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Release" DOUBLE_PRECISION="True"
#- os: osx
# osx_image: xcode9.3
# env:
# - MATRIX_EVAL="brew update && brew install gcc && CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Debug" DOUBLE_PRECISION="True" LOGGER="True" PROFILER="True"
#- os: osx
# osx_image: xcode9.3
# env:
# - MATRIX_EVAL="brew update && brew install gcc && CC=gcc-7 && CXX=g++-7" BUILD_TYPE="Release" DOUBLE_PRECISION="True" LOGGER="True" PROFILER="True"
- os: osx
name: "OS X / GCC (Debug)"
osx_image: xcode11
env:
- MATRIX_EVAL="brew install gcc@8 && CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Debug" DOUBLE_PRECISION="False"
- os: osx
name: "OS X / GCC (Release)"
osx_image: xcode11
env:
- MATRIX_EVAL="brew install gcc@8 && CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Release" DOUBLE_PRECISION="False"
- os: osx
name: "OS X / GCC (Debug, Double Precision)"
osx_image: xcode11
env:
- MATRIX_EVAL="brew install gcc@8 && CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Debug" DOUBLE_PRECISION="True"
- os: osx
name: "OS X / GCC (Release, Double Precision)"
osx_image: xcode11
env:
- MATRIX_EVAL="brew install gcc@8 && CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Release" DOUBLE_PRECISION="True"
- os: osx
name: "OS X / GCC (Debug, Profiler)"
osx_image: xcode11
env:
- MATRIX_EVAL="brew install gcc@8 && CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Debug" DOUBLE_PRECISION="False" PROFILER="True"
- os: osx
name: "OS X / GCC (Release, Profiler)"
osx_image: xcode11
env:
- MATRIX_EVAL="brew install gcc@8 && CC=gcc-8 && CXX=g++-8" BUILD_TYPE="Release" DOUBLE_PRECISION="False" PROFILER="True"
# ----- Linux / Clang -----
- os: linux
name: "Linux / Clang (Debug)"
addons:
apt:
sources:
@ -128,6 +141,7 @@ matrix:
- MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8" BUILD_TYPE="Debug" DOUBLE_PRECISION="False"
- os: linux
name: "Linux / Clang (Release)"
addons:
apt:
sources:
@ -140,6 +154,7 @@ matrix:
- MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8" BUILD_TYPE="Release" DOUBLE_PRECISION="False"
- os: linux
name: "Linux / Clang (Debug, Double Precision)"
addons:
apt:
sources:
@ -152,6 +167,7 @@ matrix:
- MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8" BUILD_TYPE="Debug" DOUBLE_PRECISION="True"
- os: linux
name: "Linux / Clang (Release, Double Precision)"
addons:
apt:
sources:
@ -163,6 +179,7 @@ matrix:
env:
- MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8" BUILD_TYPE="Release" DOUBLE_PRECISION="True"
- os: linux
name: "Linux / Clang (Debug, Double Precision, Profiler)"
addons:
apt:
sources:
@ -172,8 +189,9 @@ matrix:
- clang-3.8
- g++-7
env:
- MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8" BUILD_TYPE="Debug" DOUBLE_PRECISION="True" LOGGER="True" PROFILER="True"
- MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8" BUILD_TYPE="Debug" DOUBLE_PRECISION="True" PROFILER="True"
- os: linux
name: "Linux / Clang (Release, Double Precision, Profiler)"
addons:
apt:
sources:
@ -183,38 +201,44 @@ matrix:
- clang-3.8
- g++-7
env:
- MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8" BUILD_TYPE="Release" DOUBLE_PRECISION="True" LOGGER="True" PROFILER="True"
- MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8" BUILD_TYPE="Release" DOUBLE_PRECISION="True" PROFILER="True"
# ----- OS X / Clang -----
- os: osx
osx_image: xcode8
name: "OS X / Clang (Debug)"
osx_image: xcode11
env:
- BUILD_TYPE="Debug" DOUBLE_PRECISION="False"
- os: osx
osx_image: xcode8
name: "OS X / Clang (Release)"
osx_image: xcode11
env:
- BUILD_TYPE="Release" DOUBLE_PRECISION="False"
- os: osx
osx_image: xcode8
name: "OS X / Clang (Debug, Double Precision)"
osx_image: xcode11
env:
- BUILD_TYPE="Debug" DOUBLE_PRECISION="True"
- os: osx
osx_image: xcode8
name: "OS X / Clang (Release, Double Precision)"
osx_image: xcode11
env:
- BUILD_TYPE="Release" DOUBLE_PRECISION="True"
- os: osx
osx_image: xcode8
name: "OS X / Clang (Debug, Profiler)"
osx_image: xcode11
env:
- BUILD_TYPE="Debug" DOUBLE_PRECISION="True" LOGGER="True" PROFILER="True"
- BUILD_TYPE="Debug" DOUBLE_PRECISION="False" PROFILER="True"
- os: osx
osx_image: xcode8
name: "OS X / Clang (Release, Profiler)"
osx_image: xcode11
env:
- BUILD_TYPE="Release" DOUBLE_PRECISION="True" LOGGER="True" PROFILER="True"
- BUILD_TYPE="Release" DOUBLE_PRECISION="False" PROFILER="True"
before_install:
- eval "${MATRIX_EVAL}"
@ -225,13 +249,22 @@ branches:
- develop
script:
- mkdir build_directory
- cd build_directory
- cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} —DRP3D_DOUBLE_PRECISION_ENABLED=${DOUBLE_PRECISION} -DRP3D_COMPILE_TESTS=True -DRP3D_LOGS_ENABLE=${LOGGER} -DRP3D_PROFILING_ENABLED=${PROFILER} -DRP3D_CODE_COVERAGE_ENABLED=${CODE_COVERAGE} ../
- make && make test ARGS="-V"
- mkdir build_rp3d
- cd build_rp3d
- cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} —DRP3D_DOUBLE_PRECISION_ENABLED=${DOUBLE_PRECISION} -DRP3D_COMPILE_TESTS=True -DRP3D_PROFILING_ENABLED=${PROFILER} -DRP3D_CODE_COVERAGE_ENABLED=${CODE_COVERAGE} ../
- make -j2 && make test ARGS="-V"
- if [ "${VALGRIND}" == "True" ]; then
valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --verbose --error-exitcode=1 test/tests;
fi
- if [ "${CODE_COVERAGE}" == "False" ]; then
sudo make install;
cd ../;
mkdir build_helloworld;
cd build_helloworld;
cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} ../helloworld/;
make -j2;
fi
after_success:

97
CHANGELOG.md
View File

@ -1,12 +1,97 @@
# Changelog
## Version 0.8.0
Note that this release contains some public API changes. Please read carefully the following changes before upgrading to this new version and
do not hesitate to take a look at the user manual.
### Added
- It is now possible to change the size of a BoxShape using the BoxShape::setHalfExtents() method
- It is now possible to change the radius of a SphereShape using the SphereShape::setRadius() method
- It is now possible to change the height and radius of a CapsuleShape using the CapsuleShape::setHeight() and CapsuleShape::setRadius() methods
- It is now possible to change the scale of a ConvexMeshShape using the ConvexMeshShape::setScale() method
- It is now possible to change the scale of a ConcaveMeshShape using the ConcaveMeshShape::setScale() method
- It is now possible to change the scale of a HeightFieldShape using the HeightFieldShape::setScale() method
- A method PhysicsWorld::getCollisionBody(uint index) has been added on a physics world to retrieve a given CollisionBody
- A method PhysicsWorld::getRigidBody(uint index) has been added on a physics world to retrieve a given RigidBody
- A RigidBody::getLocalCenterOfMass() method has been added to retrieve the current local-space center of mass of a rigid body
- Add PhysicsCommon class that needs to be instanciated at the beginning and is used as a factory for other objects of the library (see the user manual)
- The RigidBody::updateLocalCenterOfMassFromColliders() method has been added to compute and set the center of mass of a body using its colliders
- The RigidBody::updateLocalInertiaTensorFromColliders() method has been added to compute and set the local inertia tensor of a body using its colliders
- The RigidBody::getLocalInertiaTensor() method has been added to retrieve the local-space inertia tensor of a rigid body
- The RigidBody::updateMassFromColliders() method has been added to compute and set the mass of a body using its colliders
- A Material nows has a mass density parameter that can be set using the Material::setMassDensity() method. The mass density is used to compute the mass of a collider when computing the mass of a rigid body
- A Collider can now be a trigger. This collider will be used to only report collisions with another collider but no collision response will be applied. You can use the Collider::setIsTrigger() method for this.
- The EventListener class now has a onTrigger() method that is called when a trigger collider is colling with another collider
- In the EventListener, the onContact() and onTrigger() method now reports the type of event (start, stay, exit) for each contact. This way the user can know whether it's a new contact or not or when two colliders are not in contact anymore
- A DebugRenderer class has been added in order to display debug info (colliders, AABBs, contacts, ...) in your simulation using graphics primitives (lines, triangles).
- A RigidBody::applyForceAtLocalPosition() method has been added to apply a force at a given position of the rigid body in local-space
- A default logger can be instanciated using the PhysicsCommon::createDefaultLogger() method
- The CMakeLists.txt file of the library has been refactored to use modern CMake. The targets are now exported when you install the library so that you can import the library with the find_package(ReactPhysics3D) function in your own CMakeLists.txt file
- A Hello World project has been added to show a very simple project that shows how to compile and use the ReactPhysics3D library
### Fixed
- Issues [#125](https://github.com/DanielChappuis/reactphysics3d/issues/125) and [#106](https://github.com/DanielChappuis/reactphysics3d/issues/106) with CMake install of the library have been fixed
- Issue [#141](https://github.com/DanielChappuis/reactphysics3d/issues/141) with limits of hinge and slider joints has been fixed
- Issue [#117](https://github.com/DanielChappuis/reactphysics3d/issues/117) in documentation has been fixed
- Issue [#131](https://github.com/DanielChappuis/reactphysics3d/issues/131) in documentation has been fixed
- Issue [#139](https://github.com/DanielChappuis/reactphysics3d/issues/139) in API documentation has been fixed
- Issue [#122](https://github.com/DanielChappuis/reactphysics3d/issues/122) in logger has been fixed
### Changed
- The CollisionWorld::testCollision() methods do not have the 'categoryMaskBits' parameter anymore
- The CollisionWorld::testOverlap() methods do not have the 'categoryMaskBits' parameter anymore
- Many methods in the EventListener class have changed. Check the user manual for more information
- The way to retrieve contacts has changed. Check the user manual for more information
- DynamicsWorld and CollisionWorld classes have been merged into a single class called PhysicsWorld
- The ProxyShape class has been renamed into Collider
- The Material is now part of the Collider instead of the RigidBody. Therefore, it is now possible to have a RigidBody with multiple
colliders and a different material for each Collider
- The Logger has to be set using the PhysicsCommon::setLogger() method
- The Box::getExtent() method has been renamed to Box::getHalfExtents()
- An instance of the BoxShape class cannot be instanciated directly anymore. You need to use the PhysicsCommon::createBoxShape() method
- An instance of the SphereShape class cannot be instanciated directly anymore. You need to use the PhysicsCommon::createSphereShape() method
- An instance of the CapsuleShape class cannot be instanciated directly anymore. You need to use the PhysicsCommon::createCapsuleShape() method
- An instance of the ConvexMeshShape class cannot be instanciated directly anymore. You need to use the PhysicsCommon::createConvexMeshShape() method
- An instance of the HeightFieldShape class cannot be instanciated directly anymore. You need to use the PhysicsCommon::createHeightFieldShape() method
- An instance of the ConcaveMeshShape class cannot be instanciated directly anymore. You need to use the PhysicsCommon::createConcaveMeshShape() method
- An instance of the PolyhedronMesh class cannot be instanciated directly anymore. You need to use the PhysicsCommon::createPolyhedronMesh() method
- An instance of the TriangleMesh class cannot be instanciated directly anymore. You need to use the PhysicsCommon::createTriangleMesh() method
- The ProxyShape class has been renamed to Collider. The CollisionBody::addCollider(), RigidBody::addCollider() methods have to be used to create and add a collider to a body. Then methods CollisionBody::removeCollider(), RigidBody::removeCollider() need to be used to remove a collider from a body.
- The RigidBody::addCollider() method (previously addProxyShape() method) does not take a "mass" parameter anymore
- The RigidBody::setCenterOfMassLocal() method has been renamed to RigidBody::setLocalCenterOfMass()
- The RigidBody::setInertiaTensorLocal() method has been renamed to RigidBody::setLocalInertiaTensor()
- Now, the local inertia tensor of a rigid body has to be set using a Vector3 instead of a Matrix3x3. You only need to provide the three diagonal values of the matrix
- The RigidBody::recomputeMassInformation() method has been renamed to RigidBody::updateMassPropertiesFromColliders.
- Now, you need to manually call the RigidBody::updateMassPropertiesFromColliders() method after adding colliders to a rigid body to recompute its inertia tensor, center of mass and mass. There are other methods that you can use form that (see the user manual)
- The RigidBody::applyForce() method has been renamed to RigidBody::applyForceAtWorldPosition()
- The rendering in the testbed application has been improved
- Many of the data inside the library have been refactored for better caching and easier parallelization in the future
- The old Logger class has been renamed to DefaultLogger
- The Logger class is now an abstract class that you can inherit from in order to receive log events from the library
- User manual and API documentation have been updated
### Removed
- The method DynamicsWorld::getContactsList() has been removed. You need to use the EventListener class to retrieve contacts now (see the user manual).
- The DynamicsWorld::getNbJoints() method has been removed.
- The EventListener::beginInternalTick() method has been removed (because internal ticks do not exist anymore).
- The EventListener::endInternalTick() method has been removed (because internal ticks do not exist anymore).
- The RigidBody::getJointsList() method has been removed.
- It is not possible anymore to set custom pool and stack frame allocators. Only the base allocator can be customized when creating a PhysicsCommon instance.
- The RigidBody::setInverseInertiaTensorLocal() method has been removed. The RigidBody::setInertiaTensorLocal() has to be used instead.
- The RigidBody::getInverseInertiaTensorWorld() method has been removed.
- The Collider::getMass() method has been removed.
## Version 0.7.1 (July 01, 2019)
### Added
- Make possible for the user to get vertices, normals and triangle indices of a ConcaveMeshShape
- Make possible for the user to get vertices and height values of the HeightFieldShape
- Make possible for the user to use a custom single frame and pool memory allocator
### Fixed
@ -27,6 +112,16 @@
- Bug [#79](https://github.com/DanielChappuis/reactphysics3d/issues/79) has been fixed.
- Bug: the free() method was called in PoolAllocator instead of release() method of base allocator.
### Removed
- The CollisionWorld::setCollisionDispatch() method has been removed. In order to use a custom collision
algorithm, you must not get the collision dispatch object with the
CollisionWorld::getCollisionDispatch() method and set a collision algorithm to this object.
- The methods CollisionBody::getProxyShapesList() has been remove. You can now use the
CollisionBody::getNbProxyShapes() method to know the number of proxy-shapes of a body and the
CollisionBody::getProxyShape(uint proxyShapeIndex) method to get a given proxy-shape of the body.
- The CollisionWorld::testAABBOverlap() methods have been removed.
## Version 0.7.0 (May 1, 2018)
### Added

420
CMakeLists.txt
View File

@ -1,176 +1,162 @@
# Minimum cmake version required
CMAKE_MINIMUM_REQUIRED(VERSION 3.2 FATAL_ERROR)
cmake_minimum_required(VERSION 3.8)
# Project configuration
PROJECT(REACTPHYSICS3D LANGUAGES CXX)
project(ReactPhysics3D VERSION 0.8.0 LANGUAGES CXX)
# In order to install libraries into correct locations on all platforms.
include(GNUInstallDirs)
# Build type
IF (NOT CMAKE_BUILD_TYPE)
SET(CMAKE_BUILD_TYPE "Release")
ENDIF()
# Where to build the library
SET(LIBRARY_OUTPUT_PATH "lib")
# Where to build the executables
SET(OUR_EXECUTABLE_OUTPUT_PATH "${PROJECT_BINARY_DIR}/bin")
# Set default build type
set(default_build_type "Release")
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE
STRING "Choose the type of build." FORCE)
# Set the possible values of build type for cmake-gui
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
"Debug" "Release" "MinSizeRel" "RelWithDebInfo")
endif()
# CMake modules path
SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules)
set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules)
# Enable testing
ENABLE_TESTING()
enable_testing()
# Options
OPTION(RP3D_COMPILE_TESTBED "Select this if you want to build the testbed application" OFF)
OPTION(RP3D_COMPILE_TESTS "Select this if you want to build the tests" OFF)
OPTION(RP3D_PROFILING_ENABLED "Select this if you want to compile with enabled profiling" OFF)
OPTION(RP3D_LOGS_ENABLED "Select this if you want to compile with logs enabled during execution" OFF)
OPTION(RP3D_CODE_COVERAGE_ENABLED "Select this if you need to build for code coverage calculation" OFF)
OPTION(RP3D_DOUBLE_PRECISION_ENABLED "Select this if you want to compile using double precision floating
values" OFF)
option(RP3D_COMPILE_TESTBED "Select this if you want to build the testbed application with demos" OFF)
option(RP3D_COMPILE_TESTS "Select this if you want to build the unit tests" OFF)
option(RP3D_PROFILING_ENABLED "Select this if you want to compile for performanace profiling" OFF)
option(RP3D_CODE_COVERAGE_ENABLED "Select this if you need to build for code coverage calculation" OFF)
option(RP3D_DOUBLE_PRECISION_ENABLED "Select this if you want to compile using double precision floating values" OFF)
# Warning Compiler flags
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
IF(RP3D_CODE_COVERAGE_ENABLED)
IF(CMAKE_COMPILER_IS_GNUCXX)
if(RP3D_CODE_COVERAGE_ENABLED)
if(CMAKE_COMPILER_IS_GNUCXX)
INCLUDE(CodeCoverage)
SETUP_TARGET_FOR_COVERAGE(${PROJECT_NAME}_coverage tests coverage)
ENDIF()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
ENDIF()
endif()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
endif()
# C++11 flags
IF(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU")
include(CheckCXXCompilerFlag)
CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
IF(COMPILER_SUPPORTS_CXX11)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
ELSE()
message("The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
ENDIF()
ENDIF()
# Use libc++ with Clang
#IF(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
# SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
#ENDIF()
IF(RP3D_PROFILING_ENABLED)
ADD_DEFINITIONS(-DIS_PROFILING_ACTIVE)
ENDIF()
IF(RP3D_LOGS_ENABLED)
ADD_DEFINITIONS(-DIS_LOGGING_ACTIVE)
ENDIF()
IF(RP3D_DOUBLE_PRECISION_ENABLED)
ADD_DEFINITIONS(-DIS_DOUBLE_PRECISION_ENABLED)
ENDIF()
# Headers files
SET (REACTPHYSICS3D_HEADERS
"src/configuration.h"
"src/decimal.h"
"src/reactphysics3d.h"
"src/body/Body.h"
"src/body/CollisionBody.h"
"src/body/RigidBody.h"
"src/collision/ContactPointInfo.h"
"src/collision/ContactManifoldInfo.h"
"src/collision/broadphase/BroadPhaseAlgorithm.h"
"src/collision/broadphase/DynamicAABBTree.h"
"src/collision/narrowphase/CollisionDispatch.h"
"src/collision/narrowphase/DefaultCollisionDispatch.h"
"src/collision/narrowphase/GJK/VoronoiSimplex.h"
"src/collision/narrowphase/GJK/GJKAlgorithm.h"
"src/collision/narrowphase/SAT/SATAlgorithm.h"
"src/collision/narrowphase/NarrowPhaseAlgorithm.h"
"src/collision/narrowphase/SphereVsSphereAlgorithm.h"
"src/collision/narrowphase/CapsuleVsCapsuleAlgorithm.h"
"src/collision/narrowphase/SphereVsCapsuleAlgorithm.h"
"src/collision/narrowphase/SphereVsConvexPolyhedronAlgorithm.h"
"src/collision/narrowphase/CapsuleVsConvexPolyhedronAlgorithm.h"
"src/collision/narrowphase/ConvexPolyhedronVsConvexPolyhedronAlgorithm.h"
"src/collision/shapes/AABB.h"
"src/collision/shapes/ConvexShape.h"
"src/collision/shapes/ConvexPolyhedronShape.h"
"src/collision/shapes/ConcaveShape.h"
"src/collision/shapes/BoxShape.h"
"src/collision/shapes/CapsuleShape.h"
"src/collision/shapes/CollisionShape.h"
"src/collision/shapes/ConvexMeshShape.h"
"src/collision/shapes/SphereShape.h"
"src/collision/shapes/TriangleShape.h"
"src/collision/shapes/ConcaveMeshShape.h"
"src/collision/shapes/HeightFieldShape.h"
"src/collision/RaycastInfo.h"
"src/collision/ProxyShape.h"
"src/collision/TriangleVertexArray.h"
"src/collision/PolygonVertexArray.h"
"src/collision/TriangleMesh.h"
"src/collision/PolyhedronMesh.h"
"src/collision/HalfEdgeStructure.h"
"src/collision/CollisionDetection.h"
"src/collision/NarrowPhaseInfo.h"
"src/collision/ContactManifold.h"
"src/collision/ContactManifoldSet.h"
"src/collision/MiddlePhaseTriangleCallback.h"
"src/constraint/BallAndSocketJoint.h"
"src/constraint/ContactPoint.h"
"src/constraint/FixedJoint.h"
"src/constraint/HingeJoint.h"
"src/constraint/Joint.h"
"src/constraint/SliderJoint.h"
"src/engine/CollisionWorld.h"
"src/engine/ConstraintSolver.h"
"src/engine/ContactSolver.h"
"src/engine/DynamicsWorld.h"
"src/engine/EventListener.h"
"src/engine/Island.h"
"src/engine/Material.h"
"src/engine/OverlappingPair.h"
"src/engine/Timer.h"
"src/engine/Timer.cpp"
"src/collision/CollisionCallback.h"
"src/collision/OverlapCallback.h"
"src/mathematics/mathematics.h"
"src/mathematics/mathematics_functions.h"
"src/mathematics/Matrix2x2.h"
"src/mathematics/Matrix3x3.h"
"src/mathematics/Quaternion.h"
"src/mathematics/Transform.h"
"src/mathematics/Vector2.h"
"src/mathematics/Vector3.h"
"src/mathematics/Ray.h"
"src/memory/MemoryAllocator.h"
"src/memory/DefaultPoolAllocator.h"
"src/memory/DefaultSingleFrameAllocator.h"
"src/memory/DefaultAllocator.h"
"src/memory/MemoryManager.h"
"src/containers/Stack.h"
"src/containers/LinkedList.h"
"src/containers/List.h"
"src/containers/Map.h"
"src/containers/Set.h"
"src/containers/Pair.h"
"src/utils/Profiler.h"
"src/utils/Logger.h"
# Headers filen1s
set (REACTPHYSICS3D_HEADERS
"include/reactphysics3d/configuration.h"
"include/reactphysics3d/decimal.h"
"include/reactphysics3d/reactphysics3d.h"
"include/reactphysics3d/body/CollisionBody.h"
"include/reactphysics3d/body/RigidBody.h"
"include/reactphysics3d/collision/ContactPointInfo.h"
"include/reactphysics3d/collision/ContactManifoldInfo.h"
"include/reactphysics3d/collision/ContactPair.h"
"include/reactphysics3d/collision/broadphase/DynamicAABBTree.h"
"include/reactphysics3d/collision/narrowphase/CollisionDispatch.h"
"include/reactphysics3d/collision/narrowphase/GJK/VoronoiSimplex.h"
"include/reactphysics3d/collision/narrowphase/GJK/GJKAlgorithm.h"
"include/reactphysics3d/collision/narrowphase/SAT/SATAlgorithm.h"
"include/reactphysics3d/collision/narrowphase/NarrowPhaseAlgorithm.h"
"include/reactphysics3d/collision/narrowphase/SphereVsSphereAlgorithm.h"
"include/reactphysics3d/collision/narrowphase/CapsuleVsCapsuleAlgorithm.h"
"include/reactphysics3d/collision/narrowphase/SphereVsCapsuleAlgorithm.h"
"include/reactphysics3d/collision/narrowphase/SphereVsConvexPolyhedronAlgorithm.h"
"include/reactphysics3d/collision/narrowphase/CapsuleVsConvexPolyhedronAlgorithm.h"
"include/reactphysics3d/collision/narrowphase/ConvexPolyhedronVsConvexPolyhedronAlgorithm.h"
"include/reactphysics3d/collision/narrowphase/NarrowPhaseInput.h"
"include/reactphysics3d/collision/narrowphase/NarrowPhaseInfoBatch.h"
"include/reactphysics3d/collision/narrowphase/SphereVsSphereNarrowPhaseInfoBatch.h"
"include/reactphysics3d/collision/narrowphase/CapsuleVsCapsuleNarrowPhaseInfoBatch.h"
"include/reactphysics3d/collision/narrowphase/SphereVsCapsuleNarrowPhaseInfoBatch.h"
"include/reactphysics3d/collision/shapes/AABB.h"
"include/reactphysics3d/collision/shapes/ConvexShape.h"
"include/reactphysics3d/collision/shapes/ConvexPolyhedronShape.h"
"include/reactphysics3d/collision/shapes/ConcaveShape.h"
"include/reactphysics3d/collision/shapes/BoxShape.h"
"include/reactphysics3d/collision/shapes/CapsuleShape.h"
"include/reactphysics3d/collision/shapes/CollisionShape.h"
"include/reactphysics3d/collision/shapes/ConvexMeshShape.h"
"include/reactphysics3d/collision/shapes/SphereShape.h"
"include/reactphysics3d/collision/shapes/TriangleShape.h"
"include/reactphysics3d/collision/shapes/ConcaveMeshShape.h"
"include/reactphysics3d/collision/shapes/HeightFieldShape.h"
"include/reactphysics3d/collision/RaycastInfo.h"
"include/reactphysics3d/collision/Collider.h"
"include/reactphysics3d/collision/TriangleVertexArray.h"
"include/reactphysics3d/collision/PolygonVertexArray.h"
"include/reactphysics3d/collision/TriangleMesh.h"
"include/reactphysics3d/collision/PolyhedronMesh.h"
"include/reactphysics3d/collision/HalfEdgeStructure.h"
"include/reactphysics3d/collision/ContactManifold.h"
"include/reactphysics3d/constraint/BallAndSocketJoint.h"
"include/reactphysics3d/constraint/ContactPoint.h"
"include/reactphysics3d/constraint/FixedJoint.h"
"include/reactphysics3d/constraint/HingeJoint.h"
"include/reactphysics3d/constraint/Joint.h"
"include/reactphysics3d/constraint/SliderJoint.h"
"include/reactphysics3d/engine/Entity.h"
"include/reactphysics3d/engine/EntityManager.h"
"include/reactphysics3d/engine/PhysicsCommon.h"
"include/reactphysics3d/systems/ConstraintSolverSystem.h"
"include/reactphysics3d/systems/ContactSolverSystem.h"
"include/reactphysics3d/systems/DynamicsSystem.h"
"include/reactphysics3d/systems/CollisionDetectionSystem.h"
"include/reactphysics3d/systems/SolveBallAndSocketJointSystem.h"
"include/reactphysics3d/systems/SolveFixedJointSystem.h"
"include/reactphysics3d/systems/SolveHingeJointSystem.h"
"include/reactphysics3d/systems/SolveSliderJointSystem.h"
"include/reactphysics3d/engine/PhysicsWorld.h"
"include/reactphysics3d/engine/EventListener.h"
"include/reactphysics3d/engine/Island.h"
"include/reactphysics3d/engine/Islands.h"
"include/reactphysics3d/engine/Material.h"
"include/reactphysics3d/engine/Timer.h"
"include/reactphysics3d/engine/OverlappingPairs.h"
"include/reactphysics3d/systems/BroadPhaseSystem.h"
"include/reactphysics3d/components/Components.h"
"include/reactphysics3d/components/CollisionBodyComponents.h"
"include/reactphysics3d/components/RigidBodyComponents.h"
"include/reactphysics3d/components/TransformComponents.h"
"include/reactphysics3d/components/ColliderComponents.h"
"include/reactphysics3d/components/JointComponents.h"
"include/reactphysics3d/components/BallAndSocketJointComponents.h"
"include/reactphysics3d/components/FixedJointComponents.h"
"include/reactphysics3d/components/HingeJointComponents.h"
"include/reactphysics3d/components/SliderJointComponents.h"
"include/reactphysics3d/collision/CollisionCallback.h"
"include/reactphysics3d/collision/OverlapCallback.h"
"include/reactphysics3d/mathematics/mathematics.h"
"include/reactphysics3d/mathematics/mathematics_functions.h"
"include/reactphysics3d/mathematics/Matrix2x2.h"
"include/reactphysics3d/mathematics/Matrix3x3.h"
"include/reactphysics3d/mathematics/Quaternion.h"
"include/reactphysics3d/mathematics/Transform.h"
"include/reactphysics3d/mathematics/Vector2.h"
"include/reactphysics3d/mathematics/Vector3.h"
"include/reactphysics3d/mathematics/Ray.h"
"include/reactphysics3d/memory/MemoryAllocator.h"
"include/reactphysics3d/memory/PoolAllocator.h"
"include/reactphysics3d/memory/SingleFrameAllocator.h"
"include/reactphysics3d/memory/HeapAllocator.h"
"include/reactphysics3d/memory/DefaultAllocator.h"
"include/reactphysics3d/memory/MemoryManager.h"
"include/reactphysics3d/containers/Stack.h"
"include/reactphysics3d/containers/LinkedList.h"
"include/reactphysics3d/containers/List.h"
"include/reactphysics3d/containers/Map.h"
"include/reactphysics3d/containers/Set.h"
"include/reactphysics3d/containers/Pair.h"
"include/reactphysics3d/containers/Deque.h"
"include/reactphysics3d/utils/Profiler.h"
"include/reactphysics3d/utils/Logger.h"
"include/reactphysics3d/utils/DefaultLogger.h"
"include/reactphysics3d/utils/DebugRenderer.h"
)
# Source files
SET (REACTPHYSICS3D_SOURCES
"src/body/Body.cpp"
set (REACTPHYSICS3D_SOURCES
"src/body/CollisionBody.cpp"
"src/body/RigidBody.cpp"
"src/collision/ContactManifoldInfo.cpp"
"src/collision/broadphase/BroadPhaseAlgorithm.cpp"
"src/collision/broadphase/DynamicAABBTree.cpp"
"src/collision/narrowphase/DefaultCollisionDispatch.cpp"
"src/collision/narrowphase/CollisionDispatch.cpp"
"src/collision/narrowphase/GJK/VoronoiSimplex.cpp"
"src/collision/narrowphase/GJK/GJKAlgorithm.cpp"
"src/collision/narrowphase/SAT/SATAlgorithm.cpp"
@ -180,6 +166,11 @@ SET (REACTPHYSICS3D_SOURCES
"src/collision/narrowphase/SphereVsConvexPolyhedronAlgorithm.cpp"
"src/collision/narrowphase/CapsuleVsConvexPolyhedronAlgorithm.cpp"
"src/collision/narrowphase/ConvexPolyhedronVsConvexPolyhedronAlgorithm.cpp"
"src/collision/narrowphase/NarrowPhaseInput.cpp"
"src/collision/narrowphase/NarrowPhaseInfoBatch.cpp"
"src/collision/narrowphase/SphereVsSphereNarrowPhaseInfoBatch.cpp"
"src/collision/narrowphase/CapsuleVsCapsuleNarrowPhaseInfoBatch.cpp"
"src/collision/narrowphase/SphereVsCapsuleNarrowPhaseInfoBatch.cpp"
"src/collision/shapes/AABB.cpp"
"src/collision/shapes/ConvexShape.cpp"
"src/collision/shapes/ConvexPolyhedronShape.cpp"
@ -193,32 +184,48 @@ SET (REACTPHYSICS3D_SOURCES
"src/collision/shapes/ConcaveMeshShape.cpp"
"src/collision/shapes/HeightFieldShape.cpp"
"src/collision/RaycastInfo.cpp"
"src/collision/ProxyShape.cpp"
"src/collision/Collider.cpp"
"src/collision/TriangleVertexArray.cpp"
"src/collision/PolygonVertexArray.cpp"
"src/collision/TriangleMesh.cpp"
"src/collision/PolyhedronMesh.cpp"
"src/collision/HalfEdgeStructure.cpp"
"src/collision/CollisionDetection.cpp"
"src/collision/NarrowPhaseInfo.cpp"
"src/collision/ContactManifold.cpp"
"src/collision/ContactManifoldSet.cpp"
"src/collision/MiddlePhaseTriangleCallback.cpp"
"src/constraint/BallAndSocketJoint.cpp"
"src/constraint/ContactPoint.cpp"
"src/constraint/FixedJoint.cpp"
"src/constraint/HingeJoint.cpp"
"src/constraint/Joint.cpp"
"src/constraint/SliderJoint.cpp"
"src/engine/CollisionWorld.cpp"
"src/engine/ConstraintSolver.cpp"
"src/engine/ContactSolver.cpp"
"src/engine/DynamicsWorld.cpp"
"src/engine/PhysicsCommon.cpp"
"src/systems/ConstraintSolverSystem.cpp"
"src/systems/ContactSolverSystem.cpp"
"src/systems/DynamicsSystem.cpp"
"src/systems/CollisionDetectionSystem.cpp"
"src/systems/SolveBallAndSocketJointSystem.cpp"
"src/systems/SolveFixedJointSystem.cpp"
"src/systems/SolveHingeJointSystem.cpp"
"src/systems/SolveSliderJointSystem.cpp"
"src/engine/PhysicsWorld.cpp"
"src/engine/Island.cpp"
"src/engine/Material.cpp"
"src/engine/OverlappingPair.cpp"
"src/engine/Timer.cpp"
"src/engine/OverlappingPairs.cpp"
"src/engine/Entity.cpp"
"src/engine/EntityManager.cpp"
"src/systems/BroadPhaseSystem.cpp"
"src/components/Components.cpp"
"src/components/CollisionBodyComponents.cpp"
"src/components/RigidBodyComponents.cpp"
"src/components/TransformComponents.cpp"
"src/components/ColliderComponents.cpp"
"src/components/JointComponents.cpp"
"src/components/BallAndSocketJointComponents.cpp"
"src/components/FixedJointComponents.cpp"
"src/components/HingeJointComponents.cpp"
"src/components/SliderJointComponents.cpp"
"src/collision/CollisionCallback.cpp"
"src/collision/OverlapCallback.cpp"
"src/mathematics/mathematics_functions.cpp"
"src/mathematics/Matrix2x2.cpp"
"src/mathematics/Matrix3x3.cpp"
@ -226,46 +233,103 @@ SET (REACTPHYSICS3D_SOURCES
"src/mathematics/Transform.cpp"
"src/mathematics/Vector2.cpp"
"src/mathematics/Vector3.cpp"
"src/memory/DefaultPoolAllocator.cpp"
"src/memory/DefaultSingleFrameAllocator.cpp"
"src/memory/PoolAllocator.cpp"
"src/memory/SingleFrameAllocator.cpp"
"src/memory/HeapAllocator.cpp"
"src/memory/MemoryManager.cpp"
"src/utils/Profiler.cpp"
"src/utils/Logger.cpp"
"src/utils/DefaultLogger.cpp"
"src/utils/DebugRenderer.cpp"
)
# Create the library
ADD_LIBRARY(reactphysics3d ${REACTPHYSICS3D_HEADERS} ${REACTPHYSICS3D_SOURCES})
add_library(reactphysics3d ${REACTPHYSICS3D_HEADERS} ${REACTPHYSICS3D_SOURCES})
# Headers
TARGET_INCLUDE_DIRECTORIES(reactphysics3d PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
# Creates an Alias Target, such that "ReactPhysics3D::reactphysics3d" can be used
# to refer to "reactphysics3d" in subsequent commands
add_library(ReactPhysics3D::reactphysics3d ALIAS reactphysics3d)
# C++11 compiler features
target_compile_features(reactphysics3d PUBLIC cxx_std_11)
set_target_properties(reactphysics3d PROPERTIES CXX_EXTENSIONS OFF)
# Compile with warning messages
target_compile_options(reactphysics3d PRIVATE
$<$<CXX_COMPILER_ID:MSVC>:/W4> # for Visual Studio
$<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra -pedantic> # Other compilers
)
# Library headers
target_include_directories(reactphysics3d PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
)
# If we need to compile the testbed application
IF(RP3D_COMPILE_TESTBED)
if(RP3D_COMPILE_TESTBED)
add_subdirectory(testbed/)
ENDIF()
endif()
# If we need to compile the tests
IF(RP3D_COMPILE_TESTS)
if(RP3D_COMPILE_TESTS)
add_subdirectory(test/)
ENDIF()
endif()
SET_TARGET_PROPERTIES(reactphysics3d PROPERTIES PUBLIC_HEADER "${REACTPHYSICS3D_HEADERS}")
# Enable profiling if necessary
if(RP3D_PROFILING_ENABLED)
target_compile_definitions(reactphysics3d PUBLIC IS_RP3D_PROFILING_ENABLED)
endif()
# Enable double precision if necessary
if(RP3D_DOUBLE_PRECISION_ENABLED)
target_compile_definitions(reactphysics3d PUBLIC IS_RP3D_DOUBLE_PRECISION_ENABLED)
endif()
# Version number and soname for the library
SET_TARGET_PROPERTIES(reactphysics3d PROPERTIES
VERSION "0.7.1"
SOVERSION "0.7"
set_target_properties(reactphysics3d PROPERTIES
VERSION "0.8.0"
SOVERSION "0.8"
)
# Install target (install library only, not headers)
INSTALL(TARGETS reactphysics3d
install(TARGETS reactphysics3d
EXPORT reactphysics3d-targets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
# Install the headers separately (because INSTALL(TARGETS ... PUBLIC_HEADER DESTINATION ...) does not support subfolders
INSTALL(DIRECTORY src/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/reactphysics3d FILES_MATCHING PATTERN "*.h")
# Install the headers separately (because INSTALL(TARGETS ... PUBLIC_HEADER DESTINATION ...) does
# not support subfolders
install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
# This is required so that the exported target has the name JSONUtils and not jsonutils
set_target_properties(reactphysics3d PROPERTIES EXPORT_NAME ReactPhysics3D)
# Give CMake access to the version number of the library so that the user is able to use the find_package() function
# with a given version number to select the version of the library he/she wants to use. This will create a
# "ReactPhysics3DConfigVersion.cmake" file that will later be copied into the install destination folder (see below)
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
${CMAKE_CURRENT_BINARY_DIR}/ReactPhysics3DConfigVersion.cmake
VERSION ${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
)
# When the user runs "make install", this will export the targets into
# a "ReactPhysics3DConfig.cmake" file in the install destination
install(EXPORT reactphysics3d-targets
FILE
ReactPhysics3DConfig.cmake
NAMESPACE
ReactPhysics3D::
DESTINATION
${CMAKE_INSTALL_LIBDIR}/cmake/ReactPhysics3D
)
# When the user runs "make install", this will copy the "ReactPhysics3DConfigVersion.cmake" file
# we have previously created into the install destination
install(FILES
${CMAKE_CURRENT_BINARY_DIR}/ReactPhysics3DConfigVersion.cmake
DESTINATION lib/cmake/ReactPhysics3D
)

17
GenerateNewVersion.py
View File

@ -35,6 +35,11 @@ file.write(newVersion + "\n")
file.close()
print("Version number has been updated in VERSION file")
# Update the RP3D version number in the CMakeLists.txt file
findReplaceText("./", r'(ReactPhysics3D[ \t]+VERSION[ \t]+)[\d\.]+', r'\g<1>' + newVersion, "CMakeLists.txt")
findReplaceText("./", r'([ \t]VERSION[ \t]+)"[\d\.]+"', r'\g<1>"' + newVersion + '"', "CMakeLists.txt")
print("Version number has been updated in CMakeLists.txt file")
# Update the RP3D version number in the documentation/API/Doxyfile file
findReplaceText("documentation/API/", r'(PROJECT_NUMBER[ \t]+=[ \t]+)"[\d\.]+"', r'\g<1>"' + newVersion + '"', "Doxyfile")
print("Version number has been updated in documentation/API/Doxyfile file")
@ -44,18 +49,20 @@ findReplaceText("documentation/UserManual/", r'(Version:[\s]+)[\d\.]+', r'\g<1>'
print("Version number has been updated in documentation/UserManual/title.tex file")
# Update the RP3D version number in the src/configuration.h file
findReplaceText("src/", r'(RP3D_VERSION[ \t]+=[ \t]+std::string\()"[\d\.]+"', r'\g<1>"' + newVersion + '"', "configuration.h")
print("Version number has been updated in src/configuration.h file")
findReplaceText("include/reactphysics3d/", r'(RP3D_VERSION[ \t]+=[ \t]+std::string\()"[\d\.]+"', r'\g<1>"' + newVersion + '"', "configuration.h")
print("Version number has been updated in include/reactphysics3d/configuration.h file")
# Update the RP3D version number in the src/reactphysics3d.h file
findReplaceText("src/", r'(\* Version[ \t]+)[\d\.]+', r'\g<1>' + newVersion, "reactphysics3d.h")
print("Version number has been updated in src/reactphysics3d.h file")
findReplaceText("include/reactphysics3d/", r'(\* Version[ \t]+)[\d\.]+', r'\g<1>' + newVersion, "reactphysics3d.h")
print("Version number has been updated in include/reactphysics3d/reactphysics3d.h file")
# Update the copyright date in LICENSE file
findReplaceText("./", '(Copyright ' + re.escape("(c)") + r' 2010-)[\d]+', r'\g<1>' + str(date.today().year), "LICENSE")
print("Copyright date has been updated in LICENSE file")
# Update the copyright date of the license in every source code files
findReplaceText("src/", '(Copyright ' + re.escape("(c)") + r' 2010-)[\d]+', r'\g<1>' + str(date.today().year), "*.h")
findReplaceText("include/", '(Copyright ' + re.escape("(c)") + r' 2010-)[\d]+', r'\g<1>' + str(date.today().year), "*.h")
findReplaceText("src/", '(Copyright ' + re.escape("(c)") + r' 2010-)[\d]+', r'\g<1>' + str(date.today().year), "*.cpp")
print("Copyright date in license has been updated in all source code files")
print("WARNING: Do not forget to manually update the SOVERSION number in the CMakeLists.txt file")

2
LICENSE
View File

@ -1,4 +1,4 @@
Copyright (c) 2010-2019 Daniel Chappuis http://www.reactphysics3d.com
Copyright (c) 2010-2020 Daniel Chappuis http://www.reactphysics3d.com
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages

3
README.md
View File

@ -31,7 +31,8 @@ ReactPhysics3D has the following features:
- No external libraries (do not use STL containers)
- Documentation (user manual and Doxygen API)
- Testbed application with demos
- Integrated Profiler
- Integrated profiler
- Debugging renderer
- Logs
- Unit tests

2
VERSION
View File

@ -1 +1 @@
0.7.1
0.8.0

2503
documentation/API/Doxyfile
View File

File diff suppressed because it is too large Load Diff

BIN
documentation/UserManual/ReactPhysics3D-UserManual.pdf
View File

Binary file not shown.

1934
documentation/UserManual/ReactPhysics3D-UserManual.tex
View File

File diff suppressed because it is too large Load Diff

BIN
documentation/UserManual/images/CMakeWin.png Executable file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 17 KiB

BIN
documentation/UserManual/images/DebugRendering.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 116 KiB

BIN
documentation/UserManual/images/VSBuild.png Executable file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 129 KiB

BIN
documentation/UserManual/images/VSInstall.png Executable file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 169 KiB

BIN
documentation/UserManual/images/testbed.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 154 KiB

After

Width:  |  Height:  |  Size: 118 KiB

2
documentation/UserManual/title.tex
View File

@ -10,7 +10,7 @@
\vskip 1.3cm
{\Huge \@title\par}%
\vskip 0.3cm
{\Large Version: 0.7.1\par}%
{\Large Version: 0.8.0\par}%
\vskip 0.3cm
{\Large \@author\par}%
\vskip 2cm

25
helloworld/CMakeLists.txt Normal file
View File

@ -0,0 +1,25 @@
# This is the CMakeLists.txt file of the "hello world" project
# in order to show a simple executable that uses the ReactPhysics3D library
# Minimum cmake version required
cmake_minimum_required(VERSION 3.8)
# Help CMake to find the installed library on Windows
if(WIN32)
list(APPEND CMAKE_PREFIX_PATH "C:\\Program Files (x86)\\ReactPhysics3D")
elseif(APPLE)
list(APPEND CMAKE_PREFIX_PATH "/usr/local/lib/cmake/ReactPhysics3D")
endif()
# Import the ReactPhysics3D library that you have installed on your computer using
# the "make install" command
find_package(ReactPhysics3D REQUIRED)
# Project
project(HelloWorld)
# Create the executable
add_executable(helloworld Main.cpp)
# Link with the ReactPhysics3D library
target_link_libraries(helloworld ReactPhysics3D::ReactPhysics3D)

47
helloworld/Main.cpp Normal file
View File

@ -0,0 +1,47 @@
/*
* This is a "hello world" project with a basic example of how to use
* the ReactPhysics3D library in your project. This example is a simple
* rigid body that is falling down because of gravity.
*/
// Libraries
#include <reactphysics3d/reactphysics3d.h>
#include <iostream>
// ReactPhysics3D namespace
using namespace reactphysics3d;
// Main function
int main(int argc, char** argv) {
// First you need to create the PhysicsCommon object. This is a factory module
// that you can use to create physics world and other objects. It is also responsible
// for logging and memory management
PhysicsCommon physicsCommon;
// Create a physics world
PhysicsWorld* world = physicsCommon.createPhysicsWorld();
// Create a rigid body in the world
Vector3 position(0, 20, 0);
Quaternion orientation = Quaternion::identity();
Transform transform(position, orientation);
RigidBody* body = world->createRigidBody(transform);
const decimal timeStep = 1.0f / 60.0f;
// Step the simulation a few steps
for (int i=0; i < 20; i++) {
world->update(timeStep);
// Get the updated position of the body
const Transform& transform = body->getTransform();
const Vector3& position = transform.getPosition();
// Display the position of the body
std::cout << "Body Position: (" << position.x << ", " << position.y << ", " << position.z << ")" << std::endl;
}
return 0;
}

204
include/reactphysics3d/body/CollisionBody.h Normal file
View File

@ -0,0 +1,204 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_COLLISION_BODY_H
#define REACTPHYSICS3D_COLLISION_BODY_H
// Libraries
#include <cassert>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/collision/shapes/AABB.h>
#include <reactphysics3d/mathematics/Transform.h>
#include <reactphysics3d/configuration.h>
/// Namespace reactphysics3d
namespace reactphysics3d {
// Declarations
class Collider;
class CollisionShape;
class PhysicsWorld;
struct RaycastInfo;
class DefaultPoolAllocator;
class Profiler;
class Logger;
// Class CollisionBody
/**
* This class represents a body that is able to collide with others
* bodies.
*/
class CollisionBody {
protected :
// -------------------- Attributes -------------------- //
/// Identifier of the entity in the ECS
Entity mEntity;
/// Reference to the world the body belongs to
PhysicsWorld& mWorld;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
#endif
// -------------------- Methods -------------------- //
/// Remove all the collision shapes
void removeAllColliders();
/// Update the broad-phase state for this body (because it has moved for instance)
void updateBroadPhaseState(decimal timeStep) const;
/// Ask the broad-phase to test again the collision shapes of the body for collision
/// (as if the body has moved).
void askForBroadPhaseCollisionCheck() const;
public :
// -------------------- Methods -------------------- //
/// Constructor
CollisionBody(PhysicsWorld& world, Entity entity);
/// Destructor
virtual ~CollisionBody();
/// Deleted copy-constructor
CollisionBody(const CollisionBody& body) = delete;
/// Deleted assignment operator
CollisionBody& operator=(const CollisionBody& body) = delete;
/// Return the corresponding entity of the body
Entity getEntity() const;
/// Return true if the body is active
bool isActive() const;
/// Return a pointer to the user data attached to this body
void* getUserData() const;
/// Attach user data to this body
void setUserData(void* userData);
/// Set whether or not the body is active
virtual void setIsActive(bool isActive);
/// Return the current position and orientation
const Transform& getTransform() const;
/// Set the current position and orientation
virtual void setTransform(const Transform& transform);
/// Create a new collider and add it to the body.
virtual Collider* addCollider(CollisionShape* collisionShape, const Transform& transform);
/// Remove a collider from the body
virtual void removeCollider(Collider* collider);
/// Return true if a point is inside the collision body
bool testPointInside(const Vector3& worldPoint) const;
/// Raycast method with feedback information
bool raycast(const Ray& ray, RaycastInfo& raycastInfo);
/// Test if the collision body overlaps with a given AABB
bool testAABBOverlap(const AABB& worldAABB) const;
/// Compute and return the AABB of the body by merging all colliders AABBs
AABB getAABB() const;
/// Return a const pointer to a given collider of the body
const Collider* getCollider(uint colliderIndex) const;
/// Return a pointer to a given collider of the body
Collider* getCollider(uint colliderIndex);
/// Return the number of colliders associated with this body
uint getNbColliders() const;
/// Return the world-space coordinates of a point given the local-space coordinates of the body
Vector3 getWorldPoint(const Vector3& localPoint) const;
/// Return the world-space vector of a vector given in local-space coordinates of the body
Vector3 getWorldVector(const Vector3& localVector) const;
/// Return the body local-space coordinates of a point given in the world-space coordinates
Vector3 getLocalPoint(const Vector3& worldPoint) const;
/// Return the body local-space coordinates of a vector given in the world-space coordinates
Vector3 getLocalVector(const Vector3& worldVector) const;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
virtual void setProfiler(Profiler* profiler);
#endif
// -------------------- Friendship -------------------- //
friend class PhysicsWorld;
friend class CollisionDetectionSystem;
friend class BroadPhaseAlgorithm;
friend class ConvexMeshShape;
friend class Collider;
};
/// Test if the collision body overlaps with a given AABB
/**
* @param worldAABB The AABB (in world-space coordinates) that will be used to test overlap
* @return True if the given AABB overlaps with the AABB of the collision body
*/
inline bool CollisionBody::testAABBOverlap(const AABB& worldAABB) const {
return worldAABB.testCollision(getAABB());
}
// Return the corresponding entity of the body
/**
* @return The entity of the body
*/
inline Entity CollisionBody::getEntity() const {
return mEntity;
}
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void CollisionBody::setProfiler(Profiler* profiler) {
mProfiler = profiler;
}
#endif
}
#endif

211
include/reactphysics3d/body/RigidBody.h Normal file
View File

@ -0,0 +1,211 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_RIGID_BODY_H
#define REACTPHYSICS3D_RIGID_BODY_H
// Libraries
#include <cassert>
#include <reactphysics3d/body/CollisionBody.h>
#include <reactphysics3d/mathematics/mathematics.h>
/// Namespace reactphysics3d
namespace reactphysics3d {
// Class declarations
struct JointListElement;
class PhysicsWorld;
class MemoryManager;
enum class BodyType;
// Class RigidBody
/**
* This class represents a rigid body of the physics
* engine. A rigid body is a non-deformable body that
* has a constant mass. This class inherits from the
* CollisionBody class.
*/
class RigidBody : public CollisionBody {
protected :
// -------------------- Methods -------------------- //
/// Set the variable to know whether or not the body is sleeping
void setIsSleeping(bool isSleeping);
/// Update whether the current overlapping pairs where this body is involed are active or not
void updateOverlappingPairs();
/// Compute and return the local-space center of mass of the body using its colliders
Vector3 computeCenterOfMass() const;
/// Compute the local-space inertia tensor and total mass of the body using its colliders
void computeMassAndInertiaTensorLocal(Vector3& inertiaTensorLocal, decimal& totalMass) const;
/// Return the inverse of the inertia tensor in world coordinates.
static const Matrix3x3 getWorldInertiaTensorInverse(PhysicsWorld& world, Entity bodyEntity);
public :
// -------------------- Methods -------------------- //
/// Constructor
RigidBody(PhysicsWorld& world, Entity entity);
/// Destructor
virtual ~RigidBody() override = default;
/// Deleted copy-constructor
RigidBody(const RigidBody& body) = delete;
/// Deleted assignment operator
RigidBody& operator=(const RigidBody& body) = delete;
/// Set the current position and orientation
virtual void setTransform(const Transform& transform) override;
/// Return the mass of the body
decimal getMass() const;
/// Set the mass of the rigid body
void setMass(decimal mass);
/// Return the linear velocity
Vector3 getLinearVelocity() const;
/// Set the linear velocity of the body.
void setLinearVelocity(const Vector3& linearVelocity);
/// Return the angular velocity
Vector3 getAngularVelocity() const;
/// Set the angular velocity.
void setAngularVelocity(const Vector3& angularVelocity);
/// Return the local inertia tensor of the body (in body coordinates)
const Vector3& getLocalInertiaTensor() const;
/// Set the local inertia tensor of the body (in body coordinates)
void setLocalInertiaTensor(const Vector3& inertiaTensorLocal);
/// Return the center of mass of the body (in local-space coordinates)
const Vector3& getLocalCenterOfMass() const;
/// Set the center of mass of the body (in local-space coordinates)
void setLocalCenterOfMass(const Vector3& centerOfMass);
/// Compute and set the local-space center of mass of the body using its colliders
void updateLocalCenterOfMassFromColliders();
/// Compute and set the local-space inertia tensor of the body using its colliders
void updateLocalInertiaTensorFromColliders();
/// Compute and set the mass of the body using its colliders
void updateMassFromColliders();
/// Compute and set the center of mass, the mass and the local-space inertia tensor of the body using its colliders
void updateMassPropertiesFromColliders();
/// Return the type of the body
BodyType getType() const;
/// Set the type of the body
void setType(BodyType type);
/// Return true if the gravity needs to be applied to this rigid body
bool isGravityEnabled() const;
/// Set the variable to know if the gravity is applied to this rigid body
void enableGravity(bool isEnabled);
/// Return the linear velocity damping factor
decimal getLinearDamping() const;
/// Set the linear damping factor
void setLinearDamping(decimal linearDamping);
/// Return the angular velocity damping factor
decimal getAngularDamping() const;
/// Set the angular damping factor
void setAngularDamping(decimal angularDamping);
/// Apply an external force to the body at its center of mass.
void applyForceToCenterOfMass(const Vector3& force);
/// Apply an external force to the body at a given point (in local-space coordinates).
void applyForceAtLocalPosition(const Vector3& force, const Vector3& point);
/// Apply an external force to the body at a given point (in world-space coordinates).
void applyForceAtWorldPosition(const Vector3& force, const Vector3& point);
/// Apply an external torque to the body.
void applyTorque(const Vector3& torque);
/// Return whether or not the body is allowed to sleep
bool isAllowedToSleep() const;
/// Set whether or not the body is allowed to go to sleep
void setIsAllowedToSleep(bool isAllowedToSleep);
/// Return whether or not the body is sleeping
bool isSleeping() const;
/// Set whether or not the body is active
virtual void setIsActive(bool isActive) override;
/// Create a new collider and add it to the body
virtual Collider* addCollider(CollisionShape* collisionShape, const Transform& transform) override;
/// Remove a collider from the body
virtual void removeCollider(Collider* collider) override;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler) override;
#endif
// -------------------- Friendship -------------------- //
friend class PhysicsWorld;
friend class ContactSolverSystem;
friend class DynamicsSystem;
friend class BallAndSocketJoint;
friend class SliderJoint;
friend class HingeJoint;
friend class FixedJoint;
friend class SolveBallAndSocketJointSystem;
friend class SolveFixedJointSystem;
friend class SolveHingeJointSystem;
friend class SolveSliderJointSystem;
friend class Joint;
};
}
#endif

238
include/reactphysics3d/collision/Collider.h Normal file
View File

@ -0,0 +1,238 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_COLLIDER_H
#define REACTPHYSICS3D_COLLIDER_H
// Libraries
#include <reactphysics3d/body/CollisionBody.h>
#include <reactphysics3d/collision/shapes/CollisionShape.h>
#include <reactphysics3d/engine/Material.h>
#include <reactphysics3d/utils/Logger.h>
namespace reactphysics3d {
// Declarations
class MemoryManager;
// Class Collider
/**
* A collider has a collision shape (box, sphere, capsule, ...) and is attached to a CollisionBody or
* RigidBody. A body can have multiple colliders. The collider also have a mass value and a Material
* with many physics parameters like friction or bounciness. When you create a body, you need to attach
* at least one collider to it if you want that body to be able to collide in the physics world.
*/
class Collider {
protected:
// -------------------- Attributes -------------------- //
/// Reference to the memory manager
MemoryManager& mMemoryManager;
/// Identifier of the entity in the ECS
Entity mEntity;
/// Pointer to the parent body
CollisionBody* mBody;
/// Material properties of the rigid body
Material mMaterial;
/// Pointer to user data
void* mUserData;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
#endif
// -------------------- Methods -------------------- //
/// Notify the collider that the size of the collision shape has been
/// changed by the user
void setHasCollisionShapeChangedSize(bool hasCollisionShapeChangedSize);
public:
// -------------------- Methods -------------------- //
/// Constructor
Collider(Entity entity, CollisionBody* body, MemoryManager& memoryManager);
/// Destructor
virtual ~Collider();
/// Deleted copy-constructor
Collider(const Collider& collider) = delete;
/// Deleted assignment operator
Collider& operator=(const Collider& collider) = delete;
/// Return the corresponding entity of the collider
Entity getEntity() const;
/// Return a pointer to the collision shape
CollisionShape* getCollisionShape();
/// Return a const pointer to the collision shape
const CollisionShape* getCollisionShape() const;
/// Return the parent body
CollisionBody* getBody() const;
/// Return a pointer to the user data attached to this body
void* getUserData() const;
/// Attach user data to this body
void setUserData(void* userData);
/// Return the local to parent body transform
const Transform& getLocalToBodyTransform() const;
/// Set the local to parent body transform
void setLocalToBodyTransform(const Transform& transform);
/// Return the local to world transform
const Transform getLocalToWorldTransform() const;
/// Return the AABB of the collider in world-space
const AABB getWorldAABB() const;
/// Test if the collider overlaps with a given AABB
bool testAABBOverlap(const AABB& worldAABB) const;
/// Return true if a point is inside the collision shape
bool testPointInside(const Vector3& worldPoint);
/// Raycast method with feedback information
bool raycast(const Ray& ray, RaycastInfo& raycastInfo);
/// Return the collision bits mask
unsigned short getCollideWithMaskBits() const;
/// Set the collision bits mask
void setCollideWithMaskBits(unsigned short collideWithMaskBits);
/// Return the collision category bits
unsigned short getCollisionCategoryBits() const;
/// Set the collision category bits
void setCollisionCategoryBits(unsigned short collisionCategoryBits);
/// Return the broad-phase id
int getBroadPhaseId() const;
/// Return a reference to the material properties of the collider
Material& getMaterial();
/// Set a new material for this collider
void setMaterial(const Material& material);
/// Return true if the collider is a trigger
bool getIsTrigger() const;
/// Set whether the collider is a trigger
void setIsTrigger(bool isTrigger) const;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler);
#endif
// -------------------- Friendship -------------------- //
friend class OverlappingPair;
friend class CollisionBody;
friend class RigidBody;
friend class BroadPhaseAlgorithm;
friend class DynamicAABBTree;
friend class CollisionDetectionSystem;
friend class PhysicsWorld;
friend class GJKAlgorithm;
friend class ConvexMeshShape;
friend class CollisionShape;
friend class ContactManifoldSet;
friend class MiddlePhaseTriangleCallback;
};
// Return the corresponding entity of the collider
/**
* @return The entity of the collider
*/
inline Entity Collider::getEntity() const {
return mEntity;
}
// Return the parent body
/**
* @return Pointer to the parent body
*/
inline CollisionBody* Collider::getBody() const {
return mBody;
}
// Return a pointer to the user data attached to this body
/**
* @return A pointer to the user data stored into the collider
*/
inline void* Collider::getUserData() const {
return mUserData;
}
// Attach user data to this body
/**
* @param userData Pointer to the user data you want to store within the collider
*/
inline void Collider::setUserData(void* userData) {
mUserData = userData;
}
/// Test if the collider overlaps with a given AABB
/**
* @param worldAABB The AABB (in world-space coordinates) that will be used to test overlap
* @return True if the given AABB overlaps with the AABB of the collision body
*/
inline bool Collider::testAABBOverlap(const AABB& worldAABB) const {
return worldAABB.testCollision(getWorldAABB());
}
// Return a reference to the material properties of the collider
/**
* @return A reference to the material of the body
*/
inline Material& Collider::getMaterial() {
return mMaterial;
}
}
#endif

345
include/reactphysics3d/collision/CollisionCallback.h Normal file
View File

@ -0,0 +1,345 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_COLLISION_CALLBACK_H
#define REACTPHYSICS3D_COLLISION_CALLBACK_H
// Libraries
#include <reactphysics3d/containers/List.h>
#include <reactphysics3d/collision/ContactPair.h>
#include <reactphysics3d/constraint/ContactPoint.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Declarations
class OverlappingPair;
class ContactManifold;
class CollisionBody;
class Collider;
class MemoryManager;
// Class CollisionCallback
/**
* This abstract class can be used to register a callback for collision test queries.
* You should implement your own class inherited from this one and implement
* the notifyContact() method. This method will called each time a contact
* point is reported.
*/
class CollisionCallback {
public:
// Class ContactPoint
/**
* This class represents a contact point between two colliders of the physics world.
*/
class ContactPoint {
private:
// -------------------- Attributes -------------------- //
const reactphysics3d::ContactPoint& mContactPoint;
// -------------------- Methods -------------------- //
/// Constructor
ContactPoint(const reactphysics3d::ContactPoint& contactPoint);
public:
// -------------------- Methods -------------------- //
/// Copy constructor
ContactPoint(const ContactPoint& contactPoint) = default;
/// Assignment operator
ContactPoint& operator=(const ContactPoint& contactPoint) = delete;
/// Destructor
~ContactPoint() = default;
/// Return the penetration depth
/**
* @return The penetration depth between the two colliders at this contact point
*/
decimal getPenetrationDepth() const;
/// Return the world-space contact normal
/**
* @return The world-space contact normal
*/
const Vector3& getWorldNormal() const;
/// Return the contact point on the first collider in the local-space of the first collider
/**
* @return The local-space contact point on the first collider
*/
const Vector3& getLocalPointOnCollider1() const;
/// Return the contact point on the second collider in the local-space of the second collider
/**
* @return The local-space contact point on the second collider
*/
const Vector3& getLocalPointOnCollider2() const;
// -------------------- Friendship -------------------- //
friend class CollisionCallback;
};
// Class ContactPair
/**
* This class represents the contact between two colliders of the physics world.
* A contact pair contains a list of contact points.
*/
class ContactPair {
public:
/// Enumeration EventType that describes the type of contact event
enum class EventType {
/// This contact is a new contact between the two
/// colliders (the colliders where not touching in the previous frame)
ContactStart,
/// The two colliders were already touching in the previous frame and this is a new or updated contact
ContactStay,
/// The two colliders were in contact in the previous frame and are not in contact anymore
ContactExit
};
private:
// -------------------- Attributes -------------------- //
const reactphysics3d::ContactPair& mContactPair;
/// Pointer to the contact points
List<reactphysics3d::ContactPoint>* mContactPoints;
/// Reference to the physics world
PhysicsWorld& mWorld;
/// True if this is a lost contact pair (contact pair colliding in previous frame but not in current one)
bool mIsLostContactPair;
// -------------------- Methods -------------------- //
/// Constructor
ContactPair(const reactphysics3d::ContactPair& contactPair, List<reactphysics3d::ContactPoint>* contactPoints,
PhysicsWorld& world, bool mIsLostContactPair);
public:
// -------------------- Methods -------------------- //
/// Copy constructor
ContactPair(const ContactPair& contactPair) = default;
/// Assignment operator
ContactPair& operator=(const ContactPair& contactPair) = delete;
/// Destructor
~ContactPair() = default;
/// Return the number of contact points in the contact pair
/**
* @return The number of contact points in the contact pair
*/
uint getNbContactPoints() const;
/// Return a given contact point
/**
* @param index Index of the contact point to retrieve
* @return A contact point object
*/
ContactPoint getContactPoint(uint index) const;
/// Return a pointer to the first body in contact
/**
* @return A pointer to the first colliding body of the pair
*/
CollisionBody* getBody1() const;
/// Return a pointer to the second body in contact
/**
* @return A pointer to the second colliding body of the pair
*/
CollisionBody* getBody2() const;
/// Return a pointer to the first collider in contact (in body 1)
/**
* @return A pointer to the first collider of the contact pair
*/
Collider* getCollider1() const;
/// Return a pointer to the second collider in contact (in body 2)
/**
* @return A pointer to the second collider of the contact pair
*/
Collider* getCollider2() const;
/// Return the corresponding type of event for this contact pair
/**
* @return The type of contact event for this contact pair
*/
EventType getEventType() const;
// -------------------- Friendship -------------------- //
friend class CollisionCallback;
};
// Class CallbackData
/**
* This class contains data about contacts between bodies
*/
class CallbackData {
private:
// -------------------- Attributes -------------------- //
/// Pointer to the list of contact pairs (contains contacts and triggers events)
List<reactphysics3d::ContactPair>* mContactPairs;
/// Pointer to the list of contact manifolds
List<ContactManifold>* mContactManifolds;
/// Pointer to the contact points
List<reactphysics3d::ContactPoint>* mContactPoints;
/// Pointer to the list of lost contact pairs (contains contacts and triggers events)
List<reactphysics3d::ContactPair>& mLostContactPairs;
/// List of indices of the mContactPairs list that are contact events (not overlap/triggers)
List<uint> mContactPairsIndices;
/// List of indices of the mLostContactPairs list that are contact events (not overlap/triggers)
List<uint> mLostContactPairsIndices;
/// Reference to the physics world
PhysicsWorld& mWorld;
// -------------------- Methods -------------------- //
/// Constructor
CallbackData(List<reactphysics3d::ContactPair>* contactPairs, List<ContactManifold>* manifolds,
List<reactphysics3d::ContactPoint>* contactPoints, List<reactphysics3d::ContactPair>& lostContactPairs,
PhysicsWorld& world);
/// Deleted copy constructor
CallbackData(const CallbackData& callbackData) = delete;
/// Deleted assignment operator
CallbackData& operator=(const CallbackData& callbackData) = delete;
/// Destructor
~CallbackData() = default;
public:
// -------------------- Methods -------------------- //
/// Return the number of contact pairs
/**
* @return The number of contact pairs
*/
uint getNbContactPairs() const;
/// Return a given contact pair
/**
* @param index Index of the contact pair to retrieve
* @return A contact pair object
*/
ContactPair getContactPair(uint index) const;
// -------------------- Friendship -------------------- //
friend class CollisionDetectionSystem;
};
/// Destructor
virtual ~CollisionCallback() = default;
/// This method is called when some contacts occur
virtual void onContact(const CallbackData& callbackData)=0;
};
// Return the number of contact pairs (there is a single contact pair between two bodies in contact)
/**
* @return The number of contact pairs
*/
inline uint CollisionCallback::CallbackData::getNbContactPairs() const {
return mContactPairsIndices.size() + mLostContactPairsIndices.size();
}
// Return the number of contact points in the contact pair
/**
* @return The number of contact points
*/
inline uint CollisionCallback::ContactPair::getNbContactPoints() const {
return mContactPair.nbToTalContactPoints;
}
// Return the penetration depth between the two bodies in contact
/**
* @return The penetration depth (larger than zero)
*/
inline decimal CollisionCallback::ContactPoint::getPenetrationDepth() const {
return mContactPoint.getPenetrationDepth();
}
// Return the world-space contact normal (vector from first body toward second body)
/**
* @return The contact normal direction at the contact point (in world-space)
*/
inline const Vector3& CollisionCallback::ContactPoint::getWorldNormal() const {
return mContactPoint.getNormal();
}
// Return the contact point on the first collider in the local-space of the first collider
/**
* @return The contact point in the local-space of the first collider (from body1) in contact
*/
inline const Vector3& CollisionCallback::ContactPoint::getLocalPointOnCollider1() const {
return mContactPoint.getLocalPointOnShape1();
}
// Return the contact point on the second collider in the local-space of the second collider
/**
* @return The contact point in the local-space of the second collider (from body2) in contact
*/
inline const Vector3& CollisionCallback::ContactPoint::getLocalPointOnCollider2() const {
return mContactPoint.getLocalPointOnShape2();
}
}
#endif

134
include/reactphysics3d/collision/ContactManifold.h Normal file
View File

@ -0,0 +1,134 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_CONTACT_MANIFOLD_H
#define REACTPHYSICS3D_CONTACT_MANIFOLD_H
// Libraries
#include <reactphysics3d/collision/Collider.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class ContactManifold;
class ContactManifoldInfo;
struct ContactPointInfo;
class CollisionBody;
class ContactPoint;
class DefaultPoolAllocator;
// Class ContactManifold
/**
* This class represents a set of contact points between two bodies that
* all have a similar contact normal direction. Usually, there is a single
* contact manifold when two convex shapes are in contact. However, when
* a convex shape collides with a concave shape, there might be several
* contact manifolds with different normal directions.
* The contact manifold is implemented in a way to cache the contact
* points among the frames for better stability (warm starting of the
* contact solver)
*/
class ContactManifold {
public:
// -------------------- Constants -------------------- //
/// Maximum number of contact points in a reduced contact manifold
const int MAX_CONTACT_POINTS_IN_MANIFOLD = 4;
// -------------------- Attributes -------------------- //
/// Index of the first contact point of the manifold in the list of contact points
uint contactPointsIndex;
/// Entity of the first body in contact
Entity bodyEntity1;
/// Entity of the second body in contact
Entity bodyEntity2;
/// Entity of the first collider in contact
Entity colliderEntity1;
/// Entity of the second collider in contact
Entity colliderEntity2;
/// Number of contacts in the cache
int8 nbContactPoints;
/// First friction vector of the contact manifold
Vector3 frictionVector1;
/// Second friction vector of the contact manifold
Vector3 frictionVector2;
/// First friction constraint accumulated impulse
decimal frictionImpulse1;
/// Second friction constraint accumulated impulse
decimal frictionImpulse2;
/// Twist friction constraint accumulated impulse
decimal frictionTwistImpulse;
/// Accumulated rolling resistance impulse
Vector3 rollingResistanceImpulse;
/// True if the contact manifold has already been added into an island
bool isAlreadyInIsland;
public:
// -------------------- Methods -------------------- //
/// Constructor
ContactManifold(Entity bodyEntity1, Entity bodyEntity2, Entity colliderEntity1, Entity colliderEntity2,
uint contactPointsIndex, int8 nbContactPoints);
/// Destructor
~ContactManifold();
/// Copy-constructor
ContactManifold(const ContactManifold& contactManifold) = default;
/// Assignment operator
ContactManifold& operator=(const ContactManifold& contactManifold) = default;
// -------------------- Friendship -------------------- //
friend class PhysicsWorld;
friend class Island;
friend class CollisionBody;
friend class ContactManifoldSet;
friend class ContactSolverSystem;
friend class CollisionDetectionSystem;
};
}
#endif

69
src/collision/narrowphase/CollisionDispatch.h → include/reactphysics3d/collision/ContactManifoldInfo.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -23,66 +23,45 @@
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_COLLISION_DISPATCH_H
#define REACTPHYSICS3D_COLLISION_DISPATCH_H
#ifndef REACTPHYSICS3D_CONTACT_MANIFOLD_INFO_H
#define REACTPHYSICS3D_CONTACT_MANIFOLD_INFO_H
// Libraries
#include <reactphysics3d/mathematics/mathematics.h>
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/engine/OverlappingPairs.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Declarations
class NarrowPhaseAlgorithm;
class Profiler;
// Class CollisionDispatch
// Structure ContactManifoldInfo
/**
* This is the abstract base class for dispatching the narrow-phase
* collision detection algorithm. Collision dispatching decides which collision
* algorithm to use given two types of proxy collision shapes.
* This structure contains informations about a collision contact
* manifold computed during the narrow-phase collision detection.
*/
class CollisionDispatch {
protected:
#ifdef IS_PROFILING_ACTIVE
/// Pointer to the profiler
Profiler* mProfiler;
#endif
struct ContactManifoldInfo {
public:
// -------------------- Attributes -------------------- //
/// Indices of the contact points in the mPotentialContactPoints array
List<uint> potentialContactPointsIndices;
/// Overlapping pair id
uint64 pairId;
// -------------------- Methods -------------------- //
/// Constructor
CollisionDispatch() = default;
ContactManifoldInfo(uint64 pairId, MemoryAllocator& allocator)
: potentialContactPointsIndices(allocator), pairId(pairId) {
/// Destructor
virtual ~CollisionDispatch() = default;
}
/// Select and return the narrow-phase collision detection algorithm to
/// use between two types of collision shapes.
virtual NarrowPhaseAlgorithm* selectAlgorithm(int shape1Type, int shape2Type)=0;
#ifdef IS_PROFILING_ACTIVE
/// Set the profiler
virtual void setProfiler(Profiler* profiler);
#endif
};
#ifdef IS_PROFILING_ACTIVE
// Set the profiler
inline void CollisionDispatch::setProfiler(Profiler* profiler) {
mProfiler = profiler;
}
#endif
}
#endif

104
include/reactphysics3d/collision/ContactPair.h Normal file
View File

@ -0,0 +1,104 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_OVERLAPPING_PAIR_CONTACT_H
#define REACTPHYSICS3D_OVERLAPPING_PAIR_CONTACT_H
// Libraries
#include <reactphysics3d/mathematics/mathematics.h>
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/engine/OverlappingPairs.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Structure ContactPair
/**
* This structure represents a pair of shapes that are in contact during narrow-phase.
*/
struct ContactPair {
public:
// -------------------- Attributes -------------------- //
/// Overlapping pair Id
uint64 pairId;
/// Indices of the potential contact manifolds
List<uint> potentialContactManifoldsIndices;
/// Entity of the first body of the contact
Entity body1Entity;
/// Entity of the second body of the contact
Entity body2Entity;
/// Entity of the first collider of the contact
Entity collider1Entity;
/// Entity of the second collider of the contact
Entity collider2Entity;
/// True if the manifold is already in an island
bool isAlreadyInIsland;
/// Index of the contact pair in the array of pairs
uint contactPairIndex;
/// Index of the first contact manifold in the array
uint contactManifoldsIndex;
/// Number of contact manifolds
int8 nbContactManifolds;
/// Index of the first contact point in the array of contact points
uint contactPointsIndex;
/// Total number of contact points in all the manifolds of the contact pair
uint nbToTalContactPoints;
/// True if the colliders of the pair were already colliding in the previous frame
bool collidingInPreviousFrame;
/// True if one of the two involved colliders is a trigger
bool isTrigger;
// -------------------- Methods -------------------- //
/// Constructor
ContactPair(uint64 pairId, Entity body1Entity, Entity body2Entity, Entity collider1Entity,
Entity collider2Entity, uint contactPairIndex, bool collidingInPreviousFrame, bool isTrigger, MemoryAllocator& allocator)
: pairId(pairId), potentialContactManifoldsIndices(allocator), body1Entity(body1Entity), body2Entity(body2Entity),
collider1Entity(collider1Entity), collider2Entity(collider2Entity),
isAlreadyInIsland(false), contactPairIndex(contactPairIndex), contactManifoldsIndex(0), nbContactManifolds(0),
contactPointsIndex(0), nbToTalContactPoints(0), collidingInPreviousFrame(collidingInPreviousFrame), isTrigger(isTrigger) {
}
};
}
#endif

14
src/collision/ContactPointInfo.h → include/reactphysics3d/collision/ContactPointInfo.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_CONTACT_POINT_INFO_H
// Libraries
#include "mathematics/mathematics.h"
#include "configuration.h"
#include <reactphysics3d/mathematics/mathematics.h>
#include <reactphysics3d/configuration.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -65,19 +65,13 @@ struct ContactPointInfo {
/// Contact point of body 2 in local space of body 2
Vector3 localPoint2;
/// Pointer to the next contact point info
ContactPointInfo* next;
/// True if the contact point has already been inserted into a manifold
bool isUsed;
// -------------------- Methods -------------------- //
/// Constructor
ContactPointInfo(const Vector3& contactNormal, decimal penDepth,
const Vector3& localPt1, const Vector3& localPt2)
: normal(contactNormal), penetrationDepth(penDepth),
localPoint1(localPt1), localPoint2(localPt2), next(nullptr), isUsed(false) {
localPoint1(localPt1), localPoint2(localPt2) {
assert(contactNormal.lengthSquare() > decimal(0.8));
assert(penDepth > decimal(0.0));

4
src/collision/HalfEdgeStructure.h → include/reactphysics3d/collision/HalfEdgeStructure.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,7 +27,7 @@
#define REACTPHYSICS3D_HALF_EDGE_STRUCTURE_MESH_H
// Libraries
#include "mathematics/mathematics.h"
#include <reactphysics3d/mathematics/mathematics.h>
namespace reactphysics3d {

213
include/reactphysics3d/collision/OverlapCallback.h Normal file
View File

@ -0,0 +1,213 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_OVERLAP_CALLBACK_H
#define REACTPHYSICS3D_OVERLAP_CALLBACK_H
// Libraries
#include <reactphysics3d/containers/List.h>
#include <reactphysics3d/collision/ContactPair.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Declarations
class CollisionBody;
class PhysicsWorld;
class Collider;
struct Entity;
// Class OverlapCallback
/**
* This class can be used to register a callback for collision overlap queries between bodies.
* You should implement your own class inherited from this one and implement the onOverlap() method.
*/
class OverlapCallback {
public:
// Class OverlapPair
/**
* This class represents the contact between two colliders of the physics world.
*/
class OverlapPair {
public:
/// Enumeration EventType that describes the type of overlapping event
enum class EventType {
/// This overlap is a new overlap between the two
/// colliders (the colliders where not overlapping in the previous frame)
OverlapStart,
/// The two colliders were already overlapping in the previous frame and this is a new or updated overlap
OverlapStay,
/// The two colliders were overlapping in the previous frame and are not overlapping anymore
OverlapExit
};
private:
// -------------------- Attributes -------------------- //
/// Contact pair
ContactPair& mContactPair;
/// Reference to the physics world
PhysicsWorld& mWorld;
/// True if the pair were overlapping in the previous frame but not in the current one
bool mIsLostOverlapPair;
// -------------------- Methods -------------------- //
/// Constructor
OverlapPair(ContactPair& contactPair, reactphysics3d::PhysicsWorld& world, bool isLostOverlappingPair);
public:
// -------------------- Methods -------------------- //
/// Copy constructor
OverlapPair(const OverlapPair& contactPair) = default;
/// Assignment operator
OverlapPair& operator=(const OverlapPair& contactPair) = default;
/// Destructor
~OverlapPair() = default;
/// Return a pointer to the first collider in contact
Collider* getCollider1() const;
/// Return a pointer to the second collider in contact
Collider* getCollider2() const;
/// Return a pointer to the first body in contact
CollisionBody* getBody1() const;
/// Return a pointer to the second body in contact
CollisionBody* getBody2() const;
/// Return the corresponding type of event for this overlapping pair
EventType getEventType() const;
// -------------------- Friendship -------------------- //
friend class OverlapCallback;
};
// Class CallbackData
/**
* This class contains data about overlap between bodies
*/
class CallbackData {
private:
// -------------------- Attributes -------------------- //
/// Reference to the list of contact pairs (contains contacts and triggers events)
List<ContactPair>& mContactPairs;
/// Reference to the list of lost contact pairs (contains contacts and triggers events)
List<ContactPair>& mLostContactPairs;
/// List of indices of the mContactPairs list that are overlap/triggers events (not contact events)
List<uint> mContactPairsIndices;
/// List of indices of the mLostContactPairs list that are overlap/triggers events (not contact events)
List<uint> mLostContactPairsIndices;
/// Reference to the physics world
PhysicsWorld& mWorld;
// -------------------- Methods -------------------- //
/// Constructor
CallbackData(List<ContactPair>& contactPairs, List<ContactPair>& lostContactPairs, bool onlyReportTriggers, PhysicsWorld& world);
/// Deleted copy constructor
CallbackData(const CallbackData& callbackData) = delete;
/// Deleted assignment operator
CallbackData& operator=(const CallbackData& callbackData) = delete;
/// Destructor
~CallbackData() = default;
public:
// -------------------- Methods -------------------- //
/// Return the number of overlapping pairs of bodies
uint getNbOverlappingPairs() const;
/// Return a given overlapping pair of bodies
OverlapPair getOverlappingPair(uint index) const;
// -------------------- Friendship -------------------- //
friend class CollisionDetectionSystem;
};
/// Destructor
virtual ~OverlapCallback() {
}
/// This method will be called to report bodies that overlap
virtual void onOverlap(CallbackData& callbackData)=0;
};
// Return the number of overlapping pairs of bodies
inline uint OverlapCallback::CallbackData::getNbOverlappingPairs() const {
return mContactPairsIndices.size() + mLostContactPairsIndices.size();
}
// Return a given overlapping pair of bodies
/// Note that the returned OverlapPair object is only valid during the call of the CollisionCallback::onOverlap()
/// method. Therefore, you need to get contact data from it and make a copy. Do not make a copy of the OverlapPair
/// object itself because it won't be valid after the CollisionCallback::onOverlap() call.
inline OverlapCallback::OverlapPair OverlapCallback::CallbackData::getOverlappingPair(uint index) const {
assert(index < getNbOverlappingPairs());
if (index < mContactPairsIndices.size()) {
// Return a contact pair
return OverlapCallback::OverlapPair((mContactPairs)[mContactPairsIndices[index]], mWorld, false);
}
else {
// Return a lost contact pair
return OverlapCallback::OverlapPair(mLostContactPairs[mLostContactPairsIndices[index - mContactPairsIndices.size()]], mWorld, true);
}
}
}
#endif

4
src/collision/PolygonVertexArray.h → include/reactphysics3d/collision/PolygonVertexArray.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,7 +27,7 @@
#define REACTPHYSICS3D_POLYGON_VERTEX_ARRAY_H
// Libraries
#include "configuration.h"
#include <reactphysics3d/configuration.h>
#include <cassert>
namespace reactphysics3d {

23
src/collision/PolyhedronMesh.h → include/reactphysics3d/collision/PolyhedronMesh.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,7 +27,7 @@
#define REACTPHYSICS3D_POLYHEDRON_MESH_H
// Libraries
#include "mathematics/mathematics.h"
#include <reactphysics3d/mathematics/mathematics.h>
#include "HalfEdgeStructure.h"
namespace reactphysics3d {
@ -47,6 +47,9 @@ class PolyhedronMesh {
// -------------------- Attributes -------------------- //
/// Reference to the memory allocator
MemoryAllocator& mMemoryAllocator;
/// Pointer the the polygon vertex array with vertices and faces
/// of the mesh
PolygonVertexArray* mPolygonVertexArray;
@ -62,6 +65,9 @@ class PolyhedronMesh {
// -------------------- Methods -------------------- //
/// Constructor
PolyhedronMesh(PolygonVertexArray* polygonVertexArray, MemoryAllocator& allocator);
/// Create the half-edge structure of the mesh
void createHalfEdgeStructure();
@ -71,13 +77,13 @@ class PolyhedronMesh {
/// Compute the centroid of the polyhedron
void computeCentroid() ;
/// Compute and return the area of a face
decimal getFaceArea(uint faceIndex) const;
public:
// -------------------- Methods -------------------- //
/// Constructor
PolyhedronMesh(PolygonVertexArray* polygonVertexArray);
/// Destructor
~PolyhedronMesh();
@ -98,6 +104,13 @@ class PolyhedronMesh {
/// Return the centroid of the polyhedron
Vector3 getCentroid() const;
/// Compute and return the volume of the polyhedron
decimal getVolume() const;
// ---------- Friendship ---------- //
friend class PhysicsCommon;
};
// Return the number of vertices

22
src/collision/RaycastInfo.h → include/reactphysics3d/collision/RaycastInfo.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,14 +27,14 @@
#define REACTPHYSICS3D_RAYCAST_INFO_H
// Libraries
#include "mathematics/Vector3.h"
#include <reactphysics3d/mathematics/Vector3.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Declarations
class CollisionBody;
class ProxyShape;
class Collider;
class CollisionShape;
struct Ray;
@ -69,13 +69,13 @@ struct RaycastInfo {
/// Pointer to the hit collision body
CollisionBody* body;
/// Pointer to the hit proxy collision shape
ProxyShape* proxyShape;
/// Pointer to the hit collider
Collider* collider;
// -------------------- Methods -------------------- //
/// Constructor
RaycastInfo() : meshSubpart(-1), triangleIndex(-1), body(nullptr), proxyShape(nullptr) {
RaycastInfo() : meshSubpart(-1), triangleIndex(-1), body(nullptr), collider(nullptr) {
}
@ -93,7 +93,7 @@ struct RaycastInfo {
/**
* This class can be used to register a callback for ray casting queries.
* You should implement your own class inherited from this one and implement
* the notifyRaycastHit() method. This method will be called for each ProxyShape
* the notifyRaycastHit() method. This method will be called for each collider
* that is hit by the ray.
*/
class RaycastCallback {
@ -107,7 +107,7 @@ class RaycastCallback {
}
/// This method will be called for each ProxyShape that is hit by the
/// This method will be called for each collider that is hit by the
/// ray. You cannot make any assumptions about the order of the
/// calls. You should use the return value to control the continuation
/// of the ray. The returned value is the next maxFraction value to use.
@ -117,7 +117,7 @@ class RaycastCallback {
/// occurred. If you return the fraction in the parameter (hitFraction
/// value in the RaycastInfo object), the current ray will be clipped
/// to this fraction in the next queries. If you return -1.0, it will
/// ignore this ProxyShape and continue the ray cast.
/// ignore this collider and continue the ray cast.
/**
* @param raycastInfo Information about the raycast hit
* @return Value that controls the continuation of the ray after a hit
@ -139,8 +139,8 @@ struct RaycastTest {
userCallback = callback;
}
/// Ray cast test against a proxy shape
decimal raycastAgainstShape(ProxyShape* shape, const Ray& ray);
/// Ray cast test against a collider
decimal raycastAgainstShape(Collider* shape, const Ray& ray);
};
}

19
src/collision/TriangleMesh.h → include/reactphysics3d/collision/TriangleMesh.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -28,13 +28,13 @@
// Libraries
#include <cassert>
#include "containers/List.h"
#include <reactphysics3d/containers/List.h>
#include <reactphysics3d/memory/MemoryAllocator.h>
namespace reactphysics3d {
// Declarations
class TriangleVertexArray;
class MemoryManager;
// Class TriangleMesh
/**
@ -51,13 +51,13 @@ class TriangleMesh {
/// All the triangle arrays of the mesh (one triangle array per part)
List<TriangleVertexArray*> mTriangleArrays;
/// Constructor
TriangleMesh(reactphysics3d::MemoryAllocator& allocator);
public:
/// Constructor
TriangleMesh();
/// Destructor
~TriangleMesh() = default;
~TriangleMesh();
/// Add a subpart of the mesh
void addSubpart(TriangleVertexArray* triangleVertexArray);
@ -67,6 +67,11 @@ class TriangleMesh {
/// Return the number of subparts of the mesh
uint getNbSubparts() const;
// ---------- Friendship ---------- //
friend class PhysicsCommon;
};
// Add a subpart of the mesh

4
src/collision/TriangleVertexArray.h → include/reactphysics3d/collision/TriangleVertexArray.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,7 +27,7 @@
#define REACTPHYSICS3D_TRIANGLE_VERTEX_ARRAY_H
// Libraries
#include "configuration.h"
#include <reactphysics3d/configuration.h>
namespace reactphysics3d {

86
src/collision/broadphase/DynamicAABBTree.h → include/reactphysics3d/collision/broadphase/DynamicAABBTree.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,14 +27,15 @@
#define REACTPHYSICS3D_DYNAMIC_AABB_TREE_H
// Libraries
#include "configuration.h"
#include "collision/shapes/AABB.h"
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/collision/shapes/AABB.h>
#include <reactphysics3d/containers/Set.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class BroadPhaseAlgorithm;
class BroadPhaseSystem;
class BroadPhaseRaycastTestCallback;
class DynamicAABBTreeOverlapCallback;
class CollisionBody;
@ -53,7 +54,7 @@ struct TreeNode {
// -------------------- Constants -------------------- //
/// Null tree node constant
const static int NULL_TREE_NODE;
const static int32 NULL_TREE_NODE;
// -------------------- Attributes -------------------- //
@ -129,8 +130,7 @@ class DynamicAABBTreeRaycastCallback {
// Class DynamicAABBTree
/**
* This class implements a dynamic AABB tree that is used for broad-phase
* collision detection. This data structure is inspired by Nathanael Presson's
* dynamic tree implementation in BulletPhysics. The following implementation is
* collision detection. The following implementation is
* based on the one from Erin Catto in Box2D as described in the book
* "Introduction to Game Physics with Box2D" by Ian Parberry.
*/
@ -147,22 +147,21 @@ class DynamicAABBTree {
TreeNode* mNodes;
/// ID of the root node of the tree
int mRootNodeID;
int32 mRootNodeID;
/// ID of the first node of the list of free (allocated) nodes in the tree that we can use
int mFreeNodeID;
int32 mFreeNodeID;
/// Number of allocated nodes in the tree
int mNbAllocatedNodes;
int32 mNbAllocatedNodes;
/// Number of nodes in the tree
int mNbNodes;
int32 mNbNodes;
/// Extra AABB Gap used to allow the collision shape to move a little bit
/// without triggering a large modification of the tree which can be costly
decimal mExtraAABBGap;
/// The fat AABB is the initial AABB inflated by a given percentage of its size.
decimal mFatAABBInflatePercentage;
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
@ -172,25 +171,25 @@ class DynamicAABBTree {
// -------------------- Methods -------------------- //
/// Allocate and return a node to use in the tree
int allocateNode();
int32 allocateNode();
/// Release a node
void releaseNode(int nodeID);
void releaseNode(int32 nodeID);
/// Insert a leaf node in the tree
void insertLeafNode(int nodeID);
void insertLeafNode(int32 nodeID);
/// Remove a leaf node from the tree
void removeLeafNode(int nodeID);
void removeLeafNode(int32 nodeID);
/// Balance the sub-tree of a given node using left or right rotations.
int balanceSubTreeAtNode(int nodeID);
int32 balanceSubTreeAtNode(int32 nodeID);
/// Compute the height of a given node in the tree
int computeHeight(int nodeID);
int computeHeight(int32 nodeID);
/// Internally add an object into the tree
int addObjectInternal(const AABB& aabb);
int32 addObjectInternal(const AABB& aabb);
/// Initialize the tree
void init();
@ -201,7 +200,7 @@ class DynamicAABBTree {
void check() const;
/// Check if the node structure is valid (for debugging purpose)
void checkNode(int nodeID) const;
void checkNode(int32 nodeID) const;
#endif
@ -210,35 +209,38 @@ class DynamicAABBTree {
// -------------------- Methods -------------------- //
/// Constructor
DynamicAABBTree(MemoryAllocator& allocator, decimal extraAABBGap = decimal(0.0));
DynamicAABBTree(MemoryAllocator& allocator, decimal fatAABBInflatePercentage = decimal(0.0));
/// Destructor
~DynamicAABBTree();
/// Add an object into the tree (where node data are two integers)
int addObject(const AABB& aabb, int32 data1, int32 data2);
int32 addObject(const AABB& aabb, int32 data1, int32 data2);
/// Add an object into the tree (where node data is a pointer)
int addObject(const AABB& aabb, void* data);
int32 addObject(const AABB& aabb, void* data);
/// Remove an object from the tree
void removeObject(int nodeID);
void removeObject(int32 nodeID);
/// Update the dynamic tree after an object has moved.
bool updateObject(int nodeID, const AABB& newAABB, const Vector3& displacement, bool forceReinsert = false);
bool updateObject(int32 nodeID, const AABB& newAABB, bool forceReinsert = false);
/// Return the fat AABB corresponding to a given node ID
const AABB& getFatAABB(int nodeID) const;
const AABB& getFatAABB(int32 nodeID) const;
/// Return the pointer to the data array of a given leaf node of the tree
int32* getNodeDataInt(int nodeID) const;
int32* getNodeDataInt(int32 nodeID) const;
/// Return the data pointer of a given leaf node of the tree
void* getNodeDataPointer(int nodeID) const;
void* getNodeDataPointer(int32 nodeID) const;
/// Report all shapes overlapping with all the shapes in the map in parameter
void reportAllShapesOverlappingWithShapes(const List<int32>& nodesToTest, size_t startIndex,
size_t endIndex, List<Pair<int32, int32>>& outOverlappingNodes) const;
/// Report all shapes overlapping with the AABB given in parameter.
void reportAllShapesOverlappingWithAABB(const AABB& aabb,
DynamicAABBTreeOverlapCallback& callback) const;
void reportAllShapesOverlappingWithAABB(const AABB& aabb, List<int>& overlappingNodes) const;
/// Ray casting method
void raycast(const Ray& ray, DynamicAABBTreeRaycastCallback& callback) const;
@ -252,7 +254,7 @@ class DynamicAABBTree {
/// Clear all the nodes and reset the tree
void reset();
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler);
@ -267,20 +269,20 @@ inline bool TreeNode::isLeaf() const {
}
// Return the fat AABB corresponding to a given node ID
inline const AABB& DynamicAABBTree::getFatAABB(int nodeID) const {
inline const AABB& DynamicAABBTree::getFatAABB(int32 nodeID) const {
assert(nodeID >= 0 && nodeID < mNbAllocatedNodes);
return mNodes[nodeID].aabb;
}
// Return the pointer to the data array of a given leaf node of the tree
inline int32* DynamicAABBTree::getNodeDataInt(int nodeID) const {
inline int32* DynamicAABBTree::getNodeDataInt(int32 nodeID) const {
assert(nodeID >= 0 && nodeID < mNbAllocatedNodes);
assert(mNodes[nodeID].isLeaf());
return mNodes[nodeID].dataInt;
}
// Return the pointer to the data pointer of a given leaf node of the tree
inline void* DynamicAABBTree::getNodeDataPointer(int nodeID) const {
inline void* DynamicAABBTree::getNodeDataPointer(int32 nodeID) const {
assert(nodeID >= 0 && nodeID < mNbAllocatedNodes);
assert(mNodes[nodeID].isLeaf());
return mNodes[nodeID].dataPointer;
@ -293,9 +295,9 @@ inline AABB DynamicAABBTree::getRootAABB() const {
// Add an object into the tree. This method creates a new leaf node in the tree and
// returns the ID of the corresponding node.
inline int DynamicAABBTree::addObject(const AABB& aabb, int32 data1, int32 data2) {
inline int32 DynamicAABBTree::addObject(const AABB& aabb, int32 data1, int32 data2) {
int nodeId = addObjectInternal(aabb);
int32 nodeId = addObjectInternal(aabb);
mNodes[nodeId].dataInt[0] = data1;
mNodes[nodeId].dataInt[1] = data2;
@ -305,16 +307,16 @@ inline int DynamicAABBTree::addObject(const AABB& aabb, int32 data1, int32 data2
// Add an object into the tree. This method creates a new leaf node in the tree and
// returns the ID of the corresponding node.
inline int DynamicAABBTree::addObject(const AABB& aabb, void* data) {
inline int32 DynamicAABBTree::addObject(const AABB& aabb, void* data) {
int nodeId = addObjectInternal(aabb);
int32 nodeId = addObjectInternal(aabb);
mNodes[nodeId].dataPointer = data;
return nodeId;
}
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void DynamicAABBTree::setProfiler(Profiler* profiler) {

10
src/collision/narrowphase/CapsuleVsCapsuleAlgorithm.h → include/reactphysics3d/collision/narrowphase/CapsuleVsCapsuleAlgorithm.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,13 +27,14 @@
#define REACTPHYSICS3D_CAPSULE_VS_CAPSULE_ALGORITHM_H
// Libraries
#include "NarrowPhaseAlgorithm.h"
#include <reactphysics3d/collision/narrowphase/NarrowPhaseAlgorithm.h>
#include <reactphysics3d/configuration.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class Body;
struct CapsuleVsCapsuleNarrowPhaseInfoBatch;
class ContactPoint;
// Class CapsuleVsCapsuleAlgorithm
@ -65,7 +66,8 @@ class CapsuleVsCapsuleAlgorithm : public NarrowPhaseAlgorithm {
CapsuleVsCapsuleAlgorithm& operator=(const CapsuleVsCapsuleAlgorithm& algorithm) = delete;
/// Compute the narrow-phase collision detection between two capsules
virtual bool testCollision(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts, MemoryAllocator& memoryAllocator) override;
bool testCollision(CapsuleVsCapsuleNarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchStartIndex,
uint batchNbItems, MemoryAllocator& memoryAllocator);
};
}

78
include/reactphysics3d/collision/narrowphase/CapsuleVsCapsuleNarrowPhaseInfoBatch.h Normal file
View File

@ -0,0 +1,78 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_CAPSULE_VS_CAPSULE_NARROW_PHASE_INFO_BATCH_H
#define REACTPHYSICS3D_CAPSULE_VS_CAPSULE_NARROW_PHASE_INFO_BATCH_H
// Libraries
#include <reactphysics3d/collision/narrowphase/NarrowPhaseInfoBatch.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Struct CapsuleVsCapsuleNarrowPhaseInfoBatch
/**
* This structure collects all the potential collisions from the middle-phase algorithm
* that have to be tested during narrow-phase collision detection. This class collects all the
* capsule vs capsule collision detection tests.
*/
struct CapsuleVsCapsuleNarrowPhaseInfoBatch : public NarrowPhaseInfoBatch {
public:
/// List of radiuses for the first capsules
List<decimal> capsule1Radiuses;
/// List of radiuses for the second capsules
List<decimal> capsule2Radiuses;
/// List of heights for the first capsules
List<decimal> capsule1Heights;
/// List of heights for the second capsules
List<decimal> capsule2Heights;
/// Constructor
CapsuleVsCapsuleNarrowPhaseInfoBatch(MemoryAllocator& allocator, OverlappingPairs& overlappingPairs);
/// Destructor
virtual ~CapsuleVsCapsuleNarrowPhaseInfoBatch() override = default;
/// Add shapes to be tested during narrow-phase collision detection into the batch
virtual void addNarrowPhaseInfo(uint64 pairId, uint64 pairIndex, Entity collider1, Entity collider2, CollisionShape* shape1,
CollisionShape* shape2, const Transform& shape1Transform,
const Transform& shape2Transform, bool needToReportContacts, MemoryAllocator& shapeAllocator) override;
// Initialize the containers using cached capacity
virtual void reserveMemory() override;
/// Clear all the objects in the batch
virtual void clear() override;
};
}
#endif

9
src/collision/narrowphase/CapsuleVsConvexPolyhedronAlgorithm.h → include/reactphysics3d/collision/narrowphase/CapsuleVsConvexPolyhedronAlgorithm.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,14 +27,13 @@
#define REACTPHYSICS3D_CAPSULE_VS_CONVEX_POLYHEDRON_ALGORITHM_H
// Libraries
#include "NarrowPhaseAlgorithm.h"
#include <reactphysics3d/collision/narrowphase/NarrowPhaseAlgorithm.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class ContactPoint;
class Body;
// Class CapsuleVsConvexPolyhedronAlgorithm
/**
@ -70,7 +69,9 @@ class CapsuleVsConvexPolyhedronAlgorithm : public NarrowPhaseAlgorithm {
CapsuleVsConvexPolyhedronAlgorithm& operator=(const CapsuleVsConvexPolyhedronAlgorithm& algorithm) = delete;
/// Compute the narrow-phase collision detection between a capsule and a polyhedron
virtual bool testCollision(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts, MemoryAllocator& memoryAllocator) override;
bool testCollision(NarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchStartIndex,
uint batchNbItems, bool clipWithPreviousAxisIfStillColliding,
MemoryAllocator& memoryAllocator);
};
}

226
include/reactphysics3d/collision/narrowphase/CollisionDispatch.h Normal file
View File

@ -0,0 +1,226 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_COLLISION_DISPATCH_H
#define REACTPHYSICS3D_COLLISION_DISPATCH_H
// Libraries
#include <reactphysics3d/collision/narrowphase/SphereVsSphereAlgorithm.h>
#include <reactphysics3d/collision/narrowphase/SphereVsConvexPolyhedronAlgorithm.h>
#include <reactphysics3d/collision/narrowphase/SphereVsCapsuleAlgorithm.h>
#include <reactphysics3d/collision/narrowphase/CapsuleVsCapsuleAlgorithm.h>
#include <reactphysics3d/collision/narrowphase/CapsuleVsConvexPolyhedronAlgorithm.h>
#include <reactphysics3d/collision/narrowphase/ConvexPolyhedronVsConvexPolyhedronAlgorithm.h>
#include <reactphysics3d/collision/shapes/CollisionShape.h>
namespace reactphysics3d {
/// Enumeration for the type of narrow-phase
/// collision detection algorithm
enum class NarrowPhaseAlgorithmType {
None,
SphereVsSphere,
SphereVsCapsule,
CapsuleVsCapsule,
SphereVsConvexPolyhedron,
CapsuleVsConvexPolyhedron,
ConvexPolyhedronVsConvexPolyhedron
};
// Class CollisionDispatch
/**
* This is the collision dispatch configuration use in ReactPhysics3D.
* Collision dispatching decides which collision
* algorithm to use given two types of colliders.
*/
class CollisionDispatch {
protected:
/// Memory allocator
MemoryAllocator& mAllocator;
/// True if the sphere vs sphere algorithm is the default one
bool mIsSphereVsSphereDefault = true;
/// True if the capsule vs capsule algorithm is the default one
bool mIsCapsuleVsCapsuleDefault = true;
/// True if the sphere vs capsule algorithm is the default one
bool mIsSphereVsCapsuleDefault = true;
/// True if the sphere vs convex polyhedron algorithm is the default one
bool mIsSphereVsConvexPolyhedronDefault = true;
/// True if the capsule vs convex polyhedron algorithm is the default one
bool mIsCapsuleVsConvexPolyhedronDefault = true;
/// True if the convex polyhedron vs convex polyhedron algorithm is the default one
bool mIsConvexPolyhedronVsConvexPolyhedronDefault = true;
/// Sphere vs Sphere collision algorithm
SphereVsSphereAlgorithm* mSphereVsSphereAlgorithm;
/// Capsule vs Capsule collision algorithm
CapsuleVsCapsuleAlgorithm* mCapsuleVsCapsuleAlgorithm;
/// Sphere vs Capsule collision algorithm
SphereVsCapsuleAlgorithm* mSphereVsCapsuleAlgorithm;
/// Sphere vs Convex Polyhedron collision algorithm
SphereVsConvexPolyhedronAlgorithm* mSphereVsConvexPolyhedronAlgorithm;
/// Capsule vs Convex Polyhedron collision algorithm
CapsuleVsConvexPolyhedronAlgorithm* mCapsuleVsConvexPolyhedronAlgorithm;
/// Convex Polyhedron vs Convex Polyhedron collision algorithm
ConvexPolyhedronVsConvexPolyhedronAlgorithm* mConvexPolyhedronVsConvexPolyhedronAlgorithm;
/// Collision detection matrix (algorithms to use)
NarrowPhaseAlgorithmType mCollisionMatrix[NB_COLLISION_SHAPE_TYPES][NB_COLLISION_SHAPE_TYPES];
/// Select and return the narrow-phase collision detection algorithm to
/// use between two types of collision shapes.
NarrowPhaseAlgorithmType selectAlgorithm(int type1, int type2);
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
#endif
public:
/// Constructor
CollisionDispatch(MemoryAllocator& allocator);
/// Destructor
~CollisionDispatch();
/// Set the Sphere vs Sphere narrow-phase collision detection algorithm
void setSphereVsSphereAlgorithm(SphereVsSphereAlgorithm* algorithm);
/// Get the Sphere vs Sphere narrow-phase collision detection algorithm
SphereVsSphereAlgorithm* getSphereVsSphereAlgorithm();
/// Set the Sphere vs Capsule narrow-phase collision detection algorithm
void setSphereVsCapsuleAlgorithm(SphereVsCapsuleAlgorithm* algorithm);
/// Get the Sphere vs Capsule narrow-phase collision detection algorithm
SphereVsCapsuleAlgorithm* getSphereVsCapsuleAlgorithm();
/// Set the Capsule vs Capsule narrow-phase collision detection algorithm
void setCapsuleVsCapsuleAlgorithm(CapsuleVsCapsuleAlgorithm* algorithm);
/// Get the Capsule vs Capsule narrow-phase collision detection algorithm
CapsuleVsCapsuleAlgorithm* getCapsuleVsCapsuleAlgorithm();
/// Set the Sphere vs Convex Polyhedron narrow-phase collision detection algorithm
void setSphereVsConvexPolyhedronAlgorithm(SphereVsConvexPolyhedronAlgorithm* algorithm);
/// Get the Sphere vs Convex Polyhedron narrow-phase collision detection algorithm
SphereVsConvexPolyhedronAlgorithm* getSphereVsConvexPolyhedronAlgorithm();
/// Set the Capsule vs Convex Polyhedron narrow-phase collision detection algorithm
void setCapsuleVsConvexPolyhedronAlgorithm(CapsuleVsConvexPolyhedronAlgorithm* algorithm);
/// Get the Capsule vs Convex Polyhedron narrow-phase collision detection algorithm
CapsuleVsConvexPolyhedronAlgorithm* getCapsuleVsConvexPolyhedronAlgorithm();
/// Set the Convex Polyhedron vs Convex Polyhedron narrow-phase collision detection algorithm
void setConvexPolyhedronVsConvexPolyhedronAlgorithm(ConvexPolyhedronVsConvexPolyhedronAlgorithm* algorithm);
/// Get the Convex Polyhedron vs Convex Polyhedron narrow-phase collision detection algorithm
ConvexPolyhedronVsConvexPolyhedronAlgorithm* getConvexPolyhedronVsConvexPolyhedronAlgorithm();
/// Fill-in the collision detection matrix
void fillInCollisionMatrix();
/// Return the corresponding narrow-phase algorithm type to use for two collision shapes
NarrowPhaseAlgorithmType selectNarrowPhaseAlgorithm(const CollisionShapeType& shape1Type,
const CollisionShapeType& shape2Type) const;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler);
#endif
};
// Get the Sphere vs Sphere narrow-phase collision detection algorithm
inline SphereVsSphereAlgorithm* CollisionDispatch::getSphereVsSphereAlgorithm() {
return mSphereVsSphereAlgorithm;
}
// Get the Sphere vs Capsule narrow-phase collision detection algorithm
inline SphereVsCapsuleAlgorithm* CollisionDispatch::getSphereVsCapsuleAlgorithm() {
return mSphereVsCapsuleAlgorithm;
}
// Get the Capsule vs Capsule narrow-phase collision detection algorithm
inline CapsuleVsCapsuleAlgorithm* CollisionDispatch::getCapsuleVsCapsuleAlgorithm() {
return mCapsuleVsCapsuleAlgorithm;
}
// Get the Sphere vs Convex Polyhedron narrow-phase collision detection algorithm
inline SphereVsConvexPolyhedronAlgorithm* CollisionDispatch::getSphereVsConvexPolyhedronAlgorithm() {
return mSphereVsConvexPolyhedronAlgorithm;
}
// Get the Capsule vs Convex Polyhedron narrow-phase collision detection algorithm
inline CapsuleVsConvexPolyhedronAlgorithm* CollisionDispatch::getCapsuleVsConvexPolyhedronAlgorithm() {
return mCapsuleVsConvexPolyhedronAlgorithm;
}
// Get the Convex Polyhedron vs Convex Polyhedron narrow-phase collision detection algorithm
inline ConvexPolyhedronVsConvexPolyhedronAlgorithm* CollisionDispatch::getConvexPolyhedronVsConvexPolyhedronAlgorithm() {
return mConvexPolyhedronVsConvexPolyhedronAlgorithm;
}
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void CollisionDispatch::setProfiler(Profiler* profiler) {
mProfiler = profiler;
mSphereVsSphereAlgorithm->setProfiler(profiler);
mCapsuleVsCapsuleAlgorithm->setProfiler(profiler);
mSphereVsCapsuleAlgorithm->setProfiler(profiler);
mSphereVsConvexPolyhedronAlgorithm->setProfiler(profiler);
mCapsuleVsConvexPolyhedronAlgorithm->setProfiler(profiler);
mConvexPolyhedronVsConvexPolyhedronAlgorithm->setProfiler(profiler);
}
#endif
}
#endif

8
src/collision/narrowphase/ConvexPolyhedronVsConvexPolyhedronAlgorithm.h → include/reactphysics3d/collision/narrowphase/ConvexPolyhedronVsConvexPolyhedronAlgorithm.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,13 +27,12 @@
#define REACTPHYSICS3D_CONVEX_POLYHEDRON_VS_CONVEX_POLYHEDRON_ALGORITHM_H
// Libraries
#include "NarrowPhaseAlgorithm.h"
#include <reactphysics3d/collision/narrowphase/NarrowPhaseAlgorithm.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class Body;
class ContactPoint;
// Class ConvexPolyhedronVsConvexPolyhedronAlgorithm
@ -65,7 +64,8 @@ class ConvexPolyhedronVsConvexPolyhedronAlgorithm : public NarrowPhaseAlgorithm
ConvexPolyhedronVsConvexPolyhedronAlgorithm& operator=(const ConvexPolyhedronVsConvexPolyhedronAlgorithm& algorithm) = delete;
/// Compute the narrow-phase collision detection between two convex polyhedra
virtual bool testCollision(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts, MemoryAllocator& memoryAllocator) override;
bool testCollision(NarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchStartIndex, uint batchNbItems,
bool clipWithPreviousAxisIfStillColliding, MemoryAllocator& memoryAllocator);
};
}

17
src/collision/narrowphase/GJK/GJKAlgorithm.h → include/reactphysics3d/collision/narrowphase/GJK/GJKAlgorithm.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,17 +27,19 @@
#define REACTPHYSICS3D_GJK_ALGORITHM_H
// Libraries
#include "decimal.h"
#include <reactphysics3d/decimal.h>
#include <reactphysics3d/configuration.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Declarations
class ContactManifoldInfo;
struct NarrowPhaseInfo;
struct NarrowPhaseInfoBatch;
class ConvexShape;
class Profiler;
class VoronoiSimplex;
template<typename T> class List;
// Constants
constexpr decimal REL_ERROR = decimal(1.0e-3);
@ -63,7 +65,7 @@ class GJKAlgorithm {
// -------------------- Attributes -------------------- //
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
@ -95,9 +97,10 @@ class GJKAlgorithm {
GJKAlgorithm& operator=(const GJKAlgorithm& algorithm) = delete;
/// Compute a contact info if the two bounding volumes collide.
GJKResult testCollision(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts);
void testCollision(NarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchStartIndex,
uint batchNbItems, List<GJKResult>& gjkResults);
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler);
@ -106,7 +109,7 @@ class GJKAlgorithm {
};
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void GJKAlgorithm::setProfiler(Profiler* profiler) {

4
src/collision/narrowphase/GJK/VoronoiSimplex.h → include/reactphysics3d/collision/narrowphase/GJK/VoronoiSimplex.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,7 +27,7 @@
#define REACTPHYSICS3D_VORONOI_SIMPLEX_H
// Libraries
#include "mathematics/Vector3.h"
#include <reactphysics3d/mathematics/Vector3.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {

21
src/collision/narrowphase/NarrowPhaseAlgorithm.h → include/reactphysics3d/collision/narrowphase/NarrowPhaseAlgorithm.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,16 +27,16 @@
#define REACTPHYSICS3D_NARROW_PHASE_ALGORITHM_H
// Libraries
#include <reactphysics3d/configuration.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
class CollisionDetection;
class Body;
class CollisionDetectionSystem;
class ContactManifoldInfo;
class DefaultPoolAllocator;
class OverlappingPair;
struct NarrowPhaseInfo;
struct NarrowPhaseInfoBatch;
struct ContactPointInfo;
class Profiler;
class MemoryAllocator;
@ -62,7 +62,7 @@ class NarrowPhaseCallback {
/**
* This abstract class is the base class for a narrow-phase collision
* detection algorithm. The goal of the narrow phase algorithm is to
* compute information about the contact between two proxy shapes.
* compute information about the contact between two colliders.
*/
class NarrowPhaseAlgorithm {
@ -70,7 +70,7 @@ class NarrowPhaseAlgorithm {
// -------------------- Attributes -------------------- //
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
@ -79,6 +79,7 @@ class NarrowPhaseAlgorithm {
public :
// -------------------- Methods -------------------- //
/// Constructor
@ -93,11 +94,7 @@ class NarrowPhaseAlgorithm {
/// Deleted assignment operator
NarrowPhaseAlgorithm& operator=(const NarrowPhaseAlgorithm& algorithm) = delete;
/// Compute a contact info if the two bounding volumes collide
virtual bool testCollision(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts,
MemoryAllocator& memoryAllocator)=0;
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler);
@ -106,7 +103,7 @@ class NarrowPhaseAlgorithm {
};
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void NarrowPhaseAlgorithm::setProfiler(Profiler* profiler) {

135
include/reactphysics3d/collision/narrowphase/NarrowPhaseInfoBatch.h Normal file
View File

@ -0,0 +1,135 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_NARROW_PHASE_INFO_BATCH_H
#define REACTPHYSICS3D_NARROW_PHASE_INFO_BATCH_H
// Libraries
#include <reactphysics3d/engine/OverlappingPairs.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class CollisionShape;
struct LastFrameCollisionInfo;
class ContactManifoldInfo;
struct ContactPointInfo;
// Struct NarrowPhaseInfoBatch
/**
* This abstract structure collects all the potential collisions from the middle-phase algorithm
* that have to be tested during narrow-phase collision detection. There is an implementation of
* this class for each kind of collision detection test. For instance, one for sphere vs sphere,
* one for sphere vs capsule, ...
*/
struct NarrowPhaseInfoBatch {
protected:
/// Memory allocator
MemoryAllocator& mMemoryAllocator;
/// Reference to all the broad-phase overlapping pairs
OverlappingPairs& mOverlappingPairs;
/// Cached capacity
uint mCachedCapacity = 0;
public:
/// List of Broadphase overlapping pairs ids
List<uint64> overlappingPairIds;
/// List of pointers to the first colliders to test collision with
List<Entity> colliderEntities1;
/// List of pointers to the second colliders to test collision with
List<Entity> colliderEntities2;
/// List of pointers to the first collision shapes to test collision with
List<CollisionShape*> collisionShapes1;
/// List of pointers to the second collision shapes to test collision with
List<CollisionShape*> collisionShapes2;
/// List of transforms that maps from collision shape 1 local-space to world-space
List<Transform> shape1ToWorldTransforms;
/// List of transforms that maps from collision shape 2 local-space to world-space
List<Transform> shape2ToWorldTransforms;
/// True for each pair of objects that we need to report contacts (false for triggers for instance)
List<bool> reportContacts;
/// Result of the narrow-phase collision detection test
List<bool> isColliding;
/// List of contact points created during the narrow-phase
List<List<ContactPointInfo*>> contactPoints;
/// Memory allocators for the collision shape (Used to release TriangleShape memory in destructor)
List<MemoryAllocator*> collisionShapeAllocators;
/// Collision infos of the previous frame
List<LastFrameCollisionInfo*> lastFrameCollisionInfos;
/// Constructor
NarrowPhaseInfoBatch(MemoryAllocator& allocator, OverlappingPairs& overlappingPairs);
/// Destructor
virtual ~NarrowPhaseInfoBatch();
/// Return the number of objects in the batch
uint getNbObjects() const;
/// Add shapes to be tested during narrow-phase collision detection into the batch
virtual void addNarrowPhaseInfo(uint64 pairId, uint64 pairIndex, Entity collider1, Entity collider2, CollisionShape* shape1,
CollisionShape* shape2, const Transform& shape1Transform,
const Transform& shape2Transform, bool needToReportContacts, MemoryAllocator& shapeAllocator);
/// Add a new contact point
virtual void addContactPoint(uint index, const Vector3& contactNormal, decimal penDepth,
const Vector3& localPt1, const Vector3& localPt2);
/// Reset the remaining contact points
void resetContactPoints(uint index);
// Initialize the containers using cached capacity
virtual void reserveMemory();
/// Clear all the objects in the batch
virtual void clear();
};
/// Return the number of objects in the batch
inline uint NarrowPhaseInfoBatch::getNbObjects() const {
return overlappingPairIds.size();
}
}
#endif

133
include/reactphysics3d/collision/narrowphase/NarrowPhaseInput.h Normal file
View File

@ -0,0 +1,133 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_NARROW_PHASE_INPUT_H
#define REACTPHYSICS3D_NARROW_PHASE_INPUT_H
// Libraries
#include <reactphysics3d/containers/List.h>
#include <reactphysics3d/collision/narrowphase/NarrowPhaseInfoBatch.h>
#include <reactphysics3d/collision/narrowphase/SphereVsSphereNarrowPhaseInfoBatch.h>
#include <reactphysics3d/collision/narrowphase/CapsuleVsCapsuleNarrowPhaseInfoBatch.h>
#include <reactphysics3d/collision/narrowphase/SphereVsCapsuleNarrowPhaseInfoBatch.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class OverlappingPair;
class CollisionShape;
struct LastFrameCollisionInfo;
struct ContactPointInfo;
class NarrowPhaseAlgorithm;
enum class NarrowPhaseAlgorithmType;
class Transform;
struct Vector3;
// Class NarrowPhaseInput
/**
* This structure contains everything that is needed to perform the narrow-phase
* collision detection.
*/
class NarrowPhaseInput {
private:
SphereVsSphereNarrowPhaseInfoBatch mSphereVsSphereBatch;
SphereVsCapsuleNarrowPhaseInfoBatch mSphereVsCapsuleBatch;
CapsuleVsCapsuleNarrowPhaseInfoBatch mCapsuleVsCapsuleBatch;
NarrowPhaseInfoBatch mSphereVsConvexPolyhedronBatch;
NarrowPhaseInfoBatch mCapsuleVsConvexPolyhedronBatch;
NarrowPhaseInfoBatch mConvexPolyhedronVsConvexPolyhedronBatch;
public:
/// Constructor
NarrowPhaseInput(MemoryAllocator& allocator, OverlappingPairs& overlappingPairs);
/// Add shapes to be tested during narrow-phase collision detection into the batch
void addNarrowPhaseTest(uint64 pairId, uint64 pairIndex, Entity collider1, Entity collider2, CollisionShape* shape1,
CollisionShape* shape2, const Transform& shape1Transform,
const Transform& shape2Transform, NarrowPhaseAlgorithmType narrowPhaseAlgorithmType, bool reportContacts,
MemoryAllocator& shapeAllocator);
/// Get a reference to the sphere vs sphere batch
SphereVsSphereNarrowPhaseInfoBatch& getSphereVsSphereBatch();
/// Get a reference to the sphere vs capsule batch
SphereVsCapsuleNarrowPhaseInfoBatch& getSphereVsCapsuleBatch();
/// Get a reference to the capsule vs capsule batch
CapsuleVsCapsuleNarrowPhaseInfoBatch& getCapsuleVsCapsuleBatch();
/// Get a reference to the sphere vs convex polyhedron batch
NarrowPhaseInfoBatch& getSphereVsConvexPolyhedronBatch();
/// Get a reference to the capsule vs convex polyhedron batch
NarrowPhaseInfoBatch& getCapsuleVsConvexPolyhedronBatch();
/// Get a reference to the convex polyhedron vs convex polyhedron batch
NarrowPhaseInfoBatch& getConvexPolyhedronVsConvexPolyhedronBatch();
/// Reserve memory for the containers with cached capacity
void reserveMemory();
/// Clear
void clear();
};
// Get a reference to the sphere vs sphere batch contacts
inline SphereVsSphereNarrowPhaseInfoBatch& NarrowPhaseInput::getSphereVsSphereBatch() {
return mSphereVsSphereBatch;
}
// Get a reference to the sphere vs capsule batch contacts
inline SphereVsCapsuleNarrowPhaseInfoBatch& NarrowPhaseInput::getSphereVsCapsuleBatch() {
return mSphereVsCapsuleBatch;
}
// Get a reference to the capsule vs capsule batch contacts
inline CapsuleVsCapsuleNarrowPhaseInfoBatch& NarrowPhaseInput::getCapsuleVsCapsuleBatch() {
return mCapsuleVsCapsuleBatch;
}
// Get a reference to the sphere vs convex polyhedron batch contacts
inline NarrowPhaseInfoBatch& NarrowPhaseInput::getSphereVsConvexPolyhedronBatch() {
return mSphereVsConvexPolyhedronBatch;
}
// Get a reference to the capsule vs convex polyhedron batch contacts
inline NarrowPhaseInfoBatch& NarrowPhaseInput::getCapsuleVsConvexPolyhedronBatch() {
return mCapsuleVsConvexPolyhedronBatch;
}
// Get a reference to the convex polyhedron vs convex polyhedron batch contacts
inline NarrowPhaseInfoBatch& NarrowPhaseInput::getConvexPolyhedronVsConvexPolyhedronBatch() {
return mConvexPolyhedronVsConvexPolyhedronBatch;
}
}
#endif

41
src/collision/narrowphase/SAT/SATAlgorithm.h → include/reactphysics3d/collision/narrowphase/SAT/SATAlgorithm.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_SAT_ALGORITHM_H
// Libraries
#include "decimal.h"
#include "collision/HalfEdgeStructure.h"
#include <reactphysics3d/decimal.h>
#include <reactphysics3d/collision/HalfEdgeStructure.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -37,7 +37,7 @@ namespace reactphysics3d {
class CapsuleShape;
class SphereShape;
class ContactManifoldInfo;
struct NarrowPhaseInfo;
struct NarrowPhaseInfoBatch;
class ConvexPolyhedronShape;
class MemoryAllocator;
class Profiler;
@ -61,10 +61,24 @@ class SATAlgorithm {
static const decimal SEPARATING_AXIS_RELATIVE_TOLERANCE;
static const decimal SEPARATING_AXIS_ABSOLUTE_TOLERANCE;
/// True means that if two shapes were colliding last time (previous frame) and are still colliding
/// we use the previous (minimum penetration depth) axis to clip the colliding features and we don't
/// recompute a new (minimum penetration depth) axis. This value must be true for a dynamic simulation
/// because it uses temporal coherence and clip the colliding features with the previous
/// axis (this is good for stability). However, when we use the testCollision() methods, the penetration
/// depths might be very large and we always want the current true axis with minimum penetration depth.
/// In this case, this value must be set to false. Consider the following situation. Two shapes start overlaping
/// with "x" being the axis of minimum penetration depth. Then, if the shapes move but are still penetrating,
/// it is possible that the axis of minimum penetration depth changes for axis "y" for instance. If this value
/// is true, we will always use the axis of the previous collision test and therefore always report that the
/// penetrating axis is "x" even if it has changed to axis "y" during the collision. This is not what we want
/// when we call the testCollision() methods.
bool mClipWithPreviousAxisIfStillColliding;
/// Memory allocator
MemoryAllocator& mMemoryAllocator;
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
@ -119,7 +133,7 @@ class SATAlgorithm {
bool computePolyhedronVsPolyhedronFaceContactPoints(bool isMinPenetrationFaceNormalPolyhedron1, const ConvexPolyhedronShape* polyhedron1,
const ConvexPolyhedronShape* polyhedron2, const Transform& polyhedron1ToPolyhedron2,
const Transform& polyhedron2ToPolyhedron1, uint minFaceIndex,
NarrowPhaseInfo* narrowPhaseInfo, decimal minPenetrationDepth) const;
NarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchIndex) const;
public :
@ -127,7 +141,7 @@ class SATAlgorithm {
// -------------------- Methods -------------------- //
/// Constructor
SATAlgorithm(MemoryAllocator& memoryAllocator);
SATAlgorithm(bool clipWithPreviousAxisIfStillColliding, MemoryAllocator& memoryAllocator);
/// Destructor
~SATAlgorithm() = default;
@ -139,26 +153,27 @@ class SATAlgorithm {
SATAlgorithm& operator=(const SATAlgorithm& algorithm) = delete;
/// Test collision between a sphere and a convex mesh
bool testCollisionSphereVsConvexPolyhedron(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts) const;
bool testCollisionSphereVsConvexPolyhedron(NarrowPhaseInfoBatch& narrowPhaseInfoBatch,
uint batchStartIndex, uint batchNbItems) const;
/// Test collision between a capsule and a convex mesh
bool testCollisionCapsuleVsConvexPolyhedron(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts) const;
bool testCollisionCapsuleVsConvexPolyhedron(NarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchIndex) const;
/// Compute the two contact points between a polyhedron and a capsule when the separating axis is a face normal of the polyhedron
bool computeCapsulePolyhedronFaceContactPoints(uint referenceFaceIndex, decimal capsuleRadius, const ConvexPolyhedronShape* polyhedron,
decimal penetrationDepth, const Transform& polyhedronToCapsuleTransform,
Vector3& normalWorld, const Vector3& separatingAxisCapsuleSpace,
const Vector3& capsuleSegAPolyhedronSpace, const Vector3& capsuleSegBPolyhedronSpace,
NarrowPhaseInfo* narrowPhaseInfo, bool isCapsuleShape1) const;
NarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchIndex, bool isCapsuleShape1) const;
// This method returns true if an edge of a polyhedron and a capsule forms a face of the Minkowski Difference
bool isMinkowskiFaceCapsuleVsEdge(const Vector3& capsuleSegment, const Vector3& edgeAdjacentFace1Normal,
const Vector3& edgeAdjacentFace2Normal) const;
/// Test collision between two convex meshes
bool testCollisionConvexPolyhedronVsConvexPolyhedron(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts) const;
bool testCollisionConvexPolyhedronVsConvexPolyhedron(NarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchStartIndex, uint batchNbItems) const;
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler);
@ -167,7 +182,7 @@ class SATAlgorithm {
};
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void SATAlgorithm::setProfiler(Profiler* profiler) {

10
src/collision/narrowphase/SphereVsCapsuleAlgorithm.h → include/reactphysics3d/collision/narrowphase/SphereVsCapsuleAlgorithm.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,15 +27,14 @@
#define REACTPHYSICS3D_SPHERE_VS_CAPSULE_ALGORITHM_H
// Libraries
#include "NarrowPhaseAlgorithm.h"
#include <reactphysics3d/collision/narrowphase/NarrowPhaseAlgorithm.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class Body;
class ContactPoint;
struct SphereVsCapsuleNarrowPhaseInfoBatch;
// Class SphereVsCapsuleAlgorithm
/**
@ -66,7 +65,8 @@ class SphereVsCapsuleAlgorithm : public NarrowPhaseAlgorithm {
SphereVsCapsuleAlgorithm& operator=(const SphereVsCapsuleAlgorithm& algorithm) = delete;
/// Compute the narrow-phase collision detection between a sphere and a capsule
virtual bool testCollision(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts, MemoryAllocator& memoryAllocator) override;
bool testCollision(SphereVsCapsuleNarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchStartIndex,
uint batchNbItems, MemoryAllocator& memoryAllocator);
};
}

78
include/reactphysics3d/collision/narrowphase/SphereVsCapsuleNarrowPhaseInfoBatch.h Normal file
View File

@ -0,0 +1,78 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_SPHERE_VS_CAPSULE_NARROW_PHASE_INFO_BATCH_H
#define REACTPHYSICS3D_SPHERE_VS_CAPSULE_NARROW_PHASE_INFO_BATCH_H
// Libraries
#include <reactphysics3d/collision/narrowphase/NarrowPhaseInfoBatch.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Struct SphereVsCapsuleNarrowPhaseInfoBatch
/**
* This structure collects all the potential collisions from the middle-phase algorithm
* that have to be tested during narrow-phase collision detection. This class collects all the
* sphere vs capsule collision detection tests.
*/
struct SphereVsCapsuleNarrowPhaseInfoBatch : public NarrowPhaseInfoBatch {
public:
/// List of boolean values to know if the the sphere is the first or second shape
List<bool> isSpheresShape1;
/// List of radiuses for the spheres
List<decimal> sphereRadiuses;
/// List of radiuses for the capsules
List<decimal> capsuleRadiuses;
/// List of heights for the capsules
List<decimal> capsuleHeights;
/// Constructor
SphereVsCapsuleNarrowPhaseInfoBatch(MemoryAllocator& allocator, OverlappingPairs& overlappingPairs);
/// Destructor
virtual ~SphereVsCapsuleNarrowPhaseInfoBatch() override = default;
/// Add shapes to be tested during narrow-phase collision detection into the batch
virtual void addNarrowPhaseInfo(uint64 pairId, uint64 pairIndex, Entity collider1, Entity collider2, CollisionShape* shape1,
CollisionShape* shape2, const Transform& shape1Transform,
const Transform& shape2Transform, bool needToReportContacts, MemoryAllocator& shapeAllocator) override;
// Initialize the containers using cached capacity
virtual void reserveMemory() override;
/// Clear all the objects in the batch
virtual void clear() override;
};
}
#endif

8
src/collision/narrowphase/SphereVsConvexPolyhedronAlgorithm.h → include/reactphysics3d/collision/narrowphase/SphereVsConvexPolyhedronAlgorithm.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,14 +27,13 @@
#define REACTPHYSICS3D_SPHERE_VS_CONVEX_POLYHEDRON_ALGORITHM_H
// Libraries
#include "NarrowPhaseAlgorithm.h"
#include <reactphysics3d/collision/narrowphase/NarrowPhaseAlgorithm.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class ContactPoint;
class Body;
// Class SphereVsConvexPolyhedronAlgorithm
/**
@ -71,7 +70,8 @@ class SphereVsConvexPolyhedronAlgorithm : public NarrowPhaseAlgorithm {
SphereVsConvexPolyhedronAlgorithm& operator=(const SphereVsConvexPolyhedronAlgorithm& algorithm) = delete;
/// Compute the narrow-phase collision detection between a sphere and a convex polyhedron
virtual bool testCollision(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts, MemoryAllocator& memoryAllocator) override;
bool testCollision(NarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchStartIndex, uint batchNbItems,
bool clipWithPreviousAxisIfStillColliding, MemoryAllocator& memoryAllocator);
};
}

9
src/collision/narrowphase/SphereVsSphereAlgorithm.h → include/reactphysics3d/collision/narrowphase/SphereVsSphereAlgorithm.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,14 +27,14 @@
#define REACTPHYSICS3D_SPHERE_VS_SPHERE_ALGORITHM_H
// Libraries
#include "NarrowPhaseAlgorithm.h"
#include <reactphysics3d/collision/narrowphase/NarrowPhaseAlgorithm.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class ContactPoint;
class Body;
struct SphereVsSphereNarrowPhaseInfoBatch;
// Class SphereVsSphereAlgorithm
/**
@ -65,7 +65,8 @@ class SphereVsSphereAlgorithm : public NarrowPhaseAlgorithm {
SphereVsSphereAlgorithm& operator=(const SphereVsSphereAlgorithm& algorithm) = delete;
/// Compute a contact info if the two bounding volume collide
virtual bool testCollision(NarrowPhaseInfo* narrowPhaseInfo, bool reportContacts, MemoryAllocator& memoryAllocator) override;
bool testCollision(SphereVsSphereNarrowPhaseInfoBatch& narrowPhaseInfoBatch, uint batchStartIndex,
uint batchNbItems, MemoryAllocator& memoryAllocator);
};
}

72
include/reactphysics3d/collision/narrowphase/SphereVsSphereNarrowPhaseInfoBatch.h Normal file
View File

@ -0,0 +1,72 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_SPHERE_VS_SPHERE_NARROW_PHASE_INFO_BATCH_H
#define REACTPHYSICS3D_SPHERE_VS_SPHERE_NARROW_PHASE_INFO_BATCH_H
// Libraries
#include <reactphysics3d/collision/narrowphase/NarrowPhaseInfoBatch.h>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Struct SphereVsSphereNarrowPhaseInfoBatch
/**
* This structure collects all the potential collisions from the middle-phase algorithm
* that have to be tested during narrow-phase collision detection. This class collects all the
* sphere vs sphere collision detection tests.
*/
struct SphereVsSphereNarrowPhaseInfoBatch : public NarrowPhaseInfoBatch {
public:
/// List of radiuses for the first spheres
List<decimal> sphere1Radiuses;
/// List of radiuses for the second spheres
List<decimal> sphere2Radiuses;
/// Constructor
SphereVsSphereNarrowPhaseInfoBatch(MemoryAllocator& allocator, OverlappingPairs& overlappingPairs);
/// Destructor
virtual ~SphereVsSphereNarrowPhaseInfoBatch() override = default;
/// Add shapes to be tested during narrow-phase collision detection into the batch
virtual void addNarrowPhaseInfo(uint64 airId, uint64 pairIndex, Entity collider1, Entity collider2, CollisionShape* shape1,
CollisionShape* shape2, const Transform& shape1Transform,
const Transform& shape2Transform, bool needToReportContacts, MemoryAllocator& shapeAllocator) override;
// Initialize the containers using cached capacity
virtual void reserveMemory() override;
/// Clear all the objects in the batch
virtual void clear() override;
};
}
#endif

13
src/collision/shapes/AABB.h → include/reactphysics3d/collision/shapes/AABB.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,7 +27,7 @@
#define REACTPHYSICS3D_AABB_H
// Libraries
#include "mathematics/mathematics.h"
#include <reactphysics3d/mathematics/mathematics.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -112,6 +112,9 @@ class AABB {
/// Return true if the ray intersects the AABB
bool testRayIntersect(const Ray& ray) const;
/// Apply a scale factor to the AABB
void applyScale(const Vector3& scale);
/// Create and return an AABB for a triangle
static AABB createAABBForTriangle(const Vector3* trianglePoints);
@ -199,6 +202,12 @@ inline bool AABB::contains(const Vector3& point) const {
point.z >= mMinCoordinates.z - MACHINE_EPSILON && point.z <= mMaxCoordinates.z + MACHINE_EPSILON);
}
// Apply a scale factor to the AABB
inline void AABB::applyScale(const Vector3& scale) {
mMinCoordinates = mMinCoordinates * scale;
mMaxCoordinates = mMaxCoordinates * scale;
}
// Assignment operator
inline AABB& AABB::operator=(const AABB& aabb) {
if (this != &aabb) {

85
src/collision/shapes/BoxShape.h → include/reactphysics3d/collision/shapes/BoxShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_BOX_SHAPE_H
// Libraries
#include "ConvexPolyhedronShape.h"
#include "mathematics/mathematics.h"
#include <reactphysics3d/collision/shapes/ConvexPolyhedronShape.h>
#include <reactphysics3d/mathematics/mathematics.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -50,50 +50,56 @@ class BoxShape : public ConvexPolyhedronShape {
// -------------------- Attributes -------------------- //
/// Extent sizes of the box in the x, y and z direction
Vector3 mExtent;
/// Half-extents of the box in the x, y and z direction
Vector3 mHalfExtents;
/// Half-edge structure of the polyhedron
HalfEdgeStructure mHalfEdgeStructure;
// -------------------- Methods -------------------- //
/// Constructor
BoxShape(const Vector3& halfExtents, MemoryAllocator& allocator);
/// Return a local support point in a given direction without the object margin
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction) const override;
/// Return true if a point is inside the collision shape
virtual bool testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const override;
virtual bool testPointInside(const Vector3& localPoint, Collider* collider) const override;
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape, MemoryAllocator& allocator) const override;
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, Collider* collider, MemoryAllocator& allocator) const override;
/// Return the number of bytes used by the collision shape
virtual size_t getSizeInBytes() const override;
/// Destructor
virtual ~BoxShape() override = default;
public :
// -------------------- Methods -------------------- //
/// Constructor
BoxShape(const Vector3& extent);
/// Destructor
virtual ~BoxShape() override = default;
/// Deleted copy-constructor
BoxShape(const BoxShape& shape) = delete;
/// Deleted assignment operator
BoxShape& operator=(const BoxShape& shape) = delete;
/// Return the extents of the box
Vector3 getExtent() const;
/// Return the half-extents of the box
Vector3 getHalfExtents() const;
/// Set the half-extents of the box
void setHalfExtents(const Vector3& halfExtents);
/// Return the local bounds of the shape in x, y and z directions
virtual void getLocalBounds(Vector3& min, Vector3& max) const override;
/// Return the local inertia tensor of the collision shape
virtual void computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const override;
virtual Vector3 getLocalInertiaTensor(decimal mass) const override;
/// Compute and return the volume of the collision shape
virtual decimal getVolume() const override;
/// Return the number of faces of the polyhedron
virtual uint getNbFaces() const override;
@ -124,14 +130,30 @@ class BoxShape : public ConvexPolyhedronShape {
/// Return the string representation of the shape
virtual std::string to_string() const override;
// ----- Friendship ----- //
friend class PhysicsCommon;
};
// Return the extents of the box
/**
* @return The vector with the three extents of the box shape (in meters)
* @return The vector with the three half-extents of the box shape
*/
inline Vector3 BoxShape::getExtent() const {
return mExtent;
inline Vector3 BoxShape::getHalfExtents() const {
return mHalfExtents;
}
// Set the half-extents of the box
/// Note that you might want to recompute the inertia tensor and center of mass of the body
/// after changing the size of the collision shape
/**
* @param halfExtents The vector with the three half-extents of the box
*/
inline void BoxShape::setHalfExtents(const Vector3& halfExtents) {
mHalfExtents = halfExtents;
notifyColliderAboutChangedSize();
}
// Return the local bounds of the shape in x, y and z directions
@ -143,7 +165,7 @@ inline Vector3 BoxShape::getExtent() const {
inline void BoxShape::getLocalBounds(Vector3& min, Vector3& max) const {
// Maximum bounds
max = mExtent;
max = mHalfExtents;
// Minimum bounds
min = -max;
@ -157,16 +179,16 @@ inline size_t BoxShape::getSizeInBytes() const {
// Return a local support point in a given direction without the object margin
inline Vector3 BoxShape::getLocalSupportPointWithoutMargin(const Vector3& direction) const {
return Vector3(direction.x < decimal(0.0) ? -mExtent.x : mExtent.x,
direction.y < decimal(0.0) ? -mExtent.y : mExtent.y,
direction.z < decimal(0.0) ? -mExtent.z : mExtent.z);
return Vector3(direction.x < decimal(0.0) ? -mHalfExtents.x : mHalfExtents.x,
direction.y < decimal(0.0) ? -mHalfExtents.y : mHalfExtents.y,
direction.z < decimal(0.0) ? -mHalfExtents.z : mHalfExtents.z);
}
// Return true if a point is inside the collision shape
inline bool BoxShape::testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const {
return (localPoint.x < mExtent[0] && localPoint.x > -mExtent[0] &&
localPoint.y < mExtent[1] && localPoint.y > -mExtent[1] &&
localPoint.z < mExtent[2] && localPoint.z > -mExtent[2]);
inline bool BoxShape::testPointInside(const Vector3& localPoint, Collider* collider) const {
return (localPoint.x < mHalfExtents[0] && localPoint.x > -mHalfExtents[0] &&
localPoint.y < mHalfExtents[1] && localPoint.y > -mHalfExtents[1] &&
localPoint.z < mHalfExtents[2] && localPoint.z > -mHalfExtents[2]);
}
// Return the number of faces of the polyhedron
@ -195,7 +217,7 @@ inline HalfEdgeStructure::Vertex BoxShape::getVertex(uint vertexIndex) const {
inline Vector3 BoxShape::getVertexPosition(uint vertexIndex) const {
assert(vertexIndex < getNbVertices());
Vector3 extent = getExtent();
Vector3 extent = getHalfExtents();
switch(vertexIndex) {
case 0: return Vector3(-extent.x, -extent.y, extent.z);
@ -234,9 +256,14 @@ inline Vector3 BoxShape::getCentroid() const {
return Vector3::zero();
}
// Compute and return the volume of the collision shape
inline decimal BoxShape::getVolume() const {
return 8 * mHalfExtents.x * mHalfExtents.y * mHalfExtents.z;
}
// Return the string representation of the shape
inline std::string BoxShape::to_string() const {
return "BoxShape{extents=" + mExtent.to_string() + "}";
return "BoxShape{extents=" + mHalfExtents.to_string() + "}";
}
// Return the number of half-edges of the polyhedron

70
src/collision/shapes/CapsuleShape.h → include/reactphysics3d/collision/shapes/CapsuleShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_CAPSULE_SHAPE_H
// Libraries
#include "ConvexShape.h"
#include "mathematics/mathematics.h"
#include <reactphysics3d/collision/shapes/ConvexShape.h>
#include <reactphysics3d/mathematics/mathematics.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
@ -57,14 +57,17 @@ class CapsuleShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Constructor
CapsuleShape(decimal radius, decimal height, MemoryAllocator& allocator);
/// Return a local support point in a given direction without the object margin
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction) const override;
/// Return true if a point is inside the collision shape
virtual bool testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const override;
virtual bool testPointInside(const Vector3& localPoint, Collider* collider) const override;
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape, MemoryAllocator& allocator) const override;
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, Collider* collider, MemoryAllocator& allocator) const override;
/// Raycasting method between a ray one of the two spheres end cap of the capsule
bool raycastWithSphereEndCap(const Vector3& point1, const Vector3& point2,
@ -74,16 +77,13 @@ class CapsuleShape : public ConvexShape {
/// Return the number of bytes used by the collision shape
virtual size_t getSizeInBytes() const override;
/// Destructor
virtual ~CapsuleShape() override = default;
public :
// -------------------- Methods -------------------- //
/// Constructor
CapsuleShape(decimal radius, decimal height);
/// Destructor
virtual ~CapsuleShape() override = default;
/// Deleted copy-constructor
CapsuleShape(const CapsuleShape& shape) = delete;
@ -93,20 +93,33 @@ class CapsuleShape : public ConvexShape {
/// Return the radius of the capsule
decimal getRadius() const;
/// Set the radius of the capsule
void setRadius(decimal radius);
/// Return the height of the capsule
decimal getHeight() const;
/// Set the height of the capsule
void setHeight(decimal height);
/// Return the local bounds of the shape in x, y and z directions
virtual void getLocalBounds(Vector3& min, Vector3& max) const override;
/// Compute and return the volume of the collision shape
virtual decimal getVolume() const override;
/// Return true if the collision shape is a polyhedron
virtual bool isPolyhedron() const override;
/// Return the local inertia tensor of the collision shape
virtual void computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const override;
virtual Vector3 getLocalInertiaTensor(decimal mass) const override;
/// Return the string representation of the shape
virtual std::string to_string() const override;
// ----- Friendship ----- //
friend class PhysicsCommon;
};
// Get the radius of the capsule
@ -117,6 +130,20 @@ inline decimal CapsuleShape::getRadius() const {
return mMargin;
}
// Set the radius of the capsule
/// Note that you might want to recompute the inertia tensor and center of mass of the body
/// after changing the radius of the collision shape
/**
* @param radius The radius of the capsule (in meters)
*/
inline void CapsuleShape::setRadius(decimal radius) {
assert(radius > decimal(0.0));
mMargin = radius;
notifyColliderAboutChangedSize();
}
// Return the height of the capsule
/**
* @return The height of the capsule shape (in meters)
@ -125,6 +152,20 @@ inline decimal CapsuleShape::getHeight() const {
return mHalfHeight + mHalfHeight;
}
// Set the height of the capsule
/// Note that you might want to recompute the inertia tensor and center of mass of the body
/// after changing the height of the collision shape
/**
* @param height The height of the capsule (in meters)
*/
inline void CapsuleShape::setHeight(decimal height) {
assert(height > decimal(0.0));
mHalfHeight = height * decimal(0.5);
notifyColliderAboutChangedSize();
}
// Return the number of bytes used by the collision shape
inline size_t CapsuleShape::getSizeInBytes() const {
return sizeof(CapsuleShape);
@ -149,6 +190,11 @@ inline void CapsuleShape::getLocalBounds(Vector3& min, Vector3& max) const {
min.z = min.x;
}
// Compute and return the volume of the collision shape
inline decimal CapsuleShape::getVolume() const {
return reactphysics3d::PI * mMargin * mMargin * (decimal(4.0) * mMargin / decimal(3.0) + decimal(2.0) * mHalfHeight);
}
// Return true if the collision shape is a polyhedron
inline bool CapsuleShape::isPolyhedron() const {
return false;

63
src/collision/shapes/CollisionShape.h → include/reactphysics3d/collision/shapes/CollisionShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -28,7 +28,9 @@
// Libraries
#include <cassert>
#include "configuration.h"
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/utils/Profiler.h>
#include <reactphysics3d/containers/List.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -51,7 +53,7 @@ const int NB_COLLISION_SHAPE_TYPES = 4;
enum class CollisionShapeName { TRIANGLE, SPHERE, CAPSULE, BOX, CONVEX_MESH, TRIANGLE_MESH, HEIGHTFIELD };
// Declarations
class ProxyShape;
class Collider;
class CollisionBody;
// Class CollisionShape
@ -72,9 +74,12 @@ class CollisionShape {
CollisionShapeName mName;
/// Unique identifier of the shape inside an overlapping pair
uint mId;
uint32 mId;
#ifdef IS_PROFILING_ACTIVE
/// List of the colliders associated with this shape
List<Collider*> mColliders;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
@ -84,20 +89,29 @@ class CollisionShape {
// -------------------- Methods -------------------- //
/// Return true if a point is inside the collision shape
virtual bool testPointInside(const Vector3& worldPoint, ProxyShape* proxyShape) const=0;
virtual bool testPointInside(const Vector3& worldPoint, Collider* collider) const=0;
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape, MemoryAllocator& allocator) const=0;
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, Collider* collider, MemoryAllocator& allocator) const=0;
/// Return the number of bytes used by the collision shape
virtual size_t getSizeInBytes() const = 0;
/// Assign a new collider to the collision shape
void addCollider(Collider* collider);
/// Remove an assigned collider from the collision shape
void removeCollider(Collider* collider);
/// Notify all the assign colliders that the size of the collision shape has changed
void notifyColliderAboutChangedSize();
public :
// -------------------- Methods -------------------- //
/// Constructor
CollisionShape(CollisionShapeName name, CollisionShapeType type);
CollisionShape(CollisionShapeName name, CollisionShapeType type, MemoryAllocator& allocator);
/// Destructor
virtual ~CollisionShape() = default;
@ -123,14 +137,14 @@ class CollisionShape {
/// Return the local bounds of the shape in x, y and z directions
virtual void getLocalBounds(Vector3& min, Vector3& max) const=0;
/// Return the scaling vector of the collision shape
Vector3 getLocalScaling() const;
/// Return the id of the shape
uint getId() const;
uint32 getId() const;
/// Return the local inertia tensor of the collision shapes
virtual void computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const=0;
virtual Vector3 getLocalInertiaTensor(decimal mass) const=0;
/// Compute and return the volume of the collision shape
virtual decimal getVolume() const=0;
/// Compute the world-space AABB of the collision shape given a transform
virtual void computeAABB(AABB& aabb, const Transform& transform) const;
@ -138,7 +152,7 @@ class CollisionShape {
/// Return the string representation of the shape
virtual std::string to_string() const=0;
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
virtual void setProfiler(Profiler* profiler);
@ -147,8 +161,11 @@ class CollisionShape {
// -------------------- Friendship -------------------- //
friend class ProxyShape;
friend class CollisionWorld;
friend class Collider;
friend class CollisionBody;
friend class RigidBody;
friend class PhyscisWorld;
friend class BroadPhaseSystem;
};
// Return the name of the collision shape
@ -168,11 +185,21 @@ inline CollisionShapeType CollisionShape::getType() const {
}
// Return the id of the shape
inline uint CollisionShape::getId() const {
inline uint32 CollisionShape::getId() const {
return mId;
}
#ifdef IS_PROFILING_ACTIVE
// Assign a new collider to the collision shape
inline void CollisionShape::addCollider(Collider* collider) {
mColliders.add(collider);
}
// Remove an assigned collider from the collision shape
inline void CollisionShape::removeCollider(Collider* collider) {
mColliders.remove(collider);
}
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void CollisionShape::setProfiler(Profiler* profiler) {

90
src/collision/shapes/ConcaveMeshShape.h → include/reactphysics3d/collision/shapes/ConcaveMeshShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,9 +27,9 @@
#define REACTPHYSICS3D_CONCAVE_MESH_SHAPE_H
// Libraries
#include "ConcaveShape.h"
#include "collision/broadphase/DynamicAABBTree.h"
#include "containers/List.h"
#include <reactphysics3d/collision/shapes/ConcaveShape.h>
#include <reactphysics3d/collision/broadphase/DynamicAABBTree.h>
#include <reactphysics3d/containers/List.h>
namespace reactphysics3d {
@ -75,13 +75,14 @@ class ConcaveMeshRaycastCallback : public DynamicAABBTreeRaycastCallback {
List<int32> mHitAABBNodes;
const DynamicAABBTree& mDynamicAABBTree;
const ConcaveMeshShape& mConcaveMeshShape;
ProxyShape* mProxyShape;
Collider* mCollider;
RaycastInfo& mRaycastInfo;
const Ray& mRay;
bool mIsHit;
MemoryAllocator& mAllocator;
const Vector3& mMeshScale;
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
@ -92,9 +93,9 @@ class ConcaveMeshRaycastCallback : public DynamicAABBTreeRaycastCallback {
// Constructor
ConcaveMeshRaycastCallback(const DynamicAABBTree& dynamicAABBTree, const ConcaveMeshShape& concaveMeshShape,
ProxyShape* proxyShape, RaycastInfo& raycastInfo, const Ray& ray, MemoryAllocator& allocator)
: mHitAABBNodes(allocator), mDynamicAABBTree(dynamicAABBTree), mConcaveMeshShape(concaveMeshShape), mProxyShape(proxyShape),
mRaycastInfo(raycastInfo), mRay(ray), mIsHit(false), mAllocator(allocator) {
Collider* collider, RaycastInfo& raycastInfo, const Ray& ray, const Vector3& meshScale, MemoryAllocator& allocator)
: mHitAABBNodes(allocator), mDynamicAABBTree(dynamicAABBTree), mConcaveMeshShape(concaveMeshShape), mCollider(collider),
mRaycastInfo(raycastInfo), mRay(ray), mIsHit(false), mAllocator(allocator), mMeshScale(meshScale) {
}
@ -109,7 +110,7 @@ class ConcaveMeshRaycastCallback : public DynamicAABBTreeRaycastCallback {
return mIsHit;
}
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler) {
@ -131,7 +132,7 @@ class ConcaveMeshShape : public ConcaveShape {
// -------------------- Attributes -------------------- //
/// Triangle mesh
/// Pointer to the triangle mesh
TriangleMesh* mTriangleMesh;
/// Dynamic AABB tree to accelerate collision with the triangles
@ -141,13 +142,13 @@ class ConcaveMeshShape : public ConcaveShape {
/// if the user did not provide its own vertices normals)
Vector3** mComputedVerticesNormals;
/// Scaling
const Vector3 mScaling;
// -------------------- Methods -------------------- //
/// Constructor
ConcaveMeshShape(TriangleMesh* triangleMesh, MemoryAllocator& allocator, const Vector3& scaling = Vector3(1, 1, 1));
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape, MemoryAllocator& allocator) const override;
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, Collider* collider, MemoryAllocator& allocator) const override;
/// Return the number of bytes used by the collision shape
virtual size_t getSizeInBytes() const override;
@ -155,26 +156,31 @@ class ConcaveMeshShape : public ConcaveShape {
/// Insert all the triangles into the dynamic AABB tree
void initBVHTree();
/// Return the three vertices coordinates (in the list outTriangleVertices) of a triangle
void getTriangleVertices(uint subPart, uint triangleIndex, Vector3* outTriangleVertices) const;
/// Return the three vertex normals (in the array outVerticesNormals) of a triangle
void getTriangleVerticesNormals(uint subPart, uint triangleIndex, Vector3* outVerticesNormals) const;
/// Compute the shape Id for a given triangle of the mesh
uint computeTriangleShapeId(uint subPart, uint triangleIndex) const;
public:
/// Constructor
ConcaveMeshShape(TriangleMesh* triangleMesh, const Vector3& scaling = Vector3(1, 1, 1));
/// Compute all the triangles of the mesh that are overlapping with the AABB in parameter
virtual void computeOverlappingTriangles(const AABB& localAABB, List<Vector3>& triangleVertices,
List<Vector3> &triangleVerticesNormals, List<uint>& shapeIds,
MemoryAllocator& allocator) const override;
/// Destructor
virtual ~ConcaveMeshShape() override = default;
public:
/// Deleted copy-constructor
ConcaveMeshShape(const ConcaveMeshShape& shape) = delete;
/// Deleted assignment operator
ConcaveMeshShape& operator=(const ConcaveMeshShape& shape) = delete;
/// Return the scaling vector
const Vector3& getScaling() const;
/// Return the number of sub parts contained in this mesh
uint getNbSubparts() const;
@ -184,25 +190,13 @@ class ConcaveMeshShape : public ConcaveShape {
/// Return the indices of the three vertices of a given triangle in the array
void getTriangleVerticesIndices(uint subPart, uint triangleIndex, uint* outVerticesIndices) const;
/// Return the three vertices coordinates (in the array outTriangleVertices) of a triangle
void getTriangleVertices(uint subPart, uint triangleIndex, Vector3* outTriangleVertices) const;
/// Return the three vertex normals (in the array outVerticesNormals) of a triangle
void getTriangleVerticesNormals(uint subPart, uint triangleIndex, Vector3* outVerticesNormals) const;
/// Return the local bounds of the shape in x, y and z directions.
virtual void getLocalBounds(Vector3& min, Vector3& max) const override;
/// Return the local inertia tensor of the collision shape
virtual void computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const override;
/// Use a callback method on all triangles of the concave shape inside a given AABB
virtual void testAllTriangles(TriangleCallback& callback, const AABB& localAABB) const override;
/// Return the string representation of the shape
virtual std::string to_string() const override;
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
virtual void setProfiler(Profiler* profiler) override;
@ -213,6 +207,8 @@ class ConcaveMeshShape : public ConcaveShape {
friend class ConvexTriangleAABBOverlapCallback;
friend class ConcaveMeshRaycastCallback;
friend class PhysicsCommon;
friend class DebugRenderer;
};
// Return the number of bytes used by the collision shape
@ -220,11 +216,6 @@ inline size_t ConcaveMeshShape::getSizeInBytes() const {
return sizeof(ConcaveMeshShape);
}
// Return the scaling vector
inline const Vector3& ConcaveMeshShape::getScaling() const {
return mScaling;
}
// Return the local bounds of the shape in x, y and z directions.
// This method is used to compute the AABB of the box
/**
@ -240,23 +231,6 @@ inline void ConcaveMeshShape::getLocalBounds(Vector3& min, Vector3& max) const {
max = treeAABB.getMax();
}
// Return the local inertia tensor of the shape
/**
* @param[out] tensor The 3x3 inertia tensor matrix of the shape in local-space
* coordinates
* @param mass Mass to use to compute the inertia tensor of the collision shape
*/
inline void ConcaveMeshShape::computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const {
// Default inertia tensor
// Note that this is not very realistic for a concave triangle mesh.
// However, in most cases, it will only be used static bodies and therefore,
// the inertia tensor is not used.
tensor.setAllValues(mass, 0, 0,
0, mass, 0,
0, 0, mass);
}
// Called when a overlapping node has been found during the call to
// DynamicAABBTree:reportAllShapesOverlappingWithAABB()
inline void ConvexTriangleAABBOverlapCallback::notifyOverlappingNode(int nodeId) {
@ -276,7 +250,7 @@ inline void ConvexTriangleAABBOverlapCallback::notifyOverlappingNode(int nodeId)
mTriangleTestCallback.testTriangle(trianglePoints, verticesNormals, mConcaveMeshShape.computeTriangleShapeId(data[0], data[1]));
}
#ifdef IS_PROFILING_ACTIVE
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void ConcaveMeshShape::setProfiler(Profiler* profiler) {

59
src/collision/shapes/ConcaveShape.h → include/reactphysics3d/collision/shapes/ConcaveShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_CONCAVE_SHAPE_H
// Libraries
#include "CollisionShape.h"
#include "TriangleShape.h"
#include <reactphysics3d/collision/shapes/CollisionShape.h>
#include <reactphysics3d/collision/shapes/TriangleShape.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
@ -65,17 +65,20 @@ class ConcaveShape : public CollisionShape {
/// Raycast test type for the triangle (front, back, front-back)
TriangleRaycastSide mRaycastTestType;
/// Scale of the shape
Vector3 mScale;
// -------------------- Methods -------------------- //
/// Return true if a point is inside the collision shape
virtual bool testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const override;
virtual bool testPointInside(const Vector3& localPoint, Collider* collider) const override;
public :
// -------------------- Methods -------------------- //
/// Constructor
ConcaveShape(CollisionShapeName name);
ConcaveShape(CollisionShapeName name, MemoryAllocator& allocator, const Vector3& scaling);
/// Destructor
virtual ~ConcaveShape() override = default;
@ -92,6 +95,15 @@ class ConcaveShape : public CollisionShape {
// Set the raycast test type (front, back, front-back)
void setRaycastTestType(TriangleRaycastSide testType);
/// Return the scale of the shape
const Vector3& getScale() const;
/// Set the scale of the shape
void setScale(const Vector3& scale);
/// Return the local inertia tensor of the collision shape
virtual Vector3 getLocalInertiaTensor(decimal mass) const override;
/// Return true if the collision shape is convex, false if it is concave
virtual bool isConvex() const override;
@ -99,7 +111,12 @@ class ConcaveShape : public CollisionShape {
virtual bool isPolyhedron() const override;
/// Use a callback method on all triangles of the concave shape inside a given AABB
virtual void testAllTriangles(TriangleCallback& callback, const AABB& localAABB) const=0;
virtual void computeOverlappingTriangles(const AABB& localAABB, List<Vector3>& triangleVertices,
List<Vector3>& triangleVerticesNormals, List<uint>& shapeIds,
MemoryAllocator& allocator) const=0;
/// Compute and return the volume of the collision shape
virtual decimal getVolume() const override;
};
// Return true if the collision shape is convex, false if it is concave
@ -113,7 +130,7 @@ inline bool ConcaveShape::isPolyhedron() const {
}
// Return true if a point is inside the collision shape
inline bool ConcaveShape::testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const {
inline bool ConcaveShape::testPointInside(const Vector3& localPoint, Collider* collider) const {
return false;
}
@ -130,6 +147,34 @@ inline void ConcaveShape::setRaycastTestType(TriangleRaycastSide testType) {
mRaycastTestType = testType;
}
// Return the scale of the shape
inline const Vector3& ConcaveShape::getScale() const {
return mScale;
}
// Set the scale of the shape
/// Note that you might want to recompute the inertia tensor and center of mass of the body
/// after changing the scale of a collision shape
inline void ConcaveShape::setScale(const Vector3& scale) {
mScale = scale;
notifyColliderAboutChangedSize();
}
// Return the local inertia tensor of the shape
/**
* @param mass Mass to use to compute the inertia tensor of the collision shape
*/
inline Vector3 ConcaveShape::getLocalInertiaTensor(decimal mass) const {
// Default inertia tensor
// Note that this is not very realistic for a concave triangle mesh.
// However, in most cases, it will only be used static bodies and therefore,
// the inertia tensor is not used.
return Vector3(mass, mass, mass);
}
}
#endif

88
src/collision/shapes/ConvexMeshShape.h → include/reactphysics3d/collision/shapes/ConvexMeshShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,17 +27,16 @@
#define REACTPHYSICS3D_CONVEX_MESH_SHAPE_H
// Libraries
#include "ConvexPolyhedronShape.h"
#include "mathematics/mathematics.h"
#include "collision/PolyhedronMesh.h"
#include <reactphysics3d/collision/shapes/ConvexPolyhedronShape.h>
#include <reactphysics3d/mathematics/mathematics.h>
#include <reactphysics3d/collision/PolyhedronMesh.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Declaration
class CollisionWorld;
class GJKAlgorithm;
class CollisionWorld;
class PhysicsWorld;
// Class ConvexMeshShape
/**
@ -61,11 +60,14 @@ class ConvexMeshShape : public ConvexPolyhedronShape {
/// Mesh maximum bounds in the three local x, y and z directions
Vector3 mMaxBounds;
/// Local scaling
const Vector3 mScaling;
/// Scale of the mesh
Vector3 mScale;
// -------------------- Methods -------------------- //
/// Constructor
ConvexMeshShape(PolyhedronMesh* polyhedronMesh, MemoryAllocator& allocator, const Vector3& scale = Vector3(1,1,1));
/// Recompute the bounds of the mesh
void recalculateBounds();
@ -73,38 +75,38 @@ class ConvexMeshShape : public ConvexPolyhedronShape {
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction) const override;
/// Return true if a point is inside the collision shape
virtual bool testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const override;
virtual bool testPointInside(const Vector3& localPoint, Collider* collider) const override;
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape, MemoryAllocator& allocator) const override;
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, Collider* collider, MemoryAllocator& allocator) const override;
/// Return the number of bytes used by the collision shape
virtual size_t getSizeInBytes() const override;
/// Destructor
virtual ~ConvexMeshShape() override = default;
public :
// -------------------- Methods -------------------- //
/// Constructor
ConvexMeshShape(PolyhedronMesh* polyhedronMesh, const Vector3& scaling = Vector3(1,1,1));
/// Destructor
virtual ~ConvexMeshShape() override = default;
/// Deleted copy-constructor
ConvexMeshShape(const ConvexMeshShape& shape) = delete;
/// Deleted assignment operator
ConvexMeshShape& operator=(const ConvexMeshShape& shape) = delete;
/// Return the scaling vector
const Vector3& getScaling() const;
/// Return the scale
const Vector3& getScale() const;
/// Set the scale
void setScale(const Vector3& scale);
/// Return the local bounds of the shape in x, y and z directions
virtual void getLocalBounds(Vector3& min, Vector3& max) const override;
/// Return the local inertia tensor of the collision shape.
virtual void computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const override;
virtual Vector3 getLocalInertiaTensor(decimal mass) const override;
/// Return the number of faces of the polyhedron
virtual uint getNbFaces() const override;
@ -133,8 +135,15 @@ class ConvexMeshShape : public ConvexPolyhedronShape {
/// Return the centroid of the polyhedron
virtual Vector3 getCentroid() const override;
/// Compute and return the volume of the collision shape
virtual decimal getVolume() const override;
/// Return the string representation of the shape
virtual std::string to_string() const override;
// ----- Friendship ----- //
friend class PhysicsCommon;
};
// Return the number of bytes used by the collision shape
@ -143,8 +152,17 @@ inline size_t ConvexMeshShape::getSizeInBytes() const {
}
// Return the scaling vector
inline const Vector3& ConvexMeshShape::getScaling() const {
return mScaling;
inline const Vector3& ConvexMeshShape::getScale() const {
return mScale;
}
// Set the scale
/// Note that you might want to recompute the inertia tensor and center of mass of the body
/// after changing the scale of a collision shape
inline void ConvexMeshShape::setScale(const Vector3& scale) {
mScale = scale;
recalculateBounds();
notifyColliderAboutChangedSize();
}
// Return the local bounds of the shape in x, y and z directions
@ -161,20 +179,16 @@ inline void ConvexMeshShape::getLocalBounds(Vector3& min, Vector3& max) const {
/// The local inertia tensor of the convex mesh is approximated using the inertia tensor
/// of its bounding box.
/**
* @param[out] tensor The 3x3 inertia tensor matrix of the shape in local-space
* coordinates
* @param mass Mass to use to compute the inertia tensor of the collision shape
*/
inline void ConvexMeshShape::computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const {
decimal factor = (decimal(1.0) / decimal(3.0)) * mass;
Vector3 realExtent = decimal(0.5) * (mMaxBounds - mMinBounds);
inline Vector3 ConvexMeshShape::getLocalInertiaTensor(decimal mass) const {
const decimal factor = (decimal(1.0) / decimal(3.0)) * mass;
const Vector3 realExtent = decimal(0.5) * (mMaxBounds - mMinBounds);
assert(realExtent.x > 0 && realExtent.y > 0 && realExtent.z > 0);
decimal xSquare = realExtent.x * realExtent.x;
decimal ySquare = realExtent.y * realExtent.y;
decimal zSquare = realExtent.z * realExtent.z;
tensor.setAllValues(factor * (ySquare + zSquare), 0.0, 0.0,
0.0, factor * (xSquare + zSquare), 0.0,
0.0, 0.0, factor * (xSquare + ySquare));
const decimal xSquare = realExtent.x * realExtent.x;
const decimal ySquare = realExtent.y * realExtent.y;
const decimal zSquare = realExtent.z * realExtent.z;
return Vector3(factor * (ySquare + zSquare), factor * (xSquare + zSquare), factor * (xSquare + ySquare));
}
// Return the number of faces of the polyhedron
@ -213,7 +227,7 @@ inline const HalfEdgeStructure::Edge& ConvexMeshShape::getHalfEdge(uint edgeInde
// Return the position of a given vertex
inline Vector3 ConvexMeshShape::getVertexPosition(uint vertexIndex) const {
assert(vertexIndex < getNbVertices());
return mPolyhedronMesh->getVertex(vertexIndex) * mScaling;
return mPolyhedronMesh->getVertex(vertexIndex) * mScale;
}
// Return the normal vector of a given face of the polyhedron
@ -224,7 +238,13 @@ inline Vector3 ConvexMeshShape::getFaceNormal(uint faceIndex) const {
// Return the centroid of the polyhedron
inline Vector3 ConvexMeshShape::getCentroid() const {
return mPolyhedronMesh->getCentroid() * mScaling;
return mPolyhedronMesh->getCentroid() * mScale;
}
// Compute and return the volume of the collision shape
inline decimal ConvexMeshShape::getVolume() const {
return mPolyhedronMesh->getVolume();
}
}

8
src/collision/shapes/ConvexPolyhedronShape.h → include/reactphysics3d/collision/shapes/ConvexPolyhedronShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_CONVEX_POLYHEDRON_H
// Libraries
#include "ConvexShape.h"
#include "collision/HalfEdgeStructure.h"
#include <reactphysics3d/collision/shapes/ConvexShape.h>
#include <reactphysics3d/collision/HalfEdgeStructure.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -47,7 +47,7 @@ class ConvexPolyhedronShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Constructor
ConvexPolyhedronShape(CollisionShapeName name);
ConvexPolyhedronShape(CollisionShapeName name, MemoryAllocator& allocator);
/// Destructor
virtual ~ConvexPolyhedronShape() override = default;

6
src/collision/shapes/ConvexShape.h → include/reactphysics3d/collision/shapes/ConvexShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,7 +27,7 @@
#define REACTPHYSICS3D_CONVEX_SHAPE_H
// Libraries
#include "CollisionShape.h"
#include <reactphysics3d/collision/shapes/CollisionShape.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -59,7 +59,7 @@ class ConvexShape : public CollisionShape {
// -------------------- Methods -------------------- //
/// Constructor
ConvexShape(CollisionShapeName name, CollisionShapeType type, decimal margin = decimal(0.0));
ConvexShape(CollisionShapeName name, CollisionShapeType type, MemoryAllocator& allocator, decimal margin = decimal(0.0));
/// Destructor
virtual ~ConvexShape() override = default;

114
src/collision/shapes/HeightFieldShape.h → include/reactphysics3d/collision/shapes/HeightFieldShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_HEIGHTFIELD_SHAPE_H
// Libraries
#include "ConcaveShape.h"
#include "collision/shapes/AABB.h"
#include <reactphysics3d/collision/shapes/ConcaveShape.h>
#include <reactphysics3d/collision/shapes/AABB.h>
namespace reactphysics3d {
@ -36,57 +36,6 @@ class HeightFieldShape;
class Profiler;
class TriangleShape;
// Class TriangleOverlapCallback
/**
* This class is used for testing AABB and triangle overlap for raycasting
*/
class TriangleOverlapCallback : public TriangleCallback {
protected:
const Ray& mRay;
ProxyShape* mProxyShape;
RaycastInfo& mRaycastInfo;
bool mIsHit;
decimal mSmallestHitFraction;
const HeightFieldShape& mHeightFieldShape;
MemoryAllocator& mAllocator;
#ifdef IS_PROFILING_ACTIVE
/// Pointer to the profiler
Profiler* mProfiler;
#endif
public:
// Constructor
TriangleOverlapCallback(const Ray& ray, ProxyShape* proxyShape, RaycastInfo& raycastInfo,
const HeightFieldShape& heightFieldShape, MemoryAllocator& allocator)
: mRay(ray), mProxyShape(proxyShape), mRaycastInfo(raycastInfo),
mHeightFieldShape (heightFieldShape), mAllocator(allocator) {
mIsHit = false;
mSmallestHitFraction = mRay.maxFraction;
}
bool getIsHit() const {return mIsHit;}
/// Raycast test between a ray and a triangle of the heightfield
virtual void testTriangle(const Vector3* trianglePoints, const Vector3* verticesNormals, uint shapeId) override;
#ifdef IS_PROFILING_ACTIVE
/// Set the profiler
void setProfiler(Profiler* profiler) {
mProfiler = profiler;
}
#endif
};
// Class HeightFieldShape
/**
* This class represents a static height field that can be used to represent
@ -142,13 +91,16 @@ class HeightFieldShape : public ConcaveShape {
/// Local AABB of the height field (without scaling)
AABB mAABB;
/// Scaling vector
const Vector3 mScaling;
// -------------------- Methods -------------------- //
/// Constructor
HeightFieldShape(int nbGridColumns, int nbGridRows, decimal minHeight, decimal maxHeight,
const void* heightFieldData, HeightDataType dataType, MemoryAllocator& allocator,
int upAxis = 1, decimal integerHeightScale = 1.0f,
const Vector3& scaling = Vector3(1,1,1));
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape, MemoryAllocator& allocator) const override;
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, Collider* collider, MemoryAllocator& allocator) const override;
/// Return the number of bytes used by the collision shape
virtual size_t getSizeInBytes() const override;
@ -170,26 +122,17 @@ class HeightFieldShape : public ConcaveShape {
/// Compute the shape Id for a given triangle
uint computeTriangleShapeId(uint iIndex, uint jIndex, uint secondTriangleIncrement) const;
public:
/// Constructor
HeightFieldShape(int nbGridColumns, int nbGridRows, decimal minHeight, decimal maxHeight,
const void* heightFieldData, HeightDataType dataType,
int upAxis = 1, decimal integerHeightScale = 1.0f,
const Vector3& scaling = Vector3(1,1,1));
/// Destructor
virtual ~HeightFieldShape() override = default;
public:
/// Deleted copy-constructor
HeightFieldShape(const HeightFieldShape& shape) = delete;
/// Deleted assignment operator
HeightFieldShape& operator=(const HeightFieldShape& shape) = delete;
/// Return the scaling factor
const Vector3& getScaling() const;
/// Return the number of rows in the height field
int getNbRows() const;
@ -208,11 +151,10 @@ class HeightFieldShape : public ConcaveShape {
/// Return the local bounds of the shape in x, y and z directions.
virtual void getLocalBounds(Vector3& min, Vector3& max) const override;
/// Return the local inertia tensor of the collision shape
virtual void computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const override;
/// Use a callback method on all triangles of the concave shape inside a given AABB
virtual void testAllTriangles(TriangleCallback& callback, const AABB& localAABB) const override;
virtual void computeOverlappingTriangles(const AABB& localAABB, List<Vector3>& triangleVertices,
List<Vector3>& triangleVerticesNormals, List<uint>& shapeIds,
MemoryAllocator& allocator) const override;
/// Return the string representation of the shape
virtual std::string to_string() const override;
@ -221,13 +163,9 @@ class HeightFieldShape : public ConcaveShape {
friend class ConvexTriangleAABBOverlapCallback;
friend class ConcaveMeshRaycastCallback;
friend class PhysicsCommon;
};
// Return the scaling factor
inline const Vector3& HeightFieldShape::getScaling() const {
return mScaling;
}
// Return the number of rows in the height field
inline int HeightFieldShape::getNbRows() const {
return mNbRows;
@ -251,6 +189,9 @@ inline size_t HeightFieldShape::getSizeInBytes() const {
// Return the height of a given (x,y) point in the height field
inline decimal HeightFieldShape::getHeightAt(int x, int y) const {
assert(x >= 0 && x < mNbColumns);
assert(y >= 0 && y < mNbRows);
switch(mHeightDataType) {
case HeightDataType::HEIGHT_FLOAT_TYPE : return ((float*)mHeightFieldData)[y * mNbColumns + x];
case HeightDataType::HEIGHT_DOUBLE_TYPE : return ((double*)mHeightFieldData)[y * mNbColumns + x];
@ -264,23 +205,6 @@ inline int HeightFieldShape::computeIntegerGridValue(decimal value) const {
return (value < decimal(0.0)) ? value - decimal(0.5) : value + decimal(0.5);
}
// Return the local inertia tensor
/**
* @param[out] tensor The 3x3 inertia tensor matrix of the shape in local-space
* coordinates
* @param mass Mass to use to compute the inertia tensor of the collision shape
*/
inline void HeightFieldShape::computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const {
// Default inertia tensor
// Note that this is not very realistic for a concave triangle mesh.
// However, in most cases, it will only be used static bodies and therefore,
// the inertia tensor is not used.
tensor.setAllValues(mass, 0, 0,
0, mass, 0,
0, 0, mass);
}
// Compute the shape Id for a given triangle
inline uint HeightFieldShape::computeTriangleShapeId(uint iIndex, uint jIndex, uint secondTriangleIncrement) const {

66
src/collision/shapes/SphereShape.h → include/reactphysics3d/collision/shapes/SphereShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_SPHERE_SHAPE_H
// Libraries
#include "ConvexShape.h"
#include "mathematics/mathematics.h"
#include <reactphysics3d/collision/shapes/ConvexShape.h>
#include <reactphysics3d/mathematics/mathematics.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
@ -50,28 +50,28 @@ class SphereShape : public ConvexShape {
// -------------------- Methods -------------------- //
/// Constructor
SphereShape(decimal radius, MemoryAllocator& allocator);
/// Return a local support point in a given direction without the object margin
virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction) const override;
/// Return true if a point is inside the collision shape
virtual bool testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const override;
virtual bool testPointInside(const Vector3& localPoint, Collider* collider) const override;
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape, MemoryAllocator& allocator) const override;
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, Collider* collider, MemoryAllocator& allocator) const override;
/// Return the number of bytes used by the collision shape
virtual size_t getSizeInBytes() const override;
/// Destructor
virtual ~SphereShape() override = default;
public :
// -------------------- Methods -------------------- //
/// Constructor
SphereShape(decimal radius);
/// Destructor
virtual ~SphereShape() override = default;
/// Deleted copy-constructor
SphereShape(const SphereShape& shape) = delete;
@ -81,6 +81,9 @@ class SphereShape : public ConvexShape {
/// Return the radius of the sphere
decimal getRadius() const;
/// Set the radius of the sphere
void setRadius(decimal radius);
/// Return true if the collision shape is a polyhedron
virtual bool isPolyhedron() const override;
@ -88,29 +91,49 @@ class SphereShape : public ConvexShape {
virtual void getLocalBounds(Vector3& min, Vector3& max) const override;
/// Return the local inertia tensor of the collision shape
virtual void computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const override;
virtual Vector3 getLocalInertiaTensor(decimal mass) const override;
/// Compute and return the volume of the collision shape
virtual decimal getVolume() const override;
/// Update the AABB of a body using its collision shape
virtual void computeAABB(AABB& aabb, const Transform& transform) const override;
/// Return the string representation of the shape
virtual std::string to_string() const override;
// ----- Friendship ----- //
friend class PhysicsCommon;
};
// Get the radius of the sphere
/**
* @return Radius of the sphere (in meters)
* @return Radius of the sphere
*/
inline decimal SphereShape::getRadius() const {
return mMargin;
}
// Set the radius of the sphere
/// Note that you might want to recompute the inertia tensor and center of mass of the body
/// after changing the radius of the collision shape
/**
* @param radius Radius of the sphere
*/
inline void SphereShape::setRadius(decimal radius) {
assert(radius > decimal(0.0));
mMargin = radius;
notifyColliderAboutChangedSize();
}
// Return true if the collision shape is a polyhedron
/**
* @return False because the sphere shape is not a polyhedron
*/
inline bool SphereShape::isPolyhedron() const {
return false;
return false;
}
// Return the number of bytes used by the collision shape
@ -149,19 +172,20 @@ inline void SphereShape::getLocalBounds(Vector3& min, Vector3& max) const {
// Return the local inertia tensor of the sphere
/**
* @param[out] tensor The 3x3 inertia tensor matrix of the shape in local-space
* coordinates
* @param mass Mass to use to compute the inertia tensor of the collision shape
*/
inline void SphereShape::computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const {
inline Vector3 SphereShape::getLocalInertiaTensor(decimal mass) const {
decimal diag = decimal(0.4) * mass * mMargin * mMargin;
tensor.setAllValues(diag, 0.0, 0.0,
0.0, diag, 0.0,
0.0, 0.0, diag);
return Vector3(diag, diag, diag);
}
// Compute and return the volume of the collision shape
inline decimal SphereShape::getVolume() const {
return decimal(4.0) / decimal(3.0) * reactphysics3d::PI * mMargin * mMargin * mMargin;
}
// Return true if a point is inside the collision shape
inline bool SphereShape::testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const {
inline bool SphereShape::testPointInside(const Vector3& localPoint, Collider* collider) const {
return (localPoint.lengthSquare() < mMargin * mMargin);
}

38
src/collision/shapes/TriangleShape.h → include/reactphysics3d/collision/shapes/TriangleShape.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_TRIANGLE_SHAPE_H
// Libraries
#include "mathematics/mathematics.h"
#include "ConvexPolyhedronShape.h"
#include <reactphysics3d/mathematics/mathematics.h>
#include <reactphysics3d/collision/shapes/ConvexPolyhedronShape.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -87,11 +87,11 @@ class TriangleShape : public ConvexPolyhedronShape {
/// Get a smooth contact normal for collision for a triangle of the mesh
Vector3 computeSmoothLocalContactNormalForTriangle(const Vector3& localContactPoint) const;
/// Return true if a point is inside the collision shape
virtual bool testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const override;
/// Return true if a point is inside the collider
virtual bool testPointInside(const Vector3& localPoint, Collider* collider) const override;
/// Raycast method with feedback information
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, ProxyShape* proxyShape,
virtual bool raycast(const Ray& ray, RaycastInfo& raycastInfo, Collider* collider,
MemoryAllocator& allocator) const override;
/// Return the number of bytes used by the collision shape
@ -107,10 +107,6 @@ class TriangleShape : public ConvexPolyhedronShape {
const Transform& worldToOtherShapeTransform, decimal penetrationDepth, bool isTriangleShape1,
Vector3& outNewLocalContactPointOtherShape, Vector3& outSmoothWorldContactTriangleNormal) const;
public:
// -------------------- Methods -------------------- //
/// Constructor
TriangleShape(const Vector3* vertices, const Vector3* verticesNormals,
uint shapeId, MemoryAllocator& allocator);
@ -118,6 +114,10 @@ class TriangleShape : public ConvexPolyhedronShape {
/// Destructor
virtual ~TriangleShape() override = default;
public:
// -------------------- Methods -------------------- //
/// Deleted copy-constructor
TriangleShape(const TriangleShape& shape) = delete;
@ -128,7 +128,7 @@ class TriangleShape : public ConvexPolyhedronShape {
virtual void getLocalBounds(Vector3& min, Vector3& max) const override;
/// Return the local inertia tensor of the collision shape
virtual void computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const override;
virtual Vector3 getLocalInertiaTensor(decimal mass) const override;
/// Update the AABB of a body using its collision shape
virtual void computeAABB(AABB& aabb, const Transform& transform) const override;
@ -166,6 +166,9 @@ class TriangleShape : public ConvexPolyhedronShape {
/// Return the centroid of the polyhedron
virtual Vector3 getCentroid() const override;
/// Compute and return the volume of the collision shape
virtual decimal getVolume() const override;
/// This method compute the smooth mesh contact with a triangle in case one of the two collision shapes is a triangle. The idea in this case is to use a smooth vertex normal of the triangle mesh
static void computeSmoothTriangleMeshContact(const CollisionShape* shape1, const CollisionShape* shape2,
Vector3& localContactPointShape1, Vector3& localContactPointShape2,
@ -180,6 +183,8 @@ class TriangleShape : public ConvexPolyhedronShape {
friend class ConcaveMeshRaycastCallback;
friend class TriangleOverlapCallback;
friend class MiddlePhaseTriangleCallback;
friend class HeightFieldShape;
friend class CollisionDetectionSystem;
};
// Return the number of bytes used by the collision shape
@ -217,12 +222,12 @@ inline void TriangleShape::getLocalBounds(Vector3& min, Vector3& max) const {
* coordinates
* @param mass Mass to use to compute the inertia tensor of the collision shape
*/
inline void TriangleShape::computeLocalInertiaTensor(Matrix3x3& tensor, decimal mass) const {
tensor.setToZero();
inline Vector3 TriangleShape::getLocalInertiaTensor(decimal mass) const {
return Vector3(0, 0, 0);
}
// Return true if a point is inside the collision shape
inline bool TriangleShape::testPointInside(const Vector3& localPoint, ProxyShape* proxyShape) const {
inline bool TriangleShape::testPointInside(const Vector3& localPoint, Collider* collider) const {
return false;
}
@ -302,6 +307,11 @@ inline std::string TriangleShape::to_string() const {
"v3=" + mPoints[2].to_string() + "}";
}
// Compute and return the volume of the collision shape
inline decimal TriangleShape::getVolume() const {
return decimal(0.0);
}
}
#endif

332
include/reactphysics3d/components/BallAndSocketJointComponents.h Normal file
View File

@ -0,0 +1,332 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_BALL_AND_SOCKET_JOINT_COMPONENTS_H
#define REACTPHYSICS3D_BALL_AND_SOCKET_JOINT_COMPONENTS_H
// Libraries
#include <reactphysics3d/mathematics/Transform.h>
#include <reactphysics3d/mathematics/Matrix3x3.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/components/Components.h>
#include <reactphysics3d/containers/Map.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class MemoryAllocator;
class EntityManager;
class BallAndSocketJoint;
enum class JointType;
// Class BallAndSocketJointComponents
/**
* This class represent the component of the ECS with data for the BallAndSocketJoint.
*/
class BallAndSocketJointComponents : public Components {
private:
// -------------------- Attributes -------------------- //
/// Array of joint entities
Entity* mJointEntities;
/// Array of pointers to the joints
BallAndSocketJoint** mJoints;
/// Anchor point of body 1 (in local-space coordinates of body 1)
Vector3* mLocalAnchorPointBody1;
/// Anchor point of body 2 (in local-space coordinates of body 2)
Vector3* mLocalAnchorPointBody2;
/// Vector from center of body 2 to anchor point in world-space
Vector3* mR1World;
/// Vector from center of body 2 to anchor point in world-space
Vector3* mR2World;
/// Inertia tensor of body 1 (in world-space coordinates)
Matrix3x3* mI1;
/// Inertia tensor of body 2 (in world-space coordinates)
Matrix3x3* mI2;
/// Bias vector for the constraint
Vector3* mBiasVector;
/// Inverse mass matrix K=JM^-1J^-t of the constraint
Matrix3x3* mInverseMassMatrix;
/// Accumulated impulse
Vector3* mImpulse;
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
virtual void allocate(uint32 nbComponentsToAllocate) override;
/// Destroy a component at a given index
virtual void destroyComponent(uint32 index) override;
/// Move a component from a source to a destination index in the components array
virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex) override;
/// Swap two components in the array
virtual void swapComponents(uint32 index1, uint32 index2) override;
public:
/// Structure for the data of a transform component
struct BallAndSocketJointComponent {
/// Constructor
BallAndSocketJointComponent() {
}
};
// -------------------- Methods -------------------- //
/// Constructor
BallAndSocketJointComponents(MemoryAllocator& allocator);
/// Destructor
virtual ~BallAndSocketJointComponents() override = default;
/// Add a component
void addComponent(Entity jointEntity, bool isSleeping, const BallAndSocketJointComponent& component);
/// Return a pointer to a given joint
BallAndSocketJoint* getJoint(Entity jointEntity) const;
/// Set the joint pointer to a given joint
void setJoint(Entity jointEntity, BallAndSocketJoint* joint) const;
/// Return the local anchor point of body 1 for a given joint
const Vector3& getLocalAnchorPointBody1(Entity jointEntity) const;
/// Set the local anchor point of body 1 for a given joint
void setLocalAnchorPointBody1(Entity jointEntity, const Vector3& localAnchoirPointBody1);
/// Return the local anchor point of body 2 for a given joint
const Vector3& getLocalAnchorPointBody2(Entity jointEntity) const;
/// Set the local anchor point of body 2 for a given joint
void setLocalAnchorPointBody2(Entity jointEntity, const Vector3& localAnchoirPointBody2);
/// Return the vector from center of body 1 to anchor point in world-space
const Vector3& getR1World(Entity jointEntity) const;
/// Set the vector from center of body 1 to anchor point in world-space
void setR1World(Entity jointEntity, const Vector3& r1World);
/// Return the vector from center of body 2 to anchor point in world-space
const Vector3& getR2World(Entity jointEntity) const;
/// Set the vector from center of body 2 to anchor point in world-space
void setR2World(Entity jointEntity, const Vector3& r2World);
/// Return the inertia tensor of body 1 (in world-space coordinates)
const Matrix3x3& getI1(Entity jointEntity) const;
/// Set the inertia tensor of body 1 (in world-space coordinates)
void setI1(Entity jointEntity, const Matrix3x3& i1);
/// Return the inertia tensor of body 2 (in world-space coordinates)
const Matrix3x3& getI2(Entity jointEntity) const;
/// Set the inertia tensor of body 2 (in world-space coordinates)
void setI2(Entity jointEntity, const Matrix3x3& i2);
/// Return the bias vector for the constraint
Vector3& getBiasVector(Entity jointEntity);
/// Set the bias vector for the constraint
void setBiasVector(Entity jointEntity, const Vector3& biasVector);
/// Return the inverse mass matrix K=JM^-1J^-t of the constraint
Matrix3x3& getInverseMassMatrix(Entity jointEntity);
/// Set the inverse mass matrix K=JM^-1J^-t of the constraint
void setInverseMassMatrix(Entity jointEntity, const Matrix3x3& inverseMassMatrix);
/// Return the accumulated impulse
Vector3& getImpulse(Entity jointEntity);
/// Set the accumulated impulse
void setImpulse(Entity jointEntity, const Vector3& impulse);
// -------------------- Friendship -------------------- //
friend class BroadPhaseSystem;
friend class SolveBallAndSocketJointSystem;
};
// Return a pointer to a given joint
inline BallAndSocketJoint* BallAndSocketJointComponents::getJoint(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mJoints[mMapEntityToComponentIndex[jointEntity]];
}
// Set the joint pointer to a given joint
inline void BallAndSocketJointComponents::setJoint(Entity jointEntity, BallAndSocketJoint* joint) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mJoints[mMapEntityToComponentIndex[jointEntity]] = joint;
}
// Return the local anchor point of body 1 for a given joint
inline const Vector3& BallAndSocketJointComponents::getLocalAnchorPointBody1(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mLocalAnchorPointBody1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the local anchor point of body 1 for a given joint
inline void BallAndSocketJointComponents::setLocalAnchorPointBody1(Entity jointEntity, const Vector3& localAnchoirPointBody1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mLocalAnchorPointBody1[mMapEntityToComponentIndex[jointEntity]] = localAnchoirPointBody1;
}
// Return the local anchor point of body 2 for a given joint
inline const Vector3& BallAndSocketJointComponents::getLocalAnchorPointBody2(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mLocalAnchorPointBody2[mMapEntityToComponentIndex[jointEntity]];
}
// Set the local anchor point of body 2 for a given joint
inline void BallAndSocketJointComponents::setLocalAnchorPointBody2(Entity jointEntity, const Vector3& localAnchoirPointBody2) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mLocalAnchorPointBody2[mMapEntityToComponentIndex[jointEntity]] = localAnchoirPointBody2;
}
// Return the vector from center of body 1 to anchor point in world-space
inline const Vector3& BallAndSocketJointComponents::getR1World(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mR1World[mMapEntityToComponentIndex[jointEntity]];
}
// Set the vector from center of body 1 to anchor point in world-space
inline void BallAndSocketJointComponents::setR1World(Entity jointEntity, const Vector3& r1World) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mR1World[mMapEntityToComponentIndex[jointEntity]] = r1World;
}
// Return the vector from center of body 2 to anchor point in world-space
inline const Vector3& BallAndSocketJointComponents::getR2World(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mR2World[mMapEntityToComponentIndex[jointEntity]];
}
// Set the vector from center of body 2 to anchor point in world-space
inline void BallAndSocketJointComponents::setR2World(Entity jointEntity, const Vector3& r2World) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mR2World[mMapEntityToComponentIndex[jointEntity]] = r2World;
}
// Return the inertia tensor of body 1 (in world-space coordinates)
inline const Matrix3x3& BallAndSocketJointComponents::getI1(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mI1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the inertia tensor of body 1 (in world-space coordinates)
inline void BallAndSocketJointComponents::setI1(Entity jointEntity, const Matrix3x3& i1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mI1[mMapEntityToComponentIndex[jointEntity]] = i1;
}
// Return the inertia tensor of body 2 (in world-space coordinates)
inline const Matrix3x3& BallAndSocketJointComponents::getI2(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mI2[mMapEntityToComponentIndex[jointEntity]];
}
// Set the inertia tensor of body 2 (in world-space coordinates)
inline void BallAndSocketJointComponents::setI2(Entity jointEntity, const Matrix3x3& i2) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mI2[mMapEntityToComponentIndex[jointEntity]] = i2;
}
// Return the bias vector for the constraint
inline Vector3 &BallAndSocketJointComponents::getBiasVector(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mBiasVector[mMapEntityToComponentIndex[jointEntity]];
}
// Set the bias vector for the constraint
inline void BallAndSocketJointComponents::setBiasVector(Entity jointEntity, const Vector3& biasVector) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mBiasVector[mMapEntityToComponentIndex[jointEntity]] = biasVector;
}
// Return the inverse mass matrix K=JM^-1J^-t of the constraint
inline Matrix3x3& BallAndSocketJointComponents::getInverseMassMatrix(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mInverseMassMatrix[mMapEntityToComponentIndex[jointEntity]];
}
// Set the inverse mass matrix K=JM^-1J^-t of the constraint
inline void BallAndSocketJointComponents::setInverseMassMatrix(Entity jointEntity, const Matrix3x3& inverseMassMatrix) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mInverseMassMatrix[mMapEntityToComponentIndex[jointEntity]] = inverseMassMatrix;
}
// Return the accumulated impulse
inline Vector3 &BallAndSocketJointComponents::getImpulse(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mImpulse[mMapEntityToComponentIndex[jointEntity]];
}
// Set the accumulated impulse
inline void BallAndSocketJointComponents::setImpulse(Entity jointEntity, const Vector3& impulse) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mImpulse[mMapEntityToComponentIndex[jointEntity]] = impulse;
}
}
#endif

362
include/reactphysics3d/components/ColliderComponents.h Normal file
View File

@ -0,0 +1,362 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_COLLIDERS_COMPONENTS_H
#define REACTPHYSICS3D_COLLIDERS_COMPONENTS_H
// Libraries
#include <reactphysics3d/mathematics/Transform.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/containers/Map.h>
#include <reactphysics3d/collision/shapes/AABB.h>
#include <reactphysics3d/components/Components.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class MemoryAllocator;
class EntityManager;
class AABB;
class CollisionShape;
class Collider;
// Class ColliderComponents
/**
* This class represent the component of the ECS that contains data about the the colliders of the
* different bodies. We also make sure that colliders of sleeping entities (bodies) are
* always stored at the end of the array.
*/
class ColliderComponents : public Components {
private:
// -------------------- Attributes -------------------- //
/// Array of body entity of each component
Entity* mBodiesEntities;
/// Array of collider entity of each component
Entity* mCollidersEntities;
/// Array of pointer to the colliders
Collider** mColliders;
/// Ids of the colliders for the broad-phase algorithm
int32* mBroadPhaseIds;
/// Transform from local-space of the collider to the body-space of its body
Transform* mLocalToBodyTransforms;
/// Pointers to the collision shapes of the colliders
CollisionShape** mCollisionShapes;
/// Array of bits used to define the collision category of this shape.
/// You can set a single bit to one to define a category value for this
/// shape. This value is one (0x0001) by default. This variable can be used
/// together with the mCollideWithMaskBits variable so that given
/// categories of shapes collide with each other and do not collide with
/// other categories.
unsigned short* mCollisionCategoryBits;
/// Array of bits mask used to state which collision categories this shape can
/// collide with. This value is 0xFFFF by default. It means that this
/// collider will collide with every collision categories by default.
unsigned short* mCollideWithMaskBits;
/// Array with the local-to-world transforms of the colliders
Transform* mLocalToWorldTransforms;
/// Array with the list of involved overlapping pairs for each collider
List<uint64>* mOverlappingPairs;
/// True if the size of the collision shape associated with the collider
/// has been changed by the user
bool* mHasCollisionShapeChangedSize;
/// True if the collider is a trigger
bool* mIsTrigger;
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
virtual void allocate(uint32 nbComponentsToAllocate) override;
/// Destroy a component at a given index
virtual void destroyComponent(uint32 index) override;
/// Move a component from a source to a destination index in the components array
virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex) override;
/// Swap two components in the array
virtual void swapComponents(uint32 index1, uint32 index2) override;
public:
/// Structure for the data of a collider component
struct ColliderComponent {
Entity bodyEntity;
Collider* collider;
AABB localBounds;
const Transform& localToBodyTransform;
CollisionShape* collisionShape;
unsigned short collisionCategoryBits;
unsigned short collideWithMaskBits;
const Transform& localToWorldTransform;
/// Constructor
ColliderComponent(Entity bodyEntity, Collider* collider, AABB localBounds, const Transform& localToBodyTransform,
CollisionShape* collisionShape, unsigned short collisionCategoryBits,
unsigned short collideWithMaskBits, const Transform& localToWorldTransform)
:bodyEntity(bodyEntity), collider(collider), localBounds(localBounds), localToBodyTransform(localToBodyTransform),
collisionShape(collisionShape), collisionCategoryBits(collisionCategoryBits), collideWithMaskBits(collideWithMaskBits),
localToWorldTransform(localToWorldTransform) {
}
};
// -------------------- Methods -------------------- //
/// Constructor
ColliderComponents(MemoryAllocator& allocator);
/// Destructor
virtual ~ColliderComponents() override = default;
/// Add a component
void addComponent(Entity colliderEntity, bool isSleeping, const ColliderComponent& component);
/// Return the body entity of a given collider
Entity getBody(Entity colliderEntity) const;
/// Return a pointer to a given collider
Collider* getCollider(Entity colliderEntity) const;
/// Return the local-to-body transform of a collider
const Transform& getLocalToBodyTransform(Entity colliderEntity) const;
/// Set the local-to-body transform of a collider
void setLocalToBodyTransform(Entity colliderEntity, const Transform& transform);
/// Return a pointer to the collision shape of a collider
CollisionShape* getCollisionShape(Entity colliderEntity) const;
/// Return the broad-phase id of a given collider
int32 getBroadPhaseId(Entity colliderEntity) const;
/// Set the broad-phase id of a given collider
void setBroadPhaseId(Entity colliderEntity, int32 broadPhaseId);
/// Return the collision category bits of a given collider
unsigned short getCollisionCategoryBits(Entity colliderEntity) const;
/// Set the collision category bits of a given collider
void setCollisionCategoryBits(Entity colliderEntity, unsigned short collisionCategoryBits);
/// Return the "collide with" mask bits of a given collider
unsigned short getCollideWithMaskBits(Entity colliderEntity) const;
/// Set the "collide with" mask bits of a given collider
void setCollideWithMaskBits(Entity colliderEntity, unsigned short collideWithMaskBits);
/// Return the local-to-world transform of a collider
const Transform& getLocalToWorldTransform(Entity colliderEntity) const;
/// Set the local-to-world transform of a collider
void setLocalToWorldTransform(Entity colliderEntity, const Transform& transform);
/// Return a reference to the list of overlapping pairs for a given collider
List<uint64>& getOverlappingPairs(Entity colliderEntity);
/// Return true if the size of collision shape of the collider has been changed by the user
bool getHasCollisionShapeChangedSize(Entity colliderEntity) const;
/// Set whether the size of collision shape of the collider has been changed by the user
void setHasCollisionShapeChangedSize(Entity colliderEntity, bool hasCollisionShapeChangedSize);
/// Return true if a collider is a trigger
bool getIsTrigger(Entity colliderEntity) const;
/// Set whether a collider is a trigger
void setIsTrigger(Entity colliderEntity, bool isTrigger);
// -------------------- Friendship -------------------- //
friend class BroadPhaseSystem;
friend class CollisionDetectionSystem;
friend class DynamicsSystem;
friend class OverlappingPairs;
};
// Return the body entity of a given collider
inline Entity ColliderComponents::getBody(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mBodiesEntities[mMapEntityToComponentIndex[colliderEntity]];
}
// Return a pointer to a given collider
inline Collider *ColliderComponents::getCollider(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mColliders[mMapEntityToComponentIndex[colliderEntity]];
}
// Return the local-to-body transform of a collider
inline const Transform& ColliderComponents::getLocalToBodyTransform(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mLocalToBodyTransforms[mMapEntityToComponentIndex[colliderEntity]];
}
// Set the local-to-body transform of a collider
inline void ColliderComponents::setLocalToBodyTransform(Entity colliderEntity, const Transform& transform) {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
mLocalToBodyTransforms[mMapEntityToComponentIndex[colliderEntity]] = transform;
}
// Return a pointer to the collision shape of a collider
inline CollisionShape* ColliderComponents::getCollisionShape(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mCollisionShapes[mMapEntityToComponentIndex[colliderEntity]];
}
// Return the broad-phase id of a given collider
inline int32 ColliderComponents::getBroadPhaseId(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mBroadPhaseIds[mMapEntityToComponentIndex[colliderEntity]];
}
// Set the broad-phase id of a given collider
inline void ColliderComponents::setBroadPhaseId(Entity colliderEntity, int32 broadPhaseId) {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
mBroadPhaseIds[mMapEntityToComponentIndex[colliderEntity]] = broadPhaseId;
}
// Return the collision category bits of a given collider
inline unsigned short ColliderComponents::getCollisionCategoryBits(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mCollisionCategoryBits[mMapEntityToComponentIndex[colliderEntity]];
}
// Return the "collide with" mask bits of a given collider
inline unsigned short ColliderComponents::getCollideWithMaskBits(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mCollideWithMaskBits[mMapEntityToComponentIndex[colliderEntity]];
}
// Set the collision category bits of a given collider
inline void ColliderComponents::setCollisionCategoryBits(Entity colliderEntity, unsigned short collisionCategoryBits) {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
mCollisionCategoryBits[mMapEntityToComponentIndex[colliderEntity]] = collisionCategoryBits;
}
// Set the "collide with" mask bits of a given collider
inline void ColliderComponents::setCollideWithMaskBits(Entity colliderEntity, unsigned short collideWithMaskBits) {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
mCollideWithMaskBits[mMapEntityToComponentIndex[colliderEntity]] = collideWithMaskBits;
}
// Return the local-to-world transform of a collider
inline const Transform& ColliderComponents::getLocalToWorldTransform(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mLocalToWorldTransforms[mMapEntityToComponentIndex[colliderEntity]];
}
// Set the local-to-world transform of a collider
inline void ColliderComponents::setLocalToWorldTransform(Entity colliderEntity, const Transform& transform) {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
mLocalToWorldTransforms[mMapEntityToComponentIndex[colliderEntity]] = transform;
}
// Return a reference to the list of overlapping pairs for a given collider
inline List<uint64>& ColliderComponents::getOverlappingPairs(Entity colliderEntity) {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mOverlappingPairs[mMapEntityToComponentIndex[colliderEntity]];
}
// Return true if the size of collision shape of the collider has been changed by the user
inline bool ColliderComponents::getHasCollisionShapeChangedSize(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mHasCollisionShapeChangedSize[mMapEntityToComponentIndex[colliderEntity]];
}
// Return true if the size of collision shape of the collider has been changed by the user
inline void ColliderComponents::setHasCollisionShapeChangedSize(Entity colliderEntity, bool hasCollisionShapeChangedSize) {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
mHasCollisionShapeChangedSize[mMapEntityToComponentIndex[colliderEntity]] = hasCollisionShapeChangedSize;
}
// Return true if a collider is a trigger
inline bool ColliderComponents::getIsTrigger(Entity colliderEntity) const {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
return mIsTrigger[mMapEntityToComponentIndex[colliderEntity]];
}
// Set whether a collider is a trigger
inline void ColliderComponents::setIsTrigger(Entity colliderEntity, bool isTrigger) {
assert(mMapEntityToComponentIndex.containsKey(colliderEntity));
mIsTrigger[mMapEntityToComponentIndex[colliderEntity]] = isTrigger;
}
}
#endif

198
include/reactphysics3d/components/CollisionBodyComponents.h Normal file
View File

@ -0,0 +1,198 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_COLLISION_BODY_COMPONENTS_H
#define REACTPHYSICS3D_COLLISION_BODY_COMPONENTS_H
// Libraries
#include <reactphysics3d/mathematics/Transform.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/components/Components.h>
#include <reactphysics3d/containers/Map.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class MemoryAllocator;
class EntityManager;
class CollisionBody;
// Class CollisionBodyComponents
/**
* This class represent the component of the ECS that contains data about a collision body.
* The components of the sleeping entities (bodies) are always stored at the end of the array.
*/
class CollisionBodyComponents : public Components {
private:
// -------------------- Attributes -------------------- //
/// Array of body entities of each component
Entity* mBodiesEntities;
/// Array of pointers to the corresponding bodies
CollisionBody** mBodies;
/// Array with the list of colliders of each body
List<Entity>* mColliders;
/// Array of boolean values to know if the body is active.
bool* mIsActive;
/// Array of pointers that can be used to attach user data to the body
void** mUserData;
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
virtual void allocate(uint32 nbComponentsToAllocate) override;
/// Destroy a component at a given index
virtual void destroyComponent(uint32 index) override;
/// Move a component from a source to a destination index in the components array
virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex) override;
/// Swap two components in the array
virtual void swapComponents(uint32 index1, uint32 index2) override;
public:
/// Structure for the data of a collision body component
struct CollisionBodyComponent {
CollisionBody* body;
/// Constructor
CollisionBodyComponent(CollisionBody* body) : body(body) {
}
};
// -------------------- Methods -------------------- //
/// Constructor
CollisionBodyComponents(MemoryAllocator& allocator);
/// Destructor
virtual ~CollisionBodyComponents() override = default;
/// Add a component
void addComponent(Entity bodyEntity, bool isSleeping, const CollisionBodyComponent& component);
/// Add a collider to a body component
void addColliderToBody(Entity bodyEntity, Entity colliderEntity);
/// Remove a collider from a body component
void removeColliderFromBody(Entity bodyEntity, Entity colliderEntity);
/// Return a pointer to a body
CollisionBody* getBody(Entity bodyEntity);
/// Return the list of colliders of a body
const List<Entity>& getColliders(Entity bodyEntity) const;
/// Return true if the body is active
bool getIsActive(Entity bodyEntity) const;
/// Set the value to know if the body is active
void setIsActive(Entity bodyEntity, bool isActive) const;
/// Return the user data associated with the body
void* getUserData(Entity bodyEntity) const;
/// Set the user data associated with the body
void setUserData(Entity bodyEntity, void* userData) const;
};
// Add a collider to a body component
inline void CollisionBodyComponents::addColliderToBody(Entity bodyEntity, Entity colliderEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mColliders[mMapEntityToComponentIndex[bodyEntity]].add(colliderEntity);
}
// Remove a collider from a body component
inline void CollisionBodyComponents::removeColliderFromBody(Entity bodyEntity, Entity colliderEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mColliders[mMapEntityToComponentIndex[bodyEntity]].remove(colliderEntity);
}
// Return a pointer to a body
inline CollisionBody *CollisionBodyComponents::getBody(Entity bodyEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mBodies[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the list of colliders of a body
inline const List<Entity>& CollisionBodyComponents::getColliders(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mColliders[mMapEntityToComponentIndex[bodyEntity]];
}
// Return true if the body is active
inline bool CollisionBodyComponents::getIsActive(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mIsActive[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the value to know if the body is active
inline void CollisionBodyComponents::setIsActive(Entity bodyEntity, bool isActive) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mIsActive[mMapEntityToComponentIndex[bodyEntity]] = isActive;
}
// Return the user data associated with the body
inline void* CollisionBodyComponents::getUserData(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mUserData[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the user data associated with the body
inline void CollisionBodyComponents::setUserData(Entity bodyEntity, void* userData) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mUserData[mMapEntityToComponentIndex[bodyEntity]] = userData;
}
}
#endif

154
include/reactphysics3d/components/Components.h Normal file
View File

@ -0,0 +1,154 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_COMPONENTS_H
#define REACTPHYSICS3D_COMPONENTS_H
// Libraries
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/containers/Map.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class MemoryAllocator;
class EntityManager;
// Class Components
/**
* This class represent the abstract class to store components of the ECS.
*/
class Components {
protected:
// -------------------- Constants -------------------- //
/// Number of components to allocated at the beginning
const uint32 INIT_NB_ALLOCATED_COMPONENTS = 10;
// -------------------- Attributes -------------------- //
/// Memory allocator
MemoryAllocator& mMemoryAllocator;
/// Current number of components
uint32 mNbComponents;
/// Size (in bytes) of a single component
size_t mComponentDataSize;
/// Number of allocated components
uint32 mNbAllocatedComponents;
/// Allocated memory for all the data of the components
void* mBuffer;
/// Map an entity to the index of its component in the array
Map<Entity, uint32> mMapEntityToComponentIndex;
/// Index of the first component of a disabled (sleeping or inactive) entity
/// Disabled components are stored at the end of the components array
uint32 mDisabledStartIndex;
/// Compute the index where we need to insert the new component
uint32 prepareAddComponent(bool isSleeping);
/// Allocate memory for a given number of components
virtual void allocate(uint32 nbComponentsToAllocate)=0;
/// Destroy a component at a given index
virtual void destroyComponent(uint32 index);
/// Move a component from a source to a destination index in the components array
virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex)=0;
/// Swap two components in the array
virtual void swapComponents(uint32 index1, uint32 index2)=0;
public:
// -------------------- Methods -------------------- //
/// Constructor
Components(MemoryAllocator& allocator, size_t componentDataSize);
/// Destructor
virtual ~Components();
/// Remove a component
void removeComponent(Entity entity);
/// Return true if an entity is disabled
bool getIsEntityDisabled(Entity entity) const;
/// Notify if a given entity is disabled
void setIsEntityDisabled(Entity entity, bool isDisabled);
/// Return true if there is a component for a given entity
bool hasComponent(Entity entity) const;
/// Return the number of components
uint32 getNbComponents() const;
/// Return the number of enabled components
uint32 getNbEnabledComponents() const;
/// Return the index in the arrays for a given entity
uint32 getEntityIndex(Entity entity) const;
};
// Return true if an entity is sleeping
inline bool Components::getIsEntityDisabled(Entity entity) const {
assert(hasComponent(entity));
return mMapEntityToComponentIndex[entity] >= mDisabledStartIndex;
}
// Return true if there is a component for a given entity
inline bool Components::hasComponent(Entity entity) const {
return mMapEntityToComponentIndex.containsKey(entity);
}
// Return the number of components
inline uint32 Components::getNbComponents() const {
return mNbComponents;
}
// Return the number of enabled components
inline uint32 Components::getNbEnabledComponents() const {
return mDisabledStartIndex;
}
// Return the index in the arrays for a given entity
inline uint32 Components::getEntityIndex(Entity entity) const {
assert(hasComponent(entity));
return mMapEntityToComponentIndex[entity];
}
}
#endif

425
include/reactphysics3d/components/FixedJointComponents.h Normal file
View File

@ -0,0 +1,425 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_FIXED_JOINT_COMPONENTS_H
#define REACTPHYSICS3D_FIXED_JOINT_COMPONENTS_H
// Libraries
#include <reactphysics3d/mathematics/Transform.h>
#include <reactphysics3d/mathematics/Matrix3x3.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/components/Components.h>
#include <reactphysics3d/containers/Map.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class MemoryAllocator;
class EntityManager;
class FixedJoint;
enum class JointType;
// Class FixedJointComponents
/**
* This class represent the component of the ECS with data for the FixedJoint.
*/
class FixedJointComponents : public Components {
private:
// -------------------- Attributes -------------------- //
/// Array of joint entities
Entity* mJointEntities;
/// Array of pointers to the joints
FixedJoint** mJoints;
/// Anchor point of body 1 (in local-space coordinates of body 1)
Vector3* mLocalAnchorPointBody1;
/// Anchor point of body 2 (in local-space coordinates of body 2)
Vector3* mLocalAnchorPointBody2;
/// Vector from center of body 2 to anchor point in world-space
Vector3* mR1World;
/// Vector from center of body 2 to anchor point in world-space
Vector3* mR2World;
/// Inertia tensor of body 1 (in world-space coordinates)
Matrix3x3* mI1;
/// Inertia tensor of body 2 (in world-space coordinates)
Matrix3x3* mI2;
/// Accumulated impulse for the 3 translation constraints
Vector3* mImpulseTranslation;
/// Accumulate impulse for the 3 rotation constraints
Vector3* mImpulseRotation;
/// Inverse mass matrix K=JM^-1J^-t of the 3 translation constraints (3x3 matrix)
Matrix3x3* mInverseMassMatrixTranslation;
/// Inverse mass matrix K=JM^-1J^-t of the 3 rotation constraints (3x3 matrix)
Matrix3x3* mInverseMassMatrixRotation;
/// Bias vector for the 3 translation constraints
Vector3* mBiasTranslation;
/// Bias vector for the 3 rotation constraints
Vector3* mBiasRotation;
/// Inverse of the initial orientation difference between the two bodies
Quaternion* mInitOrientationDifferenceInv;
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
virtual void allocate(uint32 nbComponentsToAllocate) override;
/// Destroy a component at a given index
virtual void destroyComponent(uint32 index) override;
/// Move a component from a source to a destination index in the components array
virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex) override;
/// Swap two components in the array
virtual void swapComponents(uint32 index1, uint32 index2) override;
public:
/// Structure for the data of a transform component
struct FixedJointComponent {
/// Constructor
FixedJointComponent() {
}
};
// -------------------- Methods -------------------- //
/// Constructor
FixedJointComponents(MemoryAllocator& allocator);
/// Destructor
virtual ~FixedJointComponents() override = default;
/// Add a component
void addComponent(Entity jointEntity, bool isSleeping, const FixedJointComponent& component);
/// Return a pointer to a given joint
FixedJoint* getJoint(Entity jointEntity) const;
/// Set the joint pointer to a given joint
void setJoint(Entity jointEntity, FixedJoint* joint) const;
/// Return the local anchor point of body 1 for a given joint
const Vector3& getLocalAnchorPointBody1(Entity jointEntity) const;
/// Set the local anchor point of body 1 for a given joint
void setLocalAnchorPointBody1(Entity jointEntity, const Vector3& localAnchorPointBody1);
/// Return the local anchor point of body 2 for a given joint
const Vector3& getLocalAnchorPointBody2(Entity jointEntity) const;
/// Set the local anchor point of body 2 for a given joint
void setLocalAnchorPointBody2(Entity jointEntity, const Vector3& localAnchoirPointBody2);
/// Return the vector from center of body 1 to anchor point in world-space
const Vector3& getR1World(Entity jointEntity) const;
/// Set the vector from center of body 1 to anchor point in world-space
void setR1World(Entity jointEntity, const Vector3& r1World);
/// Return the vector from center of body 2 to anchor point in world-space
const Vector3& getR2World(Entity jointEntity) const;
/// Set the vector from center of body 2 to anchor point in world-space
void setR2World(Entity jointEntity, const Vector3& r2World);
/// Return the inertia tensor of body 1 (in world-space coordinates)
const Matrix3x3& getI1(Entity jointEntity) const;
/// Set the inertia tensor of body 1 (in world-space coordinates)
void setI1(Entity jointEntity, const Matrix3x3& i1);
/// Return the inertia tensor of body 2 (in world-space coordinates)
const Matrix3x3& getI2(Entity jointEntity) const;
/// Set the inertia tensor of body 2 (in world-space coordinates)
void setI2(Entity jointEntity, const Matrix3x3& i2);
/// Return the translation impulse
Vector3& getImpulseTranslation(Entity jointEntity);
/// Set the translation impulse
void setImpulseTranslation(Entity jointEntity, const Vector3& impulseTranslation);
/// Return the translation impulse
Vector3& getImpulseRotation(Entity jointEntity);
/// Set the translation impulse
void setImpulseRotation(Entity jointEntity, const Vector3& impulseTranslation);
/// Return the translation inverse mass matrix of the constraint
Matrix3x3& getInverseMassMatrixTranslation(Entity jointEntity);
/// Set the translation inverse mass matrix of the constraint
void setInverseMassMatrixTranslation(Entity jointEntity, const Matrix3x3& inverseMassMatrix);
/// Return the rotation inverse mass matrix of the constraint
Matrix3x3& getInverseMassMatrixRotation(Entity jointEntity);
/// Set the rotation inverse mass matrix of the constraint
void setInverseMassMatrixRotation(Entity jointEntity, const Matrix3x3& inverseMassMatrix);
/// Return the translation bias
Vector3& getBiasTranslation(Entity jointEntity);
/// Set the translation impulse
void setBiasTranslation(Entity jointEntity, const Vector3& impulseTranslation);
/// Return the rotation bias
Vector3& getBiasRotation(Entity jointEntity);
/// Set the rotation impulse
void setBiasRotation(Entity jointEntity, const Vector3 &impulseRotation);
/// Return the initial orientation difference
Quaternion& getInitOrientationDifferenceInv(Entity jointEntity);
/// Set the rotation impulse
void setInitOrientationDifferenceInv(Entity jointEntity, const Quaternion& initOrientationDifferenceInv);
// -------------------- Friendship -------------------- //
friend class BroadPhaseSystem;
friend class SolveFixedJointSystem;
};
// Return a pointer to a given joint
inline FixedJoint* FixedJointComponents::getJoint(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mJoints[mMapEntityToComponentIndex[jointEntity]];
}
// Set the joint pointer to a given joint
inline void FixedJointComponents::setJoint(Entity jointEntity, FixedJoint* joint) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mJoints[mMapEntityToComponentIndex[jointEntity]] = joint;
}
// Return the local anchor point of body 1 for a given joint
inline const Vector3& FixedJointComponents::getLocalAnchorPointBody1(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mLocalAnchorPointBody1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the local anchor point of body 1 for a given joint
inline void FixedJointComponents::setLocalAnchorPointBody1(Entity jointEntity, const Vector3& localAnchorPointBody1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mLocalAnchorPointBody1[mMapEntityToComponentIndex[jointEntity]] = localAnchorPointBody1;
}
// Return the local anchor point of body 2 for a given joint
inline const Vector3& FixedJointComponents::getLocalAnchorPointBody2(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mLocalAnchorPointBody2[mMapEntityToComponentIndex[jointEntity]];
}
// Set the local anchor point of body 2 for a given joint
inline void FixedJointComponents::setLocalAnchorPointBody2(Entity jointEntity, const Vector3& localAnchorPointBody2) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mLocalAnchorPointBody2[mMapEntityToComponentIndex[jointEntity]] = localAnchorPointBody2;
}
// Return the vector from center of body 1 to anchor point in world-space
inline const Vector3& FixedJointComponents::getR1World(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mR1World[mMapEntityToComponentIndex[jointEntity]];
}
// Set the vector from center of body 1 to anchor point in world-space
inline void FixedJointComponents::setR1World(Entity jointEntity, const Vector3& r1World) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mR1World[mMapEntityToComponentIndex[jointEntity]] = r1World;
}
// Return the vector from center of body 2 to anchor point in world-space
inline const Vector3& FixedJointComponents::getR2World(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mR2World[mMapEntityToComponentIndex[jointEntity]];
}
// Set the vector from center of body 2 to anchor point in world-space
inline void FixedJointComponents::setR2World(Entity jointEntity, const Vector3& r2World) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mR2World[mMapEntityToComponentIndex[jointEntity]] = r2World;
}
// Return the inertia tensor of body 1 (in world-space coordinates)
inline const Matrix3x3& FixedJointComponents::getI1(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mI1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the inertia tensor of body 1 (in world-space coordinates)
inline void FixedJointComponents::setI1(Entity jointEntity, const Matrix3x3& i1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mI1[mMapEntityToComponentIndex[jointEntity]] = i1;
}
// Return the inertia tensor of body 2 (in world-space coordinates)
inline const Matrix3x3& FixedJointComponents::getI2(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mI2[mMapEntityToComponentIndex[jointEntity]];
}
// Set the inertia tensor of body 2 (in world-space coordinates)
inline void FixedJointComponents::setI2(Entity jointEntity, const Matrix3x3& i2) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mI2[mMapEntityToComponentIndex[jointEntity]] = i2;
}
// Return the translation impulse
inline Vector3& FixedJointComponents::getImpulseTranslation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mImpulseTranslation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the translation impulse
inline void FixedJointComponents::setImpulseTranslation(Entity jointEntity, const Vector3& impulseTranslation) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mImpulseTranslation[mMapEntityToComponentIndex[jointEntity]] = impulseTranslation;
}
// Return the translation impulse
inline Vector3& FixedJointComponents::getImpulseRotation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mImpulseRotation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the translation impulse
inline void FixedJointComponents::setImpulseRotation(Entity jointEntity, const Vector3& impulseTranslation) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mImpulseRotation[mMapEntityToComponentIndex[jointEntity]] = impulseTranslation;
}
// Return the translation inverse mass matrix of the constraint
inline Matrix3x3& FixedJointComponents::getInverseMassMatrixTranslation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mInverseMassMatrixTranslation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the translation inverse mass matrix of the constraint
inline void FixedJointComponents::setInverseMassMatrixTranslation(Entity jointEntity, const Matrix3x3& inverseMassMatrix) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mInverseMassMatrixTranslation[mMapEntityToComponentIndex[jointEntity]] = inverseMassMatrix;
}
// Return the rotation inverse mass matrix of the constraint
inline Matrix3x3& FixedJointComponents::getInverseMassMatrixRotation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mInverseMassMatrixRotation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the rotation inverse mass matrix of the constraint
inline void FixedJointComponents::setInverseMassMatrixRotation(Entity jointEntity, const Matrix3x3& inverseMassMatrix) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mInverseMassMatrixRotation[mMapEntityToComponentIndex[jointEntity]] = inverseMassMatrix;
}
// Return the translation bias
inline Vector3& FixedJointComponents::getBiasTranslation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mBiasTranslation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the translation impulse
inline void FixedJointComponents::setBiasTranslation(Entity jointEntity, const Vector3 &impulseTranslation) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mBiasTranslation[mMapEntityToComponentIndex[jointEntity]] = impulseTranslation;
}
// Return the rotation bias
inline Vector3& FixedJointComponents::getBiasRotation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mBiasRotation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the rotation impulse
inline void FixedJointComponents::setBiasRotation(Entity jointEntity, const Vector3& impulseRotation) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mBiasRotation[mMapEntityToComponentIndex[jointEntity]] = impulseRotation;
}
// Return the initial orientation difference
inline Quaternion& FixedJointComponents::getInitOrientationDifferenceInv(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mInitOrientationDifferenceInv[mMapEntityToComponentIndex[jointEntity]];
}
// Set the rotation impulse
inline void FixedJointComponents::setInitOrientationDifferenceInv(Entity jointEntity, const Quaternion& initOrientationDifferenceInv) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mInitOrientationDifferenceInv[mMapEntityToComponentIndex[jointEntity]] = initOrientationDifferenceInv;
}
}
#endif

899
include/reactphysics3d/components/HingeJointComponents.h Normal file
View File

@ -0,0 +1,899 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_HINGE_JOINT_COMPONENTS_H
#define REACTPHYSICS3D_HINGE_JOINT_COMPONENTS_H
// Libraries
#include <reactphysics3d/mathematics/Transform.h>
#include <reactphysics3d/mathematics/Matrix3x3.h>
#include <reactphysics3d/mathematics/Matrix2x2.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/components/Components.h>
#include <reactphysics3d/containers/Map.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class MemoryAllocator;
class EntityManager;
class HingeJoint;
enum class JointType;
// Class HingeJointComponents
/**
* This class represent the component of the ECS with data for the HingeJoint.
*/
class HingeJointComponents : public Components {
private:
// -------------------- Attributes -------------------- //
/// Array of joint entities
Entity* mJointEntities;
/// Array of pointers to the joints
HingeJoint** mJoints;
/// Anchor point of body 1 (in local-space coordinates of body 1)
Vector3* mLocalAnchorPointBody1;
/// Anchor point of body 2 (in local-space coordinates of body 2)
Vector3* mLocalAnchorPointBody2;
/// Vector from center of body 2 to anchor point in world-space
Vector3* mR1World;
/// Vector from center of body 2 to anchor point in world-space
Vector3* mR2World;
/// Inertia tensor of body 1 (in world-space coordinates)
Matrix3x3* mI1;
/// Inertia tensor of body 2 (in world-space coordinates)
Matrix3x3* mI2;
/// Accumulated impulse for the 3 translation constraints
Vector3* mImpulseTranslation;
/// Accumulate impulse for the 3 rotation constraints
Vector2* mImpulseRotation;
/// Inverse mass matrix K=JM^-1J^-t of the 3 translation constraints (3x3 matrix)
Matrix3x3* mInverseMassMatrixTranslation;
/// Inverse mass matrix K=JM^-1J^-t of the 3 rotation constraints (3x3 matrix)
Matrix2x2* mInverseMassMatrixRotation;
/// Bias vector for the 3 translation constraints
Vector3* mBiasTranslation;
/// Bias vector for the 3 rotation constraints
Vector2* mBiasRotation;
/// Inverse of the initial orientation difference between the two bodies
Quaternion* mInitOrientationDifferenceInv;
/// Hinge rotation axis (in local-space coordinates of body 1)
Vector3* mHingeLocalAxisBody1;
/// Hinge rotation axis (in local-space coordiantes of body 2)
Vector3* mHingeLocalAxisBody2;
/// Hinge rotation axis (in world-space coordinates) computed from body 1
Vector3* mA1;
/// Cross product of vector b2 and a1
Vector3* mB2CrossA1;
/// Cross product of vector c2 and a1;
Vector3* mC2CrossA1;
/// Accumulated impulse for the lower limit constraint
decimal* mImpulseLowerLimit;
/// Accumulated impulse for the upper limit constraint
decimal* mImpulseUpperLimit;
/// Accumulated impulse for the motor constraint;
decimal* mImpulseMotor;
/// Inverse of mass matrix K=JM^-1J^t for the limits and motor constraints (1x1 matrix)
decimal* mInverseMassMatrixLimitMotor;
/// Inverse of mass matrix K=JM^-1J^t for the motor
decimal* mInverseMassMatrixMotor;
/// Bias of the lower limit constraint
decimal* mBLowerLimit;
/// Bias of the upper limit constraint
decimal* mBUpperLimit;
/// True if the joint limits are enabled
bool* mIsLimitEnabled;
/// True if the motor of the joint in enabled
bool* mIsMotorEnabled;
/// Lower limit (minimum allowed rotation angle in radian)
decimal* mLowerLimit;
/// Upper limit (maximum translation distance)
decimal* mUpperLimit;
/// True if the lower limit is violated
bool* mIsLowerLimitViolated;
/// True if the upper limit is violated
bool* mIsUpperLimitViolated;
/// Motor speed (in rad/s)
decimal* mMotorSpeed;
/// Maximum motor torque (in Newtons) that can be applied to reach to desired motor speed
decimal* mMaxMotorTorque;
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
virtual void allocate(uint32 nbComponentsToAllocate) override;
/// Destroy a component at a given index
virtual void destroyComponent(uint32 index) override;
/// Move a component from a source to a destination index in the components array
virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex) override;
/// Swap two components in the array
virtual void swapComponents(uint32 index1, uint32 index2) override;
public:
/// Structure for the data of a transform component
struct HingeJointComponent {
bool isLimitEnabled;
bool isMotorEnabled;
decimal lowerLimit;
decimal upperLimit;
decimal motorSpeed;
decimal maxMotorTorque;
/// Constructor
HingeJointComponent(bool isLimitEnabled, bool isMotorEnabled, decimal lowerLimit, decimal upperLimit,
decimal motorSpeed, decimal maxMotorTorque)
: isLimitEnabled(isLimitEnabled), isMotorEnabled(isMotorEnabled), lowerLimit(lowerLimit), upperLimit(upperLimit),
motorSpeed(motorSpeed), maxMotorTorque(maxMotorTorque) {
}
};
// -------------------- Methods -------------------- //
/// Constructor
HingeJointComponents(MemoryAllocator& allocator);
/// Destructor
virtual ~HingeJointComponents() override = default;
/// Add a component
void addComponent(Entity jointEntity, bool isSleeping, const HingeJointComponent& component);
/// Return a pointer to a given joint
HingeJoint* getJoint(Entity jointEntity) const;
/// Set the joint pointer to a given joint
void setJoint(Entity jointEntity, HingeJoint* joint) const;
/// Return the local anchor point of body 1 for a given joint
const Vector3& getLocalAnchorPointBody1(Entity jointEntity) const;
/// Set the local anchor point of body 1 for a given joint
void setLocalAnchorPointBody1(Entity jointEntity, const Vector3& localAnchoirPointBody1);
/// Return the local anchor point of body 2 for a given joint
const Vector3& getLocalAnchorPointBody2(Entity jointEntity) const;
/// Set the local anchor point of body 2 for a given joint
void setLocalAnchorPointBody2(Entity jointEntity, const Vector3& localAnchoirPointBody2);
/// Return the vector from center of body 1 to anchor point in world-space
const Vector3& getR1World(Entity jointEntity) const;
/// Set the vector from center of body 1 to anchor point in world-space
void setR1World(Entity jointEntity, const Vector3& r1World);
/// Return the vector from center of body 2 to anchor point in world-space
const Vector3& getR2World(Entity jointEntity) const;
/// Set the vector from center of body 2 to anchor point in world-space
void setR2World(Entity jointEntity, const Vector3& r2World);
/// Return the inertia tensor of body 1 (in world-space coordinates)
const Matrix3x3& getI1(Entity jointEntity) const;
/// Set the inertia tensor of body 1 (in world-space coordinates)
void setI1(Entity jointEntity, const Matrix3x3& i1);
/// Return the inertia tensor of body 2 (in world-space coordinates)
const Matrix3x3& getI2(Entity jointEntity) const;
/// Set the inertia tensor of body 2 (in world-space coordinates)
void setI2(Entity jointEntity, const Matrix3x3& i2);
/// Return the translation impulse
Vector3& getImpulseTranslation(Entity jointEntity);
/// Set the translation impulse
void setImpulseTranslation(Entity jointEntity, const Vector3& impulseTranslation);
/// Return the translation impulse
Vector2& getImpulseRotation(Entity jointEntity);
/// Set the translation impulse
void setImpulseRotation(Entity jointEntity, const Vector2& impulseTranslation);
/// Return the translation inverse mass matrix of the constraint
Matrix3x3& getInverseMassMatrixTranslation(Entity jointEntity);
/// Set the translation inverse mass matrix of the constraint
void setInverseMassMatrixTranslation(Entity jointEntity, const Matrix3x3& inverseMassMatrix);
/// Return the rotation inverse mass matrix of the constraint
Matrix2x2& getInverseMassMatrixRotation(Entity jointEntity);
/// Set the rotation inverse mass matrix of the constraint
void setInverseMassMatrixRotation(Entity jointEntity, const Matrix2x2& inverseMassMatrix);
/// Return the translation bias
Vector3& getBiasTranslation(Entity jointEntity);
/// Set the translation impulse
void setBiasTranslation(Entity jointEntity, const Vector3& impulseTranslation);
/// Return the rotation bias
Vector2& getBiasRotation(Entity jointEntity);
/// Set the rotation impulse
void setBiasRotation(Entity jointEntity, const Vector2& impulseRotation);
/// Return the initial orientation difference
Quaternion& getInitOrientationDifferenceInv(Entity jointEntity);
/// Set the rotation impulse
void setInitOrientationDifferenceInv(Entity jointEntity, const Quaternion& initOrientationDifferenceInv);
/// Return the hinge rotation axis (in local-space coordinates of body 1)
Vector3& getHingeLocalAxisBody1(Entity jointEntity);
/// Set the hinge rotation axis (in local-space coordinates of body 1)
void setHingeLocalAxisBody1(Entity jointEntity, const Vector3& hingeLocalAxisBody1);
/// Return the hinge rotation axis (in local-space coordiantes of body 2)
Vector3& getHingeLocalAxisBody2(Entity jointEntity);
/// Set the hinge rotation axis (in local-space coordiantes of body 2)
void setHingeLocalAxisBody2(Entity jointEntity, const Vector3& hingeLocalAxisBody2);
/// Return the hinge rotation axis (in world-space coordinates) computed from body 1
Vector3& getA1(Entity jointEntity);
/// Set the hinge rotation axis (in world-space coordinates) computed from body 1
void setA1(Entity jointEntity, const Vector3& a1);
/// Return the cross product of vector b2 and a1
Vector3& getB2CrossA1(Entity jointEntity);
/// Set the cross product of vector b2 and a1
void setB2CrossA1(Entity jointEntity, const Vector3& b2CrossA1);
/// Return the cross product of vector c2 and a1;
Vector3& getC2CrossA1(Entity jointEntity);
/// Set the cross product of vector c2 and a1;
void setC2CrossA1(Entity jointEntity, const Vector3& c2CrossA1);
/// Return the accumulated impulse for the lower limit constraint
decimal getImpulseLowerLimit(Entity jointEntity) const;
/// Set the accumulated impulse for the lower limit constraint
void setImpulseLowerLimit(Entity jointEntity, decimal impulseLowerLimit);
/// Return the accumulated impulse for the upper limit constraint
decimal getImpulseUpperLimit(Entity jointEntity) const;
/// Set the accumulated impulse for the upper limit constraint
void setImpulseUpperLimit(Entity jointEntity, decimal impulseUpperLimit) const;
/// Return the accumulated impulse for the motor constraint;
decimal getImpulseMotor(Entity jointEntity) const;
/// Set the accumulated impulse for the motor constraint;
void setImpulseMotor(Entity jointEntity, decimal impulseMotor);
/// Return the inverse of mass matrix K=JM^-1J^t for the limits and motor constraints (1x1 matrix)
decimal getInverseMassMatrixLimitMotor(Entity jointEntity) const;
/// Set the inverse of mass matrix K=JM^-1J^t for the limits and motor constraints (1x1 matrix)
void setInverseMassMatrixLimitMotor(Entity jointEntity, decimal inverseMassMatrixLimitMotor);
/// Return the inverse of mass matrix K=JM^-1J^t for the motor
decimal getInverseMassMatrixMotor(Entity jointEntity);
/// Set the inverse of mass matrix K=JM^-1J^t for the motor
void setInverseMassMatrixMotor(Entity jointEntity, decimal inverseMassMatrixMotor);
/// Return the bias of the lower limit constraint
decimal getBLowerLimit(Entity jointEntity) const;
/// Set the bias of the lower limit constraint
void setBLowerLimit(Entity jointEntity, decimal bLowerLimit) const;
/// Return the bias of the upper limit constraint
decimal getBUpperLimit(Entity jointEntity) const;
/// Set the bias of the upper limit constraint
void setBUpperLimit(Entity jointEntity, decimal bUpperLimit);
/// Return true if the joint limits are enabled
bool getIsLimitEnabled(Entity jointEntity) const;
/// Set to true if the joint limits are enabled
void setIsLimitEnabled(Entity jointEntity, bool isLimitEnabled);
/// Return true if the motor of the joint in enabled
bool getIsMotorEnabled(Entity jointEntity) const;
/// Set to true if the motor of the joint in enabled
void setIsMotorEnabled(Entity jointEntity, bool isMotorEnabled) const;
/// Return the Lower limit (minimum allowed rotation angle in radian)
decimal getLowerLimit(Entity jointEntity) const;
/// Set the Lower limit (minimum allowed rotation angle in radian)
void setLowerLimit(Entity jointEntity, decimal lowerLimit) const;
/// Return the upper limit (maximum translation distance)
decimal getUpperLimit(Entity jointEntity) const;
/// Set the upper limit (maximum translation distance)
void setUpperLimit(Entity jointEntity, decimal upperLimit);
/// Return true if the lower limit is violated
bool getIsLowerLimitViolated(Entity jointEntity) const;
/// Set to true if the lower limit is violated
void setIsLowerLimitViolated(Entity jointEntity, bool isLowerLimitViolated);
/// Return true if the upper limit is violated
bool getIsUpperLimitViolated(Entity jointEntity) const;
/// Set to true if the upper limit is violated
void setIsUpperLimitViolated(Entity jointEntity, bool isUpperLimitViolated) const;
/// Return the motor speed (in rad/s)
decimal getMotorSpeed(Entity jointEntity) const;
/// Set the motor speed (in rad/s)
void setMotorSpeed(Entity jointEntity, decimal motorSpeed);
/// Return the maximum motor torque (in Newtons) that can be applied to reach to desired motor speed
decimal getMaxMotorTorque(Entity jointEntity) const;
/// Set the maximum motor torque (in Newtons) that can be applied to reach to desired motor speed
void setMaxMotorTorque(Entity jointEntity, decimal maxMotorTorque);
// -------------------- Friendship -------------------- //
friend class BroadPhaseSystem;
friend class SolveHingeJointSystem;
};
// Return a pointer to a given joint
inline HingeJoint* HingeJointComponents::getJoint(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mJoints[mMapEntityToComponentIndex[jointEntity]];
}
// Set the joint pointer to a given joint
inline void HingeJointComponents::setJoint(Entity jointEntity, HingeJoint* joint) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mJoints[mMapEntityToComponentIndex[jointEntity]] = joint;
}
// Return the local anchor point of body 1 for a given joint
inline const Vector3& HingeJointComponents::getLocalAnchorPointBody1(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mLocalAnchorPointBody1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the local anchor point of body 1 for a given joint
inline void HingeJointComponents::setLocalAnchorPointBody1(Entity jointEntity, const Vector3& localAnchoirPointBody1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mLocalAnchorPointBody1[mMapEntityToComponentIndex[jointEntity]] = localAnchoirPointBody1;
}
// Return the local anchor point of body 2 for a given joint
inline const Vector3& HingeJointComponents::getLocalAnchorPointBody2(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mLocalAnchorPointBody2[mMapEntityToComponentIndex[jointEntity]];
}
// Set the local anchor point of body 2 for a given joint
inline void HingeJointComponents::setLocalAnchorPointBody2(Entity jointEntity, const Vector3& localAnchoirPointBody2) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mLocalAnchorPointBody2[mMapEntityToComponentIndex[jointEntity]] = localAnchoirPointBody2;
}
// Return the vector from center of body 1 to anchor point in world-space
inline const Vector3& HingeJointComponents::getR1World(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mR1World[mMapEntityToComponentIndex[jointEntity]];
}
// Set the vector from center of body 1 to anchor point in world-space
inline void HingeJointComponents::setR1World(Entity jointEntity, const Vector3& r1World) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mR1World[mMapEntityToComponentIndex[jointEntity]] = r1World;
}
// Return the vector from center of body 2 to anchor point in world-space
inline const Vector3& HingeJointComponents::getR2World(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mR2World[mMapEntityToComponentIndex[jointEntity]];
}
// Set the vector from center of body 2 to anchor point in world-space
inline void HingeJointComponents::setR2World(Entity jointEntity, const Vector3& r2World) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mR2World[mMapEntityToComponentIndex[jointEntity]] = r2World;
}
// Return the inertia tensor of body 1 (in world-space coordinates)
inline const Matrix3x3& HingeJointComponents::getI1(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mI1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the inertia tensor of body 1 (in world-space coordinates)
inline void HingeJointComponents::setI1(Entity jointEntity, const Matrix3x3& i1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mI1[mMapEntityToComponentIndex[jointEntity]] = i1;
}
// Return the inertia tensor of body 2 (in world-space coordinates)
inline const Matrix3x3& HingeJointComponents::getI2(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mI2[mMapEntityToComponentIndex[jointEntity]];
}
// Set the inertia tensor of body 2 (in world-space coordinates)
inline void HingeJointComponents::setI2(Entity jointEntity, const Matrix3x3& i2) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mI2[mMapEntityToComponentIndex[jointEntity]] = i2;
}
// Return the translation impulse
inline Vector3& HingeJointComponents::getImpulseTranslation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mImpulseTranslation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the translation impulse
inline void HingeJointComponents::setImpulseTranslation(Entity jointEntity, const Vector3& impulseTranslation) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mImpulseTranslation[mMapEntityToComponentIndex[jointEntity]] = impulseTranslation;
}
// Return the translation impulse
inline Vector2& HingeJointComponents::getImpulseRotation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mImpulseRotation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the translation impulse
inline void HingeJointComponents::setImpulseRotation(Entity jointEntity, const Vector2& impulseTranslation) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mImpulseRotation[mMapEntityToComponentIndex[jointEntity]] = impulseTranslation;
}
// Return the translation inverse mass matrix of the constraint
inline Matrix3x3& HingeJointComponents::getInverseMassMatrixTranslation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mInverseMassMatrixTranslation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the translation inverse mass matrix of the constraint
inline void HingeJointComponents::setInverseMassMatrixTranslation(Entity jointEntity, const Matrix3x3& inverseMassMatrix) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mInverseMassMatrixTranslation[mMapEntityToComponentIndex[jointEntity]] = inverseMassMatrix;
}
// Return the rotation inverse mass matrix of the constraint
inline Matrix2x2& HingeJointComponents::getInverseMassMatrixRotation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mInverseMassMatrixRotation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the rotation inverse mass matrix of the constraint
inline void HingeJointComponents::setInverseMassMatrixRotation(Entity jointEntity, const Matrix2x2& inverseMassMatrix) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mInverseMassMatrixRotation[mMapEntityToComponentIndex[jointEntity]] = inverseMassMatrix;
}
// Return the translation bias
inline Vector3& HingeJointComponents::getBiasTranslation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mBiasTranslation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the translation impulse
inline void HingeJointComponents::setBiasTranslation(Entity jointEntity, const Vector3 &impulseTranslation) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mBiasTranslation[mMapEntityToComponentIndex[jointEntity]] = impulseTranslation;
}
// Return the rotation bias
inline Vector2 &HingeJointComponents::getBiasRotation(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mBiasRotation[mMapEntityToComponentIndex[jointEntity]];
}
// Set the rotation impulse
inline void HingeJointComponents::setBiasRotation(Entity jointEntity, const Vector2& impulseRotation) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mBiasRotation[mMapEntityToComponentIndex[jointEntity]] = impulseRotation;
}
// Return the initial orientation difference
inline Quaternion& HingeJointComponents::getInitOrientationDifferenceInv(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mInitOrientationDifferenceInv[mMapEntityToComponentIndex[jointEntity]];
}
// Set the rotation impulse
inline void HingeJointComponents::setInitOrientationDifferenceInv(Entity jointEntity, const Quaternion& initOrientationDifferenceInv) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mInitOrientationDifferenceInv[mMapEntityToComponentIndex[jointEntity]] = initOrientationDifferenceInv;
}
// Return the hinge rotation axis (in local-space coordinates of body 1)
inline Vector3& HingeJointComponents::getHingeLocalAxisBody1(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mHingeLocalAxisBody1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the hinge rotation axis (in local-space coordinates of body 1)
inline void HingeJointComponents::setHingeLocalAxisBody1(Entity jointEntity, const Vector3& hingeLocalAxisBody1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mHingeLocalAxisBody1[mMapEntityToComponentIndex[jointEntity]] = hingeLocalAxisBody1;
}
// Return the hinge rotation axis (in local-space coordiantes of body 2)
inline Vector3& HingeJointComponents::getHingeLocalAxisBody2(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mHingeLocalAxisBody2[mMapEntityToComponentIndex[jointEntity]];
}
// Set the hinge rotation axis (in local-space coordiantes of body 2)
inline void HingeJointComponents::setHingeLocalAxisBody2(Entity jointEntity, const Vector3& hingeLocalAxisBody2) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mHingeLocalAxisBody2[mMapEntityToComponentIndex[jointEntity]] = hingeLocalAxisBody2;
}
// Return the hinge rotation axis (in world-space coordinates) computed from body 1
inline Vector3& HingeJointComponents::getA1(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mA1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the hinge rotation axis (in world-space coordinates) computed from body 1
inline void HingeJointComponents::setA1(Entity jointEntity, const Vector3& a1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mA1[mMapEntityToComponentIndex[jointEntity]] = a1;
}
// Return the cross product of vector b2 and a1
inline Vector3& HingeJointComponents::getB2CrossA1(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mB2CrossA1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the cross product of vector b2 and a1
inline void HingeJointComponents::setB2CrossA1(Entity jointEntity, const Vector3& b2CrossA1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mB2CrossA1[mMapEntityToComponentIndex[jointEntity]] = b2CrossA1;
}
// Return the cross product of vector c2 and a1;
inline Vector3& HingeJointComponents::getC2CrossA1(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mC2CrossA1[mMapEntityToComponentIndex[jointEntity]];
}
// Set the cross product of vector c2 and a1;
inline void HingeJointComponents::setC2CrossA1(Entity jointEntity, const Vector3& c2CrossA1) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mC2CrossA1[mMapEntityToComponentIndex[jointEntity]] = c2CrossA1;
}
// Return the accumulated impulse for the lower limit constraint
inline decimal HingeJointComponents::getImpulseLowerLimit(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mImpulseLowerLimit[mMapEntityToComponentIndex[jointEntity]];
}
// Set the accumulated impulse for the lower limit constraint
inline void HingeJointComponents::setImpulseLowerLimit(Entity jointEntity, decimal impulseLowerLimit) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mImpulseLowerLimit[mMapEntityToComponentIndex[jointEntity]] = impulseLowerLimit;
}
// Return the accumulated impulse for the upper limit constraint
inline decimal HingeJointComponents::getImpulseUpperLimit(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mImpulseUpperLimit[mMapEntityToComponentIndex[jointEntity]];
}
// Set the accumulated impulse for the upper limit constraint
inline void HingeJointComponents::setImpulseUpperLimit(Entity jointEntity, decimal impulseUpperLimit) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mImpulseUpperLimit[mMapEntityToComponentIndex[jointEntity]] = impulseUpperLimit;
}
// Return the accumulated impulse for the motor constraint;
inline decimal HingeJointComponents::getImpulseMotor(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mImpulseMotor[mMapEntityToComponentIndex[jointEntity]];
}
// Set the accumulated impulse for the motor constraint;
inline void HingeJointComponents::setImpulseMotor(Entity jointEntity, decimal impulseMotor) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mImpulseMotor[mMapEntityToComponentIndex[jointEntity]] = impulseMotor;
}
// Return the inverse of mass matrix K=JM^-1J^t for the limits and motor constraints (1x1 matrix)
inline decimal HingeJointComponents::getInverseMassMatrixLimitMotor(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mInverseMassMatrixLimitMotor[mMapEntityToComponentIndex[jointEntity]];
}
// Set the inverse of mass matrix K=JM^-1J^t for the limits and motor constraints (1x1 matrix)
inline void HingeJointComponents::setInverseMassMatrixLimitMotor(Entity jointEntity, decimal inverseMassMatrixLimitMotor) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mInverseMassMatrixLimitMotor[mMapEntityToComponentIndex[jointEntity]] = inverseMassMatrixLimitMotor;
}
// Return the inverse of mass matrix K=JM^-1J^t for the motor
inline decimal HingeJointComponents::getInverseMassMatrixMotor(Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mInverseMassMatrixMotor[mMapEntityToComponentIndex[jointEntity]];
}
// Return the inverse of mass matrix K=JM^-1J^t for the motor
inline void HingeJointComponents::setInverseMassMatrixMotor(Entity jointEntity, decimal inverseMassMatrixMotor) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mInverseMassMatrixMotor[mMapEntityToComponentIndex[jointEntity]] = inverseMassMatrixMotor;
}
// Return the bias of the lower limit constraint
inline decimal HingeJointComponents::getBLowerLimit(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mBLowerLimit[mMapEntityToComponentIndex[jointEntity]];
}
// Set the bias of the lower limit constraint
inline void HingeJointComponents::setBLowerLimit(Entity jointEntity, decimal bLowerLimit) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mBLowerLimit[mMapEntityToComponentIndex[jointEntity]] = bLowerLimit;
}
// Return the bias of the upper limit constraint
inline decimal HingeJointComponents::getBUpperLimit(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mBUpperLimit[mMapEntityToComponentIndex[jointEntity]];
}
// Set the bias of the upper limit constraint
inline void HingeJointComponents::setBUpperLimit(Entity jointEntity, decimal bUpperLimit) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mBUpperLimit[mMapEntityToComponentIndex[jointEntity]] = bUpperLimit;
}
// Return true if the joint limits are enabled
inline bool HingeJointComponents::getIsLimitEnabled(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mIsLimitEnabled[mMapEntityToComponentIndex[jointEntity]];
}
// Set to true if the joint limits are enabled
inline void HingeJointComponents::setIsLimitEnabled(Entity jointEntity, bool isLimitEnabled) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mIsLimitEnabled[mMapEntityToComponentIndex[jointEntity]] = isLimitEnabled;
}
// Return true if the motor of the joint in enabled
inline bool HingeJointComponents::getIsMotorEnabled(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mIsMotorEnabled[mMapEntityToComponentIndex[jointEntity]];
}
// Set to true if the motor of the joint in enabled
inline void HingeJointComponents::setIsMotorEnabled(Entity jointEntity, bool isMotorEnabled) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mIsMotorEnabled[mMapEntityToComponentIndex[jointEntity]] = isMotorEnabled;
}
// Return the Lower limit (minimum allowed rotation angle in radian)
inline decimal HingeJointComponents::getLowerLimit(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mLowerLimit[mMapEntityToComponentIndex[jointEntity]];
}
// Set the Lower limit (minimum allowed rotation angle in radian)
inline void HingeJointComponents::setLowerLimit(Entity jointEntity, decimal lowerLimit) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mLowerLimit[mMapEntityToComponentIndex[jointEntity]] = lowerLimit;
}
// Return the upper limit (maximum translation distance)
inline decimal HingeJointComponents::getUpperLimit(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mUpperLimit[mMapEntityToComponentIndex[jointEntity]];
}
// Set the upper limit (maximum translation distance)
inline void HingeJointComponents::setUpperLimit(Entity jointEntity, decimal upperLimit) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mUpperLimit[mMapEntityToComponentIndex[jointEntity]] = upperLimit;
}
// Return true if the lower limit is violated
inline bool HingeJointComponents::getIsLowerLimitViolated(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mIsLowerLimitViolated[mMapEntityToComponentIndex[jointEntity]];
}
// Set to true if the lower limit is violated
inline void HingeJointComponents::setIsLowerLimitViolated(Entity jointEntity, bool isLowerLimitViolated) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mIsLowerLimitViolated[mMapEntityToComponentIndex[jointEntity]] = isLowerLimitViolated;
}
// Return true if the upper limit is violated
inline bool HingeJointComponents::getIsUpperLimitViolated(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mIsUpperLimitViolated[mMapEntityToComponentIndex[jointEntity]];
}
// Set to true if the upper limit is violated
inline void HingeJointComponents::setIsUpperLimitViolated(Entity jointEntity, bool isUpperLimitViolated) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mIsUpperLimitViolated[mMapEntityToComponentIndex[jointEntity]] = isUpperLimitViolated;
}
// Return the motor speed (in rad/s)
inline decimal HingeJointComponents::getMotorSpeed(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mMotorSpeed[mMapEntityToComponentIndex[jointEntity]];
}
// Set the motor speed (in rad/s)
inline void HingeJointComponents::setMotorSpeed(Entity jointEntity, decimal motorSpeed) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mMotorSpeed[mMapEntityToComponentIndex[jointEntity]] = motorSpeed;
}
// Return the maximum motor torque (in Newtons) that can be applied to reach to desired motor speed
inline decimal HingeJointComponents::getMaxMotorTorque(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mMaxMotorTorque[mMapEntityToComponentIndex[jointEntity]];
}
// Set the maximum motor torque (in Newtons) that can be applied to reach to desired motor speed
inline void HingeJointComponents::setMaxMotorTorque(Entity jointEntity, decimal maxMotorTorque) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mMaxMotorTorque[mMapEntityToComponentIndex[jointEntity]] = maxMotorTorque;
}
}
#endif

224
include/reactphysics3d/components/JointComponents.h Normal file
View File

@ -0,0 +1,224 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_JOINT_COMPONENTS_H
#define REACTPHYSICS3D_JOINT_COMPONENTS_H
// Libraries
#include <reactphysics3d/mathematics/Transform.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/components/Components.h>
#include <reactphysics3d/containers/Map.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class MemoryAllocator;
class EntityManager;
class Joint;
enum class JointType;
// Class JointComponents
/**
* This class represent the component of the ECS that contains generic information about
* all the joints.
*/
class JointComponents : public Components {
private:
// -------------------- Attributes -------------------- //
/// Array of joint entities
Entity* mJointEntities;
/// Array of body entities of the first bodies of the joints
Entity* mBody1Entities;
/// Array of body entities of the first bodies of the joints
Entity* mBody2Entities;
/// Array with pointers to the joints
Joint** mJoints;
/// Array of type of the joints
JointType* mTypes;
/// Array of position correction techniques used for the joints
JointsPositionCorrectionTechnique* mPositionCorrectionTechniques;
/// Array of boolean values to know if the two bodies of the constraint are allowed to collide with each other
bool* mIsCollisionEnabled;
/// True if the joint has already been added into an island during islands creation
bool* mIsAlreadyInIsland;
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
virtual void allocate(uint32 nbComponentsToAllocate) override;
/// Destroy a component at a given index
virtual void destroyComponent(uint32 index) override;
/// Move a component from a source to a destination index in the components array
virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex) override;
/// Swap two components in the array
virtual void swapComponents(uint32 index1, uint32 index2) override;
public:
/// Structure for the data of a transform component
struct JointComponent {
const Entity body1Entity;
const Entity body2Entity;
Joint* joint;
JointType jointType;
JointsPositionCorrectionTechnique positionCorrectionTechnique;
bool isCollisionEnabled;
/// Constructor
JointComponent(Entity body1Entity, Entity body2Entity, Joint* joint, JointType jointType,
JointsPositionCorrectionTechnique positionCorrectionTechnique, bool isCollisionEnabled)
: body1Entity(body1Entity), body2Entity(body2Entity), joint(joint), jointType(jointType),
positionCorrectionTechnique(positionCorrectionTechnique), isCollisionEnabled(isCollisionEnabled) {
}
};
// -------------------- Methods -------------------- //
/// Constructor
JointComponents(MemoryAllocator& allocator);
/// Destructor
virtual ~JointComponents() override = default;
/// Add a component
void addComponent(Entity jointEntity, bool isSleeping, const JointComponent& component);
/// Return the entity of the first body of a joint
Entity getBody1Entity(Entity jointEntity) const;
/// Return the entity of the second body of a joint
Entity getBody2Entity(Entity jointEntity) const;
/// Return a pointer to the joint
Joint* getJoint(Entity jointEntity) const;
/// Return the type of a joint
JointType getType(Entity jointEntity) const;
/// Return the position correction technique of a joint
JointsPositionCorrectionTechnique getPositionCorrectionTechnique(Entity jointEntity) const;
/// Set the position correction technique of a joint
void getPositionCorrectionTechnique(Entity jointEntity, JointsPositionCorrectionTechnique positionCorrectionTechnique);
/// Return true if the collision is enabled between the two bodies of a joint
bool getIsCollisionEnabled(Entity jointEntity) const;
/// Set whether the collision is enabled between the two bodies of a joint
void setIsCollisionEnabled(Entity jointEntity, bool isCollisionEnabled);
/// Return true if the joint has already been added into an island during island creation
bool getIsAlreadyInIsland(Entity jointEntity) const;
/// Set to true if the joint has already been added into an island during island creation
void setIsAlreadyInIsland(Entity jointEntity, bool isAlreadyInIsland);
// -------------------- Friendship -------------------- //
friend class BroadPhaseSystem;
friend class ConstraintSolverSystem;
friend class PhysicsWorld;
};
// Return the entity of the first body of a joint
inline Entity JointComponents::getBody1Entity(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mBody1Entities[mMapEntityToComponentIndex[jointEntity]];
}
// Return the entity of the second body of a joint
inline Entity JointComponents::getBody2Entity(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mBody2Entities[mMapEntityToComponentIndex[jointEntity]];
}
// Return a pointer to the joint
inline Joint* JointComponents::getJoint(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mJoints[mMapEntityToComponentIndex[jointEntity]];
}
// Return the type of a joint
inline JointType JointComponents::getType(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mTypes[mMapEntityToComponentIndex[jointEntity]];
}
// Return the position correction technique of a joint
inline JointsPositionCorrectionTechnique JointComponents::getPositionCorrectionTechnique(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mPositionCorrectionTechniques[mMapEntityToComponentIndex[jointEntity]];
}
// Set the position correction technique of a joint
inline void JointComponents::getPositionCorrectionTechnique(Entity jointEntity, JointsPositionCorrectionTechnique positionCorrectionTechnique) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mPositionCorrectionTechniques[mMapEntityToComponentIndex[jointEntity]] = positionCorrectionTechnique;
}
// Return true if the collision is enabled between the two bodies of a joint
inline bool JointComponents::getIsCollisionEnabled(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mIsCollisionEnabled[mMapEntityToComponentIndex[jointEntity]];
}
// Set whether the collision is enabled between the two bodies of a joint
inline void JointComponents::setIsCollisionEnabled(Entity jointEntity, bool isCollisionEnabled) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mIsCollisionEnabled[mMapEntityToComponentIndex[jointEntity]] = isCollisionEnabled;
}
// Return true if the joint has already been added into an island during island creation
inline bool JointComponents::getIsAlreadyInIsland(Entity jointEntity) const {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
return mIsAlreadyInIsland[mMapEntityToComponentIndex[jointEntity]];
}
// Set to true if the joint has already been added into an island during island creation
inline void JointComponents::setIsAlreadyInIsland(Entity jointEntity, bool isAlreadyInIsland) {
assert(mMapEntityToComponentIndex.containsKey(jointEntity));
mIsAlreadyInIsland[mMapEntityToComponentIndex[jointEntity]] = isAlreadyInIsland;
}
}
#endif

774
include/reactphysics3d/components/RigidBodyComponents.h Normal file
View File

@ -0,0 +1,774 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_RIGID_BODY_COMPONENTS_H
#define REACTPHYSICS3D_RIGID_BODY_COMPONENTS_H
// Libraries
#include <reactphysics3d/mathematics/Transform.h>
#include <reactphysics3d/mathematics/Matrix3x3.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/components/Components.h>
#include <reactphysics3d/containers/Map.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class MemoryAllocator;
class EntityManager;
class RigidBody;
enum class BodyType;
/// Enumeration for the type of a body
/// STATIC : A static body has infinite mass, zero velocity but the position can be
/// changed manually. A static body does not collide with other static or kinematic bodies.
/// KINEMATIC : A kinematic body has infinite mass, the velocity can be changed manually and its
/// position is computed by the physics engine. A kinematic body does not collide with
/// other static or kinematic bodies.
/// DYNAMIC : A dynamic body has non-zero mass, non-zero velocity determined by forces and its
/// position is determined by the physics engine. A dynamic body can collide with other
/// dynamic, static or kinematic bodies.
enum class BodyType {STATIC, KINEMATIC, DYNAMIC};
// Class RigidBodyComponents
/**
* This class represent the component of the ECS that contains data about a rigid body.
* The components of the sleeping entities (bodies) are always stored at the end of the array.
*/
class RigidBodyComponents : public Components {
private:
// -------------------- Attributes -------------------- //
/// Array of body entities of each component
Entity* mBodiesEntities;
/// Array of pointers to the corresponding rigid bodies
RigidBody** mRigidBodies;
/// Array of boolean values to know if the body is allowed to go to sleep
bool* mIsAllowedToSleep;
/// Array of boolean values to know if the body is sleeping
bool* mIsSleeping;
/// Array with values for elapsed time since the body velocity was below the sleep velocity
decimal* mSleepTimes;
/// Array with the type of bodies (static, kinematic or dynamic)
BodyType* mBodyTypes;
/// Array with the linear velocity of each component
Vector3* mLinearVelocities;
/// Array with the angular velocity of each component
Vector3* mAngularVelocities;
/// Array with the external force of each component
Vector3* mExternalForces;
/// Array with the external torque of each component
Vector3* mExternalTorques;
/// Array with the linear damping factor of each component
decimal* mLinearDampings;
/// Array with the angular damping factor of each component
decimal* mAngularDampings;
/// Array with the mass of each component
decimal* mMasses;
/// Array with the inverse mass of each component
decimal* mInverseMasses;
/// Array with the inertia tensor of each component
Vector3* mLocalInertiaTensors;
/// Array with the inverse of the inertia tensor of each component
Vector3* mInverseInertiaTensorsLocal;
/// Array with the constrained linear velocity of each component
Vector3* mConstrainedLinearVelocities;
/// Array with the constrained angular velocity of each component
Vector3* mConstrainedAngularVelocities;
/// Array with the split linear velocity of each component
Vector3* mSplitLinearVelocities;
/// Array with the split angular velocity of each component
Vector3* mSplitAngularVelocities;
/// Array with the constrained position of each component (for position error correction)
Vector3* mConstrainedPositions;
/// Array of constrained orientation for each component (for position error correction)
Quaternion* mConstrainedOrientations;
/// Array of center of mass of each component (in local-space coordinates)
Vector3* mCentersOfMassLocal;
/// Array of center of mass of each component (in world-space coordinates)
Vector3* mCentersOfMassWorld;
/// True if the gravity needs to be applied to this component
bool* mIsGravityEnabled;
/// Array with the boolean value to know if the body has already been added into an island
bool* mIsAlreadyInIsland;
/// For each body, the list of joints entities the body is part of
List<Entity>* mJoints;
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
virtual void allocate(uint32 nbComponentsToAllocate) override;
/// Destroy a component at a given index
virtual void destroyComponent(uint32 index) override;
/// Move a component from a source to a destination index in the components array
virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex) override;
/// Swap two components in the array
virtual void swapComponents(uint32 index1, uint32 index2) override;
public:
/// Structure for the data of a rigid body component
struct RigidBodyComponent {
RigidBody* body;
BodyType bodyType;
const Vector3& worldPosition;
/// Constructor
RigidBodyComponent(RigidBody* body, BodyType bodyType, const Vector3& worldPosition)
: body(body), bodyType(bodyType), worldPosition(worldPosition) {
}
};
// -------------------- Methods -------------------- //
/// Constructor
RigidBodyComponents(MemoryAllocator& allocator);
/// Destructor
virtual ~RigidBodyComponents() override = default;
/// Add a component
void addComponent(Entity bodyEntity, bool isSleeping, const RigidBodyComponent& component);
/// Return a pointer to a rigid body
RigidBody* getRigidBody(Entity bodyEntity);
/// Return true if the body is allowed to sleep
bool getIsAllowedToSleep(Entity bodyEntity) const;
/// Set the value to know if the body is allowed to sleep
void setIsAllowedToSleep(Entity bodyEntity, bool isAllowedToSleep) const;
/// Return true if the body is sleeping
bool getIsSleeping(Entity bodyEntity) const;
/// Set the value to know if the body is sleeping
void setIsSleeping(Entity bodyEntity, bool isSleeping) const;
/// Return the sleep time
decimal getSleepTime(Entity bodyEntity) const;
/// Set the sleep time
void setSleepTime(Entity bodyEntity, decimal sleepTime) const;
/// Return the body type of a body
BodyType getBodyType(Entity bodyEntity);
/// Set the body type of a body
void setBodyType(Entity bodyEntity, BodyType bodyType);
/// Return the linear velocity of an entity
const Vector3& getLinearVelocity(Entity bodyEntity) const;
/// Set the linear velocity of an entity
void setLinearVelocity(Entity bodyEntity, const Vector3& linearVelocity);
/// Return the angular velocity of an entity
const Vector3& getAngularVelocity(Entity bodyEntity) const;
/// Set the angular velocity of an entity
void setAngularVelocity(Entity bodyEntity, const Vector3& angularVelocity);
/// Return the external force of an entity
const Vector3& getExternalForce(Entity bodyEntity) const;
/// Return the external torque of an entity
const Vector3& getExternalTorque(Entity bodyEntity) const;
/// Return the linear damping factor of an entity
decimal getLinearDamping(Entity bodyEntity) const;
/// Return the angular damping factor of an entity
decimal getAngularDamping(Entity bodyEntity) const;
/// Return the mass of an entity
decimal getMass(Entity bodyEntity) const;
/// Set the mass of an entity
void setMass(Entity bodyEntity, decimal mass);
/// Return the mass inverse of an entity
decimal getMassInverse(Entity bodyEntity) const;
/// Set the inverse mass of an entity
void setMassInverse(Entity bodyEntity, decimal inverseMass);
/// Return the local inertia tensor of an entity
const Vector3& getLocalInertiaTensor(Entity bodyEntity);
/// Set the local inertia tensor of an entity
void setLocalInertiaTensor(Entity bodyEntity, const Vector3& inertiaTensorLocal);
/// Return the inverse local inertia tensor of an entity
const Vector3& getInertiaTensorLocalInverse(Entity bodyEntity);
/// Set the external force of an entity
void setExternalForce(Entity bodyEntity, const Vector3& externalForce);
/// Set the external force of an entity
void setExternalTorque(Entity bodyEntity, const Vector3& externalTorque);
/// Set the linear damping factor of an entity
void setLinearDamping(Entity bodyEntity, decimal linearDamping);
/// Set the angular damping factor of an entity
void setAngularDamping(Entity bodyEntity, decimal angularDamping);
/// Set the inverse local inertia tensor of an entity
void setInverseInertiaTensorLocal(Entity bodyEntity, const Vector3& inertiaTensorLocalInverse);
/// Return the constrained linear velocity of an entity
const Vector3& getConstrainedLinearVelocity(Entity bodyEntity) const;
/// Return the constrained angular velocity of an entity
const Vector3& getConstrainedAngularVelocity(Entity bodyEntity) const;
/// Return the split linear velocity of an entity
const Vector3& getSplitLinearVelocity(Entity bodyEntity) const;
/// Return the split angular velocity of an entity
const Vector3& getSplitAngularVelocity(Entity bodyEntity) const;
/// Return the constrained position of an entity
Vector3& getConstrainedPosition(Entity bodyEntity);
/// Return the constrained orientation of an entity
Quaternion& getConstrainedOrientation(Entity bodyEntity);
/// Return the local center of mass of an entity
const Vector3& getCenterOfMassLocal(Entity bodyEntity);
/// Return the world center of mass of an entity
const Vector3& getCenterOfMassWorld(Entity bodyEntity);
/// Return true if gravity is enabled for this entity
bool getIsGravityEnabled(Entity bodyEntity) const;
/// Return true if the entity is already in an island
bool getIsAlreadyInIsland(Entity bodyEntity) const;
/// Set the constrained linear velocity of an entity
void setConstrainedLinearVelocity(Entity bodyEntity, const Vector3& constrainedLinearVelocity);
/// Set the constrained angular velocity of an entity
void setConstrainedAngularVelocity(Entity bodyEntity, const Vector3& constrainedAngularVelocity);
/// Set the split linear velocity of an entity
void setSplitLinearVelocity(Entity bodyEntity, const Vector3& splitLinearVelocity);
/// Set the split angular velocity of an entity
void setSplitAngularVelocity(Entity bodyEntity, const Vector3& splitAngularVelocity);
/// Set the constrained position of an entity
void setConstrainedPosition(Entity bodyEntity, const Vector3& constrainedPosition);
/// Set the constrained orientation of an entity
void setConstrainedOrientation(Entity bodyEntity, const Quaternion& constrainedOrientation);
/// Set the local center of mass of an entity
void setCenterOfMassLocal(Entity bodyEntity, const Vector3& centerOfMassLocal);
/// Set the world center of mass of an entity
void setCenterOfMassWorld(Entity bodyEntity, const Vector3& centerOfMassWorld);
/// Set the value to know if the gravity is enabled for this entity
void setIsGravityEnabled(Entity bodyEntity, bool isGravityEnabled);
/// Set the value to know if the entity is already in an island
void setIsAlreadyInIsland(Entity bodyEntity, bool isAlreadyInIsland);
/// Return the list of joints of a body
const List<Entity>& getJoints(Entity bodyEntity) const;
/// Add a joint to a body component
void addJointToBody(Entity bodyEntity, Entity jointEntity);
/// Remove a joint from a body component
void removeJointFromBody(Entity bodyEntity, Entity jointEntity);
// -------------------- Friendship -------------------- //
friend class PhysicsWorld;
friend class ContactSolverSystem;
friend class SolveBallAndSocketJointSystem;
friend class SolveFixedJointSystem;
friend class SolveHingeJointSystem;
friend class SolveSliderJointSystem;
friend class DynamicsSystem;
friend class BallAndSocketJoint;
friend class FixedJoint;
friend class HingeJoint;
friend class SliderJoint;
};
// Return a pointer to a body rigid
inline RigidBody* RigidBodyComponents::getRigidBody(Entity bodyEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mRigidBodies[mMapEntityToComponentIndex[bodyEntity]];
}
// Return true if the body is allowed to sleep
inline bool RigidBodyComponents::getIsAllowedToSleep(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mIsAllowedToSleep[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the value to know if the body is allowed to sleep
inline void RigidBodyComponents::setIsAllowedToSleep(Entity bodyEntity, bool isAllowedToSleep) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mIsAllowedToSleep[mMapEntityToComponentIndex[bodyEntity]] = isAllowedToSleep;
}
// Return true if the body is sleeping
inline bool RigidBodyComponents::getIsSleeping(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mIsSleeping[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the value to know if the body is sleeping
inline void RigidBodyComponents::setIsSleeping(Entity bodyEntity, bool isSleeping) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mIsSleeping[mMapEntityToComponentIndex[bodyEntity]] = isSleeping;
}
// Return the sleep time
inline decimal RigidBodyComponents::getSleepTime(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mSleepTimes[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the sleep time
inline void RigidBodyComponents::setSleepTime(Entity bodyEntity, decimal sleepTime) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mSleepTimes[mMapEntityToComponentIndex[bodyEntity]] = sleepTime;
}
// Return the body type of a body
inline BodyType RigidBodyComponents::getBodyType(Entity bodyEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mBodyTypes[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the body type of a body
inline void RigidBodyComponents::setBodyType(Entity bodyEntity, BodyType bodyType) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mBodyTypes[mMapEntityToComponentIndex[bodyEntity]] = bodyType;
}
// Return the linear velocity of an entity
inline const Vector3& RigidBodyComponents::getLinearVelocity(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mLinearVelocities[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the angular velocity of an entity
inline const Vector3& RigidBodyComponents::getAngularVelocity(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mAngularVelocities[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the linear velocity of an entity
inline void RigidBodyComponents::setLinearVelocity(Entity bodyEntity, const Vector3& linearVelocity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mLinearVelocities[mMapEntityToComponentIndex[bodyEntity]] = linearVelocity;
}
// Set the angular velocity of an entity
inline void RigidBodyComponents::setAngularVelocity(Entity bodyEntity, const Vector3& angularVelocity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mAngularVelocities[mMapEntityToComponentIndex[bodyEntity]] = angularVelocity;
}
// Return the external force of an entity
inline const Vector3& RigidBodyComponents::getExternalForce(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mExternalForces[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the external torque of an entity
inline const Vector3& RigidBodyComponents::getExternalTorque(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mExternalTorques[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the linear damping factor of an entity
inline decimal RigidBodyComponents::getLinearDamping(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mLinearDampings[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the angular damping factor of an entity
inline decimal RigidBodyComponents::getAngularDamping(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mAngularDampings[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the mass of an entity
inline decimal RigidBodyComponents::getMass(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mMasses[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the inverse mass of an entity
inline decimal RigidBodyComponents::getMassInverse(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mInverseMasses[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the inverse local inertia tensor of an entity
inline const Vector3& RigidBodyComponents::getInertiaTensorLocalInverse(Entity bodyEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mInverseInertiaTensorsLocal[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the external force of an entity
inline void RigidBodyComponents::setExternalForce(Entity bodyEntity, const Vector3& externalForce) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mExternalForces[mMapEntityToComponentIndex[bodyEntity]] = externalForce;
}
// Set the external force of an entity
inline void RigidBodyComponents::setExternalTorque(Entity bodyEntity, const Vector3& externalTorque) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mExternalTorques[mMapEntityToComponentIndex[bodyEntity]] = externalTorque;
}
// Set the linear damping factor of an entity
inline void RigidBodyComponents::setLinearDamping(Entity bodyEntity, decimal linearDamping) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mLinearDampings[mMapEntityToComponentIndex[bodyEntity]] = linearDamping;
}
// Set the angular damping factor of an entity
inline void RigidBodyComponents::setAngularDamping(Entity bodyEntity, decimal angularDamping) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mAngularDampings[mMapEntityToComponentIndex[bodyEntity]] = angularDamping;
}
// Set the mass of an entity
inline void RigidBodyComponents::setMass(Entity bodyEntity, decimal mass) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mMasses[mMapEntityToComponentIndex[bodyEntity]] = mass;
}
// Set the mass inverse of an entity
inline void RigidBodyComponents::setMassInverse(Entity bodyEntity, decimal inverseMass) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mInverseMasses[mMapEntityToComponentIndex[bodyEntity]] = inverseMass;
}
// Return the local inertia tensor of an entity
inline const Vector3& RigidBodyComponents::getLocalInertiaTensor(Entity bodyEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mLocalInertiaTensors[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the local inertia tensor of an entity
inline void RigidBodyComponents::setLocalInertiaTensor(Entity bodyEntity, const Vector3& inertiaTensorLocal) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mLocalInertiaTensors[mMapEntityToComponentIndex[bodyEntity]] = inertiaTensorLocal;
}
// Set the inverse local inertia tensor of an entity
inline void RigidBodyComponents::setInverseInertiaTensorLocal(Entity bodyEntity, const Vector3& inertiaTensorLocalInverse) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mInverseInertiaTensorsLocal[mMapEntityToComponentIndex[bodyEntity]] = inertiaTensorLocalInverse;
}
// Return the constrained linear velocity of an entity
inline const Vector3& RigidBodyComponents::getConstrainedLinearVelocity(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mConstrainedLinearVelocities[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the constrained angular velocity of an entity
inline const Vector3& RigidBodyComponents::getConstrainedAngularVelocity(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mConstrainedAngularVelocities[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the split linear velocity of an entity
inline const Vector3& RigidBodyComponents::getSplitLinearVelocity(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mSplitLinearVelocities[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the split angular velocity of an entity
inline const Vector3& RigidBodyComponents::getSplitAngularVelocity(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mSplitAngularVelocities[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the constrained position of an entity
inline Vector3& RigidBodyComponents::getConstrainedPosition(Entity bodyEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mConstrainedPositions[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the constrained orientation of an entity
inline Quaternion& RigidBodyComponents::getConstrainedOrientation(Entity bodyEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mConstrainedOrientations[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the local center of mass of an entity
inline const Vector3& RigidBodyComponents::getCenterOfMassLocal(Entity bodyEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mCentersOfMassLocal[mMapEntityToComponentIndex[bodyEntity]];
}
// Return the world center of mass of an entity
inline const Vector3& RigidBodyComponents::getCenterOfMassWorld(Entity bodyEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mCentersOfMassWorld[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the constrained linear velocity of an entity
inline void RigidBodyComponents::setConstrainedLinearVelocity(Entity bodyEntity, const Vector3& constrainedLinearVelocity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mConstrainedLinearVelocities[mMapEntityToComponentIndex[bodyEntity]] = constrainedLinearVelocity;
}
// Set the constrained angular velocity of an entity
inline void RigidBodyComponents::setConstrainedAngularVelocity(Entity bodyEntity, const Vector3& constrainedAngularVelocity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mConstrainedAngularVelocities[mMapEntityToComponentIndex[bodyEntity]] = constrainedAngularVelocity;
}
// Set the split linear velocity of an entity
inline void RigidBodyComponents::setSplitLinearVelocity(Entity bodyEntity, const Vector3& splitLinearVelocity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mSplitLinearVelocities[mMapEntityToComponentIndex[bodyEntity]] = splitLinearVelocity;
}
// Set the split angular velocity of an entity
inline void RigidBodyComponents::setSplitAngularVelocity(Entity bodyEntity, const Vector3& splitAngularVelocity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mSplitAngularVelocities[mMapEntityToComponentIndex[bodyEntity]] = splitAngularVelocity;
}
// Set the constrained position of an entity
inline void RigidBodyComponents::setConstrainedPosition(Entity bodyEntity, const Vector3& constrainedPosition) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mConstrainedPositions[mMapEntityToComponentIndex[bodyEntity]] = constrainedPosition;
}
// Set the constrained orientation of an entity
inline void RigidBodyComponents::setConstrainedOrientation(Entity bodyEntity, const Quaternion& constrainedOrientation) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mConstrainedOrientations[mMapEntityToComponentIndex[bodyEntity]] = constrainedOrientation;
}
// Set the local center of mass of an entity
inline void RigidBodyComponents::setCenterOfMassLocal(Entity bodyEntity, const Vector3& centerOfMassLocal) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mCentersOfMassLocal[mMapEntityToComponentIndex[bodyEntity]] = centerOfMassLocal;
}
// Set the world center of mass of an entity
inline void RigidBodyComponents::setCenterOfMassWorld(Entity bodyEntity, const Vector3& centerOfMassWorld) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mCentersOfMassWorld[mMapEntityToComponentIndex[bodyEntity]] = centerOfMassWorld;
}
// Return true if gravity is enabled for this entity
inline bool RigidBodyComponents::getIsGravityEnabled(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mIsGravityEnabled[mMapEntityToComponentIndex[bodyEntity]];
}
// Return true if the entity is already in an island
inline bool RigidBodyComponents::getIsAlreadyInIsland(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mIsAlreadyInIsland[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the value to know if the gravity is enabled for this entity
inline void RigidBodyComponents::setIsGravityEnabled(Entity bodyEntity, bool isGravityEnabled) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mIsGravityEnabled[mMapEntityToComponentIndex[bodyEntity]] = isGravityEnabled;
}
// Set the value to know if the entity is already in an island
inline void RigidBodyComponents::setIsAlreadyInIsland(Entity bodyEntity, bool isAlreadyInIsland) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mIsAlreadyInIsland[mMapEntityToComponentIndex[bodyEntity]] = isAlreadyInIsland;
}
// Return the list of joints of a body
inline const List<Entity>& RigidBodyComponents::getJoints(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mJoints[mMapEntityToComponentIndex[bodyEntity]];
}
// Add a joint to a body component
inline void RigidBodyComponents::addJointToBody(Entity bodyEntity, Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mJoints[mMapEntityToComponentIndex[bodyEntity]].add(jointEntity);
}
// Remove a joint from a body component
inline void RigidBodyComponents::removeJointFromBody(Entity bodyEntity, Entity jointEntity) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mJoints[mMapEntityToComponentIndex[bodyEntity]].remove(jointEntity);
}
}
#endif

1012
include/reactphysics3d/components/SliderJointComponents.h Normal file
View File

File diff suppressed because it is too large Load Diff

123
include/reactphysics3d/components/TransformComponents.h Normal file
View File

@ -0,0 +1,123 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_TRANSFORM_COMPONENTS_H
#define REACTPHYSICS3D_TRANSFORM_COMPONENTS_H
// Libraries
#include <reactphysics3d/mathematics/Transform.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/components/Components.h>
#include <reactphysics3d/containers/Map.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
// Class declarations
class MemoryAllocator;
class EntityManager;
// Class TransformComponents
/**
* This class represent the component of the ECS that contains the transforms of the
* different entities. The position and orientation of the bodies are stored there.
* The components of the sleeping entities (bodies) are always stored at the end of the array.
*/
class TransformComponents : public Components {
private:
// -------------------- Attributes -------------------- //
/// Array of body entities of each component
Entity* mBodies;
/// Array of transform of each component
Transform* mTransforms;
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
virtual void allocate(uint32 nbComponentsToAllocate) override;
/// Destroy a component at a given index
virtual void destroyComponent(uint32 index) override;
/// Move a component from a source to a destination index in the components array
virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex) override;
/// Swap two components in the array
virtual void swapComponents(uint32 index1, uint32 index2) override;
public:
/// Structure for the data of a transform component
struct TransformComponent {
const Transform& transform;
/// Constructor
TransformComponent(const Transform& transform) : transform(transform) {
}
};
// -------------------- Methods -------------------- //
/// Constructor
TransformComponents(MemoryAllocator& allocator);
/// Destructor
virtual ~TransformComponents() override = default;
/// Add a component
void addComponent(Entity bodyEntity, bool isSleeping, const TransformComponent& component);
/// Return the transform of an entity
Transform& getTransform(Entity bodyEntity) const;
/// Set the transform of an entity
void setTransform(Entity bodyEntity, const Transform& transform);
// -------------------- Friendship -------------------- //
friend class BroadPhaseSystem;
};
// Return the transform of an entity
inline Transform& TransformComponents::getTransform(Entity bodyEntity) const {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
return mTransforms[mMapEntityToComponentIndex[bodyEntity]];
}
// Set the transform of an entity
inline void TransformComponents::setTransform(Entity bodyEntity, const Transform& transform) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
mTransforms[mMapEntityToComponentIndex[bodyEntity]] = transform;
}
}
#endif

111
include/reactphysics3d/configuration.h Normal file
View File

@ -0,0 +1,111 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_CONFIGURATION_H
#define REACTPHYSICS3D_CONFIGURATION_H
// Libraries
#include <limits>
#include <cfloat>
#include <utility>
#include <sstream>
#include <string>
#include <reactphysics3d/decimal.h>
#include <reactphysics3d/containers/Pair.h>
// Windows platform
#if defined(WIN32) ||defined(_WIN32) || defined(_WIN64) ||defined(__WIN32__) || defined(__WINDOWS__)
#define WINDOWS_OS
#elif defined(__APPLE__) // Apple platform
#define APPLE_OS
#elif defined(__linux__) || defined(linux) || defined(__linux) // Linux platform
#define LINUX_OS
#endif
/// Namespace reactphysics3d
namespace reactphysics3d {
// ------------------- Type definitions ------------------- //
using uint = unsigned int;
using uchar = unsigned char;
using ushort = unsigned short;
using luint = long unsigned int;
using int8 = std::int8_t;
using uint8 = std::uint8_t;
using int16 = std::int16_t;
using uint16 = std::uint16_t;
using int32 = std::int32_t;
using uint32 = std::uint32_t;
using int64 = std::int64_t;
using uint64 = std::uint64_t;
struct Entity;
using bodypair = Pair<Entity, Entity>;
// ------------------- Enumerations ------------------- //
/// Position correction technique used in the constraint solver (for joints).
/// BAUMGARTE_JOINTS : Faster but can be innacurate in some situations.
/// NON_LINEAR_GAUSS_SEIDEL : Slower but more precise. This is the option used by default.
enum class JointsPositionCorrectionTechnique {BAUMGARTE_JOINTS, NON_LINEAR_GAUSS_SEIDEL};
/// Position correction technique used in the contact solver (for contacts)
/// BAUMGARTE_CONTACTS : Faster but can be innacurate and can lead to unexpected bounciness
/// in some situations (due to error correction factor being added to
/// the bodies momentum).
/// SPLIT_IMPULSES : A bit slower but the error correction factor is not added to the
/// bodies momentum. This is the option used by default.
enum class ContactsPositionCorrectionTechnique {BAUMGARTE_CONTACTS, SPLIT_IMPULSES};
// ------------------- Constants ------------------- //
/// Smallest decimal value (negative)
const decimal DECIMAL_SMALLEST = - std::numeric_limits<decimal>::max();
/// Maximum decimal value
const decimal DECIMAL_LARGEST = std::numeric_limits<decimal>::max();
/// Machine epsilon
const decimal MACHINE_EPSILON = std::numeric_limits<decimal>::epsilon();
/// Pi constant
constexpr decimal PI = decimal(3.14159265);
/// 2*Pi constant
constexpr decimal PI_TIMES_2 = decimal(6.28318530);
/// In the broad-phase collision detection (dynamic AABB tree), the AABBs are
/// inflated by a constant percentage of its size to allow the collision shape to move a little bit
/// without triggering a large modification of the tree each frame which can be costly
constexpr decimal DYNAMIC_TREE_FAT_AABB_INFLATE_PERCENTAGE = decimal(0.08);
/// Current version of ReactPhysics3D
const std::string RP3D_VERSION = std::string("0.8.0");
}
#endif

51
src/constraint/BallAndSocketJoint.h → include/reactphysics3d/constraint/BallAndSocketJoint.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_BALL_AND_SOCKET_JOINT_H
// Libraries
#include "Joint.h"
#include "mathematics/mathematics.h"
#include <reactphysics3d/constraint/Joint.h>
#include <reactphysics3d/mathematics/mathematics.h>
namespace reactphysics3d {
@ -76,56 +76,19 @@ class BallAndSocketJoint : public Joint {
// -------------------- Attributes -------------------- //
/// Anchor point of body 1 (in local-space coordinates of body 1)
Vector3 mLocalAnchorPointBody1;
/// Anchor point of body 2 (in local-space coordinates of body 2)
Vector3 mLocalAnchorPointBody2;
/// Vector from center of body 2 to anchor point in world-space
Vector3 mR1World;
/// Vector from center of body 2 to anchor point in world-space
Vector3 mR2World;
/// Inertia tensor of body 1 (in world-space coordinates)
Matrix3x3 mI1;
/// Inertia tensor of body 2 (in world-space coordinates)
Matrix3x3 mI2;
/// Bias vector for the constraint
Vector3 mBiasVector;
/// Inverse mass matrix K=JM^-1J^-t of the constraint
Matrix3x3 mInverseMassMatrix;
/// Accumulated impulse
Vector3 mImpulse;
// -------------------- Methods -------------------- //
/// Return the number of bytes used by the joint
virtual size_t getSizeInBytes() const override;
/// Initialize before solving the constraint
virtual void initBeforeSolve(const ConstraintSolverData& constraintSolverData) override;
/// Warm start the constraint (apply the previous impulse at the beginning of the step)
virtual void warmstart(const ConstraintSolverData& constraintSolverData) override;
/// Solve the velocity constraint
virtual void solveVelocityConstraint(const ConstraintSolverData& constraintSolverData) override;
/// Solve the position constraint (for position error correction)
virtual void solvePositionConstraint(const ConstraintSolverData& constraintSolverData) override;
public :
// -------------------- Methods -------------------- //
/// Constructor
BallAndSocketJoint(uint id, const BallAndSocketJointInfo& jointInfo);
BallAndSocketJoint(Entity entity, PhysicsWorld& world, const BallAndSocketJointInfo& jointInfo);
/// Destructor
virtual ~BallAndSocketJoint() override = default;
@ -145,12 +108,6 @@ inline size_t BallAndSocketJoint::getSizeInBytes() const {
return sizeof(BallAndSocketJoint);
}
// Return a string representation
inline std::string BallAndSocketJoint::to_string() const {
return "BallAndSocketJoint{ localAnchorPointBody1=" + mLocalAnchorPointBody1.to_string() +
", localAnchorPointBody2=" + mLocalAnchorPointBody2.to_string() + "}";
}
}
#endif

120
src/constraint/ContactPoint.h → include/reactphysics3d/constraint/ContactPoint.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,9 +27,9 @@
#define REACTPHYSICS3D_CONTACT_POINT_H
// Libraries
#include "configuration.h"
#include "mathematics/mathematics.h"
#include "collision/ContactPointInfo.h"
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/mathematics/mathematics.h>
#include <reactphysics3d/collision/ContactPointInfo.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -37,8 +37,6 @@ namespace reactphysics3d {
// Declarations
class CollisionBody;
struct NarrowPhaseInfo;
// Class ContactPoint
/**
* This class represents a collision contact point between two
@ -56,10 +54,10 @@ class ContactPoint {
/// Penetration depth
decimal mPenetrationDepth;
/// Contact point on proxy shape 1 in local-space of proxy shape 1
/// Contact point on collider 1 in local-space of collider 1
Vector3 mLocalPointOnShape1;
/// Contact point on proxy shape 2 in local-space of proxy shape 2
/// Contact point on collider 2 in local-space of collider 2
Vector3 mLocalPointOnShape2;
/// True if the contact is a resting contact (exists for more than one time step)
@ -77,8 +75,8 @@ class ContactPoint {
/// Pointer to the previous contact point in the double linked-list
ContactPoint* mPrevious;
/// World settings
const WorldSettings& mWorldSettings;
/// Persistent contact distance threshold;
decimal mPersistentContactDistanceThreshold;
// -------------------- Methods -------------------- //
@ -95,41 +93,32 @@ class ContactPoint {
/// Set the mIsRestingContact variable
void setIsRestingContact(bool isRestingContact);
/// Set to true to make the contact point obsolete
void setIsObsolete(bool isObselete);
/// Set the next contact point in the linked list
void setNext(ContactPoint* next);
/// Set the previous contact point in the linked list
void setPrevious(ContactPoint* previous);
/// Return true if the contact point is obsolete
bool getIsObsolete() const;
public :
// -------------------- Methods -------------------- //
/// Constructor
ContactPoint(const ContactPointInfo* contactInfo, const WorldSettings& worldSettings);
ContactPoint(const ContactPointInfo* contactInfo, decimal persistentContactDistanceThreshold);
/// Constructor
ContactPoint(const ContactPointInfo& contactInfo, decimal persistentContactDistanceThreshold);
/// Destructor
~ContactPoint() = default;
/// Deleted copy-constructor
ContactPoint(const ContactPoint& contact) = delete;
/// Copy-constructor
ContactPoint(const ContactPoint& contact) = default;
/// Deleted assignment operator
ContactPoint& operator=(const ContactPoint& contact) = delete;
/// Assignment operator
ContactPoint& operator=(const ContactPoint& contact) = default;
/// Return the normal vector of the contact
Vector3 getNormal() const;
const Vector3& getNormal() const;
/// Return the contact point on the first proxy shape in the local-space of the proxy shape
/// Return the contact point on the first collider in the local-space of the collider
const Vector3& getLocalPointOnShape1() const;
/// Return the contact point on the second proxy shape in the local-space of the proxy shape
/// Return the contact point on the second collider in the local-space of the collider
const Vector3& getLocalPointOnShape2() const;
/// Return the cached penetration impulse
@ -138,12 +127,6 @@ class ContactPoint {
/// Return true if the contact is a resting contact
bool getIsRestingContact() const;
/// Return the previous contact point in the linked list
inline ContactPoint* getPrevious() const;
/// Return the next contact point in the linked list
ContactPoint* getNext() const;
/// Return the penetration depth
decimal getPenetrationDepth() const;
@ -153,28 +136,29 @@ class ContactPoint {
// Friendship
friend class ContactManifold;
friend class ContactManifoldSet;
friend class ContactSolver;
friend class ContactSolverSystem;
friend class CollisionDetectionSystem;
};
// Return the normal vector of the contact
/**
* @return The contact normal
*/
inline Vector3 ContactPoint::getNormal() const {
inline const Vector3& ContactPoint::getNormal() const {
return mNormal;
}
// Return the contact point on the first proxy shape in the local-space of the proxy shape
// Return the contact point on the first collider in the local-space of the collider
/**
* @return The contact point on the first proxy shape in the local-space of the proxy shape
* @return The contact point on the first collider in the local-space of the collider
*/
inline const Vector3& ContactPoint::getLocalPointOnShape1() const {
return mLocalPointOnShape1;
}
// Return the contact point on the second proxy shape in the local-space of the proxy shape
// Return the contact point on the second collider in the local-space of the collider
/**
* @return The contact point on the second proxy shape in the local-space of the proxy shape
* @return The contact point on the second collider in the local-space of the collider
*/
inline const Vector3& ContactPoint::getLocalPointOnShape2() const {
return mLocalPointOnShape2;
@ -190,8 +174,8 @@ inline decimal ContactPoint::getPenetrationImpulse() const {
// Return true if the contact point is similar (close enougth) to another given contact point
inline bool ContactPoint::isSimilarWithContactPoint(const ContactPointInfo* localContactPointBody1) const {
return (localContactPointBody1->localPoint1 - mLocalPointOnShape1).lengthSquare() <= (mWorldSettings.persistentContactDistanceThreshold *
mWorldSettings.persistentContactDistanceThreshold);
return (localContactPointBody1->localPoint1 - mLocalPointOnShape1).lengthSquare() <= (mPersistentContactDistanceThreshold *
mPersistentContactDistanceThreshold);
}
// Set the cached penetration impulse
@ -218,54 +202,6 @@ inline void ContactPoint::setIsRestingContact(bool isRestingContact) {
mIsRestingContact = isRestingContact;
}
// Return true if the contact point is obsolete
/**
* @return True if the contact is obsolete
*/
inline bool ContactPoint::getIsObsolete() const {
return mIsObsolete;
}
// Set to true to make the contact point obsolete
/**
* @param isObsolete True if the contact is obsolete
*/
inline void ContactPoint::setIsObsolete(bool isObsolete) {
mIsObsolete = isObsolete;
}
// Return the next contact point in the linked list
/**
* @return A pointer to the next contact point in the linked-list of points
*/
inline ContactPoint* ContactPoint::getNext() const {
return mNext;
}
// Set the next contact point in the linked list
/**
* @param next Pointer to the next contact point in the linked-list of points
*/
inline void ContactPoint::setNext(ContactPoint* next) {
mNext = next;
}
// Return the previous contact point in the linked list
/**
* @return A pointer to the previous contact point in the linked-list of points
*/
inline ContactPoint* ContactPoint::getPrevious() const {
return mPrevious;
}
// Set the previous contact point in the linked list
/**
* @param previous Pointer to the previous contact point in the linked-list of points
*/
inline void ContactPoint::setPrevious(ContactPoint* previous) {
mPrevious = previous;
}
// Return the penetration depth of the contact
/**
* @return the penetration depth (in meters)

74
src/constraint/FixedJoint.h → include/reactphysics3d/constraint/FixedJoint.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_FIXED_JOINT_H
// Libraries
#include "Joint.h"
#include "mathematics/mathematics.h"
#include <reactphysics3d/constraint/Joint.h>
#include <reactphysics3d/mathematics/mathematics.h>
namespace reactphysics3d {
@ -68,75 +68,17 @@ class FixedJoint : public Joint {
private :
// -------------------- Constants -------------------- //
// Beta value for the bias factor of position correction
static const decimal BETA;
// -------------------- Attributes -------------------- //
/// Anchor point of body 1 (in local-space coordinates of body 1)
Vector3 mLocalAnchorPointBody1;
/// Anchor point of body 2 (in local-space coordinates of body 2)
Vector3 mLocalAnchorPointBody2;
/// Vector from center of body 2 to anchor point in world-space
Vector3 mR1World;
/// Vector from center of body 2 to anchor point in world-space
Vector3 mR2World;
/// Inertia tensor of body 1 (in world-space coordinates)
Matrix3x3 mI1;
/// Inertia tensor of body 2 (in world-space coordinates)
Matrix3x3 mI2;
/// Accumulated impulse for the 3 translation constraints
Vector3 mImpulseTranslation;
/// Accumulate impulse for the 3 rotation constraints
Vector3 mImpulseRotation;
/// Inverse mass matrix K=JM^-1J^-t of the 3 translation constraints (3x3 matrix)
Matrix3x3 mInverseMassMatrixTranslation;
/// Inverse mass matrix K=JM^-1J^-t of the 3 rotation constraints (3x3 matrix)
Matrix3x3 mInverseMassMatrixRotation;
/// Bias vector for the 3 translation constraints
Vector3 mBiasTranslation;
/// Bias vector for the 3 rotation constraints
Vector3 mBiasRotation;
/// Inverse of the initial orientation difference between the two bodies
Quaternion mInitOrientationDifferenceInv;
// -------------------- Methods -------------------- //
/// Return the number of bytes used by the joint
virtual size_t getSizeInBytes() const override;
/// Initialize before solving the constraint
virtual void initBeforeSolve(const ConstraintSolverData& constraintSolverData) override;
/// Warm start the constraint (apply the previous impulse at the beginning of the step)
virtual void warmstart(const ConstraintSolverData& constraintSolverData) override;
/// Solve the velocity constraint
virtual void solveVelocityConstraint(const ConstraintSolverData& constraintSolverData) override;
/// Solve the position constraint (for position error correction)
virtual void solvePositionConstraint(const ConstraintSolverData& constraintSolverData) override;
public :
// -------------------- Methods -------------------- //
/// Constructor
FixedJoint(uint id, const FixedJointInfo& jointInfo);
FixedJoint(Entity entity, PhysicsWorld& world, const FixedJointInfo& jointInfo);
/// Destructor
virtual ~FixedJoint() override = default;
@ -156,14 +98,6 @@ inline size_t FixedJoint::getSizeInBytes() const {
return sizeof(FixedJoint);
}
// Return a string representation
inline std::string FixedJoint::to_string() const {
return "FixedJoint{ localAnchorPointBody1=" + mLocalAnchorPointBody1.to_string() +
", localAnchorPointBody2=" + mLocalAnchorPointBody2.to_string() +
", initOrientationDifferenceInv=" + mInitOrientationDifferenceInv.to_string() +
"}";
}
}
#endif

207
src/constraint/HingeJoint.h → include/reactphysics3d/constraint/HingeJoint.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_HINGE_JOINT_H
// Libraries
#include "Joint.h"
#include "mathematics/mathematics.h"
#include <reactphysics3d/constraint/Joint.h>
#include <reactphysics3d/mathematics/mathematics.h>
namespace reactphysics3d {
@ -144,150 +144,23 @@ class HingeJoint : public Joint {
// -------------------- Constants -------------------- //
// Beta value for the bias factor of position correction
static const decimal BETA;
// -------------------- Attributes -------------------- //
/// Anchor point of body 1 (in local-space coordinates of body 1)
Vector3 mLocalAnchorPointBody1;
/// Anchor point of body 2 (in local-space coordinates of body 2)
Vector3 mLocalAnchorPointBody2;
/// Hinge rotation axis (in local-space coordinates of body 1)
Vector3 mHingeLocalAxisBody1;
/// Hinge rotation axis (in local-space coordiantes of body 2)
Vector3 mHingeLocalAxisBody2;
/// Inertia tensor of body 1 (in world-space coordinates)
Matrix3x3 mI1;
/// Inertia tensor of body 2 (in world-space coordinates)
Matrix3x3 mI2;
/// Hinge rotation axis (in world-space coordinates) computed from body 1
Vector3 mA1;
/// Vector from center of body 2 to anchor point in world-space
Vector3 mR1World;
/// Vector from center of body 2 to anchor point in world-space
Vector3 mR2World;
/// Cross product of vector b2 and a1
Vector3 mB2CrossA1;
/// Cross product of vector c2 and a1;
Vector3 mC2CrossA1;
/// Impulse for the 3 translation constraints
Vector3 mImpulseTranslation;
/// Impulse for the 2 rotation constraints
Vector2 mImpulseRotation;
/// Accumulated impulse for the lower limit constraint
decimal mImpulseLowerLimit;
/// Accumulated impulse for the upper limit constraint
decimal mImpulseUpperLimit;
/// Accumulated impulse for the motor constraint;
decimal mImpulseMotor;
/// Inverse mass matrix K=JM^-1J^t for the 3 translation constraints
Matrix3x3 mInverseMassMatrixTranslation;
/// Inverse mass matrix K=JM^-1J^t for the 2 rotation constraints
Matrix2x2 mInverseMassMatrixRotation;
/// Inverse of mass matrix K=JM^-1J^t for the limits and motor constraints (1x1 matrix)
decimal mInverseMassMatrixLimitMotor;
/// Inverse of mass matrix K=JM^-1J^t for the motor
decimal mInverseMassMatrixMotor;
/// Bias vector for the error correction for the translation constraints
Vector3 mBTranslation;
/// Bias vector for the error correction for the rotation constraints
Vector2 mBRotation;
/// Bias of the lower limit constraint
decimal mBLowerLimit;
/// Bias of the upper limit constraint
decimal mBUpperLimit;
/// Inverse of the initial orientation difference between the bodies
Quaternion mInitOrientationDifferenceInv;
/// True if the joint limits are enabled
bool mIsLimitEnabled;
/// True if the motor of the joint in enabled
bool mIsMotorEnabled;
/// Lower limit (minimum allowed rotation angle in radian)
decimal mLowerLimit;
/// Upper limit (maximum translation distance)
decimal mUpperLimit;
/// True if the lower limit is violated
bool mIsLowerLimitViolated;
/// True if the upper limit is violated
bool mIsUpperLimitViolated;
/// Motor speed (in rad/s)
decimal mMotorSpeed;
/// Maximum motor torque (in Newtons) that can be applied to reach to desired motor speed
decimal mMaxMotorTorque;
// -------------------- Methods -------------------- //
/// Reset the limits
void resetLimits();
/// Given an angle in radian, this method returns the corresponding
/// angle in the range [-pi; pi]
decimal computeNormalizedAngle(decimal angle) const;
/// Given an "inputAngle" in the range [-pi, pi], this method returns an
/// angle (modulo 2*pi) in the range [-2*pi; 2*pi] that is closest to one of the
/// two angle limits in arguments.
decimal computeCorrespondingAngleNearLimits(decimal inputAngle, decimal lowerLimitAngle,
decimal upperLimitAngle) const;
/// Compute the current angle around the hinge axis
decimal computeCurrentHingeAngle(const Quaternion& orientationBody1,
const Quaternion& orientationBody2);
/// Return the number of bytes used by the joint
virtual size_t getSizeInBytes() const override;
/// Initialize before solving the constraint
virtual void initBeforeSolve(const ConstraintSolverData& constraintSolverData) override;
/// Warm start the constraint (apply the previous impulse at the beginning of the step)
virtual void warmstart(const ConstraintSolverData& constraintSolverData) override;
/// Solve the velocity constraint
virtual void solveVelocityConstraint(const ConstraintSolverData& constraintSolverData) override;
/// Solve the position constraint (for position error correction)
virtual void solvePositionConstraint(const ConstraintSolverData& constraintSolverData) override;
public :
// -------------------- Methods -------------------- //
/// Constructor
HingeJoint(uint id, const HingeJointInfo& jointInfo);
HingeJoint(Entity entity, PhysicsWorld& world, const HingeJointInfo& jointInfo);
/// Destructor
virtual ~HingeJoint() override = default;
@ -341,78 +214,6 @@ class HingeJoint : public Joint {
virtual std::string to_string() const override;
};
// Return true if the limits of the joint are enabled
/**
* @return True if the limits of the joint are enabled and false otherwise
*/
inline bool HingeJoint::isLimitEnabled() const {
return mIsLimitEnabled;
}
// Return true if the motor of the joint is enabled
/**
* @return True if the motor of joint is enabled and false otherwise
*/
inline bool HingeJoint::isMotorEnabled() const {
return mIsMotorEnabled;
}
// Return the minimum angle limit
/**
* @return The minimum limit angle of the joint (in radian)
*/
inline decimal HingeJoint::getMinAngleLimit() const {
return mLowerLimit;
}
// Return the maximum angle limit
/**
* @return The maximum limit angle of the joint (in radian)
*/
inline decimal HingeJoint::getMaxAngleLimit() const {
return mUpperLimit;
}
// Return the motor speed
/**
* @return The current speed of the joint motor (in radian per second)
*/
inline decimal HingeJoint::getMotorSpeed() const {
return mMotorSpeed;
}
// Return the maximum motor torque
/**
* @return The maximum torque of the joint motor (in Newtons)
*/
inline decimal HingeJoint::getMaxMotorTorque() const {
return mMaxMotorTorque;
}
// Return the intensity of the current torque applied for the joint motor
/**
* @param timeStep The current time step (in seconds)
* @return The intensity of the current torque (in Newtons) of the joint motor
*/
inline decimal HingeJoint::getMotorTorque(decimal timeStep) const {
return mImpulseMotor / timeStep;
}
// Return the number of bytes used by the joint
inline size_t HingeJoint::getSizeInBytes() const {
return sizeof(HingeJoint);
}
// Return a string representation
inline std::string HingeJoint::to_string() const {
return "HingeJoint{ lowerLimit=" + std::to_string(mLowerLimit) + ", upperLimit=" + std::to_string(mUpperLimit) +
"localAnchorPointBody1=" + mLocalAnchorPointBody1.to_string() + ", localAnchorPointBody2=" +
mLocalAnchorPointBody2.to_string() + ", hingeLocalAxisBody1=" + mHingeLocalAxisBody1.to_string() +
", hingeLocalAxisBody2=" + mHingeLocalAxisBody2.to_string() + ", initOrientationDifferenceInv=" +
mInitOrientationDifferenceInv.to_string() + ", motorSpeed=" + std::to_string(mMotorSpeed) +
", maxMotorTorque=" + std::to_string(mMaxMotorTorque) + ", isLimitEnabled=" +
(mIsLimitEnabled ? "true" : "false") + ", isMotorEnabled=" + (mIsMotorEnabled ? "true" : "false") + "}";
}
}

153
src/constraint/Joint.h → include/reactphysics3d/constraint/Joint.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,9 +27,9 @@
#define REACTPHYSICS3D_CONSTRAINT_H
// Libraries
#include "configuration.h"
#include "body/RigidBody.h"
#include "mathematics/mathematics.h"
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/body/RigidBody.h>
#include <reactphysics3d/mathematics/mathematics.h>
// ReactPhysics3D namespace
namespace reactphysics3d {
@ -40,31 +40,7 @@ enum class JointType {BALLSOCKETJOINT, SLIDERJOINT, HINGEJOINT, FIXEDJOINT};
// Class declarations
struct ConstraintSolverData;
class Joint;
// Structure JointListElement
/**
* This structure represents a single element of a linked list of joints
*/
struct JointListElement {
public:
// -------------------- Attributes -------------------- //
/// Pointer to the actual joint
Joint* joint;
/// Next element of the list
JointListElement* next;
// -------------------- Methods -------------------- //
/// Constructor
JointListElement(Joint* initJoint, JointListElement* initNext)
:joint(initJoint), next(initNext){
}
};
class RigidBody;
// Structure JointInfo
/**
@ -96,7 +72,9 @@ struct JointInfo {
JointInfo(JointType constraintType)
: body1(nullptr), body2(nullptr), type(constraintType),
positionCorrectionTechnique(JointsPositionCorrectionTechnique::NON_LINEAR_GAUSS_SEIDEL),
isCollisionEnabled(true) {}
isCollisionEnabled(true) {
}
/// Constructor
JointInfo(RigidBody* rigidBody1, RigidBody* rigidBody2, JointType constraintType)
@ -120,62 +98,26 @@ class Joint {
// -------------------- Attributes -------------------- //
/// Id of the joint
uint mId;
/// Entity ID of the joint
Entity mEntity;
/// Pointer to the first body of the joint
RigidBody* const mBody1;
/// Pointer to the second body of the joint
RigidBody* const mBody2;
/// Type of the joint
const JointType mType;
/// Body 1 index in the velocity array to solve the constraint
uint mIndexBody1;
/// Body 2 index in the velocity array to solve the constraint
uint mIndexBody2;
/// Position correction technique used for the constraint (used for joints)
JointsPositionCorrectionTechnique mPositionCorrectionTechnique;
/// True if the two bodies of the constraint are allowed to collide with each other
bool mIsCollisionEnabled;
/// True if the joint has already been added into an island
bool mIsAlreadyInIsland;
/// Total number of joints
static uint mNbTotalNbJoints;
/// Reference to the physics world
PhysicsWorld& mWorld;
// -------------------- Methods -------------------- //
/// Return true if the joint has already been added into an island
bool isAlreadyInIsland() const;
/// Return the number of bytes used by the joint
virtual size_t getSizeInBytes() const = 0;
/// Initialize before solving the joint
virtual void initBeforeSolve(const ConstraintSolverData& constraintSolverData) = 0;
/// Warm start the joint (apply the previous impulse at the beginning of the step)
virtual void warmstart(const ConstraintSolverData& constraintSolverData) = 0;
/// Solve the velocity constraint
virtual void solveVelocityConstraint(const ConstraintSolverData& constraintSolverData) = 0;
/// Solve the position constraint
virtual void solvePositionConstraint(const ConstraintSolverData& constraintSolverData) = 0;
/// Awake the two bodies of the joint
void awakeBodies() const;
public :
// -------------------- Methods -------------------- //
/// Constructor
Joint(uint id, const JointInfo& jointInfo);
Joint(Entity entity, PhysicsWorld& world);
/// Destructor
virtual ~Joint() = default;
@ -192,80 +134,31 @@ class Joint {
/// Return the reference to the body 2
RigidBody* getBody2() const;
/// Return true if the constraint is active
bool isActive() const;
/// Return the type of the constraint
JointType getType() const;
/// Return true if the collision between the two bodies of the joint is enabled
bool isCollisionEnabled() const;
/// Return the id of the joint
uint getId() const;
/// Return the entity id of the joint
Entity getEntity() const;
/// Return a string representation
virtual std::string to_string() const=0;
// -------------------- Friendship -------------------- //
friend class DynamicsWorld;
friend class PhysicsWorld;
friend class Island;
friend class ConstraintSolver;
friend class ConstraintSolverSystem;
};
// Return the reference to the body 1
// Return the entity id of the joint
/**
* @return The first body involved in the joint
* @return The entity of the joint
*/
inline RigidBody* Joint::getBody1() const {
return mBody1;
}
// Return the reference to the body 2
/**
* @return The second body involved in the joint
*/
inline RigidBody* Joint::getBody2() const {
return mBody2;
}
// Return true if the joint is active
/**
* @return True if the joint is active
*/
inline bool Joint::isActive() const {
return (mBody1->isActive() && mBody2->isActive());
}
// Return the type of the joint
/**
* @return The type of the joint
*/
inline JointType Joint::getType() const {
return mType;
}
// Return true if the collision between the two bodies of the joint is enabled
/**
* @return True if the collision is enabled between the two bodies of the joint
* is enabled and false otherwise
*/
inline bool Joint::isCollisionEnabled() const {
return mIsCollisionEnabled;
}
// Return the id of the joint
/**
* @return The id of the joint
*/
inline uint Joint::getId() const {
return mId;
}
// Return true if the joint has already been added into an island
inline bool Joint::isAlreadyInIsland() const {
return mIsAlreadyInIsland;
inline Entity Joint::getEntity() const {
return mEntity;
}
}

206
src/constraint/SliderJoint.h → include/reactphysics3d/constraint/SliderJoint.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,14 +27,14 @@
#define REACTPHYSICS3D_SLIDER_JOINT_H
// Libraries
#include "mathematics/mathematics.h"
#include "body/RigidBody.h"
#include "Joint.h"
#include <reactphysics3d/mathematics/mathematics.h>
#include <reactphysics3d/body/RigidBody.h>
#include <reactphysics3d/constraint/Joint.h>
namespace reactphysics3d {
// Declarations
class ConstraintSolver;
class ConstraintSolverSystem;
// Structure SliderJointInfo
/**
@ -150,120 +150,6 @@ class SliderJoint : public Joint {
// -------------------- Attributes -------------------- //
/// Anchor point of body 1 (in local-space coordinates of body 1)
Vector3 mLocalAnchorPointBody1;
/// Anchor point of body 2 (in local-space coordinates of body 2)
Vector3 mLocalAnchorPointBody2;
/// Slider axis (in local-space coordinates of body 1)
Vector3 mSliderAxisBody1;
/// Inertia tensor of body 1 (in world-space coordinates)
Matrix3x3 mI1;
/// Inertia tensor of body 2 (in world-space coordinates)
Matrix3x3 mI2;
/// Inverse of the initial orientation difference between the two bodies
Quaternion mInitOrientationDifferenceInv;
/// First vector orthogonal to the slider axis local-space of body 1
Vector3 mN1;
/// Second vector orthogonal to the slider axis and mN1 in local-space of body 1
Vector3 mN2;
/// Vector r1 in world-space coordinates
Vector3 mR1;
/// Vector r2 in world-space coordinates
Vector3 mR2;
/// Cross product of r2 and n1
Vector3 mR2CrossN1;
/// Cross product of r2 and n2
Vector3 mR2CrossN2;
/// Cross product of r2 and the slider axis
Vector3 mR2CrossSliderAxis;
/// Cross product of vector (r1 + u) and n1
Vector3 mR1PlusUCrossN1;
/// Cross product of vector (r1 + u) and n2
Vector3 mR1PlusUCrossN2;
/// Cross product of vector (r1 + u) and the slider axis
Vector3 mR1PlusUCrossSliderAxis;
/// Bias of the 2 translation constraints
Vector2 mBTranslation;
/// Bias of the 3 rotation constraints
Vector3 mBRotation;
/// Bias of the lower limit constraint
decimal mBLowerLimit;
/// Bias of the upper limit constraint
decimal mBUpperLimit;
/// Inverse of mass matrix K=JM^-1J^t for the translation constraint (2x2 matrix)
Matrix2x2 mInverseMassMatrixTranslationConstraint;
/// Inverse of mass matrix K=JM^-1J^t for the rotation constraint (3x3 matrix)
Matrix3x3 mInverseMassMatrixRotationConstraint;
/// Inverse of mass matrix K=JM^-1J^t for the upper and lower limit constraints (1x1 matrix)
decimal mInverseMassMatrixLimit;
/// Inverse of mass matrix K=JM^-1J^t for the motor
decimal mInverseMassMatrixMotor;
/// Accumulated impulse for the 2 translation constraints
Vector2 mImpulseTranslation;
/// Accumulated impulse for the 3 rotation constraints
Vector3 mImpulseRotation;
/// Accumulated impulse for the lower limit constraint
decimal mImpulseLowerLimit;
/// Accumulated impulse for the upper limit constraint
decimal mImpulseUpperLimit;
/// Accumulated impulse for the motor
decimal mImpulseMotor;
/// True if the slider limits are enabled
bool mIsLimitEnabled;
/// True if the motor of the joint in enabled
bool mIsMotorEnabled;
/// Slider axis in world-space coordinates
Vector3 mSliderAxisWorld;
/// Lower limit (minimum translation distance)
decimal mLowerLimit;
/// Upper limit (maximum translation distance)
decimal mUpperLimit;
/// True if the lower limit is violated
bool mIsLowerLimitViolated;
/// True if the upper limit is violated
bool mIsUpperLimitViolated;
/// Motor speed (in m/s)
decimal mMotorSpeed;
/// Maximum motor force (in Newtons) that can be applied to reach to desired motor speed
decimal mMaxMotorForce;
// -------------------- Methods -------------------- //
/// Reset the limits
@ -272,24 +158,12 @@ class SliderJoint : public Joint {
/// Return the number of bytes used by the joint
virtual size_t getSizeInBytes() const override;
/// Initialize before solving the constraint
virtual void initBeforeSolve(const ConstraintSolverData& constraintSolverData) override;
/// Warm start the constraint (apply the previous impulse at the beginning of the step)
virtual void warmstart(const ConstraintSolverData& constraintSolverData) override;
/// Solve the velocity constraint
virtual void solveVelocityConstraint(const ConstraintSolverData& constraintSolverData) override;
/// Solve the position constraint (for position error correction)
virtual void solvePositionConstraint(const ConstraintSolverData& constraintSolverData) override;
public :
// -------------------- Methods -------------------- //
/// Constructor
SliderJoint(uint id, const SliderJointInfo& jointInfo);
SliderJoint(Entity entity, PhysicsWorld& world, const SliderJointInfo& jointInfo);
/// Destructor
virtual ~SliderJoint() override = default;
@ -346,79 +220,11 @@ class SliderJoint : public Joint {
virtual std::string to_string() const override;
};
// Return true if the limits or the joint are enabled
/**
* @return True if the joint limits are enabled
*/
inline bool SliderJoint::isLimitEnabled() const {
return mIsLimitEnabled;
}
// Return true if the motor of the joint is enabled
/**
* @return True if the joint motor is enabled
*/
inline bool SliderJoint::isMotorEnabled() const {
return mIsMotorEnabled;
}
// Return the minimum translation limit
/**
* @return The minimum translation limit of the joint (in meters)
*/
inline decimal SliderJoint::getMinTranslationLimit() const {
return mLowerLimit;
}
// Return the maximum translation limit
/**
* @return The maximum translation limit of the joint (in meters)
*/
inline decimal SliderJoint::getMaxTranslationLimit() const {
return mUpperLimit;
}
// Return the motor speed
/**
* @return The current motor speed of the joint (in meters per second)
*/
inline decimal SliderJoint::getMotorSpeed() const {
return mMotorSpeed;
}
// Return the maximum motor force
/**
* @return The maximum force of the joint motor (in Newton x meters)
*/
inline decimal SliderJoint::getMaxMotorForce() const {
return mMaxMotorForce;
}
// Return the intensity of the current force applied for the joint motor
/**
* @param timeStep Time step (in seconds)
* @return The current force of the joint motor (in Newton x meters)
*/
inline decimal SliderJoint::getMotorForce(decimal timeStep) const {
return mImpulseMotor / timeStep;
}
// Return the number of bytes used by the joint
inline size_t SliderJoint::getSizeInBytes() const {
return sizeof(SliderJoint);
}
// Return a string representation
inline std::string SliderJoint::to_string() const {
return "SliderJoint{ lowerLimit=" + std::to_string(mLowerLimit) + ", upperLimit=" + std::to_string(mUpperLimit) +
"localAnchorPointBody1=" + mLocalAnchorPointBody1.to_string() + ", localAnchorPointBody2=" +
mLocalAnchorPointBody2.to_string() + ", sliderAxisBody1=" + mSliderAxisBody1.to_string() +
", initOrientationDifferenceInv=" +
mInitOrientationDifferenceInv.to_string() + ", motorSpeed=" + std::to_string(mMotorSpeed) +
", maxMotorForce=" + std::to_string(mMaxMotorForce) + ", isLimitEnabled=" +
(mIsLimitEnabled ? "true" : "false") + ", isMotorEnabled=" + (mIsMotorEnabled ? "true" : "false") + "}";
}
}
#endif

617
include/reactphysics3d/containers/Deque.h Normal file
View File

@ -0,0 +1,617 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_DEQUE_H
#define REACTPHYSICS3D_DEQUE_H
// Libraries
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/memory/MemoryAllocator.h>
#include <cassert>
#include <cmath>
#include <cstring>
#include <iterator>
#include <memory>
namespace reactphysics3d {
// Class Deque
/**
* This class represents a Deque. A Deque is a double ended queue. It is possible to
* push and pop items at both ends of the queue. Note that in the following code, the
* virtualIndex is the index of the items in the deque in range [0, mSize-1] where
* 0 is always the front item and mSize-1 the back item. There is a virtual index for
* each item that is in the deque. The allocatedIndex is the index of a allocated slot in the
* deque in range [0, (mNbChunks * CHUNK_NB_ITEMS)-1]. A given allocatedIndex corresponds to a slot
* in the deque that can be empty or contains an item.
*/
template<typename T>
class Deque {
private:
// -------------------- Constants -------------------- //
/// Number of items in a chunk
const uint CHUNK_NB_ITEMS = 17;
/// First item index in a chunk
const uint CHUNK_FIRST_ITEM_INDEX = CHUNK_NB_ITEMS / 2;
// -------------------- Attributes -------------------- //
/// Array of chunks
T** mChunks;
/// Number of current elements in the deque
size_t mSize;
/// Number of chunks
size_t mNbChunks;
/// Index of the chunk with the first element of the deque
size_t mFirstChunkIndex;
/// Index of the chunk with the last element of the deque
size_t mLastChunkIndex;
/// Index of the first element in the first chunk
uint8 mFirstItemIndex;
/// Index of the last element in the last chunk
uint8 mLastItemIndex;
/// Memory allocator
MemoryAllocator& mAllocator;
// -------------------- Methods -------------------- //
/// Return a reference to an item at the given virtual index in range [0; mSize-1]
T& getItem(size_t virtualIndex) const {
// If the virtual index is valid
if (virtualIndex < mSize) {
size_t chunkIndex = mFirstChunkIndex;
size_t itemIndex = mFirstItemIndex;
const size_t nbItemsFirstChunk = CHUNK_NB_ITEMS - mFirstItemIndex;
if (virtualIndex < nbItemsFirstChunk) {
itemIndex += virtualIndex;
}
else {
virtualIndex -= nbItemsFirstChunk;
chunkIndex++;
chunkIndex += virtualIndex / CHUNK_NB_ITEMS;
itemIndex = virtualIndex % CHUNK_NB_ITEMS;
}
return mChunks[chunkIndex][itemIndex];
}
else {
assert(false);
}
}
/// Add more chunks
void expandChunks(size_t atLeastNbChunks = 0) {
// If it is not necessary to expand the chunks
if (atLeastNbChunks > 0 && atLeastNbChunks <= mNbChunks) {
return;
}
size_t newNbChunks = mNbChunks == 0 ? 3 : 2 * mNbChunks - 1;
if (atLeastNbChunks > 0 && newNbChunks < atLeastNbChunks) {
newNbChunks = size_t(atLeastNbChunks / 2) * 2 + 1;
}
const size_t halfNbChunksToAdd = mNbChunks == 0 ? 1 : (mNbChunks - 1) / 2;
// Allocate memory for the new array of pointers to chunk
void* newMemory = mAllocator.allocate(newNbChunks * sizeof(T*));
assert(newMemory != nullptr);
T** newChunks = static_cast<T**>(newMemory);
// If chunks have already been allocated
if (mNbChunks > 0) {
// Copy the pointers to the previous chunks to the new allocated memory location
std::uninitialized_copy(mChunks, mChunks + mNbChunks, newChunks + halfNbChunksToAdd);
// Release the previously allocated memory
mAllocator.release(mChunks, mNbChunks * sizeof(T*));
}
mChunks = newChunks;
// If we need to allocate the first chunk (in the middle of the chunks array)
if (mNbChunks == 0) {
mChunks[newNbChunks / 2] = static_cast<T*>(mAllocator.allocate(sizeof(T) * CHUNK_NB_ITEMS));
assert(mChunks[newNbChunks / 2] != nullptr);
}
mNbChunks = newNbChunks;
// Allocate memory for each new chunk
for (size_t i=0; i < halfNbChunksToAdd; i++) {
// Allocate memory for the new chunk
mChunks[i] = static_cast<T*>(mAllocator.allocate(sizeof(T) * CHUNK_NB_ITEMS));
assert(mChunks[i] != nullptr);
mChunks[mNbChunks - 1 - i] = static_cast<T*>(mAllocator.allocate(sizeof(T) * CHUNK_NB_ITEMS));
assert(mChunks[mNbChunks - 1 -i] != nullptr);
}
// Update the first and last chunk index
mFirstChunkIndex += halfNbChunksToAdd;
mLastChunkIndex += halfNbChunksToAdd;
}
public:
/// Class Iterator
/**
* This class represents an iterator for the Deque
*/
class Iterator {
private:
size_t mVirtualIndex;
const Deque<T>* mDeque;
public:
// Iterator traits
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = T*;
using const_pointer = T const*;
using reference = T&;
using const_reference = const T&;
using iterator_category = std::random_access_iterator_tag;
/// Constructor
Iterator() = default;
/// Constructor
Iterator(const Deque<T>* deque, size_t virtualIndex) : mVirtualIndex(virtualIndex), mDeque(deque) {
}
/// Copy constructor
Iterator(const Iterator& it) : mVirtualIndex(it.mVirtualIndex), mDeque(it.mDeque) {
}
/// Deferencable
reference operator*() {
assert(mVirtualIndex < mDeque->mSize);
return mDeque->getItem(mVirtualIndex);
}
/// Const Deferencable
const_reference operator*() const {
assert(mVirtualIndex < mDeque->mSize);
return mDeque->getItem(mVirtualIndex);
}
/// Deferencable
const_pointer operator->() const {
assert(mVirtualIndex < mDeque->mSize);
return &(mDeque->getItem(mVirtualIndex));
}
/// Post increment (it++)
Iterator& operator++() {
assert(mVirtualIndex < mDeque->mSize);
mVirtualIndex++;
return *this;
}
/// Pre increment (++it)
Iterator operator++(int number) {
assert(mVirtualIndex < mDeque->mSize);
Iterator tmp = *this;
mVirtualIndex++;
return tmp;
}
/// Post decrement (it--)
Iterator& operator--() {
mVirtualIndex--;
return *this;
}
/// Pre decrement (--it)
Iterator operator--(int number) {
Iterator tmp = *this;
mVirtualIndex--;
return tmp;
}
/// Plus operator
Iterator operator+(const difference_type& n) {
return Iterator(mDeque, mVirtualIndex + n);
}
/// Plus operator
Iterator& operator+=(const difference_type& n) {
mVirtualIndex += n;
return *this;
}
/// Minus operator
Iterator operator-(const difference_type& n) {
return Iterator(mDeque, mVirtualIndex - n);
}
/// Minus operator
Iterator& operator-=(const difference_type& n) {
mVirtualIndex -= n;
return *this;
}
/// Difference operator
difference_type operator-(const Iterator& iterator) const {
return mVirtualIndex - iterator.mVirtualIndex;
}
/// Comparison operator
bool operator<(const Iterator& other) const {
return mVirtualIndex < other.mVirtualIndex;
}
/// Comparison operator
bool operator>(const Iterator& other) const {
return mVirtualIndex > other.mVirtualIndex;
}
/// Comparison operator
bool operator<=(const Iterator& other) const {
return mVirtualIndex <= other.mVirtualIndex;
}
/// Comparison operator
bool operator>=(const Iterator& other) const {
return mVirtualIndex >= other.mVirtualIndex;
}
/// Equality operator (it == end())
bool operator==(const Iterator& iterator) const {
return mVirtualIndex == iterator.mVirtualIndex;
}
/// Inequality operator (it != end())
bool operator!=(const Iterator& iterator) const {
return !(*this == iterator);
}
/// Frienship
friend class Deque;
};
// -------------------- Methods -------------------- //
/// Constructor
Deque(MemoryAllocator& allocator)
: mChunks(nullptr), mSize(0), mNbChunks(0), mFirstChunkIndex(1),
mLastChunkIndex(1), mFirstItemIndex(CHUNK_FIRST_ITEM_INDEX),
mLastItemIndex(CHUNK_FIRST_ITEM_INDEX), mAllocator(allocator) {
// Allocate memory for the chunks array
expandChunks();
}
/// Copy constructor
Deque(const Deque<T>& deque)
: mSize(0), mNbChunks(0), mFirstChunkIndex(1),
mLastChunkIndex(1), mFirstItemIndex(CHUNK_FIRST_ITEM_INDEX),
mLastItemIndex(CHUNK_FIRST_ITEM_INDEX), mAllocator(deque.mAllocator) {
// Allocate memory for the array of chunks
expandChunks(deque.mNbChunks);
if (deque.mSize > 0) {
const size_t dequeHalfSize1 = std::ceil(deque.mSize / 2.0f);
const size_t dequeHalfSize2 = deque.mSize - dequeHalfSize1;
// Add the items into the deque
for(size_t i=0; i < dequeHalfSize1; i++) {
addFront(deque[dequeHalfSize1 - 1 - i]);
}
for(size_t i=0; i < dequeHalfSize2; i++) {
addBack(deque[dequeHalfSize1 + i]);
}
}
}
/// Destructor
~Deque() {
clear();
// Release each chunk
for (size_t i=0; i < mNbChunks; i++) {
mAllocator.release(mChunks[i], sizeof(T) * CHUNK_NB_ITEMS);
}
// Release the chunks array
mAllocator.release(mChunks, sizeof(T*) * mNbChunks);
}
/// Add an element at the end of the deque
void addBack(const T& element) {
// If we need to add the item in a another chunk
if (mLastItemIndex == CHUNK_NB_ITEMS - 1) {
// If we need to add more chunks
if (mLastChunkIndex == mNbChunks - 1) {
// Add more chunks
expandChunks();
}
mLastItemIndex = 0;
mLastChunkIndex++;
}
else if (mSize != 0) {
mLastItemIndex++;
}
// Construct the element at its location in the chunk
new (static_cast<void*>(&(mChunks[mLastChunkIndex][mLastItemIndex]))) T(element);
mSize++;
assert(mFirstChunkIndex >= 0 && mLastChunkIndex < mNbChunks);
assert(mFirstItemIndex >= 0 && mFirstItemIndex < CHUNK_NB_ITEMS);
assert(mLastItemIndex >= 0 && mLastItemIndex < CHUNK_NB_ITEMS);
assert(mFirstChunkIndex <= mLastChunkIndex);
}
/// Add an element at the front of the deque
void addFront(const T& element) {
// If we need to add the item in another chunk
if (mFirstItemIndex == 0) {
// If we need to add more chunks
if (mFirstChunkIndex == 0) {
// Add more chunks
expandChunks();
}
mFirstItemIndex = CHUNK_NB_ITEMS - 1;
mFirstChunkIndex--;
}
else if (mSize != 0) {
mFirstItemIndex--;
}
// Construct the element at its location in the chunk
new (static_cast<void*>(&(mChunks[mFirstChunkIndex][mFirstItemIndex]))) T(element);
mSize++;
assert(mFirstChunkIndex >= 0 && mLastChunkIndex < mNbChunks);
assert(mFirstItemIndex >= 0 && mFirstItemIndex < CHUNK_NB_ITEMS);
assert(mLastItemIndex >= 0 && mLastItemIndex < CHUNK_NB_ITEMS);
assert(mFirstChunkIndex <= mLastChunkIndex);
}
/// Remove the first element of the deque
void popFront() {
if (mSize > 0) {
// Call the destructor of the first element
mChunks[mFirstChunkIndex][mFirstItemIndex].~T();
mSize--;
if (mSize == 0) {
mFirstChunkIndex = mNbChunks / 2;
mFirstItemIndex = CHUNK_FIRST_ITEM_INDEX;
mLastChunkIndex = mFirstChunkIndex;
mLastItemIndex = CHUNK_FIRST_ITEM_INDEX;
}
else if (mFirstItemIndex == CHUNK_NB_ITEMS - 1){
mFirstChunkIndex++;
mFirstItemIndex = 0;
}
else {
mFirstItemIndex++;
}
assert(mFirstChunkIndex >= 0 && mLastChunkIndex < mNbChunks);
assert(mFirstItemIndex >= 0 && mFirstItemIndex < CHUNK_NB_ITEMS);
assert(mLastItemIndex >= 0 && mLastItemIndex < CHUNK_NB_ITEMS);
assert(mFirstChunkIndex <= mLastChunkIndex);
}
}
/// Remove the last element of the deque
void popBack() {
if (mSize > 0) {
// Call the destructor of the last element
mChunks[mLastChunkIndex][mLastItemIndex].~T();
mSize--;
if (mSize == 0) {
mFirstChunkIndex = mNbChunks / 2;
mFirstItemIndex = CHUNK_FIRST_ITEM_INDEX;
mLastChunkIndex = mFirstChunkIndex;
mLastItemIndex = CHUNK_FIRST_ITEM_INDEX;
}
else if (mLastItemIndex == 0){
mLastChunkIndex--;
mLastItemIndex = CHUNK_NB_ITEMS - 1;
}
else {
mLastItemIndex--;
}
assert(mFirstChunkIndex >= 0 && mLastChunkIndex < mNbChunks);
assert(mFirstItemIndex >= 0 && mFirstItemIndex < CHUNK_NB_ITEMS);
assert(mLastItemIndex >= 0 && mLastItemIndex < CHUNK_NB_ITEMS);
assert(mFirstChunkIndex <= mLastChunkIndex);
}
}
/// Return a reference to the first item of the deque
const T& getFront() const {
if (mSize > 0) {
return mChunks[mFirstChunkIndex][mFirstItemIndex];
}
assert(false);
}
/// Return a reference to the last item of the deque
const T& getBack() const {
if (mSize > 0) {
return mChunks[mLastChunkIndex][mLastItemIndex];
}
assert(false);
}
/// Clear the elements of the deque
void clear() {
if (mSize > 0) {
// Call the destructor of every items
for (size_t i=0; i < mSize; i++) {
getItem(i).~T();
}
mSize = 0;
mFirstChunkIndex = mNbChunks / 2;
mLastChunkIndex = mFirstChunkIndex;
mFirstItemIndex = CHUNK_FIRST_ITEM_INDEX;
mLastItemIndex = CHUNK_FIRST_ITEM_INDEX;
}
}
/// Return the number of elements in the deque
size_t size() const {
return mSize;
}
/// Overloaded index operator
T& operator[](const uint index) {
assert(index < mSize);
return getItem(index);
}
/// Overloaded const index operator
const T& operator[](const uint index) const {
assert(index < mSize);
return getItem(index);
}
/// Overloaded equality operator
bool operator==(const Deque<T>& deque) const {
if (mSize != deque.mSize) return false;
for (size_t i=0; i < mSize; i++) {
if (getItem(i) != deque.getItem(i)) {
return false;
}
}
return true;
}
/// Overloaded not equal operator
bool operator!=(const Deque<T>& deque) const {
return !((*this) == deque);
}
/// Overloaded assignment operator
Deque<T>& operator=(const Deque<T>& deque) {
if (this != &deque) {
// Clear all the elements
clear();
if (deque.mSize > 0) {
// Number of used chunks
const size_t nbUsedChunks = deque.mLastChunkIndex - deque.mFirstChunkIndex + 1;
// Expand the chunk if necessary
expandChunks(nbUsedChunks);
const size_t dequeHalfSize1 = std::ceil(deque.mSize / 2.0f);
const size_t dequeHalfSize2 = deque.mSize - dequeHalfSize1;
// Add the items into the deque
for(size_t i=0; i < dequeHalfSize1; i++) {
addFront(deque[dequeHalfSize1 - 1 - i]);
}
for(size_t i=0; i < dequeHalfSize2; i++) {
addBack(deque[dequeHalfSize1 + i]);
}
}
}
return *this;
}
/// Return a begin iterator
Iterator begin() const {
return Iterator(this, 0);
}
/// Return a end iterator
Iterator end() const {
return Iterator(this, mSize);
}
};
}
#endif

4
src/containers/LinkedList.h → include/reactphysics3d/containers/LinkedList.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,7 +27,7 @@
#define REACTPHYSICS3D_LINKED_LIST_H
// Libraries
#include "memory/MemoryAllocator.h"
#include <reactphysics3d/memory/MemoryAllocator.h>
namespace reactphysics3d {

100
src/containers/List.h → include/reactphysics3d/containers/List.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_LIST_H
// Libraries
#include "configuration.h"
#include "memory/MemoryAllocator.h"
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/memory/MemoryAllocator.h>
#include <cassert>
#include <cstring>
#include <iterator>
@ -39,7 +39,7 @@ namespace reactphysics3d {
// Class List
/**
* This class represents a simple generic list with custom memory allocator.
*/
*/
template<typename T>
class List {
@ -79,8 +79,10 @@ class List {
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = T*;
using const_pointer = T const*;
using reference = T&;
using iterator_category = std::bidirectional_iterator_tag;
using const_reference = const T&;
using iterator_category = std::random_access_iterator_tag;
/// Constructor
Iterator() = default;
@ -98,13 +100,19 @@ class List {
}
/// Deferencable
reference operator*() const {
reference operator*() {
assert(mCurrentIndex >= 0 && mCurrentIndex < mSize);
return mBuffer[mCurrentIndex];
}
/// Const Deferencable
const_reference operator*() const {
assert(mCurrentIndex >= 0 && mCurrentIndex < mSize);
return mBuffer[mCurrentIndex];
}
/// Deferencable
pointer operator->() const {
const_pointer operator->() const {
assert(mCurrentIndex >= 0 && mCurrentIndex < mSize);
return &(mBuffer[mCurrentIndex]);
}
@ -138,6 +146,53 @@ class List {
mCurrentIndex--;
return tmp;
}
/// Plus operator
Iterator operator+(const difference_type& n) {
return Iterator(mBuffer, mCurrentIndex + n, mSize);
}
/// Plus operator
Iterator& operator+=(const difference_type& n) {
mCurrentIndex += n;
return *this;
}
/// Minus operator
Iterator operator-(const difference_type& n) {
return Iterator(mBuffer, mCurrentIndex - n, mSize);
}
/// Minus operator
Iterator& operator-=(const difference_type& n) {
mCurrentIndex -= n;
return *this;
}
/// Difference operator
difference_type operator-(const Iterator& iterator) const {
return mCurrentIndex - iterator.mCurrentIndex;
}
/// Comparison operator
bool operator<(const Iterator& other) const {
return mCurrentIndex < other.mCurrentIndex;
}
/// Comparison operator
bool operator>(const Iterator& other) const {
return mCurrentIndex > other.mCurrentIndex;
}
/// Comparison operator
bool operator<=(const Iterator& other) const {
return mCurrentIndex <= other.mCurrentIndex;
}
/// Comparison operator
bool operator>=(const Iterator& other) const {
return mCurrentIndex >= other.mCurrentIndex;
}
/// Equality operator (it == end())
bool operator==(const Iterator& iterator) const {
@ -188,10 +243,7 @@ class List {
if (mCapacity > 0) {
// Clear the list
clear();
// Release the memory allocated on the heap
mAllocator.release(mBuffer, mCapacity * sizeof(T));
clear(true);
}
}
@ -242,6 +294,17 @@ class List {
mSize++;
}
/// Add a given numbers of elements at the end of the list but do not init them
void addWithoutInit(uint nbElements) {
// If we need to allocate more memory
if (mSize == mCapacity) {
reserve(mCapacity == 0 ? nbElements : (mCapacity + nbElements) * 2);
}
mSize += nbElements;
}
/// Try to find a given item of the list and return an iterator
/// pointing to that element if it exists in the list. Otherwise,
/// this method returns the end() iterator
@ -268,8 +331,7 @@ class List {
return removeAt(it.mCurrentIndex);
}
/// Remove an element from the list at a given index and return an
/// iterator pointing to the element after the removed one (or end() if none)
/// Remove an element from the list at a given index (all the following items will be moved)
Iterator removeAt(uint index) {
assert(index >= 0 && index < mSize);
@ -310,7 +372,7 @@ class List {
}
/// Clear the list
void clear() {
void clear(bool releaseMemory = false) {
// Call the destructor of each element
for (uint i=0; i < mSize; i++) {
@ -318,6 +380,16 @@ class List {
}
mSize = 0;
// If we need to release all the allocated memory
if (releaseMemory && mCapacity > 0) {
// Release the memory allocated on the heap
mAllocator.release(mBuffer, mCapacity * sizeof(T));
mBuffer = nullptr;
mCapacity = 0;
}
}
/// Return the number of elements in the list

118
src/containers/Map.h → include/reactphysics3d/containers/Map.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,15 +27,14 @@
#define REACTPHYSICS3D_MAP_H
// Libraries
#include "memory/MemoryAllocator.h"
#include "mathematics/mathematics_functions.h"
#include "containers/Pair.h"
#include <reactphysics3d/memory/MemoryAllocator.h>
#include <reactphysics3d/mathematics/mathematics_functions.h>
#include <reactphysics3d/containers/Pair.h>
#include <cstring>
#include <stdexcept>
#include <functional>
#include <limits>
namespace reactphysics3d {
// Class Map
@ -43,7 +42,7 @@ namespace reactphysics3d {
* This class represents a simple generic associative map. This map is
* implemented with a hash table.
*/
template<typename K, typename V>
template<typename K, typename V, class Hash = std::hash<K>, class KeyEqual = std::equal_to<K>>
class Map {
private:
@ -123,6 +122,7 @@ class Map {
// Compute the next larger prime size
mCapacity = getPrimeSize(capacity);
assert(mCapacity >= 0);
// Allocate memory for the buckets
mBuckets = static_cast<int*>(mAllocator.allocate(mCapacity * sizeof(int)));
@ -142,6 +142,8 @@ class Map {
mNbUsedEntries = 0;
mNbFreeEntries = 0;
mFreeIndex = -1;
assert(size() >= 0);
}
/// Expand the capacity of the map
@ -200,6 +202,8 @@ class Map {
mCapacity = newCapacity;
mBuckets = newBuckets;
mEntries = newEntries;
assert(mCapacity >= 0);
}
/// Return the index of the entry with a given key or -1 if there is no entry with this key
@ -207,11 +211,12 @@ class Map {
if (mCapacity > 0) {
size_t hashCode = std::hash<K>()(key);
const size_t hashCode = Hash()(key);
int bucket = hashCode % mCapacity;
auto keyEqual = KeyEqual();
for (int i = mBuckets[bucket]; i >= 0; i = mEntries[i].next) {
if (mEntries[i].hashCode == hashCode && mEntries[i].keyValue->first == key) {
if (mEntries[i].hashCode == hashCode && keyEqual(mEntries[i].keyValue->first, key)) {
return i;
}
}
@ -240,32 +245,6 @@ class Map {
return number;
}
/// Clear and reset the map
void reset() {
// If elements have been allocated
if (mCapacity > 0) {
// Clear the map
clear();
// Destroy the entries
for (int i=0; i < mCapacity; i++) {
mEntries[i].~Entry();
}
mAllocator.release(mBuckets, mCapacity * sizeof(int));
mAllocator.release(mEntries, mCapacity * sizeof(Entry));
mNbUsedEntries = 0;
mNbFreeEntries = 0;
mCapacity = 0;
mBuckets = nullptr;
mEntries = nullptr;
mFreeIndex = -1;
}
}
public:
/// Class Iterator
@ -396,6 +375,8 @@ class Map {
:mNbUsedEntries(map.mNbUsedEntries), mNbFreeEntries(map.mNbFreeEntries), mCapacity(map.mCapacity),
mBuckets(nullptr), mEntries(nullptr), mAllocator(map.mAllocator), mFreeIndex(map.mFreeIndex) {
assert(capacity() >= 0);
if (mCapacity > 0) {
// Allocate memory for the buckets
@ -405,7 +386,7 @@ class Map {
mEntries = static_cast<Entry*>(mAllocator.allocate(mCapacity * sizeof(Entry)));
// Copy the buckets
std::uninitialized_copy(map.mBuckets, map.mBuckets + mCapacity, mBuckets);
std::uninitialized_copy(map.mBuckets, map.mBuckets + mCapacity, mBuckets);
// Copy the entries
for (int i=0; i < mCapacity; i++) {
@ -417,13 +398,17 @@ class Map {
new (mEntries[i].keyValue) Pair<K,V>(*(map.mEntries[i].keyValue));
}
}
}
assert(size() >= 0);
assert((*this) == map);
}
/// Destructor
~Map() {
reset();
clear(true);
}
/// Allocate memory for a given number of elements
@ -454,16 +439,18 @@ class Map {
}
// Compute the hash code of the key
size_t hashCode = std::hash<K>()(keyValue.first);
const size_t hashCode = Hash()(keyValue.first);
// Compute the corresponding bucket index
int bucket = hashCode % mCapacity;
auto keyEqual = KeyEqual();
// Check if the item is already in the map
for (int i = mBuckets[bucket]; i >= 0; i = mEntries[i].next) {
// If there is already an item with the same key in the map
if (mEntries[i].hashCode == hashCode && mEntries[i].keyValue->first == keyValue.first) {
if (mEntries[i].hashCode == hashCode && keyEqual(mEntries[i].keyValue->first, keyValue.first)) {
if (insertIfAlreadyPresent) {
@ -506,6 +493,7 @@ class Map {
mNbUsedEntries++;
}
assert(size() >= 0);
assert(mEntries[entryIndex].keyValue == nullptr);
mEntries[entryIndex].hashCode = hashCode;
mEntries[entryIndex].next = mBuckets[bucket];
@ -531,12 +519,14 @@ class Map {
if (mCapacity > 0) {
size_t hashcode = std::hash<K>()(key);
const size_t hashcode = Hash()(key);
int bucket = hashcode % mCapacity;
int last = -1;
auto keyEqual = KeyEqual();
for (int i = mBuckets[bucket]; i >= 0; last = i, i = mEntries[i].next) {
if (mEntries[i].hashCode == hashcode && mEntries[i].keyValue->first == key) {
if (mEntries[i].hashCode == hashcode && keyEqual(mEntries[i].keyValue->first, key)) {
if (last < 0 ) {
mBuckets[bucket] = mEntries[i].next;
@ -572,16 +562,20 @@ class Map {
}
}
assert(size() >= 0);
// Return the end iterator
return end();
}
/// Clear the map
void clear() {
void clear(bool releaseMemory = false) {
if (mNbUsedEntries > 0) {
// Remove the key/value pair of each entry
for (int i=0; i < mCapacity; i++) {
mBuckets[i] = -1;
mEntries[i].next = -1;
if (mEntries[i].keyValue != nullptr) {
@ -594,6 +588,25 @@ class Map {
mFreeIndex = -1;
mNbUsedEntries = 0;
mNbFreeEntries = 0;
assert(size() >= 0);
}
// If elements have been allocated
if (releaseMemory && mCapacity > 0) {
// Destroy the entries
for (int i=0; i < mCapacity; i++) {
mEntries[i].~Entry();
}
// Release memory
mAllocator.release(mBuckets, mCapacity * sizeof(int));
mAllocator.release(mEntries, mCapacity * sizeof(Entry));
mCapacity = 0;
mBuckets = nullptr;
mEntries = nullptr;
}
assert(size() == 0);
@ -601,6 +614,7 @@ class Map {
/// Return the number of elements in the map
int size() const {
assert(mNbUsedEntries - mNbFreeEntries >= 0);
return mNbUsedEntries - mNbFreeEntries;
}
@ -619,11 +633,13 @@ class Map {
if (mCapacity > 0) {
size_t hashCode = std::hash<K>()(key);
const size_t hashCode = Hash()(key);
bucket = hashCode % mCapacity;
auto keyEqual = KeyEqual();
for (int i = mBuckets[bucket]; i >= 0; i = mEntries[i].next) {
if (mEntries[i].hashCode == hashCode && mEntries[i].keyValue->first == key) {
if (mEntries[i].hashCode == hashCode && keyEqual(mEntries[i].keyValue->first, key)) {
entry = i;
break;
}
@ -649,6 +665,7 @@ class Map {
}
if (entry == -1) {
assert(false);
throw std::runtime_error("No item with given key has been found in the map");
}
@ -709,13 +726,14 @@ class Map {
// Check for self assignment
if (this != &map) {
// Reset the map
reset();
// Clear the map
clear(true);
if (map.mCapacity > 0) {
// Compute the next larger prime size
mCapacity = getPrimeSize(map.mCapacity);
assert(mCapacity >= 0);
// Allocate memory for the buckets
mBuckets = static_cast<int*>(mAllocator.allocate(mCapacity * sizeof(int)));
@ -743,6 +761,8 @@ class Map {
}
}
assert(size() >= 0);
return *this;
}
@ -774,15 +794,15 @@ class Map {
}
};
template<typename K, typename V>
const int Map<K,V>::PRIMES[NB_PRIMES] = {3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
template<typename K, typename V, class Hash, class KeyEqual>
const int Map<K,V, Hash, KeyEqual>::PRIMES[NB_PRIMES] = {3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,
187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559};
template<typename K, typename V>
int Map<K,V>::LARGEST_PRIME = -1;
template<typename K, typename V, class Hash, class KeyEqual>
int Map<K,V, Hash, KeyEqual>::LARGEST_PRIME = -1;
}

9
src/containers/Pair.h → include/reactphysics3d/containers/Pair.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,9 +27,9 @@
#define REACTPHYSICS3D_PAIR_H
// Libraries
#include "configuration.h"
#include "memory/MemoryAllocator.h"
#include "containers/containers_common.h"
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/memory/MemoryAllocator.h>
#include <reactphysics3d/containers/containers_common.h>
#include <cstring>
#include <iterator>
@ -103,5 +103,4 @@ namespace std {
};
}
#endif

114
src/containers/Set.h → include/reactphysics3d/containers/Set.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,8 +27,8 @@
#define REACTPHYSICS3D_SET_H
// Libraries
#include "memory/MemoryAllocator.h"
#include "mathematics/mathematics_functions.h"
#include <reactphysics3d/memory/MemoryAllocator.h>
#include <reactphysics3d/mathematics/mathematics_functions.h>
#include <cstring>
#include <stdexcept>
#include <functional>
@ -42,7 +42,7 @@ namespace reactphysics3d {
* This class represents a simple generic set. This set is implemented
* with a hash table.
*/
template<typename V>
template<typename V, class Hash = std::hash<V>, class KeyEqual = std::equal_to<V>>
class Set {
private:
@ -206,11 +206,12 @@ class Set {
if (mCapacity > 0) {
size_t hashCode = std::hash<V>()(value);
size_t hashCode = Hash()(value);
int bucket = hashCode % mCapacity;
auto keyEqual = KeyEqual();
for (int i = mBuckets[bucket]; i >= 0; i = mEntries[i].next) {
if (mEntries[i].hashCode == hashCode && (*mEntries[i].value) == value) {
if (mEntries[i].hashCode == hashCode && keyEqual(*mEntries[i].value, value)) {
return i;
}
}
@ -239,32 +240,6 @@ class Set {
return number;
}
/// Clear and reset the set
void reset() {
// If elements have been allocated
if (mCapacity > 0) {
// Clear the list
clear();
// Destroy the entries
for (int i=0; i < mCapacity; i++) {
mEntries[i].~Entry();
}
mAllocator.release(mBuckets, mCapacity * sizeof(int));
mAllocator.release(mEntries, mCapacity * sizeof(Entry));
mNbUsedEntries = 0;
mNbFreeEntries = 0;
mCapacity = 0;
mBuckets = nullptr;
mEntries = nullptr;
mFreeIndex = -1;
}
}
public:
/// Class Iterator
@ -352,7 +327,7 @@ class Set {
}
/// Pre increment (++it)
Iterator operator++(int number) {
Iterator operator++(int) {
Iterator tmp = *this;
advance();
return tmp;
@ -391,7 +366,7 @@ class Set {
}
/// Copy constructor
Set(const Set<V>& set)
Set(const Set<V, Hash, KeyEqual>& set)
:mNbUsedEntries(set.mNbUsedEntries), mNbFreeEntries(set.mNbFreeEntries), mCapacity(set.mCapacity),
mBuckets(nullptr), mEntries(nullptr), mAllocator(set.mAllocator), mFreeIndex(set.mFreeIndex) {
@ -422,7 +397,7 @@ class Set {
/// Destructor
~Set() {
reset();
clear(true);
}
/// Allocate memory for a given number of elements
@ -445,26 +420,29 @@ class Set {
return findEntry(value) != -1;
}
/// Add a value into the set
void add(const V& value) {
/// Add a value into the set.
/// Returns true if the item has been inserted and false otherwise.
bool add(const V& value) {
if (mCapacity == 0) {
initialize(0);
}
// Compute the hash code of the value
size_t hashCode = std::hash<V>()(value);
size_t hashCode = Hash()(value);
// Compute the corresponding bucket index
int bucket = hashCode % mCapacity;
auto keyEqual = KeyEqual();
// Check if the item is already in the set
for (int i = mBuckets[bucket]; i >= 0; i = mEntries[i].next) {
// If there is already an item with the same value in the set
if (mEntries[i].hashCode == hashCode && (*mEntries[i].value) == value) {
if (mEntries[i].hashCode == hashCode && keyEqual(*mEntries[i].value, value)) {
return;
return false;
}
}
@ -500,6 +478,8 @@ class Set {
assert(mEntries[entryIndex].value != nullptr);
new (mEntries[entryIndex].value) V(value);
mBuckets[bucket] = entryIndex;
return true;
}
/// Remove the element pointed by some iterator
@ -517,12 +497,13 @@ class Set {
if (mCapacity > 0) {
size_t hashcode = std::hash<V>()(value);
size_t hashcode = Hash()(value);
auto keyEqual = KeyEqual();
int bucket = hashcode % mCapacity;
int last = -1;
for (int i = mBuckets[bucket]; i >= 0; last = i, i = mEntries[i].next) {
if (mEntries[i].hashCode == hashcode && (*mEntries[i].value) == value) {
if (mEntries[i].hashCode == hashcode && keyEqual(*mEntries[i].value, value)) {
if (last < 0 ) {
mBuckets[bucket] = mEntries[i].next;
@ -561,8 +542,22 @@ class Set {
return end();
}
/// Return a list with all the values of the set
List<V> toList(MemoryAllocator& listAllocator) const {
List<V> list(listAllocator);
for (int i=0; i < mCapacity; i++) {
if (mEntries[i].value != nullptr) {
list.add(*(mEntries[i].value));
}
}
return list;
}
/// Clear the set
void clear() {
void clear(bool releaseMemory = false) {
if (mNbUsedEntries > 0) {
@ -581,6 +576,22 @@ class Set {
mNbFreeEntries = 0;
}
// If elements have been allocated
if (releaseMemory && mCapacity > 0) {
// Destroy the entries
for (int i=0; i < mCapacity; i++) {
mEntries[i].~Entry();
}
mAllocator.release(mBuckets, mCapacity * sizeof(int));
mAllocator.release(mEntries, mCapacity * sizeof(Entry));
mCapacity = 0;
mBuckets = nullptr;
mEntries = nullptr;
}
assert(size() == 0);
}
@ -604,11 +615,12 @@ class Set {
if (mCapacity > 0) {
size_t hashCode = std::hash<V>()(value);
size_t hashCode = Hash()(value);
bucket = hashCode % mCapacity;
auto keyEqual = KeyEqual();
for (int i = mBuckets[bucket]; i >= 0; i = mEntries[i].next) {
if (mEntries[i].hashCode == hashCode && *(mEntries[i].value) == value) {
if (mEntries[i].hashCode == hashCode && keyEqual(*(mEntries[i].value), value)) {
entry = i;
break;
}
@ -650,8 +662,8 @@ class Set {
// Check for self assignment
if (this != &set) {
// Reset the set
reset();
// Clear the set
clear(true);
if (set.mCapacity > 0) {
@ -715,15 +727,15 @@ class Set {
}
};
template<typename V>
const int Set<V>::PRIMES[NB_PRIMES] = {3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
template<typename V, class Hash, class KeyEqual>
const int Set<V, Hash, KeyEqual>::PRIMES[NB_PRIMES] = {3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,
187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559};
template<typename V>
int Set<V>::LARGEST_PRIME = -1;
template<typename V, class Hash, class KeyEqual>
int Set<V, Hash, KeyEqual>::LARGEST_PRIME = -1;
}

184
include/reactphysics3d/containers/Stack.h Normal file
View File

@ -0,0 +1,184 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_STACK_H
#define REACTPHYSICS3D_STACK_H
// Libraries
#include <memory>
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/memory/MemoryAllocator.h>
namespace reactphysics3d {
// Class Stack
/**
* This class represents a simple generic stack.
*/
template<typename T>
class Stack {
private:
// -------------------- Attributes -------------------- //
/// Reference to the memory allocator
MemoryAllocator& mAllocator;
/// Array that contains the elements of the stack
T* mArray;
/// Number of elements in the stack
uint mNbElements;
/// Number of allocated elements in the stack
uint mCapacity;
// -------------------- Methods -------------------- //
/// Allocate more memory
void allocate(size_t capacity) {
T* newArray = static_cast<T*>(mAllocator.allocate(capacity * sizeof(T)));
assert(newArray != nullptr);
// If there
if (mCapacity > 0) {
if (mNbElements > 0) {
// Copy the previous items in the new array
std::uninitialized_copy(mArray, mArray + mNbElements, newArray);
}
// Release memory of the previous array
mAllocator.release(mArray, mCapacity * sizeof(T));
}
mArray = newArray;
mCapacity = capacity;
}
public:
// -------------------- Methods -------------------- //
/// Constructor
Stack(MemoryAllocator& allocator, size_t capacity = 0)
:mAllocator(allocator), mArray(nullptr), mNbElements(0), mCapacity(0) {
if (capacity > 0) {
allocate(capacity);
}
}
/// Copy constructor
Stack(const Stack& stack)
:mAllocator(stack.mAllocator), mArray(nullptr),
mNbElements(stack.mNbElements), mCapacity(stack.mCapacity) {
if (mCapacity > 0) {
// Allocate memory for the buckets
mArray = static_cast<T*>(mAllocator.allocate(mCapacity * sizeof(T)));
assert(mArray != nullptr);
if (mNbElements > 0) {
// Copy the items
std::uninitialized_copy(stack.mArray, stack.mArray + mNbElements, mArray);
}
}
}
/// Destructor
~Stack() {
clear();
if (mCapacity > 0) {
// Release the memory allocated on the heap
mAllocator.release(mArray, mCapacity * sizeof(T));
}
}
/// Remove all the items from the stack
void clear() {
// Destruct the items
for (size_t i = 0; i < mNbElements; i++) {
mArray[i].~T();
}
mNbElements = 0;
}
/// Push an element into the stack
void push(const T& element) {
// If we need to allocate more elements
if (mNbElements == mCapacity) {
allocate(mCapacity > 0 ? mCapacity * 2 : 1);
}
// Copy the item into the array
new (mArray + mNbElements) T(element);
mNbElements++;
}
/// Pop an element from the stack (remove it from the stack and return it)
T pop() {
assert(mNbElements > 0);
mNbElements--;
// Copy the item
T item = mArray[mNbElements];
// Call the destructor
mArray[mNbElements].~T();
return item;
}
/// Return the number of items in the stack
size_t size() const {
return mNbElements;
}
/// Return the capacity of the stack
size_t capacity() const {
return mCapacity;
}
};
}
#endif

2
src/containers/containers_common.h → include/reactphysics3d/containers/containers_common.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *

4
src/decimal.h → include/reactphysics3d/decimal.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -29,7 +29,7 @@
/// ReactPhysiscs3D namespace
namespace reactphysics3d {
#if defined(IS_DOUBLE_PRECISION_ENABLED) // If we are compiling for double precision
#if defined(IS_RP3D_DOUBLE_PRECISION_ENABLED) // If we are compiling for double precision
using decimal = double;
#else // If we are compiling for single precision
using decimal = float;

144
include/reactphysics3d/engine/Entity.h Normal file
View File

@ -0,0 +1,144 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_ENTITY_H
#define REACTPHYSICS3D_ENTITY_H
// Libraries
#include <reactphysics3d/configuration.h>
/// Namespace reactphysics3d
namespace reactphysics3d {
// Structure Entity
/**
* This class is used to identify an entity in the Entity-Component-System.
* Entities are used for bodies in the physics engine. The id of an entity is
* a 32 bits integer that is separated in two parts. The index and the generation
* parts. The idea is that the index part directly gives us the index of the entity
* in a lookup array. However, we want to support deletion of the entities. That's why
* we have the generation part. This number is used to distinguish the entities created
* at the same index in the array. If it is the case, we will increase the generation number
* each time.
*
* We use 24 bits for the index. Therefore, we support 16 millions simultaneous entries.
* We use 8 bits for the generation. Therefore, we support 256 entries created at the same index.
* To prevent reaching the 256 entries too fast, we make sure that we do not reuse the same index
* slot too ofen. To do that, we put recycled indices in a queue and only reuse values from that
* queue when it contains at least MINIMUM_FREE_INDICES values. It means, an id will reappear until
* its index has run 256 laps through the queue. It means that we must create and destroy at least
* 256 * MINIMUM_FREE_INDICES entities until an id can reappear. This seems reasonably safe.
*
* This implementation is based on the following article:
* http://bitsquid.blogspot.com/2014/08/building-data-oriented-entity-system.html
*/
struct Entity {
private:
/// Number of bits reserved for the index
static const uint32 ENTITY_INDEX_BITS;
/// Mask for the index part of the id
static const uint32 ENTITY_INDEX_MASK;
/// Number of bits reserved for the generation number
static const uint32 ENTITY_GENERATION_BITS;
/// Mask for the generation part of the id
static const uint32 ENTITY_GENERATION_MASK;
/// Minimum of free indices in the queue before we reuse one from the queue
static const uint32 MINIMUM_FREE_INDICES;
public:
// -------------------- Attributes -------------------- //
/// Id of the entity
uint32 id;
// -------------------- Methods -------------------- //
/// Constructor
Entity(uint32 index, uint32 generation);
/// Return the lookup index of the entity in a array
uint32 getIndex() const;
/// Return the generation number of the entity
uint32 getGeneration() const;
/// Assignment operator
Entity& operator=(const Entity& entity);
/// Equality operator
bool operator==(const Entity& entity) const;
/// Inequality operator
bool operator!=(const Entity& entity) const;
// -------------------- Friendship -------------------- //
friend class EntityManager;
};
// Return the lookup index of the entity in a array
inline uint32 Entity::getIndex() const {
return id & ENTITY_INDEX_MASK;
}
// Return the generation number of the entity
inline uint32 Entity::getGeneration() const {
return (id >> ENTITY_INDEX_BITS) & ENTITY_GENERATION_MASK;
}
// Equality operator
inline bool Entity::operator==(const Entity& entity) const {
return entity.id == id;
}
// Inequality operator
inline bool Entity::operator!=(const Entity& entity) const {
return entity.id != id;
}
}
// Hash function for a reactphysics3d Entity
namespace std {
template <> struct hash<reactphysics3d::Entity> {
size_t operator()(const reactphysics3d::Entity& entity) const {
return std::hash<reactphysics3d::uint32>{}(entity.id);
}
};
}
#endif

80
include/reactphysics3d/engine/EntityManager.h Normal file
View File

@ -0,0 +1,80 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_ENTITY_MANAGER_H
#define REACTPHYSICS3D_ENTITY_MANAGER_H
// Libraries
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/containers/List.h>
#include <reactphysics3d/containers/Deque.h>
#include <reactphysics3d/engine/Entity.h>
/// Namespace reactphysics3d
namespace reactphysics3d {
// Class EntityManager
/**
* This class is responsible to manage the entities of the ECS.
*/
class EntityManager {
private:
// -------------------- Attributes -------------------- //
/// List storing the generations of the created entities
List<uint8> mGenerations;
/// Deque with the indices of destroyed entities that can be reused
Deque<uint32> mFreeIndices;
// -------------------- Methods -------------------- //
public:
// -------------------- Methods -------------------- //
/// Constructor
EntityManager(MemoryAllocator& allocator);
/// Create a new entity
Entity createEntity();
/// Destroy an entity
void destroyEntity(Entity entity);
/// Return true if the entity is still valid (not destroyed)
bool isValid(Entity entity) const;
};
// Return true if the entity is still valid (not destroyed)
inline bool EntityManager::isValid(Entity entity) const {
return mGenerations[entity.getIndex()] == entity.getGeneration();
}
}
#endif

40
src/engine/EventListener.h → include/reactphysics3d/engine/EventListener.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,45 +27,41 @@
#define REACTPHYSICS3D_EVENT_LISTENER_H
// Libraries
#include "collision/CollisionCallback.h"
#include <reactphysics3d/collision/CollisionCallback.h>
#include <reactphysics3d/collision/OverlapCallback.h>
namespace reactphysics3d {
// Class EventListener
/**
* This class can be used to receive event callbacks from the physics engine.
* This class can be used to receive notifications about events that occur during the simulation.
* In order to receive callbacks, you need to create a new class that inherits from
* this one and you must override the methods you need. Then, you need to register your
* new event listener class to the physics world using the DynamicsWorld::setEventListener()
* method.
* this one and you must override the methods that you need. Then, you will need to register your
* new event listener class to the physics world using the PhysicsWorld::setEventListener() method.
*/
class EventListener {
class EventListener : public CollisionCallback {
public :
// ---------- Methods ---------- //
/// Constructor
EventListener() = default;
/// Destructor
virtual ~EventListener() = default;
virtual ~EventListener() override = default;
/// Called when a new contact point is found between two bodies
/// Called when some contacts occur
/**
* @param contact Information about the contact
* @param callbackData Contains information about all the contacts
*/
virtual void newContact(const CollisionCallback::CollisionCallbackInfo& collisionInfo) {}
virtual void onContact(const CollisionCallback::CallbackData& callbackData) override {}
/// Called at the beginning of an internal tick of the simulation step.
/// Each time the DynamicsWorld::update() method is called, the physics
/// engine will do several internal simulation steps. This method is
/// called at the beginning of each internal simulation step.
virtual void beginInternalTick() {}
/// Called at the end of an internal tick of the simulation step.
/// Each time the DynamicsWorld::update() metho is called, the physics
/// engine will do several internal simulation steps. This method is
/// called at the end of each internal simulation step.
virtual void endInternalTick() {}
/// Called when some trigger events occur
/**
* @param callbackData Contains information about all the triggers that are colliding
*/
virtual void onTrigger(const OverlapCallback::CallbackData& callbackData) {}
};
}

34
src/engine/Island.h → include/reactphysics3d/engine/Island.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -27,7 +27,7 @@
#define REACTPHYSICS3D_ISLAND_H
// Libraries
#include "constraint/Joint.h"
#include <reactphysics3d/constraint/Joint.h>
namespace reactphysics3d {
@ -53,25 +53,18 @@ class Island {
/// Array with all the contact manifolds between bodies of the island
ContactManifold** mContactManifolds;
/// Array with all the joints between bodies of the island
Joint** mJoints;
/// Current number of bodies in the island
uint mNbBodies;
/// Current number of contact manifold in the island
uint mNbContactManifolds;
/// Current number of joints in the island
uint mNbJoints;
public:
// -------------------- Methods -------------------- //
/// Constructor
Island(uint nbMaxBodies, uint nbMaxContactManifolds, uint nbMaxJoints,
MemoryManager& memoryManager);
Island(uint nbMaxBodies, uint nbMaxContactManifolds, MemoryManager& memoryManager);
/// Destructor
~Island();
@ -106,12 +99,9 @@ class Island {
/// Return a pointer to the array of contact manifolds
ContactManifold** getContactManifolds();
/// Return a pointer to the array of joints
Joint** getJoints();
// -------------------- Friendship -------------------- //
friend class DynamicsWorld;
friend class PhysicsWorld;
};
// Add a body into the island
@ -127,12 +117,6 @@ inline void Island::addContactManifold(ContactManifold* contactManifold) {
mNbContactManifolds++;
}
// Add a joint into the island
inline void Island::addJoint(Joint* joint) {
mJoints[mNbJoints] = joint;
mNbJoints++;
}
// Return the number of bodies in the island
inline uint Island::getNbBodies() const {
return mNbBodies;
@ -143,11 +127,6 @@ inline uint Island::getNbContactManifolds() const {
return mNbContactManifolds;
}
// Return the number of joints in the island
inline uint Island::getNbJoints() const {
return mNbJoints;
}
// Return a pointer to the array of bodies
inline RigidBody** Island::getBodies() {
return mBodies;
@ -158,11 +137,6 @@ inline ContactManifold** Island::getContactManifolds() {
return mContactManifolds;
}
// Return a pointer to the array of joints
inline Joint** Island::getJoints() {
return mJoints;
}
}
#endif

114
include/reactphysics3d/engine/Islands.h Normal file
View File

@ -0,0 +1,114 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_ISLANDS_H
#define REACTPHYSICS3D_ISLANDS_H
// Libraries
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/containers/List.h>
#include <reactphysics3d/engine/Entity.h>
#include <reactphysics3d/constraint/Joint.h>
namespace reactphysics3d {
// Declarations
// Structure Islands
/**
* This class contains all the islands of bodies during a frame.
* An island represent an isolated group of awake bodies that are connected with each other by
* some contraints (contacts or joints).
*/
struct Islands {
private:
// -------------------- Attributes -------------------- //
/// Reference to the memory allocator
MemoryAllocator& memoryAllocator;
public:
// -------------------- Attributes -------------------- //
/// For each island, index of the first contact manifold of the island in the array of contact manifolds
List<uint> contactManifoldsIndices;
/// For each island, number of contact manifolds in the island
List<uint> nbContactManifolds;
/// For each island, list of all the entities of the bodies in the island
List<List<Entity>> bodyEntities;
// -------------------- Methods -------------------- //
/// Constructor
Islands(MemoryAllocator& allocator)
:memoryAllocator(allocator), contactManifoldsIndices(allocator), nbContactManifolds(allocator),
bodyEntities(allocator) {
}
/// Destructor
~Islands() = default;
/// Assignment operator
Islands& operator=(const Islands& island) = default;
/// Copy-constructor
Islands(const Islands& island) = default;
/// Return the number of islands
uint32 getNbIslands() const {
return static_cast<uint32>(contactManifoldsIndices.size());
}
/// Add an island and return its index
uint32 addIsland(uint32 contactManifoldStartIndex) {
uint32 islandIndex = contactManifoldsIndices.size();
contactManifoldsIndices.add(contactManifoldStartIndex);
nbContactManifolds.add(0);
bodyEntities.add(List<Entity>(memoryAllocator));
return islandIndex;
}
/// Clear all the islands
void clear() {
contactManifoldsIndices.clear(true);
nbContactManifolds.clear(true);
bodyEntities.clear(true);
}
};
}
#endif

39
src/engine/Material.h → include/reactphysics3d/engine/Material.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -28,13 +28,13 @@
// Libraries
#include <cassert>
#include "configuration.h"
#include <reactphysics3d/configuration.h>
namespace reactphysics3d {
// Class Material
/**
* This class contains the material properties of a rigid body that will be use for
* This class contains the material properties of a collider that will be use for
* the dynamics simulation like the friction coefficient or the bounciness of the rigid
* body.
*/
@ -53,12 +53,14 @@ class Material {
/// Bounciness during collisions (between 0 and 1) where 1 is for a very bouncy body
decimal mBounciness;
public :
/// Density of mass used to compute the mass of the collider
decimal mMassDensity;
// -------------------- Methods -------------------- //
/// Constructor
Material(const WorldSettings& worldSettings);
Material(decimal frictionCoefficient, decimal rollingResistance, decimal bounciness,
decimal massDensity = decimal(1.0));
/// Copy-constructor
Material(const Material& material);
@ -66,6 +68,10 @@ class Material {
/// Destructor
~Material() = default;
public :
// -------------------- Methods -------------------- //
/// Return the bounciness
decimal getBounciness() const;
@ -84,11 +90,21 @@ class Material {
/// Set the rolling resistance factor
void setRollingResistance(decimal rollingResistance);
/// Return the mass density of the collider
decimal getMassDensity() const;
/// Set the mass density of the collider
void setMassDensity(decimal massDensity);
/// Return a string representation for the material
std::string to_string() const;
/// Overloaded assignment operator
Material& operator=(const Material& material);
// ---------- Friendship ---------- //
friend class Collider;
};
// Return the bounciness
@ -150,6 +166,19 @@ inline void Material::setRollingResistance(decimal rollingResistance) {
mRollingResistance = rollingResistance;
}
// Return the mass density of the collider
inline decimal Material::getMassDensity() const {
return mMassDensity;
}
// Set the mass density of the collider
/**
* @param massDensity The mass density of the collider
*/
inline void Material::setMassDensity(decimal massDensity) {
mMassDensity = massDensity;
}
// Return a string representation for the material
inline std::string Material::to_string() const {

421
include/reactphysics3d/engine/OverlappingPairs.h Normal file
View File

@ -0,0 +1,421 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_OVERLAPPING_PAIR_H
#define REACTPHYSICS3D_OVERLAPPING_PAIR_H
// Libraries
#include <reactphysics3d/collision/Collider.h>
#include <reactphysics3d/containers/Map.h>
#include <reactphysics3d/containers/Pair.h>
#include <reactphysics3d/containers/Set.h>
#include <reactphysics3d/containers/containers_common.h>
#include <reactphysics3d/utils/Profiler.h>
#include <reactphysics3d/components/ColliderComponents.h>
#include <reactphysics3d/components/CollisionBodyComponents.h>
#include <reactphysics3d/components/RigidBodyComponents.h>
#include <cstddef>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Declarations
struct NarrowPhaseInfoBatch;
enum class NarrowPhaseAlgorithmType;
class CollisionShape;
class CollisionDispatch;
// Structure LastFrameCollisionInfo
/**
* This structure contains collision info about the last frame.
* This is used for temporal coherence between frames.
*/
struct LastFrameCollisionInfo {
/// True if we have information about the previous frame
bool isValid;
/// True if the frame info is obsolete (the collision shape are not overlapping in middle phase)
bool isObsolete;
/// True if the two shapes were colliding in the previous frame
bool wasColliding;
/// True if we were using GJK algorithm to check for collision in the previous frame
bool wasUsingGJK;
/// True if we were using SAT algorithm to check for collision in the previous frame
bool wasUsingSAT;
// ----- GJK Algorithm -----
/// Previous separating axis
Vector3 gjkSeparatingAxis;
// SAT Algorithm
bool satIsAxisFacePolyhedron1;
bool satIsAxisFacePolyhedron2;
uint satMinAxisFaceIndex;
uint satMinEdge1Index;
uint satMinEdge2Index;
/// Constructor
LastFrameCollisionInfo() {
isValid = false;
isObsolete = false;
wasColliding = false;
wasUsingSAT = false;
wasUsingGJK = false;
gjkSeparatingAxis = Vector3(0, 1, 0);
}
};
// Class OverlappingPairs
/**
* This class contains pairs of two colliders that are overlapping
* during the broad-phase collision detection. A pair is created when
* the two colliders start to overlap and is destroyed when they do not
* overlap anymore. Each contains a contact manifold that
* store all the contact points between the two bodies.
*/
class OverlappingPairs {
private:
// -------------------- Constants -------------------- //
/// Number of pairs to allocated at the beginning
const uint32 INIT_NB_ALLOCATED_PAIRS = 10;
// -------------------- Attributes -------------------- //
/// Persistent memory allocator
MemoryAllocator& mPersistentAllocator;
/// Memory allocator used to allocated memory for the ContactManifoldInfo and ContactPointInfo
// TODO : Do we need to keep this ?
MemoryAllocator& mTempMemoryAllocator;
/// Current number of components
uint64 mNbPairs;
/// Index in the array of the first convex vs concave pair
uint64 mConcavePairsStartIndex;
/// Size (in bytes) of a single pair
size_t mPairDataSize;
/// Number of allocated pairs
uint64 mNbAllocatedPairs;
/// Allocated memory for all the data of the pairs
void* mBuffer;
/// Map a pair id to the internal array index
Map<uint64, uint64> mMapPairIdToPairIndex;
/// Ids of the convex vs convex pairs
uint64* mPairIds;
/// Array with the broad-phase Ids of the first shape
int32* mPairBroadPhaseId1;
/// Array with the broad-phase Ids of the second shape
int32* mPairBroadPhaseId2;
/// Array of Entity of the first collider of the convex vs convex pairs
Entity* mColliders1;
/// Array of Entity of the second collider of the convex vs convex pairs
Entity* mColliders2;
/// Temporal coherence collision data for each overlapping collision shapes of this pair.
/// Temporal coherence data store collision information about the last frame.
/// If two convex shapes overlap, we have a single collision data but if one shape is concave,
/// we might have collision data for several overlapping triangles. The key in the map is the
/// shape Ids of the two collision shapes.
Map<uint64, LastFrameCollisionInfo*>* mLastFrameCollisionInfos;
/// True if we need to test if the convex vs convex overlapping pairs of shapes still overlap
bool* mNeedToTestOverlap;
/// True if the overlapping pair is active (at least one body of the pair is active and not static)
bool* mIsActive;
/// Array with the pointer to the narrow-phase algorithm for each overlapping pair
NarrowPhaseAlgorithmType* mNarrowPhaseAlgorithmType;
/// True if the first shape of the pair is convex
bool* mIsShape1Convex;
/// True if the colliders of the overlapping pair were colliding in the previous frame
bool* mCollidingInPreviousFrame;
/// True if the colliders of the overlapping pair are colliding in the current frame
bool* mCollidingInCurrentFrame;
/// Reference to the colliders components
ColliderComponents& mColliderComponents;
/// Reference to the collision body components
CollisionBodyComponents& mCollisionBodyComponents;
/// Reference to the rigid bodies components
RigidBodyComponents& mRigidBodyComponents;
/// Reference to the set of bodies that cannot collide with each others
Set<bodypair>& mNoCollisionPairs;
/// Reference to the collision dispatch
CollisionDispatch& mCollisionDispatch;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
#endif
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of pairs
void allocate(uint64 nbPairsToAllocate);
/// Compute the index where we need to insert the new pair
uint64 prepareAddPair(bool isConvexVsConvex);
/// Destroy a pair at a given index
void destroyPair(uint64 index);
// Move a pair from a source to a destination index in the pairs array
void movePairToIndex(uint64 srcIndex, uint64 destIndex);
/// Swap two pairs in the array
void swapPairs(uint64 index1, uint64 index2);
public:
// -------------------- Methods -------------------- //
/// Constructor
OverlappingPairs(MemoryAllocator& persistentMemoryAllocator, MemoryAllocator& temporaryMemoryAllocator,
ColliderComponents& colliderComponents, CollisionBodyComponents& collisionBodyComponents,
RigidBodyComponents& rigidBodyComponents, Set<bodypair>& noCollisionPairs,
CollisionDispatch& collisionDispatch);
/// Destructor
~OverlappingPairs();
/// Deleted copy-constructor
OverlappingPairs(const OverlappingPairs& pair) = delete;
/// Deleted assignment operator
OverlappingPairs& operator=(const OverlappingPairs& pair) = delete;
/// Add an overlapping pair
uint64 addPair(Collider* shape1, Collider* shape2);
/// Remove a component at a given index
void removePair(uint64 pairId);
/// Return the number of pairs
uint64 getNbPairs() const;
/// Return the number of convex vs convex pairs
uint64 getNbConvexVsConvexPairs() const;
/// Return the number of convex vs concave pairs
uint64 getNbConvexVsConcavePairs() const;
/// Return the starting index of the convex vs concave pairs
uint64 getConvexVsConcavePairsStartIndex() const;
/// Return the entity of the first collider
Entity getCollider1(uint64 pairId) const;
/// Return the entity of the second collider
Entity getCollider2(uint64 pairId) const;
/// Notify if a given pair is active or not
void setIsPairActive(uint64 pairId, bool isActive);
/// Return the index of a given overlapping pair in the internal array
uint64 getPairIndex(uint64 pairId) const;
/// Return the last frame collision info
LastFrameCollisionInfo* getLastFrameCollisionInfo(uint64, uint64 shapesId);
/// Return a reference to the temporary memory allocator
MemoryAllocator& getTemporaryAllocator();
/// Add a new last frame collision info if it does not exist for the given shapes already
LastFrameCollisionInfo* addLastFrameInfoIfNecessary(uint64 pairIndex, uint32 shapeId1, uint32 shapeId2);
/// Update whether a given overlapping pair is active or not
void updateOverlappingPairIsActive(uint64 pairId);
/// Delete all the obsolete last frame collision info
void clearObsoleteLastFrameCollisionInfos();
/// Set the collidingInPreviousFrame value with the collidinginCurrentFrame value for each pair
void updateCollidingInPreviousFrame();
/// Return the pair of bodies index of the pair
static bodypair computeBodiesIndexPair(Entity body1Entity, Entity body2Entity);
/// Set if we need to test a given pair for overlap
void setNeedToTestOverlap(uint64 pairId, bool needToTestOverlap);
/// Return true if the two colliders of the pair were already colliding the previous frame
bool getCollidingInPreviousFrame(uint64 pairId) const;
/// Set to true if the two colliders of the pair were already colliding the previous frame
void setCollidingInPreviousFrame(uint64 pairId, bool wereCollidingInPreviousFrame);
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler);
#endif
// -------------------- Friendship -------------------- //
friend class PhysicsWorld;
friend class CollisionDetectionSystem;
};
// Return the entity of the first collider
inline Entity OverlappingPairs::getCollider1(uint64 pairId) const {
assert(mMapPairIdToPairIndex.containsKey(pairId));
assert(mMapPairIdToPairIndex[pairId] < mNbPairs);
return mColliders1[mMapPairIdToPairIndex[pairId]];
}
// Return the entity of the second collider
inline Entity OverlappingPairs::getCollider2(uint64 pairId) const {
assert(mMapPairIdToPairIndex.containsKey(pairId));
assert(mMapPairIdToPairIndex[pairId] < mNbPairs);
return mColliders2[mMapPairIdToPairIndex[pairId]];
}
// Notify if a given pair is active or not
inline void OverlappingPairs::setIsPairActive(uint64 pairId, bool isActive) {
assert(mMapPairIdToPairIndex.containsKey(pairId));
assert(mMapPairIdToPairIndex[pairId] < mNbPairs);
mIsActive[mMapPairIdToPairIndex[pairId]] = isActive;
}
// Return the index of a given overlapping pair in the internal array
inline uint64 OverlappingPairs::getPairIndex(uint64 pairId) const {
assert(mMapPairIdToPairIndex.containsKey(pairId));
return mMapPairIdToPairIndex[pairId];
}
// Return the last frame collision info for a given shape id or nullptr if none is found
inline LastFrameCollisionInfo* OverlappingPairs::getLastFrameCollisionInfo(uint64 pairId, uint64 shapesId) {
assert(mMapPairIdToPairIndex.containsKey(pairId));
const uint64 index = mMapPairIdToPairIndex[pairId];
assert(index < mNbPairs);
Map<uint64, LastFrameCollisionInfo*>::Iterator it = mLastFrameCollisionInfos[index].find(shapesId);
if (it != mLastFrameCollisionInfos[index].end()) {
return it->second;
}
return nullptr;
}
// Return the pair of bodies index
inline bodypair OverlappingPairs::computeBodiesIndexPair(Entity body1Entity, Entity body2Entity) {
// Construct the pair of body index
bodypair indexPair = body1Entity.id < body2Entity.id ?
bodypair(body1Entity, body2Entity) :
bodypair(body2Entity, body1Entity);
assert(indexPair.first != indexPair.second);
return indexPair;
}
// Return the number of pairs
inline uint64 OverlappingPairs::getNbPairs() const {
return mNbPairs;
}
// Return the number of convex vs convex pairs
inline uint64 OverlappingPairs::getNbConvexVsConvexPairs() const {
return mConcavePairsStartIndex;
}
// Return the number of convex vs concave pairs
inline uint64 OverlappingPairs::getNbConvexVsConcavePairs() const {
return mNbPairs - mConcavePairsStartIndex;
}
// Return the starting index of the convex vs concave pairs
inline uint64 OverlappingPairs::getConvexVsConcavePairsStartIndex() const {
return mConcavePairsStartIndex;
}
// Return a reference to the temporary memory allocator
inline MemoryAllocator& OverlappingPairs::getTemporaryAllocator() {
return mTempMemoryAllocator;
}
// Set if we need to test a given pair for overlap
inline void OverlappingPairs::setNeedToTestOverlap(uint64 pairId, bool needToTestOverlap) {
assert(mMapPairIdToPairIndex.containsKey(pairId));
mNeedToTestOverlap[mMapPairIdToPairIndex[pairId]] = needToTestOverlap;
}
// Return true if the two colliders of the pair were already colliding the previous frame
inline bool OverlappingPairs::getCollidingInPreviousFrame(uint64 pairId) const {
assert(mMapPairIdToPairIndex.containsKey(pairId));
return mCollidingInPreviousFrame[mMapPairIdToPairIndex[pairId]];
}
// Set to true if the two colliders of the pair were already colliding the previous frame
inline void OverlappingPairs::setCollidingInPreviousFrame(uint64 pairId, bool wereCollidingInPreviousFrame) {
assert(mMapPairIdToPairIndex.containsKey(pairId));
mCollidingInPreviousFrame[mMapPairIdToPairIndex[pairId]] = wereCollidingInPreviousFrame;
}
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void OverlappingPairs::setProfiler(Profiler* profiler) {
mProfiler = profiler;
}
#endif
}
#endif

213
include/reactphysics3d/engine/PhysicsCommon.h Normal file
View File

@ -0,0 +1,213 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_PHYSICS_COMMON_H
#define REACTPHYSICS3D_PHYSICS_COMMON_H
// Libraries
#include <reactphysics3d/memory/MemoryManager.h>
#include <reactphysics3d/engine/PhysicsWorld.h>
#include <reactphysics3d/collision/shapes/SphereShape.h>
#include <reactphysics3d/collision/shapes/BoxShape.h>
#include <reactphysics3d/collision/shapes/CapsuleShape.h>
#include <reactphysics3d/collision/shapes/HeightFieldShape.h>
#include <reactphysics3d/collision/shapes/ConvexMeshShape.h>
#include <reactphysics3d/collision/shapes/ConcaveMeshShape.h>
#include <reactphysics3d/collision/TriangleMesh.h>
#include <reactphysics3d/utils/DefaultLogger.h>
/// ReactPhysics3D namespace
namespace reactphysics3d {
// Class PhysicsCommon
/**
* This class is a singleton that needs to be instanciated once at the beginning.
* Then this class is used by the user as a factory to create the physics world and
* other objects.
*/
class PhysicsCommon {
private :
// -------------------- Attributes -------------------- //
/// Memory manager
MemoryManager mMemoryManager;
/// Set of physics worlds
Set<PhysicsWorld*> mPhysicsWorlds;
/// Set of sphere shapes
Set<SphereShape*> mSphereShapes;
/// Set of box shapes
Set<BoxShape*> mBoxShapes;
/// Set of capsule shapes
Set<CapsuleShape*> mCapsuleShapes;
/// Set of convex mesh shapes
Set<ConvexMeshShape*> mConvexMeshShapes;
/// Set of concave mesh shapes
Set<ConcaveMeshShape*> mConcaveMeshShapes;
/// Set of height field shapes
Set<HeightFieldShape*> mHeightFieldShapes;
/// Set of polyhedron meshes
Set<PolyhedronMesh*> mPolyhedronMeshes;
/// Set of triangle meshes
Set<TriangleMesh*> mTriangleMeshes;
/// Pointer to the current logger
static Logger* mLogger;
/// Set of profilers
Set<Profiler*> mProfilers;
/// Set of default loggers
Set<DefaultLogger*> mDefaultLoggers;
// -------------------- Methods -------------------- //
/// Destroy and release everything that has been allocated
void release();
// If profiling is enabled
#ifdef IS_RP3D_PROFILING_ENABLED
/// Create and return a new profiler
Profiler* createProfiler();
/// Destroy a profiler
void destroyProfiler(Profiler* profiler);
#endif
public :
// -------------------- Methods -------------------- //
/// Constructor
PhysicsCommon(MemoryAllocator* baseMemoryAllocator = nullptr);
/// Destructor
~PhysicsCommon();
/// Create and return an instance of PhysicsWorld
PhysicsWorld* createPhysicsWorld(const PhysicsWorld::WorldSettings& worldSettings = PhysicsWorld::WorldSettings());
/// Destroy an instance of PhysicsWorld
void destroyPhysicsWorld(PhysicsWorld* world);
/// Create and return a sphere collision shape
SphereShape* createSphereShape(const decimal radius);
/// Destroy a sphere collision shape
void destroySphereShape(SphereShape* sphereShape);
/// Create and return a box collision shape
BoxShape* createBoxShape(const Vector3& extent);
/// Destroy a box collision shape
void destroyBoxShape(BoxShape* boxShape);
/// Create and return a capsule shape
CapsuleShape* createCapsuleShape(decimal radius, decimal height);
/// Destroy a capsule collision shape
void destroyCapsuleShape(CapsuleShape* capsuleShape);
/// Create and return a convex mesh shape
ConvexMeshShape* createConvexMeshShape(PolyhedronMesh* polyhedronMesh, const Vector3& scaling = Vector3(1,1,1));
/// Destroy a convex mesh shape
void destroyConvexMeshShape(ConvexMeshShape* convexMeshShape);
/// Create and return a height-field shape
HeightFieldShape* createHeightFieldShape(int nbGridColumns, int nbGridRows, decimal minHeight, decimal maxHeight,
const void* heightFieldData, HeightFieldShape::HeightDataType dataType,
int upAxis = 1, decimal integerHeightScale = 1.0f,
const Vector3& scaling = Vector3(1,1,1));
/// Destroy a height-field shape
void destroyHeightFieldShape(HeightFieldShape* heightFieldShape);
/// Create and return a concave mesh shape
ConcaveMeshShape* createConcaveMeshShape(TriangleMesh* triangleMesh, const Vector3& scaling = Vector3(1, 1, 1));
/// Destroy a concave mesh shape
void destroyConcaveMeshShape(ConcaveMeshShape* concaveMeshShape);
/// Create a polyhedron mesh
PolyhedronMesh* createPolyhedronMesh(PolygonVertexArray* polygonVertexArray);
/// Destroy a polyhedron mesh
void destroyPolyhedronMesh(PolyhedronMesh* polyhedronMesh);
/// Create a triangle mesh
TriangleMesh* createTriangleMesh();
/// Destroy a triangle mesh
void destroyTriangleMesh(TriangleMesh* triangleMesh);
/// Create and return a new default logger
DefaultLogger* createDefaultLogger();
/// Destroy a default logger
void destroyDefaultLogger(DefaultLogger* logger);
/// Return the current logger
static Logger* getLogger();
/// Set the logger
static void setLogger(Logger* logger);
};
// Return the current logger
/**
* @return A pointer to the current logger
*/
inline Logger* PhysicsCommon::getLogger() {
return mLogger;
}
// Set the logger
/**
* @param logger A pointer to the logger to use
*/
inline void PhysicsCommon::setLogger(Logger* logger) {
mLogger = logger;
}
// Use this macro to log something
#define RP3D_LOG(physicsWorldName, level, category, message, filename, lineNumber) if (reactphysics3d::PhysicsCommon::getLogger() != nullptr) PhysicsCommon::getLogger()->log(level, physicsWorldName, category, message, filename, lineNumber)
}
#endif

747
include/reactphysics3d/engine/PhysicsWorld.h Normal file
View File

@ -0,0 +1,747 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_PHYSICS_WORLD_H
#define REACTPHYSICS3D_PHYSICS_WORLD_H
// Libraries
#include <reactphysics3d/mathematics/mathematics.h>
#include <reactphysics3d/containers/List.h>
#include <reactphysics3d/constraint/Joint.h>
#include <reactphysics3d/memory/MemoryManager.h>
#include <reactphysics3d/engine/EntityManager.h>
#include <reactphysics3d/components/CollisionBodyComponents.h>
#include <reactphysics3d/components/RigidBodyComponents.h>
#include <reactphysics3d/components/TransformComponents.h>
#include <reactphysics3d/components/ColliderComponents.h>
#include <reactphysics3d/components/JointComponents.h>
#include <reactphysics3d/components/BallAndSocketJointComponents.h>
#include <reactphysics3d/components/FixedJointComponents.h>
#include <reactphysics3d/components/HingeJointComponents.h>
#include <reactphysics3d/components/SliderJointComponents.h>
#include <reactphysics3d/collision/CollisionCallback.h>
#include <reactphysics3d/collision/OverlapCallback.h>
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/utils/Logger.h>
#include <reactphysics3d/systems/ConstraintSolverSystem.h>
#include <reactphysics3d/systems/CollisionDetectionSystem.h>
#include <reactphysics3d/systems/ContactSolverSystem.h>
#include <reactphysics3d/systems/DynamicsSystem.h>
#include <reactphysics3d/engine/Islands.h>
#include <reactphysics3d/utils/DebugRenderer.h>
#include <sstream>
/// Namespace ReactPhysics3D
namespace reactphysics3d {
// Declarations
class Island;
class RigidBody;
struct JointInfo;
// Class PhysicsWorld
/**
* This class represents a physics world.
*/
class PhysicsWorld {
public:
/// Structure WorldSettings
/**
* This class is used to describe some settings of a physics world.
*/
struct WorldSettings {
/// Name of the world
std::string worldName;
/// Gravity force vector of the world (in Newtons)
Vector3 gravity;
/// Distance threshold for two contact points for a valid persistent contact (in meters)
decimal persistentContactDistanceThreshold;
/// Default friction coefficient for a rigid body
decimal defaultFrictionCoefficient;
/// Default bounciness factor for a rigid body
decimal defaultBounciness;
/// Velocity threshold for contact velocity restitution
decimal restitutionVelocityThreshold;
/// Default rolling resistance
decimal defaultRollingRestistance;
/// True if the sleeping technique is enabled
bool isSleepingEnabled;
/// Number of iterations when solving the velocity constraints of the Sequential Impulse technique
uint defaultVelocitySolverNbIterations;
/// Number of iterations when solving the position constraints of the Sequential Impulse technique
uint defaultPositionSolverNbIterations;
/// Time (in seconds) that a body must stay still to be considered sleeping
float defaultTimeBeforeSleep;
/// A body with a linear velocity smaller than the sleep linear velocity (in m/s)
/// might enter sleeping mode.
decimal defaultSleepLinearVelocity;
/// A body with angular velocity smaller than the sleep angular velocity (in rad/s)
/// might enter sleeping mode
decimal defaultSleepAngularVelocity;
/// Maximum number of contact manifolds in an overlapping pair
uint nbMaxContactManifolds;
/// This is used to test if two contact manifold are similar (same contact normal) in order to
/// merge them. If the cosine of the angle between the normals of the two manifold are larger
/// than the value bellow, the manifold are considered to be similar.
decimal cosAngleSimilarContactManifold;
WorldSettings() {
worldName = "";
gravity = Vector3(0, decimal(-9.81), 0);
persistentContactDistanceThreshold = decimal(0.03);
defaultFrictionCoefficient = decimal(0.3);
defaultBounciness = decimal(0.5);
restitutionVelocityThreshold = decimal(0.5);
defaultRollingRestistance = decimal(0.0);
isSleepingEnabled = true;
defaultVelocitySolverNbIterations = 10;
defaultPositionSolverNbIterations = 5;
defaultTimeBeforeSleep = 1.0f;
defaultSleepLinearVelocity = decimal(0.02);
defaultSleepAngularVelocity = decimal(3.0) * (PI / decimal(180.0));
nbMaxContactManifolds = 3;
cosAngleSimilarContactManifold = decimal(0.95);
}
~WorldSettings() = default;
/// Return a string with the world settings
std::string to_string() const {
std::stringstream ss;
ss << "worldName=" << worldName << std::endl;
ss << "gravity=" << gravity.to_string() << std::endl;
ss << "persistentContactDistanceThreshold=" << persistentContactDistanceThreshold << std::endl;
ss << "defaultFrictionCoefficient=" << defaultFrictionCoefficient << std::endl;
ss << "defaultBounciness=" << defaultBounciness << std::endl;
ss << "restitutionVelocityThreshold=" << restitutionVelocityThreshold << std::endl;
ss << "defaultRollingRestistance=" << defaultRollingRestistance << std::endl;
ss << "isSleepingEnabled=" << isSleepingEnabled << std::endl;
ss << "defaultVelocitySolverNbIterations=" << defaultVelocitySolverNbIterations << std::endl;
ss << "defaultPositionSolverNbIterations=" << defaultPositionSolverNbIterations << std::endl;
ss << "defaultTimeBeforeSleep=" << defaultTimeBeforeSleep << std::endl;
ss << "defaultSleepLinearVelocity=" << defaultSleepLinearVelocity << std::endl;
ss << "defaultSleepAngularVelocity=" << defaultSleepAngularVelocity << std::endl;
ss << "nbMaxContactManifolds=" << nbMaxContactManifolds << std::endl;
ss << "cosAngleSimilarContactManifold=" << cosAngleSimilarContactManifold << std::endl;
return ss.str();
}
};
protected :
// -------------------- Attributes -------------------- //
/// Memory manager
MemoryManager& mMemoryManager;
/// Configuration of the physics world
WorldSettings mConfig;
/// Entity Manager for the ECS
EntityManager mEntityManager;
/// Debug renderer
DebugRenderer mDebugRenderer;
/// True if debug rendering is enabled
bool mIsDebugRenderingEnabled;
/// Collision Body Components
CollisionBodyComponents mCollisionBodyComponents;
/// Rigid Body Components
RigidBodyComponents mRigidBodyComponents;
/// Transform Components
TransformComponents mTransformComponents;
/// Collider Components
ColliderComponents mCollidersComponents;
/// Joint Components
JointComponents mJointsComponents;
/// Ball And Socket joints Components
BallAndSocketJointComponents mBallAndSocketJointsComponents;
/// Fixed joints Components
FixedJointComponents mFixedJointsComponents;
/// Hinge joints Components
HingeJointComponents mHingeJointsComponents;
/// Slider joints Components
SliderJointComponents mSliderJointsComponents;
/// Reference to the collision detection
CollisionDetectionSystem mCollisionDetection;
/// All the collision bodies of the world
List<CollisionBody*> mCollisionBodies;
/// Pointer to an event listener object
EventListener* mEventListener;
/// Name of the physics world
std::string mName;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Real-time hierarchical profiler
Profiler* mProfiler;
#endif
/// Total number of worlds
static uint mNbWorlds;
/// All the islands of bodies of the current frame
Islands mIslands;
/// Contact solver system
ContactSolverSystem mContactSolverSystem;
/// Constraint solver system
ConstraintSolverSystem mConstraintSolverSystem;
/// Dynamics system
DynamicsSystem mDynamicsSystem;
/// Number of iterations for the velocity solver of the Sequential Impulses technique
uint mNbVelocitySolverIterations;
/// Number of iterations for the position solver of the Sequential Impulses technique
uint mNbPositionSolverIterations;
/// True if the spleeping technique for inactive bodies is enabled
bool mIsSleepingEnabled;
/// All the rigid bodies of the physics world
List<RigidBody*> mRigidBodies;
/// True if the gravity force is on
bool mIsGravityEnabled;
/// Sleep linear velocity threshold
decimal mSleepLinearVelocity;
/// Sleep angular velocity threshold
decimal mSleepAngularVelocity;
/// Time (in seconds) before a body is put to sleep if its velocity
/// becomes smaller than the sleep velocity.
decimal mTimeBeforeSleep;
/// Current joint id
uint mCurrentJointId;
// -------------------- Methods -------------------- //
/// Constructor
PhysicsWorld(MemoryManager& memoryManager, const WorldSettings& worldSettings = WorldSettings(), Profiler* profiler = nullptr);
/// Notify the world if a body is disabled (slepping or inactive) or not
void setBodyDisabled(Entity entity, bool isDisabled);
/// Notify the world whether a joint is disabled or not
void setJointDisabled(Entity jointEntity, bool isDisabled);
/// Solve the contacts and constraints
void solveContactsAndConstraints(decimal timeStep);
/// Solve the position error correction of the constraints
void solvePositionCorrection();
/// Compute the islands of awake bodies.
void computeIslands();
/// Compute the islands using potential contacts and joints and create the actual contacts.
void createIslands();
/// Put bodies to sleep if needed.
void updateSleepingBodies(decimal timeStep);
/// Add the joint to the list of joints of the two bodies involved in the joint
void addJointToBodies(Entity body1, Entity body2, Entity joint);
/// Destructor
~PhysicsWorld();
public :
// -------------------- Methods -------------------- //
/// Create a collision body
CollisionBody* createCollisionBody(const Transform& transform);
/// Destroy a collision body
void destroyCollisionBody(CollisionBody* collisionBody);
/// Get the collision dispatch configuration
CollisionDispatch& getCollisionDispatch();
/// Ray cast method
void raycast(const Ray& ray, RaycastCallback* raycastCallback, unsigned short raycastWithCategoryMaskBits = 0xFFFF) const;
/// Return true if two bodies overlap (collide)
bool testOverlap(CollisionBody* body1, CollisionBody* body2);
/// Report all the bodies that overlap (collide) with the body in parameter
void testOverlap(CollisionBody* body, OverlapCallback& overlapCallback);
/// Report all the bodies that overlap (collide) in the world
void testOverlap(OverlapCallback& overlapCallback);
/// Test collision and report contacts between two bodies.
void testCollision(CollisionBody* body1, CollisionBody* body2, CollisionCallback& callback);
/// Test collision and report all the contacts involving the body in parameter
void testCollision(CollisionBody* body, CollisionCallback& callback);
/// Test collision and report contacts between each colliding bodies in the world
void testCollision(CollisionCallback& callback);
/// Return a reference to the memory manager of the world
MemoryManager& getMemoryManager();
/// Return the current world-space AABB of given collider
AABB getWorldAABB(const Collider* collider) const;
/// Return the name of the world
const std::string& getName() const;
/// Deleted copy-constructor
PhysicsWorld(const PhysicsWorld& world) = delete;
/// Deleted assignment operator
PhysicsWorld& operator=(const PhysicsWorld& world) = delete;
/// Update the physics simulation
void update(decimal timeStep);
/// Get the number of iterations for the velocity constraint solver
uint getNbIterationsVelocitySolver() const;
/// Set the number of iterations for the velocity constraint solver
void setNbIterationsVelocitySolver(uint nbIterations);
/// Get the number of iterations for the position constraint solver
uint getNbIterationsPositionSolver() const;
/// Set the number of iterations for the position constraint solver
void setNbIterationsPositionSolver(uint nbIterations);
/// Set the position correction technique used for contacts
void setContactsPositionCorrectionTechnique(ContactsPositionCorrectionTechnique technique);
/// Set the position correction technique used for joints
void setJointsPositionCorrectionTechnique(JointsPositionCorrectionTechnique technique);
/// Create a rigid body into the physics world.
RigidBody* createRigidBody(const Transform& transform);
/// Disable the joints for pair of sleeping bodies
void disableJointsOfSleepingBodies();
/// Destroy a rigid body and all the joints which it belongs
void destroyRigidBody(RigidBody* rigidBody);
/// Create a joint between two bodies in the world and return a pointer to the new joint
Joint* createJoint(const JointInfo& jointInfo);
/// Destroy a joint
void destroyJoint(Joint* joint);
/// Return the gravity vector of the world
Vector3 getGravity() const;
/// Set the gravity vector of the world
void setGravity(Vector3& gravity);
/// Return if the gravity is on
bool isGravityEnabled() const;
/// Enable/Disable the gravity
void setIsGravityEnabled(bool isGravityEnabled);
/// Return true if the sleeping technique is enabled
bool isSleepingEnabled() const;
/// Enable/Disable the sleeping technique
void enableSleeping(bool isSleepingEnabled);
/// Return the current sleep linear velocity
decimal getSleepLinearVelocity() const;
/// Set the sleep linear velocity.
void setSleepLinearVelocity(decimal sleepLinearVelocity);
/// Return the current sleep angular velocity
decimal getSleepAngularVelocity() const;
/// Set the sleep angular velocity.
void setSleepAngularVelocity(decimal sleepAngularVelocity);
/// Return the time a body is required to stay still before sleeping
decimal getTimeBeforeSleep() const;
/// Set the time a body is required to stay still before sleeping
void setTimeBeforeSleep(decimal timeBeforeSleep);
/// Set an event listener object to receive events callbacks.
void setEventListener(EventListener* eventListener);
/// Return the number of CollisionBody in the physics world
uint getNbCollisionBodies() const;
/// Return a constant pointer to a given CollisionBody of the world
const CollisionBody* getCollisionBody(uint index) const;
/// Return a pointer to a given CollisionBody of the world
CollisionBody* getCollisionBody(uint index) ;
/// Return the number of RigidBody in the physics world
uint getNbRigidBodies() const;
/// Return a constant pointer to a given RigidBody of the world
const RigidBody* getRigidBody(uint index) const;
/// Return a pointer to a given RigidBody of the world
RigidBody* getRigidBody(uint index) ;
/// Return true if the debug rendering is enabled
bool getIsDebugRenderingEnabled() const;
/// Set to true if debug rendering is enabled
void setIsDebugRenderingEnabled(bool isEnabled);
/// Return a reference to the Debug Renderer of the world
DebugRenderer& getDebugRenderer();
#ifdef IS_RP3D_PROFILING_ENABLED
/// Return a reference to the profiler
Profiler* getProfiler();
#endif
// -------------------- Friendship -------------------- //
friend class CollisionDetectionSystem;
friend class CollisionBody;
friend class Collider;
friend class ConvexMeshShape;
friend class CollisionCallback::ContactPair;
friend class OverlapCallback::OverlapPair;
friend class PhysicsCommon;
friend class RigidBody;
friend class Joint;
friend class BallAndSocketJoint;
friend class FixedJoint;
friend class HingeJoint;
friend class SliderJoint;
friend class CollisionCallback::CallbackData;
friend class OverlapCallback::CallbackData;
friend class DebugRenderer;
};
// Set the collision dispatch configuration
/// This can be used to replace default collision detection algorithms by your
/// custom algorithm for instance.
/**
* @param CollisionDispatch Pointer to a collision dispatch object describing
* which collision detection algorithm to use for two given collision shapes
*/
inline CollisionDispatch& PhysicsWorld::getCollisionDispatch() {
return mCollisionDetection.getCollisionDispatch();
}
// Ray cast method
/**
* @param ray Ray to use for raycasting
* @param raycastCallback Pointer to the class with the callback method
* @param raycastWithCategoryMaskBits Bits mask corresponding to the category of
* bodies to be raycasted
*/
inline void PhysicsWorld::raycast(const Ray& ray,
RaycastCallback* raycastCallback,
unsigned short raycastWithCategoryMaskBits) const {
mCollisionDetection.raycast(raycastCallback, ray, raycastWithCategoryMaskBits);
}
// Test collision and report contacts between two bodies.
/// Use this method if you only want to get all the contacts between two bodies.
/// All the contacts will be reported using the callback object in paramater.
/// If you are not interested in the contacts but you only want to know if the bodies collide,
/// you can use the testOverlap() method instead.
/**
* @param body1 Pointer to the first body to test
* @param body2 Pointer to the second body to test
* @param callback Pointer to the object with the callback method
*/
inline void PhysicsWorld::testCollision(CollisionBody* body1, CollisionBody* body2, CollisionCallback& callback) {
mCollisionDetection.testCollision(body1, body2, callback);
}
// Test collision and report all the contacts involving the body in parameter
/// Use this method if you only want to get all the contacts involving a given body.
/// All the contacts will be reported using the callback object in paramater.
/// If you are not interested in the contacts but you only want to know if the bodies collide,
/// you can use the testOverlap() method instead.
/**
* @param body Pointer to the body against which we need to test collision
* @param callback Pointer to the object with the callback method to report contacts
*/
inline void PhysicsWorld::testCollision(CollisionBody* body, CollisionCallback& callback) {
mCollisionDetection.testCollision(body, callback);
}
// Test collision and report contacts between each colliding bodies in the world
/// Use this method if you want to get all the contacts between colliding bodies in the world.
/// All the contacts will be reported using the callback object in paramater.
/// If you are not interested in the contacts but you only want to know if the bodies collide,
/// you can use the testOverlap() method instead.
/**
* @param callback Pointer to the object with the callback method to report contacts
*/
inline void PhysicsWorld::testCollision(CollisionCallback& callback) {
mCollisionDetection.testCollision(callback);
}
// Report all the bodies that overlap (collide) with the body in parameter
/// Use this method if you are not interested in contacts but if you simply want to know
/// which bodies overlap with the body in parameter. If you want to get the contacts, you need to use the
/// testCollision() method instead.
/**
* @param body Pointer to the collision body to test overlap with
* @param overlapCallback Pointer to the callback class to report overlap
*/
inline void PhysicsWorld::testOverlap(CollisionBody* body, OverlapCallback& overlapCallback) {
mCollisionDetection.testOverlap(body, overlapCallback);
}
// Report all the bodies that overlap (collide) in the world
/// Use this method if you are not interested in contacts but if you simply want to know
/// which bodies overlap. If you want to get the contacts, you need to use the
/// testCollision() method instead.
/**
* @param overlapCallback Pointer to the callback class to report overlap
*/
inline void PhysicsWorld::testOverlap(OverlapCallback& overlapCallback) {
mCollisionDetection.testOverlap(overlapCallback);
}
// Return a reference to the memory manager of the world
inline MemoryManager& PhysicsWorld::getMemoryManager() {
return mMemoryManager;
}
// Return the name of the world
/**
* @return Name of the world
*/
inline const std::string& PhysicsWorld::getName() const {
return mName;
}
#ifdef IS_RP3D_PROFILING_ENABLED
// Return a pointer to the profiler
/**
* @return A pointer to the profiler
*/
inline Profiler* PhysicsWorld::getProfiler() {
return mProfiler;
}
#endif
// Get the number of iterations for the velocity constraint solver
/**
* @return The number of iterations of the velocity constraint solver
*/
inline uint PhysicsWorld::getNbIterationsVelocitySolver() const {
return mNbVelocitySolverIterations;
}
// Get the number of iterations for the position constraint solver
/**
* @return The number of iterations of the position constraint solver
*/
inline uint PhysicsWorld::getNbIterationsPositionSolver() const {
return mNbPositionSolverIterations;
}
// Set the position correction technique used for contacts
/**
* @param technique Technique used for the position correction (Baumgarte or Split Impulses)
*/
inline void PhysicsWorld::setContactsPositionCorrectionTechnique(
ContactsPositionCorrectionTechnique technique) {
if (technique == ContactsPositionCorrectionTechnique::BAUMGARTE_CONTACTS) {
mContactSolverSystem.setIsSplitImpulseActive(false);
}
else {
mContactSolverSystem.setIsSplitImpulseActive(true);
}
}
// Set the position correction technique used for joints
/**
* @param technique Technique used for the joins position correction (Baumgarte or Non Linear Gauss Seidel)
*/
inline void PhysicsWorld::setJointsPositionCorrectionTechnique(
JointsPositionCorrectionTechnique technique) {
if (technique == JointsPositionCorrectionTechnique::BAUMGARTE_JOINTS) {
mConstraintSolverSystem.setIsNonLinearGaussSeidelPositionCorrectionActive(false);
}
else {
mConstraintSolverSystem.setIsNonLinearGaussSeidelPositionCorrectionActive(true);
}
}
// Return the gravity vector of the world
/**
* @return The current gravity vector (in meter per seconds squared)
*/
inline Vector3 PhysicsWorld::getGravity() const {
return mConfig.gravity;
}
// Return if the gravity is enaled
/**
* @return True if the gravity is enabled in the world
*/
inline bool PhysicsWorld::isGravityEnabled() const {
return mIsGravityEnabled;
}
// Return true if the sleeping technique is enabled
/**
* @return True if the sleeping technique is enabled and false otherwise
*/
inline bool PhysicsWorld::isSleepingEnabled() const {
return mIsSleepingEnabled;
}
// Return the current sleep linear velocity
/**
* @return The sleep linear velocity (in meters per second)
*/
inline decimal PhysicsWorld::getSleepLinearVelocity() const {
return mSleepLinearVelocity;
}
// Return the current sleep angular velocity
/**
* @return The sleep angular velocity (in radian per second)
*/
inline decimal PhysicsWorld::getSleepAngularVelocity() const {
return mSleepAngularVelocity;
}
// Return the time a body is required to stay still before sleeping
/**
* @return Time a body is required to stay still before sleeping (in seconds)
*/
inline decimal PhysicsWorld::getTimeBeforeSleep() const {
return mTimeBeforeSleep;
}
// Set an event listener object to receive events callbacks.
/// If you use "nullptr" as an argument, the events callbacks will be disabled.
/**
* @param eventListener Pointer to the event listener object that will receive
* event callbacks during the simulation
*/
inline void PhysicsWorld::setEventListener(EventListener* eventListener) {
mEventListener = eventListener;
}
// Return the number of CollisionBody in the physics world
/// Note that even if a RigidBody is also a collision body, this method does not return the rigid bodies
/**
* @return The number of collision bodies in the physics world
*/
inline uint PhysicsWorld::getNbCollisionBodies() const {
return mCollisionBodies.size();
}
// Return the number of RigidBody in the physics world
/**
* @return The number of rigid bodies in the physics world
*/
inline uint PhysicsWorld::getNbRigidBodies() const {
return mRigidBodies.size();
}
// Return true if the debug rendering is enabled
/**
* @return True if the debug rendering is enabled and false otherwise
*/
inline bool PhysicsWorld::getIsDebugRenderingEnabled() const {
return mIsDebugRenderingEnabled;
}
// Set to true if debug rendering is enabled
/**
* @param isEnabled True if you want to enable the debug rendering and false otherwise
*/
inline void PhysicsWorld::setIsDebugRenderingEnabled(bool isEnabled) {
mIsDebugRenderingEnabled = isEnabled;
}
// Return a reference to the Debug Renderer of the world
/**
* @return A reference to the DebugRenderer object of the world
*/
inline DebugRenderer& PhysicsWorld::getDebugRenderer() {
return mDebugRenderer;
}
}
#endif

4
src/engine/Timer.h → include/reactphysics3d/engine/Timer.h
View File

@ -1,6 +1,6 @@
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2019 Daniel Chappuis *
* Copyright (c) 2010-2020 Daniel Chappuis *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
@ -29,7 +29,7 @@
// Libraries
#include <ctime>
#include <cassert>
#include "configuration.h"
#include <reactphysics3d/configuration.h>
#if defined(WINDOWS_OS) // For Windows platform
#define NOMINMAX // This is used to avoid definition of max() and min() macros

Some files were not shown because too many files have changed in this diff Show More