{
  "name": "BaseAnimationLoop",
  "main": {
    "name": "BaseAnimationLoop",
    "namespace": "sofa::core::behavior",
    "module": "Sofa.framework.Core",
    "include": "sofa/core/behavior/BaseAnimationLoop.h",
    "doc": "Component responsible for main animation algorithms, managing how\n and when mechanical computation happens in one animation step.\n This class can optionally replace the default computation scheme of computing\n collisions then doing an integration step.\n Note that it is in a preliminary stage, hence its functionalities and API will\n certainly change soon.",
    "inherits": [
      "BaseObject"
    ],
    "templates": [],
    "data_fields": [
      {
        "name": "d_computeBoundingBox",
        "type": "bool",
        "xmlname": "computeBoundingBox",
        "help": "If true, compute the global bounding box of the scene at each time step. Used mostly for rendering."
      }
    ],
    "links": [
      {
        "name": "l_node",
        "target": "BaseNode",
        "kind": "single",
        "xmlname": "targetNode",
        "help": "Link to the scene's node that will be processed by the loop"
      }
    ],
    "methods": [
      {
        "name": "toBaseAnimationLoop",
        "return_type": "const BaseAnimationLoop *",
        "params": [],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "storeResetState",
        "return_type": "void",
        "params": [],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "protected"
      },
      {
        "name": "init",
        "return_type": "void",
        "params": [],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "step",
        "return_type": "void",
        "params": [
          {
            "name": "params",
            "type": "const core::ExecParams *"
          },
          {
            "name": "dt",
            "type": "SReal"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": true,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "getResetTime",
        "return_type": "SReal",
        "params": [],
        "is_virtual": false,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "insertInNode",
        "return_type": "bool",
        "params": [
          {
            "name": "node",
            "type": "objectmodel::BaseNode *"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "removeInNode",
        "return_type": "bool",
        "params": [
          {
            "name": "node",
            "type": "objectmodel::BaseNode *"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      }
    ]
  },
  "desc": {
    "description": "The `BaseAnimationLoop` component is responsible for managing the main animation algorithms in SOFA, controlling how and when mechanical computations occur during an animation step. It provides an abstract framework that can optionally replace the default computation scheme which typically involves collision detection followed by integration steps.\n\n**Role and Purpose**: \n- Manages the sequence of computations within each time step, including collisions and integrations.\n- Abstract class meant to be inherited from to implement specific animation loop behaviors.\n- Provides methods for initialization (`init`), inserting into a node (`insertInNode`), and removing from a node (`removeInNode`).\n\n**Interactions with Other Components**: \n- Interfaces with `BaseNode`, which represents the scene's node being processed by the loop. The link to this node is stored in `l_node`. \n- Inherited from `BaseObject`.\n\n**Practical Usage Guidance and Data Fields**: \n- A primary method, `step`, defines how each animation step is computed but must be overridden by derived classes.\n- The `d_computeBoundingBox` data field (boolean) determines whether to compute the global bounding box of the scene at each time step. This is mostly used for rendering purposes."
  },
  "maths": {
    "maths": "The `BaseAnimationLoop` component in the SOFA framework is an abstract class that manages the sequence of computations within each time step, including collision detection and integration steps. Its primary purpose is to provide a flexible framework for implementing different animation loop behaviors.\n\n### Role and Purpose:\n- **Manages Computation Sequence**: The `step` method defines how each animation step is computed but must be overridden by derived classes. This allows customization of the computation sequence, such as integrating forces or resolving collisions.\n- **Initialization and Node Management**: Methods like `init`, `insertInNode`, and `removeInNode` handle the initialization and node management tasks within the scene graph. These methods ensure that the loop is correctly linked to the relevant parts of the simulation environment.\n\n### Mathematical and Physical Description:\n- The component does not directly involve specific mathematical equations or physical models on its own but serves as a control structure for integrating such computations.\n- It provides an interface for derived classes to implement time-stepping algorithms, which can include solving differential equations (e.g., integration of velocities and positions) and handling collision constraints.\n\n### Interaction with Other Components:\n- **BaseNode**: The component maintains a link (`l_node`) to the `BaseNode` representing the scene node being processed. This ensures that all computations are performed within the correct context.\n- **Inheritance from BaseObject**: It inherits from `BaseObject`, which provides generic object management functionalities in SOFA.\n\n### Practical Usage:\n- The `d_computeBoundingBox` data field (boolean) determines whether to compute the global bounding box of the scene at each time step, primarily used for rendering purposes. This does not directly impact the physical simulation but can be useful for visualization and debugging.\n\n### Key Methods:\n- **init()**: Initializes the loop, setting up necessary parameters and ensuring that the `l_node` is correctly linked to the node context if it is not already set.\n- **storeResetState()**: Saves the initial state of the simulation (e.g., starting time) for use in resetting the simulation later.\n- **getResetTime()**: Returns the reset time, which can be used to restart or pause the simulation from a specific point.\n\n### Conclusion:\n`BaseAnimationLoop` provides a foundational structure for managing and controlling the flow of computations within each animation step. It does not define the physical models or mathematical equations directly but ensures that these are executed in an appropriate sequence, allowing derived classes to implement various time-stepping algorithms tailored to specific simulation needs."
  },
  "summary": {
    "abstract": "Manages the sequence of computations within each animation step, including collision detection and integration steps, providing an abstract framework for implementing various animation loop behaviors.",
    "sheet": "# BaseAnimationLoop\n\n## Overview\nThe `BaseAnimationLoop` is an abstract component responsible for managing the main animation algorithms in SOFA. It controls how and when mechanical computations occur during each time step, including collision detection and integration steps. This class can optionally replace the default computation scheme.\n\n## Parameters and Data\n- **computeBoundingBox (bool)**: Determines whether to compute the global bounding box of the scene at each time step. Used mostly for rendering purposes. Default is `false`.\n\n## Dependencies and Connections\nThe component maintains a link (`l_node`) to the `BaseNode`, representing the scene node being processed. This ensures that all computations are performed within the correct context.\n\n## Practical Notes\n- The `step` method must be overridden by derived classes to define specific time-stepping algorithms.\n- The `d_computeBoundingBox` field is primarily used for rendering and does not directly impact physical simulation."
  }
}