DNA_rigidbody_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2013 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "DNA_listBase.h"
#include "DNA_object_force_types.h"
 
struct Collection;
 
struct EffectorWeights;
 
/* ******************************** */
/* RigidBody World */
 
typedef struct RigidBodyWorld_Shared {
  /* cache */
  struct PointCache *pointcache;
  struct ListBase ptcaches;
 
  /* References to Physics Sim objects. Exist at runtime only ---------------------- */
  void *physics_world;
} RigidBodyWorld_Shared;
 
/* RigidBodyWorld (rbw)
 *
 * Represents a "simulation scene" existing within the parent scene.
 */
typedef struct RigidBodyWorld {
  /* Sim World Settings ------------------------------------------------------------- */
  struct EffectorWeights *effector_weights;
 
  struct Collection *group;
  struct Object **objects;
 
  struct Collection *constraints;
 
  char _pad[4];
  float ltime;
 
  struct RigidBodyWorld_Shared *shared;
  struct PointCache *pointcache DNA_DEPRECATED;
  struct ListBase ptcaches DNA_DEPRECATED;
  int numbodies;
 
  short substeps_per_frame;
  short num_solver_iterations;
 
  int flag;
  float time_scale;
} RigidBodyWorld;
 
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 */
  RBW_FLAG_USE_SPLIT_IMPULSE = (1 << 2),
} eRigidBodyWorld_Flag;
 
/* ******************************** */
/* RigidBody Object */
 
/* Container for data that is shared among evaluated copies.
 *
 * This is placed in a separate struct so that, for example, the physics_shape
 * pointer can be replaced without having to update all evaluated copies. */
#
#
typedef struct RigidBodyOb_Shared {
  /* References to Physics Sim objects. Exist at runtime only */
  void *physics_object;
  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 */
  short type;
  short shape;
 
  int flag;
  int col_groups;
  short mesh_source;
  char _pad[2];
 
  /* Physics Parameters */
  float mass;
 
  float friction;
  float restitution;
 
  float margin;
 
  float lin_damping;
  float ang_damping;
 
  float lin_sleep_thresh;
  float ang_sleep_thresh;
 
  float orn[4];
  float pos[3];
  char _pad1[4];
 
  struct RigidBodyOb_Shared *shared;
} RigidBodyOb;
 
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;
 
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;
 
typedef enum eRigidBody_Shape {
  RB_SHAPE_BOX = 0,
  RB_SHAPE_SPHERE = 1,
  RB_SHAPE_CAPSULE = 2,
  RB_SHAPE_CYLINDER = 3,
  RB_SHAPE_CONE = 4,
 
  RB_SHAPE_CONVEXH = 5,
  RB_SHAPE_TRIMESH = 6,
 
  /* concave mesh approximated using primitives */
  RB_SHAPE_COMPOUND = 7,
} eRigidBody_Shape;
 
typedef enum eRigidBody_MeshSource {
  RBO_MESH_BASE = 0,
  RBO_MESH_DEFORM = 1,
  RBO_MESH_FINAL = 2,
} eRigidBody_MeshSource;
 
/* ******************************** */
/* RigidBody Constraint */
 
/* RigidBodyConstraint (rbc)
 *
 * Represents an constraint connecting two rigid bodies.
 */
typedef struct RigidBodyCon {
  struct Object *ob1;
  struct Object *ob2;
 
  /* General Settings for this RigidBodyCon */
  short type;
  short num_solver_iterations;
 
  int flag;
 
  float breaking_threshold;
  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 */
  float motor_lin_target_velocity;
  float motor_ang_target_velocity;
  float motor_lin_max_impulse;
  float motor_ang_max_impulse;
 
  /* References to Physics Sim object. Exist at runtime only */
  void *physics_constraint;
} RigidBodyCon;
 
typedef enum eRigidBodyCon_Type {
  RBC_TYPE_POINT = 0,
  RBC_TYPE_HINGE = 1,
  /* RBC_TYPE_HINGE2 = 2, */ /* UNUSED */
  RBC_TYPE_SLIDER = 3,
  /* RBC_TYPE_CONE_TWIST = 4, */ /* UNUSED */
  RBC_TYPE_6DOF = 5,
  RBC_TYPE_6DOF_SPRING = 6,
  /* RBC_TYPE_UNIVERSAL = 7, */ /* UNUSED */
  RBC_TYPE_FIXED = 8,
  RBC_TYPE_PISTON = 9,
  /* RBC_TYPE_SPRING = 10, */ /* UNUSED */
  RBC_TYPE_MOTOR = 11,
} eRigidBodyCon_Type;
 
typedef enum eRigidBodyCon_SpringType {
  RBC_SPRING_TYPE1 = 0, /* btGeneric6DofSpringConstraint */
  RBC_SPRING_TYPE2 = 1, /* btGeneric6DofSpring2Constraint */
} eRigidBodyCon_SpringType;
 
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;
 
/* ******************************** */