// Copyright 2022 DeepMind Technologies Limited // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // DO NOT EDIT. THIS FILE IS AUTOMATICALLY GENERATED. // Error: C reference not found // NOLINTBEGIN typedef enum mjtState_ { // state elements mjSTATE_TIME = 1<<0, // time mjSTATE_QPOS = 1<<1, // position mjSTATE_QVEL = 1<<2, // velocity mjSTATE_ACT = 1<<3, // actuator activation mjSTATE_WARMSTART = 1<<4, // acceleration used for warmstart mjSTATE_CTRL = 1<<5, // control mjSTATE_QFRC_APPLIED = 1<<6, // applied generalized force mjSTATE_XFRC_APPLIED = 1<<7, // applied Cartesian force/torque mjSTATE_EQ_ACTIVE = 1<<8, // enable/disable constraints mjSTATE_MOCAP_POS = 1<<9, // positions of mocap bodies mjSTATE_MOCAP_QUAT = 1<<10, // orientations of mocap bodies mjSTATE_USERDATA = 1<<11, // user data mjSTATE_PLUGIN = 1<<12, // plugin state mjNSTATE = 13, // number of state elements // convenience values for commonly used state specifications mjSTATE_PHYSICS = mjSTATE_QPOS | mjSTATE_QVEL | mjSTATE_ACT, mjSTATE_FULLPHYSICS = mjSTATE_TIME | mjSTATE_PHYSICS | mjSTATE_PLUGIN, mjSTATE_USER = mjSTATE_CTRL | mjSTATE_QFRC_APPLIED | mjSTATE_XFRC_APPLIED | mjSTATE_EQ_ACTIVE | mjSTATE_MOCAP_POS | mjSTATE_MOCAP_QUAT | mjSTATE_USERDATA, mjSTATE_INTEGRATION = mjSTATE_FULLPHYSICS | mjSTATE_USER | mjSTATE_WARMSTART } mjtState; typedef enum mjtWarning_ { // warning types mjWARN_INERTIA = 0, // (near) singular inertia matrix mjWARN_CONTACTFULL, // too many contacts in contact list mjWARN_CNSTRFULL, // too many constraints mjWARN_VGEOMFULL, // too many visual geoms mjWARN_BADQPOS, // bad number in qpos mjWARN_BADQVEL, // bad number in qvel mjWARN_BADQACC, // bad number in qacc mjWARN_BADCTRL, // bad number in ctrl mjNWARNING // number of warnings } mjtWarning; typedef enum mjtTimer_ { // internal timers // main api mjTIMER_STEP = 0, // step mjTIMER_FORWARD, // forward mjTIMER_INVERSE, // inverse // breakdown of step/forward mjTIMER_POSITION, // fwdPosition mjTIMER_VELOCITY, // fwdVelocity mjTIMER_ACTUATION, // fwdActuation mjTIMER_CONSTRAINT, // fwdConstraint mjTIMER_ADVANCE, // mj_Euler, mj_implicit // breakdown of fwdPosition mjTIMER_POS_KINEMATICS, // kinematics, com, tendon, transmission mjTIMER_POS_INERTIA, // inertia computations mjTIMER_POS_COLLISION, // collision detection mjTIMER_POS_MAKE, // make constraints mjTIMER_POS_PROJECT, // project constraints // breakdown of mj_collision mjTIMER_COL_BROAD, // broadphase mjTIMER_COL_NARROW, // narrowphase mjNTIMER // number of timers } mjtTimer; struct mjContact_ { // result of collision detection functions // contact parameters set by near-phase collision function mjtNum dist; // distance between nearest points; neg: penetration mjtNum pos[3]; // position of contact point: midpoint between geoms mjtNum frame[9]; // normal is in [0-2], points from geom[0] to geom[1] // contact parameters set by mj_collideGeoms mjtNum includemargin; // include if distplugin, required for deletion (nplugin x 1) uintptr_t* plugin_data; // pointer to plugin-managed data structure (nplugin x 1) //-------------------- POSITION dependent // computed by mj_fwdPosition/mj_kinematics mjtNum* xpos; // Cartesian position of body frame (nbody x 3) mjtNum* xquat; // Cartesian orientation of body frame (nbody x 4) mjtNum* xmat; // Cartesian orientation of body frame (nbody x 9) mjtNum* xipos; // Cartesian position of body com (nbody x 3) mjtNum* ximat; // Cartesian orientation of body inertia (nbody x 9) mjtNum* xanchor; // Cartesian position of joint anchor (njnt x 3) mjtNum* xaxis; // Cartesian joint axis (njnt x 3) mjtNum* geom_xpos; // Cartesian geom position (ngeom x 3) mjtNum* geom_xmat; // Cartesian geom orientation (ngeom x 9) mjtNum* site_xpos; // Cartesian site position (nsite x 3) mjtNum* site_xmat; // Cartesian site orientation (nsite x 9) mjtNum* cam_xpos; // Cartesian camera position (ncam x 3) mjtNum* cam_xmat; // Cartesian camera orientation (ncam x 9) mjtNum* light_xpos; // Cartesian light position (nlight x 3) mjtNum* light_xdir; // Cartesian light direction (nlight x 3) // computed by mj_fwdPosition/mj_comPos mjtNum* subtree_com; // center of mass of each subtree (nbody x 3) mjtNum* cdof; // com-based motion axis of each dof (rot:lin) (nv x 6) mjtNum* cinert; // com-based body inertia and mass (nbody x 10) // computed by mj_fwdPosition/mj_flex mjtNum* flexvert_xpos; // Cartesian flex vertex positions (nflexvert x 3) mjtNum* flexelem_aabb; // flex element bounding boxes (center, size) (nflexelem x 6) int* flexedge_J_rownnz; // number of non-zeros in Jacobian row (nflexedge x 1) int* flexedge_J_rowadr; // row start address in colind array (nflexedge x 1) int* flexedge_J_colind; // column indices in sparse Jacobian (nflexedge x nv) mjtNum* flexedge_J; // flex edge Jacobian (nflexedge x nv) mjtNum* flexedge_length; // flex edge lengths (nflexedge x 1) // computed by mj_fwdPosition/mj_tendon int* ten_wrapadr; // start address of tendon's path (ntendon x 1) int* ten_wrapnum; // number of wrap points in path (ntendon x 1) int* ten_J_rownnz; // number of non-zeros in Jacobian row (ntendon x 1) int* ten_J_rowadr; // row start address in colind array (ntendon x 1) int* ten_J_colind; // column indices in sparse Jacobian (ntendon x nv) mjtNum* ten_J; // tendon Jacobian (ntendon x nv) mjtNum* ten_length; // tendon lengths (ntendon x 1) int* wrap_obj; // geom id; -1: site; -2: pulley (nwrap x 2) mjtNum* wrap_xpos; // Cartesian 3D points in all paths (nwrap x 6) // computed by mj_fwdPosition/mj_transmission mjtNum* actuator_length; // actuator lengths (nu x 1) int* moment_rownnz; // number of non-zeros in actuator_moment row (nu x 1) int* moment_rowadr; // row start address in colind array (nu x 1) int* moment_colind; // column indices in sparse Jacobian (nJmom x 1) mjtNum* actuator_moment; // actuator moments (nJmom x 1) // computed by mj_fwdPosition/mj_makeM mjtNum* crb; // com-based composite inertia and mass (nbody x 10) mjtNum* qM; // inertia (sparse) (nM x 1) mjtNum* M; // reduced inertia (compressed sparse row) (nC x 1) // computed by mj_fwdPosition/mj_factorM mjtNum* qLD; // L'*D*L factorization of M (sparse) (nC x 1) mjtNum* qLDiagInv; // 1/diag(D) (nv x 1) // computed by mj_collisionTree mjtNum* bvh_aabb_dyn; // global bounding box (center, size) (nbvhdynamic x 6) mjtByte* bvh_active; // was bounding volume checked for collision (nbvh x 1) //-------------------- POSITION, VELOCITY dependent // computed by mj_fwdVelocity mjtNum* flexedge_velocity; // flex edge velocities (nflexedge x 1) mjtNum* ten_velocity; // tendon velocities (ntendon x 1) mjtNum* actuator_velocity; // actuator velocities (nu x 1) // computed by mj_fwdVelocity/mj_comVel mjtNum* cvel; // com-based velocity (rot:lin) (nbody x 6) mjtNum* cdof_dot; // time-derivative of cdof (rot:lin) (nv x 6) // computed by mj_fwdVelocity/mj_rne (without acceleration) mjtNum* qfrc_bias; // C(qpos,qvel) (nv x 1) // computed by mj_fwdVelocity/mj_passive mjtNum* qfrc_spring; // passive spring force (nv x 1) mjtNum* qfrc_damper; // passive damper force (nv x 1) mjtNum* qfrc_gravcomp; // passive gravity compensation force (nv x 1) mjtNum* qfrc_fluid; // passive fluid force (nv x 1) mjtNum* qfrc_passive; // total passive force (nv x 1) // computed by mj_sensorVel/mj_subtreeVel if needed mjtNum* subtree_linvel; // linear velocity of subtree com (nbody x 3) mjtNum* subtree_angmom; // angular momentum about subtree com (nbody x 3) // computed by mj_Euler or mj_implicit mjtNum* qH; // L'*D*L factorization of modified M (nC x 1) mjtNum* qHDiagInv; // 1/diag(D) of modified M (nv x 1) // computed by mj_resetData int* B_rownnz; // body-dof: non-zeros in each row (nbody x 1) int* B_rowadr; // body-dof: address of each row in B_colind (nbody x 1) int* B_colind; // body-dof: column indices of non-zeros (nB x 1) int* M_rownnz; // reduced inertia: non-zeros in each row (nv x 1) int* M_rowadr; // reduced inertia: address of each row in M_colind (nv x 1) int* M_colind; // reduced inertia: column indices of non-zeros (nC x 1) int* mapM2M; // index mapping from qM to M (nC x 1) int* D_rownnz; // full inertia: non-zeros in each row (nv x 1) int* D_rowadr; // full inertia: address of each row in D_colind (nv x 1) int* D_diag; // full inertia: index of diagonal element (nv x 1) int* D_colind; // full inertia: column indices of non-zeros (nD x 1) int* mapM2D; // index mapping from qM to D (nD x 1) int* mapD2M; // index mapping from D to qM (nM x 1) // computed by mj_implicit/mj_derivative mjtNum* qDeriv; // d (passive + actuator - bias) / d qvel (nD x 1) // computed by mj_implicit/mju_factorLUSparse mjtNum* qLU; // sparse LU of (qM - dt*qDeriv) (nD x 1) //-------------------- POSITION, VELOCITY, CONTROL/ACCELERATION dependent // computed by mj_fwdActuation mjtNum* actuator_force; // actuator force in actuation space (nu x 1) mjtNum* qfrc_actuator; // actuator force (nv x 1) // computed by mj_fwdAcceleration mjtNum* qfrc_smooth; // net unconstrained force (nv x 1) mjtNum* qacc_smooth; // unconstrained acceleration (nv x 1) // computed by mj_fwdConstraint/mj_inverse mjtNum* qfrc_constraint; // constraint force (nv x 1) // computed by mj_inverse mjtNum* qfrc_inverse; // net external force; should equal: // qfrc_applied + J'*xfrc_applied + qfrc_actuator (nv x 1) // computed by mj_sensorAcc/mj_rnePostConstraint if needed; rotation:translation format mjtNum* cacc; // com-based acceleration (nbody x 6) mjtNum* cfrc_int; // com-based interaction force with parent (nbody x 6) mjtNum* cfrc_ext; // com-based external force on body (nbody x 6) //-------------------- arena-allocated: POSITION dependent // computed by mj_collision mjContact* contact; // array of all detected contacts (ncon x 1) // computed by mj_makeConstraint int* efc_type; // constraint type (mjtConstraint) (nefc x 1) int* efc_id; // id of object of specified type (nefc x 1) int* efc_J_rownnz; // number of non-zeros in constraint Jacobian row (nefc x 1) int* efc_J_rowadr; // row start address in colind array (nefc x 1) int* efc_J_rowsuper; // number of subsequent rows in supernode (nefc x 1) int* efc_J_colind; // column indices in constraint Jacobian (nJ x 1) int* efc_JT_rownnz; // number of non-zeros in constraint Jacobian row T (nv x 1) int* efc_JT_rowadr; // row start address in colind array T (nv x 1) int* efc_JT_rowsuper; // number of subsequent rows in supernode T (nv x 1) int* efc_JT_colind; // column indices in constraint Jacobian T (nJ x 1) mjtNum* efc_J; // constraint Jacobian (nJ x 1) mjtNum* efc_JT; // constraint Jacobian transposed (nJ x 1) mjtNum* efc_pos; // constraint position (equality, contact) (nefc x 1) mjtNum* efc_margin; // inclusion margin (contact) (nefc x 1) mjtNum* efc_frictionloss; // frictionloss (friction) (nefc x 1) mjtNum* efc_diagApprox; // approximation to diagonal of A (nefc x 1) mjtNum* efc_KBIP; // stiffness, damping, impedance, imp' (nefc x 4) mjtNum* efc_D; // constraint mass (nefc x 1) mjtNum* efc_R; // inverse constraint mass (nefc x 1) int* tendon_efcadr; // first efc address involving tendon; -1: none (ntendon x 1) // computed by mj_island (island dof structure) int* dof_island; // island id of this dof; -1: none (nv x 1) int* island_nv; // number of dofs in this island (nisland x 1) int* island_idofadr; // island start address in idof vector (nisland x 1) int* island_dofadr; // island start address in dof vector (nisland x 1) int* map_dof2idof; // map from dof to idof (nv x 1) int* map_idof2dof; // map from idof to dof; >= nidof: unconstrained (nv x 1) // computed by mj_island (dofs sorted by island) mjtNum* ifrc_smooth; // net unconstrained force (nidof x 1) mjtNum* iacc_smooth; // unconstrained acceleration (nidof x 1) int* iM_rownnz; // inertia: non-zeros in each row (nidof x 1) int* iM_rowadr; // inertia: address of each row in iM_colind (nidof x 1) int* iM_colind; // inertia: column indices of non-zeros (nC x 1) mjtNum* iM; // total inertia (sparse) (nC x 1) mjtNum* iLD; // L'*D*L factorization of M (sparse) (nC x 1) mjtNum* iLDiagInv; // 1/diag(D) (nidof x 1) mjtNum* iacc; // acceleration (nidof x 1) // computed by mj_island (island constraint structure) int* efc_island; // island id of this constraint (nefc x 1) int* island_ne; // number of equality constraints in island (nisland x 1) int* island_nf; // number of friction constraints in island (nisland x 1) int* island_nefc; // number of constraints in island (nisland x 1) int* island_iefcadr; // start address in iefc vector (nisland x 1) int* map_efc2iefc; // map from efc to iefc (nefc x 1) int* map_iefc2efc; // map from iefc to efc (nefc x 1) // computed by mj_island (constraints sorted by island) int* iefc_type; // constraint type (mjtConstraint) (nefc x 1) int* iefc_id; // id of object of specified type (nefc x 1) int* iefc_J_rownnz; // number of non-zeros in constraint Jacobian row (nefc x 1) int* iefc_J_rowadr; // row start address in colind array (nefc x 1) int* iefc_J_rowsuper; // number of subsequent rows in supernode (nefc x 1) int* iefc_J_colind; // column indices in constraint Jacobian (nJ x 1) int* iefc_JT_rownnz; // number of non-zeros in constraint Jacobian row T (nidof x 1) int* iefc_JT_rowadr; // row start address in colind array T (nidof x 1) int* iefc_JT_rowsuper; // number of subsequent rows in supernode T (nidof x 1) int* iefc_JT_colind; // column indices in constraint Jacobian T (nJ x 1) mjtNum* iefc_J; // constraint Jacobian (nJ x 1) mjtNum* iefc_JT; // constraint Jacobian transposed (nJ x 1) mjtNum* iefc_frictionloss; // frictionloss (friction) (nefc x 1) mjtNum* iefc_D; // constraint mass (nefc x 1) mjtNum* iefc_R; // inverse constraint mass (nefc x 1) // computed by mj_projectConstraint (PGS solver) int* efc_AR_rownnz; // number of non-zeros in AR (nefc x 1) int* efc_AR_rowadr; // row start address in colind array (nefc x 1) int* efc_AR_colind; // column indices in sparse AR (nA x 1) mjtNum* efc_AR; // J*inv(M)*J' + R (nA x 1) //-------------------- arena-allocated: POSITION, VELOCITY dependent // computed by mj_fwdVelocity/mj_referenceConstraint mjtNum* efc_vel; // velocity in constraint space: J*qvel (nefc x 1) mjtNum* efc_aref; // reference pseudo-acceleration (nefc x 1) //-------------------- arena-allocated: POSITION, VELOCITY, CONTROL/ACCELERATION dependent // computed by mj_fwdConstraint/mj_inverse mjtNum* efc_b; // linear cost term: J*qacc_smooth - aref (nefc x 1) mjtNum* iefc_aref; // reference pseudo-acceleration (nefc x 1) int* iefc_state; // constraint state (mjtConstraintState) (nefc x 1) mjtNum* iefc_force; // constraint force in constraint space (nefc x 1) int* efc_state; // constraint state (mjtConstraintState) (nefc x 1) mjtNum* efc_force; // constraint force in constraint space (nefc x 1) mjtNum* ifrc_constraint; // constraint force (nidof x 1) // thread pool pointer uintptr_t threadpool; // compilation signature uint64_t signature; // also held by the mjSpec that compiled the model }; typedef struct mjData_ mjData; typedef enum mjtDisableBit_ { // disable default feature bitflags mjDSBL_CONSTRAINT = 1<<0, // entire constraint solver mjDSBL_EQUALITY = 1<<1, // equality constraints mjDSBL_FRICTIONLOSS = 1<<2, // joint and tendon frictionloss constraints mjDSBL_LIMIT = 1<<3, // joint and tendon limit constraints mjDSBL_CONTACT = 1<<4, // contact constraints mjDSBL_PASSIVE = 1<<5, // passive forces mjDSBL_GRAVITY = 1<<6, // gravitational forces mjDSBL_CLAMPCTRL = 1<<7, // clamp control to specified range mjDSBL_WARMSTART = 1<<8, // warmstart constraint solver mjDSBL_FILTERPARENT = 1<<9, // remove collisions with parent body mjDSBL_ACTUATION = 1<<10, // apply actuation forces mjDSBL_REFSAFE = 1<<11, // integrator safety: make ref[0]>=2*timestep mjDSBL_SENSOR = 1<<12, // sensors mjDSBL_MIDPHASE = 1<<13, // mid-phase collision filtering mjDSBL_EULERDAMP = 1<<14, // implicit integration of joint damping in Euler integrator mjDSBL_AUTORESET = 1<<15, // automatic reset when numerical issues are detected mjDSBL_NATIVECCD = 1<<16, // native convex collision detection mjNDISABLE = 17 // number of disable flags } mjtDisableBit; typedef enum mjtEnableBit_ { // enable optional feature bitflags mjENBL_OVERRIDE = 1<<0, // override contact parameters mjENBL_ENERGY = 1<<1, // energy computation mjENBL_FWDINV = 1<<2, // record solver statistics mjENBL_INVDISCRETE = 1<<3, // discrete-time inverse dynamics // experimental features: mjENBL_MULTICCD = 1<<4, // multi-point convex collision detection mjENBL_ISLAND = 1<<5, // constraint island discovery mjNENABLE = 6 // number of enable flags } mjtEnableBit; typedef enum mjtJoint_ { // type of degree of freedom mjJNT_FREE = 0, // global position and orientation (quat) (7) mjJNT_BALL, // orientation (quat) relative to parent (4) mjJNT_SLIDE, // sliding distance along body-fixed axis (1) mjJNT_HINGE // rotation angle (rad) around body-fixed axis (1) } mjtJoint; typedef enum mjtGeom_ { // type of geometric shape // regular geom types mjGEOM_PLANE = 0, // plane mjGEOM_HFIELD, // height field mjGEOM_SPHERE, // sphere mjGEOM_CAPSULE, // capsule mjGEOM_ELLIPSOID, // ellipsoid mjGEOM_CYLINDER, // cylinder mjGEOM_BOX, // box mjGEOM_MESH, // mesh mjGEOM_SDF, // signed distance field mjNGEOMTYPES, // number of regular geom types // rendering-only geom types: not used in mjModel, not counted in mjNGEOMTYPES mjGEOM_ARROW = 100, // arrow mjGEOM_ARROW1, // arrow without wedges mjGEOM_ARROW2, // arrow in both directions mjGEOM_LINE, // line mjGEOM_LINEBOX, // box with line edges mjGEOM_FLEX, // flex mjGEOM_SKIN, // skin mjGEOM_LABEL, // text label mjGEOM_TRIANGLE, // triangle mjGEOM_NONE = 1001 // missing geom type } mjtGeom; typedef enum mjtCamLight_ { // tracking mode for camera and light mjCAMLIGHT_FIXED = 0, // pos and rot fixed in body mjCAMLIGHT_TRACK, // pos tracks body, rot fixed in global mjCAMLIGHT_TRACKCOM, // pos tracks subtree com, rot fixed in body mjCAMLIGHT_TARGETBODY, // pos fixed in body, rot tracks target body mjCAMLIGHT_TARGETBODYCOM // pos fixed in body, rot tracks target subtree com } mjtCamLight; typedef enum mjtLightType_ { // type of light mjLIGHT_SPOT = 0, // spot mjLIGHT_DIRECTIONAL, // directional mjLIGHT_POINT, // point mjLIGHT_IMAGE, // image-based } mjtLightType; typedef enum mjtTexture_ { // type of texture mjTEXTURE_2D = 0, // 2d texture, suitable for planes and hfields mjTEXTURE_CUBE, // cube texture, suitable for all other geom types mjTEXTURE_SKYBOX // cube texture used as skybox } mjtTexture; typedef enum mjtTextureRole_ { // role of texture map in rendering mjTEXROLE_USER = 0, // unspecified mjTEXROLE_RGB, // base color (albedo) mjTEXROLE_OCCLUSION, // ambient occlusion mjTEXROLE_ROUGHNESS, // roughness mjTEXROLE_METALLIC, // metallic mjTEXROLE_NORMAL, // normal (bump) map mjTEXROLE_OPACITY, // transperancy mjTEXROLE_EMISSIVE, // light emission mjTEXROLE_RGBA, // base color, opacity mjTEXROLE_ORM, // occlusion, roughness, metallic mjNTEXROLE } mjtTextureRole; typedef enum mjtColorSpace_ { // type of color space encoding mjCOLORSPACE_AUTO = 0, // attempts to autodetect color space, defaults to linear mjCOLORSPACE_LINEAR, // linear color space mjCOLORSPACE_SRGB // standard RGB color space } mjtColorSpace; typedef enum mjtIntegrator_ { // integrator mode mjINT_EULER = 0, // semi-implicit Euler mjINT_RK4, // 4th-order Runge Kutta mjINT_IMPLICIT, // implicit in velocity mjINT_IMPLICITFAST // implicit in velocity, no rne derivative } mjtIntegrator; typedef enum mjtCone_ { // type of friction cone mjCONE_PYRAMIDAL = 0, // pyramidal mjCONE_ELLIPTIC // elliptic } mjtCone; typedef enum mjtJacobian_ { // type of constraint Jacobian mjJAC_DENSE = 0, // dense mjJAC_SPARSE, // sparse mjJAC_AUTO // dense if nv<60, sparse otherwise } mjtJacobian; typedef enum mjtSolver_ { // constraint solver algorithm mjSOL_PGS = 0, // PGS (dual) mjSOL_CG, // CG (primal) mjSOL_NEWTON // Newton (primal) } mjtSolver; typedef enum mjtEq_ { // type of equality constraint mjEQ_CONNECT = 0, // connect two bodies at a point (ball joint) mjEQ_WELD, // fix relative position and orientation of two bodies mjEQ_JOINT, // couple the values of two scalar joints with cubic mjEQ_TENDON, // couple the lengths of two tendons with cubic mjEQ_FLEX, // fix all edge lengths of a flex mjEQ_DISTANCE // unsupported, will cause an error if used } mjtEq; typedef enum mjtWrap_ { // type of tendon wrap object mjWRAP_NONE = 0, // null object mjWRAP_JOINT, // constant moment arm mjWRAP_PULLEY, // pulley used to split tendon mjWRAP_SITE, // pass through site mjWRAP_SPHERE, // wrap around sphere mjWRAP_CYLINDER // wrap around (infinite) cylinder } mjtWrap; typedef enum mjtTrn_ { // type of actuator transmission mjTRN_JOINT = 0, // force on joint mjTRN_JOINTINPARENT, // force on joint, expressed in parent frame mjTRN_SLIDERCRANK, // force via slider-crank linkage mjTRN_TENDON, // force on tendon mjTRN_SITE, // force on site mjTRN_BODY, // adhesion force on a body's geoms mjTRN_UNDEFINED = 1000 // undefined transmission type } mjtTrn; typedef enum mjtDyn_ { // type of actuator dynamics mjDYN_NONE = 0, // no internal dynamics; ctrl specifies force mjDYN_INTEGRATOR, // integrator: da/dt = u mjDYN_FILTER, // linear filter: da/dt = (u-a) / tau mjDYN_FILTEREXACT, // linear filter: da/dt = (u-a) / tau, with exact integration mjDYN_MUSCLE, // piece-wise linear filter with two time constants mjDYN_USER // user-defined dynamics type } mjtDyn; typedef enum mjtGain_ { // type of actuator gain mjGAIN_FIXED = 0, // fixed gain mjGAIN_AFFINE, // const + kp*length + kv*velocity mjGAIN_MUSCLE, // muscle FLV curve computed by mju_muscleGain() mjGAIN_USER // user-defined gain type } mjtGain; typedef enum mjtBias_ { // type of actuator bias mjBIAS_NONE = 0, // no bias mjBIAS_AFFINE, // const + kp*length + kv*velocity mjBIAS_MUSCLE, // muscle passive force computed by mju_muscleBias() mjBIAS_USER // user-defined bias type } mjtBias; typedef enum mjtObj_ { // type of MujoCo object mjOBJ_UNKNOWN = 0, // unknown object type mjOBJ_BODY, // body mjOBJ_XBODY, // body, used to access regular frame instead of i-frame mjOBJ_JOINT, // joint mjOBJ_DOF, // dof mjOBJ_GEOM, // geom mjOBJ_SITE, // site mjOBJ_CAMERA, // camera mjOBJ_LIGHT, // light mjOBJ_FLEX, // flex mjOBJ_MESH, // mesh mjOBJ_SKIN, // skin mjOBJ_HFIELD, // heightfield mjOBJ_TEXTURE, // texture mjOBJ_MATERIAL, // material for rendering mjOBJ_PAIR, // geom pair to include mjOBJ_EXCLUDE, // body pair to exclude mjOBJ_EQUALITY, // equality constraint mjOBJ_TENDON, // tendon mjOBJ_ACTUATOR, // actuator mjOBJ_SENSOR, // sensor mjOBJ_NUMERIC, // numeric mjOBJ_TEXT, // text mjOBJ_TUPLE, // tuple mjOBJ_KEY, // keyframe mjOBJ_PLUGIN, // plugin instance mjNOBJECT, // number of object types // meta elements, do not appear in mjModel mjOBJ_FRAME = 100, // frame mjOBJ_DEFAULT, // default mjOBJ_MODEL // entire model } mjtObj; typedef enum mjtConstraint_ { // type of constraint mjCNSTR_EQUALITY = 0, // equality constraint mjCNSTR_FRICTION_DOF, // dof friction mjCNSTR_FRICTION_TENDON, // tendon friction mjCNSTR_LIMIT_JOINT, // joint limit mjCNSTR_LIMIT_TENDON, // tendon limit mjCNSTR_CONTACT_FRICTIONLESS, // frictionless contact mjCNSTR_CONTACT_PYRAMIDAL, // frictional contact, pyramidal friction cone mjCNSTR_CONTACT_ELLIPTIC // frictional contact, elliptic friction cone } mjtConstraint; typedef enum mjtConstraintState_ { // constraint state mjCNSTRSTATE_SATISFIED = 0, // constraint satisfied, zero cost (limit, contact) mjCNSTRSTATE_QUADRATIC, // quadratic cost (equality, friction, limit, contact) mjCNSTRSTATE_LINEARNEG, // linear cost, negative side (friction) mjCNSTRSTATE_LINEARPOS, // linear cost, positive side (friction) mjCNSTRSTATE_CONE // squared distance to cone cost (elliptic contact) } mjtConstraintState; typedef enum mjtSensor_ { // type of sensor // common robotic sensors, attached to a site mjSENS_TOUCH = 0, // scalar contact normal forces summed over sensor zone mjSENS_ACCELEROMETER, // 3D linear acceleration, in local frame mjSENS_VELOCIMETER, // 3D linear velocity, in local frame mjSENS_GYRO, // 3D angular velocity, in local frame mjSENS_FORCE, // 3D force between site's body and its parent body mjSENS_TORQUE, // 3D torque between site's body and its parent body mjSENS_MAGNETOMETER, // 3D magnetometer mjSENS_RANGEFINDER, // scalar distance to nearest geom or site along z-axis mjSENS_CAMPROJECTION, // pixel coordinates of a site in the camera image // sensors related to scalar joints, tendons, actuators mjSENS_JOINTPOS, // scalar joint position (hinge and slide only) mjSENS_JOINTVEL, // scalar joint velocity (hinge and slide only) mjSENS_TENDONPOS, // scalar tendon position mjSENS_TENDONVEL, // scalar tendon velocity mjSENS_ACTUATORPOS, // scalar actuator position mjSENS_ACTUATORVEL, // scalar actuator velocity mjSENS_ACTUATORFRC, // scalar actuator force mjSENS_JOINTACTFRC, // scalar actuator force, measured at the joint mjSENS_TENDONACTFRC, // scalar actuator force, measured at the tendon // sensors related to ball joints mjSENS_BALLQUAT, // 4D ball joint quaternion mjSENS_BALLANGVEL, // 3D ball joint angular velocity // joint and tendon limit sensors, in constraint space mjSENS_JOINTLIMITPOS, // joint limit distance-margin mjSENS_JOINTLIMITVEL, // joint limit velocity mjSENS_JOINTLIMITFRC, // joint limit force mjSENS_TENDONLIMITPOS, // tendon limit distance-margin mjSENS_TENDONLIMITVEL, // tendon limit velocity mjSENS_TENDONLIMITFRC, // tendon limit force // sensors attached to an object with spatial frame: (x)body, geom, site, camera mjSENS_FRAMEPOS, // 3D position mjSENS_FRAMEQUAT, // 4D unit quaternion orientation mjSENS_FRAMEXAXIS, // 3D unit vector: x-axis of object's frame mjSENS_FRAMEYAXIS, // 3D unit vector: y-axis of object's frame mjSENS_FRAMEZAXIS, // 3D unit vector: z-axis of object's frame mjSENS_FRAMELINVEL, // 3D linear velocity mjSENS_FRAMEANGVEL, // 3D angular velocity mjSENS_FRAMELINACC, // 3D linear acceleration mjSENS_FRAMEANGACC, // 3D angular acceleration // sensors related to kinematic subtrees; attached to a body (which is the subtree root) mjSENS_SUBTREECOM, // 3D center of mass of subtree mjSENS_SUBTREELINVEL, // 3D linear velocity of subtree mjSENS_SUBTREEANGMOM, // 3D angular momentum of subtree // sensors of geometric relationships mjSENS_INSIDESITE, // 1 if object is inside a site, 0 otherwise mjSENS_GEOMDIST, // signed distance between two geoms mjSENS_GEOMNORMAL, // normal direction between two geoms mjSENS_GEOMFROMTO, // segment between two geoms // global sensors mjSENS_E_POTENTIAL, // potential energy mjSENS_E_KINETIC, // kinetic energy mjSENS_CLOCK, // simulation time // plugin-controlled sensors mjSENS_PLUGIN, // plugin-controlled // user-defined sensor mjSENS_USER // sensor data provided by mjcb_sensor callback } mjtSensor; typedef enum mjtStage_ { // computation stage mjSTAGE_NONE = 0, // no computations mjSTAGE_POS, // position-dependent computations mjSTAGE_VEL, // velocity-dependent computations mjSTAGE_ACC // acceleration/force-dependent computations } mjtStage; typedef enum mjtDataType_ { // data type for sensors mjDATATYPE_REAL = 0, // real values, no constraints mjDATATYPE_POSITIVE, // positive values; 0 or negative: inactive mjDATATYPE_AXIS, // 3D unit vector mjDATATYPE_QUATERNION // unit quaternion } mjtDataType; typedef enum mjtSameFrame_ { // frame alignment of bodies with their children mjSAMEFRAME_NONE = 0, // no alignment mjSAMEFRAME_BODY, // frame is same as body frame mjSAMEFRAME_INERTIA, // frame is same as inertial frame mjSAMEFRAME_BODYROT, // frame orientation is same as body orientation mjSAMEFRAME_INERTIAROT // frame orientation is same as inertia orientation } mjtSameFrame; typedef enum mjtLRMode_ { // mode for actuator length range computation mjLRMODE_NONE = 0, // do not process any actuators mjLRMODE_MUSCLE, // process muscle actuators mjLRMODE_MUSCLEUSER, // process muscle and user actuators mjLRMODE_ALL // process all actuators } mjtLRMode; typedef enum mjtFlexSelf_ { // mode for flex selfcollide mjFLEXSELF_NONE = 0, // no self-collisions mjFLEXSELF_NARROW, // skip midphase, go directly to narrowphase mjFLEXSELF_BVH, // use BVH in midphase (if midphase enabled) mjFLEXSELF_SAP, // use SAP in midphase mjFLEXSELF_AUTO // choose between BVH and SAP automatically } mjtFlexSelf; typedef enum mjtSDFType_ { // signed distance function (SDF) type mjSDFTYPE_SINGLE = 0, // single SDF mjSDFTYPE_INTERSECTION, // max(A, B) mjSDFTYPE_MIDSURFACE, // A - B mjSDFTYPE_COLLISION, // A + B + abs(max(A, B)) } mjtSDFType; struct mjLROpt_ { // options for mj_setLengthRange() // flags int mode; // which actuators to process (mjtLRMode) int useexisting; // use existing length range if available int uselimit; // use joint and tendon limits if available // algorithm parameters mjtNum accel; // target acceleration used to compute force mjtNum maxforce; // maximum force; 0: no limit mjtNum timeconst; // time constant for velocity reduction; min 0.01 mjtNum timestep; // simulation timestep; 0: use mjOption.timestep mjtNum inttotal; // total simulation time interval mjtNum interval; // evaluation time interval (at the end) mjtNum tolrange; // convergence tolerance (relative to range) }; typedef struct mjLROpt_ mjLROpt; struct mjVFS_ { // virtual file system for loading from memory void* impl_; // internal pointer to VFS memory }; typedef struct mjVFS_ mjVFS; struct mjOption_ { // physics options // timing parameters mjtNum timestep; // timestep mjtNum apirate; // update rate for remote API (Hz) // solver parameters mjtNum impratio; // ratio of friction-to-normal contact impedance mjtNum tolerance; // main solver tolerance mjtNum ls_tolerance; // CG/Newton linesearch tolerance mjtNum noslip_tolerance; // noslip solver tolerance mjtNum ccd_tolerance; // convex collision solver tolerance // physical constants mjtNum gravity[3]; // gravitational acceleration mjtNum wind[3]; // wind (for lift, drag and viscosity) mjtNum magnetic[3]; // global magnetic flux mjtNum density; // density of medium mjtNum viscosity; // viscosity of medium // override contact solver parameters (if enabled) mjtNum o_margin; // margin mjtNum o_solref[mjNREF]; // solref mjtNum o_solimp[mjNIMP]; // solimp mjtNum o_friction[5]; // friction // discrete settings int integrator; // integration mode (mjtIntegrator) int cone; // type of friction cone (mjtCone) int jacobian; // type of Jacobian (mjtJacobian) int solver; // solver algorithm (mjtSolver) int iterations; // maximum number of main solver iterations int ls_iterations; // maximum number of CG/Newton linesearch iterations int noslip_iterations; // maximum number of noslip solver iterations int ccd_iterations; // maximum number of convex collision solver iterations int disableflags; // bit flags for disabling standard features int enableflags; // bit flags for enabling optional features int disableactuator; // bit flags for disabling actuators by group id // sdf collision settings int sdf_initpoints; // number of starting points for gradient descent int sdf_iterations; // max number of iterations for gradient descent }; typedef struct mjOption_ mjOption; struct mjVisual_ { // visualization options struct { // global parameters int cameraid; // initial camera id (-1: free) int orthographic; // is the free camera orthographic (0: no, 1: yes) float fovy; // y field-of-view of free camera (orthographic ? length : degree) float ipd; // inter-pupilary distance for free camera float azimuth; // initial azimuth of free camera (degrees) float elevation; // initial elevation of free camera (degrees) float linewidth; // line width for wireframe and ray rendering float glow; // glow coefficient for selected body float realtime; // initial real-time factor (1: real time) int offwidth; // width of offscreen buffer int offheight; // height of offscreen buffer int ellipsoidinertia; // geom for inertia visualization (0: box, 1: ellipsoid) int bvactive; // visualize active bounding volumes (0: no, 1: yes) } global; struct { // rendering quality int shadowsize; // size of shadowmap texture int offsamples; // number of multisamples for offscreen rendering int numslices; // number of slices for builtin geom drawing int numstacks; // number of stacks for builtin geom drawing int numquads; // number of quads for box rendering } quality; struct { // head light float ambient[3]; // ambient rgb (alpha=1) float diffuse[3]; // diffuse rgb (alpha=1) float specular[3]; // specular rgb (alpha=1) int active; // is headlight active } headlight; struct { // mapping float stiffness; // mouse perturbation stiffness (space->force) float stiffnessrot; // mouse perturbation stiffness (space->torque) float force; // from force units to space units float torque; // from torque units to space units float alpha; // scale geom alphas when transparency is enabled float fogstart; // OpenGL fog starts at fogstart * mjModel.stat.extent float fogend; // OpenGL fog ends at fogend * mjModel.stat.extent float znear; // near clipping plane = znear * mjModel.stat.extent float zfar; // far clipping plane = zfar * mjModel.stat.extent float haze; // haze ratio float shadowclip; // directional light: shadowclip * mjModel.stat.extent float shadowscale; // spot light: shadowscale * light.cutoff float actuatortendon; // scale tendon width } map; struct { // scale of decor elements relative to mean body size float forcewidth; // width of force arrow float contactwidth; // contact width float contactheight; // contact height float connect; // autoconnect capsule width float com; // com radius float camera; // camera object float light; // light object float selectpoint; // selection point float jointlength; // joint length float jointwidth; // joint width float actuatorlength; // actuator length float actuatorwidth; // actuator width float framelength; // bodyframe axis length float framewidth; // bodyframe axis width float constraint; // constraint width float slidercrank; // slidercrank width float frustum; // frustum zfar plane } scale; struct { // color of decor elements float fog[4]; // fog float haze[4]; // haze float force[4]; // external force float inertia[4]; // inertia box float joint[4]; // joint float actuator[4]; // actuator, neutral float actuatornegative[4]; // actuator, negative limit float actuatorpositive[4]; // actuator, positive limit float com[4]; // center of mass float camera[4]; // camera object float light[4]; // light object float selectpoint[4]; // selection point float connect[4]; // auto connect float contactpoint[4]; // contact point float contactforce[4]; // contact force float contactfriction[4]; // contact friction force float contacttorque[4]; // contact torque float contactgap[4]; // contact point in gap float rangefinder[4]; // rangefinder ray float constraint[4]; // constraint float slidercrank[4]; // slidercrank float crankbroken[4]; // used when crank must be stretched/broken float frustum[4]; // camera frustum float bv[4]; // bounding volume float bvactive[4]; // active bounding volume } rgba; }; typedef struct mjVisual_ mjVisual; struct mjStatistic_ { // model statistics (in qpos0) mjtNum meaninertia; // mean diagonal inertia mjtNum meanmass; // mean body mass mjtNum meansize; // mean body size mjtNum extent; // spatial extent mjtNum center[3]; // center of model }; typedef struct mjStatistic_ mjStatistic; struct mjModel_ { // ------------------------------- sizes // sizes needed at mjModel construction int nq; // number of generalized coordinates = dim(qpos) int nv; // number of degrees of freedom = dim(qvel) int nu; // number of actuators/controls = dim(ctrl) int na; // number of activation states = dim(act) int nbody; // number of bodies int nbvh; // number of total bounding volumes in all bodies int nbvhstatic; // number of static bounding volumes (aabb stored in mjModel) int nbvhdynamic; // number of dynamic bounding volumes (aabb stored in mjData) int noct; // number of total octree cells in all meshes int njnt; // number of joints int ngeom; // number of geoms int nsite; // number of sites int ncam; // number of cameras int nlight; // number of lights int nflex; // number of flexes int nflexnode; // number of dofs in all flexes int nflexvert; // number of vertices in all flexes int nflexedge; // number of edges in all flexes int nflexelem; // number of elements in all flexes int nflexelemdata; // number of element vertex ids in all flexes int nflexelemedge; // number of element edge ids in all flexes int nflexshelldata; // number of shell fragment vertex ids in all flexes int nflexevpair; // number of element-vertex pairs in all flexes int nflextexcoord; // number of vertices with texture coordinates int nmesh; // number of meshes int nmeshvert; // number of vertices in all meshes int nmeshnormal; // number of normals in all meshes int nmeshtexcoord; // number of texcoords in all meshes int nmeshface; // number of triangular faces in all meshes int nmeshgraph; // number of ints in mesh auxiliary data int nmeshpoly; // number of polygons in all meshes int nmeshpolyvert; // number of vertices in all polygons int nmeshpolymap; // number of polygons in vertex map int nskin; // number of skins int nskinvert; // number of vertices in all skins int nskintexvert; // number of vertiex with texcoords in all skins int nskinface; // number of triangular faces in all skins int nskinbone; // number of bones in all skins int nskinbonevert; // number of vertices in all skin bones int nhfield; // number of heightfields int nhfielddata; // number of data points in all heightfields int ntex; // number of textures int ntexdata; // number of bytes in texture rgb data int nmat; // number of materials int npair; // number of predefined geom pairs int nexclude; // number of excluded geom pairs int neq; // number of equality constraints int ntendon; // number of tendons int nwrap; // number of wrap objects in all tendon paths int nsensor; // number of sensors int nnumeric; // number of numeric custom fields int nnumericdata; // number of mjtNums in all numeric fields int ntext; // number of text custom fields int ntextdata; // number of mjtBytes in all text fields int ntuple; // number of tuple custom fields int ntupledata; // number of objects in all tuple fields int nkey; // number of keyframes int nmocap; // number of mocap bodies int nplugin; // number of plugin instances int npluginattr; // number of chars in all plugin config attributes int nuser_body; // number of mjtNums in body_user int nuser_jnt; // number of mjtNums in jnt_user int nuser_geom; // number of mjtNums in geom_user int nuser_site; // number of mjtNums in site_user int nuser_cam; // number of mjtNums in cam_user int nuser_tendon; // number of mjtNums in tendon_user int nuser_actuator; // number of mjtNums in actuator_user int nuser_sensor; // number of mjtNums in sensor_user int nnames; // number of chars in all names int npaths; // number of chars in all paths // sizes set after mjModel construction int nnames_map; // number of slots in the names hash map int nM; // number of non-zeros in sparse inertia matrix int nB; // number of non-zeros in sparse body-dof matrix int nC; // number of non-zeros in sparse reduced dof-dof matrix int nD; // number of non-zeros in sparse dof-dof matrix int nJmom; // number of non-zeros in sparse actuator_moment matrix int ntree; // number of kinematic trees under world body int ngravcomp; // number of bodies with nonzero gravcomp int nemax; // number of potential equality-constraint rows int njmax; // number of available rows in constraint Jacobian (legacy) int nconmax; // number of potential contacts in contact list (legacy) int nuserdata; // number of mjtNums reserved for the user int nsensordata; // number of mjtNums in sensor data vector int npluginstate; // number of mjtNums in plugin state vector size_t narena; // number of bytes in the mjData arena (inclusive of stack) size_t nbuffer; // number of bytes in buffer // ------------------------------- options and statistics mjOption opt; // physics options mjVisual vis; // visualization options mjStatistic stat; // model statistics // ------------------------------- buffers // main buffer void* buffer; // main buffer; all pointers point in it (nbuffer) // default generalized coordinates mjtNum* qpos0; // qpos values at default pose (nq x 1) mjtNum* qpos_spring; // reference pose for springs (nq x 1) // bodies int* body_parentid; // id of body's parent (nbody x 1) int* body_rootid; // id of root above body (nbody x 1) int* body_weldid; // id of body that this body is welded to (nbody x 1) int* body_mocapid; // id of mocap data; -1: none (nbody x 1) int* body_jntnum; // number of joints for this body (nbody x 1) int* body_jntadr; // start addr of joints; -1: no joints (nbody x 1) int* body_dofnum; // number of motion degrees of freedom (nbody x 1) int* body_dofadr; // start addr of dofs; -1: no dofs (nbody x 1) int* body_treeid; // id of body's kinematic tree; -1: static (nbody x 1) int* body_geomnum; // number of geoms (nbody x 1) int* body_geomadr; // start addr of geoms; -1: no geoms (nbody x 1) mjtByte* body_simple; // 1: diag M; 2: diag M, sliders only (nbody x 1) mjtByte* body_sameframe; // same frame as inertia (mjtSameframe) (nbody x 1) mjtNum* body_pos; // position offset rel. to parent body (nbody x 3) mjtNum* body_quat; // orientation offset rel. to parent body (nbody x 4) mjtNum* body_ipos; // local position of center of mass (nbody x 3) mjtNum* body_iquat; // local orientation of inertia ellipsoid (nbody x 4) mjtNum* body_mass; // mass (nbody x 1) mjtNum* body_subtreemass; // mass of subtree starting at this body (nbody x 1) mjtNum* body_inertia; // diagonal inertia in ipos/iquat frame (nbody x 3) mjtNum* body_invweight0; // mean inv inert in qpos0 (trn, rot) (nbody x 2) mjtNum* body_gravcomp; // antigravity force, units of body weight (nbody x 1) mjtNum* body_margin; // MAX over all geom margins (nbody x 1) mjtNum* body_user; // user data (nbody x nuser_body) int* body_plugin; // plugin instance id; -1: not in use (nbody x 1) int* body_contype; // OR over all geom contypes (nbody x 1) int* body_conaffinity; // OR over all geom conaffinities (nbody x 1) int* body_bvhadr; // address of bvh root (nbody x 1) int* body_bvhnum; // number of bounding volumes (nbody x 1) // bounding volume hierarchy int* bvh_depth; // depth in the bounding volume hierarchy (nbvh x 1) int* bvh_child; // left and right children in tree (nbvh x 2) int* bvh_nodeid; // geom or elem id of node; -1: non-leaf (nbvh x 1) mjtNum* bvh_aabb; // local bounding box (center, size) (nbvhstatic x 6) // octree spatial partitioning int* oct_depth; // depth in the octree (noct x 1) int* oct_child; // children of octree node (noct x 8) mjtNum* oct_aabb; // octree node bounding box (center, size) (noct x 6) mjtNum* oct_coeff; // octree interpolation coefficients (noct x 8) // joints int* jnt_type; // type of joint (mjtJoint) (njnt x 1) int* jnt_qposadr; // start addr in 'qpos' for joint's data (njnt x 1) int* jnt_dofadr; // start addr in 'qvel' for joint's data (njnt x 1) int* jnt_bodyid; // id of joint's body (njnt x 1) int* jnt_group; // group for visibility (njnt x 1) mjtByte* jnt_limited; // does joint have limits (njnt x 1) mjtByte* jnt_actfrclimited; // does joint have actuator force limits (njnt x 1) mjtByte* jnt_actgravcomp; // is gravcomp force applied via actuators (njnt x 1) mjtNum* jnt_solref; // constraint solver reference: limit (njnt x mjNREF) mjtNum* jnt_solimp; // constraint solver impedance: limit (njnt x mjNIMP) mjtNum* jnt_pos; // local anchor position (njnt x 3) mjtNum* jnt_axis; // local joint axis (njnt x 3) mjtNum* jnt_stiffness; // stiffness coefficient (njnt x 1) mjtNum* jnt_range; // joint limits (njnt x 2) mjtNum* jnt_actfrcrange; // range of total actuator force (njnt x 2) mjtNum* jnt_margin; // min distance for limit detection (njnt x 1) mjtNum* jnt_user; // user data (njnt x nuser_jnt) // dofs int* dof_bodyid; // id of dof's body (nv x 1) int* dof_jntid; // id of dof's joint (nv x 1) int* dof_parentid; // id of dof's parent; -1: none (nv x 1) int* dof_treeid; // id of dof's kinematic tree (nv x 1) int* dof_Madr; // dof address in M-diagonal (nv x 1) int* dof_simplenum; // number of consecutive simple dofs (nv x 1) mjtNum* dof_solref; // constraint solver reference:frictionloss (nv x mjNREF) mjtNum* dof_solimp; // constraint solver impedance:frictionloss (nv x mjNIMP) mjtNum* dof_frictionloss; // dof friction loss (nv x 1) mjtNum* dof_armature; // dof armature inertia/mass (nv x 1) mjtNum* dof_damping; // damping coefficient (nv x 1) mjtNum* dof_invweight0; // diag. inverse inertia in qpos0 (nv x 1) mjtNum* dof_M0; // diag. inertia in qpos0 (nv x 1) // geoms int* geom_type; // geometric type (mjtGeom) (ngeom x 1) int* geom_contype; // geom contact type (ngeom x 1) int* geom_conaffinity; // geom contact affinity (ngeom x 1) int* geom_condim; // contact dimensionality (1, 3, 4, 6) (ngeom x 1) int* geom_bodyid; // id of geom's body (ngeom x 1) int* geom_dataid; // id of geom's mesh/hfield; -1: none (ngeom x 1) int* geom_matid; // material id for rendering; -1: none (ngeom x 1) int* geom_group; // group for visibility (ngeom x 1) int* geom_priority; // geom contact priority (ngeom x 1) int* geom_plugin; // plugin instance id; -1: not in use (ngeom x 1) mjtByte* geom_sameframe; // same frame as body (mjtSameframe) (ngeom x 1) mjtNum* geom_solmix; // mixing coef for solref/imp in geom pair (ngeom x 1) mjtNum* geom_solref; // constraint solver reference: contact (ngeom x mjNREF) mjtNum* geom_solimp; // constraint solver impedance: contact (ngeom x mjNIMP) mjtNum* geom_size; // geom-specific size parameters (ngeom x 3) mjtNum* geom_aabb; // bounding box, (center, size) (ngeom x 6) mjtNum* geom_rbound; // radius of bounding sphere (ngeom x 1) mjtNum* geom_pos; // local position offset rel. to body (ngeom x 3) mjtNum* geom_quat; // local orientation offset rel. to body (ngeom x 4) mjtNum* geom_friction; // friction for (slide, spin, roll) (ngeom x 3) mjtNum* geom_margin; // detect contact if distrgb2 mjBUILTIN_CHECKER, // checker pattern: rgb1, rgb2 mjBUILTIN_FLAT // 2d: rgb1; cube: rgb1-up, rgb2-side, rgb3-down } mjtBuiltin; typedef enum mjtMark_ { // mark type for procedural textures mjMARK_NONE = 0, // no mark mjMARK_EDGE, // edges mjMARK_CROSS, // cross mjMARK_RANDOM // random dots } mjtMark; typedef enum mjtLimited_ { // type of limit specification mjLIMITED_FALSE = 0, // not limited mjLIMITED_TRUE, // limited mjLIMITED_AUTO, // limited inferred from presence of range } mjtLimited; typedef enum mjtAlignFree_ { // whether to align free joints with the inertial frame mjALIGNFREE_FALSE = 0, // don't align mjALIGNFREE_TRUE, // align mjALIGNFREE_AUTO, // respect the global compiler flag } mjtAlignFree; typedef enum mjtInertiaFromGeom_ { // whether to infer body inertias from child geoms mjINERTIAFROMGEOM_FALSE = 0, // do not use; inertial element required mjINERTIAFROMGEOM_TRUE, // always use; overwrite inertial element mjINERTIAFROMGEOM_AUTO // use only if inertial element is missing } mjtInertiaFromGeom; typedef enum mjtOrientation_ { // type of orientation specifier mjORIENTATION_QUAT = 0, // quaternion mjORIENTATION_AXISANGLE, // axis and angle mjORIENTATION_XYAXES, // x and y axes mjORIENTATION_ZAXIS, // z axis (minimal rotation) mjORIENTATION_EULER, // Euler angles } mjtOrientation; typedef struct mjsElement_ { // element type, do not modify mjtObj elemtype; // element type uint64_t signature; // compilation signature } mjsElement; typedef struct mjsCompiler_ { // compiler options mjtByte autolimits; // infer "limited" attribute based on range double boundmass; // enforce minimum body mass double boundinertia; // enforce minimum body diagonal inertia double settotalmass; // rescale masses and inertias; <=0: ignore mjtByte balanceinertia; // automatically impose A + B >= C rule mjtByte fitaabb; // meshfit to aabb instead of inertia box mjtByte degree; // angles in radians or degrees char eulerseq[3]; // sequence for euler rotations mjtByte discardvisual; // discard visual geoms in parser mjtByte usethread; // use multiple threads to speed up compiler mjtByte fusestatic; // fuse static bodies with parent int inertiafromgeom; // use geom inertias (mjtInertiaFromGeom) int inertiagrouprange[2]; // range of geom groups used to compute inertia mjtByte saveinertial; // save explicit inertial clause for all bodies to XML int alignfree; // align free joints with inertial frame mjLROpt LRopt; // options for lengthrange computation } mjsCompiler; typedef struct mjSpec_ { // model specification mjsElement* element; // element type mjString* modelname; // model name // compiler data mjsCompiler compiler; // compiler options mjtByte strippath; // automatically strip paths from mesh files mjString* meshdir; // mesh and hfield directory mjString* texturedir; // texture directory // engine data mjOption option; // physics options mjVisual visual; // visual options mjStatistic stat; // statistics override (if defined) // sizes size_t memory; // number of bytes in arena+stack memory int nemax; // max number of equality constraints int nuserdata; // number of mjtNums in userdata int nuser_body; // number of mjtNums in body_user int nuser_jnt; // number of mjtNums in jnt_user int nuser_geom; // number of mjtNums in geom_user int nuser_site; // number of mjtNums in site_user int nuser_cam; // number of mjtNums in cam_user int nuser_tendon; // number of mjtNums in tendon_user int nuser_actuator; // number of mjtNums in actuator_user int nuser_sensor; // number of mjtNums in sensor_user int nkey; // number of keyframes int njmax; // (deprecated) max number of constraints int nconmax; // (deprecated) max number of detected contacts size_t nstack; // (deprecated) number of mjtNums in mjData stack // global data mjString* comment; // comment at top of XML mjString* modelfiledir; // path to model file // other mjtByte hasImplicitPluginElem; // already encountered an implicit plugin sensor/actuator } mjSpec; typedef struct mjsOrientation_ { // alternative orientation specifiers mjtOrientation type; // active orientation specifier double axisangle[4]; // axis and angle double xyaxes[6]; // x and y axes double zaxis[3]; // z axis (minimal rotation) double euler[3]; // Euler angles } mjsOrientation; typedef struct mjsPlugin_ { // plugin specification mjsElement* element; // element type mjString* name; // instance name mjString* plugin_name; // plugin name mjtByte active; // is the plugin active mjString* info; // message appended to compiler errors } mjsPlugin; typedef struct mjsBody_ { // body specification mjsElement* element; // element type mjString* childclass; // childclass name // body frame double pos[3]; // frame position double quat[4]; // frame orientation mjsOrientation alt; // frame alternative orientation // inertial frame double mass; // mass double ipos[3]; // inertial frame position double iquat[4]; // inertial frame orientation double inertia[3]; // diagonal inertia (in i-frame) mjsOrientation ialt; // inertial frame alternative orientation double fullinertia[6]; // non-axis-aligned inertia matrix // other mjtByte mocap; // is this a mocap body double gravcomp; // gravity compensation mjDoubleVec* userdata; // user data mjtByte explicitinertial; // whether to save the body with explicit inertial clause mjsPlugin plugin; // passive force plugin mjString* info; // message appended to compiler errors } mjsBody; typedef struct mjsFrame_ { // frame specification mjsElement* element; // element type mjString* childclass; // childclass name double pos[3]; // position double quat[4]; // orientation mjsOrientation alt; // alternative orientation mjString* info; // message appended to compiler errors } mjsFrame; typedef struct mjsJoint_ { // joint specification mjsElement* element; // element type mjtJoint type; // joint type // kinematics double pos[3]; // anchor position double axis[3]; // joint axis double ref; // value at reference configuration: qpos0 int align; // align free joint with body com (mjtAlignFree) // stiffness double stiffness; // stiffness coefficient double springref; // spring reference value: qpos_spring double springdamper[2]; // timeconst, dampratio // limits int limited; // does joint have limits (mjtLimited) double range[2]; // joint limits double margin; // margin value for joint limit detection mjtNum solref_limit[mjNREF]; // solver reference: joint limits mjtNum solimp_limit[mjNIMP]; // solver impedance: joint limits int actfrclimited; // are actuator forces on joint limited (mjtLimited) double actfrcrange[2]; // actuator force limits // dof properties double armature; // armature inertia (mass for slider) double damping; // damping coefficient double frictionloss; // friction loss mjtNum solref_friction[mjNREF]; // solver reference: dof friction mjtNum solimp_friction[mjNIMP]; // solver impedance: dof friction // other int group; // group mjtByte actgravcomp; // is gravcomp force applied via actuators mjDoubleVec* userdata; // user data mjString* info; // message appended to compiler errors } mjsJoint; typedef struct mjsGeom_ { // geom specification mjsElement* element; // element type mjtGeom type; // geom type // frame, size double pos[3]; // position double quat[4]; // orientation mjsOrientation alt; // alternative orientation double fromto[6]; // alternative for capsule, cylinder, box, ellipsoid double size[3]; // type-specific size // contact related int contype; // contact type int conaffinity; // contact affinity int condim; // contact dimensionality int priority; // contact priority double friction[3]; // one-sided friction coefficients: slide, roll, spin double solmix; // solver mixing for contact pairs mjtNum solref[mjNREF]; // solver reference mjtNum solimp[mjNIMP]; // solver impedance double margin; // margin for contact detection double gap; // include in solver if dist < margin-gap // inertia inference double mass; // used to compute density double density; // used to compute mass and inertia from volume or surface mjtGeomInertia typeinertia; // selects between surface and volume inertia // fluid forces mjtNum fluid_ellipsoid; // whether ellipsoid-fluid model is active mjtNum fluid_coefs[5]; // ellipsoid-fluid interaction coefs // visual mjString* material; // name of material float rgba[4]; // rgba when material is omitted int group; // group // other mjString* hfieldname; // heightfield attached to geom mjString* meshname; // mesh attached to geom double fitscale; // scale mesh uniformly mjDoubleVec* userdata; // user data mjsPlugin plugin; // sdf plugin mjString* info; // message appended to compiler errors } mjsGeom; typedef struct mjsSite_ { // site specification mjsElement* element; // element type // frame, size double pos[3]; // position double quat[4]; // orientation mjsOrientation alt; // alternative orientation double fromto[6]; // alternative for capsule, cylinder, box, ellipsoid double size[3]; // geom size // visual mjtGeom type; // geom type mjString* material; // name of material int group; // group float rgba[4]; // rgba when material is omitted // other mjDoubleVec* userdata; // user data mjString* info; // message appended to compiler errors } mjsSite; typedef struct mjsCamera_ { // camera specification mjsElement* element; // element type // extrinsics double pos[3]; // position double quat[4]; // orientation mjsOrientation alt; // alternative orientation mjtCamLight mode; // tracking mode mjString* targetbody; // target body for tracking/targeting // intrinsics int orthographic; // is camera orthographic double fovy; // y-field of view double ipd; // inter-pupilary distance float intrinsic[4]; // camera intrinsics (length) float sensor_size[2]; // sensor size (length) float resolution[2]; // resolution (pixel) float focal_length[2]; // focal length (length) float focal_pixel[2]; // focal length (pixel) float principal_length[2]; // principal point (length) float principal_pixel[2]; // principal point (pixel) // other mjDoubleVec* userdata; // user data mjString* info; // message appended to compiler errors } mjsCamera; typedef struct mjsLight_ { // light specification mjsElement* element; // element type // frame double pos[3]; // position double dir[3]; // direction mjtCamLight mode; // tracking mode mjString* targetbody; // target body for targeting // intrinsics mjtByte active; // is light active mjtLightType type; // type of light mjString* texture; // texture name for image lights mjtByte castshadow; // does light cast shadows float bulbradius; // bulb radius, for soft shadows float intensity; // intensity, in candelas float range; // range of effectiveness float attenuation[3]; // OpenGL attenuation (quadratic model) float cutoff; // OpenGL cutoff float exponent; // OpenGL exponent float ambient[3]; // ambient color float diffuse[3]; // diffuse color float specular[3]; // specular color // other mjString* info; // message appended to compiler errorsx } mjsLight; typedef struct mjsFlex_ { // flex specification mjsElement* element; // element type // contact properties int contype; // contact type int conaffinity; // contact affinity int condim; // contact dimensionality int priority; // contact priority double friction[3]; // one-sided friction coefficients: slide, roll, spin double solmix; // solver mixing for contact pairs mjtNum solref[mjNREF]; // solver reference mjtNum solimp[mjNIMP]; // solver impedance double margin; // margin for contact detection double gap; // include in solver if dist=max: ignore) }; struct mjuiItem_ { // UI item // common properties int type; // type (mjtItem) char name[mjMAXUINAME]; // name int state; // 0: disable, 1: enable, 2+: use predicate void *pdata; // data pointer (type-specific) int sectionid; // id of section containing item int itemid; // id of item within section int userid; // user-supplied id (for event handling) // type-specific properties union { struct mjuiItemSingle_ single; // check and button struct mjuiItemMulti_ multi; // static, radio and select struct mjuiItemSlider_ slider; // slider struct mjuiItemEdit_ edit; // edit }; // internal mjrRect rect; // rectangle occupied by item int skip; // item skipped due to closed separator }; typedef struct mjuiItem_ mjuiItem; struct mjuiSection_ { // UI section // properties char name[mjMAXUINAME]; // name int state; // section state (mjtSection) int modifier; // 0: none, 1: control, 2: shift; 4: alt int shortcut; // shortcut key; 0: undefined int checkbox; // 0: none, 1: unchecked, 2: checked int nitem; // number of items in use mjuiItem item[mjMAXUIITEM]; // preallocated array of items // internal mjrRect rtitle; // rectangle occupied by title mjrRect rcontent; // rectangle occupied by content int lastclick; // last mouse click over this section }; typedef struct mjuiSection_ mjuiSection; struct mjUI_ { // entire UI // constants set by user mjuiThemeSpacing spacing; // UI theme spacing mjuiThemeColor color; // UI theme color mjfItemEnable predicate; // callback to set item state programmatically void* userdata; // pointer to user data (passed to predicate) int rectid; // index of this ui rectangle in mjuiState int auxid; // aux buffer index of this ui int radiocol; // number of radio columns (0 defaults to 2) // UI sizes (framebuffer units) int width; // width int height; // current height int maxheight; // height when all sections open int scroll; // scroll from top of UI // mouse focus and count int mousesect; // 0: none, -1: scroll, otherwise 1+section int mouseitem; // item within section int mousehelp; // help button down: print shortcuts int mouseclicks; // number of mouse clicks over UI int mousesectcheck; // 0: none, otherwise 1+section // keyboard focus and edit int editsect; // 0: none, otherwise 1+section int edititem; // item within section int editcursor; // cursor position int editscroll; // horizontal scroll char edittext[mjMAXUITEXT]; // current text mjuiItem* editchanged; // pointer to changed edit in last mjui_event // sections int nsect; // number of sections in use mjuiSection sect[mjMAXUISECT]; // preallocated array of sections }; typedef struct mjUI_ mjUI; struct mjuiDef_ { // table passed to mjui_add() int type; // type (mjtItem); -1: section char name[mjMAXUINAME]; // name int state; // state void* pdata; // pointer to data char other[mjMAXUITEXT]; // string with type-specific properties int otherint; // int with type-specific properties }; typedef struct mjuiDef_ mjuiDef; typedef enum mjtCatBit_ { // bitflags for mjvGeom category mjCAT_STATIC = 1, // model elements in body 0 mjCAT_DYNAMIC = 2, // model elements in all other bodies mjCAT_DECOR = 4, // decorative geoms mjCAT_ALL = 7 // select all categories } mjtCatBit; typedef enum mjtMouse_ { // mouse interaction mode mjMOUSE_NONE = 0, // no action mjMOUSE_ROTATE_V, // rotate, vertical plane mjMOUSE_ROTATE_H, // rotate, horizontal plane mjMOUSE_MOVE_V, // move, vertical plane mjMOUSE_MOVE_H, // move, horizontal plane mjMOUSE_ZOOM, // zoom mjMOUSE_SELECT // selection } mjtMouse; typedef enum mjtPertBit_ { // mouse perturbations mjPERT_TRANSLATE = 1, // translation mjPERT_ROTATE = 2 // rotation } mjtPertBit; typedef enum mjtCamera_ { // abstract camera type mjCAMERA_FREE = 0, // free camera mjCAMERA_TRACKING, // tracking camera; uses trackbodyid mjCAMERA_FIXED, // fixed camera; uses fixedcamid mjCAMERA_USER // user is responsible for setting OpenGL camera } mjtCamera; typedef enum mjtLabel_ { // object labeling mjLABEL_NONE = 0, // nothing mjLABEL_BODY, // body labels mjLABEL_JOINT, // joint labels mjLABEL_GEOM, // geom labels mjLABEL_SITE, // site labels mjLABEL_CAMERA, // camera labels mjLABEL_LIGHT, // light labels mjLABEL_TENDON, // tendon labels mjLABEL_ACTUATOR, // actuator labels mjLABEL_CONSTRAINT, // constraint labels mjLABEL_FLEX, // flex labels mjLABEL_SKIN, // skin labels mjLABEL_SELECTION, // selected object mjLABEL_SELPNT, // coordinates of selection point mjLABEL_CONTACTPOINT, // contact information mjLABEL_CONTACTFORCE, // magnitude of contact force mjLABEL_ISLAND, // id of island mjNLABEL // number of label types } mjtLabel; typedef enum mjtFrame_ { // frame visualization mjFRAME_NONE = 0, // no frames mjFRAME_BODY, // body frames mjFRAME_GEOM, // geom frames mjFRAME_SITE, // site frames mjFRAME_CAMERA, // camera frames mjFRAME_LIGHT, // light frames mjFRAME_CONTACT, // contact frames mjFRAME_WORLD, // world frame mjNFRAME // number of visualization frames } mjtFrame; typedef enum mjtVisFlag_ { // flags enabling model element visualization mjVIS_CONVEXHULL = 0, // mesh convex hull mjVIS_TEXTURE, // textures mjVIS_JOINT, // joints mjVIS_CAMERA, // cameras mjVIS_ACTUATOR, // actuators mjVIS_ACTIVATION, // activations mjVIS_LIGHT, // lights mjVIS_TENDON, // tendons mjVIS_RANGEFINDER, // rangefinder sensors mjVIS_CONSTRAINT, // point constraints mjVIS_INERTIA, // equivalent inertia boxes mjVIS_SCLINERTIA, // scale equivalent inertia boxes with mass mjVIS_PERTFORCE, // perturbation force mjVIS_PERTOBJ, // perturbation object mjVIS_CONTACTPOINT, // contact points mjVIS_ISLAND, // constraint islands mjVIS_CONTACTFORCE, // contact force mjVIS_CONTACTSPLIT, // split contact force into normal and tangent mjVIS_TRANSPARENT, // make dynamic geoms more transparent mjVIS_AUTOCONNECT, // auto connect joints and body coms mjVIS_COM, // center of mass mjVIS_SELECT, // selection point mjVIS_STATIC, // static bodies mjVIS_SKIN, // skin mjVIS_FLEXVERT, // flex vertices mjVIS_FLEXEDGE, // flex edges mjVIS_FLEXFACE, // flex element faces mjVIS_FLEXSKIN, // flex smooth skin (disables the rest) mjVIS_BODYBVH, // body bounding volume hierarchy mjVIS_FLEXBVH, // flex bounding volume hierarchy mjVIS_MESHBVH, // mesh bounding volume hierarchy mjVIS_SDFITER, // iterations of SDF gradient descent mjNVISFLAG // number of visualization flags } mjtVisFlag; typedef enum mjtRndFlag_ { // flags enabling rendering effects mjRND_SHADOW = 0, // shadows mjRND_WIREFRAME, // wireframe mjRND_REFLECTION, // reflections mjRND_ADDITIVE, // additive transparency mjRND_SKYBOX, // skybox mjRND_FOG, // fog mjRND_HAZE, // haze mjRND_SEGMENT, // segmentation with random color mjRND_IDCOLOR, // segmentation with segid+1 color mjRND_CULL_FACE, // cull backward faces mjNRNDFLAG // number of rendering flags } mjtRndFlag; typedef enum mjtStereo_ { // type of stereo rendering mjSTEREO_NONE = 0, // no stereo; use left eye only mjSTEREO_QUADBUFFERED, // quad buffered; revert to side-by-side if no hardware support mjSTEREO_SIDEBYSIDE // side-by-side } mjtStereo; struct mjvPerturb_ { // object selection and perturbation int select; // selected body id; non-positive: none int flexselect; // selected flex id; negative: none int skinselect; // selected skin id; negative: none int active; // perturbation bitmask (mjtPertBit) int active2; // secondary perturbation bitmask (mjtPertBit) mjtNum refpos[3]; // reference position for selected object mjtNum refquat[4]; // reference orientation for selected object mjtNum refselpos[3]; // reference position for selection point mjtNum localpos[3]; // selection point in object coordinates mjtNum localmass; // spatial inertia at selection point mjtNum scale; // relative mouse motion-to-space scaling (set by initPerturb) }; typedef struct mjvPerturb_ mjvPerturb; struct mjvCamera_ { // abstract camera // type and ids int type; // camera type (mjtCamera) int fixedcamid; // fixed camera id int trackbodyid; // body id to track // abstract camera pose specification mjtNum lookat[3]; // lookat point mjtNum distance; // distance to lookat point or tracked body mjtNum azimuth; // camera azimuth (deg) mjtNum elevation; // camera elevation (deg) // orthographic / perspective int orthographic; // 0: perspective; 1: orthographic }; typedef struct mjvCamera_ mjvCamera; struct mjvGLCamera_ { // OpenGL camera // camera frame float pos[3]; // position float forward[3]; // forward direction float up[3]; // up direction // camera projection float frustum_center; // hor. center (left,right set to match aspect) float frustum_width; // width (not used for rendering) float frustum_bottom; // bottom float frustum_top; // top float frustum_near; // near float frustum_far; // far // orthographic / perspective int orthographic; // 0: perspective; 1: orthographic }; typedef struct mjvGLCamera_ mjvGLCamera; struct mjvGeom_ { // abstract geom // type info int type; // geom type (mjtGeom) int dataid; // mesh, hfield or plane id; -1: none; mesh: 2*id or 2*id+1 (hull) int objtype; // mujoco object type; mjOBJ_UNKNOWN for decor int objid; // mujoco object id; -1 for decor int category; // visual category int matid; // material id; -1: no textured material int texcoord; // mesh or flex geom has texture coordinates int segid; // segmentation id; -1: not shown // spatial transform float size[3]; // size parameters float pos[3]; // Cartesian position float mat[9]; // Cartesian orientation // material properties float rgba[4]; // color and transparency float emission; // emission coef float specular; // specular coef float shininess; // shininess coef float reflectance; // reflectance coef char label[100]; // text label // transparency rendering (set internally) float camdist; // distance to camera (used by sorter) float modelrbound; // geom rbound from model, 0 if not model geom mjtByte transparent; // treat geom as transparent }; typedef struct mjvGeom_ mjvGeom; struct mjvLight_ { // OpenGL light float pos[3]; // position rel. to body frame float dir[3]; // direction rel. to body frame int type; // type (mjtLightType) int texid; // texture id for image lights float attenuation[3]; // OpenGL attenuation (quadratic model) float cutoff; // OpenGL cutoff float exponent; // OpenGL exponent float ambient[3]; // ambient rgb (alpha=1) float diffuse[3]; // diffuse rgb (alpha=1) float specular[3]; // specular rgb (alpha=1) mjtByte headlight; // headlight mjtByte castshadow; // does light cast shadows float bulbradius; // bulb radius for soft shadows float intensity; // intensity, in candelas float range; // range of effectiveness }; typedef struct mjvLight_ mjvLight; struct mjvOption_ { // abstract visualization options int label; // what objects to label (mjtLabel) int frame; // which frame to show (mjtFrame) mjtByte geomgroup[mjNGROUP]; // geom visualization by group mjtByte sitegroup[mjNGROUP]; // site visualization by group mjtByte jointgroup[mjNGROUP]; // joint visualization by group mjtByte tendongroup[mjNGROUP]; // tendon visualization by group mjtByte actuatorgroup[mjNGROUP]; // actuator visualization by group mjtByte flexgroup[mjNGROUP]; // flex visualization by group mjtByte skingroup[mjNGROUP]; // skin visualization by group mjtByte flags[mjNVISFLAG]; // visualization flags (indexed by mjtVisFlag) int bvh_depth; // depth of the bounding volume hierarchy to be visualized int oct_depth; // depth of the octree to be visualized int flex_layer; // element layer to be visualized for 3D flex }; typedef struct mjvOption_ mjvOption; struct mjvScene_ { // abstract scene passed to OpenGL renderer // abstract geoms int maxgeom; // size of allocated geom buffer int ngeom; // number of geoms currently in buffer mjvGeom* geoms; // buffer for geoms (ngeom) int* geomorder; // buffer for ordering geoms by distance to camera (ngeom) // flex data int nflex; // number of flexes int* flexedgeadr; // address of flex edges (nflex) int* flexedgenum; // number of edges in flex (nflex) int* flexvertadr; // address of flex vertices (nflex) int* flexvertnum; // number of vertices in flex (nflex) int* flexfaceadr; // address of flex faces (nflex) int* flexfacenum; // number of flex faces allocated (nflex) int* flexfaceused; // number of flex faces currently in use (nflex) int* flexedge; // flex edge data (2*nflexedge) float* flexvert; // flex vertices (3*nflexvert) float* flexface; // flex faces vertices (9*sum(flexfacenum)) float* flexnormal; // flex face normals (9*sum(flexfacenum)) float* flextexcoord; // flex face texture coordinates (6*sum(flexfacenum)) mjtByte flexvertopt; // copy of mjVIS_FLEXVERT mjvOption flag mjtByte flexedgeopt; // copy of mjVIS_FLEXEDGE mjvOption flag mjtByte flexfaceopt; // copy of mjVIS_FLEXFACE mjvOption flag mjtByte flexskinopt; // copy of mjVIS_FLEXSKIN mjvOption flag // skin data int nskin; // number of skins int* skinfacenum; // number of faces in skin (nskin) int* skinvertadr; // address of skin vertices (nskin) int* skinvertnum; // number of vertices in skin (nskin) float* skinvert; // skin vertex data (3*nskinvert) float* skinnormal; // skin normal data (3*nskinvert) // OpenGL lights int nlight; // number of lights currently in buffer mjvLight lights[mjMAXLIGHT]; // buffer for lights (nlight) // OpenGL cameras mjvGLCamera camera[2]; // left and right camera // OpenGL model transformation mjtByte enabletransform; // enable model transformation float translate[3]; // model translation float rotate[4]; // model quaternion rotation float scale; // model scaling // OpenGL rendering effects int stereo; // stereoscopic rendering (mjtStereo) mjtByte flags[mjNRNDFLAG]; // rendering flags (indexed by mjtRndFlag) // framing int framewidth; // frame pixel width; 0: disable framing float framergb[3]; // frame color }; typedef struct mjvScene_ mjvScene; struct mjvFigure_ { // abstract 2D figure passed to OpenGL renderer // enable flags int flg_legend; // show legend int flg_ticklabel[2]; // show grid tick labels (x,y) int flg_extend; // automatically extend axis ranges to fit data int flg_barplot; // isolated line segments (i.e. GL_LINES) int flg_selection; // vertical selection line int flg_symmetric; // symmetric y-axis // style settings float linewidth; // line width float gridwidth; // grid line width int gridsize[2]; // number of grid points in (x,y) float gridrgb[3]; // grid line rgb float figurergba[4]; // figure color and alpha float panergba[4]; // pane color and alpha float legendrgba[4]; // legend color and alpha float textrgb[3]; // text color float linergb[mjMAXLINE][3]; // line colors float range[2][2]; // axis ranges; (min>=max) automatic char xformat[20]; // x-tick label format for sprintf char yformat[20]; // y-tick label format for sprintf char minwidth[20]; // string used to determine min y-tick width // text labels char title[1000]; // figure title; subplots separated with 2+ spaces char xlabel[100]; // x-axis label char linename[mjMAXLINE][100]; // line names for legend // dynamic settings int legendoffset; // number of lines to offset legend int subplot; // selected subplot (for title rendering) int highlight[2]; // if point is in legend rect, highlight line int highlightid; // if id>=0 and no point, highlight id float selection; // selection line x-value // line data int linepnt[mjMAXLINE]; // number of points in line; (0) disable float linedata[mjMAXLINE][2*mjMAXLINEPNT]; // line data (x,y) // output from renderer int xaxispixel[2]; // range of x-axis in pixels int yaxispixel[2]; // range of y-axis in pixels float xaxisdata[2]; // range of x-axis in data units float yaxisdata[2]; // range of y-axis in data units }; typedef struct mjvFigure_ mjvFigure; //----------------------------- MJAPI FUNCTIONS -------------------------------- void mj_defaultVFS(mjVFS* vfs); int mj_addFileVFS(mjVFS* vfs, const char* directory, const char* filename); int mj_addBufferVFS(mjVFS* vfs, const char* name, const void* buffer, int nbuffer); int mj_deleteFileVFS(mjVFS* vfs, const char* filename); void mj_deleteVFS(mjVFS* vfs); mjModel* mj_loadXML(const char* filename, const mjVFS* vfs, char* error, int error_sz); mjSpec* mj_parseXML(const char* filename, const mjVFS* vfs, char* error, int error_sz); mjSpec* mj_parseXMLString(const char* xml, const mjVFS* vfs, char* error, int error_sz); mjModel* mj_compile(mjSpec* s, const mjVFS* vfs); int mj_copyBack(mjSpec* s, const mjModel* m); int mj_recompile(mjSpec* s, const mjVFS* vfs, mjModel* m, mjData* d); int mj_saveLastXML(const char* filename, const mjModel* m, char* error, int error_sz); void mj_freeLastXML(void); int mj_saveXMLString(const mjSpec* s, char* xml, int xml_sz, char* error, int error_sz); int mj_saveXML(const mjSpec* s, const char* filename, char* error, int error_sz); void mj_step(const mjModel* m, mjData* d); void mj_step1(const mjModel* m, mjData* d); void mj_step2(const mjModel* m, mjData* d); void mj_forward(const mjModel* m, mjData* d); void mj_inverse(const mjModel* m, mjData* d); void mj_forwardSkip(const mjModel* m, mjData* d, int skipstage, int skipsensor); void mj_inverseSkip(const mjModel* m, mjData* d, int skipstage, int skipsensor); void mj_defaultLROpt(mjLROpt* opt); void mj_defaultSolRefImp(mjtNum* solref, mjtNum* solimp); void mj_defaultOption(mjOption* opt); void mj_defaultVisual(mjVisual* vis); mjModel* mj_copyModel(mjModel* dest, const mjModel* src); void mj_saveModel(const mjModel* m, const char* filename, void* buffer, int buffer_sz); mjModel* mj_loadModel(const char* filename, const mjVFS* vfs); void mj_deleteModel(mjModel* m); int mj_sizeModel(const mjModel* m); mjData* mj_makeData(const mjModel* m); mjData* mj_copyData(mjData* dest, const mjModel* m, const mjData* src); mjData* mjv_copyData(mjData* dest, const mjModel* m, const mjData* src); void mj_resetData(const mjModel* m, mjData* d); void mj_resetDataDebug(const mjModel* m, mjData* d, unsigned char debug_value); void mj_resetDataKeyframe(const mjModel* m, mjData* d, int key); void mj_markStack(mjData* d); void mj_freeStack(mjData* d); void* mj_stackAllocByte(mjData* d, size_t bytes, size_t alignment); mjtNum* mj_stackAllocNum(mjData* d, size_t size); int* mj_stackAllocInt(mjData* d, size_t size); void mj_deleteData(mjData* d); void mj_resetCallbacks(void); void mj_setConst(mjModel* m, mjData* d); int mj_setLengthRange(mjModel* m, mjData* d, int index, const mjLROpt* opt, char* error, int error_sz); mjSpec* mj_makeSpec(void); mjSpec* mj_copySpec(const mjSpec* s); void mj_deleteSpec(mjSpec* s); int mjs_activatePlugin(mjSpec* s, const char* name); int mjs_setDeepCopy(mjSpec* s, int deepcopy); void mj_printFormattedModel(const mjModel* m, const char* filename, const char* float_format); void mj_printModel(const mjModel* m, const char* filename); void mj_printFormattedData(const mjModel* m, const mjData* d, const char* filename, const char* float_format); void mj_printData(const mjModel* m, const mjData* d, const char* filename); void mju_printMat(const mjtNum* mat, int nr, int nc); void mju_printMatSparse(const mjtNum* mat, int nr, const int* rownnz, const int* rowadr, const int* colind); int mj_printSchema(const char* filename, char* buffer, int buffer_sz, int flg_html, int flg_pad); void mj_fwdPosition(const mjModel* m, mjData* d); void mj_fwdVelocity(const mjModel* m, mjData* d); void mj_fwdActuation(const mjModel* m, mjData* d); void mj_fwdAcceleration(const mjModel* m, mjData* d); void mj_fwdConstraint(const mjModel* m, mjData* d); void mj_Euler(const mjModel* m, mjData* d); void mj_RungeKutta(const mjModel* m, mjData* d, int N); void mj_implicit(const mjModel* m, mjData* d); void mj_invPosition(const mjModel* m, mjData* d); void mj_invVelocity(const mjModel* m, mjData* d); void mj_invConstraint(const mjModel* m, mjData* d); void mj_compareFwdInv(const mjModel* m, mjData* d); void mj_sensorPos(const mjModel* m, mjData* d); void mj_sensorVel(const mjModel* m, mjData* d); void mj_sensorAcc(const mjModel* m, mjData* d); void mj_energyPos(const mjModel* m, mjData* d); void mj_energyVel(const mjModel* m, mjData* d); void mj_checkPos(const mjModel* m, mjData* d); void mj_checkVel(const mjModel* m, mjData* d); void mj_checkAcc(const mjModel* m, mjData* d); void mj_kinematics(const mjModel* m, mjData* d); void mj_comPos(const mjModel* m, mjData* d); void mj_camlight(const mjModel* m, mjData* d); void mj_flex(const mjModel* m, mjData* d); void mj_tendon(const mjModel* m, mjData* d); void mj_transmission(const mjModel* m, mjData* d); void mj_crb(const mjModel* m, mjData* d); void mj_makeM(const mjModel* m, mjData* d); void mj_factorM(const mjModel* m, mjData* d); void mj_solveM(const mjModel* m, mjData* d, mjtNum* x, const mjtNum* y, int n); void mj_solveM2(const mjModel* m, mjData* d, mjtNum* x, const mjtNum* y, const mjtNum* sqrtInvD, int n); void mj_comVel(const mjModel* m, mjData* d); void mj_passive(const mjModel* m, mjData* d); void mj_subtreeVel(const mjModel* m, mjData* d); void mj_rne(const mjModel* m, mjData* d, int flg_acc, mjtNum* result); void mj_rnePostConstraint(const mjModel* m, mjData* d); void mj_collision(const mjModel* m, mjData* d); void mj_makeConstraint(const mjModel* m, mjData* d); void mj_island(const mjModel* m, mjData* d); void mj_projectConstraint(const mjModel* m, mjData* d); void mj_referenceConstraint(const mjModel* m, mjData* d); void mj_constraintUpdate(const mjModel* m, mjData* d, const mjtNum* jar, mjtNum cost[1], int flg_coneHessian); int mj_stateSize(const mjModel* m, unsigned int spec); void mj_getState(const mjModel* m, const mjData* d, mjtNum* state, unsigned int spec); void mj_setState(const mjModel* m, mjData* d, const mjtNum* state, unsigned int spec); void mj_setKeyframe(mjModel* m, const mjData* d, int k); int mj_addContact(const mjModel* m, mjData* d, const mjContact* con); int mj_isPyramidal(const mjModel* m); int mj_isSparse(const mjModel* m); int mj_isDual(const mjModel* m); void mj_mulJacVec(const mjModel* m, const mjData* d, mjtNum* res, const mjtNum* vec); void mj_mulJacTVec(const mjModel* m, const mjData* d, mjtNum* res, const mjtNum* vec); void mj_jac(const mjModel* m, const mjData* d, mjtNum* jacp, mjtNum* jacr, const mjtNum point[3], int body); void mj_jacBody(const mjModel* m, const mjData* d, mjtNum* jacp, mjtNum* jacr, int body); void mj_jacBodyCom(const mjModel* m, const mjData* d, mjtNum* jacp, mjtNum* jacr, int body); void mj_jacSubtreeCom(const mjModel* m, mjData* d, mjtNum* jacp, int body); void mj_jacGeom(const mjModel* m, const mjData* d, mjtNum* jacp, mjtNum* jacr, int geom); void mj_jacSite(const mjModel* m, const mjData* d, mjtNum* jacp, mjtNum* jacr, int site); void mj_jacPointAxis(const mjModel* m, mjData* d, mjtNum* jacPoint, mjtNum* jacAxis, const mjtNum point[3], const mjtNum axis[3], int body); void mj_jacDot(const mjModel* m, const mjData* d, mjtNum* jacp, mjtNum* jacr, const mjtNum point[3], int body); void mj_angmomMat(const mjModel* m, mjData* d, mjtNum* mat, int body); int mj_name2id(const mjModel* m, int type, const char* name); const char* mj_id2name(const mjModel* m, int type, int id); void mj_fullM(const mjModel* m, mjtNum* dst, const mjtNum* M); void mj_mulM(const mjModel* m, const mjData* d, mjtNum* res, const mjtNum* vec); void mj_mulM2(const mjModel* m, const mjData* d, mjtNum* res, const mjtNum* vec); void mj_addM(const mjModel* m, mjData* d, mjtNum* dst, int* rownnz, int* rowadr, int* colind); void mj_applyFT(const mjModel* m, mjData* d, const mjtNum force[3], const mjtNum torque[3], const mjtNum point[3], int body, mjtNum* qfrc_target); void mj_objectVelocity(const mjModel* m, const mjData* d, int objtype, int objid, mjtNum res[6], int flg_local); void mj_objectAcceleration(const mjModel* m, const mjData* d, int objtype, int objid, mjtNum res[6], int flg_local); mjtNum mj_geomDistance(const mjModel* m, const mjData* d, int geom1, int geom2, mjtNum distmax, mjtNum fromto[6]); void mj_contactForce(const mjModel* m, const mjData* d, int id, mjtNum result[6]); void mj_differentiatePos(const mjModel* m, mjtNum* qvel, mjtNum dt, const mjtNum* qpos1, const mjtNum* qpos2); void mj_integratePos(const mjModel* m, mjtNum* qpos, const mjtNum* qvel, mjtNum dt); void mj_normalizeQuat(const mjModel* m, mjtNum* qpos); void mj_local2Global(mjData* d, mjtNum xpos[3], mjtNum xmat[9], const mjtNum pos[3], const mjtNum quat[4], int body, mjtByte sameframe); mjtNum mj_getTotalmass(const mjModel* m); void mj_setTotalmass(mjModel* m, mjtNum newmass); const char* mj_getPluginConfig(const mjModel* m, int plugin_id, const char* attrib); void mj_loadPluginLibrary(const char* path); void mj_loadAllPluginLibraries(const char* directory, mjfPluginLibraryLoadCallback callback); int mj_version(void); const char* mj_versionString(void); void mj_multiRay(const mjModel* m, mjData* d, const mjtNum pnt[3], const mjtNum* vec, const mjtByte* geomgroup, mjtByte flg_static, int bodyexclude, int* geomid, mjtNum* dist, int nray, mjtNum cutoff); mjtNum mj_ray(const mjModel* m, const mjData* d, const mjtNum pnt[3], const mjtNum vec[3], const mjtByte* geomgroup, mjtByte flg_static, int bodyexclude, int geomid[1]); mjtNum mj_rayHfield(const mjModel* m, const mjData* d, int geomid, const mjtNum pnt[3], const mjtNum vec[3]); mjtNum mj_rayMesh(const mjModel* m, const mjData* d, int geomid, const mjtNum pnt[3], const mjtNum vec[3]); mjtNum mju_rayGeom(const mjtNum pos[3], const mjtNum mat[9], const mjtNum size[3], const mjtNum pnt[3], const mjtNum vec[3], int geomtype); mjtNum mju_rayFlex(const mjModel* m, const mjData* d, int flex_layer, mjtByte flg_vert, mjtByte flg_edge, mjtByte flg_face, mjtByte flg_skin, int flexid, const mjtNum* pnt, const mjtNum* vec, int vertid[1]); mjtNum mju_raySkin(int nface, int nvert, const int* face, const float* vert, const mjtNum pnt[3], const mjtNum vec[3], int vertid[1]); void mjv_defaultCamera(mjvCamera* cam); void mjv_defaultFreeCamera(const mjModel* m, mjvCamera* cam); void mjv_defaultPerturb(mjvPerturb* pert); void mjv_room2model(mjtNum modelpos[3], mjtNum modelquat[4], const mjtNum roompos[3], const mjtNum roomquat[4], const mjvScene* scn); void mjv_model2room(mjtNum roompos[3], mjtNum roomquat[4], const mjtNum modelpos[3], const mjtNum modelquat[4], const mjvScene* scn); void mjv_cameraInModel(mjtNum headpos[3], mjtNum forward[3], mjtNum up[3], const mjvScene* scn); void mjv_cameraInRoom(mjtNum headpos[3], mjtNum forward[3], mjtNum up[3], const mjvScene* scn); mjtNum mjv_frustumHeight(const mjvScene* scn); void mjv_alignToCamera(mjtNum res[3], const mjtNum vec[3], const mjtNum forward[3]); void mjv_moveCamera(const mjModel* m, int action, mjtNum reldx, mjtNum reldy, const mjvScene* scn, mjvCamera* cam); void mjv_movePerturb(const mjModel* m, const mjData* d, int action, mjtNum reldx, mjtNum reldy, const mjvScene* scn, mjvPerturb* pert); void mjv_moveModel(const mjModel* m, int action, mjtNum reldx, mjtNum reldy, const mjtNum roomup[3], mjvScene* scn); void mjv_initPerturb(const mjModel* m, mjData* d, const mjvScene* scn, mjvPerturb* pert); void mjv_applyPerturbPose(const mjModel* m, mjData* d, const mjvPerturb* pert, int flg_paused); void mjv_applyPerturbForce(const mjModel* m, mjData* d, const mjvPerturb* pert); mjvGLCamera mjv_averageCamera(const mjvGLCamera* cam1, const mjvGLCamera* cam2); int mjv_select(const mjModel* m, const mjData* d, const mjvOption* vopt, mjtNum aspectratio, mjtNum relx, mjtNum rely, const mjvScene* scn, mjtNum selpnt[3], int geomid[1], int flexid[1], int skinid[1]); void mjv_defaultOption(mjvOption* opt); void mjv_defaultFigure(mjvFigure* fig); void mjv_initGeom(mjvGeom* geom, int type, const mjtNum size[3], const mjtNum pos[3], const mjtNum mat[9], const float rgba[4]); void mjv_connector(mjvGeom* geom, int type, mjtNum width, const mjtNum from[3], const mjtNum to[3]); void mjv_defaultScene(mjvScene* scn); void mjv_makeScene(const mjModel* m, mjvScene* scn, int maxgeom); void mjv_freeScene(mjvScene* scn); void mjv_updateScene(const mjModel* m, mjData* d, const mjvOption* opt, const mjvPerturb* pert, mjvCamera* cam, int catmask, mjvScene* scn); void mjv_copyModel(mjModel* dest, const mjModel* src); void mjv_addGeoms(const mjModel* m, mjData* d, const mjvOption* opt, const mjvPerturb* pert, int catmask, mjvScene* scn); void mjv_makeLights(const mjModel* m, const mjData* d, mjvScene* scn); void mjv_updateCamera(const mjModel* m, const mjData* d, mjvCamera* cam, mjvScene* scn); void mjv_updateSkin(const mjModel* m, const mjData* d, mjvScene* scn); void mjr_defaultContext(mjrContext* con); void mjr_makeContext(const mjModel* m, mjrContext* con, int fontscale); void mjr_changeFont(int fontscale, mjrContext* con); void mjr_addAux(int index, int width, int height, int samples, mjrContext* con); void mjr_freeContext(mjrContext* con); void mjr_resizeOffscreen(int width, int height, mjrContext* con); void mjr_uploadTexture(const mjModel* m, const mjrContext* con, int texid); void mjr_uploadMesh(const mjModel* m, const mjrContext* con, int meshid); void mjr_uploadHField(const mjModel* m, const mjrContext* con, int hfieldid); void mjr_restoreBuffer(const mjrContext* con); void mjr_setBuffer(int framebuffer, mjrContext* con); void mjr_readPixels(unsigned char* rgb, float* depth, mjrRect viewport, const mjrContext* con); void mjr_drawPixels(const unsigned char* rgb, const float* depth, mjrRect viewport, const mjrContext* con); void mjr_blitBuffer(mjrRect src, mjrRect dst, int flg_color, int flg_depth, const mjrContext* con); void mjr_setAux(int index, const mjrContext* con); void mjr_blitAux(int index, mjrRect src, int left, int bottom, const mjrContext* con); void mjr_text(int font, const char* txt, const mjrContext* con, float x, float y, float r, float g, float b); void mjr_overlay(int font, int gridpos, mjrRect viewport, const char* overlay, const char* overlay2, const mjrContext* con); mjrRect mjr_maxViewport(const mjrContext* con); void mjr_rectangle(mjrRect viewport, float r, float g, float b, float a); void mjr_label(mjrRect viewport, int font, const char* txt, float r, float g, float b, float a, float rt, float gt, float bt, const mjrContext* con); void mjr_figure(mjrRect viewport, mjvFigure* fig, const mjrContext* con); void mjr_render(mjrRect viewport, mjvScene* scn, const mjrContext* con); void mjr_finish(void); int mjr_getError(void); int mjr_findRect(int x, int y, int nrect, const mjrRect* rect); mjuiThemeSpacing mjui_themeSpacing(int ind); mjuiThemeColor mjui_themeColor(int ind); void mjui_add(mjUI* ui, const mjuiDef* def); void mjui_addToSection(mjUI* ui, int sect, const mjuiDef* def); void mjui_resize(mjUI* ui, const mjrContext* con); void mjui_update(int section, int item, const mjUI* ui, const mjuiState* state, const mjrContext* con); mjuiItem* mjui_event(mjUI* ui, mjuiState* state, const mjrContext* con); void mjui_render(mjUI* ui, const mjuiState* state, const mjrContext* con); void mju_error(const char* msg, ...) mjPRINTFLIKE(1, 2); void mju_error_i(const char* msg, int i); void mju_error_s(const char* msg, const char* text); void mju_warning(const char* msg, ...) mjPRINTFLIKE(1, 2); void mju_warning_i(const char* msg, int i); void mju_warning_s(const char* msg, const char* text); void mju_clearHandlers(void); void* mju_malloc(size_t size); void mju_free(void* ptr); void mj_warning(mjData* d, int warning, int info); void mju_writeLog(const char* type, const char* msg); const char* mjs_getError(mjSpec* s); int mjs_isWarning(mjSpec* s); void mju_zero3(mjtNum res[3]); void mju_copy3(mjtNum res[3], const mjtNum data[3]); void mju_scl3(mjtNum res[3], const mjtNum vec[3], mjtNum scl); void mju_add3(mjtNum res[3], const mjtNum vec1[3], const mjtNum vec2[3]); void mju_sub3(mjtNum res[3], const mjtNum vec1[3], const mjtNum vec2[3]); void mju_addTo3(mjtNum res[3], const mjtNum vec[3]); void mju_subFrom3(mjtNum res[3], const mjtNum vec[3]); void mju_addToScl3(mjtNum res[3], const mjtNum vec[3], mjtNum scl); void mju_addScl3(mjtNum res[3], const mjtNum vec1[3], const mjtNum vec2[3], mjtNum scl); mjtNum mju_normalize3(mjtNum vec[3]); mjtNum mju_norm3(const mjtNum vec[3]); mjtNum mju_dot3(const mjtNum vec1[3], const mjtNum vec2[3]); mjtNum mju_dist3(const mjtNum pos1[3], const mjtNum pos2[3]); void mju_mulMatVec3(mjtNum res[3], const mjtNum mat[9], const mjtNum vec[3]); void mju_mulMatTVec3(mjtNum res[3], const mjtNum mat[9], const mjtNum vec[3]); void mju_cross(mjtNum res[3], const mjtNum a[3], const mjtNum b[3]); void mju_zero4(mjtNum res[4]); void mju_unit4(mjtNum res[4]); void mju_copy4(mjtNum res[4], const mjtNum data[4]); mjtNum mju_normalize4(mjtNum vec[4]); void mju_zero(mjtNum* res, int n); void mju_fill(mjtNum* res, mjtNum val, int n); void mju_copy(mjtNum* res, const mjtNum* vec, int n); mjtNum mju_sum(const mjtNum* vec, int n); mjtNum mju_L1(const mjtNum* vec, int n); void mju_scl(mjtNum* res, const mjtNum* vec, mjtNum scl, int n); void mju_add(mjtNum* res, const mjtNum* vec1, const mjtNum* vec2, int n); void mju_sub(mjtNum* res, const mjtNum* vec1, const mjtNum* vec2, int n); void mju_addTo(mjtNum* res, const mjtNum* vec, int n); void mju_subFrom(mjtNum* res, const mjtNum* vec, int n); void mju_addToScl(mjtNum* res, const mjtNum* vec, mjtNum scl, int n); void mju_addScl(mjtNum* res, const mjtNum* vec1, const mjtNum* vec2, mjtNum scl, int n); mjtNum mju_normalize(mjtNum* res, int n); mjtNum mju_norm(const mjtNum* res, int n); mjtNum mju_dot(const mjtNum* vec1, const mjtNum* vec2, int n); void mju_mulMatVec(mjtNum* res, const mjtNum* mat, const mjtNum* vec, int nr, int nc); void mju_mulMatTVec(mjtNum* res, const mjtNum* mat, const mjtNum* vec, int nr, int nc); mjtNum mju_mulVecMatVec(const mjtNum* vec1, const mjtNum* mat, const mjtNum* vec2, int n); void mju_transpose(mjtNum* res, const mjtNum* mat, int nr, int nc); void mju_symmetrize(mjtNum* res, const mjtNum* mat, int n); void mju_eye(mjtNum* mat, int n); void mju_mulMatMat(mjtNum* res, const mjtNum* mat1, const mjtNum* mat2, int r1, int c1, int c2); void mju_mulMatMatT(mjtNum* res, const mjtNum* mat1, const mjtNum* mat2, int r1, int c1, int r2); void mju_mulMatTMat(mjtNum* res, const mjtNum* mat1, const mjtNum* mat2, int r1, int c1, int c2); void mju_sqrMatTD(mjtNum* res, const mjtNum* mat, const mjtNum* diag, int nr, int nc); void mju_transformSpatial(mjtNum res[6], const mjtNum vec[6], int flg_force, const mjtNum newpos[3], const mjtNum oldpos[3], const mjtNum rotnew2old[9]); int mju_dense2sparse(mjtNum* res, const mjtNum* mat, int nr, int nc, int* rownnz, int* rowadr, int* colind, int nnz); void mju_sparse2dense(mjtNum* res, const mjtNum* mat, int nr, int nc, const int* rownnz, const int* rowadr, const int* colind); void mju_rotVecQuat(mjtNum res[3], const mjtNum vec[3], const mjtNum quat[4]); void mju_negQuat(mjtNum res[4], const mjtNum quat[4]); void mju_mulQuat(mjtNum res[4], const mjtNum quat1[4], const mjtNum quat2[4]); void mju_mulQuatAxis(mjtNum res[4], const mjtNum quat[4], const mjtNum axis[3]); void mju_axisAngle2Quat(mjtNum res[4], const mjtNum axis[3], mjtNum angle); void mju_quat2Vel(mjtNum res[3], const mjtNum quat[4], mjtNum dt); void mju_subQuat(mjtNum res[3], const mjtNum qa[4], const mjtNum qb[4]); void mju_quat2Mat(mjtNum res[9], const mjtNum quat[4]); void mju_mat2Quat(mjtNum quat[4], const mjtNum mat[9]); void mju_derivQuat(mjtNum res[4], const mjtNum quat[4], const mjtNum vel[3]); void mju_quatIntegrate(mjtNum quat[4], const mjtNum vel[3], mjtNum scale); void mju_quatZ2Vec(mjtNum quat[4], const mjtNum vec[3]); int mju_mat2Rot(mjtNum quat[4], const mjtNum mat[9]); void mju_euler2Quat(mjtNum quat[4], const mjtNum euler[3], const char* seq); void mju_mulPose(mjtNum posres[3], mjtNum quatres[4], const mjtNum pos1[3], const mjtNum quat1[4], const mjtNum pos2[3], const mjtNum quat2[4]); void mju_negPose(mjtNum posres[3], mjtNum quatres[4], const mjtNum pos[3], const mjtNum quat[4]); void mju_trnVecPose(mjtNum res[3], const mjtNum pos[3], const mjtNum quat[4], const mjtNum vec[3]); int mju_cholFactor(mjtNum* mat, int n, mjtNum mindiag); void mju_cholSolve(mjtNum* res, const mjtNum* mat, const mjtNum* vec, int n); int mju_cholUpdate(mjtNum* mat, mjtNum* x, int n, int flg_plus); mjtNum mju_cholFactorBand(mjtNum* mat, int ntotal, int nband, int ndense, mjtNum diagadd, mjtNum diagmul); void mju_cholSolveBand(mjtNum* res, const mjtNum* mat, const mjtNum* vec, int ntotal, int nband, int ndense); void mju_band2Dense(mjtNum* res, const mjtNum* mat, int ntotal, int nband, int ndense, mjtByte flg_sym); void mju_dense2Band(mjtNum* res, const mjtNum* mat, int ntotal, int nband, int ndense); void mju_bandMulMatVec(mjtNum* res, const mjtNum* mat, const mjtNum* vec, int ntotal, int nband, int ndense, int nvec, mjtByte flg_sym); int mju_bandDiag(int i, int ntotal, int nband, int ndense); int mju_eig3(mjtNum eigval[3], mjtNum eigvec[9], mjtNum quat[4], const mjtNum mat[9]); int mju_boxQP(mjtNum* res, mjtNum* R, int* index, const mjtNum* H, const mjtNum* g, int n, const mjtNum* lower, const mjtNum* upper); void mju_boxQPmalloc(mjtNum** res, mjtNum** R, int** index, mjtNum** H, mjtNum** g, int n, mjtNum** lower, mjtNum** upper); mjtNum mju_muscleGain(mjtNum len, mjtNum vel, const mjtNum lengthrange[2], mjtNum acc0, const mjtNum prm[9]); mjtNum mju_muscleBias(mjtNum len, const mjtNum lengthrange[2], mjtNum acc0, const mjtNum prm[9]); mjtNum mju_muscleDynamics(mjtNum ctrl, mjtNum act, const mjtNum prm[3]); void mju_encodePyramid(mjtNum* pyramid, const mjtNum* force, const mjtNum* mu, int dim); void mju_decodePyramid(mjtNum* force, const mjtNum* pyramid, const mjtNum* mu, int dim); mjtNum mju_springDamper(mjtNum pos0, mjtNum vel0, mjtNum Kp, mjtNum Kv, mjtNum dt); mjtNum mju_min(mjtNum a, mjtNum b); mjtNum mju_max(mjtNum a, mjtNum b); mjtNum mju_clip(mjtNum x, mjtNum min, mjtNum max); mjtNum mju_sign(mjtNum x); int mju_round(mjtNum x); const char* mju_type2Str(int type); int mju_str2Type(const char* str); const char* mju_writeNumBytes(size_t nbytes); const char* mju_warningText(int warning, size_t info); int mju_isBad(mjtNum x); int mju_isZero(mjtNum* vec, int n); mjtNum mju_standardNormal(mjtNum* num2); void mju_f2n(mjtNum* res, const float* vec, int n); void mju_n2f(float* res, const mjtNum* vec, int n); void mju_d2n(mjtNum* res, const double* vec, int n); void mju_n2d(double* res, const mjtNum* vec, int n); void mju_insertionSort(mjtNum* list, int n); void mju_insertionSortInt(int* list, int n); mjtNum mju_Halton(int index, int base); char* mju_strncpy(char *dst, const char *src, int n); mjtNum mju_sigmoid(mjtNum x); const mjpPlugin* mjc_getSDF(const mjModel* m, int id); mjtNum mjc_distance(const mjModel* m, const mjData* d, const mjSDF* s, const mjtNum x[3]); void mjc_gradient(const mjModel* m, const mjData* d, const mjSDF* s, mjtNum gradient[3], const mjtNum x[3]); void mjd_transitionFD(const mjModel* m, mjData* d, mjtNum eps, mjtByte flg_centered, mjtNum* A, mjtNum* B, mjtNum* C, mjtNum* D); void mjd_inverseFD(const mjModel* m, mjData* d, mjtNum eps, mjtByte flg_actuation, mjtNum *DfDq, mjtNum *DfDv, mjtNum *DfDa, mjtNum *DsDq, mjtNum *DsDv, mjtNum *DsDa, mjtNum *DmDq); void mjd_subQuat(const mjtNum qa[4], const mjtNum qb[4], mjtNum Da[9], mjtNum Db[9]); void mjd_quatIntegrate(const mjtNum vel[3], mjtNum scale, mjtNum Dquat[9], mjtNum Dvel[9], mjtNum Dscale[3]); void mjp_defaultPlugin(mjpPlugin* plugin); int mjp_registerPlugin(const mjpPlugin* plugin); int mjp_pluginCount(void); const mjpPlugin* mjp_getPlugin(const char* name, int* slot); const mjpPlugin* mjp_getPluginAtSlot(int slot); void mjp_defaultResourceProvider(mjpResourceProvider* provider); int mjp_registerResourceProvider(const mjpResourceProvider* provider); int mjp_resourceProviderCount(void); const mjpResourceProvider* mjp_getResourceProvider(const char* resource_name); const mjpResourceProvider* mjp_getResourceProviderAtSlot(int slot); mjThreadPool* mju_threadPoolCreate(size_t number_of_threads); void mju_bindThreadPool(mjData* d, void* thread_pool); void mju_threadPoolEnqueue(mjThreadPool* thread_pool, mjTask* task); void mju_threadPoolDestroy(mjThreadPool* thread_pool); void mju_defaultTask(mjTask* task); void mju_taskJoin(mjTask* task); mjsElement* mjs_attach(mjsElement* parent, const mjsElement* child, const char* prefix, const char* suffix); mjsBody* mjs_addBody(mjsBody* body, const mjsDefault* def); mjsSite* mjs_addSite(mjsBody* body, const mjsDefault* def); mjsJoint* mjs_addJoint(mjsBody* body, const mjsDefault* def); mjsJoint* mjs_addFreeJoint(mjsBody* body); mjsGeom* mjs_addGeom(mjsBody* body, const mjsDefault* def); mjsCamera* mjs_addCamera(mjsBody* body, const mjsDefault* def); mjsLight* mjs_addLight(mjsBody* body, const mjsDefault* def); mjsFrame* mjs_addFrame(mjsBody* body, mjsFrame* parentframe); int mjs_delete(mjSpec* spec, mjsElement* element); mjsActuator* mjs_addActuator(mjSpec* s, const mjsDefault* def); mjsSensor* mjs_addSensor(mjSpec* s); mjsFlex* mjs_addFlex(mjSpec* s); mjsPair* mjs_addPair(mjSpec* s, const mjsDefault* def); mjsExclude* mjs_addExclude(mjSpec* s); mjsEquality* mjs_addEquality(mjSpec* s, const mjsDefault* def); mjsTendon* mjs_addTendon(mjSpec* s, const mjsDefault* def); mjsWrap* mjs_wrapSite(mjsTendon* tendon, const char* name); mjsWrap* mjs_wrapGeom(mjsTendon* tendon, const char* name, const char* sidesite); mjsWrap* mjs_wrapJoint(mjsTendon* tendon, const char* name, double coef); mjsWrap* mjs_wrapPulley(mjsTendon* tendon, double divisor); mjsNumeric* mjs_addNumeric(mjSpec* s); mjsText* mjs_addText(mjSpec* s); mjsTuple* mjs_addTuple(mjSpec* s); mjsKey* mjs_addKey(mjSpec* s); mjsPlugin* mjs_addPlugin(mjSpec* s); mjsDefault* mjs_addDefault(mjSpec* s, const char* classname, const mjsDefault* parent); const char* mjs_setToMotor(mjsActuator* actuator); const char* mjs_setToPosition(mjsActuator* actuator, double kp, double kv[1], double dampratio[1], double timeconst[1], double inheritrange); const char* mjs_setToIntVelocity(mjsActuator* actuator, double kp, double kv[1], double dampratio[1], double timeconst[1], double inheritrange); const char* mjs_setToVelocity(mjsActuator* actuator, double kv); const char* mjs_setToDamper(mjsActuator* actuator, double kv); const char* mjs_setToCylinder(mjsActuator* actuator, double timeconst, double bias, double area, double diameter); const char* mjs_setToMuscle(mjsActuator* actuator, double timeconst[2], double tausmooth, double range[2], double force, double scale, double lmin, double lmax, double vmax, double fpmax, double fvmax); const char* mjs_setToAdhesion(mjsActuator* actuator, double gain); mjsMesh* mjs_addMesh(mjSpec* s, const mjsDefault* def); mjsHField* mjs_addHField(mjSpec* s); mjsSkin* mjs_addSkin(mjSpec* s); mjsTexture* mjs_addTexture(mjSpec* s); mjsMaterial* mjs_addMaterial(mjSpec* s, const mjsDefault* def); mjSpec* mjs_getSpec(mjsElement* element); mjSpec* mjs_findSpec(mjSpec* spec, const char* name); mjsBody* mjs_findBody(mjSpec* s, const char* name); mjsElement* mjs_findElement(mjSpec* s, mjtObj type, const char* name); mjsBody* mjs_findChild(mjsBody* body, const char* name); mjsBody* mjs_getParent(mjsElement* element); mjsFrame* mjs_getFrame(mjsElement* element); mjsFrame* mjs_findFrame(mjSpec* s, const char* name); mjsDefault* mjs_getDefault(mjsElement* element); mjsDefault* mjs_findDefault(mjSpec* s, const char* classname); mjsDefault* mjs_getSpecDefault(mjSpec* s); int mjs_getId(mjsElement* element); mjsElement* mjs_firstChild(mjsBody* body, mjtObj type, int recurse); mjsElement* mjs_nextChild(mjsBody* body, mjsElement* child, int recurse); mjsElement* mjs_firstElement(mjSpec* s, mjtObj type); mjsElement* mjs_nextElement(mjSpec* s, mjsElement* element); int mjs_setName(mjsElement* element, const char* name); void mjs_setBuffer(mjByteVec* dest, const void* array, int size); void mjs_setString(mjString* dest, const char* text); void mjs_setStringVec(mjStringVec* dest, const char* text); mjtByte mjs_setInStringVec(mjStringVec* dest, int i, const char* text); void mjs_appendString(mjStringVec* dest, const char* text); void mjs_setInt(mjIntVec* dest, const int* array, int size); void mjs_appendIntVec(mjIntVecVec* dest, const int* array, int size); void mjs_setFloat(mjFloatVec* dest, const float* array, int size); void mjs_appendFloatVec(mjFloatVecVec* dest, const float* array, int size); void mjs_setDouble(mjDoubleVec* dest, const double* array, int size); void mjs_setPluginAttributes(mjsPlugin* plugin, void* attributes); mjString* mjs_getName(mjsElement* element); const char* mjs_getString(const mjString* source); const double* mjs_getDouble(const mjDoubleVec* source, int* size); const void* mjs_getPluginAttributes(const mjsPlugin* plugin); void mjs_setDefault(mjsElement* element, const mjsDefault* def); int mjs_setFrame(mjsElement* dest, mjsFrame* frame); const char* mjs_resolveOrientation(double quat[4], mjtByte degree, const char* sequence, const mjsOrientation* orientation); mjsFrame* mjs_bodyToFrame(mjsBody** body); void mjs_setUserValue(mjsElement* element, const char* key, const void* data); void mjs_setUserValueWithCleanup(mjsElement* element, const char* key, const void* data, void (*cleanup)(const void*)); const void* mjs_getUserValue(mjsElement* element, const char* key); void mjs_deleteUserValue(mjsElement* element, const char* key); void mjs_defaultSpec(mjSpec* spec); void mjs_defaultOrientation(mjsOrientation* orient); void mjs_defaultBody(mjsBody* body); void mjs_defaultFrame(mjsFrame* frame); void mjs_defaultJoint(mjsJoint* joint); void mjs_defaultGeom(mjsGeom* geom); void mjs_defaultSite(mjsSite* site); void mjs_defaultCamera(mjsCamera* camera); void mjs_defaultLight(mjsLight* light); void mjs_defaultFlex(mjsFlex* flex); void mjs_defaultMesh(mjsMesh* mesh); void mjs_defaultHField(mjsHField* hfield); void mjs_defaultSkin(mjsSkin* skin); void mjs_defaultTexture(mjsTexture* texture); void mjs_defaultMaterial(mjsMaterial* material); void mjs_defaultPair(mjsPair* pair); void mjs_defaultEquality(mjsEquality* equality); void mjs_defaultTendon(mjsTendon* tendon); void mjs_defaultActuator(mjsActuator* actuator); void mjs_defaultSensor(mjsSensor* sensor); void mjs_defaultNumeric(mjsNumeric* numeric); void mjs_defaultText(mjsText* text); void mjs_defaultTuple(mjsTuple* tuple); void mjs_defaultKey(mjsKey* key); void mjs_defaultPlugin(mjsPlugin* plugin); mjsBody* mjs_asBody(mjsElement* element); mjsGeom* mjs_asGeom(mjsElement* element); mjsJoint* mjs_asJoint(mjsElement* element); mjsSite* mjs_asSite(mjsElement* element); mjsCamera* mjs_asCamera(mjsElement* element); mjsLight* mjs_asLight(mjsElement* element); mjsFrame* mjs_asFrame(mjsElement* element); mjsActuator* mjs_asActuator(mjsElement* element); mjsSensor* mjs_asSensor(mjsElement* element); mjsFlex* mjs_asFlex(mjsElement* element); mjsPair* mjs_asPair(mjsElement* element); mjsEquality* mjs_asEquality(mjsElement* element); mjsExclude* mjs_asExclude(mjsElement* element); mjsTendon* mjs_asTendon(mjsElement* element); mjsNumeric* mjs_asNumeric(mjsElement* element); mjsText* mjs_asText(mjsElement* element); mjsTuple* mjs_asTuple(mjsElement* element); mjsKey* mjs_asKey(mjsElement* element); mjsMesh* mjs_asMesh(mjsElement* element); mjsHField* mjs_asHField(mjsElement* element); mjsSkin* mjs_asSkin(mjsElement* element); mjsTexture* mjs_asTexture(mjsElement* element); mjsMaterial* mjs_asMaterial(mjsElement* element); mjsPlugin* mjs_asPlugin(mjsElement* element); // NOLINTEND