EVEngine/Physics_8cpp_source.html

#include "physics/Physics.h"

#include "physics/Body.h"

#include "physics/Body3D.h"

#include "physics/Joint2D.h"

#include "physics/Joint3D.h"

#include "physics/Mechanism2D.h"

#include "physics/Mechanism3D.h"

#include "physics/DistanceField3D.h"

#include "physics/softbody/SoftBody3D.h"

#include "physics/softbody/graphics/SoftBody3DRenderer.h"

#include "physics/Fixture.h"

#include "physics/Fluid2D.h"

#include "physics/PhysicsCapabilities.h"

#include "physics/Shape3D.h"

#include "physics/World.h"

#include "physics/World3D.h"

#include "physics/TerrainLoadGravity.h"


#include "common/Exception.h"

#include "common/SquirrelBinding.h"


#include <simplesquirrel/simplesquirrel.hpp>


#include <vector>

#include <algorithm>


namespace eve::physics {


Physics::Physics() { registerPhysicsCapabilities(); }


Module_IMPL(Physics, new Physics());


void Physics::setMeter(float pixelsPerMeter) {

    if (pixelsPerMeter <= 0.f)

        throw Exception("Physics.setMeter: pixelsPerMeter must be > 0");

    meter_ = pixelsPerMeter;

}


float Physics::getMeter() const { return meter_; }


World *Physics::newWorld(float gravityX, float gravityY, bool sleep) {

    return new World(gravityX, gravityY, sleep, meter_);

}


World3D *Physics::newWorld3D(float gravityX, float gravityY, float gravityZ, bool sleep) {

    return new World3D(gravityX, gravityY, gravityZ, sleep);

}


DistanceField3D *Physics::newDistanceField3D(int width, int height, int depth, float cellSize,

                                             float originX, float originY, float originZ,

                                             float outsideDistance) {

    return new DistanceField3D(width, height, depth, cellSize, originX, originY, originZ,

                               outsideDistance);

}


SoftBody3D *Physics::newSoftBody3D(int cols, int rows, int layers, float spacing,

                                    float originX, float originY, float originZ) {

    auto created = SoftBody3D::create(cols, rows, layers, spacing, originX, originY, originZ);

    if (!created) throw Exception("%s", created.status().describe().c_str());

    return std::move(created).takeValue().release();

}


SoftBody3DRenderer *Physics::newSoftBody3DRenderer(SoftBody3D *body) {

    return new SoftBody3DRenderer(body);

}


Fluid2D *Physics::newFluid2D(int capacity) { return new Fluid2D(capacity); }


void Physics::expose(ssq::Table &table) {

    auto cls = table.addClass(name, Physics::create, false);

    expose(cls);

    auto terrainLoadState = table.addClass<TerrainLoadGravityState>("TerrainLoadGravityState");

    terrainLoadState.addFunc("isMonitoring", &TerrainLoadGravityState::isMonitoring);

    terrainLoadState.addFunc("isActivationScheduled",

                             &TerrainLoadGravityState::isActivationScheduled);

    terrainLoadState.addFunc("isCompleted", &TerrainLoadGravityState::isCompleted);

    terrainLoadState.addFunc("getDelayElapsed", &TerrainLoadGravityState::getDelayElapsed);

    table.addFunc("beginTerrainLoadGravity",

                  [vm = table.getHandle()](TerrainLoadGravityState* state, Body3D* body,

                                           bool terrainFound) {

        return eve::script::projectResult(vm,

                                          beginTerrainLoadGravity(state, body, terrainFound));

    });

    table.addFunc("advanceTerrainLoadGravity",

                  [vm = table.getHandle()](TerrainLoadGravityState* state, Body3D* body,

                                           bool terrainLoaded, float dt, float delay) {

        return eve::script::projectResult(

            vm, advanceTerrainLoadGravity(state, body, terrainLoaded, dt, delay),

            [](bool activated) { return eve::Value(activated); });

    });


    auto world = table.addClass<World>(

        "World", std::function<World *()>([]() -> World * { return nullptr; }), true);

    world.addFunc("update", &World::update);

    world.addFunc("updateFull", &World::updateFull);

    world.addFunc("setGravity", &World::setGravity);

    world.addFunc("getGravityX", &World::getGravityX);

    world.addFunc("getGravityY", &World::getGravityY);

    world.addFunc("setMeter", &World::setMeter);

    world.addFunc("getMeter", &World::getMeter);

    world.addFunc("newBody", &World::newBody);

    world.addFunc("newDistanceJoint", &World::newDistanceJoint);

    world.addFunc("newRevoluteJoint", &World::newRevoluteJoint);

    world.addFunc("newPrismaticJoint", &World::newPrismaticJoint);

    world.addFunc("newWeldJoint", &World::newWeldJoint);

    world.addFunc("newWheelJoint", &World::newWheelJoint);

    world.addFunc("newMotorJoint", &World::newMotorJoint);

    world.addFunc("newGearJoint", &World::newGearJoint);

    world.addFunc("newShaft", &World::newShaft);

    world.addFunc("newRatchet", &World::newRatchet);

    world.addFunc("newCrankSlider", &World::newCrankSlider);

    world.addFunc("destroyBody", &World::destroyBody);

    world.addFunc("destroy", &World::destroy);

    world.addFunc("drawDebug", &World::drawDebug);

    world.addFunc("rayCast", &World::rayCast);

    world.addFunc("hasRayHit", &World::hasRayHit);

    world.addFunc("getRayHitBodyId", &World::getRayHitBodyId);

    world.addFunc("getRayHitX", &World::getRayHitX);

    world.addFunc("getRayHitY", &World::getRayHitY);

    world.addFunc("getRayHitNormalX", &World::getRayHitNormalX);

    world.addFunc("getRayHitNormalY", &World::getRayHitNormalY);

    world.addFunc("getRayHitFraction", &World::getRayHitFraction);

    world.addFunc("queryAABB", &World::queryAABB);

    world.addFunc("getQueryCount", &World::getQueryCount);

    world.addFunc("getQueryBodyId", &World::getQueryBodyId);

    world.addFunc("getBeginContactCount", &World::getBeginContactCount);

    world.addFunc("getBeginContactBodyAId", &World::getBeginContactBodyAId);

    world.addFunc("getBeginContactBodyBId", &World::getBeginContactBodyBId);

    world.addFunc("getBeginContactFixtureATag", &World::getBeginContactFixtureATag);

    world.addFunc("getBeginContactFixtureBTag", &World::getBeginContactFixtureBTag);

    world.addFunc("getEndContactCount", &World::getEndContactCount);

    world.addFunc("getEndContactBodyAId", &World::getEndContactBodyAId);

    world.addFunc("getEndContactBodyBId", &World::getEndContactBodyBId);

    world.addFunc("getEndContactFixtureATag", &World::getEndContactFixtureATag);

    world.addFunc("getEndContactFixtureBTag", &World::getEndContactFixtureBTag);

    world.addFunc("getImpactCount", &World::getImpactCount);

    world.addFunc("getImpactBodyAId", &World::getImpactBodyAId);

    world.addFunc("getImpactBodyBId", &World::getImpactBodyBId);

    world.addFunc("getImpactFixtureATag", &World::getImpactFixtureATag);

    world.addFunc("getImpactFixtureBTag", &World::getImpactFixtureBTag);

    world.addFunc("getImpactPointX", &World::getImpactPointX);

    world.addFunc("getImpactPointY", &World::getImpactPointY);

    world.addFunc("getImpactNormalX", &World::getImpactNormalX);

    world.addFunc("getImpactNormalY", &World::getImpactNormalY);

    world.addFunc("getImpactRelativeNormalSpeed", &World::getImpactRelativeNormalSpeed);

    world.addFunc("getImpactNormalImpulse", &World::getImpactNormalImpulse);

    world.addFunc("getImpactTangentImpulse", &World::getImpactTangentImpulse);

    world.addFunc("clearContactEvents", &World::clearContactEvents);


    auto world3 = table.addClass<World3D>(

        "World3D", std::function<World3D *()>([]() -> World3D * { return nullptr; }), true);

    world3.addFunc("update", &World3D::update);

    world3.addFunc("updateFull", &World3D::updateFull);

    world3.addFunc("setGravity", &World3D::setGravity);

    world3.addFunc("getGravityX", &World3D::getGravityX);

    world3.addFunc("getGravityY", &World3D::getGravityY);

    world3.addFunc("getGravityZ", &World3D::getGravityZ);

    world3.addFunc("setContinuousCollisionEnabled", &World3D::setContinuousCollisionEnabled);

    world3.addFunc("isContinuousCollisionEnabled", &World3D::isContinuousCollisionEnabled);

    world3.addFunc("setRestitutionThreshold", &World3D::setRestitutionThreshold);

    world3.addFunc("getRestitutionThreshold", &World3D::getRestitutionThreshold);

    world3.addFunc("setHitEventThreshold", &World3D::setHitEventThreshold);

    world3.addFunc("getHitEventThreshold", &World3D::getHitEventThreshold);

    world3.addFunc("setBodyPairCollisionEnabled", &World3D::setBodyPairCollisionEnabled);

    world3.addFunc("isBodyPairCollisionEnabled", &World3D::isBodyPairCollisionEnabled);

    world3.addFunc("setShapePairCollisionEnabled", &World3D::setShapePairCollisionEnabled);

    world3.addFunc("isShapePairCollisionEnabled", &World3D::isShapePairCollisionEnabled);

    world3.addFunc("setContactTuning", &World3D::setContactTuning);

    world3.addFunc("getContactHertz", &World3D::getContactHertz);

    world3.addFunc("getContactDampingRatio", &World3D::getContactDampingRatio);

    world3.addFunc("getContactPushOutSpeed", &World3D::getContactPushOutSpeed);

    world3.addFunc("setContactRecycleDistance", &World3D::setContactRecycleDistance);

    world3.addFunc("getContactRecycleDistance", &World3D::getContactRecycleDistance);

    world3.addFunc("setMaximumLinearSpeed", &World3D::setMaximumLinearSpeed);

    world3.addFunc("getMaximumLinearSpeed", &World3D::getMaximumLinearSpeed);

    world3.addFunc("setWarmStartingEnabled", &World3D::setWarmStartingEnabled);

    world3.addFunc("isWarmStartingEnabled", &World3D::isWarmStartingEnabled);

    world3.addFunc("explode", &World3D::explode);

    world3.addFunc("getExplosionResultCount", &World3D::getExplosionResultCount);

    world3.addFunc("getExplosionResultBodyId", &World3D::getExplosionResultBodyId);

    world3.addFunc("getExplosionResultDeltaVelocityX",

                   &World3D::getExplosionResultDeltaVelocityX);

    world3.addFunc("getExplosionResultDeltaVelocityY",

                   &World3D::getExplosionResultDeltaVelocityY);

    world3.addFunc("getExplosionResultDeltaVelocityZ",

                   &World3D::getExplosionResultDeltaVelocityZ);

    world3.addFunc("getExplosionResultDeltaAngularVelocityX",

                   &World3D::getExplosionResultDeltaAngularVelocityX);

    world3.addFunc("getExplosionResultDeltaAngularVelocityY",

                   &World3D::getExplosionResultDeltaAngularVelocityY);

    world3.addFunc("getExplosionResultDeltaAngularVelocityZ",

                   &World3D::getExplosionResultDeltaAngularVelocityZ);

    world3.addFunc("getBoundsMinX", &World3D::getBoundsMinX);

    world3.addFunc("getBoundsMinY", &World3D::getBoundsMinY);

    world3.addFunc("getBoundsMinZ", &World3D::getBoundsMinZ);

    world3.addFunc("getBoundsMaxX", &World3D::getBoundsMaxX);

    world3.addFunc("getBoundsMaxY", &World3D::getBoundsMaxY);

    world3.addFunc("getBoundsMaxZ", &World3D::getBoundsMaxZ);

    world3.addFunc("getBodyCount", &World3D::getBodyCount);

    world3.addFunc("getShapeCount", &World3D::getShapeCount);

    world3.addFunc("getContactCount", &World3D::getContactCount);

    world3.addFunc("getJointCount", &World3D::getJointCount);

    world3.addFunc("getIslandCount", &World3D::getIslandCount);

    world3.addFunc("getAwakeBodyCount", &World3D::getAwakeBodyCount);

    world3.addFunc("getAwakeContactCount", &World3D::getAwakeContactCount);

    world3.addFunc("getRecycledContactCount", &World3D::getRecycledContactCount);

    world3.addFunc("getStaticTreeHeight", &World3D::getStaticTreeHeight);

    world3.addFunc("getDynamicTreeHeight", &World3D::getDynamicTreeHeight);

    world3.addFunc("getMemoryByteCount", &World3D::getMemoryByteCount);

    world3.addFunc("getProfileStepMs", &World3D::getProfileStepMs);

    world3.addFunc("getProfilePairsMs", &World3D::getProfilePairsMs);

    world3.addFunc("getProfileCollideMs", &World3D::getProfileCollideMs);

    world3.addFunc("getProfileSolveMs", &World3D::getProfileSolveMs);

    world3.addFunc("getProfileBulletsMs", &World3D::getProfileBulletsMs);

    world3.addFunc("getProfileSensorsMs", &World3D::getProfileSensorsMs);

    world3.addFunc("newBody", &World3D::newBody);

    world3.addFunc("newDistanceJoint", &World3D::newDistanceJoint);

    world3.addFunc("newRevoluteJoint", &World3D::newRevoluteJoint);

    world3.addFunc("newPrismaticJoint", &World3D::newPrismaticJoint);

    world3.addFunc("newSphericalJoint", &World3D::newSphericalJoint);

    world3.addFunc("newWheelJoint", &World3D::newWheelJoint);

    world3.addFunc("newWeldJoint", &World3D::newWeldJoint);

    world3.addFunc("newMotorJoint", &World3D::newMotorJoint);

    world3.addFunc("newParallelJoint", &World3D::newParallelJoint);

    world3.addFunc("newFilterJoint", &World3D::newFilterJoint);

    world3.addFunc("newShaft", &World3D::newShaft);

    world3.addFunc("newRatchet", &World3D::newRatchet);

    world3.addFunc("newCrankSlider", &World3D::newCrankSlider);

    world3.addFunc("destroyBody", &World3D::destroyBody);

    world3.addFunc("destroy", &World3D::destroy);

    world3.addFunc("rayCast", &World3D::rayCast);

    world3.addFunc("rayCastAll", &World3D::rayCastAll);

    world3.addFunc("hasRayHit", &World3D::hasRayHit);

    world3.addFunc("getRayHitBodyId", &World3D::getRayHitBodyId);

    world3.addFunc("getRayHitShapeId", &World3D::getRayHitShapeId);

    world3.addFunc("getRayHitShapeTag", &World3D::getRayHitShapeTag);

    world3.addFunc("getRayHitMaterialId", &World3D::getRayHitMaterialId);

    world3.addFunc("getRayHitTriangleIndex", &World3D::getRayHitTriangleIndex);

    world3.addFunc("getRayHitX", &World3D::getRayHitX);

    world3.addFunc("getRayHitY", &World3D::getRayHitY);

    world3.addFunc("getRayHitZ", &World3D::getRayHitZ);

    world3.addFunc("getRayHitNormalX", &World3D::getRayHitNormalX);

    world3.addFunc("getRayHitNormalY", &World3D::getRayHitNormalY);

    world3.addFunc("getRayHitNormalZ", &World3D::getRayHitNormalZ);

    world3.addFunc("getRayHitFraction", &World3D::getRayHitFraction);

    world3.addFunc("getRayResultCount", &World3D::getRayResultCount);

    world3.addFunc("getRayResultBodyId", &World3D::getRayResultBodyId);

    world3.addFunc("getRayResultShapeId", &World3D::getRayResultShapeId);

    world3.addFunc("getRayResultShapeTag", &World3D::getRayResultShapeTag);

    world3.addFunc("getRayResultMaterialId", &World3D::getRayResultMaterialId);

    world3.addFunc("getRayResultTriangleIndex", &World3D::getRayResultTriangleIndex);

    world3.addFunc("getRayResultX", &World3D::getRayResultX);

    world3.addFunc("getRayResultY", &World3D::getRayResultY);

    world3.addFunc("getRayResultZ", &World3D::getRayResultZ);

    world3.addFunc("getRayResultNormalX", &World3D::getRayResultNormalX);

    world3.addFunc("getRayResultNormalY", &World3D::getRayResultNormalY);

    world3.addFunc("getRayResultNormalZ", &World3D::getRayResultNormalZ);

    world3.addFunc("getRayResultFraction", &World3D::getRayResultFraction);

    world3.addFunc("queryAABB", &World3D::queryAABB);

    world3.addFunc("querySphere", &World3D::querySphere);

    world3.addFunc("queryCapsule", &World3D::queryCapsule);

    world3.addFunc("queryBox", &World3D::queryBox);

    world3.addFunc("castSphere", &World3D::castSphere);

    world3.addFunc("castSphereAll", &World3D::castSphereAll);

    world3.addFunc("castCapsule", &World3D::castCapsule);

    world3.addFunc("castCapsuleAll", &World3D::castCapsuleAll);

    world3.addFunc("castBox", &World3D::castBox);

    world3.addFunc("castBoxAll", &World3D::castBoxAll);

    world3.addFunc("closestPoint", &World3D::closestPoint);

    world3.addFunc("hasClosestPoint", &World3D::hasClosestPoint);

    world3.addFunc("getClosestBodyId", &World3D::getClosestBodyId);

    world3.addFunc("getClosestShapeId", &World3D::getClosestShapeId);

    world3.addFunc("getClosestShapeTag", &World3D::getClosestShapeTag);

    world3.addFunc("getClosestX", &World3D::getClosestX);

    world3.addFunc("getClosestY", &World3D::getClosestY);

    world3.addFunc("getClosestZ", &World3D::getClosestZ);

    world3.addFunc("getClosestNormalX", &World3D::getClosestNormalX);

    world3.addFunc("getClosestNormalY", &World3D::getClosestNormalY);

    world3.addFunc("getClosestNormalZ", &World3D::getClosestNormalZ);

    world3.addFunc("getClosestDistance", &World3D::getClosestDistance);

    world3.addFunc("hasShapeCastHit", &World3D::hasShapeCastHit);

    world3.addFunc("getShapeCastBodyId", &World3D::getShapeCastBodyId);

    world3.addFunc("getShapeCastShapeId", &World3D::getShapeCastShapeId);

    world3.addFunc("getShapeCastShapeTag", &World3D::getShapeCastShapeTag);

    world3.addFunc("getShapeCastMaterialId", &World3D::getShapeCastMaterialId);

    world3.addFunc("getShapeCastTriangleIndex", &World3D::getShapeCastTriangleIndex);

    world3.addFunc("getShapeCastX", &World3D::getShapeCastX);

    world3.addFunc("getShapeCastY", &World3D::getShapeCastY);

    world3.addFunc("getShapeCastZ", &World3D::getShapeCastZ);

    world3.addFunc("getShapeCastNormalX", &World3D::getShapeCastNormalX);

    world3.addFunc("getShapeCastNormalY", &World3D::getShapeCastNormalY);

    world3.addFunc("getShapeCastNormalZ", &World3D::getShapeCastNormalZ);

    world3.addFunc("getShapeCastFraction", &World3D::getShapeCastFraction);

    world3.addFunc("getShapeCastResultCount", &World3D::getShapeCastResultCount);

    world3.addFunc("getShapeCastResultBodyId", &World3D::getShapeCastResultBodyId);

    world3.addFunc("getShapeCastResultShapeId", &World3D::getShapeCastResultShapeId);

    world3.addFunc("getShapeCastResultShapeTag", &World3D::getShapeCastResultShapeTag);

    world3.addFunc("getShapeCastResultMaterialId", &World3D::getShapeCastResultMaterialId);

    world3.addFunc("getShapeCastResultTriangleIndex",

                   &World3D::getShapeCastResultTriangleIndex);

    world3.addFunc("getShapeCastResultX", &World3D::getShapeCastResultX);

    world3.addFunc("getShapeCastResultY", &World3D::getShapeCastResultY);

    world3.addFunc("getShapeCastResultZ", &World3D::getShapeCastResultZ);

    world3.addFunc("getShapeCastResultNormalX", &World3D::getShapeCastResultNormalX);

    world3.addFunc("getShapeCastResultNormalY", &World3D::getShapeCastResultNormalY);

    world3.addFunc("getShapeCastResultNormalZ", &World3D::getShapeCastResultNormalZ);

    world3.addFunc("getShapeCastResultFraction", &World3D::getShapeCastResultFraction);

    world3.addFunc("moveCapsule", &World3D::moveCapsule);

    world3.addFunc("getMoverDeltaX", &World3D::getMoverDeltaX);

    world3.addFunc("getMoverDeltaY", &World3D::getMoverDeltaY);

    world3.addFunc("getMoverDeltaZ", &World3D::getMoverDeltaZ);

    world3.addFunc("getMoverNormalX", &World3D::getMoverNormalX);

    world3.addFunc("getMoverNormalY", &World3D::getMoverNormalY);

    world3.addFunc("getMoverNormalZ", &World3D::getMoverNormalZ);

    world3.addFunc("getMoverPlaneCount", &World3D::getMoverPlaneCount);

    world3.addFunc("getMoverIterations", &World3D::getMoverIterations);

    world3.addFunc("setMoverUp", &World3D::setMoverUp);

    world3.addFunc("setMoverSlopeLimit", &World3D::setMoverSlopeLimit);

    world3.addFunc("isMoverGrounded", &World3D::isMoverGrounded);

    world3.addFunc("getMoverGroundDot", &World3D::getMoverGroundDot);

    world3.addFunc("getQueryCount", &World3D::getQueryCount);

    world3.addFunc("getQueryBodyId", &World3D::getQueryBodyId);

    world3.addFunc("getQueryShapeCount", &World3D::getQueryShapeCount);

    world3.addFunc("getQueryShapeId", &World3D::getQueryShapeId);

    world3.addFunc("getQueryShapeTag", &World3D::getQueryShapeTag);

    world3.addFunc("getBeginContactCount", &World3D::getBeginContactCount);

    world3.addFunc("getBeginContactBodyAId", &World3D::getBeginContactBodyAId);

    world3.addFunc("getBeginContactBodyBId", &World3D::getBeginContactBodyBId);

    world3.addFunc("getBeginContactShapeAId", &World3D::getBeginContactShapeAId);

    world3.addFunc("getBeginContactShapeBId", &World3D::getBeginContactShapeBId);

    world3.addFunc("getBeginContactShapeATag", &World3D::getBeginContactShapeATag);

    world3.addFunc("getBeginContactShapeBTag", &World3D::getBeginContactShapeBTag);

    world3.addFunc("getEndContactCount", &World3D::getEndContactCount);

    world3.addFunc("getEndContactBodyAId", &World3D::getEndContactBodyAId);

    world3.addFunc("getEndContactBodyBId", &World3D::getEndContactBodyBId);

    world3.addFunc("getEndContactShapeAId", &World3D::getEndContactShapeAId);

    world3.addFunc("getEndContactShapeBId", &World3D::getEndContactShapeBId);

    world3.addFunc("getEndContactShapeATag", &World3D::getEndContactShapeATag);

    world3.addFunc("getEndContactShapeBTag", &World3D::getEndContactShapeBTag);

    world3.addFunc("getBeginTriggerCount", &World3D::getBeginTriggerCount);

    world3.addFunc("getBeginTriggerSensorBodyId", &World3D::getBeginTriggerSensorBodyId);

    world3.addFunc("getBeginTriggerVisitorBodyId", &World3D::getBeginTriggerVisitorBodyId);

    world3.addFunc("getBeginTriggerSensorShapeId", &World3D::getBeginTriggerSensorShapeId);

    world3.addFunc("getBeginTriggerVisitorShapeId", &World3D::getBeginTriggerVisitorShapeId);

    world3.addFunc("getBeginTriggerSensorShapeTag", &World3D::getBeginTriggerSensorShapeTag);

    world3.addFunc("getBeginTriggerVisitorShapeTag", &World3D::getBeginTriggerVisitorShapeTag);

    world3.addFunc("getEndTriggerCount", &World3D::getEndTriggerCount);

    world3.addFunc("getEndTriggerSensorBodyId", &World3D::getEndTriggerSensorBodyId);

    world3.addFunc("getEndTriggerVisitorBodyId", &World3D::getEndTriggerVisitorBodyId);

    world3.addFunc("getEndTriggerSensorShapeId", &World3D::getEndTriggerSensorShapeId);

    world3.addFunc("getEndTriggerVisitorShapeId", &World3D::getEndTriggerVisitorShapeId);

    world3.addFunc("getEndTriggerSensorShapeTag", &World3D::getEndTriggerSensorShapeTag);

    world3.addFunc("getEndTriggerVisitorShapeTag", &World3D::getEndTriggerVisitorShapeTag);

    world3.addFunc("clearContactEvents", &World3D::clearContactEvents);

    world3.addFunc("queryBodyContacts", &World3D::queryBodyContacts);

    world3.addFunc("getContactPointCount", &World3D::getContactPointCount);

    world3.addFunc("getContactPointShapeId", &World3D::getContactPointShapeId);

    world3.addFunc("getContactPointShapeTag", &World3D::getContactPointShapeTag);

    world3.addFunc("getContactPointOtherBodyId", &World3D::getContactPointOtherBodyId);

    world3.addFunc("getContactPointOtherShapeId", &World3D::getContactPointOtherShapeId);

    world3.addFunc("getContactPointOtherShapeTag", &World3D::getContactPointOtherShapeTag);

    world3.addFunc("getContactPointX", &World3D::getContactPointX);

    world3.addFunc("getContactPointY", &World3D::getContactPointY);

    world3.addFunc("getContactPointZ", &World3D::getContactPointZ);

    world3.addFunc("getContactPointNormalX", &World3D::getContactPointNormalX);

    world3.addFunc("getContactPointNormalY", &World3D::getContactPointNormalY);

    world3.addFunc("getContactPointNormalZ", &World3D::getContactPointNormalZ);

    world3.addFunc("getContactPointSeparation", &World3D::getContactPointSeparation);

    world3.addFunc("getContactPointNormalImpulse", &World3D::getContactPointNormalImpulse);

    world3.addFunc("getContactPointTotalNormalImpulse", &World3D::getContactPointTotalNormalImpulse);

    world3.addFunc("getContactPointNormalVelocity", &World3D::getContactPointNormalVelocity);

    world3.addFunc("isContactPointPersisted", &World3D::isContactPointPersisted);

    world3.addFunc("getHitCount", &World3D::getHitCount);

    world3.addFunc("getHitBodyAId", &World3D::getHitBodyAId);

    world3.addFunc("getHitBodyBId", &World3D::getHitBodyBId);

    world3.addFunc("getHitShapeAId", &World3D::getHitShapeAId);

    world3.addFunc("getHitShapeBId", &World3D::getHitShapeBId);

    world3.addFunc("getHitShapeATag", &World3D::getHitShapeATag);

    world3.addFunc("getHitShapeBTag", &World3D::getHitShapeBTag);

    world3.addFunc("getHitPointX", &World3D::getHitPointX);

    world3.addFunc("getHitPointY", &World3D::getHitPointY);

    world3.addFunc("getHitPointZ", &World3D::getHitPointZ);

    world3.addFunc("getHitNormalX", &World3D::getHitNormalX);

    world3.addFunc("getHitNormalY", &World3D::getHitNormalY);

    world3.addFunc("getHitNormalZ", &World3D::getHitNormalZ);

    world3.addFunc("getHitApproachSpeed", &World3D::getHitApproachSpeed);

    world3.addFunc("getHitNormalImpulse", &World3D::getHitNormalImpulse);

    world3.addFunc("getJointStressCount", &World3D::getJointStressCount);

    world3.addFunc("getJointStressJointId", &World3D::getJointStressJointId);

    world3.addFunc("getJointStressBodyAId", &World3D::getJointStressBodyAId);

    world3.addFunc("getJointStressBodyBId", &World3D::getJointStressBodyBId);

    world3.addFunc("getJointStressKind", &World3D::getJointStressKind);

    world3.addFunc("getJointStressForceX", &World3D::getJointStressForceX);

    world3.addFunc("getJointStressForceY", &World3D::getJointStressForceY);

    world3.addFunc("getJointStressForceZ", &World3D::getJointStressForceZ);

    world3.addFunc("getJointStressTorqueX", &World3D::getJointStressTorqueX);

    world3.addFunc("getJointStressTorqueY", &World3D::getJointStressTorqueY);

    world3.addFunc("getJointStressTorqueZ", &World3D::getJointStressTorqueZ);

    world3.addFunc("setQueryFilter", &World3D::setQueryFilter);

    world3.addFunc("resetQueryFilter", &World3D::resetQueryFilter);

    world3.addFunc("getQueryCategoryBits", &World3D::getQueryCategoryBits);

    world3.addFunc("getQueryMaskBits", &World3D::getQueryMaskBits);

    world3.addFunc("setQueryIgnoredBodyId", &World3D::setQueryIgnoredBodyId);

    world3.addFunc("setQueryIgnoredShapeId", &World3D::setQueryIgnoredShapeId);

    world3.addFunc("getQueryIgnoredBodyId", &World3D::getQueryIgnoredBodyId);

    world3.addFunc("getQueryIgnoredShapeId", &World3D::getQueryIgnoredShapeId);

    world3.addFunc("clearQueryIgnores", &World3D::clearQueryIgnores);


    auto sdf = table.addClass<DistanceField3D>(

        "DistanceField3D", std::function<DistanceField3D *()>([]() -> DistanceField3D * {

            return nullptr;

        }), true);

    sdf.addFunc("setDistances", [](DistanceField3D *field, ssq::Array values) {

        std::vector<float> distances;

        distances.reserve(values.size());

        const size_t count = values.size();

        for (size_t i = 0; i < count; ++i) distances.push_back(values.get<float>(i));

        field->setDistances(distances);

    });

    sdf.addFunc("setDistanceRegion",

                [](DistanceField3D *field, int x, int y, int z, int width, int height, int depth,

                   ssq::Array values) {

                    std::vector<float> distances;

                    const size_t count = values.size();

                    distances.reserve(count);

                    for (size_t i = 0; i < count; ++i)

                        distances.push_back(values.get<float>(i));

                    field->setDistanceRegion(x, y, z, width, height, depth, distances);

                });

    sdf.addFunc("fill", &DistanceField3D::fill);

    sdf.addFunc("fillRegion", &DistanceField3D::fillRegion);

    sdf.addFunc("setDistance", &DistanceField3D::setDistance);

    sdf.addFunc("getDistance", &DistanceField3D::getDistance);

    sdf.addFunc("sample", &DistanceField3D::sample);

    sdf.addFunc("getWidth", &DistanceField3D::getWidth);

    sdf.addFunc("getHeight", &DistanceField3D::getHeight);

    sdf.addFunc("getDepth", &DistanceField3D::getDepth);

    sdf.addFunc("getSampleCount", &DistanceField3D::getSampleCount);

    sdf.addFunc("getCellSize", &DistanceField3D::getCellSize);

    sdf.addFunc("getOriginX", &DistanceField3D::getOriginX);

    sdf.addFunc("getOriginY", &DistanceField3D::getOriginY);

    sdf.addFunc("getOriginZ", &DistanceField3D::getOriginZ);

    sdf.addFunc("getOutsideDistance", &DistanceField3D::getOutsideDistance);

    sdf.addFunc("getRevision", &DistanceField3D::getRevision);

    sdf.addFunc("sampleNormal", &DistanceField3D::sampleNormal);

    sdf.addFunc("getNormalX", &DistanceField3D::getNormalX);

    sdf.addFunc("getNormalY", &DistanceField3D::getNormalY);

    sdf.addFunc("getNormalZ", &DistanceField3D::getNormalZ);

    sdf.addFunc("checkSphere", &DistanceField3D::checkSphere);

    sdf.addFunc("checkCapsule", &DistanceField3D::checkCapsule);

    sdf.addFunc("castSphere", &DistanceField3D::castSphere);

    sdf.addFunc("castCapsule", &DistanceField3D::castCapsule);

    sdf.addFunc("moveCapsule", &DistanceField3D::moveCapsule);

    sdf.addFunc("setMoverUp", &DistanceField3D::setMoverUp);

    sdf.addFunc("setMoverSlopeLimit", &DistanceField3D::setMoverSlopeLimit);

    sdf.addFunc("setMoverSkinWidth", &DistanceField3D::setMoverSkinWidth);

    sdf.addFunc("getMoverSkinWidth", &DistanceField3D::getMoverSkinWidth);

    sdf.addFunc("setMoverGroundSnap", &DistanceField3D::setMoverGroundSnap);

    sdf.addFunc("getMoverGroundSnap", &DistanceField3D::getMoverGroundSnap);

    sdf.addFunc("setMoverStepHeight", &DistanceField3D::setMoverStepHeight);

    sdf.addFunc("getMoverStepHeight", &DistanceField3D::getMoverStepHeight);

    sdf.addFunc("getCollisionDistance", &DistanceField3D::getCollisionDistance);

    sdf.addFunc("getCollisionX", &DistanceField3D::getCollisionX);

    sdf.addFunc("getCollisionY", &DistanceField3D::getCollisionY);

    sdf.addFunc("getCollisionZ", &DistanceField3D::getCollisionZ);

    sdf.addFunc("getSurfaceX", &DistanceField3D::getSurfaceX);

    sdf.addFunc("getSurfaceY", &DistanceField3D::getSurfaceY);

    sdf.addFunc("getSurfaceZ", &DistanceField3D::getSurfaceZ);

    sdf.addFunc("getShapeContactX", &DistanceField3D::getShapeContactX);

    sdf.addFunc("getShapeContactY", &DistanceField3D::getShapeContactY);

    sdf.addFunc("getShapeContactZ", &DistanceField3D::getShapeContactZ);

    sdf.addFunc("getPenetrationDepth", &DistanceField3D::getPenetrationDepth);

    sdf.addFunc("getCastFraction", &DistanceField3D::getCastFraction);

    sdf.addFunc("getCastDistance", &DistanceField3D::getCastDistance);

    sdf.addFunc("didCastStartInside", &DistanceField3D::didCastStartInside);

    sdf.addFunc("getMoverDeltaX", &DistanceField3D::getMoverDeltaX);

    sdf.addFunc("getMoverDeltaY", &DistanceField3D::getMoverDeltaY);

    sdf.addFunc("getMoverDeltaZ", &DistanceField3D::getMoverDeltaZ);

    sdf.addFunc("getMoverNormalX", &DistanceField3D::getMoverNormalX);

    sdf.addFunc("getMoverNormalY", &DistanceField3D::getMoverNormalY);

    sdf.addFunc("getMoverNormalZ", &DistanceField3D::getMoverNormalZ);

    sdf.addFunc("getMoverIterations", &DistanceField3D::getMoverIterations);

    sdf.addFunc("isMoverGrounded", &DistanceField3D::isMoverGrounded);

    sdf.addFunc("getMoverGroundDot", &DistanceField3D::getMoverGroundDot);

    sdf.addFunc("didMoverHitWall", &DistanceField3D::didMoverHitWall);


    auto body = table.addClass<Body>(

        "Body", std::function<Body *()>([]() -> Body * { return nullptr; }), true);

    body.addFunc("getId", &Body::getId);

    body.addFunc("setPosition", &Body::setPosition);

    body.addFunc("getX", &Body::getX);

    body.addFunc("getY", &Body::getY);

    body.addFunc("setAngle", &Body::setAngle);

    body.addFunc("getAngle", &Body::getAngle);

    body.addFunc("setLinearVelocity", &Body::setLinearVelocity);

    body.addFunc("getLinearVelocityX", &Body::getLinearVelocityX);

    body.addFunc("getLinearVelocityY", &Body::getLinearVelocityY);

    body.addFunc("getLinearSpeed", &Body::getLinearSpeed);

    body.addFunc("getMass", &Body::getMass);

    body.addFunc("getWorldCenterX", &Body::getWorldCenterX);

    body.addFunc("getWorldCenterY", &Body::getWorldCenterY);

    body.addFunc("setAngularVelocity", &Body::setAngularVelocity);

    body.addFunc("getAngularVelocity", &Body::getAngularVelocity);

    body.addFunc("applyForce", &Body::applyForce);

    body.addFunc("applyForceAt", &Body::applyForceAt);

    body.addFunc("applyLinearImpulse", &Body::applyLinearImpulse);

    body.addFunc("applyAngularImpulse", &Body::applyAngularImpulse);

    body.addFunc("setType", &Body::setType);

    body.addFunc("getType", &Body::getType);

    body.addFunc("setFixedRotation", &Body::setFixedRotation);

    body.addFunc("isFixedRotation", &Body::isFixedRotation);

    body.addFunc("setActive", &Body::setActive);

    body.addFunc("isActive", &Body::isActive);

    body.addFunc("setBullet", &Body::setBullet);

    body.addFunc("isBullet", &Body::isBullet);

    body.addFunc("setAwake", &Body::setAwake);

    body.addFunc("isAwake", &Body::isAwake);

    body.addFunc("newRectangleFixture", &Body::newRectangleFixture);

    body.addFunc("newRectangleFixtureAt", &Body::newRectangleFixtureAt);

    body.addFunc("newCircleFixture", &Body::newCircleFixture);

    body.addFunc("destroy", &Body::destroy);


    auto joint2 = table.addClass<Joint2D>(

        "Joint2D", std::function<Joint2D *()>([]() -> Joint2D * { return nullptr; }), true);

    joint2.addFunc("getId", &Joint2D::getId);

    joint2.addFunc("getKind", &Joint2D::getKind);

    joint2.addFunc("getBodyAId", &Joint2D::getBodyAId);

    joint2.addFunc("getBodyBId", &Joint2D::getBodyBId);

    joint2.addFunc("setCollideConnected", &Joint2D::setCollideConnected);

    joint2.addFunc("getCollideConnected", &Joint2D::getCollideConnected);

    joint2.addFunc("setDistanceLength", &Joint2D::setDistanceLength);

    joint2.addFunc("getDistanceLength", &Joint2D::getDistanceLength);

    joint2.addFunc("setDistanceSpring", &Joint2D::setDistanceSpring);

    joint2.addFunc("getDistanceFrequency", &Joint2D::getDistanceFrequency);

    joint2.addFunc("getDistanceDampingRatio", &Joint2D::getDistanceDampingRatio);

    joint2.addFunc("setRevoluteLimits", &Joint2D::setRevoluteLimits);

    joint2.addFunc("setRevoluteMotor", &Joint2D::setRevoluteMotor);

    joint2.addFunc("getRevoluteAngle", &Joint2D::getRevoluteAngle);

    joint2.addFunc("getRevoluteSpeed", &Joint2D::getRevoluteSpeed);

    joint2.addFunc("getRevoluteMotorTorque", &Joint2D::getRevoluteMotorTorque);

    joint2.addFunc("setPrismaticLimits", &Joint2D::setPrismaticLimits);

    joint2.addFunc("setPrismaticMotor", &Joint2D::setPrismaticMotor);

    joint2.addFunc("getPrismaticTranslation", &Joint2D::getPrismaticTranslation);

    joint2.addFunc("getPrismaticSpeed", &Joint2D::getPrismaticSpeed);

    joint2.addFunc("setWeldSpring", &Joint2D::setWeldSpring);

    joint2.addFunc("getWeldFrequency", &Joint2D::getWeldFrequency);

    joint2.addFunc("getWeldDampingRatio", &Joint2D::getWeldDampingRatio);

    joint2.addFunc("setWheelSpring", &Joint2D::setWheelSpring);

    joint2.addFunc("setWheelMotor", &Joint2D::setWheelMotor);

    joint2.addFunc("getWheelTranslation", &Joint2D::getWheelTranslation);

    joint2.addFunc("getWheelSpeed", &Joint2D::getWheelSpeed);

    joint2.addFunc("setMotorLinearOffset", &Joint2D::setMotorLinearOffset);

    joint2.addFunc("setMotorAngularOffset", &Joint2D::setMotorAngularOffset);

    joint2.addFunc("setMotorLimits", &Joint2D::setMotorLimits);

    joint2.addFunc("getMotorLinearOffsetX", &Joint2D::getMotorLinearOffsetX);

    joint2.addFunc("getMotorLinearOffsetY", &Joint2D::getMotorLinearOffsetY);

    joint2.addFunc("getMotorAngularOffset", &Joint2D::getMotorAngularOffset);

    joint2.addFunc("setGearRatio", &Joint2D::setGearRatio);

    joint2.addFunc("getGearRatio", &Joint2D::getGearRatio);

    joint2.addFunc("getGearJoint1", &Joint2D::getGearJoint1);

    joint2.addFunc("getGearJoint2", &Joint2D::getGearJoint2);

    joint2.addFunc("destroy", &Joint2D::destroy);

    joint2.addFunc("isValid", &Joint2D::isValid);


    auto mechanism2 = table.addClass<Mechanism2D>(

        "Mechanism2D", std::function<Mechanism2D *()>([]() -> Mechanism2D * { return nullptr; }),

        true);

    mechanism2.addFunc("getId", &Mechanism2D::getId);

    mechanism2.addFunc("getKind", &Mechanism2D::getKind);

    mechanism2.addFunc("isValid", &Mechanism2D::isValid);

    mechanism2.addFunc("getDriveJoint", &Mechanism2D::getDriveJoint);

    mechanism2.addFunc("getCrankPinJoint", &Mechanism2D::getCrankPinJoint);

    mechanism2.addFunc("getSliderPinJoint", &Mechanism2D::getSliderPinJoint);

    mechanism2.addFunc("getSliderJoint", &Mechanism2D::getSliderJoint);

    mechanism2.addFunc("getDriveAngle", &Mechanism2D::getDriveAngle);

    mechanism2.addFunc("getSliderTranslation", &Mechanism2D::getSliderTranslation);

    mechanism2.addFunc("getSpinSpeed", &Mechanism2D::getSpinSpeed);

    mechanism2.addFunc("setDrive", &Mechanism2D::setDrive);

    mechanism2.addFunc("clearDrive", &Mechanism2D::clearDrive);

    mechanism2.addFunc("isDriveEnabled", &Mechanism2D::isDriveEnabled);

    mechanism2.addFunc("setRatchetDirection", &Mechanism2D::setRatchetDirection);

    mechanism2.addFunc("getRatchetDirection", &Mechanism2D::getRatchetDirection);

    mechanism2.addFunc("setRatchetEngagementTorque", &Mechanism2D::setRatchetEngagementTorque);

    mechanism2.addFunc("getRatchetEngagementTorque", &Mechanism2D::getRatchetEngagementTorque);

    mechanism2.addFunc("destroy", &Mechanism2D::destroy);


    auto body3 = table.addClass<Body3D>(

        "Body3D", std::function<Body3D *()>([]() -> Body3D * { return nullptr; }), true);

    body3.addFunc("getId", &Body3D::getId);

    body3.addFunc("setPosition", &Body3D::setPosition);

    body3.addFunc("getX", &Body3D::getX);

    body3.addFunc("getY", &Body3D::getY);

    body3.addFunc("getZ", &Body3D::getZ);

    body3.addFunc("setRotation", &Body3D::setRotation);

    body3.addFunc("getRotX", &Body3D::getRotX);

    body3.addFunc("getRotY", &Body3D::getRotY);

    body3.addFunc("getRotZ", &Body3D::getRotZ);

    body3.addFunc("getRotW", &Body3D::getRotW);

    body3.addFunc("setLinearVelocity", &Body3D::setLinearVelocity);

    body3.addFunc("getLinearVelocityX", &Body3D::getLinearVelocityX);

    body3.addFunc("getLinearVelocityY", &Body3D::getLinearVelocityY);

    body3.addFunc("getLinearVelocityZ", &Body3D::getLinearVelocityZ);

    body3.addFunc("getMass", &Body3D::getMass);

    body3.addFunc("setAngularVelocity", &Body3D::setAngularVelocity);

    body3.addFunc("getAngularVelocityX", &Body3D::getAngularVelocityX);

    body3.addFunc("getAngularVelocityY", &Body3D::getAngularVelocityY);

    body3.addFunc("getAngularVelocityZ", &Body3D::getAngularVelocityZ);

    body3.addFunc("localToWorldPoint", &Body3D::localToWorldPoint);

    body3.addFunc("worldToLocalPoint", &Body3D::worldToLocalPoint);

    body3.addFunc("localToWorldVector", &Body3D::localToWorldVector);

    body3.addFunc("worldToLocalVector", &Body3D::worldToLocalVector);

    body3.addFunc("getLocalPointVelocity", &Body3D::getLocalPointVelocity);

    body3.addFunc("getWorldPointVelocity", &Body3D::getWorldPointVelocity);

    body3.addFunc("applyForce", &Body3D::applyForce);

    body3.addFunc("applyForceAt", &Body3D::applyForceAt);

    body3.addFunc("applyTorque", &Body3D::applyTorque);

    body3.addFunc("applyLinearImpulse", &Body3D::applyLinearImpulse);

    body3.addFunc("applyLinearImpulseAt", &Body3D::applyLinearImpulseAt);

    body3.addFunc("applyAngularImpulse", &Body3D::applyAngularImpulse);

    body3.addFunc("applyLocalForce", &Body3D::applyLocalForce);

    body3.addFunc("applyLocalForceToCenter", &Body3D::applyLocalForceToCenter);

    body3.addFunc("applyLocalTorque", &Body3D::applyLocalTorque);

    body3.addFunc("applyLocalLinearImpulse", &Body3D::applyLocalLinearImpulse);

    body3.addFunc("applyLocalLinearImpulseToCenter", &Body3D::applyLocalLinearImpulseToCenter);

    body3.addFunc("applyLocalAngularImpulse", &Body3D::applyLocalAngularImpulse);

    body3.addFunc("setTargetTransform", &Body3D::setTargetTransform);

    body3.addFunc("setLinearDamping", &Body3D::setLinearDamping);

    body3.addFunc("getLinearDamping", &Body3D::getLinearDamping);

    body3.addFunc("setAngularDamping", &Body3D::setAngularDamping);

    body3.addFunc("getAngularDamping", &Body3D::getAngularDamping);

    body3.addFunc("setGravityScale", &Body3D::setGravityScale);

    body3.addFunc("getGravityScale", &Body3D::getGravityScale);

    body3.addFunc("setSleepEnabled", &Body3D::setSleepEnabled);

    body3.addFunc("isSleepEnabled", &Body3D::isSleepEnabled);

    body3.addFunc("setSleepThreshold", &Body3D::setSleepThreshold);

    body3.addFunc("getSleepThreshold", &Body3D::getSleepThreshold);

    body3.addFunc("setMotionLocks", &Body3D::setMotionLocks);

    body3.addFunc("isLinearXLocked", &Body3D::isLinearXLocked);

    body3.addFunc("isLinearYLocked", &Body3D::isLinearYLocked);

    body3.addFunc("isLinearZLocked", &Body3D::isLinearZLocked);

    body3.addFunc("isAngularXLocked", &Body3D::isAngularXLocked);

    body3.addFunc("isAngularYLocked", &Body3D::isAngularYLocked);

    body3.addFunc("isAngularZLocked", &Body3D::isAngularZLocked);

    body3.addFunc("getMass", &Body3D::getMass);

    body3.addFunc("setMassProperties", &Body3D::setMassProperties);

    body3.addFunc("resetMassProperties", &Body3D::resetMassProperties);

    body3.addFunc("getInertiaXX", &Body3D::getInertiaXX);

    body3.addFunc("getInertiaYY", &Body3D::getInertiaYY);

    body3.addFunc("getInertiaZZ", &Body3D::getInertiaZZ);

    body3.addFunc("getInertiaXY", &Body3D::getInertiaXY);

    body3.addFunc("getInertiaXZ", &Body3D::getInertiaXZ);

    body3.addFunc("getInertiaYZ", &Body3D::getInertiaYZ);

    body3.addFunc("getLocalCenterX", &Body3D::getLocalCenterX);

    body3.addFunc("getLocalCenterY", &Body3D::getLocalCenterY);

    body3.addFunc("getLocalCenterZ", &Body3D::getLocalCenterZ);

    body3.addFunc("getWorldCenterX", &Body3D::getWorldCenterX);

    body3.addFunc("getWorldCenterY", &Body3D::getWorldCenterY);

    body3.addFunc("getWorldCenterZ", &Body3D::getWorldCenterZ);

    body3.addFunc("setType", &Body3D::setType);

    body3.addFunc("getType", &Body3D::getType);

    body3.addFunc("setFixedRotation", &Body3D::setFixedRotation);

    body3.addFunc("isFixedRotation", &Body3D::isFixedRotation);

    body3.addFunc("setActive", &Body3D::setActive);

    body3.addFunc("isActive", &Body3D::isActive);

    body3.addFunc("setBullet", &Body3D::setBullet);

    body3.addFunc("isBullet", &Body3D::isBullet);

    body3.addFunc("setAwake", &Body3D::setAwake);

    body3.addFunc("isAwake", &Body3D::isAwake);

    body3.addFunc("newBoxShape", &Body3D::newBoxShape);

    body3.addFunc("newSphereShape", &Body3D::newSphereShape);

    body3.addFunc("newCapsuleShape", &Body3D::newCapsuleShape);

    body3.addFunc("newConvexHullShape", [](Body3D *body, ssq::Array values, int maxVertices) {

        std::vector<float> vertices;

        vertices.reserve(values.size());

        for (size_t i = 0; i < values.size(); ++i) vertices.push_back(values.get<float>(i));

        return body->newConvexHullShape(vertices, maxVertices);

    });

    body3.addFunc("newTriangleMeshShape",

                  [](Body3D *body, ssq::Array vertexValues, ssq::Array indexValues) {

                      std::vector<float> vertices;

                      std::vector<int32_t> indices;

                      vertices.reserve(vertexValues.size());

                      indices.reserve(indexValues.size());

                      for (size_t i = 0; i < vertexValues.size(); ++i)

                          vertices.push_back(vertexValues.get<float>(i));

                      for (size_t i = 0; i < indexValues.size(); ++i)

                          indices.push_back(indexValues.get<int32_t>(i));

                      return body->newTriangleMeshShape(vertices, indices);

                  });

    body3.addFunc(

        "newTriangleMeshShapeFull",

        [](Body3D *body, ssq::Array vertexValues, ssq::Array indexValues, bool weldVertices,

           float weldTolerance, bool identifyEdges, bool useMedianSplit) {

            std::vector<float> vertices;

            std::vector<int32_t> indices;

            vertices.reserve(vertexValues.size());

            indices.reserve(indexValues.size());

            for (size_t i = 0; i < vertexValues.size(); ++i)

                vertices.push_back(vertexValues.get<float>(i));

            for (size_t i = 0; i < indexValues.size(); ++i)

                indices.push_back(indexValues.get<int32_t>(i));

            return body->newTriangleMeshShape(vertices, indices, weldVertices, weldTolerance,

                                              identifyEdges, useMedianSplit);

        });

    body3.addFunc("newHeightFieldShape",

                  [](Body3D *body, int countX, int countZ, float cellSizeX, float cellSizeZ,

                     ssq::Array values) {

                      std::vector<float> heights;

                      heights.reserve(values.size());

                      for (size_t i = 0; i < values.size(); ++i)

                          heights.push_back(values.get<float>(i));

                      if (heights.empty())

                          throw eve::Exception("Body3D.newHeightFieldShape: heights is empty");

                      const auto range = std::minmax_element(heights.begin(), heights.end());

                      return body->newHeightFieldShape(countX, countZ, cellSizeX, cellSizeZ,

                                                       heights, *range.first, *range.second);

                  });

    body3.addFunc(

        "newHeightFieldShapeFull",

        [](Body3D *body, int countX, int countZ, float cellSizeX, float cellSizeZ,

           ssq::Array values, float globalMin, float globalMax, bool clockwiseWinding) {

            std::vector<float> heights;

            heights.reserve(values.size());

            for (size_t i = 0; i < values.size(); ++i)

                heights.push_back(values.get<float>(i));

            return body->newHeightFieldShape(countX, countZ, cellSizeX, cellSizeZ, heights,

                                             globalMin, globalMax, clockwiseWinding);

        });

    body3.addFunc("destroy", &Body3D::destroy);


    auto joint3 = table.addClass<Joint3D>(

        "Joint3D", std::function<Joint3D *()>([]() -> Joint3D * { return nullptr; }), true);

    joint3.addFunc("getId", &Joint3D::getId);

    joint3.addFunc("getKind", &Joint3D::getKind);

    joint3.addFunc("getBodyAId", &Joint3D::getBodyAId);

    joint3.addFunc("getBodyBId", &Joint3D::getBodyBId);

    joint3.addFunc("setCollideConnected", &Joint3D::setCollideConnected);

    joint3.addFunc("getCollideConnected", &Joint3D::getCollideConnected);

    joint3.addFunc("setForceThreshold", &Joint3D::setForceThreshold);

    joint3.addFunc("getForceThreshold", &Joint3D::getForceThreshold);

    joint3.addFunc("setTorqueThreshold", &Joint3D::setTorqueThreshold);

    joint3.addFunc("getTorqueThreshold", &Joint3D::getTorqueThreshold);

    joint3.addFunc("getConstraintForceX", &Joint3D::getConstraintForceX);

    joint3.addFunc("getConstraintForceY", &Joint3D::getConstraintForceY);

    joint3.addFunc("getConstraintForceZ", &Joint3D::getConstraintForceZ);

    joint3.addFunc("getConstraintTorqueX", &Joint3D::getConstraintTorqueX);

    joint3.addFunc("getConstraintTorqueY", &Joint3D::getConstraintTorqueY);

    joint3.addFunc("getConstraintTorqueZ", &Joint3D::getConstraintTorqueZ);

    joint3.addFunc("getLinearSeparation", &Joint3D::getLinearSeparation);

    joint3.addFunc("getAngularSeparation", &Joint3D::getAngularSeparation);

    joint3.addFunc("setDistanceLength", &Joint3D::setDistanceLength);

    joint3.addFunc("getDistanceLength", &Joint3D::getDistanceLength);

    joint3.addFunc("getDistanceCurrentLength", &Joint3D::getDistanceCurrentLength);

    joint3.addFunc("setDistanceSpring", &Joint3D::setDistanceSpring);

    joint3.addFunc("setDistanceLimits", &Joint3D::setDistanceLimits);

    joint3.addFunc("setDistanceMotor", &Joint3D::setDistanceMotor);

    joint3.addFunc("setRevoluteSpring", &Joint3D::setRevoluteSpring);

    joint3.addFunc("setRevoluteLimits", &Joint3D::setRevoluteLimits);

    joint3.addFunc("setRevoluteMotor", &Joint3D::setRevoluteMotor);

    joint3.addFunc("getRevoluteAngle", &Joint3D::getRevoluteAngle);

    joint3.addFunc("getRevoluteMotorTorque", &Joint3D::getRevoluteMotorTorque);

    joint3.addFunc("setPrismaticSpring", &Joint3D::setPrismaticSpring);

    joint3.addFunc("setPrismaticLimits", &Joint3D::setPrismaticLimits);

    joint3.addFunc("setPrismaticMotor", &Joint3D::setPrismaticMotor);

    joint3.addFunc("getPrismaticTranslation", &Joint3D::getPrismaticTranslation);

    joint3.addFunc("getPrismaticSpeed", &Joint3D::getPrismaticSpeed);

    joint3.addFunc("getPrismaticMotorForce", &Joint3D::getPrismaticMotorForce);

    joint3.addFunc("setSphericalConeLimit", &Joint3D::setSphericalConeLimit);

    joint3.addFunc("setSphericalTwistLimits", &Joint3D::setSphericalTwistLimits);

    joint3.addFunc("setSphericalMotor", &Joint3D::setSphericalMotor);

    joint3.addFunc("getSphericalConeAngle", &Joint3D::getSphericalConeAngle);

    joint3.addFunc("getSphericalTwistAngle", &Joint3D::getSphericalTwistAngle);

    joint3.addFunc("setWheelSuspension", &Joint3D::setWheelSuspension);

    joint3.addFunc("setWheelSuspensionLimits", &Joint3D::setWheelSuspensionLimits);

    joint3.addFunc("setWheelSpinMotor", &Joint3D::setWheelSpinMotor);

    joint3.addFunc("setWheelSteering", &Joint3D::setWheelSteering);

    joint3.addFunc("setWheelSteeringLimits", &Joint3D::setWheelSteeringLimits);

    joint3.addFunc("getWheelSpinSpeed", &Joint3D::getWheelSpinSpeed);

    joint3.addFunc("getWheelSpinTorque", &Joint3D::getWheelSpinTorque);

    joint3.addFunc("getWheelSteeringAngle", &Joint3D::getWheelSteeringAngle);

    joint3.addFunc("getWheelSteeringTorque", &Joint3D::getWheelSteeringTorque);

    joint3.addFunc("setWeldLinearSpring", &Joint3D::setWeldLinearSpring);

    joint3.addFunc("setWeldAngularSpring", &Joint3D::setWeldAngularSpring);

    joint3.addFunc("getWeldLinearHertz", &Joint3D::getWeldLinearHertz);

    joint3.addFunc("getWeldLinearDampingRatio", &Joint3D::getWeldLinearDampingRatio);

    joint3.addFunc("getWeldAngularHertz", &Joint3D::getWeldAngularHertz);

    joint3.addFunc("getWeldAngularDampingRatio", &Joint3D::getWeldAngularDampingRatio);

    joint3.addFunc("setMotorLinearVelocity", &Joint3D::setMotorLinearVelocity);

    joint3.addFunc("setMotorAngularVelocity", &Joint3D::setMotorAngularVelocity);

    joint3.addFunc("setMotorVelocityLimits", &Joint3D::setMotorVelocityLimits);

    joint3.addFunc("setMotorLinearSpring", &Joint3D::setMotorLinearSpring);

    joint3.addFunc("setMotorAngularSpring", &Joint3D::setMotorAngularSpring);

    joint3.addFunc("getMotorLinearVelocityX", &Joint3D::getMotorLinearVelocityX);

    joint3.addFunc("getMotorLinearVelocityY", &Joint3D::getMotorLinearVelocityY);

    joint3.addFunc("getMotorLinearVelocityZ", &Joint3D::getMotorLinearVelocityZ);

    joint3.addFunc("getMotorAngularVelocityX", &Joint3D::getMotorAngularVelocityX);

    joint3.addFunc("getMotorAngularVelocityY", &Joint3D::getMotorAngularVelocityY);

    joint3.addFunc("getMotorAngularVelocityZ", &Joint3D::getMotorAngularVelocityZ);

    joint3.addFunc("setParallelSpring", &Joint3D::setParallelSpring);

    joint3.addFunc("getParallelHertz", &Joint3D::getParallelHertz);

    joint3.addFunc("getParallelDampingRatio", &Joint3D::getParallelDampingRatio);

    joint3.addFunc("getParallelMaxTorque", &Joint3D::getParallelMaxTorque);

    joint3.addFunc("destroy", &Joint3D::destroy);


    auto mechanism3 = table.addClass<Mechanism3D>(

        "Mechanism3D", std::function<Mechanism3D *()>([]() -> Mechanism3D * { return nullptr; }),

        true);

    mechanism3.addFunc("getId", &Mechanism3D::getId);

    mechanism3.addFunc("getKind", &Mechanism3D::getKind);

    mechanism3.addFunc("isValid", &Mechanism3D::isValid);

    mechanism3.addFunc("getDriveJoint", &Mechanism3D::getDriveJoint);

    mechanism3.addFunc("getCrankPinJoint", &Mechanism3D::getCrankPinJoint);

    mechanism3.addFunc("getSliderPinJoint", &Mechanism3D::getSliderPinJoint);

    mechanism3.addFunc("getSliderJoint", &Mechanism3D::getSliderJoint);

    mechanism3.addFunc("getDriveAngle", &Mechanism3D::getDriveAngle);

    mechanism3.addFunc("getSliderTranslation", &Mechanism3D::getSliderTranslation);

    mechanism3.addFunc("getSpinSpeed", &Mechanism3D::getSpinSpeed);

    mechanism3.addFunc("setDrive", &Mechanism3D::setDrive);

    mechanism3.addFunc("clearDrive", &Mechanism3D::clearDrive);

    mechanism3.addFunc("isDriveEnabled", &Mechanism3D::isDriveEnabled);

    mechanism3.addFunc("setRatchetDirection", &Mechanism3D::setRatchetDirection);

    mechanism3.addFunc("getRatchetDirection", &Mechanism3D::getRatchetDirection);

    mechanism3.addFunc("setRatchetEngagementTorque", &Mechanism3D::setRatchetEngagementTorque);

    mechanism3.addFunc("getRatchetEngagementTorque", &Mechanism3D::getRatchetEngagementTorque);

    mechanism3.addFunc("destroy", &Mechanism3D::destroy);


    auto fixture = table.addClass<Fixture>(

        "Fixture", std::function<Fixture *()>([]() -> Fixture * { return nullptr; }), true);

    fixture.addFunc("setSensor", &Fixture::setSensor);

    fixture.addFunc("isSensor", &Fixture::isSensor);

    fixture.addFunc("setFriction", &Fixture::setFriction);

    fixture.addFunc("getFriction", &Fixture::getFriction);

    fixture.addFunc("setRestitution", &Fixture::setRestitution);

    fixture.addFunc("getRestitution", &Fixture::getRestitution);

    fixture.addFunc("setDensity", &Fixture::setDensity);

    fixture.addFunc("getDensity", &Fixture::getDensity);

    fixture.addFunc("setTag", &Fixture::setTag);

    fixture.addFunc("getTag", &Fixture::getTag);

    fixture.addFunc("setCategoryBits", &Fixture::setCategoryBits);

    fixture.addFunc("getCategoryBits", &Fixture::getCategoryBits);

    fixture.addFunc("setMaskBits", &Fixture::setMaskBits);

    fixture.addFunc("getMaskBits", &Fixture::getMaskBits);

    fixture.addFunc("setGroupIndex", &Fixture::setGroupIndex);

    fixture.addFunc("getGroupIndex", &Fixture::getGroupIndex);

    fixture.addFunc("getBodyId", &Fixture::getBodyId);

    fixture.addFunc("getBody", &Fixture::getBody);

    fixture.addFunc("testPoint", &Fixture::testPoint);

    fixture.addFunc("destroy", &Fixture::destroy);


    auto shape3 = table.addClass<Shape3D>(

        "Shape3D", std::function<Shape3D *()>([]() -> Shape3D * { return nullptr; }), true);

    shape3.addFunc("getId", &Shape3D::getId);

    shape3.addFunc("setTag", &Shape3D::setTag);

    shape3.addFunc("getTag", &Shape3D::getTag);

    shape3.addFunc("setHitEventsEnabled", &Shape3D::setHitEventsEnabled);

    shape3.addFunc("areHitEventsEnabled", &Shape3D::areHitEventsEnabled);

    shape3.addFunc("setOneWay", &Shape3D::setOneWay);

    shape3.addFunc("disableOneWay", &Shape3D::disableOneWay);

    shape3.addFunc("isOneWay", &Shape3D::isOneWay);

    shape3.addFunc("getKind", &Shape3D::getKind);

    shape3.addFunc("setBoxSize", &Shape3D::setBoxSize);

    shape3.addFunc("setSphereRadius", &Shape3D::setSphereRadius);

    shape3.addFunc("setCapsuleSize", &Shape3D::setCapsuleSize);

    shape3.addFunc("setConvexHullVertices",

                   [](Shape3D *shape, ssq::Array values, int maxVertices) {

                       std::vector<float> vertices;

                       vertices.reserve(values.size());

                       for (size_t i = 0; i < values.size(); ++i)

                           vertices.push_back(values.get<float>(i));

                       shape->setConvexHullVertices(vertices, maxVertices);

                   });

    shape3.addFunc("getConvexHullPointCount", &Shape3D::getConvexHullPointCount);

    shape3.addFunc("getConvexHullMaxVertices", &Shape3D::getConvexHullMaxVertices);

    shape3.addFunc("setTriangleMeshData",

                   [](Shape3D *shape, ssq::Array vertexValues, ssq::Array indexValues) {

                       std::vector<float> vertices;

                       std::vector<int32_t> indices;

                       vertices.reserve(vertexValues.size());

                       indices.reserve(indexValues.size());

                       for (size_t i = 0; i < vertexValues.size(); ++i)

                           vertices.push_back(vertexValues.get<float>(i));

                       for (size_t i = 0; i < indexValues.size(); ++i)

                           indices.push_back(indexValues.get<int32_t>(i));

                       shape->setTriangleMeshData(vertices, indices);

                   });

    shape3.addFunc(

        "setTriangleMeshDataFull",

        [](Shape3D *shape, ssq::Array vertexValues, ssq::Array indexValues, bool weldVertices,

           float weldTolerance, bool identifyEdges, bool useMedianSplit) {

            std::vector<float> vertices;

            std::vector<int32_t> indices;

            vertices.reserve(vertexValues.size());

            indices.reserve(indexValues.size());

            for (size_t i = 0; i < vertexValues.size(); ++i)

                vertices.push_back(vertexValues.get<float>(i));

            for (size_t i = 0; i < indexValues.size(); ++i)

                indices.push_back(indexValues.get<int32_t>(i));

            shape->setTriangleMeshData(vertices, indices, weldVertices, weldTolerance,

                                       identifyEdges, useMedianSplit);

        });

    shape3.addFunc("getTriangleMeshVertexCount", &Shape3D::getTriangleMeshVertexCount);

    shape3.addFunc("getTriangleMeshTriangleCount", &Shape3D::getTriangleMeshTriangleCount);

    shape3.addFunc("setTriangleMeshMaterialIndices", [](Shape3D *shape, ssq::Array values) {

        std::vector<int32_t> indices;

        indices.reserve(values.size());

        for (size_t i = 0; i < values.size(); ++i)

            indices.push_back(values.get<int32_t>(i));

        shape->setTriangleMeshMaterialIndices(indices);

    });

    shape3.addFunc("getTriangleMeshMaterialIndex",

                   &Shape3D::getTriangleMeshMaterialIndex);

    shape3.addFunc("getTriangleMeshMaterialCount",

                   &Shape3D::getTriangleMeshMaterialCount);

    shape3.addFunc("setTriangleMeshMaterial", &Shape3D::setTriangleMeshMaterial);

    shape3.addFunc("getTriangleMeshMaterialFriction",

                   &Shape3D::getTriangleMeshMaterialFriction);

    shape3.addFunc("getTriangleMeshMaterialRestitution",

                   &Shape3D::getTriangleMeshMaterialRestitution);

    shape3.addFunc("getTriangleMeshMaterialRollingResistance",

                   &Shape3D::getTriangleMeshMaterialRollingResistance);

    shape3.addFunc("getTriangleMeshMaterialId", &Shape3D::getTriangleMeshMaterialId);

    shape3.addFunc("setHeightFieldHeights", [](Shape3D *shape, ssq::Array values) {

        std::vector<float> heights;

        heights.reserve(values.size());

        for (size_t i = 0; i < values.size(); ++i)

            heights.push_back(values.get<float>(i));

        shape->setHeightFieldHeights(heights);

    });

    shape3.addFunc("setHeightFieldRegion",

                   [](Shape3D *shape, int x, int z, int width, int depth,

                      ssq::Array values) {

                       std::vector<float> heights;

                       heights.reserve(values.size());

                       for (size_t i = 0; i < values.size(); ++i)

                           heights.push_back(values.get<float>(i));

                       shape->setHeightFieldRegion(x, z, width, depth, heights);

                   });

    shape3.addFunc("getHeightFieldHeight", &Shape3D::getHeightFieldHeight);

    shape3.addFunc("getHeightFieldCountX", &Shape3D::getHeightFieldCountX);

    shape3.addFunc("getHeightFieldCountZ", &Shape3D::getHeightFieldCountZ);

    shape3.addFunc("getHeightFieldCellSizeX", &Shape3D::getHeightFieldCellSizeX);

    shape3.addFunc("getHeightFieldCellSizeZ", &Shape3D::getHeightFieldCellSizeZ);

    shape3.addFunc("getHeightFieldGlobalMin", &Shape3D::getHeightFieldGlobalMin);

    shape3.addFunc("getHeightFieldGlobalMax", &Shape3D::getHeightFieldGlobalMax);

    shape3.addFunc("getBoxWidth", &Shape3D::getBoxWidth);

    shape3.addFunc("getBoxHeight", &Shape3D::getBoxHeight);

    shape3.addFunc("getBoxDepth", &Shape3D::getBoxDepth);

    shape3.addFunc("getRadius", &Shape3D::getRadius);

    shape3.addFunc("getCapsuleHeight", &Shape3D::getCapsuleHeight);

    shape3.addFunc("setLocalTransform", &Shape3D::setLocalTransform);

    shape3.addFunc("setLocalPosition", &Shape3D::setLocalPosition);

    shape3.addFunc("setLocalRotation", &Shape3D::setLocalRotation);

    shape3.addFunc("getLocalX", &Shape3D::getLocalX);

    shape3.addFunc("getLocalY", &Shape3D::getLocalY);

    shape3.addFunc("getLocalZ", &Shape3D::getLocalZ);

    shape3.addFunc("getLocalRotX", &Shape3D::getLocalRotX);

    shape3.addFunc("getLocalRotY", &Shape3D::getLocalRotY);

    shape3.addFunc("getLocalRotZ", &Shape3D::getLocalRotZ);

    shape3.addFunc("getLocalRotW", &Shape3D::getLocalRotW);

    shape3.addFunc("setSensor", &Shape3D::setSensor);

    shape3.addFunc("isSensor", &Shape3D::isSensor);

    shape3.addFunc("setFriction", &Shape3D::setFriction);

    shape3.addFunc("getFriction", &Shape3D::getFriction);

    shape3.addFunc("setRestitution", &Shape3D::setRestitution);

    shape3.addFunc("getRestitution", &Shape3D::getRestitution);

    shape3.addFunc("setRollingResistance", &Shape3D::setRollingResistance);

    shape3.addFunc("getRollingResistance", &Shape3D::getRollingResistance);

    shape3.addFunc("setTangentVelocity", &Shape3D::setTangentVelocity);

    shape3.addFunc("getTangentVelocityX", &Shape3D::getTangentVelocityX);

    shape3.addFunc("getTangentVelocityY", &Shape3D::getTangentVelocityY);

    shape3.addFunc("getTangentVelocityZ", &Shape3D::getTangentVelocityZ);

    shape3.addFunc("setMaterialId", &Shape3D::setMaterialId);

    shape3.addFunc("getMaterialId", &Shape3D::getMaterialId);

    shape3.addFunc("setExplosionScale", &Shape3D::setExplosionScale);

    shape3.addFunc("getExplosionScale", &Shape3D::getExplosionScale);

    shape3.addFunc("setFrictionCombineMode", &Shape3D::setFrictionCombineMode);

    shape3.addFunc("getFrictionCombineMode", &Shape3D::getFrictionCombineMode);

    shape3.addFunc("setRestitutionCombineMode", &Shape3D::setRestitutionCombineMode);

    shape3.addFunc("getRestitutionCombineMode", &Shape3D::getRestitutionCombineMode);

    shape3.addFunc("setDensity", &Shape3D::setDensity);

    shape3.addFunc("getDensity", &Shape3D::getDensity);

    shape3.addFunc("setCategoryBits", [](Shape3D *shape, int64_t bits) {

        shape->setCategoryBits(static_cast<uint64_t>(bits));

    });

    shape3.addFunc("getCategoryBits", [](Shape3D *shape) {

        return static_cast<int64_t>(shape->getCategoryBits());

    });

    shape3.addFunc("setMaskBits", [](Shape3D *shape, int64_t bits) {

        shape->setMaskBits(static_cast<uint64_t>(bits));

    });

    shape3.addFunc("getMaskBits", [](Shape3D *shape) {

        return static_cast<int64_t>(shape->getMaskBits());

    });

    shape3.addFunc("setGroupIndex", &Shape3D::setGroupIndex);

    shape3.addFunc("getGroupIndex", &Shape3D::getGroupIndex);

    shape3.addFunc("getBody", [](Shape3D *shape) { return shape->getBody(); });

    shape3.addFunc("testPoint", &Shape3D::testPoint);

    shape3.addFunc("destroy", &Shape3D::destroy);


    auto soft3 = table.addClass<SoftBody3D>(

        "SoftBody3D", std::function<SoftBody3D *()>([]() -> SoftBody3D * { return nullptr; }), true);

    soft3.addFunc("update", &SoftBody3D::update);

    soft3.addFunc("setGravity", &SoftBody3D::setGravity);

    soft3.addFunc("getGravityX", &SoftBody3D::getGravityX);

    soft3.addFunc("getGravityY", &SoftBody3D::getGravityY);

    soft3.addFunc("getGravityZ", &SoftBody3D::getGravityZ);

    soft3.addFunc("setDeformationResistance", &SoftBody3D::setDeformationResistance);

    soft3.addFunc("getDeformationResistance", &SoftBody3D::getDeformationResistance);

    soft3.addFunc("setIterations", &SoftBody3D::setIterations);

    soft3.addFunc("getIterations", &SoftBody3D::getIterations);

    soft3.addFunc("setDamping", &SoftBody3D::setDamping);

    soft3.addFunc("getDamping", &SoftBody3D::getDamping);

    soft3.addFunc("setParticleRadius", &SoftBody3D::setParticleRadius);

    soft3.addFunc("getParticleRadius", &SoftBody3D::getParticleRadius);

    soft3.addFunc("setParticleMass", &SoftBody3D::setParticleMass);

    soft3.addFunc("getParticleMass", &SoftBody3D::getParticleMass);

    soft3.addFunc("setPlasticity", &SoftBody3D::setPlasticity);

    soft3.addFunc("getPlasticYield", &SoftBody3D::getPlasticYield);

    soft3.addFunc("getPlasticCreep", &SoftBody3D::getPlasticCreep);

    soft3.addFunc("getPlasticRecovery", &SoftBody3D::getPlasticRecovery);

    soft3.addFunc("getMaxDeformation", &SoftBody3D::getMaxDeformation);

    soft3.addFunc("setSelfCollision", &SoftBody3D::setSelfCollision);

    soft3.addFunc("getSelfCollision", &SoftBody3D::getSelfCollision);

    soft3.addFunc("setBounds", &SoftBody3D::setBounds);

    soft3.addFunc("clearBounds", &SoftBody3D::clearBounds);

    soft3.addFunc("pin", &SoftBody3D::pin);

    soft3.addFunc("unpin", &SoftBody3D::unpin);

    soft3.addFunc("isPinned", &SoftBody3D::isPinned);

    soft3.addFunc("grabAt", &SoftBody3D::grabAt);

    soft3.addFunc("moveGrab", &SoftBody3D::moveGrab);

    soft3.addFunc("releaseGrab", &SoftBody3D::releaseGrab);

    soft3.addFunc("isGrabbing", &SoftBody3D::isGrabbing);

    soft3.addFunc("getGrabIndex", &SoftBody3D::getGrabIndex);

    soft3.addFunc("applyForce", &SoftBody3D::applyForce);

    soft3.addFunc("interactAt", &SoftBody3D::interactAt);

    soft3.addFunc("setCollideWorld", &SoftBody3D::setCollideWorld);

    soft3.addFunc("getCollideWorld", &SoftBody3D::getCollideWorld);

    soft3.addFunc("reset", &SoftBody3D::reset);

    soft3.addFunc("getCols", &SoftBody3D::getCols);

    soft3.addFunc("getRows", &SoftBody3D::getRows);

    soft3.addFunc("getLayers", &SoftBody3D::getLayers);

    soft3.addFunc("getParticleCount", &SoftBody3D::getParticleCount);

    soft3.addFunc("getParticleX", &SoftBody3D::getParticleX);

    soft3.addFunc("getParticleY", &SoftBody3D::getParticleY);

    soft3.addFunc("getParticleZ", &SoftBody3D::getParticleZ);

    soft3.addFunc("setParticlePosition", &SoftBody3D::setParticlePosition);

    soft3.addFunc("getVolumeRatio", &SoftBody3D::getVolumeRatio);

    soft3.addFunc("destroy", &SoftBody3D::destroy);


    auto soft3Renderer = table.addClass<SoftBody3DRenderer>(

        "SoftBody3DRenderer",

        std::function<SoftBody3DRenderer *()>([]() -> SoftBody3DRenderer * { return nullptr; }), true);

    soft3Renderer.addFunc("setBody", &SoftBody3DRenderer::setBody);

    soft3Renderer.addFunc("setColor", &SoftBody3DRenderer::setColor);

    soft3Renderer.addFunc("draw", &SoftBody3DRenderer::draw);


    auto fluid = table.addClass<Fluid2D>(

        "Fluid2D", std::function<Fluid2D *()>([]() -> Fluid2D * { return nullptr; }), true);

    fluid.addFunc("update", &Fluid2D::update);

    fluid.addFunc("setGravity", &Fluid2D::setGravity);

    fluid.addFunc("getGravityX", &Fluid2D::getGravityX);

    fluid.addFunc("getGravityY", &Fluid2D::getGravityY);

    fluid.addFunc("setSmoothingRadius", &Fluid2D::setSmoothingRadius);

    fluid.addFunc("getSmoothingRadius", &Fluid2D::getSmoothingRadius);

    fluid.addFunc("setRestDensity", &Fluid2D::setRestDensity);

    fluid.addFunc("getRestDensity", &Fluid2D::getRestDensity);

    fluid.addFunc("setPressureStiffness", &Fluid2D::setPressureStiffness);

    fluid.addFunc("getPressureStiffness", &Fluid2D::getPressureStiffness);

    fluid.addFunc("setNearPressureStiffness", &Fluid2D::setNearPressureStiffness);

    fluid.addFunc("getNearPressureStiffness", &Fluid2D::getNearPressureStiffness);

    fluid.addFunc("setViscosity", &Fluid2D::setViscosity);

    fluid.addFunc("getViscosity", &Fluid2D::getViscosity);

    fluid.addFunc("setIterations", &Fluid2D::setIterations);

    fluid.addFunc("getIterations", &Fluid2D::getIterations);

    fluid.addFunc("setBounds", &Fluid2D::setBounds);

    fluid.addFunc("clearBounds", &Fluid2D::clearBounds);

    fluid.addFunc("emit", &Fluid2D::emit);

    fluid.addFunc("clear", &Fluid2D::clear);

    fluid.addFunc("interactAt", &Fluid2D::interactAt);

    fluid.addFunc("setColor", &Fluid2D::setColor);

    fluid.addFunc("setParticleSize", &Fluid2D::setParticleSize);

    fluid.addFunc("getParticleSize", &Fluid2D::getParticleSize);

    fluid.addFunc("draw", &Fluid2D::draw);

    fluid.addFunc("getCapacity", &Fluid2D::getCapacity);

    fluid.addFunc("getParticleCount", &Fluid2D::getParticleCount);

    fluid.addFunc("getParticleX", &Fluid2D::getParticleX);

    fluid.addFunc("getParticleY", &Fluid2D::getParticleY);

    fluid.addFunc("getParticleVx", &Fluid2D::getParticleVx);

    fluid.addFunc("getParticleVy", &Fluid2D::getParticleVy);

    fluid.addFunc("destroy", &Fluid2D::destroy);

}


void Physics::expose(ssq::Class &cls) {

    cls.addFunc("getName", &Physics::getName);

    cls.addFunc("setMeter", &Physics::setMeter);

    cls.addFunc("getMeter", &Physics::getMeter);

    cls.addFunc("newWorld", &Physics::newWorld);

    cls.addFunc("newWorld3D", &Physics::newWorld3D);

    cls.addFunc("newDistanceField3D", &Physics::newDistanceField3D);

    cls.addFunc("newSoftBody3D", &Physics::newSoftBody3D);

    cls.addFunc("newSoftBody3DRenderer", &Physics::newSoftBody3DRenderer);

    cls.addFunc("newFluid2D", &Physics::newFluid2D);

}


}  // namespace eve::physics

state
bool state
Definition ActionTimelineWidget.cpp:33

y
float y
Definition AnimClip.cpp:738

x
float x
Definition AnimClip.cpp:738

z
float z
Definition AnimClip.cpp:738

Body3D.h

Body.h

DistanceField3D.h

vm
HSQUIRRELVM vm
Definition ECS.cpp:20

cls
HSQOBJECT cls
Definition ECS.cpp:21

values
std::map< std::string, Var > values
Definition EditorHost.cpp:490

Exception.h

Fixture.h

rows
int rows
Definition FloorTextures.cpp:208

cols
int cols
Definition FloorTextures.cpp:209

Fluid2D.h

capacity
std::uint32_t capacity
Definition GraphicsParticles.cpp:37

shape
ShaderImageInput shape
Definition GraphicsShaderResources.cpp:17

indices
std::vector< std::uint32_t > indices
Definition HeightmapMesh.cpp:19

height
std::uint32_t height
Definition ImageImporter.cpp:14

width
std::uint32_t width
Definition ImageImporter.cpp:13

Joint2D.h

Joint3D.h

range
Range range
Definition LanguageIndex.cpp:20

name
std::string name
Definition McpScriptTools.cpp:40

Mechanism2D.h

Mechanism3D.h

Module_IMPL
#define Module_IMPL(ModuleName, newExpr)
Definition Module.h:26

world
World3D * world
Definition PhysicsCapabilities.cpp:116

PhysicsCapabilities.h

Physics.h

vertices
std::vector< Point > vertices
Definition PlacementSystem.cpp:46

created
int created
Definition SceneCapabilities.cpp:631

Shape3D.h

SoftBody3DRenderer.h

SoftBody3D.h

count
std::uint32_t count
Definition SourceTiff.cpp:24

SquirrelBinding.h
The single Squirrel projection for common Result, Status and Value.

TerrainLoadGravity.h

spacing
int spacing
Definition TileConfig.cpp:86

body
std::string body
Definition UnityImporter.cpp:595

depth
std::uint32_t depth
Definition UnityVegetationPreset.cpp:34

World3D.h

World.h

eve::Exception
EVENGINE_API_FOUNDATION public API.
Definition Exception.h:13

eve::Module::getName
virtual std::string getName() const =0
Returns the name.

eve::Value
The canonical owning dynamic value used by data-facing protocols.
Definition Value.h:31

eve::physics::Body3D
3D rigid body (Box3D) in meter-space coordinates (+Y up by convention). Owned by a World3D; create pr...
Definition Body3D.h:24

eve::physics::Body3D::isAngularYLocked
bool isAngularYLocked() const
Whether rotation around Y is locked.

eve::physics::Body3D::setActive
void setActive(bool active)
Disables/enables the body and its shapes.
Definition Body3D.cpp:691

eve::physics::Body3D::isAngularXLocked
bool isAngularXLocked() const
Whether rotation around X is locked.

eve::physics::Body3D::setRotation
void setRotation(float qx, float qy, float qz, float qw)
Orientation as quaternion (x, y, z, w).
Definition Body3D.cpp:274

eve::physics::Body3D::localToWorldVector
std::vector< float > localToWorldVector(float x, float y, float z) const
Rotates a body-local direction/vector into world space; returns {x,y,z}.
Definition Body3D.cpp:386

eve::physics::Body3D::getInertiaYZ
float getInertiaYZ() const
Local symmetric inertia tensor YZ component.

eve::physics::Body3D::worldToLocalVector
std::vector< float > worldToLocalVector(float x, float y, float z) const
Rotates a world direction/vector into body-local space; returns {x,y,z}.
Definition Body3D.cpp:400

eve::physics::Body3D::getLocalCenterY
float getLocalCenterY() const
Local center of mass Y coordinate.

eve::physics::Body3D::isBullet
bool isBullet() const
True when bullet.
Definition Body3D.cpp:706

eve::physics::Body3D::setAngularDamping
void setAngularDamping(float damping)
Angular damping coefficient, finite and non-negative.
Definition Body3D.cpp:529

eve::physics::Body3D::isAngularZLocked
bool isAngularZLocked() const
Whether rotation around Z is locked.

eve::physics::Body3D::isActive
bool isActive() const
True when active.
Definition Body3D.cpp:699

eve::physics::Body3D::applyForce
void applyForce(float fx, float fy, float fz)
Force applied at the center of mass.
Definition Body3D.cpp:428

eve::physics::Body3D::getWorldCenterX
float getWorldCenterX() const
World center of mass X coordinate.

eve::physics::Body3D::getLinearVelocityY
float getLinearVelocityY() const
Returns the linear velocity y.
Definition Body3D.cpp:321

eve::physics::Body3D::localToWorldPoint
std::vector< float > localToWorldPoint(float x, float y, float z) const
Converts a body-local point to world coordinates; returns {x,y,z}.
Definition Body3D.cpp:356

eve::physics::Body3D::applyLinearImpulse
void applyLinearImpulse(float ix, float iy, float iz)
Instantaneous linear impulse.
Definition Body3D.cpp:443

eve::physics::Body3D::setFixedRotation
void setFixedRotation(bool fixed)
Lock all angular axes (Box3D motion locks).
Definition Body3D.cpp:676

eve::physics::Body3D::applyAngularImpulse
void applyAngularImpulse(float ix, float iy, float iz)
Instantaneous angular impulse.
Definition Body3D.cpp:453

eve::physics::Body3D::getInertiaYY
float getInertiaYY() const
Local inertia tensor YY component about the center of mass.

eve::physics::Body3D::getAngularDamping
float getAngularDamping() const
Current angular damping coefficient.
Definition Body3D.cpp:535

eve::physics::Body3D::getX
float getX() const
Returns the x.
Definition Body3D.cpp:259

eve::physics::Body3D::setLinearDamping
void setLinearDamping(float damping)
Linear damping coefficient, finite and non-negative.
Definition Body3D.cpp:519

eve::physics::Body3D::worldToLocalPoint
std::vector< float > worldToLocalPoint(float x, float y, float z) const
Converts a world point to body-local coordinates; returns {x,y,z}.
Definition Body3D.cpp:372

eve::physics::Body3D::applyLocalForceToCenter
void applyLocalForceToCenter(float fx, float fy, float fz)
Body-local force applied at the center of mass.
Definition Body3D.cpp:467

eve::physics::Body3D::isLinearYLocked
bool isLinearYLocked() const
Whether translation along Y is locked.

eve::physics::Body3D::getMass
float getMass() const
Body mass in kg.
Definition Body3D.cpp:331

eve::physics::Body3D::isFixedRotation
bool isFixedRotation() const
True when fixed rotation.
Definition Body3D.cpp:685

eve::physics::Body3D::setBullet
void setBullet(bool bullet)
CCD bullet mode.
Definition Body3D.cpp:701

eve::physics::Body3D::newBoxShape
Shape3D * newBoxShape(float width, float height, float depth, float density=1.f, float friction=0.2f, float restitution=0.f)
Creates a box shape in meter-space units.
Definition Body3D.cpp:715

eve::physics::Body3D::applyLocalTorque
void applyLocalTorque(float tx, float ty, float tz)
Body-local torque.
Definition Body3D.cpp:474

eve::physics::Body3D::getY
float getY() const
Returns the y.
Definition Body3D.cpp:264

eve::physics::Body3D::setAwake
void setAwake(bool awake)
Wakes / sleeps the body manually.
Definition Body3D.cpp:708

eve::physics::Body3D::applyLinearImpulseAt
void applyLinearImpulseAt(float ix, float iy, float iz, float x, float y, float z)
Instantaneous linear impulse applied at a world position.
Definition Body3D.cpp:448

eve::physics::Body3D::getLinearDamping
float getLinearDamping() const
Current linear damping coefficient.
Definition Body3D.cpp:525

eve::physics::Body3D::getInertiaXZ
float getInertiaXZ() const
Local symmetric inertia tensor XZ component.

eve::physics::Body3D::destroy
void destroy()
Destroys the body inside its world.
Definition Body3D.cpp:225

eve::physics::Body3D::getRotZ
float getRotZ() const
Returns the rot z.
Definition Body3D.cpp:301

eve::physics::Body3D::getSleepThreshold
float getSleepThreshold() const
Current sleep velocity threshold.
Definition Body3D.cpp:564

eve::physics::Body3D::setMassProperties
void setMassProperties(float mass, float centerX, float centerY, float centerZ, float inertiaXX, float inertiaYY, float inertiaZZ, float inertiaXY=0.f, float inertiaXZ=0.f, float inertiaYZ=0.f)
Overrides mass, local center of mass, and the symmetric local inertia tensor.
Definition Body3D.cpp:588

eve::physics::Body3D::setTargetTransform
void setTargetTransform(float x, float y, float z, float qx, float qy, float qz, float qw, float timeStep)
Drives a kinematic body to a target pose over a positive time step. The target quaternion is normaliz...
Definition Body3D.cpp:504

eve::physics::Body3D::getRotY
float getRotY() const
Returns the rot y.
Definition Body3D.cpp:296

eve::physics::Body3D::applyLocalForce
void applyLocalForce(float fx, float fy, float fz, float x, float y, float z)
Body-local force applied at a body-local point.
Definition Body3D.cpp:458

eve::physics::Body3D::isLinearZLocked
bool isLinearZLocked() const
Whether translation along Z is locked.

eve::physics::Body3D::getGravityScale
float getGravityScale() const
Current world-gravity multiplier.
Definition Body3D.cpp:545

eve::physics::Body3D::getLocalCenterZ
float getLocalCenterZ() const
Local center of mass Z coordinate.

eve::physics::Body3D::getRotX
float getRotX() const
Returns the rot x.
Definition Body3D.cpp:291

eve::physics::Body3D::isLinearXLocked
bool isLinearXLocked() const
Whether translation along X is locked.

eve::physics::Body3D::getAngularVelocityZ
float getAngularVelocityZ() const
Returns the angular velocity z.
Definition Body3D.cpp:351

eve::physics::Body3D::setSleepEnabled
void setSleepEnabled(bool enabled)
Enables or disables automatic sleeping for this body.
Definition Body3D.cpp:549

eve::physics::Body3D::getId
int getId() const
Stable id used by collision events.
Definition Body3D.h:35

eve::physics::Body3D::applyLocalLinearImpulseToCenter
void applyLocalLinearImpulseToCenter(float ix, float iy, float iz)
Body-local linear impulse applied at the center of mass.
Definition Body3D.cpp:490

eve::physics::Body3D::getAngularVelocityX
float getAngularVelocityX() const
Returns the angular velocity x.
Definition Body3D.cpp:341

eve::physics::Body3D::getType
std::string getType() const
Returns the type.
Definition Body3D.cpp:671

eve::physics::Body3D::getRotW
float getRotW() const
Returns the rot w.
Definition Body3D.cpp:306

eve::physics::Body3D::applyTorque
void applyTorque(float tx, float ty, float tz)
Torque applied in world space.
Definition Body3D.cpp:438

eve::physics::Body3D::isSleepEnabled
bool isSleepEnabled() const
Whether automatic sleeping is enabled.
Definition Body3D.cpp:554

eve::physics::Body3D::getInertiaXX
float getInertiaXX() const
Local inertia tensor XX component about the center of mass.

eve::physics::Body3D::setMotionLocks
void setMotionLocks(bool linearX, bool linearY, bool linearZ, bool angularX, bool angularY, bool angularZ)
Atomically locks translation and rotation on individual local solver axes.
Definition Body3D.cpp:568

eve::physics::Body3D::applyForceAt
void applyForceAt(float fx, float fy, float fz, float x, float y, float z)
Force applied at a world position.
Definition Body3D.cpp:433

eve::physics::Body3D::resetMassProperties
void resetMassProperties()
Restores automatic mass, center, and inertia calculation from attached shapes.
Definition Body3D.cpp:627

eve::physics::Body3D::getInertiaXY
float getInertiaXY() const
Local symmetric inertia tensor XY component.

eve::physics::Body3D::getWorldCenterZ
float getWorldCenterZ() const
World center of mass Z coordinate.

eve::physics::Body3D::getInertiaZZ
float getInertiaZZ() const
Local inertia tensor ZZ component about the center of mass.

eve::physics::Body3D::newCapsuleShape
Shape3D * newCapsuleShape(float height, float radius, float density=1.f, float friction=0.2f, float restitution=0.f)
Creates a capsule along local Y.
Definition Body3D.cpp:753

eve::physics::Body3D::setLinearVelocity
void setLinearVelocity(float vx, float vy, float vz)
Linear velocity in m/s.
Definition Body3D.cpp:311

eve::physics::Body3D::applyLocalLinearImpulse
void applyLocalLinearImpulse(float ix, float iy, float iz, float x, float y, float z)
Body-local linear impulse applied at a body-local point.
Definition Body3D.cpp:480

eve::physics::Body3D::getWorldCenterY
float getWorldCenterY() const
World center of mass Y coordinate.

eve::physics::Body3D::setGravityScale
void setGravityScale(float scale)
Multiplier applied to world gravity; may be negative.
Definition Body3D.cpp:539

eve::physics::Body3D::isAwake
bool isAwake() const
True when awake.
Definition Body3D.cpp:713

eve::physics::Body3D::setPosition
void setPosition(float x, float y, float z)
Position in meters.
Definition Body3D.cpp:254

eve::physics::Body3D::setType
void setType(const std::string &bodyType)
"static" | "kinematic" | "dynamic".
Definition Body3D.cpp:656

eve::physics::Body3D::getLocalCenterX
float getLocalCenterX() const
Local center of mass X coordinate.

eve::physics::Body3D::getLinearVelocityZ
float getLinearVelocityZ() const
Returns the linear velocity z.
Definition Body3D.cpp:326

eve::physics::Body3D::getWorldPointVelocity
std::vector< float > getWorldPointVelocity(float x, float y, float z) const
World-space velocity at the supplied world point.
Definition Body3D.cpp:421

eve::physics::Body3D::setAngularVelocity
void setAngularVelocity(float wx, float wy, float wz)
Angular velocity in rad/s.
Definition Body3D.cpp:336

eve::physics::Body3D::setSleepThreshold
void setSleepThreshold(float threshold)
Sleep velocity threshold, finite and non-negative.
Definition Body3D.cpp:558

eve::physics::Body3D::getAngularVelocityY
float getAngularVelocityY() const
Returns the angular velocity y.
Definition Body3D.cpp:346

eve::physics::Body3D::getLocalPointVelocity
std::vector< float > getLocalPointVelocity(float x, float y, float z) const
World-space velocity at a point expressed in body-local coordinates.
Definition Body3D.cpp:407

eve::physics::Body3D::getZ
float getZ() const
Returns the z.
Definition Body3D.cpp:269

eve::physics::Body3D::newSphereShape
Shape3D * newSphereShape(float radius, float density=1.f, float friction=0.2f, float restitution=0.f)
Creates a sphere shape in meter-space units.
Definition Body3D.cpp:735

eve::physics::Body3D::getLinearVelocityX
float getLinearVelocityX() const
Returns the linear velocity x.
Definition Body3D.cpp:316

eve::physics::Body3D::applyLocalAngularImpulse
void applyLocalAngularImpulse(float ix, float iy, float iz)
Body-local angular impulse.
Definition Body3D.cpp:497

eve::physics::Body::newRectangleFixture
Fixture * newRectangleFixture(float width, float height, float density=1.f, float friction=0.2f, float restitution=0.f)
Creates a rectangle fixture in pixel-space units.
Definition Body.cpp:228

eve::physics::Body::getLinearVelocityX
float getLinearVelocityX() const
Returns the linear velocity x.
Definition Body.cpp:130

eve::physics::Body::applyForceAt
void applyForceAt(float fx, float fy, float x, float y)
Force applied at a world pixel position.
Definition Body.cpp:173

eve::physics::Body::setBullet
void setBullet(bool bullet)
CCD bullet mode (recommended for fast small bodies).
Definition Body.cpp:214

eve::physics::Body::getX
float getX() const
Returns the x.
Definition Body.cpp:105

eve::physics::Body::setAwake
void setAwake(bool awake)
Wakes / sleeps the body manually.
Definition Body.cpp:221

eve::physics::Body::setType
void setType(const std::string &bodyType)
"static" | "kinematic" | "dynamic".
Definition Body.cpp:190

eve::physics::Body::setAngle
void setAngle(float radians)
Rotation in radians.
Definition Body.cpp:115

eve::physics::Body::getLinearVelocityY
float getLinearVelocityY() const
Returns the linear velocity y.
Definition Body.cpp:135

eve::physics::Body::isActive
bool isActive() const
True when active.
Definition Body.cpp:212

eve::physics::Body::applyLinearImpulse
void applyLinearImpulse(float ix, float iy)
Instantaneous linear impulse.
Definition Body.cpp:179

eve::physics::Body::newCircleFixture
Fixture * newCircleFixture(float radius, float density=1.f, float friction=0.2f, float restitution=0.f)
Creates a circular fixture in pixel-space units.
Definition Body.cpp:256

eve::physics::Body::setFixedRotation
void setFixedRotation(bool fixed)
Locks rotation so the body cannot spin.
Definition Body.cpp:200

eve::physics::Body::applyForce
void applyForce(float fx, float fy)
Force (pixels/s² * kg) applied at the center of mass.
Definition Body.cpp:167

eve::physics::Body::isAwake
bool isAwake() const
True when awake.
Definition Body.cpp:226

eve::physics::Body::isFixedRotation
bool isFixedRotation() const
True when fixed rotation.
Definition Body.cpp:205

eve::physics::Body::isBullet
bool isBullet() const
True when bullet.
Definition Body.cpp:219

eve::physics::Body::setAngularVelocity
void setAngularVelocity(float omega)
Angular velocity in radians/s.
Definition Body.cpp:157

eve::physics::Body::getAngularVelocity
float getAngularVelocity() const
Returns the angular velocity.
Definition Body.cpp:162

eve::physics::Body::destroy
void destroy()
Destroys the body inside its world.
Definition Body.cpp:72

eve::physics::Body::applyAngularImpulse
void applyAngularImpulse(float impulse)
Instantaneous angular impulse.
Definition Body.cpp:185

eve::physics::Body::getWorldCenterY
float getWorldCenterY() const
Returns the world center y.
Definition Body.cpp:152

eve::physics::Body::getLinearSpeed
float getLinearSpeed() const
Magnitude of the linear velocity.
Definition Body.cpp:140

eve::physics::Body::getAngle
float getAngle() const
Returns the angle.
Definition Body.cpp:120

eve::physics::Body::getType
std::string getType() const
Returns the type.
Definition Body.cpp:195

eve::physics::Body::getId
int getId() const
Stable id used by contact/impact events.
Definition Body.h:32

eve::physics::Body::setPosition
void setPosition(float x, float y)
Position in pixels.
Definition Body.cpp:100

eve::physics::Body::getWorldCenterX
float getWorldCenterX() const
World center of mass in pixels.
Definition Body.cpp:147

eve::physics::Body::newRectangleFixtureAt
Fixture * newRectangleFixtureAt(float width, float height, float offsetX, float offsetY, float density=1.f, float friction=0.2f, float restitution=0.f)
Creates an offset rectangle fixture in pixel-space units.
Definition Body.cpp:233

eve::physics::Body::getMass
float getMass() const
Mass in kilograms (Box2D units).
Definition Body.cpp:145

eve::physics::Body::setActive
void setActive(bool active)
Disables/enables the body and its fixtures.
Definition Body.cpp:207

eve::physics::Body::setLinearVelocity
void setLinearVelocity(float vx, float vy)
Linear velocity in pixels/s.
Definition Body.cpp:125

eve::physics::Body::getY
float getY() const
Returns the y.
Definition Body.cpp:110

eve::physics::DistanceField3D
Regular 3D signed-distance grid for terrain and voxel collision queries. Negative samples are solid,...
Definition DistanceField3D.h:16

eve::physics::DistanceField3D::getMoverGroundDot
float getMoverGroundDot() const
Greatest dot product between mover Up and a normal from the latest move.
Definition DistanceField3D.h:169

eve::physics::DistanceField3D::setMoverGroundSnap
void setMoverGroundSnap(float distance)
Set the non-negative distance used to snap onto walkable ground after movement.
Definition DistanceField3D.cpp:393

eve::physics::DistanceField3D::getCollisionDistance
float getCollisionDistance() const
Signed clearance from the last check (negative means penetration).
Definition DistanceField3D.h:125

eve::physics::DistanceField3D::getCastDistance
float getCastDistance() const
World-space travel distance at the last cast hit.
Definition DistanceField3D.h:149

eve::physics::DistanceField3D::fill
void fill(float distance)
Set every grid sample to the same finite distance.
Definition DistanceField3D.cpp:66

eve::physics::DistanceField3D::getSampleCount
int getSampleCount() const
Total number of signed-distance samples.
Definition DistanceField3D.h:54

eve::physics::DistanceField3D::moveCapsule
bool moveCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius, float deltaX, float deltaY, float deltaZ)
Resolve a capsule displacement against the field with sliding and depenetration. The capsule coordina...
Definition DistanceField3D.cpp:407

eve::physics::DistanceField3D::getCollisionY
float getCollisionY() const
Y coordinate of the closest sampled point from the last collision check.
Definition DistanceField3D.h:129

eve::physics::DistanceField3D::setMoverUp
void setMoverUp(float x, float y, float z)
Set the normalized reference-up direction used for ground classification.
Definition DistanceField3D.cpp:369

eve::physics::DistanceField3D::fillRegion
void fillRegion(int x, int y, int z, int width, int height, int depth, float distance)
Fill an in-bounds grid subregion with one finite signed distance.
Definition DistanceField3D.cpp:98

eve::physics::DistanceField3D::isMoverGrounded
bool isMoverGrounded() const
Whether the latest move encountered a normal within the walkable slope limit.
Definition DistanceField3D.h:167

eve::physics::DistanceField3D::getMoverGroundSnap
float getMoverGroundSnap() const
Current post-move ground-snap distance.
Definition DistanceField3D.h:119

eve::physics::DistanceField3D::sampleNormal
void sampleNormal(float x, float y, float z)
Estimate the normalized outward field gradient at a world position.
Definition DistanceField3D.cpp:151

eve::physics::DistanceField3D::getOriginX
float getOriginX() const
World-space X coordinate of grid vertex (0,0,0).
Definition DistanceField3D.h:58

eve::physics::DistanceField3D::getMoverStepHeight
float getMoverStepHeight() const
Current automatic step height; zero disables step climbing.
Definition DistanceField3D.h:123

eve::physics::DistanceField3D::checkCapsule
bool checkCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius)
Test a capsule defined by two sphere centers against the solid.
Definition DistanceField3D.cpp:210

eve::physics::DistanceField3D::getOriginY
float getOriginY() const
World-space Y coordinate of grid vertex (0,0,0).
Definition DistanceField3D.h:60

eve::physics::DistanceField3D::getCellSize
float getCellSize() const
World-space distance between adjacent grid vertices.
Definition DistanceField3D.h:56

eve::physics::DistanceField3D::getHeight
int getHeight() const
Number of grid vertices along the Y axis.
Definition DistanceField3D.h:50

eve::physics::DistanceField3D::getOutsideDistance
float getOutsideDistance() const
Distance returned for world samples outside the grid.
Definition DistanceField3D.h:64

eve::physics::DistanceField3D::getNormalZ
float getNormalZ() const
Z component of the most recently sampled collision normal.
Definition DistanceField3D.h:75

eve::physics::DistanceField3D::getMoverDeltaX
float getMoverDeltaX() const
Resolved X displacement from the most recent moveCapsule call.
Definition DistanceField3D.h:153

eve::physics::DistanceField3D::getRevision
unsigned int getRevision() const
Monotonic wrapping counter incremented once after each successful mutation.
Definition DistanceField3D.h:66

eve::physics::DistanceField3D::getShapeContactY
float getShapeContactY() const
Y coordinate on the sphere or capsule surface along the contact normal.
Definition DistanceField3D.h:141

eve::physics::DistanceField3D::setMoverSlopeLimit
void setMoverSlopeLimit(float degrees)
Set the maximum walkable slope angle in degrees, clamped to [0, 89.9].
Definition DistanceField3D.cpp:380

eve::physics::DistanceField3D::castCapsule
bool castCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius, float deltaX, float deltaY, float deltaZ)
Sweep a capsule through the field and cache the earliest contact.
Definition DistanceField3D.cpp:313

eve::physics::DistanceField3D::getNormalX
float getNormalX() const
X component of the most recently sampled collision normal.
Definition DistanceField3D.h:71

eve::physics::DistanceField3D::castSphere
bool castSphere(float x, float y, float z, float radius, float deltaX, float deltaY, float deltaZ)
Sweep a sphere through the field and cache the earliest contact.
Definition DistanceField3D.cpp:265

eve::physics::DistanceField3D::getMoverNormalX
float getMoverNormalX() const
X component of the most recent blocking or recovery normal.
Definition DistanceField3D.h:159

eve::physics::DistanceField3D::getMoverDeltaZ
float getMoverDeltaZ() const
Resolved Z displacement from the most recent moveCapsule call.
Definition DistanceField3D.h:157

eve::physics::DistanceField3D::didCastStartInside
bool didCastStartInside() const
Whether the most recent cast began overlapping the solid.
Definition DistanceField3D.h:151

eve::physics::DistanceField3D::getCollisionX
float getCollisionX() const
X coordinate of the closest sampled point from the last collision check.
Definition DistanceField3D.h:127

eve::physics::DistanceField3D::getMoverIterations
int getMoverIterations() const
Number of solver passes used by the most recent moveCapsule call.
Definition DistanceField3D.h:165

eve::physics::DistanceField3D::getShapeContactZ
float getShapeContactZ() const
Z coordinate on the sphere or capsule surface along the contact normal.
Definition DistanceField3D.h:143

eve::physics::DistanceField3D::getWidth
int getWidth() const
Number of grid vertices along the X axis.
Definition DistanceField3D.h:48

eve::physics::DistanceField3D::getNormalY
float getNormalY() const
Y component of the most recently sampled collision normal.
Definition DistanceField3D.h:73

eve::physics::DistanceField3D::didMoverHitWall
bool didMoverHitWall() const
Whether the latest move encountered a non-walkable contact normal.
Definition DistanceField3D.h:171

eve::physics::DistanceField3D::setMoverSkinWidth
void setMoverSkinWidth(float width)
Set the non-negative separation retained from surfaces by moveCapsule.
Definition DistanceField3D.cpp:387

eve::physics::DistanceField3D::getSurfaceX
float getSurfaceX() const
X coordinate of the projected signed-distance-field surface point.
Definition DistanceField3D.h:133

eve::physics::DistanceField3D::getCastFraction
float getCastFraction() const
Fraction in [0,1] of the requested displacement at the last cast hit.
Definition DistanceField3D.h:147

eve::physics::DistanceField3D::getMoverDeltaY
float getMoverDeltaY() const
Resolved Y displacement from the most recent moveCapsule call.
Definition DistanceField3D.h:155

eve::physics::DistanceField3D::setDistance
void setDistance(int x, int y, int z, float distance)
Set a signed-distance sample at a grid vertex.
Definition DistanceField3D.cpp:114

eve::physics::DistanceField3D::getCollisionZ
float getCollisionZ() const
Z coordinate of the closest sampled point from the last collision check.
Definition DistanceField3D.h:131

eve::physics::DistanceField3D::getShapeContactX
float getShapeContactX() const
X coordinate on the sphere or capsule surface along the contact normal.
Definition DistanceField3D.h:139

eve::physics::DistanceField3D::checkSphere
bool checkSphere(float x, float y, float z, float radius)
Test a sphere against the solid (distance <= radius).
Definition DistanceField3D.cpp:203

eve::physics::DistanceField3D::getPenetrationDepth
float getPenetrationDepth() const
Non-negative overlap depth from the most recent overlap, cast, or move query.
Definition DistanceField3D.h:145

eve::physics::DistanceField3D::getSurfaceZ
float getSurfaceZ() const
Z coordinate of the projected signed-distance-field surface point.
Definition DistanceField3D.h:137

eve::physics::DistanceField3D::getSurfaceY
float getSurfaceY() const
Y coordinate of the projected signed-distance-field surface point.
Definition DistanceField3D.h:135

eve::physics::DistanceField3D::getMoverNormalZ
float getMoverNormalZ() const
Z component of the most recent blocking or recovery normal.
Definition DistanceField3D.h:163

eve::physics::DistanceField3D::setMoverStepHeight
void setMoverStepHeight(float height)
Set the maximum non-negative ledge height automatically climbed by moveCapsule.
Definition DistanceField3D.cpp:400

eve::physics::DistanceField3D::getDepth
int getDepth() const
Number of grid vertices along the Z axis.
Definition DistanceField3D.h:52

eve::physics::DistanceField3D::getMoverSkinWidth
float getMoverSkinWidth() const
Current mover separation from collision surfaces.
Definition DistanceField3D.h:115

eve::physics::DistanceField3D::sample
float sample(float x, float y, float z) const
Trilinearly sample the field in world coordinates.
Definition DistanceField3D.cpp:126

eve::physics::DistanceField3D::getOriginZ
float getOriginZ() const
World-space Z coordinate of grid vertex (0,0,0).
Definition DistanceField3D.h:62

eve::physics::DistanceField3D::getDistance
float getDistance(int x, int y, int z) const
Read a grid vertex; out-of-range vertices return the outside distance.
Definition DistanceField3D.cpp:122

eve::physics::DistanceField3D::getMoverNormalY
float getMoverNormalY() const
Y component of the most recent blocking or recovery normal.
Definition DistanceField3D.h:161

eve::physics::Fixture::destroy
void destroy()
Destroys the fixture inside its world.
Definition Fixture.cpp:30

eve::physics::Fixture::getBody
Body * getBody()
Returns the owning body, or null after invalidation.
Definition Fixture.h:77

eve::physics::Fixture::setSensor
void setSensor(bool sensor)
Sensor fixtures report contacts but never collide.
Definition Fixture.cpp:43

eve::physics::Fixture::testPoint
bool testPoint(float x, float y) const
Pixel-space point-in-fixture test (uses World meter).
Definition Fixture.cpp:105

eve::physics::Fixture::getMaskBits
int getMaskBits() const
Returns the mask bits.
Definition Fixture.cpp:90

eve::physics::Fixture::getCategoryBits
int getCategoryBits() const
Returns the category bits.
Definition Fixture.cpp:79

eve::physics::Fixture::setMaskBits
void setMaskBits(int bits)
Sets the mask bits.
Definition Fixture.cpp:83

eve::physics::Fixture::getFriction
float getFriction() const
Returns the friction.
Definition Fixture.cpp:55

eve::physics::Fixture::setDensity
void setDensity(float density)
Sets the density.
Definition Fixture.cpp:64

eve::physics::Fixture::isSensor
bool isSensor() const
True when sensor.
Definition Fixture.cpp:48

eve::physics::Fixture::setFriction
void setFriction(float friction)
Material properties.
Definition Fixture.cpp:50

eve::physics::Fixture::getGroupIndex
int getGroupIndex() const
Returns the group index.
Definition Fixture.cpp:99

eve::physics::Fixture::getBodyId
int getBodyId() const
Id of the owning body.
Definition Fixture.cpp:103

eve::physics::Fixture::setCategoryBits
void setCategoryBits(int bits)
Collision filtering (Box2D category/mask bits, group index).
Definition Fixture.cpp:72

eve::physics::Fixture::setGroupIndex
void setGroupIndex(int index)
Sets the group index.
Definition Fixture.cpp:92

eve::physics::Fixture::getTag
const std::string & getTag() const
Returns the tag.
Definition Fixture.h:51

eve::physics::Fixture::getDensity
float getDensity() const
Returns the density.
Definition Fixture.cpp:70

eve::physics::Fixture::setRestitution
void setRestitution(float restitution)
Sets the restitution.
Definition Fixture.cpp:57

eve::physics::Fixture::setTag
void setTag(const std::string &tag)
Arbitrary string tag surfaced in begin/end contact events.
Definition Fixture.h:49

eve::physics::Fixture::getRestitution
float getRestitution() const
Returns the restitution.
Definition Fixture.cpp:62

eve::physics::Fluid2D
Interactive 2D particle fluid (double-density relaxation) in pixel space. Script-owned; independent o...
Definition Fluid2D.h:19

eve::physics::Fluid2D::setViscosity
void setViscosity(float viscosity)
Sets the viscosity.
Definition Fluid2D.cpp:47

eve::physics::Fluid2D::getNearPressureStiffness
float getNearPressureStiffness() const
Returns the near pressure stiffness.
Definition Fluid2D.h:57

eve::physics::Fluid2D::getParticleVy
float getParticleVy(int index) const
Returns the particle vy.
Definition Fluid2D.cpp:124

eve::physics::Fluid2D::getGravityY
float getGravityY() const
Returns the gravity y.
Definition Fluid2D.h:37

eve::physics::Fluid2D::update
void update(float dt)
Updates .
Definition Fluid2D.cpp:266

eve::physics::Fluid2D::getIterations
int getIterations() const
Returns the iterations.
Definition Fluid2D.h:67

eve::physics::Fluid2D::setIterations
void setIterations(int iterations)
Solver iterations per frame (default 3).
Definition Fluid2D.cpp:49

eve::physics::Fluid2D::getRestDensity
float getRestDensity() const
Returns the rest density.
Definition Fluid2D.h:47

eve::physics::Fluid2D::getGravityX
float getGravityX() const
Returns the gravity x.
Definition Fluid2D.h:35

eve::physics::Fluid2D::setBounds
void setBounds(float x, float y, float w, float h)
Axis-aligned container; particles bounce inside.
Definition Fluid2D.cpp:51

eve::physics::Fluid2D::getParticleCount
int getParticleCount() const
Returns the particle count.
Definition Fluid2D.h:111

eve::physics::Fluid2D::setRestDensity
void setRestDensity(float density)
Target rest density for the relaxation solver (default 4).
Definition Fluid2D.cpp:38

eve::physics::Fluid2D::setGravity
void setGravity(float gx, float gy)
Sets the gravity.
Definition Fluid2D.cpp:28

eve::physics::Fluid2D::clear
void clear()
Clear all particles.
Definition Fluid2D.cpp:84

eve::physics::Fluid2D::emit
int emit(float x, float y, int count, float vx=0.f, float vy=0.f)
Spawn up to count particles at (x,y) with initial velocity. Returns number actually added.
Definition Fluid2D.cpp:65

eve::physics::Fluid2D::getSmoothingRadius
float getSmoothingRadius() const
Returns the smoothing radius.
Definition Fluid2D.h:42

eve::physics::Fluid2D::destroy
void destroy()
Destroys .
Definition Fluid2D.cpp:22

eve::physics::Fluid2D::getCapacity
int getCapacity() const
Returns the capacity.
Definition Fluid2D.h:109

eve::physics::Fluid2D::setPressureStiffness
void setPressureStiffness(float k)
Pressure stiffness (default 0.5).
Definition Fluid2D.cpp:43

eve::physics::Fluid2D::getParticleY
float getParticleY(int index) const
Returns the particle y.
Definition Fluid2D.cpp:114

eve::physics::Fluid2D::setParticleSize
void setParticleSize(float size)
Particle draw size in pixels (default 5).
Definition Fluid2D.cpp:103

eve::physics::Fluid2D::setSmoothingRadius
void setSmoothingRadius(float radius)
Interaction / neighbor radius in pixels (default 18).
Definition Fluid2D.cpp:33

eve::physics::Fluid2D::draw
void draw(graphics::Graphics *gfx)
Draws .
Definition Fluid2D.cpp:329

eve::physics::Fluid2D::getParticleSize
float getParticleSize() const
Returns the particle size.
Definition Fluid2D.h:103

eve::physics::Fluid2D::getParticleVx
float getParticleVx(int index) const
Returns the particle vx.
Definition Fluid2D.cpp:119

eve::physics::Fluid2D::setNearPressureStiffness
void setNearPressureStiffness(float k)
Near-pressure (anti-clustering) stiffness (default 0.5).
Definition Fluid2D.cpp:45

eve::physics::Fluid2D::getViscosity
float getViscosity() const
Returns the viscosity.
Definition Fluid2D.h:62

eve::physics::Fluid2D::setColor
void setColor(float r, float g, float b, float a=1.f)
Sets the color.
Definition Fluid2D.cpp:96

eve::physics::Fluid2D::interactAt
void interactAt(float x, float y, float radius, float strength)
Mouse / pointer interaction: positive strength attracts, negative repels. Applied as acceleration wit...
Definition Fluid2D.cpp:89

eve::physics::Fluid2D::clearBounds
void clearBounds()
Clears bounds.
Definition Fluid2D.cpp:63

eve::physics::Fluid2D::getPressureStiffness
float getPressureStiffness() const
Returns the pressure stiffness.
Definition Fluid2D.h:52

eve::physics::Fluid2D::getParticleX
float getParticleX(int index) const
Returns the particle x.
Definition Fluid2D.cpp:109

eve::physics::Joint2D::setWheelSpring
void setWheelSpring(float frequencyHz, float dampingRatio)
Configures wheel suspension spring.
Definition Joint2D.cpp:213

eve::physics::Joint2D::setGearRatio
void setGearRatio(float ratio)
Changes gear ratio.
Definition Joint2D.cpp:272

eve::physics::Joint2D::getMotorAngularOffset
float getMotorAngularOffset() const
Motor angular offset in radians.
Definition Joint2D.cpp:267

eve::physics::Joint2D::getGearJoint1
Joint2D * getGearJoint1() const
First joint linked by a gear, or null.
Definition Joint2D.h:129

eve::physics::Joint2D::getKind
std::string getKind() const
Joint kind string for script/debug.
Definition Joint2D.cpp:76

eve::physics::Joint2D::getRevoluteSpeed
float getRevoluteSpeed() const
Current revolute speed in radians/second.
Definition Joint2D.cpp:159

eve::physics::Joint2D::setPrismaticMotor
void setPrismaticMotor(bool enabled, float speedPixels, float maxForcePixels)
Configures a prismatic motor in pixels/second and pixel-force units.
Definition Joint2D.cpp:178

eve::physics::Joint2D::getWeldFrequency
float getWeldFrequency() const
Weld spring frequency in Hertz.
Definition Joint2D.cpp:204

eve::physics::Joint2D::setMotorAngularOffset
void setMotorAngularOffset(float radians)
Sets motor-joint angular offset in radians.
Definition Joint2D.cpp:246

eve::physics::Joint2D::getDistanceLength
float getDistanceLength() const
Distance-joint rest length in pixels.
Definition Joint2D.cpp:115

eve::physics::Joint2D::destroy
void destroy()
Destroys the backend joint and invalidates this wrapper.
Definition Joint2D.cpp:51

eve::physics::Joint2D::getGearJoint2
Joint2D * getGearJoint2() const
Second joint linked by a gear, or null.
Definition Joint2D.h:136

eve::physics::Joint2D::setWeldSpring
void setWeldSpring(float frequencyHz, float dampingRatio)
Configures weld rotational spring frequency and damping.
Definition Joint2D.cpp:196

eve::physics::Joint2D::getMotorLinearOffsetX
float getMotorLinearOffsetX() const
Motor linear offset X in pixels.
Definition Joint2D.cpp:259

eve::physics::Joint2D::setPrismaticLimits
void setPrismaticLimits(bool enabled, float lowerPixels, float upperPixels)
Configures prismatic translation limits in pixels.
Definition Joint2D.cpp:168

eve::physics::Joint2D::setCollideConnected
void setCollideConnected(bool collide)
Enables or disables collision between the attached bodies.
Definition Joint2D.cpp:92

eve::physics::Joint2D::setMotorLimits
void setMotorLimits(float maxForcePixels, float maxTorque)
Sets motor max force (pixel-force) and torque (N·m).
Definition Joint2D.cpp:251

eve::physics::Joint2D::setWheelMotor
void setWheelMotor(bool enabled, float speed, float maxTorque)
Configures wheel spin motor in radians/second and newton-metres.
Definition Joint2D.cpp:221

eve::physics::Joint2D::getPrismaticSpeed
float getPrismaticSpeed() const
Current prismatic speed in pixels/second.
Definition Joint2D.cpp:191

eve::physics::Joint2D::getBodyBId
int getBodyBId() const
Stable ID of attached body B, or -1 after invalidation.
Definition Joint2D.cpp:90

eve::physics::Joint2D::setDistanceSpring
void setDistanceSpring(float frequencyHz, float dampingRatio)
Configures distance spring frequency (Hz) and damping ratio.
Definition Joint2D.cpp:119

eve::physics::Joint2D::isValid
bool isValid() const
Whether the backend joint still exists.
Definition Joint2D.cpp:38

eve::physics::Joint2D::getCollideConnected
bool getCollideConnected() const
Whether attached bodies may collide.
Definition Joint2D.cpp:101

eve::physics::Joint2D::getDistanceFrequency
float getDistanceFrequency() const
Distance spring frequency in Hertz.
Definition Joint2D.cpp:127

eve::physics::Joint2D::getWheelTranslation
float getWheelTranslation() const
Current wheel translation along the suspension axis in pixels.
Definition Joint2D.cpp:230

eve::physics::Joint2D::getBodyAId
int getBodyAId() const
Stable ID of attached body A, or -1 after invalidation.
Definition Joint2D.cpp:89

eve::physics::Joint2D::getId
int getId() const
Stable world-local identifier.
Definition Joint2D.h:38

eve::physics::Joint2D::setRevoluteMotor
void setRevoluteMotor(bool enabled, float speed, float maxTorque)
Configures the revolute motor in radians/second and newton-metres.
Definition Joint2D.cpp:146

eve::physics::Joint2D::getRevoluteAngle
float getRevoluteAngle() const
Current revolute angle in radians.
Definition Joint2D.cpp:155

eve::physics::Joint2D::getMotorLinearOffsetY
float getMotorLinearOffsetY() const
Motor linear offset Y in pixels.
Definition Joint2D.cpp:263

eve::physics::Joint2D::setRevoluteLimits
void setRevoluteLimits(bool enabled, float lower, float upper)
Configures revolute angular limits in radians.
Definition Joint2D.cpp:136

eve::physics::Joint2D::getGearRatio
float getGearRatio() const
Current gear ratio.
Definition Joint2D.cpp:278

eve::physics::Joint2D::getWeldDampingRatio
float getWeldDampingRatio() const
Weld spring damping ratio.
Definition Joint2D.cpp:208

eve::physics::Joint2D::getPrismaticTranslation
float getPrismaticTranslation() const
Current prismatic translation in pixels.
Definition Joint2D.cpp:187

eve::physics::Joint2D::setDistanceLength
void setDistanceLength(float lengthPixels)
Changes distance-joint rest length in pixels.
Definition Joint2D.cpp:110

eve::physics::Joint2D::getWheelSpeed
float getWheelSpeed() const
Current wheel spin speed in radians/second.
Definition Joint2D.cpp:234

eve::physics::Joint2D::getDistanceDampingRatio
float getDistanceDampingRatio() const
Distance spring damping ratio.
Definition Joint2D.cpp:131

eve::physics::Joint2D::setMotorLinearOffset
void setMotorLinearOffset(float xPixels, float yPixels)
Sets motor-joint linear offset in pixels (bodyA frame).
Definition Joint2D.cpp:239

eve::physics::Joint2D::getRevoluteMotorTorque
float getRevoluteMotorTorque() const
Current revolute motor torque in newton-metres.
Definition Joint2D.cpp:163

eve::physics::Joint3D::getConstraintForceX
float getConstraintForceX() const
Current world-space constraint force X in newtons.

eve::physics::Joint3D::setDistanceLength
void setDistanceLength(float length)
Changes distance-joint rest length in metres.
Definition Joint3D.cpp:119

eve::physics::Joint3D::getConstraintForceY
float getConstraintForceY() const
Current world-space constraint force Y in newtons.

eve::physics::Joint3D::getParallelHertz
float getParallelHertz() const
Parallel spring stiffness in Hertz.
Definition Joint3D.cpp:442

eve::physics::Joint3D::destroy
void destroy()
Destroys the backend joint and invalidates this wrapper.
Definition Joint3D.cpp:48

eve::physics::Joint3D::setForceThreshold
void setForceThreshold(float threshold)
Sets the force threshold that emits a joint-stress event, in newtons.
Definition Joint3D.cpp:80

eve::physics::Joint3D::getDistanceLength
float getDistanceLength() const
Distance-joint rest length in metres.
Definition Joint3D.cpp:124

eve::physics::Joint3D::setWheelSteering
void setWheelSteering(bool enabled, float targetAngle, float hertz, float dampingRatio, float maxTorque)
Configures steering target, stiffness, damping and maximum torque.
Definition Joint3D.cpp:299

eve::physics::Joint3D::setMotorVelocityLimits
void setMotorVelocityLimits(float maxForce, float maxTorque)
Sets motor velocity force/torque limits.
Definition Joint3D.cpp:383

eve::physics::Joint3D::setWheelSpinMotor
void setWheelSpinMotor(bool enabled, float speed, float maxTorque)
Configures wheel spin motor speed and maximum torque.
Definition Joint3D.cpp:291

eve::physics::Joint3D::setSphericalTwistLimits
void setSphericalTwistLimits(bool enabled, float lower, float upper)
Enables spherical twist limits in radians.
Definition Joint3D.cpp:244

eve::physics::Joint3D::getTorqueThreshold
float getTorqueThreshold() const
Current torque event threshold in newton-metres.
Definition Joint3D.cpp:93

eve::physics::Joint3D::getParallelMaxTorque
float getParallelMaxTorque() const
Parallel maximum spring torque in newton-metres.
Definition Joint3D.cpp:450

eve::physics::Joint3D::getWheelSpinTorque
float getWheelSpinTorque() const
Current wheel spin motor torque in newton-metres.
Definition Joint3D.cpp:325

eve::physics::Joint3D::setRevoluteLimits
void setRevoluteLimits(bool enabled, float lower, float upper)
Configures revolute angular limits in radians.
Definition Joint3D.cpp:169

eve::physics::Joint3D::setDistanceMotor
void setDistanceMotor(bool enabled, float speed, float maxForce)
Configures the distance motor in metres/second and newtons.
Definition Joint3D.cpp:149

eve::physics::Joint3D::getRevoluteMotorTorque
float getRevoluteMotorTorque() const
Current revolute motor torque in newton-metres.
Definition Joint3D.cpp:190

eve::physics::Joint3D::setMotorAngularVelocity
void setMotorAngularVelocity(float wx, float wy, float wz)
Sets motor-joint relative angular velocity in radians/second.
Definition Joint3D.cpp:376

eve::physics::Joint3D::getForceThreshold
float getForceThreshold() const
Current force event threshold in newtons.
Definition Joint3D.cpp:85

eve::physics::Joint3D::getParallelDampingRatio
float getParallelDampingRatio() const
Parallel spring damping ratio.
Definition Joint3D.cpp:446

eve::physics::Joint3D::setSphericalMotor
void setSphericalMotor(bool enabled, float velocityX, float velocityY, float velocityZ, float maxTorque)
Configures spherical motor velocity and maximum torque.
Definition Joint3D.cpp:254

eve::physics::Joint3D::getWeldAngularHertz
float getWeldAngularHertz() const
Weld angular stiffness in Hertz.
Definition Joint3D.cpp:360

eve::physics::Joint3D::getWeldLinearDampingRatio
float getWeldLinearDampingRatio() const
Weld linear damping ratio.
Definition Joint3D.cpp:356

eve::physics::Joint3D::setTorqueThreshold
void setTorqueThreshold(float threshold)
Sets the torque threshold that emits a joint-stress event, in newton-metres.
Definition Joint3D.cpp:88

eve::physics::Joint3D::setWeldLinearSpring
void setWeldLinearSpring(float hertz, float dampingRatio)
Configures weld linear spring stiffness and damping; 0 hertz is rigid.
Definition Joint3D.cpp:338

eve::physics::Joint3D::getDistanceCurrentLength
float getDistanceCurrentLength() const
Current anchor-to-anchor distance in metres.
Definition Joint3D.cpp:128

eve::physics::Joint3D::getPrismaticTranslation
float getPrismaticTranslation() const
Current prismatic translation in metres.
Definition Joint3D.cpp:223

eve::physics::Joint3D::getRevoluteAngle
float getRevoluteAngle() const
Current revolute angle in radians.
Definition Joint3D.cpp:186

eve::physics::Joint3D::setDistanceLimits
void setDistanceLimits(bool enabled, float minimum, float maximum)
Configures optional distance limits in metres.
Definition Joint3D.cpp:140

eve::physics::Joint3D::getConstraintTorqueZ
float getConstraintTorqueZ() const
Current world-space constraint torque Z in newton-metres.

eve::physics::Joint3D::getWheelSpinSpeed
float getWheelSpinSpeed() const
Current wheel spin speed in radians/second.
Definition Joint3D.cpp:321

eve::physics::Joint3D::getId
int getId() const
Stable world-local identifier.
Definition Joint3D.h:35

eve::physics::Joint3D::setWheelSteeringLimits
void setWheelSteeringLimits(bool enabled, float lower, float upper)
Configures steering angular limits in radians.
Definition Joint3D.cpp:312

eve::physics::Joint3D::getPrismaticMotorForce
float getPrismaticMotorForce() const
Current prismatic motor force in newtons.
Definition Joint3D.cpp:231

eve::physics::Joint3D::setRevoluteSpring
void setRevoluteSpring(bool enabled, float targetAngle, float hertz, float dampingRatio)
Configures a revolute angular spring in radians.
Definition Joint3D.cpp:158

eve::physics::Joint3D::setPrismaticLimits
void setPrismaticLimits(bool enabled, float lower, float upper)
Configures prismatic translation limits in metres.
Definition Joint3D.cpp:206

eve::physics::Joint3D::getKind
std::string getKind() const
Joint kind string for script/debug ("distance", "revolute", …, "filter").
Definition Joint3D.cpp:54

eve::physics::Joint3D::getMotorLinearVelocityX
float getMotorLinearVelocityX() const
Desired motor linear velocity X in metres/second.
Definition Joint3D.cpp:408

eve::physics::Joint3D::setParallelSpring
void setParallelSpring(float hertz, float dampingRatio, float maxTorque)
Configures parallel-joint spring stiffness, damping and torque cap.
Definition Joint3D.cpp:433

eve::physics::Joint3D::setMotorLinearVelocity
void setMotorLinearVelocity(float vx, float vy, float vz)
Sets motor-joint relative linear velocity in metres/second.
Definition Joint3D.cpp:369

eve::physics::Joint3D::getMotorAngularVelocityY
float getMotorAngularVelocityY() const
Desired motor angular velocity Y in radians/second.
Definition Joint3D.cpp:424

eve::physics::Joint3D::getLinearSeparation
float getLinearSeparation() const
Current inadmissible linear separation error in metres.
Definition Joint3D.cpp:107

eve::physics::Joint3D::getMotorAngularVelocityX
float getMotorAngularVelocityX() const
Desired motor angular velocity X in radians/second.
Definition Joint3D.cpp:420

eve::physics::Joint3D::getWheelSteeringTorque
float getWheelSteeringTorque() const
Current steering torque in newton-metres.
Definition Joint3D.cpp:333

eve::physics::Joint3D::getMotorAngularVelocityZ
float getMotorAngularVelocityZ() const
Desired motor angular velocity Z in radians/second.
Definition Joint3D.cpp:428

eve::physics::Joint3D::getWeldLinearHertz
float getWeldLinearHertz() const
Weld linear stiffness in Hertz.
Definition Joint3D.cpp:352

eve::physics::Joint3D::getWeldAngularDampingRatio
float getWeldAngularDampingRatio() const
Weld angular damping ratio.
Definition Joint3D.cpp:364

eve::physics::Joint3D::getConstraintTorqueX
float getConstraintTorqueX() const
Current world-space constraint torque X in newton-metres.

eve::physics::Joint3D::getConstraintForceZ
float getConstraintForceZ() const
Current world-space constraint force Z in newtons.

eve::physics::Joint3D::getMotorLinearVelocityY
float getMotorLinearVelocityY() const
Desired motor linear velocity Y in metres/second.
Definition Joint3D.cpp:412

eve::physics::Joint3D::getAngularSeparation
float getAngularSeparation() const
Current inadmissible angular separation error in radians.
Definition Joint3D.cpp:110

eve::physics::Joint3D::getMotorLinearVelocityZ
float getMotorLinearVelocityZ() const
Desired motor linear velocity Z in metres/second.
Definition Joint3D.cpp:416

eve::physics::Joint3D::getWheelSteeringAngle
float getWheelSteeringAngle() const
Current wheel steering angle in radians.
Definition Joint3D.cpp:329

eve::physics::Joint3D::setDistanceSpring
void setDistanceSpring(bool enabled, float hertz, float dampingRatio)
Configures a distance spring; hertz and damping must be non-negative.
Definition Joint3D.cpp:132

eve::physics::Joint3D::setRevoluteMotor
void setRevoluteMotor(bool enabled, float speed, float maxTorque)
Configures the revolute motor in radians/second and newton-metres.
Definition Joint3D.cpp:178

eve::physics::Joint3D::getBodyAId
int getBodyAId() const
Stable ID of attached body A, or -1 after invalidation.
Definition Joint3D.cpp:69

eve::physics::Joint3D::setWheelSuspensionLimits
void setWheelSuspensionLimits(bool enabled, float lower, float upper)
Configures wheel suspension travel limits in metres.
Definition Joint3D.cpp:282

eve::physics::Joint3D::getPrismaticSpeed
float getPrismaticSpeed() const
Current prismatic translation speed in metres/second.
Definition Joint3D.cpp:227

eve::physics::Joint3D::getCollideConnected
bool getCollideConnected() const
Whether attached bodies may collide.
Definition Joint3D.cpp:76

eve::physics::Joint3D::setMotorAngularSpring
void setMotorAngularSpring(float hertz, float dampingRatio, float maxTorque)
Configures motor angular position spring.
Definition Joint3D.cpp:399

eve::physics::Joint3D::getSphericalConeAngle
float getSphericalConeAngle() const
Current spherical cone angle in radians.
Definition Joint3D.cpp:265

eve::physics::Joint3D::setPrismaticMotor
void setPrismaticMotor(bool enabled, float speed, float maxForce)
Configures a prismatic motor in metres/second and newtons.
Definition Joint3D.cpp:215

eve::physics::Joint3D::setSphericalConeLimit
void setSphericalConeLimit(bool enabled, float angle)
Enables a spherical cone limit in radians, within [0, pi].
Definition Joint3D.cpp:236

eve::physics::Joint3D::setWeldAngularSpring
void setWeldAngularSpring(float hertz, float dampingRatio)
Configures weld angular spring stiffness and damping; 0 hertz is rigid.
Definition Joint3D.cpp:345

eve::physics::Joint3D::getBodyBId
int getBodyBId() const
Stable ID of attached body B, or -1 after invalidation.
Definition Joint3D.cpp:70

eve::physics::Joint3D::setWheelSuspension
void setWheelSuspension(bool enabled, float hertz, float dampingRatio)
Configures wheel suspension spring stiffness and damping.
Definition Joint3D.cpp:274

eve::physics::Joint3D::setPrismaticSpring
void setPrismaticSpring(bool enabled, float targetTranslation, float hertz, float dampingRatio)
Configures a prismatic linear spring and target translation.
Definition Joint3D.cpp:195

eve::physics::Joint3D::getConstraintTorqueY
float getConstraintTorqueY() const
Current world-space constraint torque Y in newton-metres.

eve::physics::Joint3D::getSphericalTwistAngle
float getSphericalTwistAngle() const
Current spherical twist angle in radians.
Definition Joint3D.cpp:269

eve::physics::Joint3D::setCollideConnected
void setCollideConnected(bool collide)
Enables or disables collision between the attached bodies.
Definition Joint3D.cpp:72

eve::physics::Joint3D::setMotorLinearSpring
void setMotorLinearSpring(float hertz, float dampingRatio, float maxForce)
Configures motor linear position spring.
Definition Joint3D.cpp:390

eve::physics::Mechanism2D::getSliderJoint
Joint2D * getSliderJoint() const
Frame-to-slider prismatic, or null for shaft/ratchet.
Definition Mechanism2D.h:74

eve::physics::Mechanism2D::getRatchetEngagementTorque
float getRatchetEngagementTorque() const
Current ratchet engagement torque in newton-metres.
Definition Mechanism2D.h:101

eve::physics::Mechanism2D::setRatchetDirection
void setRatchetDirection(int direction)
Sets ratchet freewheel direction (+1 or -1).
Definition Mechanism2D.cpp:89

eve::physics::Mechanism2D::getKind
std::string getKind() const
Kind name: "crankSlider", "shaft", or "ratchet".
Definition Mechanism2D.cpp:27

eve::physics::Mechanism2D::getSpinSpeed
float getSpinSpeed() const
Relative spin speed in radians/second.
Definition Mechanism2D.cpp:65

eve::physics::Mechanism2D::getDriveAngle
float getDriveAngle() const
Current drive revolute angle in radians.
Definition Mechanism2D.cpp:50

eve::physics::Mechanism2D::clearDrive
void clearDrive()
Disables the continuous drive motor.
Definition Mechanism2D.cpp:81

eve::physics::Mechanism2D::getRatchetDirection
int getRatchetDirection() const
Current ratchet freewheel direction (+1 or -1).
Definition Mechanism2D.h:97

eve::physics::Mechanism2D::setRatchetEngagementTorque
void setRatchetEngagementTorque(float torque)
Sets reverse-lock torque for ratchet engagement.
Definition Mechanism2D.cpp:96

eve::physics::Mechanism2D::getDriveJoint
Joint2D * getDriveJoint() const
Primary revolute (crank / shaft / ratchet wheel).
Definition Mechanism2D.h:53

eve::physics::Mechanism2D::getId
int getId() const
Stable world-local identifier.
Definition Mechanism2D.h:34

eve::physics::Mechanism2D::getSliderTranslation
float getSliderTranslation() const
Current slider translation in pixels (crank-slider only).
Definition Mechanism2D.cpp:55

eve::physics::Mechanism2D::getCrankPinJoint
Joint2D * getCrankPinJoint() const
Crank-to-rod revolute, or null for shaft/ratchet.
Definition Mechanism2D.h:60

eve::physics::Mechanism2D::setDrive
void setDrive(float speed, float maxTorque)
Enables a continuous drive motor on the primary revolute.
Definition Mechanism2D.cpp:70

eve::physics::Mechanism2D::isValid
bool isValid() const
Whether the assembly and its primary joints are still live.
Definition Mechanism2D.cpp:36

eve::physics::Mechanism2D::getSliderPinJoint
Joint2D * getSliderPinJoint() const
Rod-to-slider revolute, or null for shaft/ratchet.
Definition Mechanism2D.h:67

eve::physics::Mechanism2D::destroy
void destroy()
Destroys owned joints and invalidates this wrapper.
Definition Mechanism2D.cpp:128

eve::physics::Mechanism2D::isDriveEnabled
bool isDriveEnabled() const
Whether a continuous drive motor is configured.
Definition Mechanism2D.h:92

eve::physics::Mechanism3D::getCrankPinJoint
Joint3D * getCrankPinJoint() const
Crank-to-rod revolute, or null for shaft/ratchet.
Definition Mechanism3D.h:55

eve::physics::Mechanism3D::getSliderTranslation
float getSliderTranslation() const
Current slider translation in metres (crank-slider only).
Definition Mechanism3D.cpp:58

eve::physics::Mechanism3D::setRatchetEngagementTorque
void setRatchetEngagementTorque(float torque)
Sets reverse-lock torque for ratchet engagement.
Definition Mechanism3D.cpp:109

eve::physics::Mechanism3D::destroy
void destroy()
Destroys owned joints and invalidates this wrapper.
Definition Mechanism3D.cpp:141

eve::physics::Mechanism3D::setRatchetDirection
void setRatchetDirection(int direction)
Sets ratchet freewheel direction.
Definition Mechanism3D.cpp:102

eve::physics::Mechanism3D::getDriveAngle
float getDriveAngle() const
Current drive revolute angle in radians (shaft/crank/ratchet).
Definition Mechanism3D.cpp:53

eve::physics::Mechanism3D::setDrive
void setDrive(float speed, float maxTorque)
Enables a continuous drive motor on the primary revolute.
Definition Mechanism3D.cpp:79

eve::physics::Mechanism3D::getSliderPinJoint
Joint3D * getSliderPinJoint() const
Rod-to-slider revolute, or null for shaft/ratchet.
Definition Mechanism3D.h:62

eve::physics::Mechanism3D::getId
int getId() const
Stable world-local identifier.
Definition Mechanism3D.h:34

eve::physics::Mechanism3D::isValid
bool isValid() const
Whether the assembly and its primary joints are still live.
Definition Mechanism3D.cpp:39

eve::physics::Mechanism3D::getRatchetDirection
int getRatchetDirection() const
Current ratchet freewheel direction (+1 or -1).
Definition Mechanism3D.h:96

eve::physics::Mechanism3D::getKind
std::string getKind() const
Kind name: "crankSlider", "shaft", or "ratchet".
Definition Mechanism3D.cpp:30

eve::physics::Mechanism3D::getRatchetEngagementTorque
float getRatchetEngagementTorque() const
Current ratchet engagement torque in newton-metres.
Definition Mechanism3D.h:103

eve::physics::Mechanism3D::isDriveEnabled
bool isDriveEnabled() const
Whether a continuous drive motor is configured.
Definition Mechanism3D.h:88

eve::physics::Mechanism3D::clearDrive
void clearDrive()
Disables the continuous drive motor.
Definition Mechanism3D.cpp:92

eve::physics::Mechanism3D::getDriveJoint
Joint3D * getDriveJoint() const
Primary revolute (crank / shaft / ratchet wheel).
Definition Mechanism3D.h:48

eve::physics::Mechanism3D::getSliderJoint
Joint3D * getSliderJoint() const
Frame-to-slider prismatic, or null for shaft/ratchet.
Definition Mechanism3D.h:69

eve::physics::Mechanism3D::getSpinSpeed
float getSpinSpeed() const
Relative spin speed along the drive axis in radians/second.
Definition Mechanism3D.cpp:74

eve::physics::Physics
Physics module — Box2D (2D) + Box3D (3D) rigid bodies and SPH fluid. Script: physics <- eve....
Definition Physics.h:22

eve::physics::Physics::newDistanceField3D
DistanceField3D * newDistanceField3D(int width, int height, int depth, float cellSize, float originX=0.f, float originY=0.f, float originZ=0.f, float outsideDistance=1e6f)
Create a regular 3D signed-distance grid for map collision queries.
Definition Physics.cpp:49

eve::physics::Physics::newWorld3D
World3D * newWorld3D(float gravityX, float gravityY, float gravityZ, bool sleep=true)
Create a 3D Box3D physics world. Coordinates are meters (Box3D native); +Y is up by convention.
Definition Physics.cpp:45

eve::physics::Physics::setMeter
void setMeter(float pixelsPerMeter)
Pixels per meter for 2D Box2D worlds (default 30, same as LÖVE).
Definition Physics.cpp:33

eve::physics::Physics::Physics
Physics()
Physics.
Definition Physics.cpp:29

eve::physics::Physics::newSoftBody3DRenderer
SoftBody3DRenderer * newSoftBody3DRenderer(SoftBody3D *body)
Create a presentation satellite observing a soft-body runtime.
Definition Physics.cpp:63

eve::physics::Physics::newFluid2D
Fluid2D * newFluid2D(int capacity=512)
Creates an interactive 2D particle fluid in pixel space.
Definition Physics.cpp:67

eve::physics::Physics::getMeter
float getMeter() const
Returns the meter.
Definition Physics.cpp:39

eve::physics::Physics::newWorld
World * newWorld(float gravityX, float gravityY, bool sleep=true)
Create a 2D Box2D physics world.
Definition Physics.cpp:41

eve::physics::Physics::newSoftBody3D
SoftBody3D * newSoftBody3D(int cols, int rows, int layers, float spacing, float originX, float originY, float originZ)
Compatibility factory for a volumetric shape-matching soft body.
Definition Physics.cpp:56

eve::physics::Shape3D::getId
int getId() const
Stable world-local id, preserved when sensor state recreates the backend shape.
Definition Shape3D.h:44

eve::physics::Shape3D::getHeightFieldCellSizeZ
float getHeightFieldCellSizeZ() const
Height-field cell spacing along local Z, or zero.
Definition Shape3D.h:149

eve::physics::Shape3D::setLocalPosition
void setLocalPosition(float x, float y, float z)
Sets local translation while preserving local rotation.
Definition Shape3D.cpp:764

eve::physics::Shape3D::setDensity
void setDensity(float density)
Definition Shape3D.cpp:882

eve::physics::Shape3D::setTag
void setTag(int tag)
User-defined integer tag preserved for the wrapper lifetime.
Definition Shape3D.cpp:383

eve::physics::Shape3D::setBoxSize
void setBoxSize(float width, float height, float depth)
Atomically changes full box dimensions in meters.
Definition Shape3D.cpp:469

eve::physics::Shape3D::getHeightFieldCountZ
int getHeightFieldCountZ() const
Height-field sample count along local Z, or zero.
Definition Shape3D.h:143

eve::physics::Shape3D::getTriangleMeshMaterialRestitution
float getTriangleMeshMaterialRestitution(int slot) const
Restitution of a triangle-mesh material slot.
Definition Shape3D.cpp:659

eve::physics::Shape3D::getTriangleMeshMaterialId
int getTriangleMeshMaterialId(int slot) const
Application material ID of a triangle-mesh material slot.
Definition Shape3D.cpp:673

eve::physics::Shape3D::setOneWay
void setOneWay(float nx, float ny, float nz, float planeOffset, float margin, float minNormalDot)
Enables a one-way collision plane in shape-local space.
Definition Shape3D.cpp:398

eve::physics::Shape3D::getLocalZ
float getLocalZ() const
Local translation Z in meters.
Definition Shape3D.h:209

eve::physics::Shape3D::getTriangleMeshVertexCount
int getTriangleMeshVertexCount() const
Source vertex count for a triangle mesh, or zero.
Definition Shape3D.h:94

eve::physics::Shape3D::getKind
std::string getKind() const
Kind name including primitives, "convexHull", "triangleMesh", or "heightField".
Definition Shape3D.cpp:457

eve::physics::Shape3D::testPoint
bool testPoint(float x, float y, float z) const
Point-in-shape test in world meters.
Definition Shape3D.cpp:932

eve::physics::Shape3D::setHitEventsEnabled
void setHitEventsEnabled(bool enabled)
Enables significant collision hit events for this shape.
Definition Shape3D.cpp:388

eve::physics::Shape3D::setMaterialId
void setMaterialId(int id)
Sets a low-32-bit application material identifier exposed by native queries.
Definition Shape3D.cpp:829

eve::physics::Shape3D::getTriangleMeshMaterialIndex
int getTriangleMeshMaterialIndex(int triangleIndex) const
Material-slot index assigned to a source triangle.
Definition Shape3D.cpp:608

eve::physics::Shape3D::getLocalRotX
float getLocalRotX() const
Normalized local quaternion X.
Definition Shape3D.h:211

eve::physics::Shape3D::getTag
int getTag() const
User-defined integer tag, zero by default.
Definition Shape3D.h:50

eve::physics::Shape3D::setTriangleMeshMaterial
void setTriangleMeshMaterial(int slot, float friction, float restitution, float rollingResistance, float tangentX, float tangentY, float tangentZ, int materialId, const std::string &frictionMode, const std::string &restitutionMode)
Replaces one triangle-mesh material slot without rebuilding geometry.
Definition Shape3D.cpp:622

eve::physics::Shape3D::getHeightFieldHeight
float getHeightFieldHeight(int x, int z) const
Source height at a grid sample.
Definition Shape3D.cpp:719

eve::physics::Shape3D::getTriangleMeshMaterialCount
int getTriangleMeshMaterialCount() const
Number of material slots on a triangle mesh, otherwise zero.
Definition Shape3D.cpp:618

eve::physics::Shape3D::getTangentVelocityY
float getTangentVelocityY() const
Local-space conveyor velocity Y component.
Definition Shape3D.cpp:821

eve::physics::Shape3D::getTriangleMeshMaterialRollingResistance
float getTriangleMeshMaterialRollingResistance(int slot) const
Rolling resistance of a triangle-mesh material slot.
Definition Shape3D.cpp:665

eve::physics::Shape3D::isSensor
bool isSensor() const
Definition Shape3D.cpp:772

eve::physics::Shape3D::setRestitution
void setRestitution(float restitution)
Definition Shape3D.cpp:783

eve::physics::Shape3D::getLocalY
float getLocalY() const
Local translation Y in meters.
Definition Shape3D.h:207

eve::physics::Shape3D::setSphereRadius
void setSphereRadius(float radius)
Atomically changes sphere radius in meters.
Definition Shape3D.cpp:488

eve::physics::Shape3D::getBoxHeight
float getBoxHeight() const
Full box height, or zero for another geometry kind.
Definition Shape3D.h:163

eve::physics::Shape3D::getLocalX
float getLocalX() const
Local translation X in meters.
Definition Shape3D.h:205

eve::physics::Shape3D::isOneWay
bool isOneWay() const
Whether one-way pre-solve filtering is requested.
Definition Shape3D.h:187

eve::physics::Shape3D::setLocalTransform
void setLocalTransform(float px, float py, float pz, float qx, float qy, float qz, float qw)
Atomically sets the shape transform relative to its Body3D.
Definition Shape3D.cpp:728

eve::physics::Shape3D::setGroupIndex
void setGroupIndex(int index)
Collision group; negative never collides, positive always collides.
Definition Shape3D.cpp:921

eve::physics::Shape3D::getTriangleMeshMaterialFriction
float getTriangleMeshMaterialFriction(int slot) const
Friction of a triangle-mesh material slot.
Definition Shape3D.cpp:653

eve::physics::Shape3D::getBoxWidth
float getBoxWidth() const
Full box width, or zero for another geometry kind.
Definition Shape3D.h:161

eve::physics::Shape3D::getHeightFieldGlobalMin
float getHeightFieldGlobalMin() const
Height-field shared quantization minimum, or zero.
Definition Shape3D.h:153

eve::physics::Shape3D::getFriction
float getFriction() const
Definition Shape3D.cpp:781

eve::physics::Shape3D::getRestitution
float getRestitution() const
Definition Shape3D.cpp:790

eve::physics::Shape3D::setFrictionCombineMode
void setFrictionCombineMode(const std::string &mode)
Sets friction combine mode: default, average, minimum, multiply, or maximum.
Definition Shape3D.cpp:837

eve::physics::Shape3D::destroy
void destroy()
Destroys the shape inside its world.
Definition Shape3D.cpp:240

eve::physics::Shape3D::setLocalRotation
void setLocalRotation(float qx, float qy, float qz, float qw)
Sets local rotation while preserving local translation.
Definition Shape3D.cpp:768

eve::physics::Shape3D::getLocalRotW
float getLocalRotW() const
Normalized local quaternion scalar component.
Definition Shape3D.h:217

eve::physics::Shape3D::setTangentVelocity
void setTangentVelocity(float x, float y, float z)
Sets local-space conveyor velocity projected onto contact surfaces.
Definition Shape3D.cpp:808

eve::physics::Shape3D::getExplosionScale
float getExplosionScale() const
Current explosion impulse multiplier; zero opts this shape out.
Definition Shape3D.h:249

eve::physics::Shape3D::getMaterialId
int getMaterialId() const
Low-32-bit application material identifier.
Definition Shape3D.cpp:867

eve::physics::Shape3D::getCapsuleHeight
float getCapsuleHeight() const
Capsule hemisphere-center distance, or zero for another kind.
Definition Shape3D.h:171

eve::physics::Shape3D::getBoxDepth
float getBoxDepth() const
Full box depth, or zero for another geometry kind.
Definition Shape3D.h:165

eve::physics::Shape3D::getHeightFieldCountX
int getHeightFieldCountX() const
Height-field sample count along local X, or zero.
Definition Shape3D.h:141

eve::physics::Shape3D::setCapsuleSize
void setCapsuleSize(float height, float radius)
Atomically changes capsule segment height and radius in meters.
Definition Shape3D.cpp:501

eve::physics::Shape3D::getHeightFieldCellSizeX
float getHeightFieldCellSizeX() const
Height-field cell spacing along local X, or zero.
Definition Shape3D.h:145

eve::physics::Shape3D::getDensity
float getDensity() const
Definition Shape3D.cpp:889

eve::physics::Shape3D::getGroupIndex
int getGroupIndex() const
Definition Shape3D.cpp:928

eve::physics::Shape3D::getLocalRotZ
float getLocalRotZ() const
Normalized local quaternion Z.
Definition Shape3D.h:215

eve::physics::Shape3D::getHeightFieldGlobalMax
float getHeightFieldGlobalMax() const
Height-field shared quantization maximum, or zero.
Definition Shape3D.h:157

eve::physics::Shape3D::setRestitutionCombineMode
void setRestitutionCombineMode(const std::string &mode)
Sets restitution combine mode: default, average, minimum, multiply, or maximum.
Definition Shape3D.cpp:852

eve::physics::Shape3D::getTangentVelocityZ
float getTangentVelocityZ() const
Local-space conveyor velocity Z component.
Definition Shape3D.cpp:825

eve::physics::Shape3D::getTriangleMeshTriangleCount
int getTriangleMeshTriangleCount() const
Source triangle count for a triangle mesh, or zero.
Definition Shape3D.h:98

eve::physics::Shape3D::getRestitutionCombineMode
std::string getRestitutionCombineMode() const
Current restitution combine mode.
Definition Shape3D.cpp:861

eve::physics::Shape3D::setRollingResistance
void setRollingResistance(float resistance)
Rolling resistance coefficient, finite and non-negative.
Definition Shape3D.cpp:794

eve::physics::Shape3D::disableOneWay
void disableOneWay()
Disables one-way filtering and restores ordinary two-sided collision.
Definition Shape3D.cpp:422

eve::physics::Shape3D::setSensor
void setSensor(bool sensor)
Sensor shapes report contacts but never collide.
Definition Shape3D.cpp:371

eve::physics::Shape3D::getConvexHullPointCount
int getConvexHullPointCount() const
Source point count for a convex hull, or zero for another kind.
Definition Shape3D.h:78

eve::physics::Shape3D::getLocalRotY
float getLocalRotY() const
Normalized local quaternion Y.
Definition Shape3D.h:213

eve::physics::Shape3D::getFrictionCombineMode
std::string getFrictionCombineMode() const
Current friction combine mode.
Definition Shape3D.cpp:846

eve::physics::Shape3D::areHitEventsEnabled
bool areHitEventsEnabled() const
Whether significant collision hit events are enabled.
Definition Shape3D.cpp:394

eve::physics::Shape3D::setFriction
void setFriction(float friction)
Material properties.
Definition Shape3D.cpp:774

eve::physics::Shape3D::setExplosionScale
void setExplosionScale(float scale)
Sets non-negative multiplier applied to geometry-aware explosion impulses.
Definition Shape3D.cpp:874

eve::physics::Shape3D::getRadius
float getRadius() const
Sphere/capsule radius, or zero for a box.
Definition Shape3D.h:167

eve::physics::Shape3D::getConvexHullMaxVertices
int getConvexHullMaxVertices() const
Current convex-hull simplification budget, or zero for another kind.
Definition Shape3D.h:82

eve::physics::Shape3D::getTangentVelocityX
float getTangentVelocityX() const
Local-space conveyor velocity X component.
Definition Shape3D.cpp:817

eve::physics::Shape3D::getRollingResistance
float getRollingResistance() const
Current rolling resistance; physically affects spheres and capsules.
Definition Shape3D.cpp:804

eve::physics::SoftBody3DRenderer
Presentation-only renderer for a borrowed volumetric soft body.
Definition SoftBody3DRenderer.h:21

eve::physics::SoftBody3DRenderer::draw
void draw(graphics::Graphics *graphics)
Update the surface cache and draw it in the current 3D frame.
Definition SoftBody3DGraphics.cpp:29

eve::physics::SoftBody3DRenderer::setBody
void setBody(SoftBody3D *body)
Replace the borrowed runtime; null disables drawing.
Definition SoftBody3DGraphics.cpp:15

eve::physics::SoftBody3DRenderer::setColor
void setColor(float r, float g, float b, float a)
Set the clamped RGBA presentation color.
Definition SoftBody3DGraphics.cpp:22

eve::physics::SoftBody3D
Volumetric particle soft body using overlapping shape-matching clusters.
Definition SoftBody3D.h:27

eve::physics::SoftBody3D::getCollideWorld
World3D * getCollideWorld() const
Returns the collide world.
Definition SoftBody3DWorldBridge.cpp:75

eve::physics::SoftBody3D::getParticleCount
int getParticleCount() const
Definition SoftBody3D.h:174

eve::physics::SoftBody3D::applyForce
void applyForce(float x, float y, float z)
Applies force.
Definition SoftBody3D.cpp:205

eve::physics::SoftBody3D::pin
void pin(int index)
Pin.
Definition SoftBody3D.cpp:162

eve::physics::SoftBody3D::setParticleMass
void setParticleMass(float value)
Sets the particle mass.
Definition SoftBody3D.cpp:134

eve::physics::SoftBody3D::getGravityY
float getGravityY() const
Returns the gravity y.
Definition SoftBody3D.h:81

eve::physics::SoftBody3D::getParticleMass
float getParticleMass() const
Returns the particle mass.
Definition SoftBody3D.h:103

eve::physics::SoftBody3D::releaseGrab
void releaseGrab()
Release grab.
Definition SoftBody3D.h:134

eve::physics::SoftBody3D::update
void update(float dt)
Advances using a legacy variable timestep clamped to 50 ms.
Definition SoftBody3D.cpp:406

eve::physics::SoftBody3D::getGravityZ
float getGravityZ() const
Returns the gravity z.
Definition SoftBody3D.h:83

eve::physics::SoftBody3D::setBounds
void setBounds(float x, float y, float z, float width, float height, float depth)
Sets the bounds.
Definition SoftBody3D.cpp:151

eve::physics::SoftBody3D::getParticleZ
float getParticleZ(int index) const
Definition SoftBody3D.cpp:228

eve::physics::SoftBody3D::setIterations
void setIterations(int value)
Sets the iterations.
Definition SoftBody3D.cpp:128

eve::physics::SoftBody3D::getSelfCollision
bool getSelfCollision() const
Returns the self collision.
Definition SoftBody3D.h:117

eve::physics::SoftBody3D::setDeformationResistance
void setDeformationResistance(float value)
Sets the deformation resistance.
Definition SoftBody3D.cpp:124

eve::physics::SoftBody3D::setCollideWorld
void setCollideWorld(World3D *world)
Borrows a rigid-body world used for particle contacts.
Definition SoftBody3DWorldBridge.cpp:69

eve::physics::SoftBody3D::getPlasticCreep
float getPlasticCreep() const
Returns the plastic creep.
Definition SoftBody3D.cpp:146

eve::physics::SoftBody3D::getMaxDeformation
float getMaxDeformation() const
Returns the max deformation.
Definition SoftBody3D.cpp:148

eve::physics::SoftBody3D::getVolumeRatio
float getVolumeRatio() const
Returns current cell volume divided by undeformed rest volume.
Definition SoftBody3D.cpp:453

eve::physics::SoftBody3D::getPlasticYield
float getPlasticYield() const
Returns the plastic yield.
Definition SoftBody3D.cpp:145

eve::physics::SoftBody3D::moveGrab
void moveGrab(float x, float y, float z)
Moves grab.
Definition SoftBody3D.cpp:194

eve::physics::SoftBody3D::getIterations
int getIterations() const
Returns the iterations.
Definition SoftBody3D.h:91

eve::physics::SoftBody3D::getLayers
int getLayers() const
Definition SoftBody3D.cpp:149

eve::physics::SoftBody3D::setGravity
void setGravity(float x, float y, float z)
Sets the gravity.
Definition SoftBody3D.cpp:118

eve::physics::SoftBody3D::setPlasticity
void setPlasticity(float yield, float creep, float recovery, float maxDeformation)
Sets the plasticity.
Definition SoftBody3D.cpp:138

eve::physics::SoftBody3D::setParticlePosition
void setParticlePosition(int index, float x, float y, float z)
Definition SoftBody3D.cpp:232

eve::physics::SoftBody3D::getDeformationResistance
float getDeformationResistance() const
Returns the deformation resistance.
Definition SoftBody3D.cpp:126

eve::physics::SoftBody3D::create
static eve::Result< std::unique_ptr< SoftBody3D > > create(const SoftBody3DDefinition &definition)
Creates a soft body from the canonical versioned definition.
Definition SoftBody3D.cpp:52

eve::physics::SoftBody3D::interactAt
void interactAt(float x, float y, float z, float radius, float strength)
Interact at.
Definition SoftBody3D.cpp:211

eve::physics::SoftBody3D::isGrabbing
bool isGrabbing() const
True when grabbing.
Definition SoftBody3D.h:136

eve::physics::SoftBody3D::getGrabIndex
int getGrabIndex() const
Returns the grab index.
Definition SoftBody3D.h:138

eve::physics::SoftBody3D::reset
void reset()
Resets .
Definition SoftBody3D.cpp:242

eve::physics::SoftBody3D::getDamping
float getDamping() const
Returns the damping.
Definition SoftBody3D.h:95

eve::physics::SoftBody3D::getPlasticRecovery
float getPlasticRecovery() const
Returns the plastic recovery.
Definition SoftBody3D.cpp:147

eve::physics::SoftBody3D::setParticleRadius
void setParticleRadius(float value)
Sets the particle radius.
Definition SoftBody3D.cpp:130

eve::physics::SoftBody3D::clearBounds
void clearBounds()
Clears bounds.
Definition SoftBody3D.h:121

eve::physics::SoftBody3D::getRows
int getRows() const
Definition SoftBody3D.h:172

eve::physics::SoftBody3D::setDamping
void setDamping(float value)
Sets the damping.
Definition SoftBody3D.cpp:129

eve::physics::SoftBody3D::isPinned
bool isPinned(int index) const
True when pinned.
Definition SoftBody3D.cpp:170

eve::physics::SoftBody3D::getParticleX
float getParticleX(int index) const
Definition SoftBody3D.cpp:220

eve::physics::SoftBody3D::getParticleY
float getParticleY(int index) const
Definition SoftBody3D.cpp:224

eve::physics::SoftBody3D::grabAt
int grabAt(float x, float y, float z, float radius)
Grab at.
Definition SoftBody3D.cpp:175

eve::physics::SoftBody3D::unpin
void unpin(int index)
Unpin.
Definition SoftBody3D.cpp:166

eve::physics::SoftBody3D::getGravityX
float getGravityX() const
Returns the gravity x.
Definition SoftBody3D.h:79

eve::physics::SoftBody3D::getCols
int getCols() const
Definition SoftBody3D.h:171

eve::physics::SoftBody3D::destroy
void destroy()
Destroys .
Definition SoftBody3D.cpp:107

eve::physics::SoftBody3D::setSelfCollision
void setSelfCollision(bool enabled)
Sets the self collision.
Definition SoftBody3D.h:115

eve::physics::SoftBody3D::getParticleRadius
float getParticleRadius() const
Returns the particle radius.
Definition SoftBody3D.cpp:133

eve::physics::TerrainLoadGravityState
Caller-owned state for Pcg-style rigid-body activation after terrain loading.
Definition TerrainLoadGravity.h:11

eve::physics::TerrainLoadGravityState::isCompleted
bool isCompleted() const
Whether gravity restoration and the activation notification completed.
Definition TerrainLoadGravity.h:18

eve::physics::TerrainLoadGravityState::isMonitoring
bool isMonitoring() const
Whether a containing terrain was found and activation is being monitored.
Definition TerrainLoadGravity.h:14

eve::physics::TerrainLoadGravityState::isActivationScheduled
bool isActivationScheduled() const
Whether the post-load delay has been scheduled.
Definition TerrainLoadGravity.h:16

eve::physics::TerrainLoadGravityState::getDelayElapsed
float getDelayElapsed() const
Elapsed seconds since the first loaded observation.
Definition TerrainLoadGravity.h:20

eve::physics::World3D
Box3D rigid-body world. Script coordinates are meters (Box3D native), unlike 2D World which uses pixe...
Definition World3D.h:63

eve::physics::World3D::hasClosestPoint
bool hasClosestPoint() const
Whether the latest closestPoint call found a shape.
Definition World3D.h:655

eve::physics::World3D::getBeginTriggerVisitorShapeId
int getBeginTriggerVisitorShapeId(int index) const
Visitor shape ID of a begin-trigger event.

eve::physics::World3D::getProfileStepMs
float getProfileStepMs() const
Latest complete physics step time in milliseconds.

eve::physics::World3D::getRestitutionThreshold
float getRestitutionThreshold() const
Current restitution speed threshold in m/s.
Definition World3D.cpp:235

eve::physics::World3D::setGravity
void setGravity(float gx, float gy, float gz)
Gravity in m/s².
Definition World3D.cpp:775

eve::physics::World3D::getBeginContactShapeAId
int getBeginContactShapeAId(int index) const
Shape ID on stable side A of a begin-contact event.

eve::physics::World3D::getShapeCastX
float getShapeCastX() const
World-space contact point X from the last shape cast.
Definition World3D.h:690

eve::physics::World3D::getEndTriggerCount
int getEndTriggerCount() const
Number of sensor overlaps that ended during the latest step.
Definition World3D.h:828

eve::physics::World3D::getQueryBodyId
int getQueryBodyId(int index) const
Body id of the i-th query hit.
Definition World3D.cpp:2074

eve::physics::World3D::getJointStressForceY
float getJointStressForceY(int index) const
Constraint force Y of a stress event.

eve::physics::World3D::getClosestShapeId
int getClosestShapeId() const
Stable shape id from the latest closestPoint call, or -1.
Definition World3D.h:659

eve::physics::World3D::getContactPointTotalNormalImpulse
float getContactPointTotalNormalImpulse(int index) const
Total normal impulse accumulated across all physics substeps.

eve::physics::World3D::getRayHitTriangleIndex
int getRayHitTriangleIndex() const
Mesh/height-field triangle index from the last ray cast, otherwise -1.
Definition World3D.h:523

eve::physics::World3D::getHitNormalX
float getHitNormalX(int index) const
Hit normal X, pointing from stable side A to B.

eve::physics::World3D::getDynamicTreeHeight
int getDynamicTreeHeight() const
Dynamic broad-phase tree height.

eve::physics::World3D::castSphere
int castSphere(float x, float y, float z, float radius, float dx, float dy, float dz)
Sweep a sphere through the world and return the earliest hit body id, or -1.
Definition World3D.cpp:1788

eve::physics::World3D::hasRayHit
bool hasRayHit() const
Definition World3D.h:514

eve::physics::World3D::isWarmStartingEnabled
bool isWarmStartingEnabled() const
Whether constraint warm starting is enabled.
Definition World3D.cpp:276

eve::physics::World3D::getShapeCastResultShapeId
int getShapeCastResultShapeId(int index) const
Shape ID of a sorted Shape Cast result.

eve::physics::World3D::getMaximumLinearSpeed
float getMaximumLinearSpeed() const
Current world-wide maximum linear speed in m/s.
Definition World3D.cpp:268

eve::physics::World3D::getClosestY
float getClosestY() const
Closest surface point Y.
Definition World3D.h:665

eve::physics::World3D::getBeginTriggerSensorBodyId
int getBeginTriggerSensorBodyId(int index) const
Sensor body ID of a begin-trigger event.

eve::physics::World3D::getHitPointZ
float getHitPointZ(int index) const
World-space impact point Z.

eve::physics::World3D::getAwakeBodyCount
int getAwakeBodyCount() const
Number of awake bodies.
Definition World3D.cpp:388

eve::physics::World3D::newMotorJoint
Joint3D * newMotorJoint(Body3D *bodyA, Body3D *bodyB, bool collideConnected=false)
Creates a motor joint that drives relative linear/angular velocity between bodies.
Definition World3DJoints.cpp:61

eve::physics::World3D::getContactPushOutSpeed
float getContactPushOutSpeed() const
Current maximum contact push-out speed in m/s.
Definition World3D.h:222

eve::physics::World3D::queryCapsule
int queryCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius)
Query shapes overlapping an arbitrarily oriented capsule. The endpoints are the centers of its hemisp...
Definition World3D.cpp:1636

eve::physics::World3D::getContactPointNormalImpulse
float getContactPointNormalImpulse(int index) const
Normal impulse from the final physics substep.

eve::physics::World3D::getEndContactShapeBId
int getEndContactShapeBId(int index) const
Shape ID on stable side B of an end-contact event.

eve::physics::World3D::update
void update(float dt)
Steps the simulation by dt seconds (default substep count).
Definition World3D.cpp:726

eve::physics::World3D::closestPoint
int closestPoint(float x, float y, float z, float maxDistance)
Find the closest collision surface within maxDistance of a world point. Uses the current query catego...
Definition World3D.cpp:1838

eve::physics::World3D::getShapeCastResultFraction
float getShapeCastResultFraction(int index) const
Translation fraction in [0,1] of a Shape Cast result.

eve::physics::World3D::getClosestShapeTag
int getClosestShapeTag() const
User tag of the shape from the latest closestPoint call, or zero.
Definition World3D.h:661

eve::physics::World3D::getEndContactBodyAId
int getEndContactBodyAId(int index) const
Body ID on stable side A of an end-contact event.

eve::physics::World3D::getEndContactShapeATag
int getEndContactShapeATag(int index) const
Shape Tag on stable side A of an end-contact event.

eve::physics::World3D::getJointCount
int getJointCount() const
Current backend joint count.

eve::physics::World3D::getShapeCastShapeId
int getShapeCastShapeId() const
Stable shape id from the last shape cast, or -1.
Definition World3D.h:682

eve::physics::World3D::getRayResultTriangleIndex
int getRayResultTriangleIndex(int index) const
Mesh/height-field triangle index of a sorted ray result, otherwise -1.

eve::physics::World3D::getRayHitX
float getRayHitX() const
Definition World3D.h:524

eve::physics::World3D::getShapeCastZ
float getShapeCastZ() const
World-space contact point Z from the last shape cast.
Definition World3D.h:694

eve::physics::World3D::getContactPointX
float getContactPointX(int index) const
World-space contact point X on the queried body.

eve::physics::World3D::castBox
int castBox(float x, float y, float z, float width, float height, float depth, float qx, float qy, float qz, float qw, float dx, float dy, float dz)
Sweep an oriented box without changing its rotation.
Definition World3D.cpp:1820

eve::physics::World3D::getBeginContactBodyBId
int getBeginContactBodyBId(int index) const
Body ID on stable side B of a begin-contact event.

eve::physics::World3D::getRayHitY
float getRayHitY() const
Definition World3D.h:525

eve::physics::World3D::getContactPointOtherShapeId
int getContactPointOtherShapeId(int index) const
Other Shape ID of a contact point.

eve::physics::World3D::getContactDampingRatio
float getContactDampingRatio() const
Current contact damping ratio.
Definition World3D.h:220

eve::physics::World3D::getMoverNormalY
float getMoverNormalY() const
Representative blocking normal Y from the last move.
Definition World3D.h:757

eve::physics::World3D::getQueryShapeCount
int getQueryShapeCount() const
Number of individual shapes hit by the last overlap query.
Definition World3D.h:778

eve::physics::World3D::newWeldJoint
Joint3D * newWeldJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY, float anchorZ, bool collideConnected=false)
Welds two bodies at a shared world-space anchor, preserving current relative pose.
Definition World3DJoints.cpp:36

eve::physics::World3D::getBoundsMinZ
float getBoundsMinZ() const
Minimum world-space Z covered by current broad-phase bounds.
Definition World3D.cpp:360

eve::physics::World3D::getExplosionResultDeltaVelocityX
float getExplosionResultDeltaVelocityX(int index) const
Explosion-induced linear velocity delta X.

eve::physics::World3D::getQueryShapeId
int getQueryShapeId(int index) const
Stable shape id of the i-th shape hit, sorted ascending.
Definition World3D.cpp:2182

eve::physics::World3D::getGravityX
float getGravityX() const
Definition World3D.cpp:780

eve::physics::World3D::getQueryCount
int getQueryCount() const
Number of bodies hit by the last overlap query.
Definition World3D.h:774

eve::physics::World3D::getRayResultNormalY
float getRayResultNormalY(int index) const
Surface normal Y of a sorted ray result.

eve::physics::World3D::getProfileBulletsMs
float getProfileBulletsMs() const
Latest continuous-collision bullet time in milliseconds.

eve::physics::World3D::setBodyPairCollisionEnabled
void setBodyPairCollisionEnabled(Body3D *bodyA, Body3D *bodyB, bool enabled)
Overrides collision for a live body pair without changing layer masks.
Definition World3D.cpp:810

eve::physics::World3D::getContactHertz
float getContactHertz() const
Current contact stiffness frequency.
Definition World3D.h:218

eve::physics::World3D::getRayHitNormalX
float getRayHitNormalX() const
Definition World3D.h:527

eve::physics::World3D::getContactPointSeparation
float getContactPointSeparation(int index) const
Signed surface separation; negative values indicate penetration.

eve::physics::World3D::getHitShapeBId
int getHitShapeBId(int index) const
Stable Shape ID on side B of a hit.

eve::physics::World3D::getClosestNormalX
float getClosestNormalX() const
Surface-to-target normal X, or zero for an inside/on-surface target.
Definition World3D.h:669

eve::physics::World3D::getQueryMaskBits
int getQueryMaskBits() const
Query mask bits currently in use.
Definition World3D.h:945

eve::physics::World3D::getQueryShapeTag
int getQueryShapeTag(int index) const
User tag paired with the i-th shape hit.
Definition World3D.cpp:2188

eve::physics::World3D::newParallelJoint
Joint3D * newParallelJoint(Body3D *bodyA, Body3D *bodyB, float axisX, float axisY, float axisZ, bool collideConnected=false)
Creates a parallel joint that spring-aligns body local Z axes to a world axis.
Definition World3DJoints.cpp:76

eve::physics::World3D::getMoverDeltaZ
float getMoverDeltaZ() const
Resolved translation Z from the last moveCapsule call.
Definition World3D.h:753

eve::physics::World3D::getProfileCollideMs
float getProfileCollideMs() const
Latest narrow-phase collision time in milliseconds.

eve::physics::World3D::setMoverUp
void setMoverUp(float x, float y, float z)
Set the up direction used for grounded and slope classification.
Definition World3D.cpp:1918

eve::physics::World3D::getHitCount
int getHitCount() const
Number of significant collision hits generated during the latest step.
Definition World3D.h:887

eve::physics::World3D::newSphericalJoint
Joint3D * newSphericalJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY, float anchorZ, float axisX, float axisY, float axisZ, bool collideConnected=false)
Creates a ball-and-socket joint with a world-space twist/cone axis.
Definition World3D.cpp:632

eve::physics::World3D::getJointStressKind
int getJointStressKind(int index) const
Joint kind code: 0 distance, 1 revolute, 2 prismatic, 3 spherical, 4 wheel.

eve::physics::World3D::getShapeCastShapeTag
int getShapeCastShapeTag() const
User tag of the shape from the last shape cast, or zero on no hit.
Definition World3D.h:684

eve::physics::World3D::getRayHitNormalZ
float getRayHitNormalZ() const
Definition World3D.h:529

eve::physics::World3D::newRevoluteJoint
Joint3D * newRevoluteJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY, float anchorZ, float axisX, float axisY, float axisZ, bool collideConnected=false)
Creates a hinge around a normalized world-space axis at a shared anchor.
Definition World3D.cpp:562

eve::physics::World3D::getMoverDeltaY
float getMoverDeltaY() const
Resolved translation Y from the last moveCapsule call.
Definition World3D.h:751

eve::physics::World3D::getHitPointX
float getHitPointX(int index) const
World-space impact point X.

eve::physics::World3D::getBeginTriggerCount
int getBeginTriggerCount() const
Number of sensor overlaps that began during the latest step.
Definition World3D.h:814

eve::physics::World3D::setContactTuning
void setContactTuning(float hertz, float dampingRatio, float pushOutSpeed)
Configures contact overlap recovery.
Definition World3D.cpp:239

eve::physics::World3D::isBodyPairCollisionEnabled
bool isBodyPairCollisionEnabled(Body3D *bodyA, Body3D *bodyB) const
Whether a body pair is permitted by the runtime contact override.
Definition World3D.cpp:827

eve::physics::World3D::queryBodyContacts
int queryBodyContacts(int bodyId, int maxPoints)
Caches current touching manifold points for one stable Body3D ID. Results are oriented from the queri...
Definition World3D.cpp:1096

eve::physics::World3D::setQueryIgnoredBodyId
void setQueryIgnoredBodyId(int bodyId)
Ignores one stable Body3D ID in subsequent spatial queries; -1 disables.
Definition World3D.cpp:980

eve::physics::World3D::getExplosionResultBodyId
int getExplosionResultBodyId(int index) const
Stable Body ID of an affected body, sorted ascending.

eve::physics::World3D::getQueryCategoryBits
int getQueryCategoryBits() const
Query category bits currently in use.
Definition World3D.h:943

eve::physics::World3D::castCapsule
int castCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius, float dx, float dy, float dz)
Sweep an arbitrarily oriented capsule through the world. The endpoints are cap centers and d{x,...
Definition World3D.cpp:1803

eve::physics::World3D::getMoverNormalZ
float getMoverNormalZ() const
Representative blocking normal Z from the last move.
Definition World3D.h:759

eve::physics::World3D::getBeginTriggerVisitorShapeTag
int getBeginTriggerVisitorShapeTag(int index) const
Visitor Shape Tag of a begin-trigger event.

eve::physics::World3D::getEndContactShapeBTag
int getEndContactShapeBTag(int index) const
Shape Tag on stable side B of an end-contact event.

eve::physics::World3D::getClosestDistance
float getClosestDistance() const
Non-negative distance from the target to the closest shape.
Definition World3D.h:675

eve::physics::World3D::getHitBodyBId
int getHitBodyBId(int index) const
Stable body ID on side B of a hit.

eve::physics::World3D::isContinuousCollisionEnabled
bool isContinuousCollisionEnabled() const
Whether world-level continuous collision is enabled.
Definition World3D.cpp:225

eve::physics::World3D::getContactPointShapeTag
int getContactPointShapeTag(int index) const
Queried-body Shape Tag of a contact point.

eve::physics::World3D::getHitNormalImpulse
float getHitNormalImpulse(int index) const
Total normal impulse accumulated across all manifolds and substeps.

eve::physics::World3D::querySphere
int querySphere(float x, float y, float z, float radius)
Query shapes overlapping a sphere in world meters.
Definition World3D.cpp:1627

eve::physics::World3D::getHitShapeAId
int getHitShapeAId(int index) const
Stable Shape ID on side A of a hit.

eve::physics::World3D::getShapeCastNormalZ
float getShapeCastNormalZ() const
Contact normal Z from the last shape cast.
Definition World3D.h:700

eve::physics::World3D::setWarmStartingEnabled
void setWarmStartingEnabled(bool enabled)
Enables constraint warm starting for stable stacks and joints.
Definition World3D.cpp:272

eve::physics::World3D::getContactPointY
float getContactPointY(int index) const
World-space contact point Y on the queried body.

eve::physics::World3D::getContactPointNormalY
float getContactPointNormalY(int index) const
Contact normal Y from queried body toward the other body.

eve::physics::World3D::getBeginContactCount
int getBeginContactCount() const
Number of non-sensor contacts that began during the latest step.
Definition World3D.h:785

eve::physics::World3D::getJointStressBodyAId
int getJointStressBodyAId(int index) const
Stable body A ID of a stress event.

eve::physics::World3D::getGravityY
float getGravityY() const
Definition World3D.cpp:785

eve::physics::World3D::getShapeCastResultNormalZ
float getShapeCastResultNormalZ(int index) const
Contact normal Z of a Shape Cast result.

eve::physics::World3D::getEndContactCount
int getEndContactCount() const
Number of non-sensor contacts that ended during the latest step.
Definition World3D.h:799

eve::physics::World3D::getRayResultShapeId
int getRayResultShapeId(int index) const
Shape ID of a sorted ray result.

eve::physics::World3D::isShapePairCollisionEnabled
bool isShapePairCollisionEnabled(Shape3D *shapeA, Shape3D *shapeB) const
Whether a shape pair is permitted by the runtime contact override.
Definition World3D.cpp:849

eve::physics::World3D::castCapsuleAll
int castCapsuleAll(float ax, float ay, float az, float bx, float by, float bz, float radius, float dx, float dy, float dz, int maxHits)
Collects the nearest maxHits swept-capsule intersections.
Definition World3D.cpp:1809

eve::physics::World3D::getBeginTriggerSensorShapeId
int getBeginTriggerSensorShapeId(int index) const
Sensor shape ID of a begin-trigger event.

eve::physics::World3D::rayCast
int rayCast(float x1, float y1, float z1, float x2, float y2, float z2)
Closest raycast from (x1,y1,z1) to (x2,y2,z2) in meters. Returns hit body id, or -1....
Definition World3D.cpp:1332

eve::physics::World3D::getJointStressCount
int getJointStressCount() const
Number of joints exceeding force/torque thresholds in the latest step.
Definition World3D.h:917

eve::physics::World3D::getShapeCastResultY
float getShapeCastResultY(int index) const
World-space contact point Y of a Shape Cast result.

eve::physics::World3D::explode
int explode(float x, float y, float z, float radius, float falloff, float impulsePerArea, int maskBits=-1)
Applies a geometry-aware radial impulse to dynamic convex shapes.
Definition World3D.cpp:280

eve::physics::World3D::getShapeCastTriangleIndex
int getShapeCastTriangleIndex() const
Mesh/height-field triangle index from the latest shape cast, otherwise -1.
Definition World3D.h:688

eve::physics::World3D::setQueryFilter
void setQueryFilter(int categoryBits, int maskBits)
Set category/mask bits for subsequent ray, overlap, cast and mover queries.
Definition World3D.cpp:970

eve::physics::World3D::getMoverDeltaX
float getMoverDeltaX() const
Resolved translation X from the last moveCapsule call.
Definition World3D.h:749

eve::physics::World3D::getShapeCastMaterialId
int getShapeCastMaterialId() const
Surface material ID at the last shape-cast intersection, or zero.
Definition World3D.h:686

eve::physics::World3D::getRayResultFraction
float getRayResultFraction(int index) const
Segment fraction in [0,1] of a sorted ray result.

eve::physics::World3D::getClosestZ
float getClosestZ() const
Closest surface point Z.
Definition World3D.h:667

eve::physics::World3D::getBoundsMaxZ
float getBoundsMaxZ() const
Maximum world-space Z covered by current broad-phase bounds.
Definition World3D.cpp:369

eve::physics::World3D::getEndTriggerSensorShapeTag
int getEndTriggerSensorShapeTag(int index) const
Sensor Shape Tag of an end-trigger event.

eve::physics::World3D::setMoverSlopeLimit
void setMoverSlopeLimit(float degrees)
Set maximum walkable slope in degrees, clamped to [0, 89.9].
Definition World3D.cpp:1928

eve::physics::World3D::getIslandCount
int getIslandCount() const
Current solver-island count.

eve::physics::World3D::setHitEventThreshold
void setHitEventThreshold(float speed)
Minimum approach speed in m/s required for enabled Shape3D hit events.
Definition World3D.cpp:795

eve::physics::World3D::getBeginContactShapeATag
int getBeginContactShapeATag(int index) const
Shape Tag on stable side A of a begin-contact event.

eve::physics::World3D::castBoxAll
int castBoxAll(float x, float y, float z, float width, float height, float depth, float qx, float qy, float qz, float qw, float dx, float dy, float dz, int maxHits)
Collects the nearest maxHits swept-oriented-box intersections.
Definition World3D.cpp:1826

eve::physics::World3D::getStaticTreeHeight
int getStaticTreeHeight() const
Static broad-phase tree height.

eve::physics::World3D::getContactPointOtherBodyId
int getContactPointOtherBodyId(int index) const
Other Body ID of a contact point.

eve::physics::World3D::getEndTriggerSensorShapeId
int getEndTriggerSensorShapeId(int index) const
Sensor shape ID of an end-trigger event.

eve::physics::World3D::newCrankSlider
Mechanism3D * newCrankSlider(Body3D *frame, Body3D *crank, Body3D *rod, Body3D *slider, float crankAnchorX, float crankAnchorY, float crankAnchorZ, float axisX, float axisY, float axisZ, float crankPinX, float crankPinY, float crankPinZ, float sliderPinX, float sliderPinY, float sliderPinZ, float slideAxisX, float slideAxisY, float slideAxisZ, bool collideConnected=false)
Builds a planar crank-slider from frame, crank, connecting rod and slider bodies.
Definition World3DJoints.cpp:155

eve::physics::World3D::getShapeCastResultNormalX
float getShapeCastResultNormalX(int index) const
Contact normal X of a Shape Cast result.

eve::physics::World3D::getClosestBodyId
int getClosestBodyId() const
Stable body id from the latest closestPoint call, or -1.
Definition World3D.h:657

eve::physics::World3D::getContactPointZ
float getContactPointZ(int index) const
World-space contact point Z on the queried body.

eve::physics::World3D::getBeginContactShapeBTag
int getBeginContactShapeBTag(int index) const
Shape Tag on stable side B of a begin-contact event.

eve::physics::World3D::getExplosionResultDeltaAngularVelocityY
float getExplosionResultDeltaAngularVelocityY(int index) const
Explosion-induced angular velocity delta Y.

eve::physics::World3D::getExplosionResultDeltaVelocityY
float getExplosionResultDeltaVelocityY(int index) const
Explosion-induced linear velocity delta Y.

eve::physics::World3D::getRayResultX
float getRayResultX(int index) const
World-space hit point X of a sorted ray result.

eve::physics::World3D::getMemoryByteCount
int getMemoryByteCount() const
Approximate Box3D world allocation in bytes.

eve::physics::World3D::getEndTriggerVisitorShapeId
int getEndTriggerVisitorShapeId(int index) const
Visitor shape ID of an end-trigger event.

eve::physics::World3D::getQueryIgnoredShapeId
int getQueryIgnoredShapeId() const
Stable Shape3D ID currently ignored by queries, or -1.
Definition World3D.h:953

eve::physics::World3D::getEndTriggerVisitorShapeTag
int getEndTriggerVisitorShapeTag(int index) const
Visitor Shape Tag of an end-trigger event.

eve::physics::World3D::getShapeCastBodyId
int getShapeCastBodyId() const
Stable body id from the last shape cast, or -1.
Definition World3D.h:680

eve::physics::World3D::getShapeCastY
float getShapeCastY() const
World-space contact point Y from the last shape cast.
Definition World3D.h:692

eve::physics::World3D::getContactPointShapeId
int getContactPointShapeId(int index) const
Queried-body Shape ID of a contact point.

eve::physics::World3D::getExplosionResultDeltaAngularVelocityX
float getExplosionResultDeltaAngularVelocityX(int index) const
Explosion-induced angular velocity delta X.

eve::physics::World3D::getShapeCastResultX
float getShapeCastResultX(int index) const
World-space contact point X of a Shape Cast result.

eve::physics::World3D::queryBox
int queryBox(float x, float y, float z, float width, float height, float depth, float qx, float qy, float qz, float qw)
Query shapes overlapping an oriented box.
Definition World3D.cpp:1692

eve::physics::World3D::setMaximumLinearSpeed
void setMaximumLinearSpeed(float speed)
Sets the finite positive world-wide linear velocity clamp in m/s.
Definition World3D.cpp:262

eve::physics::World3D::getBoundsMinY
float getBoundsMinY() const
Minimum world-space Y covered by current broad-phase bounds.
Definition World3D.cpp:357

eve::physics::World3D::getRayHitMaterialId
int getRayHitMaterialId() const
Surface material ID at the last ray intersection, or zero.
Definition World3D.h:521

eve::physics::World3D::newRatchet
Mechanism3D * newRatchet(Body3D *frame, Body3D *wheel, float anchorX, float anchorY, float anchorZ, float axisX, float axisY, float axisZ, int direction, float engagementTorque, bool collideConnected=false)
Builds a one-way ratchet around a revolute axis.
Definition World3DJoints.cpp:136

eve::physics::World3D::getJointStressForceZ
float getJointStressForceZ(int index) const
Constraint force Z of a stress event.

eve::physics::World3D::getShapeCastResultTriangleIndex
int getShapeCastResultTriangleIndex(int index) const
Mesh/height-field triangle index of a Shape Cast result, otherwise -1.

eve::physics::World3D::getClosestNormalZ
float getClosestNormalZ() const
Surface-to-target normal Z, or zero for an inside/on-surface target.
Definition World3D.h:673

eve::physics::World3D::newFilterJoint
Joint3D * newFilterJoint(Body3D *bodyA, Body3D *bodyB)
Disables collision between two specific bodies (filter joint).
Definition World3DJoints.cpp:100

eve::physics::World3D::getExplosionResultCount
int getExplosionResultCount() const
Number of bodies affected by the latest explosion.
Definition World3D.h:249

eve::physics::World3D::getShapeCastResultZ
float getShapeCastResultZ(int index) const
World-space contact point Z of a Shape Cast result.

eve::physics::World3D::getRayHitShapeTag
int getRayHitShapeTag() const
User tag of the shape from the last ray cast, or zero on no hit.
Definition World3D.h:519

eve::physics::World3D::newPrismaticJoint
Joint3D * newPrismaticJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY, float anchorZ, float axisX, float axisY, float axisZ, bool collideConnected=false)
Creates a slider whose permitted world-space translation follows axis.
Definition World3D.cpp:597

eve::physics::World3D::getProfileSensorsMs
float getProfileSensorsMs() const
Latest sensor processing time in milliseconds.

eve::physics::World3D::newShaft
Mechanism3D * newShaft(Body3D *support, Body3D *rotor, float anchorX, float anchorY, float anchorZ, float axisX, float axisY, float axisZ, bool collideConnected=false)
Builds a shaft (support↔rotor revolute) with optional drive motor helpers.
Definition World3DJoints.cpp:122

eve::physics::World3D::getBodyCount
int getBodyCount() const
Current backend body count.

eve::physics::World3D::getBoundsMinX
float getBoundsMinX() const
Minimum world-space X covered by current broad-phase bounds.
Definition World3D.cpp:354

eve::physics::World3D::getAwakeContactCount
int getAwakeContactCount() const
Contacts processed by the latest collide pass.

eve::physics::World3D::getHitShapeBTag
int getHitShapeBTag(int index) const
Shape Tag on side B of a hit.

eve::physics::World3D::getClosestNormalY
float getClosestNormalY() const
Surface-to-target normal Y, or zero for an inside/on-surface target.
Definition World3D.h:671

eve::physics::World3D::newWheelJoint
Joint3D * newWheelJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY, float anchorZ, float suspensionAxisX, float suspensionAxisY, float suspensionAxisZ, float wheelAxisX, float wheelAxisY, float wheelAxisZ, bool collideConnected=false)
Creates a vehicle wheel joint with independent world suspension and spin axes.
Definition World3D.cpp:667

eve::physics::World3D::setRestitutionThreshold
void setRestitutionThreshold(float speed)
Minimum impact speed that permits material restitution, in m/s.
Definition World3D.cpp:229

eve::physics::World3D::newDistanceJoint
Joint3D * newDistanceJoint(Body3D *bodyA, Body3D *bodyB, float anchorAX, float anchorAY, float anchorAZ, float anchorBX, float anchorBY, float anchorBZ, float length, bool collideConnected=false)
Connects two world-space anchor points with a rigid distance constraint.
Definition World3D.cpp:532

eve::physics::World3D::getContactRecycleDistance
float getContactRecycleDistance() const
Current contact-point persistence distance in meters.
Definition World3D.cpp:258

eve::physics::World3D::getHitBodyAId
int getHitBodyAId(int index) const
Stable body ID on side A of a hit.

eve::physics::World3D::getJointStressForceX
float getJointStressForceX(int index) const
Constraint force X of a stress event.

eve::physics::World3D::queryAABB
int queryAABB(float minX, float minY, float minZ, float maxX, float maxY, float maxZ)
Query shapes overlapping an AABB in meters (min/max corners). Returns match count; read ids with getQ...
Definition World3D.cpp:1502

eve::physics::World3D::getContactPointNormalVelocity
float getContactPointNormalVelocity(int index) const
Pre-solve relative normal velocity; negative means approaching.

eve::physics::World3D::updateFull
void updateFull(float dt, int subStepCount)
Steps with an explicit substep count.
Definition World3D.cpp:728

eve::physics::World3D::castSphereAll
int castSphereAll(float x, float y, float z, float radius, float dx, float dy, float dz, int maxHits)
Collects the nearest maxHits swept-sphere intersections.
Definition World3D.cpp:1793

eve::physics::World3D::getRayResultShapeTag
int getRayResultShapeTag(int index) const
Shape Tag of a sorted ray result.

eve::physics::World3D::destroyBody
void destroyBody(Body3D *body)
Destroys a body (null is ignored).
Definition World3D.cpp:997

eve::physics::World3D::getShapeCastResultShapeTag
int getShapeCastResultShapeTag(int index) const
Shape Tag of a sorted Shape Cast result.

eve::physics::World3D::setContinuousCollisionEnabled
void setContinuousCollisionEnabled(bool enabled)
Enables world-level continuous collision against static geometry.
Definition World3D.cpp:221

eve::physics::World3D::setQueryIgnoredShapeId
void setQueryIgnoredShapeId(int shapeId)
Ignores one stable Shape3D ID in subsequent spatial queries; -1 disables.
Definition World3D.cpp:986

eve::physics::World3D::getShapeCastFraction
float getShapeCastFraction() const
Translation fraction in [0,1] at the earliest hit.
Definition World3D.h:702

eve::physics::World3D::clearQueryIgnores
void clearQueryIgnores()
Clears Body and Shape query exclusions without changing layer filtering.
Definition World3D.cpp:992

eve::physics::World3D::getBoundsMaxX
float getBoundsMaxX() const
Maximum world-space X covered by current broad-phase bounds.
Definition World3D.cpp:363

eve::physics::World3D::getBeginContactShapeBId
int getBeginContactShapeBId(int index) const
Shape ID on stable side B of a begin-contact event.

eve::physics::World3D::getEndTriggerSensorBodyId
int getEndTriggerSensorBodyId(int index) const
Sensor body ID of an end-trigger event.

eve::physics::World3D::getEndTriggerVisitorBodyId
int getEndTriggerVisitorBodyId(int index) const
Visitor body ID of an end-trigger event.

eve::physics::World3D::getShapeCastNormalX
float getShapeCastNormalX() const
Contact normal X from the last shape cast.
Definition World3D.h:696

eve::physics::World3D::getContactCount
int getContactCount() const
Current backend contact count.

eve::physics::World3D::getQueryIgnoredBodyId
int getQueryIgnoredBodyId() const
Stable Body3D ID currently ignored by queries, or -1.
Definition World3D.h:951

eve::physics::World3D::getContactPointCount
int getContactPointCount() const
Number of points cached by queryBodyContacts.
Definition World3D.h:852

eve::physics::World3D::getExplosionResultDeltaAngularVelocityZ
float getExplosionResultDeltaAngularVelocityZ(int index) const
Explosion-induced angular velocity delta Z.

eve::physics::World3D::getRayResultNormalX
float getRayResultNormalX(int index) const
Surface normal X of a sorted ray result.

eve::physics::World3D::getShapeCastResultNormalY
float getShapeCastResultNormalY(int index) const
Contact normal Y of a Shape Cast result.

eve::physics::World3D::getGravityZ
float getGravityZ() const
Definition World3D.cpp:790

eve::physics::World3D::getProfileSolveMs
float getProfileSolveMs() const
Latest constraint solver time in milliseconds.

eve::physics::World3D::clearContactEvents
void clearContactEvents()
Clears all contact and trigger buffers before the next step.
Definition World3D.cpp:1086

eve::physics::World3D::getJointStressBodyBId
int getJointStressBodyBId(int index) const
Stable body B ID of a stress event.

eve::physics::World3D::getEndContactShapeAId
int getEndContactShapeAId(int index) const
Shape ID on stable side A of an end-contact event.

eve::physics::World3D::destroy
void destroy()
Destroys the world and invalidates all wrappers.
Definition World3D.cpp:432

eve::physics::World3D::getRayHitZ
float getRayHitZ() const
Definition World3D.h:526

eve::physics::World3D::getContactPointNormalX
float getContactPointNormalX(int index) const
Contact normal X from queried body toward the other body.

eve::physics::World3D::getShapeCastNormalY
float getShapeCastNormalY() const
Contact normal Y from the last shape cast.
Definition World3D.h:698

eve::physics::World3D::getHitNormalY
float getHitNormalY(int index) const
Hit normal Y, pointing from stable side A to B.

eve::physics::World3D::getProfilePairsMs
float getProfilePairsMs() const
Latest broad-phase pair generation time in milliseconds.

eve::physics::World3D::getHitApproachSpeed
float getHitApproachSpeed(int index) const
Positive pre-solve approach speed in m/s.

eve::physics::World3D::hasShapeCastHit
bool hasShapeCastHit() const
Whether the last sphere, capsule, or box cast hit a body.
Definition World3D.h:678

eve::physics::World3D::resetQueryFilter
void resetQueryFilter()
Restore the query filter to accept all lower-32-bit categories.
Definition World3D.cpp:975

eve::physics::World3D::setShapePairCollisionEnabled
void setShapePairCollisionEnabled(Shape3D *shapeA, Shape3D *shapeB, bool enabled)
Overrides collision for one live shape pair.
Definition World3D.cpp:835

eve::physics::World3D::getRayHitBodyId
int getRayHitBodyId() const
Definition World3D.h:515

eve::physics::World3D::isContactPointPersisted
bool isContactPointPersisted(int index) const
Whether this manifold point existed in the previous step.
Definition World3D.cpp:2339

eve::physics::World3D::getClosestX
float getClosestX() const
Closest surface point X.
Definition World3D.h:663

eve::physics::World3D::getMoverNormalX
float getMoverNormalX() const
Representative blocking normal X from the last move.
Definition World3D.h:755

eve::physics::World3D::getHitEventThreshold
float getHitEventThreshold() const
Current significant-hit speed threshold in m/s.
Definition World3D.cpp:801

eve::physics::World3D::getRecycledContactCount
int getRecycledContactCount() const
Contact points recycled during the latest step.

eve::physics::World3D::getShapeCastResultMaterialId
int getShapeCastResultMaterialId(int index) const
Surface material ID at a sorted Shape Cast intersection.

eve::physics::World3D::getEndContactBodyBId
int getEndContactBodyBId(int index) const
Body ID on stable side B of an end-contact event.

eve::physics::World3D::getRayResultCount
int getRayResultCount() const
Number of results cached by the latest rayCast or rayCastAll call.
Definition World3D.h:532

eve::physics::World3D::getExplosionResultDeltaVelocityZ
float getExplosionResultDeltaVelocityZ(int index) const
Explosion-induced linear velocity delta Z.

eve::physics::World3D::rayCastAll
int rayCastAll(float x1, float y1, float z1, float x2, float y2, float z2, int maxHits)
Collects the nearest maxHits ray intersections, sorted by fraction then Shape ID.
Definition World3D.cpp:1405

eve::physics::World3D::newBody
Body3D * newBody(const std::string &bodyType, float x, float y, float z)
Creates a body in meter-space units.
Definition World3D.cpp:902

eve::physics::World3D::getHitNormalZ
float getHitNormalZ(int index) const
Hit normal Z, pointing from stable side A to B.

eve::physics::World3D::getBeginTriggerSensorShapeTag
int getBeginTriggerSensorShapeTag(int index) const
Sensor Shape Tag of a begin-trigger event.

eve::physics::World3D::getBoundsMaxY
float getBoundsMaxY() const
Maximum world-space Y covered by current broad-phase bounds.
Definition World3D.cpp:366

eve::physics::World3D::setContactRecycleDistance
void setContactRecycleDistance(float distance)
Sets contact-point persistence distance in meters; zero disables recycling.
Definition World3D.cpp:252

eve::physics::World3D::getRayResultNormalZ
float getRayResultNormalZ(int index) const
Surface normal Z of a sorted ray result.

eve::physics::World3D::getRayHitFraction
float getRayHitFraction() const
Definition World3D.h:530

eve::physics::World3D::getShapeCastResultBodyId
int getShapeCastResultBodyId(int index) const
Body ID of a sorted Shape Cast result.

eve::physics::World3D::getHitShapeATag
int getHitShapeATag(int index) const
Shape Tag on side A of a hit.

eve::physics::World3D::moveCapsule
bool moveCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius, float dx, float dy, float dz)
Move a capsule with continuous collision and multi-plane sliding. Existing penetration is recovered b...
Definition World3D.cpp:1935

eve::physics::World3D::getJointStressTorqueY
float getJointStressTorqueY(int index) const
Constraint torque Y of a stress event.

eve::physics::World3D::getJointStressJointId
int getJointStressJointId(int index) const
Stable Joint3D ID of a stress event.

eve::physics::World3D::getBeginContactBodyAId
int getBeginContactBodyAId(int index) const
Body ID on stable side A of a begin-contact event.

eve::physics::World3D::getBeginTriggerVisitorBodyId
int getBeginTriggerVisitorBodyId(int index) const
Visitor body ID of a begin-trigger event.

eve::physics::World3D::getJointStressTorqueZ
float getJointStressTorqueZ(int index) const
Constraint torque Z of a stress event.

eve::physics::World3D::getMoverIterations
int getMoverIterations() const
Number of outer solver passes used by the last move.
Definition World3D.h:763

eve::physics::World3D::getRayResultY
float getRayResultY(int index) const
World-space hit point Y of a sorted ray result.

eve::physics::World3D::getRayHitNormalY
float getRayHitNormalY() const
Definition World3D.h:528

eve::physics::World3D::getShapeCastResultCount
int getShapeCastResultCount() const
Number of results cached by the latest single or multi Shape Cast.
Definition World3D.h:704

eve::physics::World3D::getMoverPlaneCount
int getMoverPlaneCount() const
Number of collision planes considered during the last move.
Definition World3D.h:761

eve::physics::World3D::getJointStressTorqueX
float getJointStressTorqueX(int index) const
Constraint torque X of a stress event.

eve::physics::World3D::getContactPointOtherShapeTag
int getContactPointOtherShapeTag(int index) const
Other Shape Tag of a contact point.

eve::physics::World3D::getShapeCount
int getShapeCount() const
Current backend shape count.

eve::physics::World3D::getRayHitShapeId
int getRayHitShapeId() const
Stable shape id from the last ray cast, or -1.
Definition World3D.h:517

eve::physics::World3D::getHitPointY
float getHitPointY(int index) const
World-space impact point Y.

eve::physics::World3D::getRayResultBodyId
int getRayResultBodyId(int index) const
Body ID of a sorted ray result.

eve::physics::World3D::getRayResultMaterialId
int getRayResultMaterialId(int index) const
Surface material ID at a sorted ray intersection.

eve::physics::World3D::getContactPointNormalZ
float getContactPointNormalZ(int index) const
Contact normal Z from queried body toward the other body.

eve::physics::World3D::getMoverGroundDot
float getMoverGroundDot() const
Largest dot product between mover up and a contact normal.
Definition World3D.h:771

eve::physics::World3D::isMoverGrounded
bool isMoverGrounded() const
True when the last move touched a walkable plane.
Definition World3D.h:769

eve::physics::World3D::getRayResultZ
float getRayResultZ(int index) const
World-space hit point Z of a sorted ray result.

eve::physics::World
Box2D world wrapper (2D physics) with pixel-space coordinates. Handles stepping, gravity,...
Definition World.h:41

eve::physics::World::setMeter
void setMeter(float pixelsPerMeter)
Changes the pixels-per-meter conversion.
Definition World.cpp:414

eve::physics::World::getRayHitX
float getRayHitX() const
Definition World.h:324

eve::physics::World::getRayHitBodyId
int getRayHitBodyId() const
Definition World.h:323

eve::physics::World::newDistanceJoint
Joint2D * newDistanceJoint(Body *bodyA, Body *bodyB, float anchorAX, float anchorAY, float anchorBX, float anchorBY, float lengthPixels, bool collideConnected=false)
Connects two pixel-space anchors with a distance constraint.
Definition WorldJoints2D.cpp:79

eve::physics::World::newWheelJoint
Joint2D * newWheelJoint(Body *bodyA, Body *bodyB, float anchorX, float anchorY, float axisX, float axisY, bool collideConnected=false)
Creates a wheel joint with a pixel-space suspension axis.
Definition WorldJoints2D.cpp:131

eve::physics::World::update
void update(float dt)
Steps the simulation by dt seconds (5 velocity / 2 position iterations).
Definition World.cpp:354

eve::physics::World::queryAABB
int queryAABB(float x, float y, float w, float h)
Query fixtures overlapping an axis-aligned box in pixel space (x,y,w,h). Returns match count; read id...
Definition World.cpp:695

eve::physics::World::getImpactNormalY
float getImpactNormalY(int index) const
Definition World.cpp:630

eve::physics::World::destroyBody
void destroyBody(Body *body)
Destroys a body (null is ignored).
Definition World.cpp:462

eve::physics::World::newWeldJoint
Joint2D * newWeldJoint(Body *bodyA, Body *bodyB, float anchorX, float anchorY, bool collideConnected=false)
Welds two bodies at a shared pixel-space anchor.
Definition WorldJoints2D.cpp:120

eve::physics::World::getBeginContactFixtureATag
std::string getBeginContactFixtureATag(int index) const
Definition World.cpp:591

eve::physics::World::getRayHitY
float getRayHitY() const
Definition World.h:325

eve::physics::World::getEndContactFixtureATag
std::string getEndContactFixtureATag(int index) const
Definition World.cpp:603

eve::physics::World::getImpactPointX
float getImpactPointX(int index) const
Definition World.cpp:621

eve::physics::World::drawDebug
void drawDebug(graphics::Graphics *gfx)
Optional: draw fixture AABBs via Graphics::drawSolidRect.
Definition WorldDebugDraw.cpp:117

eve::physics::World::getQueryBodyId
int getQueryBodyId(int index) const
Definition World.cpp:726

eve::physics::World::getQueryCount
int getQueryCount() const
Definition World.h:336

eve::physics::World::getEndContactBodyBId
int getEndContactBodyBId(int index) const
Definition World.cpp:600

eve::physics::World::getBeginContactBodyBId
int getBeginContactBodyBId(int index) const
Definition World.cpp:588

eve::physics::World::newPrismaticJoint
Joint2D * newPrismaticJoint(Body *bodyA, Body *bodyB, float anchorX, float anchorY, float axisX, float axisY, bool collideConnected=false)
Creates a prismatic slider along a pixel-space axis.
Definition WorldJoints2D.cpp:108

eve::physics::World::destroy
void destroy()
Destroys the underlying Box2D world and resets event buffers.
Definition World.cpp:259

eve::physics::World::setGravity
void setGravity(float gx, float gy)
Sets the world gravity vector in pixels/s^2.
Definition World.cpp:399

eve::physics::World::getEndContactBodyAId
int getEndContactBodyAId(int index) const
Definition World.cpp:597

eve::physics::World::getImpactCount
int getImpactCount() const
Definition World.h:350

eve::physics::World::getGravityX
float getGravityX() const
Definition World.cpp:404

eve::physics::World::getRayHitFraction
float getRayHitFraction() const
Fraction along the segment [0,1] of the closest hit.
Definition World.h:329

eve::physics::World::getRayHitNormalY
float getRayHitNormalY() const
Definition World.h:327

eve::physics::World::hasRayHit
bool hasRayHit() const
Definition World.h:322

eve::physics::World::newRevoluteJoint
Joint2D * newRevoluteJoint(Body *bodyA, Body *bodyB, float anchorX, float anchorY, bool collideConnected=false)
Creates a revolute hinge at a shared pixel-space anchor.
Definition WorldJoints2D.cpp:97

eve::physics::World::getImpactNormalX
float getImpactNormalX(int index) const
Definition World.cpp:627

eve::physics::World::getImpactRelativeNormalSpeed
float getImpactRelativeNormalSpeed(int index) const
Definition World.cpp:633

eve::physics::World::newBody
Body * newBody(const std::string &bodyType, float x, float y)
Creates a body in pixel-space units.
Definition World.cpp:431

eve::physics::World::newCrankSlider
Mechanism2D * newCrankSlider(Body *frame, Body *crank, Body *rod, Body *slider, float crankAnchorX, float crankAnchorY, float crankPinX, float crankPinY, float sliderPinX, float sliderPinY, float slideAxisX, float slideAxisY, bool collideConnected=false)
Builds a planar crank-slider from frame, crank, connecting rod and slider bodies.
Definition WorldJoints2D.cpp:204

eve::physics::World::getBeginContactBodyAId
int getBeginContactBodyAId(int index) const
Definition World.cpp:585

eve::physics::World::getImpactBodyAId
int getImpactBodyAId(int index) const
Definition World.cpp:609

eve::physics::World::getBeginContactCount
int getBeginContactCount() const
Definition World.h:339

eve::physics::World::getImpactBodyBId
int getImpactBodyBId(int index) const
Definition World.cpp:612

eve::physics::World::getRayHitNormalX
float getRayHitNormalX() const
Definition World.h:326

eve::physics::World::newGearJoint
Joint2D * newGearJoint(Joint2D *joint1, Joint2D *joint2, float ratio)
Creates a gear joint that couples two revolute or prismatic joints.
Definition WorldJoints2D.cpp:151

eve::physics::World::newRatchet
Mechanism2D * newRatchet(Body *frame, Body *wheel, float anchorX, float anchorY, int direction, float engagementTorque, bool collideConnected=false)
Builds a one-way ratchet around a revolute hinge.
Definition WorldJoints2D.cpp:189

eve::physics::World::getEndContactCount
int getEndContactCount() const
Definition World.h:344

eve::physics::World::getImpactNormalImpulse
float getImpactNormalImpulse(int index) const
Definition World.cpp:636

eve::physics::World::getEndContactFixtureBTag
std::string getEndContactFixtureBTag(int index) const
Definition World.cpp:606

eve::physics::World::rayCast
int rayCast(float x1, float y1, float x2, float y2)
Closest raycast in pixel space from (x1,y1) to (x2,y2). Returns hit body id, or -1....
Definition World.cpp:650

eve::physics::World::getImpactTangentImpulse
float getImpactTangentImpulse(int index) const
Definition World.cpp:639

eve::physics::World::getGravityY
float getGravityY() const
Definition World.cpp:409

eve::physics::World::getBeginContactFixtureBTag
std::string getBeginContactFixtureBTag(int index) const
Definition World.cpp:594

eve::physics::World::updateFull
void updateFull(float dt, int velocityIterations, int positionIterations)
Steps with explicit iteration counts.
Definition World.cpp:356

eve::physics::World::clearContactEvents
void clearContactEvents()
Clears collected begin/end contact and impact event buffers.
Definition World.cpp:643

eve::physics::World::getImpactFixtureATag
std::string getImpactFixtureATag(int index) const
Definition World.cpp:615

eve::physics::World::getImpactFixtureBTag
std::string getImpactFixtureBTag(int index) const
Definition World.cpp:618

eve::physics::World::getMeter
float getMeter() const
Definition World.h:161

eve::physics::World::newMotorJoint
Joint2D * newMotorJoint(Body *bodyA, Body *bodyB, bool collideConnected=false)
Creates a motor joint that drives relative pose between bodies.
Definition WorldJoints2D.cpp:143

eve::physics::World::getImpactPointY
float getImpactPointY(int index) const
Definition World.cpp:624

eve::physics::World::newShaft
Mechanism2D * newShaft(Body *support, Body *rotor, float anchorX, float anchorY, bool collideConnected=false)
Builds a shaft (support↔rotor revolute) with optional drive motor helpers.
Definition WorldJoints2D.cpp:178

eve::editor::TimelineHitPart::Body
@ Body

eve::physics
Optional physics backend for vehicle mobility and body attach.
Definition Climbing.h:36

eve::physics::beginTerrainLoadGravity
Result< void > beginTerrainLoadGravity(TerrainLoadGravityState *state, Body3D *body, bool terrainFound)
Begin monitoring a body when a containing terrain scene exists.
Definition TerrainLoadGravity.cpp:10

eve::physics::advanceTerrainLoadGravity
Result< bool > advanceTerrainLoadGravity(TerrainLoadGravityState *state, Body3D *body, bool terrainLoaded, float deltaSeconds, float activationDelay)
Advance terrain-load waiting and restore gravity after the configured delay.
Definition TerrainLoadGravity.cpp:28

eve::physics::SimulationBackendDomain::World3D
@ World3D

eve::physics::SimulationBackendDomain::SoftBody3D
@ SoftBody3D

eve::physics::registerPhysicsCapabilities
void registerPhysicsCapabilities()
Registers physics capabilities.
Definition PhysicsCapabilities.cpp:158

eve::procgen_editing::detail::field
const EditorValue * field(const EditorValue &value, const char *name)
Definition RoadNetworkEditTarget.cpp:15

eve::rpg::table
std::unordered_map< std::string, SkillDefinition > & table()
Definition Skill.cpp:65

eve::script::projectResult
ssq::Table projectResult(HSQUIRRELVM vm, Result< void > &&result)
Consume and project a void native Result using the common schema.
Definition SquirrelBinding.cpp:470