path: root/source/blender/makesdna/DNA_rigidbody_types.h

/* SPDX-License-Identifier: GPL-2.0-or-later
 * Copyright 2013 Blender Foundation. All rights reserved. */

/** \file
 * \ingroup DNA
 * \brief Types and defines for representing Rigid Body entities
 */

#pragma once

#include "DNA_listBase.h"
#include "DNA_object_force_types.h"

#ifdef __cplusplus
extern "C" {
#endif

struct Collection;

struct EffectorWeights;

/* ******************************** */
/* RigidBody World */

/** Container for data shared by original and evaluated copies of #RigidBodyWorld. */
typedef struct RigidBodyWorld_Shared {
  /* cache */
  struct PointCache *pointcache;
  struct ListBase ptcaches;

  /* References to Physics Sim objects. Exist at runtime only ---------------------- */
  /** Physics sim world (i.e. #btDiscreteDynamicsWorld). */
  void *physics_world;
} RigidBodyWorld_Shared;

/* RigidBodyWorld (rbw)
 *
 * Represents a "simulation scene" existing within the parent scene.
 */
typedef struct RigidBodyWorld {
  /* Sim World Settings ------------------------------------------------------------- */
  /** Effectors info. */
  struct EffectorWeights *effector_weights;

  /** Group containing objects to use for Rigid Bodies. */
  struct Collection *group;
  /** Array to access group objects by index, only used at runtime. */
  struct Object **objects;

  /** Group containing objects to use for Rigid Body Constraints. */
  struct Collection *constraints;

  char _pad[4];
  /** Last frame world was evaluated for (internal). */
  float ltime;

  /** This pointer is shared between all evaluated copies. */
  struct RigidBodyWorld_Shared *shared;
  /** Moved to `shared->pointcache`. */
  struct PointCache *pointcache DNA_DEPRECATED;
  /** Moved to `shared->ptcaches`. */
  struct ListBase ptcaches DNA_DEPRECATED;
  /** Number of objects in rigid body group. */
  int numbodies;

  /** Number of simulation sub-steps steps taken per frame. */
  short substeps_per_frame;
  /** Number of constraint solver iterations made per simulation step. */
  short num_solver_iterations;

  /** (#eRigidBodyWorld_Flag) settings for this RigidBodyWorld. */
  int flag;
  /** Used to speed up or slow down the simulation. */
  float time_scale;
} RigidBodyWorld;

/** RigidBodyWorld.flag */
typedef enum eRigidBodyWorld_Flag {
  /* should sim world be skipped when evaluating (user setting) */
  RBW_FLAG_MUTED = (1 << 0),
  /* sim data needs to be rebuilt */
  /* RBW_FLAG_NEEDS_REBUILD = (1 << 1), */ /* UNUSED */
  /** Use split impulse when stepping the simulation. */
  RBW_FLAG_USE_SPLIT_IMPULSE = (1 << 2),
} eRigidBodyWorld_Flag;

/* ******************************** */
/* RigidBody Object */

/* Container for data that is shared among CoW copies.
 *
 * This is placed in a separate struct so that, for example, the physics_shape
 * pointer can be replaced without having to update all CoW copies. */
#
#
typedef struct RigidBodyOb_Shared {
  /* References to Physics Sim objects. Exist at runtime only */
  /** Physics object representation (i.e. btRigidBody). */
  void *physics_object;
  /** Collision shape used by physics sim (i.e. btCollisionShape). */
  void *physics_shape;
} RigidBodyOb_Shared;

/* RigidBodyObject (rbo)
 *
 * Represents an object participating in a RigidBody sim.
 * This is attached to each object that is currently
 * participating in a sim.
 */
typedef struct RigidBodyOb {
  /* General Settings for this RigidBodyOb */
  /** (eRigidBodyOb_Type) role of RigidBody in sim. */
  short type;
  /** (eRigidBody_Shape) collision shape to use. */
  short shape;

  /** (eRigidBodyOb_Flag). */
  int flag;
  /** Collision groups that determines which rigid bodies can collide with each other. */
  int col_groups;
  /** (eRigidBody_MeshSource) mesh source for mesh based collision shapes. */
  short mesh_source;
  char _pad[2];

  /* Physics Parameters */
  /** How much object 'weighs' (i.e. absolute 'amount of stuff' it holds). */
  float mass;

  /** Resistance of object to movement. */
  float friction;
  /** How 'bouncy' object is when it collides. */
  float restitution;

  /** Tolerance for detecting collisions. */
  float margin;

  /** Damping for linear velocities. */
  float lin_damping;
  /** Damping for angular velocities. */
  float ang_damping;

  /** Deactivation threshold for linear velocities. */
  float lin_sleep_thresh;
  /** Deactivation threshold for angular velocities. */
  float ang_sleep_thresh;

  /** Rigid body orientation. */
  float orn[4];
  /** Rigid body position. */
  float pos[3];
  char _pad1[4];

  /** This pointer is shared between all evaluated copies. */
  struct RigidBodyOb_Shared *shared;
} RigidBodyOb;

/** #RigidBodyOb.type */
typedef enum eRigidBodyOb_Type {
  /* active geometry participant in simulation. is directly controlled by sim */
  RBO_TYPE_ACTIVE = 0,
  /* passive geometry participant in simulation. is directly controlled by animsys */
  RBO_TYPE_PASSIVE = 1,
} eRigidBodyOb_Type;

/** #RigidBodyOb.flag */
typedef enum eRigidBodyOb_Flag {
  /* rigidbody is kinematic (controlled by the animation system) */
  RBO_FLAG_KINEMATIC = (1 << 0),
  /* rigidbody needs to be validated (usually set after duplicating and not hooked up yet) */
  RBO_FLAG_NEEDS_VALIDATE = (1 << 1),
  /* rigidbody shape needs refreshing (usually after exiting editmode) */
  RBO_FLAG_NEEDS_RESHAPE = (1 << 2),
  /* rigidbody can be deactivated */
  RBO_FLAG_USE_DEACTIVATION = (1 << 3),
  /* rigidbody is deactivated at the beginning of simulation */
  RBO_FLAG_START_DEACTIVATED = (1 << 4),
  /* rigidbody is not dynamically simulated */
  RBO_FLAG_DISABLED = (1 << 5),
  /* collision margin is not embedded (only used by convex hull shapes for now) */
  RBO_FLAG_USE_MARGIN = (1 << 6),
  /* collision shape deforms during simulation (only for passive triangle mesh shapes) */
  RBO_FLAG_USE_DEFORM = (1 << 7),
} eRigidBodyOb_Flag;

/** Rigid Body Collision Shape. */
typedef enum eRigidBody_Shape {
  /** Simple box (i.e. bounding box). */
  RB_SHAPE_BOX = 0,
  /** Sphere. */
  RB_SHAPE_SPHERE = 1,
  /** Rounded "pill" shape (i.e. calcium tablets). */
  RB_SHAPE_CAPSULE = 2,
  /** Cylinder (i.e. tin of beans). */
  RB_SHAPE_CYLINDER = 3,
  /** Cone (i.e. party hat). */
  RB_SHAPE_CONE = 4,

  /** Convex hull (minimal shrink-wrap encompassing all verts). */
  RB_SHAPE_CONVEXH = 5,
  /** Triangulated mesh. */
  RB_SHAPE_TRIMESH = 6,

  /* concave mesh approximated using primitives */
  RB_SHAPE_COMPOUND = 7,
} eRigidBody_Shape;

typedef enum eRigidBody_MeshSource {
  /* base mesh */
  RBO_MESH_BASE = 0,
  /* only deformations */
  RBO_MESH_DEFORM = 1,
  /* final derived mesh */
  RBO_MESH_FINAL = 2,
} eRigidBody_MeshSource;

/* ******************************** */
/* RigidBody Constraint */

/* RigidBodyConstraint (rbc)
 *
 * Represents an constraint connecting two rigid bodies.
 */
typedef struct RigidBodyCon {
  /** First object influenced by the constraint. */
  struct Object *ob1;
  /** Second object influenced by the constraint. */
  struct Object *ob2;

  /* General Settings for this RigidBodyCon */
  /** (eRigidBodyCon_Type) role of RigidBody in sim. */
  short type;
  /** Number of constraint solver iterations made per simulation step. */
  short num_solver_iterations;

  /** (eRigidBodyCon_Flag). */
  int flag;

  /** Breaking impulse threshold. */
  float breaking_threshold;
  /** Spring implementation to use. */
  char spring_type;
  char _pad[3];

  /* limits */
  /* translation limits */
  float limit_lin_x_lower;
  float limit_lin_x_upper;
  float limit_lin_y_lower;
  float limit_lin_y_upper;
  float limit_lin_z_lower;
  float limit_lin_z_upper;
  /* rotation limits */
  float limit_ang_x_lower;
  float limit_ang_x_upper;
  float limit_ang_y_lower;
  float limit_ang_y_upper;
  float limit_ang_z_lower;
  float limit_ang_z_upper;

  /* spring settings */
  /* resistance to deformation */
  float spring_stiffness_x;
  float spring_stiffness_y;
  float spring_stiffness_z;
  float spring_stiffness_ang_x;
  float spring_stiffness_ang_y;
  float spring_stiffness_ang_z;
  /* amount of velocity lost over time */
  float spring_damping_x;
  float spring_damping_y;
  float spring_damping_z;
  float spring_damping_ang_x;
  float spring_damping_ang_y;
  float spring_damping_ang_z;

  /* motor settings */
  /** Linear velocity the motor tries to hold. */
  float motor_lin_target_velocity;
  /** Angular velocity the motor tries to hold. */
  float motor_ang_target_velocity;
  /** Maximum force used to reach linear target velocity. */
  float motor_lin_max_impulse;
  /** Maximum force used to reach angular target velocity. */
  float motor_ang_max_impulse;

  /* References to Physics Sim object. Exist at runtime only */
  /** Physics object representation (i.e. btTypedConstraint). */
  void *physics_constraint;
} RigidBodyCon;

/** Participation types for #RigidBodyOb.type */
typedef enum eRigidBodyCon_Type {
  /** lets bodies rotate around a specified point */
  RBC_TYPE_POINT = 0,
  /** lets bodies rotate around a specified axis */
  RBC_TYPE_HINGE = 1,
  /** simulates wheel suspension */
  /* RBC_TYPE_HINGE2 = 2, */ /* UNUSED */
  /** Restricts moment to a specified axis. */
  RBC_TYPE_SLIDER = 3,
  /** lets object rotate within a specified cone */
  /* RBC_TYPE_CONE_TWIST = 4, */ /* UNUSED */
  /** allows user to specify constraint axes */
  RBC_TYPE_6DOF = 5,
  /** like 6DOF but has springs */
  RBC_TYPE_6DOF_SPRING = 6,
  /** simulates a universal joint */
  /* RBC_TYPE_UNIVERSAL = 7, */ /* UNUSED */
  /** glues two bodies together */
  RBC_TYPE_FIXED = 8,
  /** similar to slider but also allows rotation around slider axis */
  RBC_TYPE_PISTON = 9,
  /** Simplified spring constraint with only once axis that's
   * automatically placed between the connected bodies */
  /* RBC_TYPE_SPRING = 10, */ /* UNUSED */
  /** Drives bodies by applying linear and angular forces. */
  RBC_TYPE_MOTOR = 11,
} eRigidBodyCon_Type;

/** Spring implementation type for RigidBodyOb. */
typedef enum eRigidBodyCon_SpringType {
  RBC_SPRING_TYPE1 = 0, /* btGeneric6DofSpringConstraint */
  RBC_SPRING_TYPE2 = 1, /* btGeneric6DofSpring2Constraint */
} eRigidBodyCon_SpringType;

/** #RigidBodyCon.flag */
typedef enum eRigidBodyCon_Flag {
  /* constraint influences rigid body motion */
  RBC_FLAG_ENABLED = (1 << 0),
  /* constraint needs to be validated */
  RBC_FLAG_NEEDS_VALIDATE = (1 << 1),
  /* allow constrained bodies to collide */
  RBC_FLAG_DISABLE_COLLISIONS = (1 << 2),
  /* constraint can break */
  RBC_FLAG_USE_BREAKING = (1 << 3),
  /* constraint use custom number of constraint solver iterations */
  RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS = (1 << 4),
  /* limits */
  RBC_FLAG_USE_LIMIT_LIN_X = (1 << 5),
  RBC_FLAG_USE_LIMIT_LIN_Y = (1 << 6),
  RBC_FLAG_USE_LIMIT_LIN_Z = (1 << 7),
  RBC_FLAG_USE_LIMIT_ANG_X = (1 << 8),
  RBC_FLAG_USE_LIMIT_ANG_Y = (1 << 9),
  RBC_FLAG_USE_LIMIT_ANG_Z = (1 << 10),
  /* springs */
  RBC_FLAG_USE_SPRING_X = (1 << 11),
  RBC_FLAG_USE_SPRING_Y = (1 << 12),
  RBC_FLAG_USE_SPRING_Z = (1 << 13),
  /* motors */
  RBC_FLAG_USE_MOTOR_LIN = (1 << 14),
  RBC_FLAG_USE_MOTOR_ANG = (1 << 15),
  /* angular springs */
  RBC_FLAG_USE_SPRING_ANG_X = (1 << 16),
  RBC_FLAG_USE_SPRING_ANG_Y = (1 << 17),
  RBC_FLAG_USE_SPRING_ANG_Z = (1 << 18),
} eRigidBodyCon_Flag;

/* ******************************** */

#ifdef __cplusplus
}
#endif