rigidBody property

ComponentSchema<RigidBody3D> get rigidBody

RigidBody3D: grouped, labelled and described as RigidBody2D is.

Implementation

static ComponentSchema<RigidBody3D>
get rigidBody => ComponentSchema<RigidBody3D>(
  type: 'RigidBody3D',
  id: 'rigid_body_3d_d3ff8994',
  create: RigidBody3D.new,
  hints: ComponentHints(
    dimensions: Dimensions.threeD,
    name: 'Rigid Body 3D',
    group: _group,
    description:
        'Simulates the entity: gravity, forces and collisions. Its shape is a Collider 3D.',
    icon: Icons.sports_basketball,
    accentColor: const Color(0xFFFF7043),
    fieldGroups: const {
      'Body': ['bodyType', 'mass', 'layer', 'isSensor'],
      'Surface': ['friction', 'restitution'],
      'Motion': [
        'gravityScale',
        'linearDamping',
        'angularDamping',
        'continuousCollision',
        'canSleep',
        'lockRotation',
        'initialVelocity',
        'initialAngularVelocity',
      ],
    },
    fields: {
      'bodyType': const FieldHint(
        label: 'Body type',
        description: PhysicsDefinitions2D.bodyTypeDescription,
      ),
      'mass': FieldHint(
        label: 'Mass',
        description:
            'How heavy it is, in kg; 0 works it out from the collider.',
        scrub: const ScrubHint(step: 0.5, fractionDigits: 1, suffix: 'kg'),
        visibleWhen: (c) => (c as RigidBody3D).bodyType == BodyType3D.dynamic,
      ),
      'layer': const FieldHint(
        label: 'Layer',
        description: PhysicsDefinitions2D.layerDescription,
      ),
      'isSensor': const FieldHint(
        label: 'Sensor',
        description: PhysicsDefinitions2D.sensorDescription,
      ),
      'friction': FieldHint(
        label: 'Friction',
        description: PhysicsDefinitions2D.frictionDescription,
        slider: true,
        scrub: _plain,
        visibleWhen: (c) => !(c as RigidBody3D).isSensor,
      ),
      'restitution': FieldHint(
        label: 'Bounciness',
        description: PhysicsDefinitions2D.restitutionDescription,
        slider: true,
        scrub: _plain,
        visibleWhen: (c) => !(c as RigidBody3D).isSensor,
      ),
      'gravityScale': FieldHint(
        label: 'Gravity scale',
        description: PhysicsDefinitions2D.gravityScaleDescription,
        scrub: const ScrubHint(step: 0.05, fractionDigits: 2, suffix: '×'),
        visibleWhen: (c) => (c as RigidBody3D).bodyType == BodyType3D.dynamic,
      ),
      'linearDamping': FieldHint(
        label: 'Linear damping',
        description: PhysicsDefinitions2D.linearDampingDescription,
        scrub: const ScrubHint(step: 0.05, fractionDigits: 2, suffix: '/s'),
        visibleWhen: (c) => (c as RigidBody3D).bodyType == BodyType3D.dynamic,
      ),
      'angularDamping': FieldHint(
        label: 'Angular damping',
        description: 'As linear damping, for its spin.',
        scrub: const ScrubHint(step: 0.05, fractionDigits: 2, suffix: '/s'),
        visibleWhen: (c) => (c as RigidBody3D).bodyType == BodyType3D.dynamic,
      ),
      'continuousCollision': FieldHint(
        label: 'Continuous',
        description: PhysicsDefinitions2D.continuousDescription,
        visibleWhen: (c) => (c as RigidBody3D).bodyType == BodyType3D.dynamic,
      ),
      'canSleep': FieldHint(
        label: 'Can sleep',
        description: PhysicsDefinitions2D.canSleepDescription,
        visibleWhen: (c) => (c as RigidBody3D).bodyType != BodyType3D.static,
      ),
      'lockRotation': FieldHint(
        label: 'Lock rotation',
        description: PhysicsDefinitions2D.lockRotationDescription,
        visibleWhen: (c) => (c as RigidBody3D).bodyType != BodyType3D.static,
      ),
      'initialVelocity': FieldHint(
        label: 'Start velocity',
        description:
            'The velocity it starts with, in m/s: a thrown crate, a platform already on its way.',
        visibleWhen: (c) => (c as RigidBody3D).bodyType != BodyType3D.static,
      ),
      'initialAngularVelocity': FieldHint(
        label: 'Start spin',
        description:
            'The spin it starts with, in radians per second about each axis.',
        visibleWhen: (c) => (c as RigidBody3D).bodyType != BodyType3D.static,
      ),
    },
  ),
  fields: [
    SchemaField(
      name: 'bodyType',
      kind: _bodyType,
      read: (c) => (c as RigidBody3D).bodyType,
      write: (c, v) => (c as RigidBody3D).bodyType = v as BodyType3D,
    ),
    _decimal<RigidBody3D>(
      'mass',
      (c) => c.mass,
      (c, v) => c.mass = v,
      min: 0,
    ),
    SchemaField(
      name: 'layer',
      kind: FieldTypes.physicsLayer,
      read: (c) => (c as RigidBody3D).layer,
      write: (c, v) => (c as RigidBody3D).layer = (v as num).toInt(),
    ),
    _bool<RigidBody3D>(
      'isSensor',
      (c) => c.isSensor,
      (c, v) => c.isSensor = v,
    ),
    _decimal<RigidBody3D>(
      'friction',
      (c) => c.friction,
      (c, v) => c.friction = v,
      min: 0,
    ),
    _decimal<RigidBody3D>(
      'restitution',
      (c) => c.restitution,
      (c, v) => c.restitution = v,
      min: 0,
      max: 1,
    ),
    _decimal<RigidBody3D>(
      'gravityScale',
      (c) => c.gravityScale,
      (c, v) => c.gravityScale = v,
    ),
    _decimal<RigidBody3D>(
      'linearDamping',
      (c) => c.linearDamping,
      (c, v) => c.linearDamping = v,
      min: 0,
    ),
    _decimal<RigidBody3D>(
      'angularDamping',
      (c) => c.angularDamping,
      (c, v) => c.angularDamping = v,
      min: 0,
    ),
    _bool<RigidBody3D>(
      'continuousCollision',
      (c) => c.continuousCollision,
      (c, v) => c.continuousCollision = v,
    ),
    _bool<RigidBody3D>(
      'canSleep',
      (c) => c.canSleep,
      (c, v) => c.canSleep = v,
    ),
    _bool<RigidBody3D>(
      'lockRotation',
      (c) => c.lockRotation,
      (c, v) => c.lockRotation = v,
    ),
    _vector<RigidBody3D>(
      'initialVelocity',
      (c) => c.initialVelocity,
      (c, v) => c.initialVelocity = v,
    ),
    _vector<RigidBody3D>(
      'initialAngularVelocity',
      (c) => c.initialAngularVelocity,
      (c, v) => c.initialAngularVelocity = v,
    ),
  ],
);