Struct mjModel_ 

#[repr(C)]
pub struct mjModel_ {

    pub nq: c_int,
    pub nv: c_int,
    pub nu: c_int,
    pub na: c_int,
    pub nbody: c_int,
    pub nbvh: c_int,
    pub nbvhstatic: c_int,
    pub nbvhdynamic: c_int,
    pub noct: c_int,
    pub njnt: c_int,
    pub ngeom: c_int,
    pub nsite: c_int,
    pub ncam: c_int,
    pub nlight: c_int,
    pub nflex: c_int,
    pub nflexnode: c_int,
    pub nflexvert: c_int,
    pub nflexedge: c_int,
    pub nflexelem: c_int,
    pub nflexelemdata: c_int,
    pub nflexelemedge: c_int,
    pub nflexshelldata: c_int,
    pub nflexevpair: c_int,
    pub nflextexcoord: c_int,
    pub nmesh: c_int,
    pub nmeshvert: c_int,
    pub nmeshnormal: c_int,
    pub nmeshtexcoord: c_int,
    pub nmeshface: c_int,
    pub nmeshgraph: c_int,
    pub nmeshpoly: c_int,
    pub nmeshpolyvert: c_int,
    pub nmeshpolymap: c_int,
    pub nskin: c_int,
    pub nskinvert: c_int,
    pub nskintexvert: c_int,
    pub nskinface: c_int,
    pub nskinbone: c_int,
    pub nskinbonevert: c_int,
    pub nhfield: c_int,
    pub nhfielddata: c_int,
    pub ntex: c_int,
    pub ntexdata: c_int,
    pub nmat: c_int,
    pub npair: c_int,
    pub nexclude: c_int,
    pub neq: c_int,
    pub ntendon: c_int,
    pub nwrap: c_int,
    pub nsensor: c_int,
    pub nnumeric: c_int,
    pub nnumericdata: c_int,
    pub ntext: c_int,
    pub ntextdata: c_int,
    pub ntuple: c_int,
    pub ntupledata: c_int,
    pub nkey: c_int,
    pub nmocap: c_int,
    pub nplugin: c_int,
    pub npluginattr: c_int,
    pub nuser_body: c_int,
    pub nuser_jnt: c_int,
    pub nuser_geom: c_int,
    pub nuser_site: c_int,
    pub nuser_cam: c_int,
    pub nuser_tendon: c_int,
    pub nuser_actuator: c_int,
    pub nuser_sensor: c_int,
    pub nnames: c_int,
    pub npaths: c_int,
    pub nnames_map: c_int,
    pub nM: c_int,
    pub nB: c_int,
    pub nC: c_int,
    pub nD: c_int,
    pub nJmom: c_int,
    pub ntree: c_int,
    pub ngravcomp: c_int,
    pub nemax: c_int,
    pub njmax: c_int,
    pub nconmax: c_int,
    pub nuserdata: c_int,
    pub nsensordata: c_int,
    pub npluginstate: c_int,
    pub narena: mjtSize,
    pub nbuffer: mjtSize,
    pub opt: mjOption,
    pub vis: mjVisual,
    pub stat: mjStatistic,
    pub buffer: *mut c_void,
    pub qpos0: *mut mjtNum,
    pub qpos_spring: *mut mjtNum,
    pub body_parentid: *mut c_int,
    pub body_rootid: *mut c_int,
    pub body_weldid: *mut c_int,
    pub body_mocapid: *mut c_int,
    pub body_jntnum: *mut c_int,
    pub body_jntadr: *mut c_int,
    pub body_dofnum: *mut c_int,
    pub body_dofadr: *mut c_int,
    pub body_treeid: *mut c_int,
    pub body_geomnum: *mut c_int,
    pub body_geomadr: *mut c_int,
    pub body_simple: *mut mjtByte,
    pub body_sameframe: *mut mjtByte,
    pub body_pos: *mut mjtNum,
    pub body_quat: *mut mjtNum,
    pub body_ipos: *mut mjtNum,
    pub body_iquat: *mut mjtNum,
    pub body_mass: *mut mjtNum,
    pub body_subtreemass: *mut mjtNum,
    pub body_inertia: *mut mjtNum,
    pub body_invweight0: *mut mjtNum,
    pub body_gravcomp: *mut mjtNum,
    pub body_margin: *mut mjtNum,
    pub body_user: *mut mjtNum,
    pub body_plugin: *mut c_int,
    pub body_contype: *mut c_int,
    pub body_conaffinity: *mut c_int,
    pub body_bvhadr: *mut c_int,
    pub body_bvhnum: *mut c_int,
    pub bvh_depth: *mut c_int,
    pub bvh_child: *mut c_int,
    pub bvh_nodeid: *mut c_int,
    pub bvh_aabb: *mut mjtNum,
    pub oct_depth: *mut c_int,
    pub oct_child: *mut c_int,
    pub oct_aabb: *mut mjtNum,
    pub oct_coeff: *mut mjtNum,
    pub jnt_type: *mut c_int,
    pub jnt_qposadr: *mut c_int,
    pub jnt_dofadr: *mut c_int,
    pub jnt_bodyid: *mut c_int,
    pub jnt_group: *mut c_int,
    pub jnt_limited: *mut mjtByte,
    pub jnt_actfrclimited: *mut mjtByte,
    pub jnt_actgravcomp: *mut mjtByte,
    pub jnt_solref: *mut mjtNum,
    pub jnt_solimp: *mut mjtNum,
    pub jnt_pos: *mut mjtNum,
    pub jnt_axis: *mut mjtNum,
    pub jnt_stiffness: *mut mjtNum,
    pub jnt_range: *mut mjtNum,
    pub jnt_actfrcrange: *mut mjtNum,
    pub jnt_margin: *mut mjtNum,
    pub jnt_user: *mut mjtNum,
    pub dof_bodyid: *mut c_int,
    pub dof_jntid: *mut c_int,
    pub dof_parentid: *mut c_int,
    pub dof_treeid: *mut c_int,
    pub dof_Madr: *mut c_int,
    pub dof_simplenum: *mut c_int,
    pub dof_solref: *mut mjtNum,
    pub dof_solimp: *mut mjtNum,
    pub dof_frictionloss: *mut mjtNum,
    pub dof_armature: *mut mjtNum,
    pub dof_damping: *mut mjtNum,
    pub dof_invweight0: *mut mjtNum,
    pub dof_M0: *mut mjtNum,
    pub geom_type: *mut c_int,
    pub geom_contype: *mut c_int,
    pub geom_conaffinity: *mut c_int,
    pub geom_condim: *mut c_int,
    pub geom_bodyid: *mut c_int,
    pub geom_dataid: *mut c_int,
    pub geom_matid: *mut c_int,
    pub geom_group: *mut c_int,
    pub geom_priority: *mut c_int,
    pub geom_plugin: *mut c_int,
    pub geom_sameframe: *mut mjtByte,
    pub geom_solmix: *mut mjtNum,
    pub geom_solref: *mut mjtNum,
    pub geom_solimp: *mut mjtNum,
    pub geom_size: *mut mjtNum,
    pub geom_aabb: *mut mjtNum,
    pub geom_rbound: *mut mjtNum,
    pub geom_pos: *mut mjtNum,
    pub geom_quat: *mut mjtNum,
    pub geom_friction: *mut mjtNum,
    pub geom_margin: *mut mjtNum,
    pub geom_gap: *mut mjtNum,
    pub geom_fluid: *mut mjtNum,
    pub geom_user: *mut mjtNum,
    pub geom_rgba: *mut f32,
    pub site_type: *mut c_int,
    pub site_bodyid: *mut c_int,
    pub site_matid: *mut c_int,
    pub site_group: *mut c_int,
    pub site_sameframe: *mut mjtByte,
    pub site_size: *mut mjtNum,
    pub site_pos: *mut mjtNum,
    pub site_quat: *mut mjtNum,
    pub site_user: *mut mjtNum,
    pub site_rgba: *mut f32,
    pub cam_mode: *mut c_int,
    pub cam_bodyid: *mut c_int,
    pub cam_targetbodyid: *mut c_int,
    pub cam_pos: *mut mjtNum,
    pub cam_quat: *mut mjtNum,
    pub cam_poscom0: *mut mjtNum,
    pub cam_pos0: *mut mjtNum,
    pub cam_mat0: *mut mjtNum,
    pub cam_orthographic: *mut c_int,
    pub cam_fovy: *mut mjtNum,
    pub cam_ipd: *mut mjtNum,
    pub cam_resolution: *mut c_int,
    pub cam_sensorsize: *mut f32,
    pub cam_intrinsic: *mut f32,
    pub cam_user: *mut mjtNum,
    pub light_mode: *mut c_int,
    pub light_bodyid: *mut c_int,
    pub light_targetbodyid: *mut c_int,
    pub light_type: *mut c_int,
    pub light_texid: *mut c_int,
    pub light_castshadow: *mut mjtByte,
    pub light_bulbradius: *mut f32,
    pub light_intensity: *mut f32,
    pub light_range: *mut f32,
    pub light_active: *mut mjtByte,
    pub light_pos: *mut mjtNum,
    pub light_dir: *mut mjtNum,
    pub light_poscom0: *mut mjtNum,
    pub light_pos0: *mut mjtNum,
    pub light_dir0: *mut mjtNum,
    pub light_attenuation: *mut f32,
    pub light_cutoff: *mut f32,
    pub light_exponent: *mut f32,
    pub light_ambient: *mut f32,
    pub light_diffuse: *mut f32,
    pub light_specular: *mut f32,
    pub flex_contype: *mut c_int,
    pub flex_conaffinity: *mut c_int,
    pub flex_condim: *mut c_int,
    pub flex_priority: *mut c_int,
    pub flex_solmix: *mut mjtNum,
    pub flex_solref: *mut mjtNum,
    pub flex_solimp: *mut mjtNum,
    pub flex_friction: *mut mjtNum,
    pub flex_margin: *mut mjtNum,
    pub flex_gap: *mut mjtNum,
    pub flex_internal: *mut mjtByte,
    pub flex_selfcollide: *mut c_int,
    pub flex_activelayers: *mut c_int,
    pub flex_dim: *mut c_int,
    pub flex_matid: *mut c_int,
    pub flex_group: *mut c_int,
    pub flex_interp: *mut c_int,
    pub flex_nodeadr: *mut c_int,
    pub flex_nodenum: *mut c_int,
    pub flex_vertadr: *mut c_int,
    pub flex_vertnum: *mut c_int,
    pub flex_edgeadr: *mut c_int,
    pub flex_edgenum: *mut c_int,
    pub flex_elemadr: *mut c_int,
    pub flex_elemnum: *mut c_int,
    pub flex_elemdataadr: *mut c_int,
    pub flex_elemedgeadr: *mut c_int,
    pub flex_shellnum: *mut c_int,
    pub flex_shelldataadr: *mut c_int,
    pub flex_evpairadr: *mut c_int,
    pub flex_evpairnum: *mut c_int,
    pub flex_texcoordadr: *mut c_int,
    pub flex_nodebodyid: *mut c_int,
    pub flex_vertbodyid: *mut c_int,
    pub flex_edge: *mut c_int,
    pub flex_edgeflap: *mut c_int,
    pub flex_elem: *mut c_int,
    pub flex_elemtexcoord: *mut c_int,
    pub flex_elemedge: *mut c_int,
    pub flex_elemlayer: *mut c_int,
    pub flex_shell: *mut c_int,
    pub flex_evpair: *mut c_int,
    pub flex_vert: *mut mjtNum,
    pub flex_vert0: *mut mjtNum,
    pub flex_node: *mut mjtNum,
    pub flex_node0: *mut mjtNum,
    pub flexedge_length0: *mut mjtNum,
    pub flexedge_invweight0: *mut mjtNum,
    pub flex_radius: *mut mjtNum,
    pub flex_stiffness: *mut mjtNum,
    pub flex_bending: *mut mjtNum,
    pub flex_damping: *mut mjtNum,
    pub flex_edgestiffness: *mut mjtNum,
    pub flex_edgedamping: *mut mjtNum,
    pub flex_edgeequality: *mut mjtByte,
    pub flex_rigid: *mut mjtByte,
    pub flexedge_rigid: *mut mjtByte,
    pub flex_centered: *mut mjtByte,
    pub flex_flatskin: *mut mjtByte,
    pub flex_bvhadr: *mut c_int,
    pub flex_bvhnum: *mut c_int,
    pub flex_rgba: *mut f32,
    pub flex_texcoord: *mut f32,
    pub mesh_vertadr: *mut c_int,
    pub mesh_vertnum: *mut c_int,
    pub mesh_faceadr: *mut c_int,
    pub mesh_facenum: *mut c_int,
    pub mesh_bvhadr: *mut c_int,
    pub mesh_bvhnum: *mut c_int,
    pub mesh_octadr: *mut c_int,
    pub mesh_octnum: *mut c_int,
    pub mesh_normaladr: *mut c_int,
    pub mesh_normalnum: *mut c_int,
    pub mesh_texcoordadr: *mut c_int,
    pub mesh_texcoordnum: *mut c_int,
    pub mesh_graphadr: *mut c_int,
    pub mesh_vert: *mut f32,
    pub mesh_normal: *mut f32,
    pub mesh_texcoord: *mut f32,
    pub mesh_face: *mut c_int,
    pub mesh_facenormal: *mut c_int,
    pub mesh_facetexcoord: *mut c_int,
    pub mesh_graph: *mut c_int,
    pub mesh_scale: *mut mjtNum,
    pub mesh_pos: *mut mjtNum,
    pub mesh_quat: *mut mjtNum,
    pub mesh_pathadr: *mut c_int,
    pub mesh_polynum: *mut c_int,
    pub mesh_polyadr: *mut c_int,
    pub mesh_polynormal: *mut mjtNum,
    pub mesh_polyvertadr: *mut c_int,
    pub mesh_polyvertnum: *mut c_int,
    pub mesh_polyvert: *mut c_int,
    pub mesh_polymapadr: *mut c_int,
    pub mesh_polymapnum: *mut c_int,
    pub mesh_polymap: *mut c_int,
    pub skin_matid: *mut c_int,
    pub skin_group: *mut c_int,
    pub skin_rgba: *mut f32,
    pub skin_inflate: *mut f32,
    pub skin_vertadr: *mut c_int,
    pub skin_vertnum: *mut c_int,
    pub skin_texcoordadr: *mut c_int,
    pub skin_faceadr: *mut c_int,
    pub skin_facenum: *mut c_int,
    pub skin_boneadr: *mut c_int,
    pub skin_bonenum: *mut c_int,
    pub skin_vert: *mut f32,
    pub skin_texcoord: *mut f32,
    pub skin_face: *mut c_int,
    pub skin_bonevertadr: *mut c_int,
    pub skin_bonevertnum: *mut c_int,
    pub skin_bonebindpos: *mut f32,
    pub skin_bonebindquat: *mut f32,
    pub skin_bonebodyid: *mut c_int,
    pub skin_bonevertid: *mut c_int,
    pub skin_bonevertweight: *mut f32,
    pub skin_pathadr: *mut c_int,
    pub hfield_size: *mut mjtNum,
    pub hfield_nrow: *mut c_int,
    pub hfield_ncol: *mut c_int,
    pub hfield_adr: *mut c_int,
    pub hfield_data: *mut f32,
    pub hfield_pathadr: *mut c_int,
    pub tex_type: *mut c_int,
    pub tex_colorspace: *mut c_int,
    pub tex_height: *mut c_int,
    pub tex_width: *mut c_int,
    pub tex_nchannel: *mut c_int,
    pub tex_adr: *mut c_int,
    pub tex_data: *mut mjtByte,
    pub tex_pathadr: *mut c_int,
    pub mat_texid: *mut c_int,
    pub mat_texuniform: *mut mjtByte,
    pub mat_texrepeat: *mut f32,
    pub mat_emission: *mut f32,
    pub mat_specular: *mut f32,
    pub mat_shininess: *mut f32,
    pub mat_reflectance: *mut f32,
    pub mat_metallic: *mut f32,
    pub mat_roughness: *mut f32,
    pub mat_rgba: *mut f32,
    pub pair_dim: *mut c_int,
    pub pair_geom1: *mut c_int,
    pub pair_geom2: *mut c_int,
    pub pair_signature: *mut c_int,
    pub pair_solref: *mut mjtNum,
    pub pair_solreffriction: *mut mjtNum,
    pub pair_solimp: *mut mjtNum,
    pub pair_margin: *mut mjtNum,
    pub pair_gap: *mut mjtNum,
    pub pair_friction: *mut mjtNum,
    pub exclude_signature: *mut c_int,
    pub eq_type: *mut c_int,
    pub eq_obj1id: *mut c_int,
    pub eq_obj2id: *mut c_int,
    pub eq_objtype: *mut c_int,
    pub eq_active0: *mut mjtByte,
    pub eq_solref: *mut mjtNum,
    pub eq_solimp: *mut mjtNum,
    pub eq_data: *mut mjtNum,
    pub tendon_adr: *mut c_int,
    pub tendon_num: *mut c_int,
    pub tendon_matid: *mut c_int,
    pub tendon_group: *mut c_int,
    pub tendon_limited: *mut mjtByte,
    pub tendon_actfrclimited: *mut mjtByte,
    pub tendon_width: *mut mjtNum,
    pub tendon_solref_lim: *mut mjtNum,
    pub tendon_solimp_lim: *mut mjtNum,
    pub tendon_solref_fri: *mut mjtNum,
    pub tendon_solimp_fri: *mut mjtNum,
    pub tendon_range: *mut mjtNum,
    pub tendon_actfrcrange: *mut mjtNum,
    pub tendon_margin: *mut mjtNum,
    pub tendon_stiffness: *mut mjtNum,
    pub tendon_damping: *mut mjtNum,
    pub tendon_armature: *mut mjtNum,
    pub tendon_frictionloss: *mut mjtNum,
    pub tendon_lengthspring: *mut mjtNum,
    pub tendon_length0: *mut mjtNum,
    pub tendon_invweight0: *mut mjtNum,
    pub tendon_user: *mut mjtNum,
    pub tendon_rgba: *mut f32,
    pub wrap_type: *mut c_int,
    pub wrap_objid: *mut c_int,
    pub wrap_prm: *mut mjtNum,
    pub actuator_trntype: *mut c_int,
    pub actuator_dyntype: *mut c_int,
    pub actuator_gaintype: *mut c_int,
    pub actuator_biastype: *mut c_int,
    pub actuator_trnid: *mut c_int,
    pub actuator_actadr: *mut c_int,
    pub actuator_actnum: *mut c_int,
    pub actuator_group: *mut c_int,
    pub actuator_ctrllimited: *mut mjtByte,
    pub actuator_forcelimited: *mut mjtByte,
    pub actuator_actlimited: *mut mjtByte,
    pub actuator_dynprm: *mut mjtNum,
    pub actuator_gainprm: *mut mjtNum,
    pub actuator_biasprm: *mut mjtNum,
    pub actuator_actearly: *mut mjtByte,
    pub actuator_ctrlrange: *mut mjtNum,
    pub actuator_forcerange: *mut mjtNum,
    pub actuator_actrange: *mut mjtNum,
    pub actuator_gear: *mut mjtNum,
    pub actuator_cranklength: *mut mjtNum,
    pub actuator_acc0: *mut mjtNum,
    pub actuator_length0: *mut mjtNum,
    pub actuator_lengthrange: *mut mjtNum,
    pub actuator_user: *mut mjtNum,
    pub actuator_plugin: *mut c_int,
    pub sensor_type: *mut c_int,
    pub sensor_datatype: *mut c_int,
    pub sensor_needstage: *mut c_int,
    pub sensor_objtype: *mut c_int,
    pub sensor_objid: *mut c_int,
    pub sensor_reftype: *mut c_int,
    pub sensor_refid: *mut c_int,
    pub sensor_intprm: *mut c_int,
    pub sensor_dim: *mut c_int,
    pub sensor_adr: *mut c_int,
    pub sensor_cutoff: *mut mjtNum,
    pub sensor_noise: *mut mjtNum,
    pub sensor_user: *mut mjtNum,
    pub sensor_plugin: *mut c_int,
    pub plugin: *mut c_int,
    pub plugin_stateadr: *mut c_int,
    pub plugin_statenum: *mut c_int,
    pub plugin_attr: *mut c_char,
    pub plugin_attradr: *mut c_int,
    pub numeric_adr: *mut c_int,
    pub numeric_size: *mut c_int,
    pub numeric_data: *mut mjtNum,
    pub text_adr: *mut c_int,
    pub text_size: *mut c_int,
    pub text_data: *mut c_char,
    pub tuple_adr: *mut c_int,
    pub tuple_size: *mut c_int,
    pub tuple_objtype: *mut c_int,
    pub tuple_objid: *mut c_int,
    pub tuple_objprm: *mut mjtNum,
    pub key_time: *mut mjtNum,
    pub key_qpos: *mut mjtNum,
    pub key_qvel: *mut mjtNum,
    pub key_act: *mut mjtNum,
    pub key_mpos: *mut mjtNum,
    pub key_mquat: *mut mjtNum,
    pub key_ctrl: *mut mjtNum,
    pub name_bodyadr: *mut c_int,
    pub name_jntadr: *mut c_int,
    pub name_geomadr: *mut c_int,
    pub name_siteadr: *mut c_int,
    pub name_camadr: *mut c_int,
    pub name_lightadr: *mut c_int,
    pub name_flexadr: *mut c_int,
    pub name_meshadr: *mut c_int,
    pub name_skinadr: *mut c_int,
    pub name_hfieldadr: *mut c_int,
    pub name_texadr: *mut c_int,
    pub name_matadr: *mut c_int,
    pub name_pairadr: *mut c_int,
    pub name_excludeadr: *mut c_int,
    pub name_eqadr: *mut c_int,
    pub name_tendonadr: *mut c_int,
    pub name_actuatoradr: *mut c_int,
    pub name_sensoradr: *mut c_int,
    pub name_numericadr: *mut c_int,
    pub name_textadr: *mut c_int,
    pub name_tupleadr: *mut c_int,
    pub name_keyadr: *mut c_int,
    pub name_pluginadr: *mut c_int,
    pub names: *mut c_char,
    pub names_map: *mut c_int,
    pub paths: *mut c_char,
    pub signature: u64,
}

Fields

nq: c_int

nv: c_int

nu: c_int

na: c_int

nbody: c_int

nbvh: c_int

nbvhstatic: c_int

nbvhdynamic: c_int

noct: c_int

njnt: c_int

ngeom: c_int

nsite: c_int

ncam: c_int

nlight: c_int

nflex: c_int

nflexnode: c_int

nflexvert: c_int

nflexedge: c_int

nflexelem: c_int

nflexelemdata: c_int

nflexelemedge: c_int

nflexshelldata: c_int

nflexevpair: c_int

nflextexcoord: c_int

nmesh: c_int

nmeshvert: c_int

nmeshnormal: c_int

nmeshtexcoord: c_int

nmeshface: c_int

nmeshgraph: c_int

nmeshpoly: c_int

nmeshpolyvert: c_int

nmeshpolymap: c_int

nskin: c_int

nskinvert: c_int

nskintexvert: c_int

nskinface: c_int

nskinbone: c_int

nskinbonevert: c_int

nhfield: c_int

nhfielddata: c_int

ntex: c_int

ntexdata: c_int

nmat: c_int

npair: c_int

nexclude: c_int

neq: c_int

ntendon: c_int

nwrap: c_int

nsensor: c_int

nnumeric: c_int

nnumericdata: c_int

ntext: c_int

ntextdata: c_int

ntuple: c_int

ntupledata: c_int

nkey: c_int

nmocap: c_int

nplugin: c_int

npluginattr: c_int

nuser_body: c_int

nuser_jnt: c_int

nuser_geom: c_int

nuser_site: c_int

nuser_cam: c_int

nuser_tendon: c_int

nuser_actuator: c_int

nuser_sensor: c_int

nnames: c_int

npaths: c_int

nnames_map: c_int

nM: c_int

nB: c_int

nC: c_int

nD: c_int

nJmom: c_int

ntree: c_int

ngravcomp: c_int

nemax: c_int

njmax: c_int

nconmax: c_int

nuserdata: c_int

nsensordata: c_int

npluginstate: c_int

narena: mjtSize

nbuffer: mjtSize

opt: mjOption

vis: mjVisual

stat: mjStatistic

buffer: *mut c_void

qpos0: *mut mjtNum

qpos_spring: *mut mjtNum

body_parentid: *mut c_int

body_rootid: *mut c_int

body_weldid: *mut c_int

body_mocapid: *mut c_int

body_jntnum: *mut c_int

body_jntadr: *mut c_int

body_dofnum: *mut c_int

body_dofadr: *mut c_int

body_treeid: *mut c_int

body_geomnum: *mut c_int

body_geomadr: *mut c_int

body_simple: *mut mjtByte

body_sameframe: *mut mjtByte

body_pos: *mut mjtNum

body_quat: *mut mjtNum

body_ipos: *mut mjtNum

body_iquat: *mut mjtNum

body_mass: *mut mjtNum

body_subtreemass: *mut mjtNum

body_inertia: *mut mjtNum

body_invweight0: *mut mjtNum

body_gravcomp: *mut mjtNum

body_margin: *mut mjtNum

body_user: *mut mjtNum

body_plugin: *mut c_int

body_contype: *mut c_int

body_conaffinity: *mut c_int

body_bvhadr: *mut c_int

body_bvhnum: *mut c_int

bvh_depth: *mut c_int

bvh_child: *mut c_int

bvh_nodeid: *mut c_int

bvh_aabb: *mut mjtNum

oct_depth: *mut c_int

oct_child: *mut c_int

oct_aabb: *mut mjtNum

oct_coeff: *mut mjtNum

jnt_type: *mut c_int

jnt_qposadr: *mut c_int

jnt_dofadr: *mut c_int

jnt_bodyid: *mut c_int

jnt_group: *mut c_int

jnt_limited: *mut mjtByte

jnt_actfrclimited: *mut mjtByte

jnt_actgravcomp: *mut mjtByte

jnt_solref: *mut mjtNum

jnt_solimp: *mut mjtNum

jnt_pos: *mut mjtNum

jnt_axis: *mut mjtNum

jnt_stiffness: *mut mjtNum

jnt_range: *mut mjtNum

jnt_actfrcrange: *mut mjtNum

jnt_margin: *mut mjtNum

jnt_user: *mut mjtNum

dof_bodyid: *mut c_int

dof_jntid: *mut c_int

dof_parentid: *mut c_int

dof_treeid: *mut c_int

dof_Madr: *mut c_int

dof_simplenum: *mut c_int

dof_solref: *mut mjtNum

dof_solimp: *mut mjtNum

dof_frictionloss: *mut mjtNum

dof_armature: *mut mjtNum

dof_damping: *mut mjtNum

dof_invweight0: *mut mjtNum

dof_M0: *mut mjtNum

geom_type: *mut c_int

geom_contype: *mut c_int

geom_conaffinity: *mut c_int

geom_condim: *mut c_int

geom_bodyid: *mut c_int

geom_dataid: *mut c_int

geom_matid: *mut c_int

geom_group: *mut c_int

geom_priority: *mut c_int

geom_plugin: *mut c_int

geom_sameframe: *mut mjtByte

geom_solmix: *mut mjtNum

geom_solref: *mut mjtNum

geom_solimp: *mut mjtNum

geom_size: *mut mjtNum

geom_aabb: *mut mjtNum

geom_rbound: *mut mjtNum

geom_pos: *mut mjtNum

geom_quat: *mut mjtNum

geom_friction: *mut mjtNum

geom_margin: *mut mjtNum

geom_gap: *mut mjtNum

geom_fluid: *mut mjtNum

geom_user: *mut mjtNum

geom_rgba: *mut f32

site_type: *mut c_int

site_bodyid: *mut c_int

site_matid: *mut c_int

site_group: *mut c_int

site_sameframe: *mut mjtByte

site_size: *mut mjtNum

site_pos: *mut mjtNum

site_quat: *mut mjtNum

site_user: *mut mjtNum

site_rgba: *mut f32

cam_mode: *mut c_int

cam_bodyid: *mut c_int

cam_targetbodyid: *mut c_int

cam_pos: *mut mjtNum

cam_quat: *mut mjtNum

cam_poscom0: *mut mjtNum

cam_pos0: *mut mjtNum

cam_mat0: *mut mjtNum

cam_orthographic: *mut c_int

cam_fovy: *mut mjtNum

cam_ipd: *mut mjtNum

cam_resolution: *mut c_int

cam_sensorsize: *mut f32

cam_intrinsic: *mut f32

cam_user: *mut mjtNum

light_mode: *mut c_int

light_bodyid: *mut c_int

light_targetbodyid: *mut c_int

light_type: *mut c_int

light_texid: *mut c_int

light_castshadow: *mut mjtByte

light_bulbradius: *mut f32

light_intensity: *mut f32

light_range: *mut f32

light_active: *mut mjtByte

light_pos: *mut mjtNum

light_dir: *mut mjtNum

light_poscom0: *mut mjtNum

light_pos0: *mut mjtNum

light_dir0: *mut mjtNum

light_attenuation: *mut f32

light_cutoff: *mut f32

light_exponent: *mut f32

light_ambient: *mut f32

light_diffuse: *mut f32

light_specular: *mut f32

flex_contype: *mut c_int

flex_conaffinity: *mut c_int

flex_condim: *mut c_int

flex_priority: *mut c_int

flex_solmix: *mut mjtNum

flex_solref: *mut mjtNum

flex_solimp: *mut mjtNum

flex_friction: *mut mjtNum

flex_margin: *mut mjtNum

flex_gap: *mut mjtNum

flex_internal: *mut mjtByte

flex_selfcollide: *mut c_int

flex_activelayers: *mut c_int

flex_dim: *mut c_int

flex_matid: *mut c_int

flex_group: *mut c_int

flex_interp: *mut c_int

flex_nodeadr: *mut c_int

flex_nodenum: *mut c_int

flex_vertadr: *mut c_int

flex_vertnum: *mut c_int

flex_edgeadr: *mut c_int

flex_edgenum: *mut c_int

flex_elemadr: *mut c_int

flex_elemnum: *mut c_int

flex_elemdataadr: *mut c_int

flex_elemedgeadr: *mut c_int

flex_shellnum: *mut c_int

flex_shelldataadr: *mut c_int

flex_evpairadr: *mut c_int

flex_evpairnum: *mut c_int

flex_texcoordadr: *mut c_int

flex_nodebodyid: *mut c_int

flex_vertbodyid: *mut c_int

flex_edge: *mut c_int

flex_edgeflap: *mut c_int

flex_elem: *mut c_int

flex_elemtexcoord: *mut c_int

flex_elemedge: *mut c_int

flex_elemlayer: *mut c_int

flex_shell: *mut c_int

flex_evpair: *mut c_int

flex_vert: *mut mjtNum

flex_vert0: *mut mjtNum

flex_node: *mut mjtNum

flex_node0: *mut mjtNum

flexedge_length0: *mut mjtNum

flexedge_invweight0: *mut mjtNum

flex_radius: *mut mjtNum

flex_stiffness: *mut mjtNum

flex_bending: *mut mjtNum

flex_damping: *mut mjtNum

flex_edgestiffness: *mut mjtNum

flex_edgedamping: *mut mjtNum

flex_edgeequality: *mut mjtByte

flex_rigid: *mut mjtByte

flexedge_rigid: *mut mjtByte

flex_centered: *mut mjtByte

flex_flatskin: *mut mjtByte

flex_bvhadr: *mut c_int

flex_bvhnum: *mut c_int

flex_rgba: *mut f32

flex_texcoord: *mut f32

mesh_vertadr: *mut c_int

mesh_vertnum: *mut c_int

mesh_faceadr: *mut c_int

mesh_facenum: *mut c_int

mesh_bvhadr: *mut c_int

mesh_bvhnum: *mut c_int

mesh_octadr: *mut c_int

mesh_octnum: *mut c_int

mesh_normaladr: *mut c_int

mesh_normalnum: *mut c_int

mesh_texcoordadr: *mut c_int

mesh_texcoordnum: *mut c_int

mesh_graphadr: *mut c_int

mesh_vert: *mut f32

mesh_normal: *mut f32

mesh_texcoord: *mut f32

mesh_face: *mut c_int

mesh_facenormal: *mut c_int

mesh_facetexcoord: *mut c_int

mesh_graph: *mut c_int

mesh_scale: *mut mjtNum

mesh_pos: *mut mjtNum

mesh_quat: *mut mjtNum

mesh_pathadr: *mut c_int

mesh_polynum: *mut c_int

mesh_polyadr: *mut c_int

mesh_polynormal: *mut mjtNum

mesh_polyvertadr: *mut c_int

mesh_polyvertnum: *mut c_int

mesh_polyvert: *mut c_int

mesh_polymapadr: *mut c_int

mesh_polymapnum: *mut c_int

mesh_polymap: *mut c_int

skin_matid: *mut c_int

skin_group: *mut c_int

skin_rgba: *mut f32

skin_inflate: *mut f32

skin_vertadr: *mut c_int

skin_vertnum: *mut c_int

skin_texcoordadr: *mut c_int

skin_faceadr: *mut c_int

skin_facenum: *mut c_int

skin_boneadr: *mut c_int

skin_bonenum: *mut c_int

skin_vert: *mut f32

skin_texcoord: *mut f32

skin_face: *mut c_int

skin_bonevertadr: *mut c_int

skin_bonevertnum: *mut c_int

skin_bonebindpos: *mut f32

skin_bonebindquat: *mut f32

skin_bonebodyid: *mut c_int

skin_bonevertid: *mut c_int

skin_bonevertweight: *mut f32

skin_pathadr: *mut c_int

hfield_size: *mut mjtNum

hfield_nrow: *mut c_int

hfield_ncol: *mut c_int

hfield_adr: *mut c_int

hfield_data: *mut f32

hfield_pathadr: *mut c_int

tex_type: *mut c_int

tex_colorspace: *mut c_int

tex_height: *mut c_int

tex_width: *mut c_int

tex_nchannel: *mut c_int

tex_adr: *mut c_int

tex_data: *mut mjtByte

tex_pathadr: *mut c_int

mat_texid: *mut c_int

mat_texuniform: *mut mjtByte

mat_texrepeat: *mut f32

mat_emission: *mut f32

mat_specular: *mut f32

mat_shininess: *mut f32

mat_reflectance: *mut f32

mat_metallic: *mut f32

mat_roughness: *mut f32

mat_rgba: *mut f32

pair_dim: *mut c_int

pair_geom1: *mut c_int

pair_geom2: *mut c_int

pair_signature: *mut c_int

pair_solref: *mut mjtNum

pair_solreffriction: *mut mjtNum

pair_solimp: *mut mjtNum

pair_margin: *mut mjtNum

pair_gap: *mut mjtNum

pair_friction: *mut mjtNum

exclude_signature: *mut c_int

eq_type: *mut c_int

eq_obj1id: *mut c_int

eq_obj2id: *mut c_int

eq_objtype: *mut c_int

eq_active0: *mut mjtByte

eq_solref: *mut mjtNum

eq_solimp: *mut mjtNum

eq_data: *mut mjtNum

tendon_adr: *mut c_int

tendon_num: *mut c_int

tendon_matid: *mut c_int

tendon_group: *mut c_int

tendon_limited: *mut mjtByte

tendon_actfrclimited: *mut mjtByte

tendon_width: *mut mjtNum

tendon_solref_lim: *mut mjtNum

tendon_solimp_lim: *mut mjtNum

tendon_solref_fri: *mut mjtNum

tendon_solimp_fri: *mut mjtNum

tendon_range: *mut mjtNum

tendon_actfrcrange: *mut mjtNum

tendon_margin: *mut mjtNum

tendon_stiffness: *mut mjtNum

tendon_damping: *mut mjtNum

tendon_armature: *mut mjtNum

tendon_frictionloss: *mut mjtNum

tendon_lengthspring: *mut mjtNum

tendon_length0: *mut mjtNum

tendon_invweight0: *mut mjtNum

tendon_user: *mut mjtNum

tendon_rgba: *mut f32

wrap_type: *mut c_int

wrap_objid: *mut c_int

wrap_prm: *mut mjtNum

actuator_trntype: *mut c_int

actuator_dyntype: *mut c_int

actuator_gaintype: *mut c_int

actuator_biastype: *mut c_int

actuator_trnid: *mut c_int

actuator_actadr: *mut c_int

actuator_actnum: *mut c_int

actuator_group: *mut c_int

actuator_ctrllimited: *mut mjtByte

actuator_forcelimited: *mut mjtByte

actuator_actlimited: *mut mjtByte

actuator_dynprm: *mut mjtNum

actuator_gainprm: *mut mjtNum

actuator_biasprm: *mut mjtNum

actuator_actearly: *mut mjtByte

actuator_ctrlrange: *mut mjtNum

actuator_forcerange: *mut mjtNum

actuator_actrange: *mut mjtNum

actuator_gear: *mut mjtNum

actuator_cranklength: *mut mjtNum

actuator_acc0: *mut mjtNum

actuator_length0: *mut mjtNum

actuator_lengthrange: *mut mjtNum

actuator_user: *mut mjtNum

actuator_plugin: *mut c_int

sensor_type: *mut c_int

sensor_datatype: *mut c_int

sensor_needstage: *mut c_int

sensor_objtype: *mut c_int

sensor_objid: *mut c_int

sensor_reftype: *mut c_int

sensor_refid: *mut c_int

sensor_intprm: *mut c_int

sensor_dim: *mut c_int

sensor_adr: *mut c_int

sensor_cutoff: *mut mjtNum

sensor_noise: *mut mjtNum

sensor_user: *mut mjtNum

sensor_plugin: *mut c_int

plugin: *mut c_int

plugin_stateadr: *mut c_int

plugin_statenum: *mut c_int

plugin_attr: *mut c_char

plugin_attradr: *mut c_int

numeric_adr: *mut c_int

numeric_size: *mut c_int

numeric_data: *mut mjtNum

text_adr: *mut c_int

text_size: *mut c_int

text_data: *mut c_char

tuple_adr: *mut c_int

tuple_size: *mut c_int

tuple_objtype: *mut c_int

tuple_objid: *mut c_int

tuple_objprm: *mut mjtNum

key_time: *mut mjtNum

key_qpos: *mut mjtNum

key_qvel: *mut mjtNum

key_act: *mut mjtNum

key_mpos: *mut mjtNum

key_mquat: *mut mjtNum

key_ctrl: *mut mjtNum

name_bodyadr: *mut c_int

name_jntadr: *mut c_int

name_geomadr: *mut c_int

name_siteadr: *mut c_int

name_camadr: *mut c_int

name_lightadr: *mut c_int

name_flexadr: *mut c_int

name_meshadr: *mut c_int

name_skinadr: *mut c_int

name_hfieldadr: *mut c_int

name_texadr: *mut c_int

name_matadr: *mut c_int

name_pairadr: *mut c_int

name_excludeadr: *mut c_int

name_eqadr: *mut c_int

name_tendonadr: *mut c_int

name_actuatoradr: *mut c_int

name_sensoradr: *mut c_int

name_numericadr: *mut c_int

name_textadr: *mut c_int

name_tupleadr: *mut c_int

name_keyadr: *mut c_int

name_pluginadr: *mut c_int

names: *mut c_char

names_map: *mut c_int

paths: *mut c_char

signature: u64

Trait Implementations

impl Clone for mjModel_

fn clone(&self) -> mjModel_

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for mjModel_

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.