types.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 Erin Catto
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "box2d/color.h"
#include "box2d/constants.h"
#include "box2d/id.h"
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
#define B2_LITERAL(T) T
#define B2_ZERO_INIT                                                                                                             \
    {                                                                                                                            \
    }
#else
#define B2_LITERAL(T) (T)
 
#define B2_ZERO_INIT                                                                                                             \
    {                                                                                                                            \
        0                                                                                                                        \
    }
#endif
 
#define B2_ARRAY_COUNT(A) (int)(sizeof(A) / sizeof(A[0]))
 
#define B2_MAYBE_UNUSED(x) ((void)(x))
 
typedef struct b2Vec2
{
    float x, y;
} b2Vec2;
 
typedef struct b2Rot
{
    float s, c;
} b2Rot;
 
typedef struct b2Transform
{
    b2Vec2 p;
    b2Rot q;
} b2Transform;
 
typedef struct b2Mat22
{
    b2Vec2 cx, cy;
} b2Mat22;
 
typedef struct b2AABB
{
    b2Vec2 lowerBound;
    b2Vec2 upperBound;
} b2AABB;
 
typedef struct b2RayCastInput
{
    b2Vec2 origin, translation;
    float maxFraction;
} b2RayCastInput;
 
typedef struct b2ShapeCastInput
{
    b2Vec2 points[b2_maxPolygonVertices];
    int32_t count;
    float radius;
    b2Vec2 translation;
    float maxFraction;
} b2ShapeCastInput;
 
typedef struct b2CastOutput
{
    b2Vec2 normal;
    b2Vec2 point;
    float fraction;
    int32_t iterations;
    bool hit;
} b2RayCastOutput;
 
typedef void b2TaskCallback(int32_t startIndex, int32_t endIndex, uint32_t threadIndex, void* taskContext);
 
typedef void* b2EnqueueTaskCallback(b2TaskCallback* task, int32_t itemCount, int32_t minRange, void* taskContext,
                                    void* userContext);
 
typedef void b2FinishTaskCallback(void* userTask, void* userContext);
 
typedef struct b2WorldDef
{
    b2Vec2 gravity;
 
    float restitutionThreshold;
 
    float contactPushoutVelocity;
 
    float contactHertz;
 
    float contactDampingRatio;
 
    bool enableSleep;
 
    int32_t bodyCapacity;
 
    int32_t shapeCapacity;
 
    int32_t contactCapacity;
 
    int32_t jointCapacity;
 
    int32_t stackAllocatorCapacity;
 
    uint32_t workerCount;
    b2EnqueueTaskCallback* enqueueTask;
    b2FinishTaskCallback* finishTask;
    void* userTaskContext;
} b2WorldDef;
 
static inline b2WorldDef b2DefaultWorldDef(void)
{
    b2WorldDef def = B2_ZERO_INIT;
    def.gravity = B2_LITERAL(b2Vec2){0.0f, -10.0f};
    def.restitutionThreshold = 1.0f * b2_lengthUnitsPerMeter;
    def.contactPushoutVelocity = 3.0f * b2_lengthUnitsPerMeter;
    def.contactHertz = 30.0f;
    def.contactDampingRatio = 1.0f;
    def.enableSleep = true;
    def.bodyCapacity = 8;
    def.shapeCapacity = 8;
    def.contactCapacity = 8;
    def.jointCapacity = 8;
    def.stackAllocatorCapacity = 1024 * 1024;
    return def;
}
 
typedef enum b2BodyType
{
    b2_staticBody = 0,
    b2_kinematicBody = 1,
    b2_dynamicBody = 2,
    b2_bodyTypeCount
} b2BodyType;
 
typedef struct b2BodyDef
{
    b2BodyType type;
 
    b2Vec2 position;
 
    float angle;
 
    b2Vec2 linearVelocity;
 
    float angularVelocity;
 
    float linearDamping;
 
    float angularDamping;
 
    float gravityScale;
 
    void* userData;
 
    bool enableSleep;
 
    bool isAwake;
 
    bool fixedRotation;
 
    bool isEnabled;
} b2BodyDef;
 
static const b2BodyDef b2_defaultBodyDef = {
    b2_staticBody, {0.0f, 0.0f}, 0.0f, {0.0f, 0.0f}, 0.0f, 0.0f, 0.0f, 1.0f, NULL, true, true, false, true,
};
 
typedef struct b2Filter
{
    uint32_t categoryBits;
 
    uint32_t maskBits;
 
    int32_t groupIndex;
} b2Filter;
 
static const b2Filter b2_defaultFilter = {0x00000001, 0xFFFFFFFF, 0};
 
typedef struct b2QueryFilter
{
    uint32_t categoryBits;
 
    uint32_t maskBits;
} b2QueryFilter;
 
static const b2QueryFilter b2_defaultQueryFilter = {0x00000001, 0xFFFFFFFF};
 
typedef enum b2ShapeType
{
    b2_capsuleShape,
    b2_circleShape,
    b2_polygonShape,
    b2_segmentShape,
    b2_smoothSegmentShape,
    b2_shapeTypeCount
} b2ShapeType;
 
typedef struct b2ShapeDef
{
    void* userData;
 
    float friction;
 
    float restitution;
 
    float density;
 
    b2Filter filter;
 
    bool isSensor;
 
    bool enableSensorEvents;
 
    bool enableContactEvents;
 
    bool enablePreSolveEvents;
 
} b2ShapeDef;
 
static const b2ShapeDef b2_defaultShapeDef = {
    NULL, 0.6f, 0.0f, 1.0f, {0x00000001, 0xFFFFFFFF, 0}, false, true, true, false,
};
 
typedef struct b2ChainDef
{
    const b2Vec2* points;
 
    int32_t count;
 
    bool loop;
 
    void* userData;
 
    float friction;
 
    float restitution;
 
    b2Filter filter;
} b2ChainDef;
 
static const b2ChainDef b2_defaultChainDef = {NULL, 0, false, NULL, 0.6f, 0.0f, {0x00000001, 0xFFFFFFFF, 0}};