# `ExMujoco.Model` [🔗](https://github.com/d-led/ex.mujoco/blob/main/lib/ex_mujoco/model.ex#L2) The fields of `mjModel`, read one at a time. Each function is one call into MuJoCo that copies the field out, so the answer is a value: it does not change under you when the next step runs. * a scalar answers a number — `nq/1` answers an integer; * an array answers an `ExMujoco.Tensor`, with the element type and the shape, because a bare binary would have lost both; * a field MuJoCo gives no extent to is not here at all, and `docs/coverage.md` says which, and why. The names are MuJoCo's own — `geom_pos`, `qpos`, `efc_force` — so the documentation for a field is MuJoCo's documentation for that field. # `t` ```elixir @type t() :: reference() ``` An mjModel this process holds. # `actuator_acc0` ```elixir @spec actuator_acc0(t()) :: ExMujoco.Tensor.t() ``` `actuator_acc0` — acceleration from unit force in qpos0 (nout x 1) `mjtNum*` in C, `nout` × `1`. # `actuator_actadr` ```elixir @spec actuator_actadr(t()) :: ExMujoco.Tensor.t() ``` `actuator_actadr` — first activation address; -1: stateless (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_actearly` ```elixir @spec actuator_actearly(t()) :: ExMujoco.Tensor.t() ``` `actuator_actearly` — step activation before force (nactuator x 1) `mjtBool*` in C, `nactuator` × `1`. # `actuator_actlimited` ```elixir @spec actuator_actlimited(t()) :: ExMujoco.Tensor.t() ``` `actuator_actlimited` — is activation limited (nactuator x 1) `mjtBool*` in C, `nactuator` × `1`. # `actuator_actnum` ```elixir @spec actuator_actnum(t()) :: ExMujoco.Tensor.t() ``` `actuator_actnum` — number of activation variables (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_actrange` ```elixir @spec actuator_actrange(t()) :: ExMujoco.Tensor.t() ``` `actuator_actrange` — range of activations (nactuator x 2) `mjtNum*` in C, `nactuator` × `2`. # `actuator_armature` ```elixir @spec actuator_armature(t()) :: ExMujoco.Tensor.t() ``` `actuator_armature` — armature added to target (joint, tendon) (nactuator x 1) `mjtNum*` in C, `nactuator` × `1`. # `actuator_biasprm` ```elixir @spec actuator_biasprm(t()) :: ExMujoco.Tensor.t() ``` `actuator_biasprm` — bias parameters (nactuator x mjNBIAS) `mjtNum*` in C, `nactuator` × `mjNBIAS`. # `actuator_biastype` ```elixir @spec actuator_biastype(t()) :: ExMujoco.Tensor.t() ``` `actuator_biastype` — bias type (mjtBias) (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_cranklength` ```elixir @spec actuator_cranklength(t()) :: ExMujoco.Tensor.t() ``` `actuator_cranklength` — crank length for slider-crank (nactuator x 1) `mjtNum*` in C, `nactuator` × `1`. # `actuator_ctrladr` ```elixir @spec actuator_ctrladr(t()) :: ExMujoco.Tensor.t() ``` `actuator_ctrladr` — address of first control (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_ctrllimited` ```elixir @spec actuator_ctrllimited(t()) :: ExMujoco.Tensor.t() ``` `actuator_ctrllimited` — is control limited (nu x 1) `mjtBool*` in C, `nu` × `1`. # `actuator_ctrlnum` ```elixir @spec actuator_ctrlnum(t()) :: ExMujoco.Tensor.t() ``` `actuator_ctrlnum` — number of controls (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_ctrlrange` ```elixir @spec actuator_ctrlrange(t()) :: ExMujoco.Tensor.t() ``` `actuator_ctrlrange` — range of controls (nu x 2) `mjtNum*` in C, `nu` × `2`. # `actuator_ctrlspec` ```elixir @spec actuator_ctrlspec(t()) :: ExMujoco.Tensor.t() ``` `actuator_ctrlspec` — input signature, scoped by gaintype (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_damping` ```elixir @spec actuator_damping(t()) :: ExMujoco.Tensor.t() ``` `actuator_damping` — linear damping coefficient (nactuator x 1) `mjtNum*` in C, `nactuator` × `1`. # `actuator_dampingpoly` ```elixir @spec actuator_dampingpoly(t()) :: ExMujoco.Tensor.t() ``` `actuator_dampingpoly` — high-order damping coefficients (nactuator x mjNPOLY) `mjtNum*` in C, `nactuator` × `mjNPOLY`. # `actuator_delay` ```elixir @spec actuator_delay(t()) :: ExMujoco.Tensor.t() ``` `actuator_delay` — delay time; 0: no delay (nactuator x 1) `mjtNum*` in C, `nactuator` × `1`. # `actuator_dynprm` ```elixir @spec actuator_dynprm(t()) :: ExMujoco.Tensor.t() ``` `actuator_dynprm` — dynamics parameters (nactuator x mjNDYN) `mjtNum*` in C, `nactuator` × `mjNDYN`. # `actuator_dyntype` ```elixir @spec actuator_dyntype(t()) :: ExMujoco.Tensor.t() ``` `actuator_dyntype` — dynamics type (mjtDyn) (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_forcelimited` ```elixir @spec actuator_forcelimited(t()) :: ExMujoco.Tensor.t() ``` `actuator_forcelimited` — is force limited (nactuator x 1) `mjtBool*` in C, `nactuator` × `1`. # `actuator_forcerange` ```elixir @spec actuator_forcerange(t()) :: ExMujoco.Tensor.t() ``` `actuator_forcerange` — range of forces (nactuator x 2) `mjtNum*` in C, `nactuator` × `2`. # `actuator_gainprm` ```elixir @spec actuator_gainprm(t()) :: ExMujoco.Tensor.t() ``` `actuator_gainprm` — gain parameters (nactuator x mjNGAIN) `mjtNum*` in C, `nactuator` × `mjNGAIN`. # `actuator_gaintype` ```elixir @spec actuator_gaintype(t()) :: ExMujoco.Tensor.t() ``` `actuator_gaintype` — gain type (mjtGain) (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_gear` ```elixir @spec actuator_gear(t()) :: ExMujoco.Tensor.t() ``` `actuator_gear` — scale length and transmitted force (nout x 6) `mjtNum*` in C, `nout` × `6`. # `actuator_group` ```elixir @spec actuator_group(t()) :: ExMujoco.Tensor.t() ``` `actuator_group` — group for visibility (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_history` ```elixir @spec actuator_history(t()) :: ExMujoco.Tensor.t() ``` `actuator_history` — history buffer: [nsample, interp] (nactuator x 2) `int*` in C, `nactuator` × `2`. # `actuator_historyadr` ```elixir @spec actuator_historyadr(t()) :: ExMujoco.Tensor.t() ``` `actuator_historyadr` — address in history buffer; -1: none (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_length0` ```elixir @spec actuator_length0(t()) :: ExMujoco.Tensor.t() ``` `actuator_length0` — actuator length in qpos0 (nout x 1) `mjtNum*` in C, `nout` × `1`. # `actuator_lengthrange` ```elixir @spec actuator_lengthrange(t()) :: ExMujoco.Tensor.t() ``` `actuator_lengthrange` — feasible actuator length range (nout x 2) `mjtNum*` in C, `nout` × `2`. # `actuator_outadr` ```elixir @spec actuator_outadr(t()) :: ExMujoco.Tensor.t() ``` `actuator_outadr` — address of first force output (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_outnum` ```elixir @spec actuator_outnum(t()) :: ExMujoco.Tensor.t() ``` `actuator_outnum` — number of force outputs, from trntype (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_plugin` ```elixir @spec actuator_plugin(t()) :: ExMujoco.Tensor.t() ``` `actuator_plugin` — plugin instance id; -1: not a plugin (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_trnid` ```elixir @spec actuator_trnid(t()) :: ExMujoco.Tensor.t() ``` `actuator_trnid` — transmission id: joint, tendon, site (nactuator x 2) `int*` in C, `nactuator` × `2`. # `actuator_trntype` ```elixir @spec actuator_trntype(t()) :: ExMujoco.Tensor.t() ``` `actuator_trntype` — transmission type (mjtTrn) (nactuator x 1) `int*` in C, `nactuator` × `1`. # `actuator_user` ```elixir @spec actuator_user(t()) :: ExMujoco.Tensor.t() ``` `actuator_user` — user data (nactuator x nuser_actuator) `mjtNum*` in C, `nactuator` × `nuser_actuator@model`. # `b_colind` ```elixir @spec b_colind(t()) :: ExMujoco.Tensor.t() ``` `B_colind` — body-dof: column indices (nB x 1) `int*` in C, `nB` × `1`. # `b_rowadr` ```elixir @spec b_rowadr(t()) :: ExMujoco.Tensor.t() ``` `B_rowadr` — body-dof: row addresses (nbody x 1) `int*` in C, `nbody` × `1`. # `b_rownnz` ```elixir @spec b_rownnz(t()) :: ExMujoco.Tensor.t() ``` `B_rownnz` — body-dof: non-zeros in each row (nbody x 1) `int*` in C, `nbody` × `1`. # `body_bvhadr` ```elixir @spec body_bvhadr(t()) :: ExMujoco.Tensor.t() ``` `body_bvhadr` — address of bvh root (nbody x 1) `int*` in C, `nbody` × `1`. # `body_bvhnum` ```elixir @spec body_bvhnum(t()) :: ExMujoco.Tensor.t() ``` `body_bvhnum` — number of bounding volumes (nbody x 1) `int*` in C, `nbody` × `1`. # `body_conaffinity` ```elixir @spec body_conaffinity(t()) :: ExMujoco.Tensor.t() ``` `body_conaffinity` — OR over all geom conaffinities (nbody x 1) `int*` in C, `nbody` × `1`. # `body_contype` ```elixir @spec body_contype(t()) :: ExMujoco.Tensor.t() ``` `body_contype` — OR over all geom contypes (nbody x 1) `int*` in C, `nbody` × `1`. # `body_dofadr` ```elixir @spec body_dofadr(t()) :: ExMujoco.Tensor.t() ``` `body_dofadr` — start addr of dofs; -1: no dofs (nbody x 1) `int*` in C, `nbody` × `1`. # `body_dofnum` ```elixir @spec body_dofnum(t()) :: ExMujoco.Tensor.t() ``` `body_dofnum` — number of motion degrees of freedom (nbody x 1) `int*` in C, `nbody` × `1`. # `body_geomadr` ```elixir @spec body_geomadr(t()) :: ExMujoco.Tensor.t() ``` `body_geomadr` — start addr of geoms; -1: no geoms (nbody x 1) `int*` in C, `nbody` × `1`. # `body_geomnum` ```elixir @spec body_geomnum(t()) :: ExMujoco.Tensor.t() ``` `body_geomnum` — number of geoms (nbody x 1) `int*` in C, `nbody` × `1`. # `body_gravcomp` ```elixir @spec body_gravcomp(t()) :: ExMujoco.Tensor.t() ``` `body_gravcomp` — antigravity force, units of body weight (nbody x 1) `mjtNum*` in C, `nbody` × `1`. # `body_inertia` ```elixir @spec body_inertia(t()) :: ExMujoco.Tensor.t() ``` `body_inertia` — diagonal inertia in ipos/iquat frame (nbody x 3) `mjtNum*` in C, `nbody` × `3`. # `body_invweight0` ```elixir @spec body_invweight0(t()) :: ExMujoco.Tensor.t() ``` `body_invweight0` — mean inv inert in qpos0 (trn, rot) (nbody x 2) `mjtNum*` in C, `nbody` × `2`. # `body_ipos` ```elixir @spec body_ipos(t()) :: ExMujoco.Tensor.t() ``` `body_ipos` — local position of center of mass (nbody x 3) `mjtNum*` in C, `nbody` × `3`. # `body_iquat` ```elixir @spec body_iquat(t()) :: ExMujoco.Tensor.t() ``` `body_iquat` — local orientation of inertia ellipsoid (nbody x 4) `mjtNum*` in C, `nbody` × `4`. # `body_jntadr` ```elixir @spec body_jntadr(t()) :: ExMujoco.Tensor.t() ``` `body_jntadr` — start addr of joints; -1: no joints (nbody x 1) `int*` in C, `nbody` × `1`. # `body_jntnum` ```elixir @spec body_jntnum(t()) :: ExMujoco.Tensor.t() ``` `body_jntnum` — number of joints for this body (nbody x 1) `int*` in C, `nbody` × `1`. # `body_margin` ```elixir @spec body_margin(t()) :: ExMujoco.Tensor.t() ``` `body_margin` — MAX over all geom margins+gaps (nbody x 1) `mjtNum*` in C, `nbody` × `1`. # `body_mass` ```elixir @spec body_mass(t()) :: ExMujoco.Tensor.t() ``` `body_mass` — mass (nbody x 1) `mjtNum*` in C, `nbody` × `1`. # `body_mocapid` ```elixir @spec body_mocapid(t()) :: ExMujoco.Tensor.t() ``` `body_mocapid` — id of mocap data; -1: none (nbody x 1) `int*` in C, `nbody` × `1`. # `body_parentid` ```elixir @spec body_parentid(t()) :: ExMujoco.Tensor.t() ``` `body_parentid` — id of body's parent (nbody x 1) `int*` in C, `nbody` × `1`. # `body_plugin` ```elixir @spec body_plugin(t()) :: ExMujoco.Tensor.t() ``` `body_plugin` — plugin instance id; -1: not in use (nbody x 1) `int*` in C, `nbody` × `1`. # `body_pos` ```elixir @spec body_pos(t()) :: ExMujoco.Tensor.t() ``` `body_pos` — position offset rel. to parent body (nbody x 3) `mjtNum*` in C, `nbody` × `3`. # `body_quat` ```elixir @spec body_quat(t()) :: ExMujoco.Tensor.t() ``` `body_quat` — orientation offset rel. to parent body (nbody x 4) `mjtNum*` in C, `nbody` × `4`. # `body_rootid` ```elixir @spec body_rootid(t()) :: ExMujoco.Tensor.t() ``` `body_rootid` — ancestor that is direct child of world (nbody x 1) `int*` in C, `nbody` × `1`. # `body_sameframe` ```elixir @spec body_sameframe(t()) :: ExMujoco.Tensor.t() ``` `body_sameframe` — same frame as inertia (mjtSameframe) (nbody x 1) `mjtByte*` in C, `nbody` × `1`. # `body_simple` ```elixir @spec body_simple(t()) :: ExMujoco.Tensor.t() ``` `body_simple` — 1: diag M; 2: diag M, sliders only (nbody x 1) `mjtByte*` in C, `nbody` × `1`. # `body_subtreemass` ```elixir @spec body_subtreemass(t()) :: ExMujoco.Tensor.t() ``` `body_subtreemass` — mass of subtree starting at this body (nbody x 1) `mjtNum*` in C, `nbody` × `1`. # `body_treeid` ```elixir @spec body_treeid(t()) :: ExMujoco.Tensor.t() ``` `body_treeid` — id of body's kinematic tree; -1: static (nbody x 1) `int*` in C, `nbody` × `1`. # `body_user` ```elixir @spec body_user(t()) :: ExMujoco.Tensor.t() ``` `body_user` — user data (nbody x nuser_body) `mjtNum*` in C, `nbody` × `nuser_body@model`. # `body_weldid` ```elixir @spec body_weldid(t()) :: ExMujoco.Tensor.t() ``` `body_weldid` — top dof-less ancestor; mocap: own root (nbody x 1) `int*` in C, `nbody` × `1`. # `bvh_aabb` ```elixir @spec bvh_aabb(t()) :: ExMujoco.Tensor.t() ``` `bvh_aabb` — local bounding box (center, size) (nbvhstatic x 6) `mjtNum*` in C, `nbvhstatic` × `6`. # `bvh_child` ```elixir @spec bvh_child(t()) :: ExMujoco.Tensor.t() ``` `bvh_child` — left and right children in tree (nbvh x 2) `int*` in C, `nbvh` × `2`. # `bvh_depth` ```elixir @spec bvh_depth(t()) :: ExMujoco.Tensor.t() ``` `bvh_depth` — depth in the bounding volume hierarchy (nbvh x 1) `int*` in C, `nbvh` × `1`. # `bvh_nodeid` ```elixir @spec bvh_nodeid(t()) :: ExMujoco.Tensor.t() ``` `bvh_nodeid` — geom or elem id of node; -1: non-leaf (nbvh x 1) `int*` in C, `nbvh` × `1`. # `cam_bodyid` ```elixir @spec cam_bodyid(t()) :: ExMujoco.Tensor.t() ``` `cam_bodyid` — id of camera's body (ncam x 1) `int*` in C, `ncam` × `1`. # `cam_fovy` ```elixir @spec cam_fovy(t()) :: ExMujoco.Tensor.t() ``` `cam_fovy` — y field-of-view (ortho ? len : deg) (ncam x 1) `mjtNum*` in C, `ncam` × `1`. # `cam_intrinsic` ```elixir @spec cam_intrinsic(t()) :: ExMujoco.Tensor.t() ``` `cam_intrinsic` — [focal length; principal point] (ncam x 4) `float*` in C, `ncam` × `4`. # `cam_ipd` ```elixir @spec cam_ipd(t()) :: ExMujoco.Tensor.t() ``` `cam_ipd` — inter-pupilary distance (ncam x 1) `mjtNum*` in C, `ncam` × `1`. # `cam_mat0` ```elixir @spec cam_mat0(t()) :: ExMujoco.Tensor.t() ``` `cam_mat0` — global orientation in qpos0 (ncam x 9) `mjtNum*` in C, `ncam` × `9`. # `cam_mode` ```elixir @spec cam_mode(t()) :: ExMujoco.Tensor.t() ``` `cam_mode` — camera tracking mode (mjtCamLight) (ncam x 1) `int*` in C, `ncam` × `1`. # `cam_output` ```elixir @spec cam_output(t()) :: ExMujoco.Tensor.t() ``` `cam_output` — output types (mjtCamOut bit flags) (ncam x 1) `int*` in C, `ncam` × `1`. # `cam_pos0` ```elixir @spec cam_pos0(t()) :: ExMujoco.Tensor.t() ``` `cam_pos0` — global position rel. to body in qpos0 (ncam x 3) `mjtNum*` in C, `ncam` × `3`. # `cam_pos` ```elixir @spec cam_pos(t()) :: ExMujoco.Tensor.t() ``` `cam_pos` — position rel. to body frame (ncam x 3) `mjtNum*` in C, `ncam` × `3`. # `cam_poscom0` ```elixir @spec cam_poscom0(t()) :: ExMujoco.Tensor.t() ``` `cam_poscom0` — global position rel. to sub-com in qpos0 (ncam x 3) `mjtNum*` in C, `ncam` × `3`. # `cam_projection` ```elixir @spec cam_projection(t()) :: ExMujoco.Tensor.t() ``` `cam_projection` — projection type (mjtProjection) (ncam x 1) `int*` in C, `ncam` × `1`. # `cam_quat` ```elixir @spec cam_quat(t()) :: ExMujoco.Tensor.t() ``` `cam_quat` — orientation rel. to body frame (ncam x 4) `mjtNum*` in C, `ncam` × `4`. # `cam_resolution` ```elixir @spec cam_resolution(t()) :: ExMujoco.Tensor.t() ``` `cam_resolution` — resolution: pixels [width, height] (ncam x 2) `int*` in C, `ncam` × `2`. # `cam_sensorsize` ```elixir @spec cam_sensorsize(t()) :: ExMujoco.Tensor.t() ``` `cam_sensorsize` — sensor size: length [width, height] (ncam x 2) `float*` in C, `ncam` × `2`. # `cam_targetbodyid` ```elixir @spec cam_targetbodyid(t()) :: ExMujoco.Tensor.t() ``` `cam_targetbodyid` — id of targeted body; -1: none (ncam x 1) `int*` in C, `ncam` × `1`. # `cam_user` ```elixir @spec cam_user(t()) :: ExMujoco.Tensor.t() ``` `cam_user` — user data (ncam x nuser_cam) `mjtNum*` in C, `ncam` × `nuser_cam@model`. # `d_colind` ```elixir @spec d_colind(t()) :: ExMujoco.Tensor.t() ``` `D_colind` — full inertia: column indices (nD x 1) `int*` in C, `nD` × `1`. # `d_diag` ```elixir @spec d_diag(t()) :: ExMujoco.Tensor.t() ``` `D_diag` — full inertia: index of diagonal element (nv x 1) `int*` in C, `nv` × `1`. # `d_rowadr` ```elixir @spec d_rowadr(t()) :: ExMujoco.Tensor.t() ``` `D_rowadr` — full inertia: row addresses (nv x 1) `int*` in C, `nv` × `1`. # `d_rownnz` ```elixir @spec d_rownnz(t()) :: ExMujoco.Tensor.t() ``` `D_rownnz` — full inertia: non-zeros in each row (nv x 1) `int*` in C, `nv` × `1`. # `dof_armature` ```elixir @spec dof_armature(t()) :: ExMujoco.Tensor.t() ``` `dof_armature` — dof armature inertia/mass (nv x 1) `mjtNum*` in C, `nv` × `1`. # `dof_bodyid` ```elixir @spec dof_bodyid(t()) :: ExMujoco.Tensor.t() ``` `dof_bodyid` — id of dof's body (nv x 1) `int*` in C, `nv` × `1`. # `dof_damping` ```elixir @spec dof_damping(t()) :: ExMujoco.Tensor.t() ``` `dof_damping` — linear damping coefficient (nv x 1) `mjtNum*` in C, `nv` × `1`. # `dof_dampingpoly` ```elixir @spec dof_dampingpoly(t()) :: ExMujoco.Tensor.t() ``` `dof_dampingpoly` — high-order damping coefficients (nv x mjNPOLY) `mjtNum*` in C, `nv` × `mjNPOLY`. # `dof_frictionloss` ```elixir @spec dof_frictionloss(t()) :: ExMujoco.Tensor.t() ``` `dof_frictionloss` — dof friction loss (nv x 1) `mjtNum*` in C, `nv` × `1`. # `dof_invweight0` ```elixir @spec dof_invweight0(t()) :: ExMujoco.Tensor.t() ``` `dof_invweight0` — diag. inverse inertia in qpos0 (nv x 1) `mjtNum*` in C, `nv` × `1`. # `dof_jntid` ```elixir @spec dof_jntid(t()) :: ExMujoco.Tensor.t() ``` `dof_jntid` — id of dof's joint (nv x 1) `int*` in C, `nv` × `1`. # `dof_length` ```elixir @spec dof_length(t()) :: ExMujoco.Tensor.t() ``` `dof_length` — linear: 1; angular: approx. length scale (nv x 1) `mjtNum*` in C, `nv` × `1`. # `dof_M0` ```elixir @spec dof_M0(t()) :: ExMujoco.Tensor.t() ``` `dof_M0` — diag. inertia in qpos0 (nv x 1) `mjtNum*` in C, `nv` × `1`. # `dof_Madr` ```elixir @spec dof_Madr(t()) :: ExMujoco.Tensor.t() ``` `dof_Madr` — dof address in M-diagonal (nv x 1) `int*` in C, `nv` × `1`. # `dof_parentid` ```elixir @spec dof_parentid(t()) :: ExMujoco.Tensor.t() ``` `dof_parentid` — id of dof's parent; -1: none (nv x 1) `int*` in C, `nv` × `1`. # `dof_simplenum` ```elixir @spec dof_simplenum(t()) :: ExMujoco.Tensor.t() ``` `dof_simplenum` — number of consecutive simple dofs (nv x 1) `int*` in C, `nv` × `1`. # `dof_solimp` ```elixir @spec dof_solimp(t()) :: ExMujoco.Tensor.t() ``` `dof_solimp` — constraint solver impedance:frictionloss (nv x mjNIMP) `mjtNum*` in C, `nv` × `mjNIMP`. # `dof_solref` ```elixir @spec dof_solref(t()) :: ExMujoco.Tensor.t() ``` `dof_solref` — constraint solver reference:frictionloss (nv x mjNREF) `mjtNum*` in C, `nv` × `mjNREF`. # `dof_treeid` ```elixir @spec dof_treeid(t()) :: ExMujoco.Tensor.t() ``` `dof_treeid` — id of dof's kinematic tree (nv x 1) `int*` in C, `nv` × `1`. # `efm0_dofid` ```elixir @spec efm0_dofid(t()) :: ExMujoco.Tensor.t() ``` `efm0_dofid` — constant metric factor row->dof address (nefm0dof x 1) `int*` in C, `nefm0dof` × `1`. # `efm0_L` ```elixir @spec efm0_L(t()) :: ExMujoco.Tensor.t() ``` `efm0_L` — factor of M + (dt^2+dt*d)*K_bend (nefm0L x 1) `mjtNum*` in C, `nefm0L` × `1`. # `efm0_L_colind` ```elixir @spec efm0_L_colind(t()) :: ExMujoco.Tensor.t() ``` `efm0_L_colind` — constant metric factor column indices (nefm0L x 1) `int*` in C, `nefm0L` × `1`. # `efm0_L_rowadr` ```elixir @spec efm0_L_rowadr(t()) :: ExMujoco.Tensor.t() ``` `efm0_L_rowadr` — constant metric factor row addresses (nefm0dof x 1) `int*` in C, `nefm0dof` × `1`. # `efm0_L_rownnz` ```elixir @spec efm0_L_rownnz(t()) :: ExMujoco.Tensor.t() ``` `efm0_L_rownnz` — constant metric factor row nonzeros (nefm0dof x 1) `int*` in C, `nefm0dof` × `1`. # `efmC_perm` ```elixir @spec efmC_perm(t()) :: ExMujoco.Tensor.t() ``` `efmC_perm` — sparse factor order: vertex dof or -1 (nefmCvert x 1) `int*` in C, `nefmCvert` × `1`. # `eq_active0` ```elixir @spec eq_active0(t()) :: ExMujoco.Tensor.t() ``` `eq_active0` — initial enable/disable constraint state (neq x 1) `mjtBool*` in C, `neq` × `1`. # `eq_data` ```elixir @spec eq_data(t()) :: ExMujoco.Tensor.t() ``` `eq_data` — numeric data for constraint (neq x mjNEQDATA) `mjtNum*` in C, `neq` × `mjNEQDATA`. # `eq_obj1id` ```elixir @spec eq_obj1id(t()) :: ExMujoco.Tensor.t() ``` `eq_obj1id` — id of object 1 (neq x 1) `int*` in C, `neq` × `1`. # `eq_obj2id` ```elixir @spec eq_obj2id(t()) :: ExMujoco.Tensor.t() ``` `eq_obj2id` — id of object 2 (neq x 1) `int*` in C, `neq` × `1`. # `eq_objtype` ```elixir @spec eq_objtype(t()) :: ExMujoco.Tensor.t() ``` `eq_objtype` — type of both objects (mjtObj) (neq x 1) `int*` in C, `neq` × `1`. # `eq_solimp` ```elixir @spec eq_solimp(t()) :: ExMujoco.Tensor.t() ``` `eq_solimp` — constraint solver impedance (neq x mjNIMP) `mjtNum*` in C, `neq` × `mjNIMP`. # `eq_solref` ```elixir @spec eq_solref(t()) :: ExMujoco.Tensor.t() ``` `eq_solref` — constraint solver reference (neq x mjNREF) `mjtNum*` in C, `neq` × `mjNREF`. # `eq_type` ```elixir @spec eq_type(t()) :: ExMujoco.Tensor.t() ``` `eq_type` — constraint type (mjtEq) (neq x 1) `int*` in C, `neq` × `1`. # `exclude_signature` ```elixir @spec exclude_signature(t()) :: ExMujoco.Tensor.t() ``` `exclude_signature` — body1 << 16 + body2 (nexclude x 1) `int*` in C, `nexclude` × `1`. # `flex_activelayers` ```elixir @spec flex_activelayers(t()) :: ExMujoco.Tensor.t() ``` `flex_activelayers` — number of active element layers, 3D only (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_bending` ```elixir @spec flex_bending(t()) :: ExMujoco.Tensor.t() ``` `flex_bending` — bending stiffness (nflexbending x 1) `mjtNum*` in C, `nflexbending` × `1`. # `flex_bendingadr` ```elixir @spec flex_bendingadr(t()) :: ExMujoco.Tensor.t() ``` `flex_bendingadr` — first bending data address (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_bvhadr` ```elixir @spec flex_bvhadr(t()) :: ExMujoco.Tensor.t() ``` `flex_bvhadr` — address of bvh root; -1: no bvh (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_bvhnum` ```elixir @spec flex_bvhnum(t()) :: ExMujoco.Tensor.t() ``` `flex_bvhnum` — number of bounding volumes (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_cellnum` ```elixir @spec flex_cellnum(t()) :: ExMujoco.Tensor.t() ``` `flex_cellnum` — finite cell num per dimension (nflex x 3) `int*` in C, `nflex` × `3`. # `flex_centered` ```elixir @spec flex_centered(t()) :: ExMujoco.Tensor.t() ``` `flex_centered` — are all vertex coordinates (0,0,0) (nflex x 1) `mjtBool*` in C, `nflex` × `1`. # `flex_conaffinity` ```elixir @spec flex_conaffinity(t()) :: ExMujoco.Tensor.t() ``` `flex_conaffinity` — flex contact affinity (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_condim` ```elixir @spec flex_condim(t()) :: ExMujoco.Tensor.t() ``` `flex_condim` — contact dimensionality (1, 3, 4, 6) (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_contype` ```elixir @spec flex_contype(t()) :: ExMujoco.Tensor.t() ``` `flex_contype` — flex contact type (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_damping` ```elixir @spec flex_damping(t()) :: ExMujoco.Tensor.t() ``` `flex_damping` — Rayleigh's damping coefficient (nflex x 1) `mjtNum*` in C, `nflex` × `1`. # `flex_dim` ```elixir @spec flex_dim(t()) :: ExMujoco.Tensor.t() ``` `flex_dim` — 1: lines, 2: triangles, 3: tetrahedra (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_edge` ```elixir @spec flex_edge(t()) :: ExMujoco.Tensor.t() ``` `flex_edge` — edge vertex ids (2 per edge) (nflexedge x 2) `int*` in C, `nflexedge` × `2`. # `flex_edgeadr` ```elixir @spec flex_edgeadr(t()) :: ExMujoco.Tensor.t() ``` `flex_edgeadr` — first edge address (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_edgedamping` ```elixir @spec flex_edgedamping(t()) :: ExMujoco.Tensor.t() ``` `flex_edgedamping` — edge damping (nflex x 1) `mjtNum*` in C, `nflex` × `1`. # `flex_edgeequality` ```elixir @spec flex_edgeequality(t()) :: ExMujoco.Tensor.t() ``` `flex_edgeequality` — 0:none, 1:edges, 3:strain (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_edgeflap` ```elixir @spec flex_edgeflap(t()) :: ExMujoco.Tensor.t() ``` `flex_edgeflap` — adjacent vertex ids (dim=2 only) (nflexedge x 2) `int*` in C, `nflexedge` × `2`. # `flex_edgenum` ```elixir @spec flex_edgenum(t()) :: ExMujoco.Tensor.t() ``` `flex_edgenum` — number of edges (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_edgestiffness` ```elixir @spec flex_edgestiffness(t()) :: ExMujoco.Tensor.t() ``` `flex_edgestiffness` — edge stiffness (nflex x 1) `mjtNum*` in C, `nflex` × `1`. # `flex_elem` ```elixir @spec flex_elem(t()) :: ExMujoco.Tensor.t() ``` `flex_elem` — element vertex ids (dim+1 per elem) (nflexelemdata x 1) `int*` in C, `nflexelemdata` × `1`. # `flex_elemadr` ```elixir @spec flex_elemadr(t()) :: ExMujoco.Tensor.t() ``` `flex_elemadr` — first element address (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_elemdataadr` ```elixir @spec flex_elemdataadr(t()) :: ExMujoco.Tensor.t() ``` `flex_elemdataadr` — first element vertex id address (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_elemedge` ```elixir @spec flex_elemedge(t()) :: ExMujoco.Tensor.t() ``` `flex_elemedge` — element edge ids (nflexelemedge x 1) `int*` in C, `nflexelemedge` × `1`. # `flex_elemedgeadr` ```elixir @spec flex_elemedgeadr(t()) :: ExMujoco.Tensor.t() ``` `flex_elemedgeadr` — first element edge id address (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_elemlayer` ```elixir @spec flex_elemlayer(t()) :: ExMujoco.Tensor.t() ``` `flex_elemlayer` — element distance from surface, 3D only (nflexelem x 1) `int*` in C, `nflexelem` × `1`. # `flex_elemnum` ```elixir @spec flex_elemnum(t()) :: ExMujoco.Tensor.t() ``` `flex_elemnum` — number of elements (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_elemtexcoord` ```elixir @spec flex_elemtexcoord(t()) :: ExMujoco.Tensor.t() ``` `flex_elemtexcoord` — element texture coordinates (dim+1) (nflexelemdata x 1) `int*` in C, `nflexelemdata` × `1`. # `flex_flatskin` ```elixir @spec flex_flatskin(t()) :: ExMujoco.Tensor.t() ``` `flex_flatskin` — render flex skin with flat shading (nflex x 1) `mjtBool*` in C, `nflex` × `1`. # `flex_friction` ```elixir @spec flex_friction(t()) :: ExMujoco.Tensor.t() ``` `flex_friction` — friction for (slide, spin, roll) (nflex x 3) `mjtNum*` in C, `nflex` × `3`. # `flex_gap` ```elixir @spec flex_gap(t()) :: ExMujoco.Tensor.t() ``` `flex_gap` — additional contact detection buffer (nflex x 1) `mjtNum*` in C, `nflex` × `1`. # `flex_group` ```elixir @spec flex_group(t()) :: ExMujoco.Tensor.t() ``` `flex_group` — group for visibility (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_interp` ```elixir @spec flex_interp(t()) :: ExMujoco.Tensor.t() ``` `flex_interp` — interpolation (0: vertex, 1: nodes) (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_margin` ```elixir @spec flex_margin(t()) :: ExMujoco.Tensor.t() ``` `flex_margin` — geometric inflation for contact (nflex x 1) `mjtNum*` in C, `nflex` × `1`. # `flex_matid` ```elixir @spec flex_matid(t()) :: ExMujoco.Tensor.t() ``` `flex_matid` — material id for rendering (nflexelem x 1) `int*` in C, `nflexelem` × `1`. # `flex_node0` ```elixir @spec flex_node0(t()) :: ExMujoco.Tensor.t() ``` `flex_node0` — Cartesian node positions in qpos0 (nflexnode x 3) `mjtNum*` in C, `nflexnode` × `3`. # `flex_node` ```elixir @spec flex_node(t()) :: ExMujoco.Tensor.t() ``` `flex_node` — node positions in local body frames (nflexnode x 3) `mjtNum*` in C, `nflexnode` × `3`. # `flex_nodeadr` ```elixir @spec flex_nodeadr(t()) :: ExMujoco.Tensor.t() ``` `flex_nodeadr` — first node address (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_nodebodyid` ```elixir @spec flex_nodebodyid(t()) :: ExMujoco.Tensor.t() ``` `flex_nodebodyid` — node body ids (nflexnode x 1) `int*` in C, `nflexnode` × `1`. # `flex_nodenum` ```elixir @spec flex_nodenum(t()) :: ExMujoco.Tensor.t() ``` `flex_nodenum` — number of nodes (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_passive` ```elixir @spec flex_passive(t()) :: ExMujoco.Tensor.t() ``` `flex_passive` — passive collisions enabled (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_plasticadr` ```elixir @spec flex_plasticadr(t()) :: ExMujoco.Tensor.t() ``` `flex_plasticadr` — plastic state address; -1: elastic (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_plasticmode` ```elixir @spec flex_plasticmode(t()) :: ExMujoco.Tensor.t() ``` `flex_plasticmode` — plastic state bits; 1: bend, 2: stretch (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_priority` ```elixir @spec flex_priority(t()) :: ExMujoco.Tensor.t() ``` `flex_priority` — flex contact priority (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_radius` ```elixir @spec flex_radius(t()) :: ExMujoco.Tensor.t() ``` `flex_radius` — radius around primitive element (nflex x 1) `mjtNum*` in C, `nflex` × `1`. # `flex_rgba` ```elixir @spec flex_rgba(t()) :: ExMujoco.Tensor.t() ``` `flex_rgba` — rgba when material is omitted (nflex x 4) `float*` in C, `nflex` × `4`. # `flex_rigid` ```elixir @spec flex_rigid(t()) :: ExMujoco.Tensor.t() ``` `flex_rigid` — are all vertices in the same body (nflex x 1) `mjtBool*` in C, `nflex` × `1`. # `flex_selfcollide` ```elixir @spec flex_selfcollide(t()) :: ExMujoco.Tensor.t() ``` `flex_selfcollide` — self collision mode (mjtFlexSelf) (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_shell` ```elixir @spec flex_shell(t()) :: ExMujoco.Tensor.t() ``` `flex_shell` — shell fragment vertex ids (dim per frag) (nflexshelldata x 1) `int*` in C, `nflexshelldata` × `1`. # `flex_shelldataadr` ```elixir @spec flex_shelldataadr(t()) :: ExMujoco.Tensor.t() ``` `flex_shelldataadr` — first shell data address (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_shellnum` ```elixir @spec flex_shellnum(t()) :: ExMujoco.Tensor.t() ``` `flex_shellnum` — number of shells (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_size` ```elixir @spec flex_size(t()) :: ExMujoco.Tensor.t() ``` `flex_size` — vertex bounding box half sizes in qpos0 (nflex x 3) `mjtNum*` in C, `nflex` × `3`. # `flex_solimp` ```elixir @spec flex_solimp(t()) :: ExMujoco.Tensor.t() ``` `flex_solimp` — constraint solver impedance: contact (nflex x mjNIMP) `mjtNum*` in C, `nflex` × `mjNIMP`. # `flex_solmix` ```elixir @spec flex_solmix(t()) :: ExMujoco.Tensor.t() ``` `flex_solmix` — mix coef for solref/imp in contact pair (nflex x 1) `mjtNum*` in C, `nflex` × `1`. # `flex_solref` ```elixir @spec flex_solref(t()) :: ExMujoco.Tensor.t() ``` `flex_solref` — constraint solver reference: contact (nflex x mjNREF) `mjtNum*` in C, `nflex` × `mjNREF`. # `flex_stiffness` ```elixir @spec flex_stiffness(t()) :: ExMujoco.Tensor.t() ``` `flex_stiffness` — finite element stiffness matrix (nflexstiffness x 1) `mjtNum*` in C, `nflexstiffness` × `1`. # `flex_stiffnessadr` ```elixir @spec flex_stiffnessadr(t()) :: ExMujoco.Tensor.t() ``` `flex_stiffnessadr` — stiffness matrix address (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_texcoord` ```elixir @spec flex_texcoord(t()) :: ExMujoco.Tensor.t() ``` `flex_texcoord` — vertex texture coordinates (nflextexcoord x 2) `float*` in C, `nflextexcoord` × `2`. # `flex_texcoordadr` ```elixir @spec flex_texcoordadr(t()) :: ExMujoco.Tensor.t() ``` `flex_texcoordadr` — address in flex_texcoord; -1: none (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_vert0` ```elixir @spec flex_vert0(t()) :: ExMujoco.Tensor.t() ``` `flex_vert0` — vertex positions in qpos0 on [0, 1]^d (nflexvert x 3) `mjtNum*` in C, `nflexvert` × `3`. # `flex_vert` ```elixir @spec flex_vert(t()) :: ExMujoco.Tensor.t() ``` `flex_vert` — vertex positions in local body frames (nflexvert x 3) `mjtNum*` in C, `nflexvert` × `3`. # `flex_vertadr` ```elixir @spec flex_vertadr(t()) :: ExMujoco.Tensor.t() ``` `flex_vertadr` — first vertex address (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_vertbodyid` ```elixir @spec flex_vertbodyid(t()) :: ExMujoco.Tensor.t() ``` `flex_vertbodyid` — vertex body ids (nflexvert x 1) `int*` in C, `nflexvert` × `1`. # `flex_vertcell` ```elixir @spec flex_vertcell(t()) :: ExMujoco.Tensor.t() ``` `flex_vertcell` — finite cell index for vertex; -1: none (nflexvert x 1) `int*` in C, `nflexvert` × `1`. # `flex_vertnum` ```elixir @spec flex_vertnum(t()) :: ExMujoco.Tensor.t() ``` `flex_vertnum` — number of vertices (nflex x 1) `int*` in C, `nflex` × `1`. # `flex_yield` ```elixir @spec flex_yield(t()) :: ExMujoco.Tensor.t() ``` `flex_yield` — yield strain (stretch, bend); 0: elastic (nflex x 2) `mjtNum*` in C, `nflex` × `2`. # `flexedge_invweight0` ```elixir @spec flexedge_invweight0(t()) :: ExMujoco.Tensor.t() ``` `flexedge_invweight0` — edge inv. weight in qpos0 (nflexedge x 1) `mjtNum*` in C, `nflexedge` × `1`. # `flexedge_J_colind` ```elixir @spec flexedge_J_colind(t()) :: ExMujoco.Tensor.t() ``` `flexedge_J_colind` — column indices in sparse Jacobian (nJfe x 1) `int*` in C, `nJfe` × `1`. # `flexedge_J_rowadr` ```elixir @spec flexedge_J_rowadr(t()) :: ExMujoco.Tensor.t() ``` `flexedge_J_rowadr` — row start address in colind array (nflexedge x 1) `int*` in C, `nflexedge` × `1`. # `flexedge_J_rownnz` ```elixir @spec flexedge_J_rownnz(t()) :: ExMujoco.Tensor.t() ``` `flexedge_J_rownnz` — number of non-zeros in Jacobian row (nflexedge x 1) `int*` in C, `nflexedge` × `1`. # `flexedge_length0` ```elixir @spec flexedge_length0(t()) :: ExMujoco.Tensor.t() ``` `flexedge_length0` — edge lengths in qpos0 (nflexedge x 1) `mjtNum*` in C, `nflexedge` × `1`. # `flexedge_rigid` ```elixir @spec flexedge_rigid(t()) :: ExMujoco.Tensor.t() ``` `flexedge_rigid` — are both edge vertices in same body (nflexedge x 1) `mjtBool*` in C, `nflexedge` × `1`. # `flg_adhesion` ```elixir @spec flg_adhesion(t()) :: integer() ``` `flg_adhesion` — whether any geom or pair has nonzero adhesion `mjtBool` in C, read as an integer. # `flg_gravcomp` ```elixir @spec flg_gravcomp(t()) :: integer() ``` `flg_gravcomp` — whether any body has nonzero gravcomp `mjtBool` in C, read as an integer. # `flg_surfacevel` ```elixir @spec flg_surfacevel(t()) :: integer() ``` `flg_surfacevel` — whether any geom has nonzero surfacevel `mjtBool` in C, read as an integer. # `geom_aabb` ```elixir @spec geom_aabb(t()) :: ExMujoco.Tensor.t() ``` `geom_aabb` — bounding box, (center, size) (ngeom x 6) `mjtNum*` in C, `ngeom` × `6`. # `geom_adhesion` ```elixir @spec geom_adhesion(t()) :: ExMujoco.Tensor.t() ``` `geom_adhesion` — adhesive force of contacts (ngeom x 1) `mjtNum*` in C, `ngeom` × `1`. # `geom_bodyid` ```elixir @spec geom_bodyid(t()) :: ExMujoco.Tensor.t() ``` `geom_bodyid` — id of geom's body (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_castshadow` ```elixir @spec geom_castshadow(t()) :: ExMujoco.Tensor.t() ``` `geom_castshadow` — does geom cast shadows (ngeom x 1) `mjtBool*` in C, `ngeom` × `1`. # `geom_conaffinity` ```elixir @spec geom_conaffinity(t()) :: ExMujoco.Tensor.t() ``` `geom_conaffinity` — geom contact affinity (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_condim` ```elixir @spec geom_condim(t()) :: ExMujoco.Tensor.t() ``` `geom_condim` — contact dimensionality (1, 3, 4, 6) (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_contype` ```elixir @spec geom_contype(t()) :: ExMujoco.Tensor.t() ``` `geom_contype` — geom contact type (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_dataid` ```elixir @spec geom_dataid(t()) :: ExMujoco.Tensor.t() ``` `geom_dataid` — id of geom's mesh/hfield; -1: none (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_fluid` ```elixir @spec geom_fluid(t()) :: ExMujoco.Tensor.t() ``` `geom_fluid` — fluid interaction parameters (ngeom x mjNFLUID) `mjtNum*` in C, `ngeom` × `mjNFLUID`. # `geom_friction` ```elixir @spec geom_friction(t()) :: ExMujoco.Tensor.t() ``` `geom_friction` — friction for (slide, spin, roll) (ngeom x 3) `mjtNum*` in C, `ngeom` × `3`. # `geom_gap` ```elixir @spec geom_gap(t()) :: ExMujoco.Tensor.t() ``` `geom_gap` — additional contact detection buffer (ngeom x 1) `mjtNum*` in C, `ngeom` × `1`. # `geom_group` ```elixir @spec geom_group(t()) :: ExMujoco.Tensor.t() ``` `geom_group` — group for visibility (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_margin` ```elixir @spec geom_margin(t()) :: ExMujoco.Tensor.t() ``` `geom_margin` — geometric inflation for contact (ngeom x 1) `mjtNum*` in C, `ngeom` × `1`. # `geom_matid` ```elixir @spec geom_matid(t()) :: ExMujoco.Tensor.t() ``` `geom_matid` — material id for rendering; -1: none (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_plugin` ```elixir @spec geom_plugin(t()) :: ExMujoco.Tensor.t() ``` `geom_plugin` — plugin instance id; -1: not in use (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_pos` ```elixir @spec geom_pos(t()) :: ExMujoco.Tensor.t() ``` `geom_pos` — local position offset rel. to body (ngeom x 3) `mjtNum*` in C, `ngeom` × `3`. # `geom_priority` ```elixir @spec geom_priority(t()) :: ExMujoco.Tensor.t() ``` `geom_priority` — geom contact priority (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_quat` ```elixir @spec geom_quat(t()) :: ExMujoco.Tensor.t() ``` `geom_quat` — local orientation offset rel. to body (ngeom x 4) `mjtNum*` in C, `ngeom` × `4`. # `geom_rbound` ```elixir @spec geom_rbound(t()) :: ExMujoco.Tensor.t() ``` `geom_rbound` — radius of bounding sphere (ngeom x 1) `mjtNum*` in C, `ngeom` × `1`. # `geom_rgba` ```elixir @spec geom_rgba(t()) :: ExMujoco.Tensor.t() ``` `geom_rgba` — rgba when material is omitted (ngeom x 4) `float*` in C, `ngeom` × `4`. # `geom_sameframe` ```elixir @spec geom_sameframe(t()) :: ExMujoco.Tensor.t() ``` `geom_sameframe` — same frame as body (mjtSameframe) (ngeom x 1) `mjtByte*` in C, `ngeom` × `1`. # `geom_size` ```elixir @spec geom_size(t()) :: ExMujoco.Tensor.t() ``` `geom_size` — geom-specific size parameters (ngeom x 3) `mjtNum*` in C, `ngeom` × `3`. # `geom_solimp` ```elixir @spec geom_solimp(t()) :: ExMujoco.Tensor.t() ``` `geom_solimp` — constraint solver impedance: contact (ngeom x mjNIMP) `mjtNum*` in C, `ngeom` × `mjNIMP`. # `geom_solmix` ```elixir @spec geom_solmix(t()) :: ExMujoco.Tensor.t() ``` `geom_solmix` — mixing coef for solref/imp in geom pair (ngeom x 1) `mjtNum*` in C, `ngeom` × `1`. # `geom_solref` ```elixir @spec geom_solref(t()) :: ExMujoco.Tensor.t() ``` `geom_solref` — constraint solver reference: contact (ngeom x mjNREF) `mjtNum*` in C, `ngeom` × `mjNREF`. # `geom_surfacevel` ```elixir @spec geom_surfacevel(t()) :: ExMujoco.Tensor.t() ``` `geom_surfacevel` — surface velocity in local frame: lin,ang (ngeom x 6) `mjtNum*` in C, `ngeom` × `6`. # `geom_type` ```elixir @spec geom_type(t()) :: ExMujoco.Tensor.t() ``` `geom_type` — geometric type (mjtGeom) (ngeom x 1) `int*` in C, `ngeom` × `1`. # `geom_user` ```elixir @spec geom_user(t()) :: ExMujoco.Tensor.t() ``` `geom_user` — user data (ngeom x nuser_geom) `mjtNum*` in C, `ngeom` × `nuser_geom@model`. # `hfield_adr` ```elixir @spec hfield_adr(t()) :: ExMujoco.Tensor.t() ``` `hfield_adr` — address in hfield_data (nhfield x 1) `int*` in C, `nhfield` × `1`. # `hfield_data` ```elixir @spec hfield_data(t()) :: ExMujoco.Tensor.t() ``` `hfield_data` — elevation data (nhfielddata x 1) `float*` in C, `nhfielddata` × `1`. # `hfield_ncol` ```elixir @spec hfield_ncol(t()) :: ExMujoco.Tensor.t() ``` `hfield_ncol` — number of columns in grid (nhfield x 1) `int*` in C, `nhfield` × `1`. # `hfield_nrow` ```elixir @spec hfield_nrow(t()) :: ExMujoco.Tensor.t() ``` `hfield_nrow` — number of rows in grid (nhfield x 1) `int*` in C, `nhfield` × `1`. # `hfield_pathadr` ```elixir @spec hfield_pathadr(t()) :: ExMujoco.Tensor.t() ``` `hfield_pathadr` — address of hfield asset path; -1: none (nhfield x 1) `int*` in C, `nhfield` × `1`. # `hfield_size` ```elixir @spec hfield_size(t()) :: ExMujoco.Tensor.t() ``` `hfield_size` — (x, y, z_top, z_bottom) (nhfield x 4) `mjtNum*` in C, `nhfield` × `4`. # `jnt_actfrclimited` ```elixir @spec jnt_actfrclimited(t()) :: ExMujoco.Tensor.t() ``` `jnt_actfrclimited` — does joint have actuator force limits (njnt x 1) `mjtBool*` in C, `njnt` × `1`. # `jnt_actfrcrange` ```elixir @spec jnt_actfrcrange(t()) :: ExMujoco.Tensor.t() ``` `jnt_actfrcrange` — range of total actuator force (njnt x 2) `mjtNum*` in C, `njnt` × `2`. # `jnt_actgravcomp` ```elixir @spec jnt_actgravcomp(t()) :: ExMujoco.Tensor.t() ``` `jnt_actgravcomp` — is gravcomp force applied via actuators (njnt x 1) `mjtBool*` in C, `njnt` × `1`. # `jnt_actuatorid` ```elixir @spec jnt_actuatorid(t()) :: ExMujoco.Tensor.t() ``` `jnt_actuatorid` — actuator contributing damping / armature (njnt x 1) `int*` in C, `njnt` × `1`. # `jnt_axis` ```elixir @spec jnt_axis(t()) :: ExMujoco.Tensor.t() ``` `jnt_axis` — local joint axis (njnt x 3) `mjtNum*` in C, `njnt` × `3`. # `jnt_bodyid` ```elixir @spec jnt_bodyid(t()) :: ExMujoco.Tensor.t() ``` `jnt_bodyid` — id of joint's body (njnt x 1) `int*` in C, `njnt` × `1`. # `jnt_dofadr` ```elixir @spec jnt_dofadr(t()) :: ExMujoco.Tensor.t() ``` `jnt_dofadr` — start addr in 'qvel' for joint's data (njnt x 1) `int*` in C, `njnt` × `1`. # `jnt_group` ```elixir @spec jnt_group(t()) :: ExMujoco.Tensor.t() ``` `jnt_group` — group for visibility (njnt x 1) `int*` in C, `njnt` × `1`. # `jnt_limited` ```elixir @spec jnt_limited(t()) :: ExMujoco.Tensor.t() ``` `jnt_limited` — does joint have limits (njnt x 1) `mjtBool*` in C, `njnt` × `1`. # `jnt_margin` ```elixir @spec jnt_margin(t()) :: ExMujoco.Tensor.t() ``` `jnt_margin` — min distance for limit detection (njnt x 1) `mjtNum*` in C, `njnt` × `1`. # `jnt_plasticadr` ```elixir @spec jnt_plasticadr(t()) :: ExMujoco.Tensor.t() ``` `jnt_plasticadr` — start addr in plastic state (-1: none) (njnt x 1) `int*` in C, `njnt` × `1`. # `jnt_pos` ```elixir @spec jnt_pos(t()) :: ExMujoco.Tensor.t() ``` `jnt_pos` — local anchor position (njnt x 3) `mjtNum*` in C, `njnt` × `3`. # `jnt_qposadr` ```elixir @spec jnt_qposadr(t()) :: ExMujoco.Tensor.t() ``` `jnt_qposadr` — start addr in 'qpos' for joint's data (njnt x 1) `int*` in C, `njnt` × `1`. # `jnt_range` ```elixir @spec jnt_range(t()) :: ExMujoco.Tensor.t() ``` `jnt_range` — joint limits (njnt x 2) `mjtNum*` in C, `njnt` × `2`. # `jnt_solimp` ```elixir @spec jnt_solimp(t()) :: ExMujoco.Tensor.t() ``` `jnt_solimp` — constraint solver impedance: limit (njnt x mjNIMP) `mjtNum*` in C, `njnt` × `mjNIMP`. # `jnt_solref` ```elixir @spec jnt_solref(t()) :: ExMujoco.Tensor.t() ``` `jnt_solref` — constraint solver reference: limit (njnt x mjNREF) `mjtNum*` in C, `njnt` × `mjNREF`. # `jnt_springyield` ```elixir @spec jnt_springyield(t()) :: ExMujoco.Tensor.t() ``` `jnt_springyield` — plastic yield threshold (njnt x 1) `mjtNum*` in C, `njnt` × `1`. # `jnt_stiffness` ```elixir @spec jnt_stiffness(t()) :: ExMujoco.Tensor.t() ``` `jnt_stiffness` — linear stiffness coefficient (njnt x 1) `mjtNum*` in C, `njnt` × `1`. # `jnt_stiffnesspoly` ```elixir @spec jnt_stiffnesspoly(t()) :: ExMujoco.Tensor.t() ``` `jnt_stiffnesspoly` — high-order stiffness coefficients (njnt x mjNPOLY) `mjtNum*` in C, `njnt` × `mjNPOLY`. # `jnt_type` ```elixir @spec jnt_type(t()) :: ExMujoco.Tensor.t() ``` `jnt_type` — type of joint (mjtJoint) (njnt x 1) `int*` in C, `njnt` × `1`. # `jnt_user` ```elixir @spec jnt_user(t()) :: ExMujoco.Tensor.t() ``` `jnt_user` — user data (njnt x nuser_jnt) `mjtNum*` in C, `njnt` × `nuser_jnt@model`. # `key_act` ```elixir @spec key_act(t()) :: ExMujoco.Tensor.t() ``` `key_act` — key activation (nkey x na) `mjtNum*` in C, `nkey` × `na@model`. # `key_ctrl` ```elixir @spec key_ctrl(t()) :: ExMujoco.Tensor.t() ``` `key_ctrl` — key control (nkey x nu) `mjtNum*` in C, `nkey` × `nu@model`. # `key_mpos` ```elixir @spec key_mpos(t()) :: ExMujoco.Tensor.t() ``` `key_mpos` — key mocap position (nkey x nmocap*3) `mjtNum*` in C, `nkey` × `nmocap@model*3`. # `key_mquat` ```elixir @spec key_mquat(t()) :: ExMujoco.Tensor.t() ``` `key_mquat` — key mocap quaternion (nkey x nmocap*4) `mjtNum*` in C, `nkey` × `nmocap@model*4`. # `key_plastic` ```elixir @spec key_plastic(t()) :: ExMujoco.Tensor.t() ``` `key_plastic` — key plastic state (nkey x nplastic) `mjtNum*` in C, `nkey` × `nplastic@model`. # `key_qpos` ```elixir @spec key_qpos(t()) :: ExMujoco.Tensor.t() ``` `key_qpos` — key position (nkey x nq) `mjtNum*` in C, `nkey` × `nq@model`. # `key_qvel` ```elixir @spec key_qvel(t()) :: ExMujoco.Tensor.t() ``` `key_qvel` — key velocity (nkey x nv) `mjtNum*` in C, `nkey` × `nv@model`. # `key_time` ```elixir @spec key_time(t()) :: ExMujoco.Tensor.t() ``` `key_time` — key time (nkey x 1) `mjtNum*` in C, `nkey` × `1`. # `light_active` ```elixir @spec light_active(t()) :: ExMujoco.Tensor.t() ``` `light_active` — is light on (nlight x 1) `mjtBool*` in C, `nlight` × `1`. # `light_ambient` ```elixir @spec light_ambient(t()) :: ExMujoco.Tensor.t() ``` `light_ambient` — ambient rgb (alpha=1) (nlight x 3) `float*` in C, `nlight` × `3`. # `light_attenuation` ```elixir @spec light_attenuation(t()) :: ExMujoco.Tensor.t() ``` `light_attenuation` — OpenGL attenuation (quadratic model) (nlight x 3) `float*` in C, `nlight` × `3`. # `light_bodyid` ```elixir @spec light_bodyid(t()) :: ExMujoco.Tensor.t() ``` `light_bodyid` — id of light's body (nlight x 1) `int*` in C, `nlight` × `1`. # `light_bulbradius` ```elixir @spec light_bulbradius(t()) :: ExMujoco.Tensor.t() ``` `light_bulbradius` — light radius for soft shadows (nlight x 1) `float*` in C, `nlight` × `1`. # `light_castshadow` ```elixir @spec light_castshadow(t()) :: ExMujoco.Tensor.t() ``` `light_castshadow` — does light cast shadows (nlight x 1) `mjtBool*` in C, `nlight` × `1`. # `light_cutoff` ```elixir @spec light_cutoff(t()) :: ExMujoco.Tensor.t() ``` `light_cutoff` — OpenGL cutoff (nlight x 1) `float*` in C, `nlight` × `1`. # `light_diffuse` ```elixir @spec light_diffuse(t()) :: ExMujoco.Tensor.t() ``` `light_diffuse` — diffuse rgb (alpha=1) (nlight x 3) `float*` in C, `nlight` × `3`. # `light_dir0` ```elixir @spec light_dir0(t()) :: ExMujoco.Tensor.t() ``` `light_dir0` — global direction in qpos0 (nlight x 3) `mjtNum*` in C, `nlight` × `3`. # `light_dir` ```elixir @spec light_dir(t()) :: ExMujoco.Tensor.t() ``` `light_dir` — direction rel. to body frame (nlight x 3) `mjtNum*` in C, `nlight` × `3`. # `light_exponent` ```elixir @spec light_exponent(t()) :: ExMujoco.Tensor.t() ``` `light_exponent` — OpenGL exponent (nlight x 1) `float*` in C, `nlight` × `1`. # `light_intensity` ```elixir @spec light_intensity(t()) :: ExMujoco.Tensor.t() ``` `light_intensity` — intensity, in candela (nlight x 1) `float*` in C, `nlight` × `1`. # `light_mode` ```elixir @spec light_mode(t()) :: ExMujoco.Tensor.t() ``` `light_mode` — light tracking mode (mjtCamLight) (nlight x 1) `int*` in C, `nlight` × `1`. # `light_pos0` ```elixir @spec light_pos0(t()) :: ExMujoco.Tensor.t() ``` `light_pos0` — global position rel. to body in qpos0 (nlight x 3) `mjtNum*` in C, `nlight` × `3`. # `light_pos` ```elixir @spec light_pos(t()) :: ExMujoco.Tensor.t() ``` `light_pos` — position rel. to body frame (nlight x 3) `mjtNum*` in C, `nlight` × `3`. # `light_poscom0` ```elixir @spec light_poscom0(t()) :: ExMujoco.Tensor.t() ``` `light_poscom0` — global position rel. to sub-com in qpos0 (nlight x 3) `mjtNum*` in C, `nlight` × `3`. # `light_range` ```elixir @spec light_range(t()) :: ExMujoco.Tensor.t() ``` `light_range` — range of effectiveness (nlight x 1) `float*` in C, `nlight` × `1`. # `light_softness` ```elixir @spec light_softness(t()) :: ExMujoco.Tensor.t() ``` `light_softness` — spotlight edge softness (nlight x 1) `float*` in C, `nlight` × `1`. # `light_specular` ```elixir @spec light_specular(t()) :: ExMujoco.Tensor.t() ``` `light_specular` — specular rgb (alpha=1) (nlight x 3) `float*` in C, `nlight` × `3`. # `light_targetbodyid` ```elixir @spec light_targetbodyid(t()) :: ExMujoco.Tensor.t() ``` `light_targetbodyid` — id of targeted body; -1: none (nlight x 1) `int*` in C, `nlight` × `1`. # `light_texid` ```elixir @spec light_texid(t()) :: ExMujoco.Tensor.t() ``` `light_texid` — texture id for image lights (nlight x 1) `int*` in C, `nlight` × `1`. # `light_type` ```elixir @spec light_type(t()) :: ExMujoco.Tensor.t() ``` `light_type` — spot, directional, etc. (mjtLightType) (nlight x 1) `int*` in C, `nlight` × `1`. # `m_colind` ```elixir @spec m_colind(t()) :: ExMujoco.Tensor.t() ``` `M_colind` — reduced inertia: column indices (nC x 1) `int*` in C, `nC` × `1`. # `m_rowadr` ```elixir @spec m_rowadr(t()) :: ExMujoco.Tensor.t() ``` `M_rowadr` — reduced inertia: row addresses (nv x 1) `int*` in C, `nv` × `1`. # `m_rownnz` ```elixir @spec m_rownnz(t()) :: ExMujoco.Tensor.t() ``` `M_rownnz` — reduced inertia: non-zeros in each row (nv x 1) `int*` in C, `nv` × `1`. # `mapD2M` ```elixir @spec mapD2M(t()) :: ExMujoco.Tensor.t() ``` `mapD2M` — index mapping from D to M (nC x 1) `int*` in C, `nC` × `1`. # `mapM2D` ```elixir @spec mapM2D(t()) :: ExMujoco.Tensor.t() ``` `mapM2D` — index mapping from M to D (nD x 1) `int*` in C, `nD` × `1`. # `mapM2M` ```elixir @spec mapM2M(t()) :: ExMujoco.Tensor.t() ``` `mapM2M` — index mapping from qM to M (nC x 1) `int*` in C, `nC` × `1`. # `mat_emission` ```elixir @spec mat_emission(t()) :: ExMujoco.Tensor.t() ``` `mat_emission` — emission (x rgb) (nmat x 1) `float*` in C, `nmat` × `1`. # `mat_metallic` ```elixir @spec mat_metallic(t()) :: ExMujoco.Tensor.t() ``` `mat_metallic` — metallic coef (nmat x 1) `float*` in C, `nmat` × `1`. # `mat_reflectance` ```elixir @spec mat_reflectance(t()) :: ExMujoco.Tensor.t() ``` `mat_reflectance` — reflectance (0: disable) (nmat x 1) `float*` in C, `nmat` × `1`. # `mat_rgba` ```elixir @spec mat_rgba(t()) :: ExMujoco.Tensor.t() ``` `mat_rgba` — rgba (nmat x 4) `float*` in C, `nmat` × `4`. # `mat_roughness` ```elixir @spec mat_roughness(t()) :: ExMujoco.Tensor.t() ``` `mat_roughness` — roughness coef (nmat x 1) `float*` in C, `nmat` × `1`. # `mat_shininess` ```elixir @spec mat_shininess(t()) :: ExMujoco.Tensor.t() ``` `mat_shininess` — shininess coef (nmat x 1) `float*` in C, `nmat` × `1`. # `mat_specular` ```elixir @spec mat_specular(t()) :: ExMujoco.Tensor.t() ``` `mat_specular` — specular (x white) (nmat x 1) `float*` in C, `nmat` × `1`. # `mat_texid` ```elixir @spec mat_texid(t()) :: ExMujoco.Tensor.t() ``` `mat_texid` — indices of textures; -1: none (nmat x mjNTEXROLE) `int*` in C, `nmat` × `mjNTEXROLE`. # `mat_texrepeat` ```elixir @spec mat_texrepeat(t()) :: ExMujoco.Tensor.t() ``` `mat_texrepeat` — texture repetition for 2d mapping (nmat x 2) `float*` in C, `nmat` × `2`. # `mat_texuniform` ```elixir @spec mat_texuniform(t()) :: ExMujoco.Tensor.t() ``` `mat_texuniform` — make texture cube uniform (nmat x 1) `mjtBool*` in C, `nmat` × `1`. # `mesh_bvhadr` ```elixir @spec mesh_bvhadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_bvhadr` — address of bvh root (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_bvhnum` ```elixir @spec mesh_bvhnum(t()) :: ExMujoco.Tensor.t() ``` `mesh_bvhnum` — number of bvh (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_extrema` ```elixir @spec mesh_extrema(t()) :: ExMujoco.Tensor.t() ``` `mesh_extrema` — extremum vertices in 3x3x3 directions (nmesh x 27) `int*` in C, `nmesh` × `27`. # `mesh_face` ```elixir @spec mesh_face(t()) :: ExMujoco.Tensor.t() ``` `mesh_face` — vertex face data (nmeshface x 3) `int*` in C, `nmeshface` × `3`. # `mesh_faceadr` ```elixir @spec mesh_faceadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_faceadr` — first face address (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_facenormal` ```elixir @spec mesh_facenormal(t()) :: ExMujoco.Tensor.t() ``` `mesh_facenormal` — normal face data (nmeshface x 3) `int*` in C, `nmeshface` × `3`. # `mesh_facenum` ```elixir @spec mesh_facenum(t()) :: ExMujoco.Tensor.t() ``` `mesh_facenum` — number of faces (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_facetexcoord` ```elixir @spec mesh_facetexcoord(t()) :: ExMujoco.Tensor.t() ``` `mesh_facetexcoord` — texture face data (nmeshface x 3) `int*` in C, `nmeshface` × `3`. # `mesh_graph` ```elixir @spec mesh_graph(t()) :: ExMujoco.Tensor.t() ``` `mesh_graph` — convex graph data (nmeshgraph x 1) `int*` in C, `nmeshgraph` × `1`. # `mesh_graphadr` ```elixir @spec mesh_graphadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_graphadr` — graph data address; -1: no graph (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_normal` ```elixir @spec mesh_normal(t()) :: ExMujoco.Tensor.t() ``` `mesh_normal` — normals for all meshes (nmeshnormal x 3) `float*` in C, `nmeshnormal` × `3`. # `mesh_normaladr` ```elixir @spec mesh_normaladr(t()) :: ExMujoco.Tensor.t() ``` `mesh_normaladr` — first normal address (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_normalnum` ```elixir @spec mesh_normalnum(t()) :: ExMujoco.Tensor.t() ``` `mesh_normalnum` — number of normals (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_octadr` ```elixir @spec mesh_octadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_octadr` — address of octree root (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_octnum` ```elixir @spec mesh_octnum(t()) :: ExMujoco.Tensor.t() ``` `mesh_octnum` — number of octree nodes (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_pathadr` ```elixir @spec mesh_pathadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_pathadr` — address of asset path for mesh; -1: none (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_polyadr` ```elixir @spec mesh_polyadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_polyadr` — first polygon address per mesh (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_polymap` ```elixir @spec mesh_polymap(t()) :: ExMujoco.Tensor.t() ``` `mesh_polymap` — vertex to polygon map (nmeshpolymap x 1) `int*` in C, `nmeshpolymap` × `1`. # `mesh_polymapadr` ```elixir @spec mesh_polymapadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_polymapadr` — first polygon address per vertex (nmeshvert x 1) `int*` in C, `nmeshvert` × `1`. # `mesh_polymapnum` ```elixir @spec mesh_polymapnum(t()) :: ExMujoco.Tensor.t() ``` `mesh_polymapnum` — number of polygons per vertex (nmeshvert x 1) `int*` in C, `nmeshvert` × `1`. # `mesh_polynormal` ```elixir @spec mesh_polynormal(t()) :: ExMujoco.Tensor.t() ``` `mesh_polynormal` — all polygon normals (nmeshpoly x 3) `mjtNum*` in C, `nmeshpoly` × `3`. # `mesh_polynum` ```elixir @spec mesh_polynum(t()) :: ExMujoco.Tensor.t() ``` `mesh_polynum` — number of polygons per mesh (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_polyvert` ```elixir @spec mesh_polyvert(t()) :: ExMujoco.Tensor.t() ``` `mesh_polyvert` — all polygon vertices (nmeshpolyvert x 1) `int*` in C, `nmeshpolyvert` × `1`. # `mesh_polyvertadr` ```elixir @spec mesh_polyvertadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_polyvertadr` — polygon vertex start address (nmeshpoly x 1) `int*` in C, `nmeshpoly` × `1`. # `mesh_polyvertnum` ```elixir @spec mesh_polyvertnum(t()) :: ExMujoco.Tensor.t() ``` `mesh_polyvertnum` — number of vertices per polygon (nmeshpoly x 1) `int*` in C, `nmeshpoly` × `1`. # `mesh_pos` ```elixir @spec mesh_pos(t()) :: ExMujoco.Tensor.t() ``` `mesh_pos` — translation applied to asset vertices (nmesh x 3) `mjtNum*` in C, `nmesh` × `3`. # `mesh_quat` ```elixir @spec mesh_quat(t()) :: ExMujoco.Tensor.t() ``` `mesh_quat` — rotation applied to asset vertices (nmesh x 4) `mjtNum*` in C, `nmesh` × `4`. # `mesh_scale` ```elixir @spec mesh_scale(t()) :: ExMujoco.Tensor.t() ``` `mesh_scale` — scaling applied to asset vertices (nmesh x 3) `mjtNum*` in C, `nmesh` × `3`. # `mesh_texcoord` ```elixir @spec mesh_texcoord(t()) :: ExMujoco.Tensor.t() ``` `mesh_texcoord` — vertex texcoords for all meshes (nmeshtexcoord x 2) `float*` in C, `nmeshtexcoord` × `2`. # `mesh_texcoordadr` ```elixir @spec mesh_texcoordadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_texcoordadr` — texcoord data address; -1: no texcoord (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_texcoordnum` ```elixir @spec mesh_texcoordnum(t()) :: ExMujoco.Tensor.t() ``` `mesh_texcoordnum` — number of texcoord (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_vert` ```elixir @spec mesh_vert(t()) :: ExMujoco.Tensor.t() ``` `mesh_vert` — vertex positions for all meshes (nmeshvert x 3) `float*` in C, `nmeshvert` × `3`. # `mesh_vertadr` ```elixir @spec mesh_vertadr(t()) :: ExMujoco.Tensor.t() ``` `mesh_vertadr` — first vertex address (nmesh x 1) `int*` in C, `nmesh` × `1`. # `mesh_vertnum` ```elixir @spec mesh_vertnum(t()) :: ExMujoco.Tensor.t() ``` `mesh_vertnum` — number of vertices (nmesh x 1) `int*` in C, `nmesh` × `1`. # `na` ```elixir @spec na(t()) :: integer() ``` `na` — number of activation states = dim(act) `mjtSize` in C, read as an integer. # `nactuator` ```elixir @spec nactuator(t()) :: integer() ``` `nactuator` — number of actuators `mjtSize` in C, read as an integer. # `name_actuatoradr` ```elixir @spec name_actuatoradr(t()) :: ExMujoco.Tensor.t() ``` `name_actuatoradr` — actuator name pointers (nactuator x 1) `int*` in C, `nactuator` × `1`. # `name_bodyadr` ```elixir @spec name_bodyadr(t()) :: ExMujoco.Tensor.t() ``` `name_bodyadr` — body name pointers (nbody x 1) `int*` in C, `nbody` × `1`. # `name_camadr` ```elixir @spec name_camadr(t()) :: ExMujoco.Tensor.t() ``` `name_camadr` — camera name pointers (ncam x 1) `int*` in C, `ncam` × `1`. # `name_eqadr` ```elixir @spec name_eqadr(t()) :: ExMujoco.Tensor.t() ``` `name_eqadr` — equality constraint name pointers (neq x 1) `int*` in C, `neq` × `1`. # `name_excludeadr` ```elixir @spec name_excludeadr(t()) :: ExMujoco.Tensor.t() ``` `name_excludeadr` — exclude name pointers (nexclude x 1) `int*` in C, `nexclude` × `1`. # `name_flexadr` ```elixir @spec name_flexadr(t()) :: ExMujoco.Tensor.t() ``` `name_flexadr` — flex name pointers (nflex x 1) `int*` in C, `nflex` × `1`. # `name_geomadr` ```elixir @spec name_geomadr(t()) :: ExMujoco.Tensor.t() ``` `name_geomadr` — geom name pointers (ngeom x 1) `int*` in C, `ngeom` × `1`. # `name_hfieldadr` ```elixir @spec name_hfieldadr(t()) :: ExMujoco.Tensor.t() ``` `name_hfieldadr` — hfield name pointers (nhfield x 1) `int*` in C, `nhfield` × `1`. # `name_jntadr` ```elixir @spec name_jntadr(t()) :: ExMujoco.Tensor.t() ``` `name_jntadr` — joint name pointers (njnt x 1) `int*` in C, `njnt` × `1`. # `name_keyadr` ```elixir @spec name_keyadr(t()) :: ExMujoco.Tensor.t() ``` `name_keyadr` — keyframe name pointers (nkey x 1) `int*` in C, `nkey` × `1`. # `name_lightadr` ```elixir @spec name_lightadr(t()) :: ExMujoco.Tensor.t() ``` `name_lightadr` — light name pointers (nlight x 1) `int*` in C, `nlight` × `1`. # `name_matadr` ```elixir @spec name_matadr(t()) :: ExMujoco.Tensor.t() ``` `name_matadr` — material name pointers (nmat x 1) `int*` in C, `nmat` × `1`. # `name_meshadr` ```elixir @spec name_meshadr(t()) :: ExMujoco.Tensor.t() ``` `name_meshadr` — mesh name pointers (nmesh x 1) `int*` in C, `nmesh` × `1`. # `name_numericadr` ```elixir @spec name_numericadr(t()) :: ExMujoco.Tensor.t() ``` `name_numericadr` — numeric name pointers (nnumeric x 1) `int*` in C, `nnumeric` × `1`. # `name_pairadr` ```elixir @spec name_pairadr(t()) :: ExMujoco.Tensor.t() ``` `name_pairadr` — geom pair name pointers (npair x 1) `int*` in C, `npair` × `1`. # `name_pluginadr` ```elixir @spec name_pluginadr(t()) :: ExMujoco.Tensor.t() ``` `name_pluginadr` — plugin instance name pointers (nplugin x 1) `int*` in C, `nplugin` × `1`. # `name_sensoradr` ```elixir @spec name_sensoradr(t()) :: ExMujoco.Tensor.t() ``` `name_sensoradr` — sensor name pointers (nsensor x 1) `int*` in C, `nsensor` × `1`. # `name_siteadr` ```elixir @spec name_siteadr(t()) :: ExMujoco.Tensor.t() ``` `name_siteadr` — site name pointers (nsite x 1) `int*` in C, `nsite` × `1`. # `name_skinadr` ```elixir @spec name_skinadr(t()) :: ExMujoco.Tensor.t() ``` `name_skinadr` — skin name pointers (nskin x 1) `int*` in C, `nskin` × `1`. # `name_tendonadr` ```elixir @spec name_tendonadr(t()) :: ExMujoco.Tensor.t() ``` `name_tendonadr` — tendon name pointers (ntendon x 1) `int*` in C, `ntendon` × `1`. # `name_texadr` ```elixir @spec name_texadr(t()) :: ExMujoco.Tensor.t() ``` `name_texadr` — texture name pointers (ntex x 1) `int*` in C, `ntex` × `1`. # `name_textadr` ```elixir @spec name_textadr(t()) :: ExMujoco.Tensor.t() ``` `name_textadr` — text name pointers (ntext x 1) `int*` in C, `ntext` × `1`. # `name_tupleadr` ```elixir @spec name_tupleadr(t()) :: ExMujoco.Tensor.t() ``` `name_tupleadr` — tuple name pointers (ntuple x 1) `int*` in C, `ntuple` × `1`. # `names_map` ```elixir @spec names_map(t()) :: ExMujoco.Tensor.t() ``` `names_map` — internal hash map of names (nnames_map x 1) `int*` in C, `nnames_map` × `1`. # `narena` ```elixir @spec narena(t()) :: integer() ``` `narena` — number of bytes in the mjData arena (inclusive of stack) `mjtSize` in C, read as an integer. # `nB` ```elixir @spec nB(t()) :: integer() ``` `nB` — number of non-zeros in sparse body-dof matrix `mjtSize` in C, read as an integer. # `nbody` ```elixir @spec nbody(t()) :: integer() ``` `nbody` — number of bodies `mjtSize` in C, read as an integer. # `nbuffer` ```elixir @spec nbuffer(t()) :: integer() ``` `nbuffer` — number of bytes in buffer `mjtSize` in C, read as an integer. # `nbvh` ```elixir @spec nbvh(t()) :: integer() ``` `nbvh` — number of total bounding volumes in all bodies `mjtSize` in C, read as an integer. # `nbvhdynamic` ```elixir @spec nbvhdynamic(t()) :: integer() ``` `nbvhdynamic` — number of dynamic bounding volumes (aabb stored in mjData) `mjtSize` in C, read as an integer. # `nbvhstatic` ```elixir @spec nbvhstatic(t()) :: integer() ``` `nbvhstatic` — number of static bounding volumes (aabb stored in mjModel) `mjtSize` in C, read as an integer. # `nC` ```elixir @spec nC(t()) :: integer() ``` `nC` — number of non-zeros in sparse reduced dof-dof matrix `mjtSize` in C, read as an integer. # `ncam` ```elixir @spec ncam(t()) :: integer() ``` `ncam` — number of cameras `mjtSize` in C, read as an integer. # `nconmax` ```elixir @spec nconmax(t()) :: integer() ``` `nconmax` — number of potential contacts in contact list (legacy) `mjtSize` in C, read as an integer. # `nD` ```elixir @spec nD(t()) :: integer() ``` `nD` — number of non-zeros in sparse dof-dof matrix `mjtSize` in C, read as an integer. # `nefm0dof` ```elixir @spec nefm0dof(t()) :: integer() ``` `nefm0dof` — number of dofs covered by the constant metric factor `mjtSize` in C, read as an integer. # `nefm0L` ```elixir @spec nefm0L(t()) :: integer() ``` `nefm0L` — number of non-zeros in the constant metric factor `mjtSize` in C, read as an integer. # `nefmCvert` ```elixir @spec nefmCvert(t()) :: integer() ``` `nefmCvert` — number of sparse metric factor ordering slots `mjtSize` in C, read as an integer. # `nemax` ```elixir @spec nemax(t()) :: integer() ``` `nemax` — number of potential equality-constraint rows `mjtSize` in C, read as an integer. # `neq` ```elixir @spec neq(t()) :: integer() ``` `neq` — number of equality constraints `mjtSize` in C, read as an integer. # `nexclude` ```elixir @spec nexclude(t()) :: integer() ``` `nexclude` — number of excluded geom pairs `mjtSize` in C, read as an integer. # `nflex` ```elixir @spec nflex(t()) :: integer() ``` `nflex` — number of flexes `mjtSize` in C, read as an integer. # `nflexbending` ```elixir @spec nflexbending(t()) :: integer() ``` `nflexbending` — number of bending parameters in all flexes `mjtSize` in C, read as an integer. # `nflexedge` ```elixir @spec nflexedge(t()) :: integer() ``` `nflexedge` — number of edges in all flexes `mjtSize` in C, read as an integer. # `nflexelem` ```elixir @spec nflexelem(t()) :: integer() ``` `nflexelem` — number of elements in all flexes `mjtSize` in C, read as an integer. # `nflexelemdata` ```elixir @spec nflexelemdata(t()) :: integer() ``` `nflexelemdata` — number of element vertex ids in all flexes `mjtSize` in C, read as an integer. # `nflexelemedge` ```elixir @spec nflexelemedge(t()) :: integer() ``` `nflexelemedge` — number of element edge ids in all flexes `mjtSize` in C, read as an integer. # `nflexnode` ```elixir @spec nflexnode(t()) :: integer() ``` `nflexnode` — number of dofs in all flexes `mjtSize` in C, read as an integer. # `nflexshelldata` ```elixir @spec nflexshelldata(t()) :: integer() ``` `nflexshelldata` — number of shell fragment vertex ids in all flexes `mjtSize` in C, read as an integer. # `nflexstiffness` ```elixir @spec nflexstiffness(t()) :: integer() ``` `nflexstiffness` — number of stiffness parameters in all flexes `mjtSize` in C, read as an integer. # `nflextexcoord` ```elixir @spec nflextexcoord(t()) :: integer() ``` `nflextexcoord` — number of vertices with texture coordinates `mjtSize` in C, read as an integer. # `nflexvert` ```elixir @spec nflexvert(t()) :: integer() ``` `nflexvert` — number of vertices in all flexes `mjtSize` in C, read as an integer. # `ngeom` ```elixir @spec ngeom(t()) :: integer() ``` `ngeom` — number of geoms `mjtSize` in C, read as an integer. # `ngravcomp` ```elixir @spec ngravcomp(t()) :: integer() ``` `ngravcomp` — number of bodies with nonzero gravcomp `mjtSize` in C, read as an integer. # `nhfield` ```elixir @spec nhfield(t()) :: integer() ``` `nhfield` — number of heightfields `mjtSize` in C, read as an integer. # `nhfielddata` ```elixir @spec nhfielddata(t()) :: integer() ``` `nhfielddata` — number of data points in all heightfields `mjtSize` in C, read as an integer. # `nhistory` ```elixir @spec nhistory(t()) :: integer() ``` `nhistory` — number of mjtNums in history buffer `mjtSize` in C, read as an integer. # `nJfe` ```elixir @spec nJfe(t()) :: integer() ``` `nJfe` — number of non-zeros in sparse flexedge Jacobian matrix `mjtSize` in C, read as an integer. # `nJmom` ```elixir @spec nJmom(t()) :: integer() ``` `nJmom` — number of non-zeros in sparse actuator_moment matrix `mjtSize` in C, read as an integer. # `nJten` ```elixir @spec nJten(t()) :: integer() ``` `nJten` — number of non-zeros in sparse ten_J matrix `mjtSize` in C, read as an integer. # `njmax` ```elixir @spec njmax(t()) :: integer() ``` `njmax` — number of available rows in constraint Jacobian (legacy) `mjtSize` in C, read as an integer. # `njnt` ```elixir @spec njnt(t()) :: integer() ``` `njnt` — number of joints `mjtSize` in C, read as an integer. # `nkey` ```elixir @spec nkey(t()) :: integer() ``` `nkey` — number of keyframes `mjtSize` in C, read as an integer. # `nlight` ```elixir @spec nlight(t()) :: integer() ``` `nlight` — number of lights `mjtSize` in C, read as an integer. # `nM` ```elixir @spec nM(t()) :: integer() ``` `nM` — number of non-zeros in sparse inertia matrix `mjtSize` in C, read as an integer. # `nmat` ```elixir @spec nmat(t()) :: integer() ``` `nmat` — number of materials `mjtSize` in C, read as an integer. # `nmesh` ```elixir @spec nmesh(t()) :: integer() ``` `nmesh` — number of meshes `mjtSize` in C, read as an integer. # `nmeshdegmax` ```elixir @spec nmeshdegmax(t()) :: integer() ``` `nmeshdegmax` — maximum number of edges adjacent to a mesh vertex `mjtSize` in C, read as an integer. # `nmeshface` ```elixir @spec nmeshface(t()) :: integer() ``` `nmeshface` — number of triangular faces in all meshes `mjtSize` in C, read as an integer. # `nmeshgraph` ```elixir @spec nmeshgraph(t()) :: integer() ``` `nmeshgraph` — number of ints in mesh auxiliary data `mjtSize` in C, read as an integer. # `nmeshnormal` ```elixir @spec nmeshnormal(t()) :: integer() ``` `nmeshnormal` — number of normals in all meshes `mjtSize` in C, read as an integer. # `nmeshpoly` ```elixir @spec nmeshpoly(t()) :: integer() ``` `nmeshpoly` — number of polygons in all meshes `mjtSize` in C, read as an integer. # `nmeshpolymap` ```elixir @spec nmeshpolymap(t()) :: integer() ``` `nmeshpolymap` — number of polygons in vertex map `mjtSize` in C, read as an integer. # `nmeshpolyvert` ```elixir @spec nmeshpolyvert(t()) :: integer() ``` `nmeshpolyvert` — number of vertices in all polygons `mjtSize` in C, read as an integer. # `nmeshtexcoord` ```elixir @spec nmeshtexcoord(t()) :: integer() ``` `nmeshtexcoord` — number of texcoords in all meshes `mjtSize` in C, read as an integer. # `nmeshvert` ```elixir @spec nmeshvert(t()) :: integer() ``` `nmeshvert` — number of vertices in all meshes `mjtSize` in C, read as an integer. # `nmocap` ```elixir @spec nmocap(t()) :: integer() ``` `nmocap` — number of mocap bodies `mjtSize` in C, read as an integer. # `nnames` ```elixir @spec nnames(t()) :: integer() ``` `nnames` — number of chars in all names `mjtSize` in C, read as an integer. # `nnames_map` ```elixir @spec nnames_map(t()) :: integer() ``` `nnames_map` — number of slots in the names hash map `mjtSize` in C, read as an integer. # `nnumeric` ```elixir @spec nnumeric(t()) :: integer() ``` `nnumeric` — number of numeric custom fields `mjtSize` in C, read as an integer. # `nnumericdata` ```elixir @spec nnumericdata(t()) :: integer() ``` `nnumericdata` — number of mjtNums in all numeric fields `mjtSize` in C, read as an integer. # `noct` ```elixir @spec noct(t()) :: integer() ``` `noct` — number of total octree cells in all meshes `mjtSize` in C, read as an integer. # `nout` ```elixir @spec nout(t()) :: integer() ``` `nout` — number of force outputs, derived from transmission type `mjtSize` in C, read as an integer. # `npair` ```elixir @spec npair(t()) :: integer() ``` `npair` — number of predefined geom pairs `mjtSize` in C, read as an integer. # `npaths` ```elixir @spec npaths(t()) :: integer() ``` `npaths` — number of chars in all paths `mjtSize` in C, read as an integer. # `nplastic` ```elixir @spec nplastic(t()) :: integer() ``` `nplastic` — number of mjtNums in plastic state vector `mjtSize` in C, read as an integer. # `nplugin` ```elixir @spec nplugin(t()) :: integer() ``` `nplugin` — number of plugin instances `mjtSize` in C, read as an integer. # `npluginattr` ```elixir @spec npluginattr(t()) :: integer() ``` `npluginattr` — number of chars in all plugin config attributes `mjtSize` in C, read as an integer. # `npluginstate` ```elixir @spec npluginstate(t()) :: integer() ``` `npluginstate` — number of mjtNums in plugin state vector `mjtSize` in C, read as an integer. # `npolygonmax` ```elixir @spec npolygonmax(t()) :: integer() ``` `npolygonmax` — maximum number of vertices in a mesh polygon `mjtSize` in C, read as an integer. # `nq` ```elixir @spec nq(t()) :: integer() ``` `nq` — number of generalized coordinates = dim(qpos) `mjtSize` in C, read as an integer. # `nsensor` ```elixir @spec nsensor(t()) :: integer() ``` `nsensor` — number of sensors `mjtSize` in C, read as an integer. # `nsensordata` ```elixir @spec nsensordata(t()) :: integer() ``` `nsensordata` — number of mjtNums in sensor data vector `mjtSize` in C, read as an integer. # `nsite` ```elixir @spec nsite(t()) :: integer() ``` `nsite` — number of sites `mjtSize` in C, read as an integer. # `nskin` ```elixir @spec nskin(t()) :: integer() ``` `nskin` — number of skins `mjtSize` in C, read as an integer. # `nskinbone` ```elixir @spec nskinbone(t()) :: integer() ``` `nskinbone` — number of bones in all skins `mjtSize` in C, read as an integer. # `nskinbonevert` ```elixir @spec nskinbonevert(t()) :: integer() ``` `nskinbonevert` — number of vertices in all skin bones `mjtSize` in C, read as an integer. # `nskinface` ```elixir @spec nskinface(t()) :: integer() ``` `nskinface` — number of triangular faces in all skins `mjtSize` in C, read as an integer. # `nskintexvert` ```elixir @spec nskintexvert(t()) :: integer() ``` `nskintexvert` — number of vertices with texcoords in all skins `mjtSize` in C, read as an integer. # `nskinvert` ```elixir @spec nskinvert(t()) :: integer() ``` `nskinvert` — number of vertices in all skins `mjtSize` in C, read as an integer. # `ntendon` ```elixir @spec ntendon(t()) :: integer() ``` `ntendon` — number of tendons `mjtSize` in C, read as an integer. # `ntex` ```elixir @spec ntex(t()) :: integer() ``` `ntex` — number of textures `mjtSize` in C, read as an integer. # `ntexdata` ```elixir @spec ntexdata(t()) :: integer() ``` `ntexdata` — number of bytes in texture rgb data `mjtSize` in C, read as an integer. # `ntext` ```elixir @spec ntext(t()) :: integer() ``` `ntext` — number of text custom fields `mjtSize` in C, read as an integer. # `ntextdata` ```elixir @spec ntextdata(t()) :: integer() ``` `ntextdata` — number of mjtBytes in all text fields `mjtSize` in C, read as an integer. # `ntree` ```elixir @spec ntree(t()) :: integer() ``` `ntree` — number of kinematic trees under world body `mjtSize` in C, read as an integer. # `ntuple` ```elixir @spec ntuple(t()) :: integer() ``` `ntuple` — number of tuple custom fields `mjtSize` in C, read as an integer. # `ntupledata` ```elixir @spec ntupledata(t()) :: integer() ``` `ntupledata` — number of objects in all tuple fields `mjtSize` in C, read as an integer. # `nu` ```elixir @spec nu(t()) :: integer() ``` `nu` — number of scalar controls = dim(ctrl) `mjtSize` in C, read as an integer. # `numeric_adr` ```elixir @spec numeric_adr(t()) :: ExMujoco.Tensor.t() ``` `numeric_adr` — address of field in numeric_data (nnumeric x 1) `int*` in C, `nnumeric` × `1`. # `numeric_data` ```elixir @spec numeric_data(t()) :: ExMujoco.Tensor.t() ``` `numeric_data` — array of all numeric fields (nnumericdata x 1) `mjtNum*` in C, `nnumericdata` × `1`. # `numeric_size` ```elixir @spec numeric_size(t()) :: ExMujoco.Tensor.t() ``` `numeric_size` — size of numeric field (nnumeric x 1) `int*` in C, `nnumeric` × `1`. # `nuser_actuator` ```elixir @spec nuser_actuator(t()) :: integer() ``` `nuser_actuator` — number of mjtNums in actuator_user `mjtSize` in C, read as an integer. # `nuser_body` ```elixir @spec nuser_body(t()) :: integer() ``` `nuser_body` — number of mjtNums in body_user `mjtSize` in C, read as an integer. # `nuser_cam` ```elixir @spec nuser_cam(t()) :: integer() ``` `nuser_cam` — number of mjtNums in cam_user `mjtSize` in C, read as an integer. # `nuser_geom` ```elixir @spec nuser_geom(t()) :: integer() ``` `nuser_geom` — number of mjtNums in geom_user `mjtSize` in C, read as an integer. # `nuser_jnt` ```elixir @spec nuser_jnt(t()) :: integer() ``` `nuser_jnt` — number of mjtNums in jnt_user `mjtSize` in C, read as an integer. # `nuser_sensor` ```elixir @spec nuser_sensor(t()) :: integer() ``` `nuser_sensor` — number of mjtNums in sensor_user `mjtSize` in C, read as an integer. # `nuser_site` ```elixir @spec nuser_site(t()) :: integer() ``` `nuser_site` — number of mjtNums in site_user `mjtSize` in C, read as an integer. # `nuser_tendon` ```elixir @spec nuser_tendon(t()) :: integer() ``` `nuser_tendon` — number of mjtNums in tendon_user `mjtSize` in C, read as an integer. # `nuserdata` ```elixir @spec nuserdata(t()) :: integer() ``` `nuserdata` — number of mjtNums reserved for the user `mjtSize` in C, read as an integer. # `nv` ```elixir @spec nv(t()) :: integer() ``` `nv` — number of degrees of freedom = dim(qvel) `mjtSize` in C, read as an integer. # `nwrap` ```elixir @spec nwrap(t()) :: integer() ``` `nwrap` — number of wrap objects in all tendon paths `mjtSize` in C, read as an integer. # `oct_aabb` ```elixir @spec oct_aabb(t()) :: ExMujoco.Tensor.t() ``` `oct_aabb` — octree node bounding box (center, size) (noct x 6) `mjtNum*` in C, `noct` × `6`. # `oct_child` ```elixir @spec oct_child(t()) :: ExMujoco.Tensor.t() ``` `oct_child` — children of octree node (noct x 8) `int*` in C, `noct` × `8`. # `oct_coeff` ```elixir @spec oct_coeff(t()) :: ExMujoco.Tensor.t() ``` `oct_coeff` — octree interpolation coefficients (noct x 8) `mjtNum*` in C, `noct` × `8`. # `oct_depth` ```elixir @spec oct_depth(t()) :: ExMujoco.Tensor.t() ``` `oct_depth` — depth in the octree (noct x 1) `int*` in C, `noct` × `1`. # `pair_adhesion` ```elixir @spec pair_adhesion(t()) :: ExMujoco.Tensor.t() ``` `pair_adhesion` — adhesive force of contacts (npair x 1) `mjtNum*` in C, `npair` × `1`. # `pair_dim` ```elixir @spec pair_dim(t()) :: ExMujoco.Tensor.t() ``` `pair_dim` — contact dimensionality (npair x 1) `int*` in C, `npair` × `1`. # `pair_friction` ```elixir @spec pair_friction(t()) :: ExMujoco.Tensor.t() ``` `pair_friction` — tangent1, 2, spin, roll1, 2 (npair x 5) `mjtNum*` in C, `npair` × `5`. # `pair_gap` ```elixir @spec pair_gap(t()) :: ExMujoco.Tensor.t() ``` `pair_gap` — additional contact detection buffer (npair x 1) `mjtNum*` in C, `npair` × `1`. # `pair_geom1` ```elixir @spec pair_geom1(t()) :: ExMujoco.Tensor.t() ``` `pair_geom1` — id of geom1 (npair x 1) `int*` in C, `npair` × `1`. # `pair_geom2` ```elixir @spec pair_geom2(t()) :: ExMujoco.Tensor.t() ``` `pair_geom2` — id of geom2 (npair x 1) `int*` in C, `npair` × `1`. # `pair_margin` ```elixir @spec pair_margin(t()) :: ExMujoco.Tensor.t() ``` `pair_margin` — geometric inflation for contact (npair x 1) `mjtNum*` in C, `npair` × `1`. # `pair_signature` ```elixir @spec pair_signature(t()) :: ExMujoco.Tensor.t() ``` `pair_signature` — body1 << 16 + body2 (npair x 1) `int*` in C, `npair` × `1`. # `pair_solimp` ```elixir @spec pair_solimp(t()) :: ExMujoco.Tensor.t() ``` `pair_solimp` — solver impedance: contact (npair x mjNIMP) `mjtNum*` in C, `npair` × `mjNIMP`. # `pair_solref` ```elixir @spec pair_solref(t()) :: ExMujoco.Tensor.t() ``` `pair_solref` — solver reference: contact normal (npair x mjNREF) `mjtNum*` in C, `npair` × `mjNREF`. # `pair_solreffriction` ```elixir @spec pair_solreffriction(t()) :: ExMujoco.Tensor.t() ``` `pair_solreffriction` — solver reference: contact friction (npair x mjNREF) `mjtNum*` in C, `npair` × `mjNREF`. # `plugin` ```elixir @spec plugin(t()) :: ExMujoco.Tensor.t() ``` `plugin` — globally registered plugin slot number (nplugin x 1) `int*` in C, `nplugin` × `1`. # `plugin_attradr` ```elixir @spec plugin_attradr(t()) :: ExMujoco.Tensor.t() ``` `plugin_attradr` — address to each instance's config attrib (nplugin x 1) `int*` in C, `nplugin` × `1`. # `plugin_stateadr` ```elixir @spec plugin_stateadr(t()) :: ExMujoco.Tensor.t() ``` `plugin_stateadr` — address in the plugin state array (nplugin x 1) `int*` in C, `nplugin` × `1`. # `plugin_statenum` ```elixir @spec plugin_statenum(t()) :: ExMujoco.Tensor.t() ``` `plugin_statenum` — number of states in the plugin instance (nplugin x 1) `int*` in C, `nplugin` × `1`. # `qpos0` ```elixir @spec qpos0(t()) :: ExMujoco.Tensor.t() ``` `qpos0` — qpos values at default pose (nq x 1) `mjtNum*` in C, `nq` × `1`. # `qpos_spring` ```elixir @spec qpos_spring(t()) :: ExMujoco.Tensor.t() ``` `qpos_spring` — reference pose for springs (nq x 1) `mjtNum*` in C, `nq` × `1`. # `sensor_adr` ```elixir @spec sensor_adr(t()) :: ExMujoco.Tensor.t() ``` `sensor_adr` — address in sensor array (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_cutoff` ```elixir @spec sensor_cutoff(t()) :: ExMujoco.Tensor.t() ``` `sensor_cutoff` — cutoff for real and positive; 0: ignore (nsensor x 1) `mjtNum*` in C, `nsensor` × `1`. # `sensor_datatype` ```elixir @spec sensor_datatype(t()) :: ExMujoco.Tensor.t() ``` `sensor_datatype` — numeric data type (mjtDataType) (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_delay` ```elixir @spec sensor_delay(t()) :: ExMujoco.Tensor.t() ``` `sensor_delay` — delay time in seconds; 0: no delay (nsensor x 1) `mjtNum*` in C, `nsensor` × `1`. # `sensor_dim` ```elixir @spec sensor_dim(t()) :: ExMujoco.Tensor.t() ``` `sensor_dim` — number of scalar outputs (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_history` ```elixir @spec sensor_history(t()) :: ExMujoco.Tensor.t() ``` `sensor_history` — history buffer: [nsample, interp] (nsensor x 2) `int*` in C, `nsensor` × `2`. # `sensor_historyadr` ```elixir @spec sensor_historyadr(t()) :: ExMujoco.Tensor.t() ``` `sensor_historyadr` — address in history buffer; -1: none (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_interval` ```elixir @spec sensor_interval(t()) :: ExMujoco.Tensor.t() ``` `sensor_interval` — interval: [period, phase] in seconds (nsensor x 2) `mjtNum*` in C, `nsensor` × `2`. # `sensor_intprm` ```elixir @spec sensor_intprm(t()) :: ExMujoco.Tensor.t() ``` `sensor_intprm` — sensor parameters (nsensor x mjNSENS) `int*` in C, `nsensor` × `mjNSENS`. # `sensor_needstage` ```elixir @spec sensor_needstage(t()) :: ExMujoco.Tensor.t() ``` `sensor_needstage` — required compute stage (mjtStage) (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_noise` ```elixir @spec sensor_noise(t()) :: ExMujoco.Tensor.t() ``` `sensor_noise` — noise standard deviation (nsensor x 1) `mjtNum*` in C, `nsensor` × `1`. # `sensor_objid` ```elixir @spec sensor_objid(t()) :: ExMujoco.Tensor.t() ``` `sensor_objid` — id of sensorized object (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_objtype` ```elixir @spec sensor_objtype(t()) :: ExMujoco.Tensor.t() ``` `sensor_objtype` — type of sensorized object (mjtObj) (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_plugin` ```elixir @spec sensor_plugin(t()) :: ExMujoco.Tensor.t() ``` `sensor_plugin` — plugin instance id; -1: not a plugin (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_refid` ```elixir @spec sensor_refid(t()) :: ExMujoco.Tensor.t() ``` `sensor_refid` — id of reference frame; -1: global frame (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_reftype` ```elixir @spec sensor_reftype(t()) :: ExMujoco.Tensor.t() ``` `sensor_reftype` — type of reference frame (mjtObj) (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_type` ```elixir @spec sensor_type(t()) :: ExMujoco.Tensor.t() ``` `sensor_type` — sensor type (mjtSensor) (nsensor x 1) `int*` in C, `nsensor` × `1`. # `sensor_user` ```elixir @spec sensor_user(t()) :: ExMujoco.Tensor.t() ``` `sensor_user` — user data (nsensor x nuser_sensor) `mjtNum*` in C, `nsensor` × `nuser_sensor@model`. # `site_bodyid` ```elixir @spec site_bodyid(t()) :: ExMujoco.Tensor.t() ``` `site_bodyid` — id of site's body (nsite x 1) `int*` in C, `nsite` × `1`. # `site_dataid` ```elixir @spec site_dataid(t()) :: ExMujoco.Tensor.t() ``` `site_dataid` — id of site's mesh; -1: none (nsite x 1) `int*` in C, `nsite` × `1`. # `site_group` ```elixir @spec site_group(t()) :: ExMujoco.Tensor.t() ``` `site_group` — group for visibility (nsite x 1) `int*` in C, `nsite` × `1`. # `site_matid` ```elixir @spec site_matid(t()) :: ExMujoco.Tensor.t() ``` `site_matid` — material id for rendering; -1: none (nsite x 1) `int*` in C, `nsite` × `1`. # `site_pos` ```elixir @spec site_pos(t()) :: ExMujoco.Tensor.t() ``` `site_pos` — local position offset rel. to body (nsite x 3) `mjtNum*` in C, `nsite` × `3`. # `site_quat` ```elixir @spec site_quat(t()) :: ExMujoco.Tensor.t() ``` `site_quat` — local orientation offset rel. to body (nsite x 4) `mjtNum*` in C, `nsite` × `4`. # `site_rgba` ```elixir @spec site_rgba(t()) :: ExMujoco.Tensor.t() ``` `site_rgba` — rgba when material is omitted (nsite x 4) `float*` in C, `nsite` × `4`. # `site_sameframe` ```elixir @spec site_sameframe(t()) :: ExMujoco.Tensor.t() ``` `site_sameframe` — same frame as body (mjtSameframe) (nsite x 1) `mjtByte*` in C, `nsite` × `1`. # `site_size` ```elixir @spec site_size(t()) :: ExMujoco.Tensor.t() ``` `site_size` — geom size for rendering (nsite x 3) `mjtNum*` in C, `nsite` × `3`. # `site_type` ```elixir @spec site_type(t()) :: ExMujoco.Tensor.t() ``` `site_type` — geom type for rendering (mjtGeom) (nsite x 1) `int*` in C, `nsite` × `1`. # `site_user` ```elixir @spec site_user(t()) :: ExMujoco.Tensor.t() ``` `site_user` — user data (nsite x nuser_site) `mjtNum*` in C, `nsite` × `nuser_site@model`. # `skin_boneadr` ```elixir @spec skin_boneadr(t()) :: ExMujoco.Tensor.t() ``` `skin_boneadr` — first bone in skin (nskin x 1) `int*` in C, `nskin` × `1`. # `skin_bonebindpos` ```elixir @spec skin_bonebindpos(t()) :: ExMujoco.Tensor.t() ``` `skin_bonebindpos` — bind pos of each bone (nskinbone x 3) `float*` in C, `nskinbone` × `3`. # `skin_bonebindquat` ```elixir @spec skin_bonebindquat(t()) :: ExMujoco.Tensor.t() ``` `skin_bonebindquat` — bind quat of each bone (nskinbone x 4) `float*` in C, `nskinbone` × `4`. # `skin_bonebodyid` ```elixir @spec skin_bonebodyid(t()) :: ExMujoco.Tensor.t() ``` `skin_bonebodyid` — body id of each bone (nskinbone x 1) `int*` in C, `nskinbone` × `1`. # `skin_bonenum` ```elixir @spec skin_bonenum(t()) :: ExMujoco.Tensor.t() ``` `skin_bonenum` — number of bones in skin (nskin x 1) `int*` in C, `nskin` × `1`. # `skin_bonevertadr` ```elixir @spec skin_bonevertadr(t()) :: ExMujoco.Tensor.t() ``` `skin_bonevertadr` — first vertex in each bone (nskinbone x 1) `int*` in C, `nskinbone` × `1`. # `skin_bonevertid` ```elixir @spec skin_bonevertid(t()) :: ExMujoco.Tensor.t() ``` `skin_bonevertid` — mesh ids of vertices in each bone (nskinbonevert x 1) `int*` in C, `nskinbonevert` × `1`. # `skin_bonevertnum` ```elixir @spec skin_bonevertnum(t()) :: ExMujoco.Tensor.t() ``` `skin_bonevertnum` — number of vertices in each bone (nskinbone x 1) `int*` in C, `nskinbone` × `1`. # `skin_bonevertweight` ```elixir @spec skin_bonevertweight(t()) :: ExMujoco.Tensor.t() ``` `skin_bonevertweight` — weights of vertices in each bone (nskinbonevert x 1) `float*` in C, `nskinbonevert` × `1`. # `skin_face` ```elixir @spec skin_face(t()) :: ExMujoco.Tensor.t() ``` `skin_face` — triangle faces for all skin meshes (nskinface x 3) `int*` in C, `nskinface` × `3`. # `skin_faceadr` ```elixir @spec skin_faceadr(t()) :: ExMujoco.Tensor.t() ``` `skin_faceadr` — first face address (nskin x 1) `int*` in C, `nskin` × `1`. # `skin_facenum` ```elixir @spec skin_facenum(t()) :: ExMujoco.Tensor.t() ``` `skin_facenum` — number of faces (nskin x 1) `int*` in C, `nskin` × `1`. # `skin_group` ```elixir @spec skin_group(t()) :: ExMujoco.Tensor.t() ``` `skin_group` — group for visibility (nskin x 1) `int*` in C, `nskin` × `1`. # `skin_inflate` ```elixir @spec skin_inflate(t()) :: ExMujoco.Tensor.t() ``` `skin_inflate` — inflate skin in normal direction (nskin x 1) `float*` in C, `nskin` × `1`. # `skin_matid` ```elixir @spec skin_matid(t()) :: ExMujoco.Tensor.t() ``` `skin_matid` — skin material id; -1: none (nskin x 1) `int*` in C, `nskin` × `1`. # `skin_pathadr` ```elixir @spec skin_pathadr(t()) :: ExMujoco.Tensor.t() ``` `skin_pathadr` — address of asset path for skin; -1: none (nskin x 1) `int*` in C, `nskin` × `1`. # `skin_rgba` ```elixir @spec skin_rgba(t()) :: ExMujoco.Tensor.t() ``` `skin_rgba` — skin rgba (nskin x 4) `float*` in C, `nskin` × `4`. # `skin_texcoord` ```elixir @spec skin_texcoord(t()) :: ExMujoco.Tensor.t() ``` `skin_texcoord` — vertex texcoords for all skin meshes (nskintexvert x 2) `float*` in C, `nskintexvert` × `2`. # `skin_texcoordadr` ```elixir @spec skin_texcoordadr(t()) :: ExMujoco.Tensor.t() ``` `skin_texcoordadr` — texcoord data address; -1: no texcoord (nskin x 1) `int*` in C, `nskin` × `1`. # `skin_vert` ```elixir @spec skin_vert(t()) :: ExMujoco.Tensor.t() ``` `skin_vert` — vertex positions for all skin meshes (nskinvert x 3) `float*` in C, `nskinvert` × `3`. # `skin_vertadr` ```elixir @spec skin_vertadr(t()) :: ExMujoco.Tensor.t() ``` `skin_vertadr` — first vertex address (nskin x 1) `int*` in C, `nskin` × `1`. # `skin_vertnum` ```elixir @spec skin_vertnum(t()) :: ExMujoco.Tensor.t() ``` `skin_vertnum` — number of vertices (nskin x 1) `int*` in C, `nskin` × `1`. # `ten_J_colind` ```elixir @spec ten_J_colind(t()) :: ExMujoco.Tensor.t() ``` `ten_J_colind` — column indices in sparse Jacobian (nJten x 1) `int*` in C, `nJten` × `1`. # `ten_J_rowadr` ```elixir @spec ten_J_rowadr(t()) :: ExMujoco.Tensor.t() ``` `ten_J_rowadr` — row start address in colind array (ntendon x 1) `int*` in C, `ntendon` × `1`. # `ten_J_rownnz` ```elixir @spec ten_J_rownnz(t()) :: ExMujoco.Tensor.t() ``` `ten_J_rownnz` — number of non-zeros in Jacobian row (ntendon x 1) `int*` in C, `ntendon` × `1`. # `tendon_actfrclimited` ```elixir @spec tendon_actfrclimited(t()) :: ExMujoco.Tensor.t() ``` `tendon_actfrclimited` — does tendon have actuator force limits (ntendon x 1) `mjtBool*` in C, `ntendon` × `1`. # `tendon_actfrcrange` ```elixir @spec tendon_actfrcrange(t()) :: ExMujoco.Tensor.t() ``` `tendon_actfrcrange` — range of total actuator force (ntendon x 2) `mjtNum*` in C, `ntendon` × `2`. # `tendon_actuatorid` ```elixir @spec tendon_actuatorid(t()) :: ExMujoco.Tensor.t() ``` `tendon_actuatorid` — actuator contributing damping / armature (ntendon x 1) `int*` in C, `ntendon` × `1`. # `tendon_adr` ```elixir @spec tendon_adr(t()) :: ExMujoco.Tensor.t() ``` `tendon_adr` — address of first object in tendon's path (ntendon x 1) `int*` in C, `ntendon` × `1`. # `tendon_armature` ```elixir @spec tendon_armature(t()) :: ExMujoco.Tensor.t() ``` `tendon_armature` — inertia associated with tendon velocity (ntendon x 1) `mjtNum*` in C, `ntendon` × `1`. # `tendon_damping` ```elixir @spec tendon_damping(t()) :: ExMujoco.Tensor.t() ``` `tendon_damping` — linear damping coefficient (ntendon x 1) `mjtNum*` in C, `ntendon` × `1`. # `tendon_dampingpoly` ```elixir @spec tendon_dampingpoly(t()) :: ExMujoco.Tensor.t() ``` `tendon_dampingpoly` — high-order damping coefficients (ntendon x mjNPOLY) `mjtNum*` in C, `ntendon` × `mjNPOLY`. # `tendon_frictionloss` ```elixir @spec tendon_frictionloss(t()) :: ExMujoco.Tensor.t() ``` `tendon_frictionloss` — loss due to friction (ntendon x 1) `mjtNum*` in C, `ntendon` × `1`. # `tendon_group` ```elixir @spec tendon_group(t()) :: ExMujoco.Tensor.t() ``` `tendon_group` — group for visibility (ntendon x 1) `int*` in C, `ntendon` × `1`. # `tendon_invweight0` ```elixir @spec tendon_invweight0(t()) :: ExMujoco.Tensor.t() ``` `tendon_invweight0` — inv. weight in qpos0 (ntendon x 1) `mjtNum*` in C, `ntendon` × `1`. # `tendon_length0` ```elixir @spec tendon_length0(t()) :: ExMujoco.Tensor.t() ``` `tendon_length0` — tendon length in qpos0 (ntendon x 1) `mjtNum*` in C, `ntendon` × `1`. # `tendon_lengthspring` ```elixir @spec tendon_lengthspring(t()) :: ExMujoco.Tensor.t() ``` `tendon_lengthspring` — spring resting length range (ntendon x 2) `mjtNum*` in C, `ntendon` × `2`. # `tendon_limited` ```elixir @spec tendon_limited(t()) :: ExMujoco.Tensor.t() ``` `tendon_limited` — does tendon have length limits (ntendon x 1) `mjtBool*` in C, `ntendon` × `1`. # `tendon_margin` ```elixir @spec tendon_margin(t()) :: ExMujoco.Tensor.t() ``` `tendon_margin` — min distance for limit detection (ntendon x 1) `mjtNum*` in C, `ntendon` × `1`. # `tendon_matid` ```elixir @spec tendon_matid(t()) :: ExMujoco.Tensor.t() ``` `tendon_matid` — material id for rendering (ntendon x 1) `int*` in C, `ntendon` × `1`. # `tendon_num` ```elixir @spec tendon_num(t()) :: ExMujoco.Tensor.t() ``` `tendon_num` — number of objects in tendon's path (ntendon x 1) `int*` in C, `ntendon` × `1`. # `tendon_plasticadr` ```elixir @spec tendon_plasticadr(t()) :: ExMujoco.Tensor.t() ``` `tendon_plasticadr` — start addr in plastic state (-1: none) (ntendon x 1) `int*` in C, `ntendon` × `1`. # `tendon_range` ```elixir @spec tendon_range(t()) :: ExMujoco.Tensor.t() ``` `tendon_range` — tendon length limits (ntendon x 2) `mjtNum*` in C, `ntendon` × `2`. # `tendon_rgba` ```elixir @spec tendon_rgba(t()) :: ExMujoco.Tensor.t() ``` `tendon_rgba` — rgba when material is omitted (ntendon x 4) `float*` in C, `ntendon` × `4`. # `tendon_solimp_fri` ```elixir @spec tendon_solimp_fri(t()) :: ExMujoco.Tensor.t() ``` `tendon_solimp_fri` — constraint solver impedance: friction (ntendon x mjNIMP) `mjtNum*` in C, `ntendon` × `mjNIMP`. # `tendon_solimp_lim` ```elixir @spec tendon_solimp_lim(t()) :: ExMujoco.Tensor.t() ``` `tendon_solimp_lim` — constraint solver impedance: limit (ntendon x mjNIMP) `mjtNum*` in C, `ntendon` × `mjNIMP`. # `tendon_solref_fri` ```elixir @spec tendon_solref_fri(t()) :: ExMujoco.Tensor.t() ``` `tendon_solref_fri` — constraint solver reference: friction (ntendon x mjNREF) `mjtNum*` in C, `ntendon` × `mjNREF`. # `tendon_solref_lim` ```elixir @spec tendon_solref_lim(t()) :: ExMujoco.Tensor.t() ``` `tendon_solref_lim` — constraint solver reference: limit (ntendon x mjNREF) `mjtNum*` in C, `ntendon` × `mjNREF`. # `tendon_springyield` ```elixir @spec tendon_springyield(t()) :: ExMujoco.Tensor.t() ``` `tendon_springyield` — plastic yield threshold (ntendon x 1) `mjtNum*` in C, `ntendon` × `1`. # `tendon_stiffness` ```elixir @spec tendon_stiffness(t()) :: ExMujoco.Tensor.t() ``` `tendon_stiffness` — linear stiffness coefficient (ntendon x 1) `mjtNum*` in C, `ntendon` × `1`. # `tendon_stiffnesspoly` ```elixir @spec tendon_stiffnesspoly(t()) :: ExMujoco.Tensor.t() ``` `tendon_stiffnesspoly` — high-order stiffness coefficients (ntendon x mjNPOLY) `mjtNum*` in C, `ntendon` × `mjNPOLY`. # `tendon_treeid` ```elixir @spec tendon_treeid(t()) :: ExMujoco.Tensor.t() ``` `tendon_treeid` — first two trees along tendon's path (ntendon x 2) `int*` in C, `ntendon` × `2`. # `tendon_treenum` ```elixir @spec tendon_treenum(t()) :: ExMujoco.Tensor.t() ``` `tendon_treenum` — number of trees along tendon's path (ntendon x 1) `int*` in C, `ntendon` × `1`. # `tendon_type` ```elixir @spec tendon_type(t()) :: ExMujoco.Tensor.t() ``` `tendon_type` — type of tendon (mjtTendon) (ntendon x 1) `int*` in C, `ntendon` × `1`. # `tendon_user` ```elixir @spec tendon_user(t()) :: ExMujoco.Tensor.t() ``` `tendon_user` — user data (ntendon x nuser_tendon) `mjtNum*` in C, `ntendon` × `nuser_tendon@model`. # `tendon_width` ```elixir @spec tendon_width(t()) :: ExMujoco.Tensor.t() ``` `tendon_width` — width for rendering (ntendon x 1) `mjtNum*` in C, `ntendon` × `1`. # `tex_colorspace` ```elixir @spec tex_colorspace(t()) :: ExMujoco.Tensor.t() ``` `tex_colorspace` — texture colorspace (mjtColorSpace) (ntex x 1) `int*` in C, `ntex` × `1`. # `tex_contenttypeadr` ```elixir @spec tex_contenttypeadr(t()) :: ExMujoco.Tensor.t() ``` `tex_contenttypeadr` — content type address in paths; -1: none (ntex x 1) `int*` in C, `ntex` × `1`. # `tex_data` ```elixir @spec tex_data(t()) :: ExMujoco.Tensor.t() ``` `tex_data` — pixel values (ntexdata x 1) `mjtByte*` in C, `ntexdata` × `1`. # `tex_height` ```elixir @spec tex_height(t()) :: ExMujoco.Tensor.t() ``` `tex_height` — number of rows in texture image (ntex x 1) `int*` in C, `ntex` × `1`. # `tex_nchannel` ```elixir @spec tex_nchannel(t()) :: ExMujoco.Tensor.t() ``` `tex_nchannel` — number of channels in texture image (ntex x 1) `int*` in C, `ntex` × `1`. # `tex_pathadr` ```elixir @spec tex_pathadr(t()) :: ExMujoco.Tensor.t() ``` `tex_pathadr` — address of texture asset path; -1: none (ntex x 1) `int*` in C, `ntex` × `1`. # `tex_type` ```elixir @spec tex_type(t()) :: ExMujoco.Tensor.t() ``` `tex_type` — texture type (mjtTexture) (ntex x 1) `int*` in C, `ntex` × `1`. # `tex_width` ```elixir @spec tex_width(t()) :: ExMujoco.Tensor.t() ``` `tex_width` — number of columns in texture image (ntex x 1) `int*` in C, `ntex` × `1`. # `text_adr` ```elixir @spec text_adr(t()) :: ExMujoco.Tensor.t() ``` `text_adr` — address of text in text_data (ntext x 1) `int*` in C, `ntext` × `1`. # `text_size` ```elixir @spec text_size(t()) :: ExMujoco.Tensor.t() ``` `text_size` — size of text field (strlen+1) (ntext x 1) `int*` in C, `ntext` × `1`. # `tree_bodyadr` ```elixir @spec tree_bodyadr(t()) :: ExMujoco.Tensor.t() ``` `tree_bodyadr` — start addr of bodies (ntree x 1) `int*` in C, `ntree` × `1`. # `tree_bodynum` ```elixir @spec tree_bodynum(t()) :: ExMujoco.Tensor.t() ``` `tree_bodynum` — number of bodies in tree (ntree x 1) `int*` in C, `ntree` × `1`. # `tree_dofadr` ```elixir @spec tree_dofadr(t()) :: ExMujoco.Tensor.t() ``` `tree_dofadr` — start addr of dofs (ntree x 1) `int*` in C, `ntree` × `1`. # `tree_dofnum` ```elixir @spec tree_dofnum(t()) :: ExMujoco.Tensor.t() ``` `tree_dofnum` — number of dofs in tree (ntree x 1) `int*` in C, `ntree` × `1`. # `tree_sleep_policy` ```elixir @spec tree_sleep_policy(t()) :: ExMujoco.Tensor.t() ``` `tree_sleep_policy` — sleep policy (mjtSleepPolicy) (ntree x 1) `int*` in C, `ntree` × `1`. # `tuple_adr` ```elixir @spec tuple_adr(t()) :: ExMujoco.Tensor.t() ``` `tuple_adr` — address of text in text_data (ntuple x 1) `int*` in C, `ntuple` × `1`. # `tuple_objid` ```elixir @spec tuple_objid(t()) :: ExMujoco.Tensor.t() ``` `tuple_objid` — array of object ids in all tuples (ntupledata x 1) `int*` in C, `ntupledata` × `1`. # `tuple_objprm` ```elixir @spec tuple_objprm(t()) :: ExMujoco.Tensor.t() ``` `tuple_objprm` — array of object params in all tuples (ntupledata x 1) `mjtNum*` in C, `ntupledata` × `1`. # `tuple_objtype` ```elixir @spec tuple_objtype(t()) :: ExMujoco.Tensor.t() ``` `tuple_objtype` — array of object types in all tuples (ntupledata x 1) `int*` in C, `ntupledata` × `1`. # `tuple_size` ```elixir @spec tuple_size(t()) :: ExMujoco.Tensor.t() ``` `tuple_size` — number of objects in tuple (ntuple x 1) `int*` in C, `ntuple` × `1`. # `wrap_objid` ```elixir @spec wrap_objid(t()) :: ExMujoco.Tensor.t() ``` `wrap_objid` — object id: geom, site, joint (nwrap x 1) `int*` in C, `nwrap` × `1`. # `wrap_prm` ```elixir @spec wrap_prm(t()) :: ExMujoco.Tensor.t() ``` `wrap_prm` — divisor, joint coef, or site id (nwrap x 1) `mjtNum*` in C, `nwrap` × `1`. # `wrap_type` ```elixir @spec wrap_type(t()) :: ExMujoco.Tensor.t() ``` `wrap_type` — wrap object type (mjtWrap) (nwrap x 1) `int*` in C, `nwrap` × `1`. --- *Consult [api-reference.md](api-reference.md) for complete listing*