Alessio Quaglino
ea230a950c
This CL replaces the post-hoc implicit flex correction (`flexInterp_cgsolve`) with a **linearly-implicit effective metric** `M̃ = M + (h² + h·damping)·K` carried by the CG constraint solver itself. Contact/friction forces and implicit flex elasticity are now computed against one consistent metric, instead of the solver seeing `M` and a post-solve correction changing `qacc` behind its back. Gate (unchanged semantics): `solver="CG"` + implicit/implicitfast integrator + pyramidal cones + flex stiffness present. Newton and PGS are untouched. `solver="CG"` remains the user-facing contract — the factorization is an implementation detail of the preconditioner. ### What's in the metric - **mjData `efm_*`** (arena, efc-like lifetime/skip semantics; built in `mj_fwdPosition`, value-refreshed in `mj_fwdVelocity`): the per-step stiffness CSR `efm_B_*`, its reverse-Cholesky factor `efm_dofid` + `efm_L_*` (nested-dissection ordered, separators-first for the reverse factorization), and the smooth-force shift `efm_c = h·K·qvel`. - **`mjd_flexStiff_assemble`** now assembles stretch (Gauss–Newton), standard dim-2 bending, and — via the cached corotated stiffness `d->flexelem_krot` — interp stiffness (all node bodies on simple sliders: point Jacobian is I₃, `flex_centered` not required; fixed nodes drop like pins) into one dof-level CSR. `mjd_effMulAdd`/`mjd_effSolve` apply the metric, with matrix-free operator fallbacks where assembly does not apply. - **mjModel `efm0_*`** (`nefm0dof`/`nefm0L`): the constant part of the metric factor — currently the dim-2 bending factor, computed once in `mj_setConst` — so bending-only models pay zero per-step factorization cost. Naming mirrors mjData's `efm_*` with the standard `0`-suffix (reference/constant) idiom, and is deliberately not bending-specific: future constant contributors extend it without renames. - The solver consumes the metric through pre-shifted `qfrc_smooth` and the metric products `Ma`/`Mv`/`Mgrad`; `qacc_smooth` becomes the unconstrained minimizer of the implicit dynamics, which makes the no-constraint shortcut and the warmstart choice consistent by construction. - **`mj_inverse` adds `B·qacc − c`**, making inverse dynamics discrete-consistent with the gated forward dynamics — exact, since the gated path has no qDeriv term (new test `ForwardTest.GatedFlexInverseConsistency`). ### Performance All numbers: ms/step over the same 2000-step window, models as shipped on each side (old code with the old model settings vs this CL with the new ones). The new solver path activates on exactly two shipped models — the ponchos, the only flex models that need an implicit integrator (poncho on Euler degenerates to >200 ms/step). For them, this CL trades speed for consistency: the implicit bending solve now runs inside every solver iteration, where the contact solve can see the stiffness, instead of once after the solve. Solver iterations drop because the curvature is visible, but each iteration pays for the implicit solve: | model | before | after | solver iters/step | |---|---|---|---| | poncho | 2.47 | 3.30 (1.33×) | 16.8 → 11.8 | | poncho_edgeequality | 1.96 | 2.72 (1.39×) | 13.2 → 10.0 | What that price buys: contact forces consistent with the implicit elasticity (previously the post-hoc correction changed `qacc` after the constraint solve), discrete-consistent inverse dynamics, and the removal of the post-hoc special case from the integration path. Raising poncho's timestep from 2 to 5 ms leaves its per-step cost nearly flat, so the consistency price can be recovered by taking fewer steps where accuracy allows. Every other flex model was measured stable on Euler at its shipped timestep and switches to it (these models predate the post-hoc integrator; implicit was never load-bearing for them). They end up equal or faster than before: bunny_multicell 0.47 → 0.40, trampoline 0.28 → 0.25, plate 1.02 → 0.99, pancake 0.34 → 0.33. Finally, the per-step factorization makes configurations practical that the old code could only integrate explicitly: implicit stretch elasticity (`elastic2d="stretch"`/`"both"`, dim-3 solids) and factorized interp stiffness. No before/after exists for these — stock has no implicit treatment of stretch at all. ### Behavior changes - With the post-hoc correction deleted, interp/bending models running `solver="Newton"` (or elliptic cones, or islands) now integrate flex elasticity **explicitly** (previously: post-hoc implicit). Affects e.g. `gripper_trilinear` (stable, and faster, but different semantics). Follow-up options: Newton-side metric support, or a documented fallback. - With the gate on, `mj_forward` outputs are timestep-dependent for gated models (they answer the linearly-implicit discrete problem); `qacc_smooth` and `mj_inverse` change accordingly. Non-gated models are bit-identical (full suite green throughout). ### Validation - 1737/1737 tests, including new: `FlexStretchDerivatives` (FD-validated GN operator), `FlexStiffAssemble`/`FlexStiffAssembleInterp` (CSR ≡ operators), `GatedFlexInverseConsistency` (fails pre-change), equivalence tests vs the old post-hoc treatment (bending matches to 2e-11). - Fingerprint discipline throughout: bending-only models bit-exact across every refactor; permutation/kernel changes verified iteration-identical. ### Known follow-ups (not in this CL) 3×3-block sparse Cholesky kernel (the numeric factorization is index-bound; projected ~3× on the factor); mjModel persistence of the factor's symbolic pattern (rest-pose ND makes sizes compile-time); the general effective-metric mode (all solvers, all PSD-safe force classes, behind an enable flag). PiperOrigin-RevId: 948561856 Change-Id: I8b8e32ebd0428042af71647d0470d10773bf6daf
7575 lines
239 KiB
C++
7575 lines
239 KiB
C++
// Copyright 2025 DeepMind Technologies Limited
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// DO NOT EDIT. THIS FILE IS AUTOMATICALLY GENERATED.
|
|
|
|
// NOLINTBEGIN(whitespace/line_length)
|
|
// NOLINTBEGIN(whitespace/semicolon)
|
|
|
|
#ifndef MUJOCO_WASM_CODEGEN_GENERATED_BINDINGS_H_
|
|
#define MUJOCO_WASM_CODEGEN_GENERATED_BINDINGS_H_
|
|
|
|
#include <emscripten.h>
|
|
#include <emscripten/bind.h>
|
|
#include <emscripten/em_asm.h>
|
|
#include <emscripten/val.h>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring> // NOLINT
|
|
#include <memory>
|
|
#include <optional> // NOLINT
|
|
#include <sstream>
|
|
#include <string> // NOLINT
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
#include <mujoco/mjmodel.h>
|
|
#include <mujoco/mjspec.h>
|
|
#include <mujoco/mjvisualize.h>
|
|
#include <mujoco/mujoco.h>
|
|
#include "engine/engine_util_errmem.h"
|
|
#include "wasm/unpack.h"
|
|
#include "python/mujoco/indexer_xmacro.h"
|
|
|
|
namespace mujoco::wasm {
|
|
|
|
using emscripten::enum_;
|
|
using emscripten::function;
|
|
using emscripten::typed_memory_view;
|
|
using emscripten::val;
|
|
using emscripten::return_value_policy::reference;
|
|
using emscripten::return_value_policy::take_ownership;
|
|
|
|
EMSCRIPTEN_DECLARE_VAL_TYPE(NumberOrString);
|
|
EMSCRIPTEN_DECLARE_VAL_TYPE(NumberArray);
|
|
EMSCRIPTEN_DECLARE_VAL_TYPE(String);
|
|
EMSCRIPTEN_DECLARE_VAL_TYPE(StringOrNull);
|
|
|
|
// Macro to define accessors for different MuJoCo object types within mjModel.
|
|
// Each line calls X_ACCESSOR with the following arguments:
|
|
// 1. NAME: The object type name in uppercase (e.g., ACTUATOR).
|
|
// 2. Name: The object type name in CamelCase (e.g., Actuator).
|
|
// 3. OBJTYPE: The corresponding mjOBJ_* enum value (e.g., mjOBJ_ACTUATOR).
|
|
// 4. field: The name of the array field in mjModel (e.g., actuator).
|
|
// 5. nfield: The name of the count field in mjModel (e.g., nu).
|
|
#define MJMODEL_ACCESSORS \
|
|
X_ACCESSOR( ACTUATOR, Actuator, mjOBJ_ACTUATOR, actuator, nu ) \
|
|
X_ACCESSOR( BODY, Body, mjOBJ_BODY, body, nbody ) \
|
|
X_ACCESSOR( CAMERA, Camera, mjOBJ_CAMERA, cam, ncam ) \
|
|
X_ACCESSOR( EQUALITY, Equality, mjOBJ_EQUALITY, eq, neq ) \
|
|
X_ACCESSOR( EXCLUDE, Exclude, mjOBJ_EXCLUDE, exclude, nexclude ) \
|
|
X_ACCESSOR( GEOM, Geom, mjOBJ_GEOM, geom, ngeom ) \
|
|
X_ACCESSOR( HFIELD, Hfield, mjOBJ_HFIELD, hfield, nhfield ) \
|
|
X_ACCESSOR( JOINT, Joint, mjOBJ_JOINT, jnt, njnt ) \
|
|
X_ACCESSOR( LIGHT, Light, mjOBJ_LIGHT, light, nlight ) \
|
|
X_ACCESSOR( MATERIAL, Material, mjOBJ_MATERIAL, mat, nmat ) \
|
|
X_ACCESSOR( MESH, Mesh, mjOBJ_MESH, mesh, nmesh ) \
|
|
X_ACCESSOR( NUMERIC, Numeric, mjOBJ_NUMERIC, numeric, nnumeric ) \
|
|
X_ACCESSOR( PAIR, Pair, mjOBJ_PAIR, pair, npair ) \
|
|
X_ACCESSOR( SENSOR, Sensor, mjOBJ_SENSOR, sensor, nsensor ) \
|
|
X_ACCESSOR( SITE, Site, mjOBJ_SITE, site, nsite ) \
|
|
X_ACCESSOR( SKIN, Skin, mjOBJ_SKIN, skin, nskin ) \
|
|
X_ACCESSOR( TENDON, Tendon, mjOBJ_TENDON, tendon, ntendon ) \
|
|
X_ACCESSOR( TEXTURE, Texture, mjOBJ_TEXTURE, tex, ntex ) \
|
|
X_ACCESSOR( TUPLE, Tuple, mjOBJ_TUPLE, tuple, ntuple ) \
|
|
X_ACCESSOR( KEYFRAME, Keyframe, mjOBJ_KEY, key, nkey )
|
|
|
|
// Macro to define accessors for different MuJoCo object types within mjData.
|
|
// Each line calls X_ACCESSOR with the following arguments:
|
|
// 1. NAME: The object type name in uppercase (e.g., ACTUATOR).
|
|
// 2. Name: The object type name in CamelCase (e.g., Actuator).
|
|
// 3. OBJTYPE: The corresponding mjOBJ_* enum value (e.g., mjOBJ_ACTUATOR).
|
|
// 4. field: The name of the array field in mjData (e.g., actuator).
|
|
// 5. nfield: The name of the count field in mjModel (e.g., nu).
|
|
#define MJDATA_ACCESSORS \
|
|
X_ACCESSOR( ACTUATOR, Actuator, mjOBJ_ACTUATOR, actuator, nu ) \
|
|
X_ACCESSOR( BODY, Body, mjOBJ_BODY, body, nbody ) \
|
|
X_ACCESSOR( CAMERA, Camera, mjOBJ_CAMERA, cam, ncam ) \
|
|
X_ACCESSOR( GEOM, Geom, mjOBJ_GEOM, geom, ngeom ) \
|
|
X_ACCESSOR( JOINT, Joint, mjOBJ_JOINT, jnt, njnt ) \
|
|
X_ACCESSOR( LIGHT, Light, mjOBJ_LIGHT, light, nlight ) \
|
|
X_ACCESSOR( SENSOR, Sensor, mjOBJ_SENSOR, sensor, nsensor ) \
|
|
X_ACCESSOR( SITE, Site, mjOBJ_SITE, site, nsite ) \
|
|
X_ACCESSOR( TENDON, Tendon, mjOBJ_TENDON, tendon, ntendon )
|
|
|
|
// Raises an error if the given val is null or undefined.
|
|
// A macro is used so that the error contains the name of the variable.
|
|
// TODO(matijak): Remove this when we can handle strings using UNPACK_STRING?
|
|
#define CHECK_VAL(val) \
|
|
if (val.isNull()) { \
|
|
mju_error("Invalid argument: %s is null", #val); \
|
|
} else if (val.isUndefined()) { \
|
|
mju_error("Invalid argument: %s is undefined", #val); \
|
|
}
|
|
|
|
std::string KeyErrorMessage(const mjModel* model, int objtype, int count,
|
|
std::string_view name, std::string_view accessor_name);
|
|
|
|
std::string IndexErrorMessage(int index, int count,
|
|
std::string_view accessor_name);
|
|
|
|
using mjVisualGlobal = decltype(::mjVisual::global);
|
|
using mjVisualHeadlight = decltype(::mjVisual::headlight);
|
|
using mjVisualMap = decltype(::mjVisual::map);
|
|
using mjVisualQuality = decltype(::mjVisual::quality);
|
|
using mjVisualRgba = decltype(::mjVisual::rgba);
|
|
using mjVisualScale = decltype(::mjVisual::scale);
|
|
|
|
#undef MJ_M
|
|
#define MJ_M(n) model_->n
|
|
// The X macro expands to a member function within an MjModel...Accessor struct.
|
|
// This function returns an emscripten::val, typically a typed memory view,
|
|
// providing access to array data within the underlying mjModel. The size and
|
|
// offset of the memory view are determined by the arguments:
|
|
// - type: The C++ type of the array elements (e.g., mjtNum, int).
|
|
// - prefix: The prefix of the field name in mjModel (e.g., jnt_, geom_).
|
|
// - var: The name of the field being accessed (e.g., qposadr, size).
|
|
// - dim0: Used to determine special indexing logic for dynamically sized arrays
|
|
// like joints (nq, nv), hfields, textures, numerics, and tuples.
|
|
// - dim1: The fixed dimension of the array if not dynamically sized. If "1",
|
|
// a single element is returned. Otherwise, it's used as the stride
|
|
// for the typed memory view.
|
|
#define X(type, prefix, var, dim0, dim1) \
|
|
emscripten::val get_##var() const { \
|
|
if constexpr (std::string_view(#dim0) == "nq") { \
|
|
int start = model_->jnt_qposadr[id_]; \
|
|
int end = (id_ < model_->njnt - 1) ? model_->jnt_qposadr[id_ + 1] : model_->nq; \
|
|
return val(typed_memory_view(end - start, model_->prefix##var + start)); \
|
|
} else if constexpr (std::string_view(#dim0) == "nv") { \
|
|
int start = model_->jnt_dofadr[id_]; \
|
|
int end = (id_ < model_->njnt - 1) ? model_->jnt_dofadr[id_ + 1] : model_->nv; \
|
|
return val(typed_memory_view(end - start, model_->prefix##var + start)); \
|
|
} else if constexpr (std::string_view(#dim0) == "nhfielddata") { \
|
|
int start = model_->hfield_adr[id_]; \
|
|
int count = model_->hfield_nrow[id_] * model_->hfield_ncol[id_]; \
|
|
return val(typed_memory_view(count, model_->hfield_data + start)); \
|
|
} else if constexpr (std::string_view(#dim0) == "ntexdata") { \
|
|
int start = model_->tex_adr[id_]; \
|
|
int count = model_->tex_height[id_] * model_->tex_width[id_] * model_->tex_nchannel[id_]; \
|
|
return val(typed_memory_view(count, model_->tex_data + start)); \
|
|
} else if constexpr (std::string_view(#dim0) == "nnumericdata") { \
|
|
int start = model_->numeric_adr[id_]; \
|
|
int count = model_->numeric_size[id_]; \
|
|
return val(typed_memory_view(count, model_->numeric_data + start)); \
|
|
} else if constexpr (std::string_view(#dim0) == "ntupledata") { \
|
|
int start = model_->tuple_adr[id_]; \
|
|
int count = model_->tuple_size[id_]; \
|
|
return val(typed_memory_view(count, model_->prefix##var + start)); \
|
|
} else { \
|
|
if constexpr (std::string_view(#dim1) == "1") { \
|
|
return val(model_->prefix##var[id_]); \
|
|
} else { \
|
|
return val(typed_memory_view(dim1, model_->prefix##var + id_ * dim1)); \
|
|
} \
|
|
} \
|
|
} \
|
|
void set_##var(const emscripten::val& value) { \
|
|
if constexpr (std::string_view(#dim0) == "nq") { \
|
|
int start = model_->jnt_qposadr[id_]; \
|
|
int end = (id_ < model_->njnt - 1) ? model_->jnt_qposadr[id_ + 1] : model_->nq; \
|
|
val(typed_memory_view(end - start, model_->prefix##var + start)) \
|
|
.call<void>("set", value); \
|
|
} else if constexpr (std::string_view(#dim0) == "nv") { \
|
|
int start = model_->jnt_dofadr[id_]; \
|
|
int end = (id_ < model_->njnt - 1) ? model_->jnt_dofadr[id_ + 1] : model_->nv; \
|
|
val(typed_memory_view(end - start, model_->prefix##var + start)) \
|
|
.call<void>("set", value); \
|
|
} else if constexpr (std::string_view(#dim0) == "nhfielddata") { \
|
|
int start = model_->hfield_adr[id_]; \
|
|
int count = model_->hfield_nrow[id_] * model_->hfield_ncol[id_]; \
|
|
val(typed_memory_view(count, model_->hfield_data + start)) \
|
|
.call<void>("set", value); \
|
|
} else if constexpr (std::string_view(#dim0) == "ntexdata") { \
|
|
int start = model_->tex_adr[id_]; \
|
|
int count = model_->tex_height[id_] * model_->tex_width[id_] * model_->tex_nchannel[id_]; \
|
|
val(typed_memory_view(count, model_->tex_data + start)) \
|
|
.call<void>("set", value); \
|
|
} else if constexpr (std::string_view(#dim0) == "nnumericdata") { \
|
|
int start = model_->numeric_adr[id_]; \
|
|
int count = model_->numeric_size[id_]; \
|
|
val(typed_memory_view(count, model_->numeric_data + start)) \
|
|
.call<void>("set", value); \
|
|
} else if constexpr (std::string_view(#dim0) == "ntupledata") { \
|
|
int start = model_->tuple_adr[id_]; \
|
|
int count = model_->tuple_size[id_]; \
|
|
val(typed_memory_view(count, model_->prefix##var + start)) \
|
|
.call<void>("set", value); \
|
|
} else { \
|
|
if constexpr (std::string_view(#dim1) == "1") { \
|
|
model_->prefix##var[id_] = value.as<type>(); \
|
|
} else { \
|
|
val(typed_memory_view(dim1, model_->prefix##var + id_ * dim1)) \
|
|
.call<void>("set", value); \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
// Expands to a struct definition for each object type in MJMODEL_ACCESSORS.
|
|
// Each struct, named `MjModel{Name}Accessor`, provides:
|
|
// - A constructor taking an `mjModel*` and an integer `id`.
|
|
// - An `id()` method to get the object's index.
|
|
// - A `name()` method to get the object's name using `mj_id2name`.
|
|
// - Member functions generated by the `MJMODEL_##NAME` macro, which in turn
|
|
// uses the `X` macro to define accessors for fields within `mjModel`.
|
|
#define X_ACCESSOR(NAME, Name, OBJTYPE, field, nfield) \
|
|
struct MjModel##Name##Accessor { \
|
|
MjModel##Name##Accessor(mjModel* model, int id) : model_(model), id_(id) {} \
|
|
\
|
|
int id() const { return id_; } \
|
|
std::string name() const { \
|
|
const char* name = mj_id2name(model_, OBJTYPE, id_); \
|
|
return name ? name : ""; \
|
|
} \
|
|
\
|
|
MJMODEL_##NAME \
|
|
\
|
|
private: \
|
|
mjModel* model_; \
|
|
int id_; \
|
|
};
|
|
MJMODEL_ACCESSORS
|
|
#undef X_ACCESSOR
|
|
|
|
// Expands to a struct definition for each object type in MJDATA_ACCESSORS.
|
|
// Each struct, named `MjData{Name}Accessor`, provides:
|
|
// - A constructor taking an `mjData*`, an `mjModel*`, and an integer `id`.
|
|
// - An `id()` method to get the object's index.
|
|
// - A `name()` method to get the object's name using `mj_id2name`.
|
|
// - Member functions generated by the `MJDATA_##NAME` macro, which in turn
|
|
// uses the `X` macro to define accessors for fields within `mjData`.
|
|
#undef MJ_M
|
|
#define MJ_M(n) model_->n
|
|
#undef X
|
|
#define X(type, prefix, var, dim0, dim1) \
|
|
emscripten::val get_##var() const { \
|
|
if constexpr (std::string_view(#dim0) == "nq") { \
|
|
int start = model_->jnt_qposadr[id_]; \
|
|
int end = (id_ < model_->njnt - 1) ? model_->jnt_qposadr[id_ + 1] : model_->nq; \
|
|
return val(typed_memory_view(end - start, data_->prefix##var + start)); \
|
|
} else if constexpr (std::string_view(#dim0) == "nv") { \
|
|
int start = model_->jnt_dofadr[id_]; \
|
|
int end = (id_ < model_->njnt - 1) ? model_->jnt_dofadr[id_ + 1] : model_->nv; \
|
|
if constexpr (std::string_view(#dim1) == "1") { \
|
|
return val(typed_memory_view(end - start, data_->prefix##var + start)); \
|
|
} else { \
|
|
return val(typed_memory_view( \
|
|
(end - start) * dim1, data_->prefix##var + start * dim1)); \
|
|
} \
|
|
} else if constexpr (std::string_view(#dim0) == "nsensordata") { \
|
|
int start = model_->sensor_adr[id_]; \
|
|
int count = model_->sensor_dim[id_]; \
|
|
return val(typed_memory_view(count, data_->sensordata + start)); \
|
|
} else { \
|
|
if constexpr (std::string_view(#dim1) == "1") { \
|
|
return val(data_->prefix##var[id_]); \
|
|
} else { \
|
|
return val(typed_memory_view(dim1, data_->prefix##var + id_ * dim1)); \
|
|
} \
|
|
} \
|
|
} \
|
|
void set_##var(const emscripten::val& value) { \
|
|
if constexpr (std::string_view(#dim0) == "nq") { \
|
|
int start = model_->jnt_qposadr[id_]; \
|
|
int end = (id_ < model_->njnt - 1) ? model_->jnt_qposadr[id_ + 1] : model_->nq; \
|
|
val(typed_memory_view(end - start, data_->prefix##var + start)) \
|
|
.call<void>("set", value); \
|
|
} else if constexpr (std::string_view(#dim0) == "nv") { \
|
|
int start = model_->jnt_dofadr[id_]; \
|
|
int end = (id_ < model_->njnt - 1) ? model_->jnt_dofadr[id_ + 1] : model_->nv; \
|
|
if constexpr (std::string_view(#dim1) == "1") { \
|
|
val(typed_memory_view(end - start, data_->prefix##var + start)) \
|
|
.call<void>("set", value); \
|
|
} else { \
|
|
val(typed_memory_view((end - start) * dim1, \
|
|
data_->prefix##var + start * dim1)) \
|
|
.call<void>("set", value); \
|
|
} \
|
|
} else if constexpr (std::string_view(#dim0) == "nsensordata") { \
|
|
int start = model_->sensor_adr[id_]; \
|
|
int count = model_->sensor_dim[id_]; \
|
|
val(typed_memory_view(count, data_->sensordata + start)) \
|
|
.call<void>("set", value); \
|
|
} else { \
|
|
if constexpr (std::string_view(#dim1) == "1") { \
|
|
data_->prefix##var[id_] = value.as<type>(); \
|
|
} else { \
|
|
val(typed_memory_view(dim1, data_->prefix##var + id_ * dim1)) \
|
|
.call<void>("set", value); \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define X_ACCESSOR(NAME, Name, OBJTYPE, field, nfield) \
|
|
struct MjData##Name##Accessor { \
|
|
MjData##Name##Accessor(mjData* data, mjModel* model, int id) : data_(data), model_(model), id_(id) {} \
|
|
\
|
|
int id() const { return id_; } \
|
|
std::string name() const { \
|
|
const char* name = mj_id2name(model_, OBJTYPE, id_); \
|
|
return name ? name : ""; \
|
|
} \
|
|
\
|
|
MJDATA_##NAME \
|
|
\
|
|
private: \
|
|
mjData* data_; \
|
|
mjModel* model_; \
|
|
int id_; \
|
|
};
|
|
MJDATA_ACCESSORS
|
|
#undef X_ACCESSOR
|
|
|
|
#undef X
|
|
#undef MJ_M
|
|
|
|
struct MjContact {
|
|
~MjContact();
|
|
MjContact();
|
|
explicit MjContact(mjContact *ptr);
|
|
MjContact(const MjContact &);
|
|
MjContact &operator=(const MjContact &);
|
|
std::unique_ptr<MjContact> copy();
|
|
mjContact* get() const;
|
|
void set(mjContact* ptr);
|
|
mjtNum dist() const {
|
|
return ptr_->dist;
|
|
}
|
|
void set_dist(mjtNum value) {
|
|
ptr_->dist = value;
|
|
}
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val frame() const {
|
|
return emscripten::val(emscripten::typed_memory_view(9, ptr_->frame));
|
|
}
|
|
mjtNum includemargin() const {
|
|
return ptr_->includemargin;
|
|
}
|
|
void set_includemargin(mjtNum value) {
|
|
ptr_->includemargin = value;
|
|
}
|
|
emscripten::val friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->friction));
|
|
}
|
|
emscripten::val solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
|
|
}
|
|
emscripten::val solreffriction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solreffriction));
|
|
}
|
|
emscripten::val solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
|
|
}
|
|
mjtNum mu() const {
|
|
return ptr_->mu;
|
|
}
|
|
void set_mu(mjtNum value) {
|
|
ptr_->mu = value;
|
|
}
|
|
emscripten::val H() const {
|
|
return emscripten::val(emscripten::typed_memory_view(36, ptr_->H));
|
|
}
|
|
int dim() const {
|
|
return ptr_->dim;
|
|
}
|
|
void set_dim(int value) {
|
|
ptr_->dim = value;
|
|
}
|
|
int geom1() const {
|
|
return ptr_->geom1;
|
|
}
|
|
void set_geom1(int value) {
|
|
ptr_->geom1 = value;
|
|
}
|
|
int geom2() const {
|
|
return ptr_->geom2;
|
|
}
|
|
void set_geom2(int value) {
|
|
ptr_->geom2 = value;
|
|
}
|
|
emscripten::val geom() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->geom));
|
|
}
|
|
emscripten::val flex() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->flex));
|
|
}
|
|
emscripten::val elem() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->elem));
|
|
}
|
|
emscripten::val vert() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->vert));
|
|
}
|
|
int exclude() const {
|
|
return ptr_->exclude;
|
|
}
|
|
void set_exclude(int value) {
|
|
ptr_->exclude = value;
|
|
}
|
|
int efc_address() const {
|
|
return ptr_->efc_address;
|
|
}
|
|
void set_efc_address(int value) {
|
|
ptr_->efc_address = value;
|
|
}
|
|
|
|
private:
|
|
mjContact* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjLROpt {
|
|
~MjLROpt();
|
|
MjLROpt();
|
|
explicit MjLROpt(mjLROpt *ptr);
|
|
MjLROpt(const MjLROpt &);
|
|
MjLROpt &operator=(const MjLROpt &);
|
|
std::unique_ptr<MjLROpt> copy();
|
|
mjLROpt* get() const;
|
|
void set(mjLROpt* ptr);
|
|
int mode() const {
|
|
return ptr_->mode;
|
|
}
|
|
void set_mode(int value) {
|
|
ptr_->mode = value;
|
|
}
|
|
int useexisting() const {
|
|
return ptr_->useexisting;
|
|
}
|
|
void set_useexisting(int value) {
|
|
ptr_->useexisting = value;
|
|
}
|
|
int uselimit() const {
|
|
return ptr_->uselimit;
|
|
}
|
|
void set_uselimit(int value) {
|
|
ptr_->uselimit = value;
|
|
}
|
|
mjtNum accel() const {
|
|
return ptr_->accel;
|
|
}
|
|
void set_accel(mjtNum value) {
|
|
ptr_->accel = value;
|
|
}
|
|
mjtNum maxforce() const {
|
|
return ptr_->maxforce;
|
|
}
|
|
void set_maxforce(mjtNum value) {
|
|
ptr_->maxforce = value;
|
|
}
|
|
mjtNum timeconst() const {
|
|
return ptr_->timeconst;
|
|
}
|
|
void set_timeconst(mjtNum value) {
|
|
ptr_->timeconst = value;
|
|
}
|
|
mjtNum timestep() const {
|
|
return ptr_->timestep;
|
|
}
|
|
void set_timestep(mjtNum value) {
|
|
ptr_->timestep = value;
|
|
}
|
|
mjtNum inttotal() const {
|
|
return ptr_->inttotal;
|
|
}
|
|
void set_inttotal(mjtNum value) {
|
|
ptr_->inttotal = value;
|
|
}
|
|
mjtNum interval() const {
|
|
return ptr_->interval;
|
|
}
|
|
void set_interval(mjtNum value) {
|
|
ptr_->interval = value;
|
|
}
|
|
mjtNum tolrange() const {
|
|
return ptr_->tolrange;
|
|
}
|
|
void set_tolrange(mjtNum value) {
|
|
ptr_->tolrange = value;
|
|
}
|
|
|
|
private:
|
|
mjLROpt* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjLogConfig {
|
|
~MjLogConfig();
|
|
MjLogConfig();
|
|
explicit MjLogConfig(mjLogConfig *ptr);
|
|
MjLogConfig(const MjLogConfig &);
|
|
MjLogConfig &operator=(const MjLogConfig &);
|
|
std::unique_ptr<MjLogConfig> copy();
|
|
mjLogConfig* get() const;
|
|
void set(mjLogConfig* ptr);
|
|
mjtBool logto_console() const {
|
|
return ptr_->logto_console;
|
|
}
|
|
void set_logto_console(mjtBool value) {
|
|
ptr_->logto_console = value;
|
|
}
|
|
mjtBool logto_file() const {
|
|
return ptr_->logto_file;
|
|
}
|
|
void set_logto_file(mjtBool value) {
|
|
ptr_->logto_file = value;
|
|
}
|
|
emscripten::val logfile() const {
|
|
return emscripten::val(emscripten::typed_memory_view(1024, ptr_->logfile));
|
|
}
|
|
int topics() const {
|
|
return ptr_->topics;
|
|
}
|
|
void set_topics(int value) {
|
|
ptr_->topics = value;
|
|
}
|
|
|
|
private:
|
|
mjLogConfig* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjLogMessage {
|
|
~MjLogMessage();
|
|
MjLogMessage();
|
|
explicit MjLogMessage(mjLogMessage *ptr);
|
|
mjLogMessage* get() const;
|
|
void set(mjLogMessage* ptr);
|
|
int level() const {
|
|
return ptr_->level;
|
|
}
|
|
void set_level(int value) {
|
|
ptr_->level = value;
|
|
}
|
|
int topic() const {
|
|
return ptr_->topic;
|
|
}
|
|
void set_topic(int value) {
|
|
ptr_->topic = value;
|
|
}
|
|
emscripten::val subject() const {
|
|
return emscripten::val(emscripten::typed_memory_view(1024, ptr_->subject));
|
|
}
|
|
std::string body() const {
|
|
return ptr_->body ? std::string(ptr_->body) : "";
|
|
}
|
|
std::string func() const {
|
|
return ptr_->func ? std::string(ptr_->func) : "";
|
|
}
|
|
std::string file() const {
|
|
return ptr_->file ? std::string(ptr_->file) : "";
|
|
}
|
|
int line() const {
|
|
return ptr_->line;
|
|
}
|
|
void set_line(int value) {
|
|
ptr_->line = value;
|
|
}
|
|
mjtBool timestamp() const {
|
|
return ptr_->timestamp;
|
|
}
|
|
void set_timestamp(mjtBool value) {
|
|
ptr_->timestamp = value;
|
|
}
|
|
|
|
private:
|
|
mjLogMessage* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjOption {
|
|
~MjOption();
|
|
MjOption();
|
|
explicit MjOption(mjOption *ptr);
|
|
MjOption(const MjOption &);
|
|
MjOption &operator=(const MjOption &);
|
|
std::unique_ptr<MjOption> copy();
|
|
mjOption* get() const;
|
|
void set(mjOption* ptr);
|
|
mjtNum timestep() const {
|
|
return ptr_->timestep;
|
|
}
|
|
void set_timestep(mjtNum value) {
|
|
ptr_->timestep = value;
|
|
}
|
|
mjtNum impratio() const {
|
|
return ptr_->impratio;
|
|
}
|
|
void set_impratio(mjtNum value) {
|
|
ptr_->impratio = value;
|
|
}
|
|
mjtNum tolerance() const {
|
|
return ptr_->tolerance;
|
|
}
|
|
void set_tolerance(mjtNum value) {
|
|
ptr_->tolerance = value;
|
|
}
|
|
mjtNum ls_tolerance() const {
|
|
return ptr_->ls_tolerance;
|
|
}
|
|
void set_ls_tolerance(mjtNum value) {
|
|
ptr_->ls_tolerance = value;
|
|
}
|
|
mjtNum noslip_tolerance() const {
|
|
return ptr_->noslip_tolerance;
|
|
}
|
|
void set_noslip_tolerance(mjtNum value) {
|
|
ptr_->noslip_tolerance = value;
|
|
}
|
|
mjtNum ccd_tolerance() const {
|
|
return ptr_->ccd_tolerance;
|
|
}
|
|
void set_ccd_tolerance(mjtNum value) {
|
|
ptr_->ccd_tolerance = value;
|
|
}
|
|
mjtNum sleep_tolerance() const {
|
|
return ptr_->sleep_tolerance;
|
|
}
|
|
void set_sleep_tolerance(mjtNum value) {
|
|
ptr_->sleep_tolerance = value;
|
|
}
|
|
emscripten::val gravity() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->gravity));
|
|
}
|
|
emscripten::val wind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->wind));
|
|
}
|
|
emscripten::val magnetic() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->magnetic));
|
|
}
|
|
mjtNum density() const {
|
|
return ptr_->density;
|
|
}
|
|
void set_density(mjtNum value) {
|
|
ptr_->density = value;
|
|
}
|
|
mjtNum viscosity() const {
|
|
return ptr_->viscosity;
|
|
}
|
|
void set_viscosity(mjtNum value) {
|
|
ptr_->viscosity = value;
|
|
}
|
|
mjtNum o_margin() const {
|
|
return ptr_->o_margin;
|
|
}
|
|
void set_o_margin(mjtNum value) {
|
|
ptr_->o_margin = value;
|
|
}
|
|
emscripten::val o_solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->o_solref));
|
|
}
|
|
emscripten::val o_solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->o_solimp));
|
|
}
|
|
emscripten::val o_friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->o_friction));
|
|
}
|
|
int integrator() const {
|
|
return ptr_->integrator;
|
|
}
|
|
void set_integrator(int value) {
|
|
ptr_->integrator = value;
|
|
}
|
|
int cone() const {
|
|
return ptr_->cone;
|
|
}
|
|
void set_cone(int value) {
|
|
ptr_->cone = value;
|
|
}
|
|
int jacobian() const {
|
|
return ptr_->jacobian;
|
|
}
|
|
void set_jacobian(int value) {
|
|
ptr_->jacobian = value;
|
|
}
|
|
int solver() const {
|
|
return ptr_->solver;
|
|
}
|
|
void set_solver(int value) {
|
|
ptr_->solver = value;
|
|
}
|
|
int iterations() const {
|
|
return ptr_->iterations;
|
|
}
|
|
void set_iterations(int value) {
|
|
ptr_->iterations = value;
|
|
}
|
|
int ls_iterations() const {
|
|
return ptr_->ls_iterations;
|
|
}
|
|
void set_ls_iterations(int value) {
|
|
ptr_->ls_iterations = value;
|
|
}
|
|
int noslip_iterations() const {
|
|
return ptr_->noslip_iterations;
|
|
}
|
|
void set_noslip_iterations(int value) {
|
|
ptr_->noslip_iterations = value;
|
|
}
|
|
int ccd_iterations() const {
|
|
return ptr_->ccd_iterations;
|
|
}
|
|
void set_ccd_iterations(int value) {
|
|
ptr_->ccd_iterations = value;
|
|
}
|
|
int disableflags() const {
|
|
return ptr_->disableflags;
|
|
}
|
|
void set_disableflags(int value) {
|
|
ptr_->disableflags = value;
|
|
}
|
|
int enableflags() const {
|
|
return ptr_->enableflags;
|
|
}
|
|
void set_enableflags(int value) {
|
|
ptr_->enableflags = value;
|
|
}
|
|
int disableactuator() const {
|
|
return ptr_->disableactuator;
|
|
}
|
|
void set_disableactuator(int value) {
|
|
ptr_->disableactuator = value;
|
|
}
|
|
int sdf_initpoints() const {
|
|
return ptr_->sdf_initpoints;
|
|
}
|
|
void set_sdf_initpoints(int value) {
|
|
ptr_->sdf_initpoints = value;
|
|
}
|
|
int sdf_iterations() const {
|
|
return ptr_->sdf_iterations;
|
|
}
|
|
void set_sdf_iterations(int value) {
|
|
ptr_->sdf_iterations = value;
|
|
}
|
|
|
|
private:
|
|
mjOption* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjPreContact {
|
|
~MjPreContact();
|
|
MjPreContact();
|
|
explicit MjPreContact(mjPreContact *ptr);
|
|
MjPreContact(const MjPreContact &);
|
|
MjPreContact &operator=(const MjPreContact &);
|
|
std::unique_ptr<MjPreContact> copy();
|
|
mjPreContact* get() const;
|
|
void set(mjPreContact* ptr);
|
|
mjtNum dist() const {
|
|
return ptr_->dist;
|
|
}
|
|
void set_dist(mjtNum value) {
|
|
ptr_->dist = value;
|
|
}
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val normal() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->normal));
|
|
}
|
|
emscripten::val tangent() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->tangent));
|
|
}
|
|
|
|
private:
|
|
mjPreContact* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjSolverStat {
|
|
~MjSolverStat();
|
|
MjSolverStat();
|
|
explicit MjSolverStat(mjSolverStat *ptr);
|
|
MjSolverStat(const MjSolverStat &);
|
|
MjSolverStat &operator=(const MjSolverStat &);
|
|
std::unique_ptr<MjSolverStat> copy();
|
|
mjSolverStat* get() const;
|
|
void set(mjSolverStat* ptr);
|
|
mjtNum improvement() const {
|
|
return ptr_->improvement;
|
|
}
|
|
void set_improvement(mjtNum value) {
|
|
ptr_->improvement = value;
|
|
}
|
|
mjtNum gradient() const {
|
|
return ptr_->gradient;
|
|
}
|
|
void set_gradient(mjtNum value) {
|
|
ptr_->gradient = value;
|
|
}
|
|
mjtNum lineslope() const {
|
|
return ptr_->lineslope;
|
|
}
|
|
void set_lineslope(mjtNum value) {
|
|
ptr_->lineslope = value;
|
|
}
|
|
int nactive() const {
|
|
return ptr_->nactive;
|
|
}
|
|
void set_nactive(int value) {
|
|
ptr_->nactive = value;
|
|
}
|
|
int nchange() const {
|
|
return ptr_->nchange;
|
|
}
|
|
void set_nchange(int value) {
|
|
ptr_->nchange = value;
|
|
}
|
|
int neval() const {
|
|
return ptr_->neval;
|
|
}
|
|
void set_neval(int value) {
|
|
ptr_->neval = value;
|
|
}
|
|
int nupdate() const {
|
|
return ptr_->nupdate;
|
|
}
|
|
void set_nupdate(int value) {
|
|
ptr_->nupdate = value;
|
|
}
|
|
|
|
private:
|
|
mjSolverStat* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjStatistic {
|
|
~MjStatistic();
|
|
MjStatistic();
|
|
explicit MjStatistic(mjStatistic *ptr);
|
|
MjStatistic(const MjStatistic &);
|
|
MjStatistic &operator=(const MjStatistic &);
|
|
std::unique_ptr<MjStatistic> copy();
|
|
mjStatistic* get() const;
|
|
void set(mjStatistic* ptr);
|
|
mjtNum meaninertia() const {
|
|
return ptr_->meaninertia;
|
|
}
|
|
void set_meaninertia(mjtNum value) {
|
|
ptr_->meaninertia = value;
|
|
}
|
|
mjtNum meanmass() const {
|
|
return ptr_->meanmass;
|
|
}
|
|
void set_meanmass(mjtNum value) {
|
|
ptr_->meanmass = value;
|
|
}
|
|
mjtNum meansize() const {
|
|
return ptr_->meansize;
|
|
}
|
|
void set_meansize(mjtNum value) {
|
|
ptr_->meansize = value;
|
|
}
|
|
mjtNum extent() const {
|
|
return ptr_->extent;
|
|
}
|
|
void set_extent(mjtNum value) {
|
|
ptr_->extent = value;
|
|
}
|
|
emscripten::val center() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->center));
|
|
}
|
|
|
|
private:
|
|
mjStatistic* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjTimerStat {
|
|
~MjTimerStat();
|
|
MjTimerStat();
|
|
explicit MjTimerStat(mjTimerStat *ptr);
|
|
MjTimerStat(const MjTimerStat &);
|
|
MjTimerStat &operator=(const MjTimerStat &);
|
|
std::unique_ptr<MjTimerStat> copy();
|
|
mjTimerStat* get() const;
|
|
void set(mjTimerStat* ptr);
|
|
mjtNum duration() const {
|
|
return ptr_->duration;
|
|
}
|
|
void set_duration(mjtNum value) {
|
|
ptr_->duration = value;
|
|
}
|
|
int number() const {
|
|
return ptr_->number;
|
|
}
|
|
void set_number(int value) {
|
|
ptr_->number = value;
|
|
}
|
|
|
|
private:
|
|
mjTimerStat* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjVisualGlobal {
|
|
~MjVisualGlobal();
|
|
MjVisualGlobal();
|
|
explicit MjVisualGlobal(mjVisualGlobal *ptr);
|
|
MjVisualGlobal(const MjVisualGlobal &);
|
|
MjVisualGlobal &operator=(const MjVisualGlobal &);
|
|
std::unique_ptr<MjVisualGlobal> copy();
|
|
mjVisualGlobal* get() const;
|
|
void set(mjVisualGlobal* ptr);
|
|
int cameraid() const {
|
|
return ptr_->cameraid;
|
|
}
|
|
void set_cameraid(int value) {
|
|
ptr_->cameraid = value;
|
|
}
|
|
int orthographic() const {
|
|
return ptr_->orthographic;
|
|
}
|
|
void set_orthographic(int value) {
|
|
ptr_->orthographic = value;
|
|
}
|
|
float fovy() const {
|
|
return ptr_->fovy;
|
|
}
|
|
void set_fovy(float value) {
|
|
ptr_->fovy = value;
|
|
}
|
|
float ipd() const {
|
|
return ptr_->ipd;
|
|
}
|
|
void set_ipd(float value) {
|
|
ptr_->ipd = value;
|
|
}
|
|
float azimuth() const {
|
|
return ptr_->azimuth;
|
|
}
|
|
void set_azimuth(float value) {
|
|
ptr_->azimuth = value;
|
|
}
|
|
float elevation() const {
|
|
return ptr_->elevation;
|
|
}
|
|
void set_elevation(float value) {
|
|
ptr_->elevation = value;
|
|
}
|
|
float linewidth() const {
|
|
return ptr_->linewidth;
|
|
}
|
|
void set_linewidth(float value) {
|
|
ptr_->linewidth = value;
|
|
}
|
|
float glow() const {
|
|
return ptr_->glow;
|
|
}
|
|
void set_glow(float value) {
|
|
ptr_->glow = value;
|
|
}
|
|
float realtime() const {
|
|
return ptr_->realtime;
|
|
}
|
|
void set_realtime(float value) {
|
|
ptr_->realtime = value;
|
|
}
|
|
int offwidth() const {
|
|
return ptr_->offwidth;
|
|
}
|
|
void set_offwidth(int value) {
|
|
ptr_->offwidth = value;
|
|
}
|
|
int offheight() const {
|
|
return ptr_->offheight;
|
|
}
|
|
void set_offheight(int value) {
|
|
ptr_->offheight = value;
|
|
}
|
|
int ellipsoidinertia() const {
|
|
return ptr_->ellipsoidinertia;
|
|
}
|
|
void set_ellipsoidinertia(int value) {
|
|
ptr_->ellipsoidinertia = value;
|
|
}
|
|
int bvactive() const {
|
|
return ptr_->bvactive;
|
|
}
|
|
void set_bvactive(int value) {
|
|
ptr_->bvactive = value;
|
|
}
|
|
|
|
private:
|
|
mjVisualGlobal* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjVisualHeadlight {
|
|
~MjVisualHeadlight();
|
|
MjVisualHeadlight();
|
|
explicit MjVisualHeadlight(mjVisualHeadlight *ptr);
|
|
MjVisualHeadlight(const MjVisualHeadlight &);
|
|
MjVisualHeadlight &operator=(const MjVisualHeadlight &);
|
|
std::unique_ptr<MjVisualHeadlight> copy();
|
|
mjVisualHeadlight* get() const;
|
|
void set(mjVisualHeadlight* ptr);
|
|
emscripten::val ambient() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->ambient));
|
|
}
|
|
emscripten::val diffuse() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->diffuse));
|
|
}
|
|
emscripten::val specular() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->specular));
|
|
}
|
|
int active() const {
|
|
return ptr_->active;
|
|
}
|
|
void set_active(int value) {
|
|
ptr_->active = value;
|
|
}
|
|
|
|
private:
|
|
mjVisualHeadlight* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjVisualMap {
|
|
~MjVisualMap();
|
|
MjVisualMap();
|
|
explicit MjVisualMap(mjVisualMap *ptr);
|
|
MjVisualMap(const MjVisualMap &);
|
|
MjVisualMap &operator=(const MjVisualMap &);
|
|
std::unique_ptr<MjVisualMap> copy();
|
|
mjVisualMap* get() const;
|
|
void set(mjVisualMap* ptr);
|
|
float stiffness() const {
|
|
return ptr_->stiffness;
|
|
}
|
|
void set_stiffness(float value) {
|
|
ptr_->stiffness = value;
|
|
}
|
|
float stiffnessrot() const {
|
|
return ptr_->stiffnessrot;
|
|
}
|
|
void set_stiffnessrot(float value) {
|
|
ptr_->stiffnessrot = value;
|
|
}
|
|
float force() const {
|
|
return ptr_->force;
|
|
}
|
|
void set_force(float value) {
|
|
ptr_->force = value;
|
|
}
|
|
float torque() const {
|
|
return ptr_->torque;
|
|
}
|
|
void set_torque(float value) {
|
|
ptr_->torque = value;
|
|
}
|
|
float alpha() const {
|
|
return ptr_->alpha;
|
|
}
|
|
void set_alpha(float value) {
|
|
ptr_->alpha = value;
|
|
}
|
|
float fogstart() const {
|
|
return ptr_->fogstart;
|
|
}
|
|
void set_fogstart(float value) {
|
|
ptr_->fogstart = value;
|
|
}
|
|
float fogend() const {
|
|
return ptr_->fogend;
|
|
}
|
|
void set_fogend(float value) {
|
|
ptr_->fogend = value;
|
|
}
|
|
float znear() const {
|
|
return ptr_->znear;
|
|
}
|
|
void set_znear(float value) {
|
|
ptr_->znear = value;
|
|
}
|
|
float zfar() const {
|
|
return ptr_->zfar;
|
|
}
|
|
void set_zfar(float value) {
|
|
ptr_->zfar = value;
|
|
}
|
|
float haze() const {
|
|
return ptr_->haze;
|
|
}
|
|
void set_haze(float value) {
|
|
ptr_->haze = value;
|
|
}
|
|
float shadowclip() const {
|
|
return ptr_->shadowclip;
|
|
}
|
|
void set_shadowclip(float value) {
|
|
ptr_->shadowclip = value;
|
|
}
|
|
float shadowscale() const {
|
|
return ptr_->shadowscale;
|
|
}
|
|
void set_shadowscale(float value) {
|
|
ptr_->shadowscale = value;
|
|
}
|
|
float actuatortendon() const {
|
|
return ptr_->actuatortendon;
|
|
}
|
|
void set_actuatortendon(float value) {
|
|
ptr_->actuatortendon = value;
|
|
}
|
|
|
|
private:
|
|
mjVisualMap* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjVisualQuality {
|
|
~MjVisualQuality();
|
|
MjVisualQuality();
|
|
explicit MjVisualQuality(mjVisualQuality *ptr);
|
|
MjVisualQuality(const MjVisualQuality &);
|
|
MjVisualQuality &operator=(const MjVisualQuality &);
|
|
std::unique_ptr<MjVisualQuality> copy();
|
|
mjVisualQuality* get() const;
|
|
void set(mjVisualQuality* ptr);
|
|
int shadowsize() const {
|
|
return ptr_->shadowsize;
|
|
}
|
|
void set_shadowsize(int value) {
|
|
ptr_->shadowsize = value;
|
|
}
|
|
int offsamples() const {
|
|
return ptr_->offsamples;
|
|
}
|
|
void set_offsamples(int value) {
|
|
ptr_->offsamples = value;
|
|
}
|
|
int numslices() const {
|
|
return ptr_->numslices;
|
|
}
|
|
void set_numslices(int value) {
|
|
ptr_->numslices = value;
|
|
}
|
|
int numstacks() const {
|
|
return ptr_->numstacks;
|
|
}
|
|
void set_numstacks(int value) {
|
|
ptr_->numstacks = value;
|
|
}
|
|
int numquads() const {
|
|
return ptr_->numquads;
|
|
}
|
|
void set_numquads(int value) {
|
|
ptr_->numquads = value;
|
|
}
|
|
|
|
private:
|
|
mjVisualQuality* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjVisualRgba {
|
|
~MjVisualRgba();
|
|
MjVisualRgba();
|
|
explicit MjVisualRgba(mjVisualRgba *ptr);
|
|
MjVisualRgba(const MjVisualRgba &);
|
|
MjVisualRgba &operator=(const MjVisualRgba &);
|
|
std::unique_ptr<MjVisualRgba> copy();
|
|
mjVisualRgba* get() const;
|
|
void set(mjVisualRgba* ptr);
|
|
emscripten::val fog() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->fog));
|
|
}
|
|
emscripten::val haze() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->haze));
|
|
}
|
|
emscripten::val force() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->force));
|
|
}
|
|
emscripten::val inertia() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->inertia));
|
|
}
|
|
emscripten::val joint() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->joint));
|
|
}
|
|
emscripten::val actuator() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->actuator));
|
|
}
|
|
emscripten::val actuatornegative() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->actuatornegative));
|
|
}
|
|
emscripten::val actuatorpositive() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->actuatorpositive));
|
|
}
|
|
emscripten::val com() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->com));
|
|
}
|
|
emscripten::val camera() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->camera));
|
|
}
|
|
emscripten::val light() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->light));
|
|
}
|
|
emscripten::val selectpoint() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->selectpoint));
|
|
}
|
|
emscripten::val connect() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->connect));
|
|
}
|
|
emscripten::val contactpoint() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->contactpoint));
|
|
}
|
|
emscripten::val contactforce() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->contactforce));
|
|
}
|
|
emscripten::val contactfriction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->contactfriction));
|
|
}
|
|
emscripten::val contacttorque() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->contacttorque));
|
|
}
|
|
emscripten::val contactgap() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->contactgap));
|
|
}
|
|
emscripten::val rangefinder() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->rangefinder));
|
|
}
|
|
emscripten::val constraint() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->constraint));
|
|
}
|
|
emscripten::val slidercrank() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->slidercrank));
|
|
}
|
|
emscripten::val crankbroken() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->crankbroken));
|
|
}
|
|
emscripten::val frustum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->frustum));
|
|
}
|
|
emscripten::val bv() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->bv));
|
|
}
|
|
emscripten::val bvactive() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->bvactive));
|
|
}
|
|
|
|
private:
|
|
mjVisualRgba* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjVisualScale {
|
|
~MjVisualScale();
|
|
MjVisualScale();
|
|
explicit MjVisualScale(mjVisualScale *ptr);
|
|
MjVisualScale(const MjVisualScale &);
|
|
MjVisualScale &operator=(const MjVisualScale &);
|
|
std::unique_ptr<MjVisualScale> copy();
|
|
mjVisualScale* get() const;
|
|
void set(mjVisualScale* ptr);
|
|
float forcewidth() const {
|
|
return ptr_->forcewidth;
|
|
}
|
|
void set_forcewidth(float value) {
|
|
ptr_->forcewidth = value;
|
|
}
|
|
float contactwidth() const {
|
|
return ptr_->contactwidth;
|
|
}
|
|
void set_contactwidth(float value) {
|
|
ptr_->contactwidth = value;
|
|
}
|
|
float contactheight() const {
|
|
return ptr_->contactheight;
|
|
}
|
|
void set_contactheight(float value) {
|
|
ptr_->contactheight = value;
|
|
}
|
|
float connect() const {
|
|
return ptr_->connect;
|
|
}
|
|
void set_connect(float value) {
|
|
ptr_->connect = value;
|
|
}
|
|
float com() const {
|
|
return ptr_->com;
|
|
}
|
|
void set_com(float value) {
|
|
ptr_->com = value;
|
|
}
|
|
float camera() const {
|
|
return ptr_->camera;
|
|
}
|
|
void set_camera(float value) {
|
|
ptr_->camera = value;
|
|
}
|
|
float light() const {
|
|
return ptr_->light;
|
|
}
|
|
void set_light(float value) {
|
|
ptr_->light = value;
|
|
}
|
|
float selectpoint() const {
|
|
return ptr_->selectpoint;
|
|
}
|
|
void set_selectpoint(float value) {
|
|
ptr_->selectpoint = value;
|
|
}
|
|
float jointlength() const {
|
|
return ptr_->jointlength;
|
|
}
|
|
void set_jointlength(float value) {
|
|
ptr_->jointlength = value;
|
|
}
|
|
float jointwidth() const {
|
|
return ptr_->jointwidth;
|
|
}
|
|
void set_jointwidth(float value) {
|
|
ptr_->jointwidth = value;
|
|
}
|
|
float actuatorlength() const {
|
|
return ptr_->actuatorlength;
|
|
}
|
|
void set_actuatorlength(float value) {
|
|
ptr_->actuatorlength = value;
|
|
}
|
|
float actuatorwidth() const {
|
|
return ptr_->actuatorwidth;
|
|
}
|
|
void set_actuatorwidth(float value) {
|
|
ptr_->actuatorwidth = value;
|
|
}
|
|
float framelength() const {
|
|
return ptr_->framelength;
|
|
}
|
|
void set_framelength(float value) {
|
|
ptr_->framelength = value;
|
|
}
|
|
float framewidth() const {
|
|
return ptr_->framewidth;
|
|
}
|
|
void set_framewidth(float value) {
|
|
ptr_->framewidth = value;
|
|
}
|
|
float constraint() const {
|
|
return ptr_->constraint;
|
|
}
|
|
void set_constraint(float value) {
|
|
ptr_->constraint = value;
|
|
}
|
|
float slidercrank() const {
|
|
return ptr_->slidercrank;
|
|
}
|
|
void set_slidercrank(float value) {
|
|
ptr_->slidercrank = value;
|
|
}
|
|
float frustum() const {
|
|
return ptr_->frustum;
|
|
}
|
|
void set_frustum(float value) {
|
|
ptr_->frustum = value;
|
|
}
|
|
|
|
private:
|
|
mjVisualScale* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjWarningStat {
|
|
~MjWarningStat();
|
|
MjWarningStat();
|
|
explicit MjWarningStat(mjWarningStat *ptr);
|
|
MjWarningStat(const MjWarningStat &);
|
|
MjWarningStat &operator=(const MjWarningStat &);
|
|
std::unique_ptr<MjWarningStat> copy();
|
|
mjWarningStat* get() const;
|
|
void set(mjWarningStat* ptr);
|
|
int lastinfo() const {
|
|
return ptr_->lastinfo;
|
|
}
|
|
void set_lastinfo(int value) {
|
|
ptr_->lastinfo = value;
|
|
}
|
|
int number() const {
|
|
return ptr_->number;
|
|
}
|
|
void set_number(int value) {
|
|
ptr_->number = value;
|
|
}
|
|
|
|
private:
|
|
mjWarningStat* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjsAuthored {
|
|
explicit MjsAuthored(mjsAuthored *ptr);
|
|
mjsAuthored* get() const;
|
|
void set(mjsAuthored* ptr);
|
|
uint64_t option() const {
|
|
return ptr_->option;
|
|
}
|
|
void set_option(uint64_t value) {
|
|
ptr_->option = value;
|
|
}
|
|
int disableflags() const {
|
|
return ptr_->disableflags;
|
|
}
|
|
void set_disableflags(int value) {
|
|
ptr_->disableflags = value;
|
|
}
|
|
int enableflags() const {
|
|
return ptr_->enableflags;
|
|
}
|
|
void set_enableflags(int value) {
|
|
ptr_->enableflags = value;
|
|
}
|
|
int disableactuator() const {
|
|
return ptr_->disableactuator;
|
|
}
|
|
void set_disableactuator(int value) {
|
|
ptr_->disableactuator = value;
|
|
}
|
|
uint64_t visual_global() const {
|
|
return ptr_->visual_global;
|
|
}
|
|
void set_visual_global(uint64_t value) {
|
|
ptr_->visual_global = value;
|
|
}
|
|
uint64_t visual_quality() const {
|
|
return ptr_->visual_quality;
|
|
}
|
|
void set_visual_quality(uint64_t value) {
|
|
ptr_->visual_quality = value;
|
|
}
|
|
uint64_t visual_headlight() const {
|
|
return ptr_->visual_headlight;
|
|
}
|
|
void set_visual_headlight(uint64_t value) {
|
|
ptr_->visual_headlight = value;
|
|
}
|
|
uint64_t visual_map() const {
|
|
return ptr_->visual_map;
|
|
}
|
|
void set_visual_map(uint64_t value) {
|
|
ptr_->visual_map = value;
|
|
}
|
|
uint64_t visual_scale() const {
|
|
return ptr_->visual_scale;
|
|
}
|
|
void set_visual_scale(uint64_t value) {
|
|
ptr_->visual_scale = value;
|
|
}
|
|
uint64_t visual_rgba() const {
|
|
return ptr_->visual_rgba;
|
|
}
|
|
void set_visual_rgba(uint64_t value) {
|
|
ptr_->visual_rgba = value;
|
|
}
|
|
|
|
private:
|
|
mjsAuthored* ptr_;
|
|
};
|
|
|
|
struct MjsElement {
|
|
explicit MjsElement(mjsElement *ptr);
|
|
mjsElement* get() const;
|
|
void set(mjsElement* ptr);
|
|
mjtObj elemtype() const {
|
|
return ptr_->elemtype;
|
|
}
|
|
void set_elemtype(mjtObj value) {
|
|
ptr_->elemtype = value;
|
|
}
|
|
uint64_t signature() const {
|
|
return ptr_->signature;
|
|
}
|
|
void set_signature(uint64_t value) {
|
|
ptr_->signature = value;
|
|
}
|
|
|
|
private:
|
|
mjsElement* ptr_;
|
|
};
|
|
|
|
struct MjsOrientation {
|
|
explicit MjsOrientation(mjsOrientation *ptr);
|
|
mjsOrientation* get() const;
|
|
void set(mjsOrientation* ptr);
|
|
mjtOrientation type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(mjtOrientation value) {
|
|
ptr_->type = value;
|
|
}
|
|
emscripten::val axisangle() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->axisangle));
|
|
}
|
|
emscripten::val xyaxes() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->xyaxes));
|
|
}
|
|
emscripten::val zaxis() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->zaxis));
|
|
}
|
|
emscripten::val euler() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->euler));
|
|
}
|
|
|
|
private:
|
|
mjsOrientation* ptr_;
|
|
};
|
|
|
|
struct MjvCamera {
|
|
~MjvCamera();
|
|
MjvCamera();
|
|
explicit MjvCamera(mjvCamera *ptr);
|
|
MjvCamera(const MjvCamera &);
|
|
MjvCamera &operator=(const MjvCamera &);
|
|
std::unique_ptr<MjvCamera> copy();
|
|
mjvCamera* get() const;
|
|
void set(mjvCamera* ptr);
|
|
int type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(int value) {
|
|
ptr_->type = value;
|
|
}
|
|
int fixedcamid() const {
|
|
return ptr_->fixedcamid;
|
|
}
|
|
void set_fixedcamid(int value) {
|
|
ptr_->fixedcamid = value;
|
|
}
|
|
int trackbodyid() const {
|
|
return ptr_->trackbodyid;
|
|
}
|
|
void set_trackbodyid(int value) {
|
|
ptr_->trackbodyid = value;
|
|
}
|
|
emscripten::val lookat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->lookat));
|
|
}
|
|
mjtNum distance() const {
|
|
return ptr_->distance;
|
|
}
|
|
void set_distance(mjtNum value) {
|
|
ptr_->distance = value;
|
|
}
|
|
mjtNum azimuth() const {
|
|
return ptr_->azimuth;
|
|
}
|
|
void set_azimuth(mjtNum value) {
|
|
ptr_->azimuth = value;
|
|
}
|
|
mjtNum elevation() const {
|
|
return ptr_->elevation;
|
|
}
|
|
void set_elevation(mjtNum value) {
|
|
ptr_->elevation = value;
|
|
}
|
|
int orthographic() const {
|
|
return ptr_->orthographic;
|
|
}
|
|
void set_orthographic(int value) {
|
|
ptr_->orthographic = value;
|
|
}
|
|
|
|
private:
|
|
mjvCamera* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjvFigure {
|
|
~MjvFigure();
|
|
MjvFigure();
|
|
explicit MjvFigure(mjvFigure *ptr);
|
|
MjvFigure(const MjvFigure &);
|
|
MjvFigure &operator=(const MjvFigure &);
|
|
std::unique_ptr<MjvFigure> copy();
|
|
mjvFigure* get() const;
|
|
void set(mjvFigure* ptr);
|
|
int flg_legend() const {
|
|
return ptr_->flg_legend;
|
|
}
|
|
void set_flg_legend(int value) {
|
|
ptr_->flg_legend = value;
|
|
}
|
|
emscripten::val flg_ticklabel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->flg_ticklabel));
|
|
}
|
|
int flg_extend() const {
|
|
return ptr_->flg_extend;
|
|
}
|
|
void set_flg_extend(int value) {
|
|
ptr_->flg_extend = value;
|
|
}
|
|
int flg_barplot() const {
|
|
return ptr_->flg_barplot;
|
|
}
|
|
void set_flg_barplot(int value) {
|
|
ptr_->flg_barplot = value;
|
|
}
|
|
int flg_selection() const {
|
|
return ptr_->flg_selection;
|
|
}
|
|
void set_flg_selection(int value) {
|
|
ptr_->flg_selection = value;
|
|
}
|
|
int flg_symmetric() const {
|
|
return ptr_->flg_symmetric;
|
|
}
|
|
void set_flg_symmetric(int value) {
|
|
ptr_->flg_symmetric = value;
|
|
}
|
|
float linewidth() const {
|
|
return ptr_->linewidth;
|
|
}
|
|
void set_linewidth(float value) {
|
|
ptr_->linewidth = value;
|
|
}
|
|
float gridwidth() const {
|
|
return ptr_->gridwidth;
|
|
}
|
|
void set_gridwidth(float value) {
|
|
ptr_->gridwidth = value;
|
|
}
|
|
emscripten::val gridsize() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->gridsize));
|
|
}
|
|
emscripten::val gridrgb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->gridrgb));
|
|
}
|
|
emscripten::val figurergba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->figurergba));
|
|
}
|
|
emscripten::val panergba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->panergba));
|
|
}
|
|
emscripten::val legendrgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->legendrgba));
|
|
}
|
|
emscripten::val textrgb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->textrgb));
|
|
}
|
|
emscripten::val linergb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(300, reinterpret_cast<float*>(ptr_->linergb)));
|
|
}
|
|
emscripten::val range() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, reinterpret_cast<float*>(ptr_->range)));
|
|
}
|
|
emscripten::val xformat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(20, ptr_->xformat));
|
|
}
|
|
emscripten::val yformat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(20, ptr_->yformat));
|
|
}
|
|
emscripten::val minwidth() const {
|
|
return emscripten::val(emscripten::typed_memory_view(20, ptr_->minwidth));
|
|
}
|
|
emscripten::val title() const {
|
|
return emscripten::val(emscripten::typed_memory_view(1000, ptr_->title));
|
|
}
|
|
emscripten::val xlabel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(100, ptr_->xlabel));
|
|
}
|
|
emscripten::val linename() const {
|
|
return emscripten::val(emscripten::typed_memory_view(10000, reinterpret_cast<char*>(ptr_->linename)));
|
|
}
|
|
int legendoffset() const {
|
|
return ptr_->legendoffset;
|
|
}
|
|
void set_legendoffset(int value) {
|
|
ptr_->legendoffset = value;
|
|
}
|
|
int subplot() const {
|
|
return ptr_->subplot;
|
|
}
|
|
void set_subplot(int value) {
|
|
ptr_->subplot = value;
|
|
}
|
|
emscripten::val highlight() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->highlight));
|
|
}
|
|
int highlightid() const {
|
|
return ptr_->highlightid;
|
|
}
|
|
void set_highlightid(int value) {
|
|
ptr_->highlightid = value;
|
|
}
|
|
float selection() const {
|
|
return ptr_->selection;
|
|
}
|
|
void set_selection(float value) {
|
|
ptr_->selection = value;
|
|
}
|
|
emscripten::val linepnt() const {
|
|
return emscripten::val(emscripten::typed_memory_view(100, ptr_->linepnt));
|
|
}
|
|
emscripten::val linedata() const {
|
|
return emscripten::val(emscripten::typed_memory_view(200200, reinterpret_cast<float*>(ptr_->linedata)));
|
|
}
|
|
emscripten::val xaxispixel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->xaxispixel));
|
|
}
|
|
emscripten::val yaxispixel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->yaxispixel));
|
|
}
|
|
emscripten::val xaxisdata() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->xaxisdata));
|
|
}
|
|
emscripten::val yaxisdata() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->yaxisdata));
|
|
}
|
|
|
|
private:
|
|
mjvFigure* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjvGLCamera {
|
|
~MjvGLCamera();
|
|
MjvGLCamera();
|
|
explicit MjvGLCamera(mjvGLCamera *ptr);
|
|
MjvGLCamera(const MjvGLCamera &);
|
|
MjvGLCamera &operator=(const MjvGLCamera &);
|
|
std::unique_ptr<MjvGLCamera> copy();
|
|
mjvGLCamera* get() const;
|
|
void set(mjvGLCamera* ptr);
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val forward() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->forward));
|
|
}
|
|
emscripten::val up() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->up));
|
|
}
|
|
float frustum_center() const {
|
|
return ptr_->frustum_center;
|
|
}
|
|
void set_frustum_center(float value) {
|
|
ptr_->frustum_center = value;
|
|
}
|
|
float frustum_width() const {
|
|
return ptr_->frustum_width;
|
|
}
|
|
void set_frustum_width(float value) {
|
|
ptr_->frustum_width = value;
|
|
}
|
|
float frustum_bottom() const {
|
|
return ptr_->frustum_bottom;
|
|
}
|
|
void set_frustum_bottom(float value) {
|
|
ptr_->frustum_bottom = value;
|
|
}
|
|
float frustum_top() const {
|
|
return ptr_->frustum_top;
|
|
}
|
|
void set_frustum_top(float value) {
|
|
ptr_->frustum_top = value;
|
|
}
|
|
float frustum_near() const {
|
|
return ptr_->frustum_near;
|
|
}
|
|
void set_frustum_near(float value) {
|
|
ptr_->frustum_near = value;
|
|
}
|
|
float frustum_far() const {
|
|
return ptr_->frustum_far;
|
|
}
|
|
void set_frustum_far(float value) {
|
|
ptr_->frustum_far = value;
|
|
}
|
|
int orthographic() const {
|
|
return ptr_->orthographic;
|
|
}
|
|
void set_orthographic(int value) {
|
|
ptr_->orthographic = value;
|
|
}
|
|
|
|
private:
|
|
mjvGLCamera* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjvGeom {
|
|
~MjvGeom();
|
|
MjvGeom();
|
|
explicit MjvGeom(mjvGeom *ptr);
|
|
MjvGeom(const MjvGeom &);
|
|
MjvGeom &operator=(const MjvGeom &);
|
|
std::unique_ptr<MjvGeom> copy();
|
|
mjvGeom* get() const;
|
|
void set(mjvGeom* ptr);
|
|
int type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(int value) {
|
|
ptr_->type = value;
|
|
}
|
|
int dataid() const {
|
|
return ptr_->dataid;
|
|
}
|
|
void set_dataid(int value) {
|
|
ptr_->dataid = value;
|
|
}
|
|
int objtype() const {
|
|
return ptr_->objtype;
|
|
}
|
|
void set_objtype(int value) {
|
|
ptr_->objtype = value;
|
|
}
|
|
int objid() const {
|
|
return ptr_->objid;
|
|
}
|
|
void set_objid(int value) {
|
|
ptr_->objid = value;
|
|
}
|
|
int category() const {
|
|
return ptr_->category;
|
|
}
|
|
void set_category(int value) {
|
|
ptr_->category = value;
|
|
}
|
|
int matid() const {
|
|
return ptr_->matid;
|
|
}
|
|
void set_matid(int value) {
|
|
ptr_->matid = value;
|
|
}
|
|
int texcoord() const {
|
|
return ptr_->texcoord;
|
|
}
|
|
void set_texcoord(int value) {
|
|
ptr_->texcoord = value;
|
|
}
|
|
int segid() const {
|
|
return ptr_->segid;
|
|
}
|
|
void set_segid(int value) {
|
|
ptr_->segid = value;
|
|
}
|
|
emscripten::val size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->size));
|
|
}
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val mat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(9, ptr_->mat));
|
|
}
|
|
emscripten::val rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
|
|
}
|
|
float emission() const {
|
|
return ptr_->emission;
|
|
}
|
|
void set_emission(float value) {
|
|
ptr_->emission = value;
|
|
}
|
|
float specular() const {
|
|
return ptr_->specular;
|
|
}
|
|
void set_specular(float value) {
|
|
ptr_->specular = value;
|
|
}
|
|
float shininess() const {
|
|
return ptr_->shininess;
|
|
}
|
|
void set_shininess(float value) {
|
|
ptr_->shininess = value;
|
|
}
|
|
float reflectance() const {
|
|
return ptr_->reflectance;
|
|
}
|
|
void set_reflectance(float value) {
|
|
ptr_->reflectance = value;
|
|
}
|
|
emscripten::val label() const {
|
|
return emscripten::val(emscripten::typed_memory_view(100, ptr_->label));
|
|
}
|
|
float camdist() const {
|
|
return ptr_->camdist;
|
|
}
|
|
void set_camdist(float value) {
|
|
ptr_->camdist = value;
|
|
}
|
|
float modelrbound() const {
|
|
return ptr_->modelrbound;
|
|
}
|
|
void set_modelrbound(float value) {
|
|
ptr_->modelrbound = value;
|
|
}
|
|
mjtByte transparent() const {
|
|
return ptr_->transparent;
|
|
}
|
|
void set_transparent(mjtByte value) {
|
|
ptr_->transparent = value;
|
|
}
|
|
|
|
private:
|
|
mjvGeom* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjvLight {
|
|
~MjvLight();
|
|
MjvLight();
|
|
explicit MjvLight(mjvLight *ptr);
|
|
MjvLight(const MjvLight &);
|
|
MjvLight &operator=(const MjvLight &);
|
|
std::unique_ptr<MjvLight> copy();
|
|
mjvLight* get() const;
|
|
void set(mjvLight* ptr);
|
|
int id() const {
|
|
return ptr_->id;
|
|
}
|
|
void set_id(int value) {
|
|
ptr_->id = value;
|
|
}
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val dir() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->dir));
|
|
}
|
|
int type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(int value) {
|
|
ptr_->type = value;
|
|
}
|
|
int texid() const {
|
|
return ptr_->texid;
|
|
}
|
|
void set_texid(int value) {
|
|
ptr_->texid = value;
|
|
}
|
|
emscripten::val attenuation() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->attenuation));
|
|
}
|
|
float cutoff() const {
|
|
return ptr_->cutoff;
|
|
}
|
|
void set_cutoff(float value) {
|
|
ptr_->cutoff = value;
|
|
}
|
|
float exponent() const {
|
|
return ptr_->exponent;
|
|
}
|
|
void set_exponent(float value) {
|
|
ptr_->exponent = value;
|
|
}
|
|
emscripten::val ambient() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->ambient));
|
|
}
|
|
emscripten::val diffuse() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->diffuse));
|
|
}
|
|
emscripten::val specular() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->specular));
|
|
}
|
|
mjtByte headlight() const {
|
|
return ptr_->headlight;
|
|
}
|
|
void set_headlight(mjtByte value) {
|
|
ptr_->headlight = value;
|
|
}
|
|
mjtByte castshadow() const {
|
|
return ptr_->castshadow;
|
|
}
|
|
void set_castshadow(mjtByte value) {
|
|
ptr_->castshadow = value;
|
|
}
|
|
float bulbradius() const {
|
|
return ptr_->bulbradius;
|
|
}
|
|
void set_bulbradius(float value) {
|
|
ptr_->bulbradius = value;
|
|
}
|
|
float intensity() const {
|
|
return ptr_->intensity;
|
|
}
|
|
void set_intensity(float value) {
|
|
ptr_->intensity = value;
|
|
}
|
|
float range() const {
|
|
return ptr_->range;
|
|
}
|
|
void set_range(float value) {
|
|
ptr_->range = value;
|
|
}
|
|
|
|
private:
|
|
mjvLight* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjvOption {
|
|
~MjvOption();
|
|
MjvOption();
|
|
explicit MjvOption(mjvOption *ptr);
|
|
MjvOption(const MjvOption &);
|
|
MjvOption &operator=(const MjvOption &);
|
|
std::unique_ptr<MjvOption> copy();
|
|
mjvOption* get() const;
|
|
void set(mjvOption* ptr);
|
|
int label() const {
|
|
return ptr_->label;
|
|
}
|
|
void set_label(int value) {
|
|
ptr_->label = value;
|
|
}
|
|
int frame() const {
|
|
return ptr_->frame;
|
|
}
|
|
void set_frame(int value) {
|
|
ptr_->frame = value;
|
|
}
|
|
emscripten::val geomgroup() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->geomgroup));
|
|
}
|
|
emscripten::val sitegroup() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->sitegroup));
|
|
}
|
|
emscripten::val jointgroup() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->jointgroup));
|
|
}
|
|
emscripten::val tendongroup() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->tendongroup));
|
|
}
|
|
emscripten::val actuatorgroup() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->actuatorgroup));
|
|
}
|
|
emscripten::val flexgroup() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->flexgroup));
|
|
}
|
|
emscripten::val skingroup() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->skingroup));
|
|
}
|
|
emscripten::val flags() const {
|
|
return emscripten::val(emscripten::typed_memory_view(31, ptr_->flags));
|
|
}
|
|
int bvh_depth() const {
|
|
return ptr_->bvh_depth;
|
|
}
|
|
void set_bvh_depth(int value) {
|
|
ptr_->bvh_depth = value;
|
|
}
|
|
int flex_layer() const {
|
|
return ptr_->flex_layer;
|
|
}
|
|
void set_flex_layer(int value) {
|
|
ptr_->flex_layer = value;
|
|
}
|
|
|
|
private:
|
|
mjvOption* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjvPerturb {
|
|
~MjvPerturb();
|
|
MjvPerturb();
|
|
explicit MjvPerturb(mjvPerturb *ptr);
|
|
MjvPerturb(const MjvPerturb &);
|
|
MjvPerturb &operator=(const MjvPerturb &);
|
|
std::unique_ptr<MjvPerturb> copy();
|
|
mjvPerturb* get() const;
|
|
void set(mjvPerturb* ptr);
|
|
int select() const {
|
|
return ptr_->select;
|
|
}
|
|
void set_select(int value) {
|
|
ptr_->select = value;
|
|
}
|
|
int flexselect() const {
|
|
return ptr_->flexselect;
|
|
}
|
|
void set_flexselect(int value) {
|
|
ptr_->flexselect = value;
|
|
}
|
|
int skinselect() const {
|
|
return ptr_->skinselect;
|
|
}
|
|
void set_skinselect(int value) {
|
|
ptr_->skinselect = value;
|
|
}
|
|
int active() const {
|
|
return ptr_->active;
|
|
}
|
|
void set_active(int value) {
|
|
ptr_->active = value;
|
|
}
|
|
int active2() const {
|
|
return ptr_->active2;
|
|
}
|
|
void set_active2(int value) {
|
|
ptr_->active2 = value;
|
|
}
|
|
emscripten::val refpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->refpos));
|
|
}
|
|
emscripten::val refquat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->refquat));
|
|
}
|
|
emscripten::val refselpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->refselpos));
|
|
}
|
|
emscripten::val localpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->localpos));
|
|
}
|
|
mjtNum localmass() const {
|
|
return ptr_->localmass;
|
|
}
|
|
void set_localmass(mjtNum value) {
|
|
ptr_->localmass = value;
|
|
}
|
|
mjtNum scale() const {
|
|
return ptr_->scale;
|
|
}
|
|
void set_scale(mjtNum value) {
|
|
ptr_->scale = value;
|
|
}
|
|
|
|
private:
|
|
mjvPerturb* ptr_;
|
|
bool owned_ = false;
|
|
};
|
|
|
|
struct MjsCompiler {
|
|
explicit MjsCompiler(mjsCompiler *ptr);
|
|
mjsCompiler* get() const;
|
|
void set(mjsCompiler* ptr);
|
|
mjtBool autolimits() const {
|
|
return ptr_->autolimits;
|
|
}
|
|
void set_autolimits(mjtBool value) {
|
|
ptr_->autolimits = value;
|
|
}
|
|
double boundmass() const {
|
|
return ptr_->boundmass;
|
|
}
|
|
void set_boundmass(double value) {
|
|
ptr_->boundmass = value;
|
|
}
|
|
double boundinertia() const {
|
|
return ptr_->boundinertia;
|
|
}
|
|
void set_boundinertia(double value) {
|
|
ptr_->boundinertia = value;
|
|
}
|
|
double settotalmass() const {
|
|
return ptr_->settotalmass;
|
|
}
|
|
void set_settotalmass(double value) {
|
|
ptr_->settotalmass = value;
|
|
}
|
|
mjtBool balanceinertia() const {
|
|
return ptr_->balanceinertia;
|
|
}
|
|
void set_balanceinertia(mjtBool value) {
|
|
ptr_->balanceinertia = value;
|
|
}
|
|
mjtBool fitaabb() const {
|
|
return ptr_->fitaabb;
|
|
}
|
|
void set_fitaabb(mjtBool value) {
|
|
ptr_->fitaabb = value;
|
|
}
|
|
mjtBool degree() const {
|
|
return ptr_->degree;
|
|
}
|
|
void set_degree(mjtBool value) {
|
|
ptr_->degree = value;
|
|
}
|
|
emscripten::val eulerseq() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->eulerseq));
|
|
}
|
|
mjtBool discardvisual() const {
|
|
return ptr_->discardvisual;
|
|
}
|
|
void set_discardvisual(mjtBool value) {
|
|
ptr_->discardvisual = value;
|
|
}
|
|
mjtBool usethread() const {
|
|
return ptr_->usethread;
|
|
}
|
|
void set_usethread(mjtBool value) {
|
|
ptr_->usethread = value;
|
|
}
|
|
mjtBool fusestatic() const {
|
|
return ptr_->fusestatic;
|
|
}
|
|
void set_fusestatic(mjtBool value) {
|
|
ptr_->fusestatic = value;
|
|
}
|
|
mjtInertiaFromGeom inertiafromgeom() const {
|
|
return ptr_->inertiafromgeom;
|
|
}
|
|
void set_inertiafromgeom(mjtInertiaFromGeom value) {
|
|
ptr_->inertiafromgeom = value;
|
|
}
|
|
emscripten::val inertiagrouprange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->inertiagrouprange));
|
|
}
|
|
mjtBool saveinertial() const {
|
|
return ptr_->saveinertial;
|
|
}
|
|
void set_saveinertial(mjtBool value) {
|
|
ptr_->saveinertial = value;
|
|
}
|
|
mjtBool alignfree() const {
|
|
return ptr_->alignfree;
|
|
}
|
|
void set_alignfree(mjtBool value) {
|
|
ptr_->alignfree = value;
|
|
}
|
|
mjtConflict conflict() const {
|
|
return ptr_->conflict;
|
|
}
|
|
void set_conflict(mjtConflict value) {
|
|
ptr_->conflict = value;
|
|
}
|
|
mjString meshdir() const {
|
|
return (ptr_ && ptr_->meshdir) ? *(ptr_->meshdir) : "";
|
|
}
|
|
void set_meshdir(const mjString& value) {
|
|
if (ptr_ && ptr_->meshdir) {
|
|
*(ptr_->meshdir) = value;
|
|
}
|
|
}
|
|
mjString texturedir() const {
|
|
return (ptr_ && ptr_->texturedir) ? *(ptr_->texturedir) : "";
|
|
}
|
|
void set_texturedir(const mjString& value) {
|
|
if (ptr_ && ptr_->texturedir) {
|
|
*(ptr_->texturedir) = value;
|
|
}
|
|
}
|
|
uint64_t authored() const {
|
|
return ptr_->authored;
|
|
}
|
|
void set_authored(uint64_t value) {
|
|
ptr_->authored = value;
|
|
}
|
|
|
|
private:
|
|
mjsCompiler* ptr_;
|
|
|
|
public:
|
|
MjLROpt LRopt;
|
|
};
|
|
|
|
struct MjVisual {
|
|
~MjVisual();
|
|
MjVisual();
|
|
explicit MjVisual(mjVisual *ptr);
|
|
MjVisual(const MjVisual &);
|
|
MjVisual &operator=(const MjVisual &);
|
|
std::unique_ptr<MjVisual> copy();
|
|
mjVisual* get() const;
|
|
void set(mjVisual* ptr);
|
|
|
|
private:
|
|
mjVisual* ptr_;
|
|
bool owned_ = false;
|
|
|
|
public:
|
|
MjVisualGlobal global;
|
|
MjVisualQuality quality;
|
|
MjVisualHeadlight headlight;
|
|
MjVisualMap map;
|
|
MjVisualScale scale;
|
|
MjVisualRgba rgba;
|
|
};
|
|
|
|
struct MjsEquality {
|
|
explicit MjsEquality(mjsEquality *ptr);
|
|
mjsEquality* get() const;
|
|
void set(mjsEquality* ptr);
|
|
mjtEq type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(mjtEq value) {
|
|
ptr_->type = value;
|
|
}
|
|
emscripten::val data() const {
|
|
return emscripten::val(emscripten::typed_memory_view(11, ptr_->data));
|
|
}
|
|
mjtBool active() const {
|
|
return ptr_->active;
|
|
}
|
|
void set_active(mjtBool value) {
|
|
ptr_->active = value;
|
|
}
|
|
mjString name1() const {
|
|
return (ptr_ && ptr_->name1) ? *(ptr_->name1) : "";
|
|
}
|
|
void set_name1(const mjString& value) {
|
|
if (ptr_ && ptr_->name1) {
|
|
*(ptr_->name1) = value;
|
|
}
|
|
}
|
|
mjString name2() const {
|
|
return (ptr_ && ptr_->name2) ? *(ptr_->name2) : "";
|
|
}
|
|
void set_name2(const mjString& value) {
|
|
if (ptr_ && ptr_->name2) {
|
|
*(ptr_->name2) = value;
|
|
}
|
|
}
|
|
mjtObj objtype() const {
|
|
return ptr_->objtype;
|
|
}
|
|
void set_objtype(mjtObj value) {
|
|
ptr_->objtype = value;
|
|
}
|
|
emscripten::val solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
|
|
}
|
|
emscripten::val solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsEquality* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsExclude {
|
|
explicit MjsExclude(mjsExclude *ptr);
|
|
mjsExclude* get() const;
|
|
void set(mjsExclude* ptr);
|
|
mjString bodyname1() const {
|
|
return (ptr_ && ptr_->bodyname1) ? *(ptr_->bodyname1) : "";
|
|
}
|
|
void set_bodyname1(const mjString& value) {
|
|
if (ptr_ && ptr_->bodyname1) {
|
|
*(ptr_->bodyname1) = value;
|
|
}
|
|
}
|
|
mjString bodyname2() const {
|
|
return (ptr_ && ptr_->bodyname2) ? *(ptr_->bodyname2) : "";
|
|
}
|
|
void set_bodyname2(const mjString& value) {
|
|
if (ptr_ && ptr_->bodyname2) {
|
|
*(ptr_->bodyname2) = value;
|
|
}
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsExclude* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsFlex {
|
|
explicit MjsFlex(mjsFlex *ptr);
|
|
mjsFlex* get() const;
|
|
void set(mjsFlex* ptr);
|
|
int contype() const {
|
|
return ptr_->contype;
|
|
}
|
|
void set_contype(int value) {
|
|
ptr_->contype = value;
|
|
}
|
|
int conaffinity() const {
|
|
return ptr_->conaffinity;
|
|
}
|
|
void set_conaffinity(int value) {
|
|
ptr_->conaffinity = value;
|
|
}
|
|
int condim() const {
|
|
return ptr_->condim;
|
|
}
|
|
void set_condim(int value) {
|
|
ptr_->condim = value;
|
|
}
|
|
int priority() const {
|
|
return ptr_->priority;
|
|
}
|
|
void set_priority(int value) {
|
|
ptr_->priority = value;
|
|
}
|
|
emscripten::val friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->friction));
|
|
}
|
|
double solmix() const {
|
|
return ptr_->solmix;
|
|
}
|
|
void set_solmix(double value) {
|
|
ptr_->solmix = value;
|
|
}
|
|
emscripten::val solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
|
|
}
|
|
emscripten::val solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
|
|
}
|
|
double margin() const {
|
|
return ptr_->margin;
|
|
}
|
|
void set_margin(double value) {
|
|
ptr_->margin = value;
|
|
}
|
|
double gap() const {
|
|
return ptr_->gap;
|
|
}
|
|
void set_gap(double value) {
|
|
ptr_->gap = value;
|
|
}
|
|
int dim() const {
|
|
return ptr_->dim;
|
|
}
|
|
void set_dim(int value) {
|
|
ptr_->dim = value;
|
|
}
|
|
double radius() const {
|
|
return ptr_->radius;
|
|
}
|
|
void set_radius(double value) {
|
|
ptr_->radius = value;
|
|
}
|
|
emscripten::val size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->size));
|
|
}
|
|
mjtBool internal() const {
|
|
return ptr_->internal;
|
|
}
|
|
void set_internal(mjtBool value) {
|
|
ptr_->internal = value;
|
|
}
|
|
mjtBool flatskin() const {
|
|
return ptr_->flatskin;
|
|
}
|
|
void set_flatskin(mjtBool value) {
|
|
ptr_->flatskin = value;
|
|
}
|
|
mjtFlexSelf selfcollide() const {
|
|
return ptr_->selfcollide;
|
|
}
|
|
void set_selfcollide(mjtFlexSelf value) {
|
|
ptr_->selfcollide = value;
|
|
}
|
|
int passive() const {
|
|
return ptr_->passive;
|
|
}
|
|
void set_passive(int value) {
|
|
ptr_->passive = value;
|
|
}
|
|
int activelayers() const {
|
|
return ptr_->activelayers;
|
|
}
|
|
void set_activelayers(int value) {
|
|
ptr_->activelayers = value;
|
|
}
|
|
int group() const {
|
|
return ptr_->group;
|
|
}
|
|
void set_group(int value) {
|
|
ptr_->group = value;
|
|
}
|
|
double edgestiffness() const {
|
|
return ptr_->edgestiffness;
|
|
}
|
|
void set_edgestiffness(double value) {
|
|
ptr_->edgestiffness = value;
|
|
}
|
|
double edgedamping() const {
|
|
return ptr_->edgedamping;
|
|
}
|
|
void set_edgedamping(double value) {
|
|
ptr_->edgedamping = value;
|
|
}
|
|
emscripten::val rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
|
|
}
|
|
mjString material() const {
|
|
return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
|
|
}
|
|
void set_material(const mjString& value) {
|
|
if (ptr_ && ptr_->material) {
|
|
*(ptr_->material) = value;
|
|
}
|
|
}
|
|
double young() const {
|
|
return ptr_->young;
|
|
}
|
|
void set_young(double value) {
|
|
ptr_->young = value;
|
|
}
|
|
double poisson() const {
|
|
return ptr_->poisson;
|
|
}
|
|
void set_poisson(double value) {
|
|
ptr_->poisson = value;
|
|
}
|
|
double damping() const {
|
|
return ptr_->damping;
|
|
}
|
|
void set_damping(double value) {
|
|
ptr_->damping = value;
|
|
}
|
|
double thickness() const {
|
|
return ptr_->thickness;
|
|
}
|
|
void set_thickness(double value) {
|
|
ptr_->thickness = value;
|
|
}
|
|
int elastic2d() const {
|
|
return ptr_->elastic2d;
|
|
}
|
|
void set_elastic2d(int value) {
|
|
ptr_->elastic2d = value;
|
|
}
|
|
emscripten::val cellcount() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->cellcount));
|
|
}
|
|
int order() const {
|
|
return ptr_->order;
|
|
}
|
|
void set_order(int value) {
|
|
ptr_->order = value;
|
|
}
|
|
mjStringVec &nodebody() const {
|
|
return *(ptr_->nodebody);
|
|
}
|
|
mjStringVec &vertbody() const {
|
|
return *(ptr_->vertbody);
|
|
}
|
|
mjDoubleVec &node() const {
|
|
return *(ptr_->node);
|
|
}
|
|
mjDoubleVec &vert() const {
|
|
return *(ptr_->vert);
|
|
}
|
|
mjIntVec &elem() const {
|
|
return *(ptr_->elem);
|
|
}
|
|
mjFloatVec &texcoord() const {
|
|
return *(ptr_->texcoord);
|
|
}
|
|
mjIntVec &elemtexcoord() const {
|
|
return *(ptr_->elemtexcoord);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsFlex* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsHField {
|
|
explicit MjsHField(mjsHField *ptr);
|
|
mjsHField* get() const;
|
|
void set(mjsHField* ptr);
|
|
mjString content_type() const {
|
|
return (ptr_ && ptr_->content_type) ? *(ptr_->content_type) : "";
|
|
}
|
|
void set_content_type(const mjString& value) {
|
|
if (ptr_ && ptr_->content_type) {
|
|
*(ptr_->content_type) = value;
|
|
}
|
|
}
|
|
mjString file() const {
|
|
return (ptr_ && ptr_->file) ? *(ptr_->file) : "";
|
|
}
|
|
void set_file(const mjString& value) {
|
|
if (ptr_ && ptr_->file) {
|
|
*(ptr_->file) = value;
|
|
}
|
|
}
|
|
emscripten::val size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->size));
|
|
}
|
|
int nrow() const {
|
|
return ptr_->nrow;
|
|
}
|
|
void set_nrow(int value) {
|
|
ptr_->nrow = value;
|
|
}
|
|
int ncol() const {
|
|
return ptr_->ncol;
|
|
}
|
|
void set_ncol(int value) {
|
|
ptr_->ncol = value;
|
|
}
|
|
mjFloatVec &userdata() const {
|
|
return *(ptr_->userdata);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsHField* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsJoint {
|
|
explicit MjsJoint(mjsJoint *ptr);
|
|
mjsJoint* get() const;
|
|
void set(mjsJoint* ptr);
|
|
mjtJoint type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(mjtJoint value) {
|
|
ptr_->type = value;
|
|
}
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val axis() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->axis));
|
|
}
|
|
double ref() const {
|
|
return ptr_->ref;
|
|
}
|
|
void set_ref(double value) {
|
|
ptr_->ref = value;
|
|
}
|
|
mjtAlignFree align() const {
|
|
return ptr_->align;
|
|
}
|
|
void set_align(mjtAlignFree value) {
|
|
ptr_->align = value;
|
|
}
|
|
emscripten::val stiffness() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->stiffness));
|
|
}
|
|
double springref() const {
|
|
return ptr_->springref;
|
|
}
|
|
void set_springref(double value) {
|
|
ptr_->springref = value;
|
|
}
|
|
emscripten::val springdamper() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->springdamper));
|
|
}
|
|
mjtLimited limited() const {
|
|
return ptr_->limited;
|
|
}
|
|
void set_limited(mjtLimited value) {
|
|
ptr_->limited = value;
|
|
}
|
|
emscripten::val range() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->range));
|
|
}
|
|
double margin() const {
|
|
return ptr_->margin;
|
|
}
|
|
void set_margin(double value) {
|
|
ptr_->margin = value;
|
|
}
|
|
emscripten::val solref_limit() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref_limit));
|
|
}
|
|
emscripten::val solimp_limit() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp_limit));
|
|
}
|
|
mjtLimited actfrclimited() const {
|
|
return ptr_->actfrclimited;
|
|
}
|
|
void set_actfrclimited(mjtLimited value) {
|
|
ptr_->actfrclimited = value;
|
|
}
|
|
emscripten::val actfrcrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->actfrcrange));
|
|
}
|
|
double armature() const {
|
|
return ptr_->armature;
|
|
}
|
|
void set_armature(double value) {
|
|
ptr_->armature = value;
|
|
}
|
|
emscripten::val damping() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->damping));
|
|
}
|
|
double frictionloss() const {
|
|
return ptr_->frictionloss;
|
|
}
|
|
void set_frictionloss(double value) {
|
|
ptr_->frictionloss = value;
|
|
}
|
|
emscripten::val solref_friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref_friction));
|
|
}
|
|
emscripten::val solimp_friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp_friction));
|
|
}
|
|
int group() const {
|
|
return ptr_->group;
|
|
}
|
|
void set_group(int value) {
|
|
ptr_->group = value;
|
|
}
|
|
mjtBool actgravcomp() const {
|
|
return ptr_->actgravcomp;
|
|
}
|
|
void set_actgravcomp(mjtBool value) {
|
|
ptr_->actgravcomp = value;
|
|
}
|
|
mjDoubleVec &userdata() const {
|
|
return *(ptr_->userdata);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsJoint* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsKey {
|
|
explicit MjsKey(mjsKey *ptr);
|
|
mjsKey* get() const;
|
|
void set(mjsKey* ptr);
|
|
double time() const {
|
|
return ptr_->time;
|
|
}
|
|
void set_time(double value) {
|
|
ptr_->time = value;
|
|
}
|
|
mjDoubleVec &qpos() const {
|
|
return *(ptr_->qpos);
|
|
}
|
|
mjDoubleVec &qvel() const {
|
|
return *(ptr_->qvel);
|
|
}
|
|
mjDoubleVec &act() const {
|
|
return *(ptr_->act);
|
|
}
|
|
mjDoubleVec &mpos() const {
|
|
return *(ptr_->mpos);
|
|
}
|
|
mjDoubleVec &mquat() const {
|
|
return *(ptr_->mquat);
|
|
}
|
|
mjDoubleVec &ctrl() const {
|
|
return *(ptr_->ctrl);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsKey* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsLight {
|
|
explicit MjsLight(mjsLight *ptr);
|
|
mjsLight* get() const;
|
|
void set(mjsLight* ptr);
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val dir() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->dir));
|
|
}
|
|
mjtCamLight mode() const {
|
|
return ptr_->mode;
|
|
}
|
|
void set_mode(mjtCamLight value) {
|
|
ptr_->mode = value;
|
|
}
|
|
mjString targetbody() const {
|
|
return (ptr_ && ptr_->targetbody) ? *(ptr_->targetbody) : "";
|
|
}
|
|
void set_targetbody(const mjString& value) {
|
|
if (ptr_ && ptr_->targetbody) {
|
|
*(ptr_->targetbody) = value;
|
|
}
|
|
}
|
|
mjtBool active() const {
|
|
return ptr_->active;
|
|
}
|
|
void set_active(mjtBool value) {
|
|
ptr_->active = value;
|
|
}
|
|
mjtLightType type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(mjtLightType value) {
|
|
ptr_->type = value;
|
|
}
|
|
mjString texture() const {
|
|
return (ptr_ && ptr_->texture) ? *(ptr_->texture) : "";
|
|
}
|
|
void set_texture(const mjString& value) {
|
|
if (ptr_ && ptr_->texture) {
|
|
*(ptr_->texture) = value;
|
|
}
|
|
}
|
|
mjtBool castshadow() const {
|
|
return ptr_->castshadow;
|
|
}
|
|
void set_castshadow(mjtBool value) {
|
|
ptr_->castshadow = value;
|
|
}
|
|
float bulbradius() const {
|
|
return ptr_->bulbradius;
|
|
}
|
|
void set_bulbradius(float value) {
|
|
ptr_->bulbradius = value;
|
|
}
|
|
float intensity() const {
|
|
return ptr_->intensity;
|
|
}
|
|
void set_intensity(float value) {
|
|
ptr_->intensity = value;
|
|
}
|
|
float range() const {
|
|
return ptr_->range;
|
|
}
|
|
void set_range(float value) {
|
|
ptr_->range = value;
|
|
}
|
|
emscripten::val attenuation() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->attenuation));
|
|
}
|
|
float cutoff() const {
|
|
return ptr_->cutoff;
|
|
}
|
|
void set_cutoff(float value) {
|
|
ptr_->cutoff = value;
|
|
}
|
|
float exponent() const {
|
|
return ptr_->exponent;
|
|
}
|
|
void set_exponent(float value) {
|
|
ptr_->exponent = value;
|
|
}
|
|
emscripten::val ambient() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->ambient));
|
|
}
|
|
emscripten::val diffuse() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->diffuse));
|
|
}
|
|
emscripten::val specular() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->specular));
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsLight* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsMaterial {
|
|
explicit MjsMaterial(mjsMaterial *ptr);
|
|
mjsMaterial* get() const;
|
|
void set(mjsMaterial* ptr);
|
|
mjStringVec &textures() const {
|
|
return *(ptr_->textures);
|
|
}
|
|
mjtBool texuniform() const {
|
|
return ptr_->texuniform;
|
|
}
|
|
void set_texuniform(mjtBool value) {
|
|
ptr_->texuniform = value;
|
|
}
|
|
emscripten::val texrepeat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->texrepeat));
|
|
}
|
|
float emission() const {
|
|
return ptr_->emission;
|
|
}
|
|
void set_emission(float value) {
|
|
ptr_->emission = value;
|
|
}
|
|
float specular() const {
|
|
return ptr_->specular;
|
|
}
|
|
void set_specular(float value) {
|
|
ptr_->specular = value;
|
|
}
|
|
float shininess() const {
|
|
return ptr_->shininess;
|
|
}
|
|
void set_shininess(float value) {
|
|
ptr_->shininess = value;
|
|
}
|
|
float reflectance() const {
|
|
return ptr_->reflectance;
|
|
}
|
|
void set_reflectance(float value) {
|
|
ptr_->reflectance = value;
|
|
}
|
|
float metallic() const {
|
|
return ptr_->metallic;
|
|
}
|
|
void set_metallic(float value) {
|
|
ptr_->metallic = value;
|
|
}
|
|
float roughness() const {
|
|
return ptr_->roughness;
|
|
}
|
|
void set_roughness(float value) {
|
|
ptr_->roughness = value;
|
|
}
|
|
emscripten::val rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsMaterial* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsNumeric {
|
|
explicit MjsNumeric(mjsNumeric *ptr);
|
|
mjsNumeric* get() const;
|
|
void set(mjsNumeric* ptr);
|
|
mjDoubleVec &data() const {
|
|
return *(ptr_->data);
|
|
}
|
|
int size() const {
|
|
return ptr_->size;
|
|
}
|
|
void set_size(int value) {
|
|
ptr_->size = value;
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsNumeric* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsPair {
|
|
explicit MjsPair(mjsPair *ptr);
|
|
mjsPair* get() const;
|
|
void set(mjsPair* ptr);
|
|
mjString geomname1() const {
|
|
return (ptr_ && ptr_->geomname1) ? *(ptr_->geomname1) : "";
|
|
}
|
|
void set_geomname1(const mjString& value) {
|
|
if (ptr_ && ptr_->geomname1) {
|
|
*(ptr_->geomname1) = value;
|
|
}
|
|
}
|
|
mjString geomname2() const {
|
|
return (ptr_ && ptr_->geomname2) ? *(ptr_->geomname2) : "";
|
|
}
|
|
void set_geomname2(const mjString& value) {
|
|
if (ptr_ && ptr_->geomname2) {
|
|
*(ptr_->geomname2) = value;
|
|
}
|
|
}
|
|
int condim() const {
|
|
return ptr_->condim;
|
|
}
|
|
void set_condim(int value) {
|
|
ptr_->condim = value;
|
|
}
|
|
emscripten::val solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
|
|
}
|
|
emscripten::val solreffriction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solreffriction));
|
|
}
|
|
emscripten::val solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
|
|
}
|
|
double margin() const {
|
|
return ptr_->margin;
|
|
}
|
|
void set_margin(double value) {
|
|
ptr_->margin = value;
|
|
}
|
|
double gap() const {
|
|
return ptr_->gap;
|
|
}
|
|
void set_gap(double value) {
|
|
ptr_->gap = value;
|
|
}
|
|
emscripten::val friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->friction));
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsPair* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsPlugin {
|
|
explicit MjsPlugin(mjsPlugin *ptr);
|
|
mjsPlugin* get() const;
|
|
void set(mjsPlugin* ptr);
|
|
mjString name() const {
|
|
return (ptr_ && ptr_->name) ? *(ptr_->name) : "";
|
|
}
|
|
void set_name(const mjString& value) {
|
|
if (ptr_ && ptr_->name) {
|
|
*(ptr_->name) = value;
|
|
}
|
|
}
|
|
mjString plugin_name() const {
|
|
return (ptr_ && ptr_->plugin_name) ? *(ptr_->plugin_name) : "";
|
|
}
|
|
void set_plugin_name(const mjString& value) {
|
|
if (ptr_ && ptr_->plugin_name) {
|
|
*(ptr_->plugin_name) = value;
|
|
}
|
|
}
|
|
mjtBool active() const {
|
|
return ptr_->active;
|
|
}
|
|
void set_active(mjtBool value) {
|
|
ptr_->active = value;
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsPlugin* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsSkin {
|
|
explicit MjsSkin(mjsSkin *ptr);
|
|
mjsSkin* get() const;
|
|
void set(mjsSkin* ptr);
|
|
mjString file() const {
|
|
return (ptr_ && ptr_->file) ? *(ptr_->file) : "";
|
|
}
|
|
void set_file(const mjString& value) {
|
|
if (ptr_ && ptr_->file) {
|
|
*(ptr_->file) = value;
|
|
}
|
|
}
|
|
mjString material() const {
|
|
return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
|
|
}
|
|
void set_material(const mjString& value) {
|
|
if (ptr_ && ptr_->material) {
|
|
*(ptr_->material) = value;
|
|
}
|
|
}
|
|
emscripten::val rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
|
|
}
|
|
float inflate() const {
|
|
return ptr_->inflate;
|
|
}
|
|
void set_inflate(float value) {
|
|
ptr_->inflate = value;
|
|
}
|
|
int group() const {
|
|
return ptr_->group;
|
|
}
|
|
void set_group(int value) {
|
|
ptr_->group = value;
|
|
}
|
|
mjFloatVec &vert() const {
|
|
return *(ptr_->vert);
|
|
}
|
|
mjFloatVec &texcoord() const {
|
|
return *(ptr_->texcoord);
|
|
}
|
|
mjIntVec &face() const {
|
|
return *(ptr_->face);
|
|
}
|
|
mjStringVec &bodyname() const {
|
|
return *(ptr_->bodyname);
|
|
}
|
|
mjFloatVec &bindpos() const {
|
|
return *(ptr_->bindpos);
|
|
}
|
|
mjFloatVec &bindquat() const {
|
|
return *(ptr_->bindquat);
|
|
}
|
|
mjIntVecVec &vertid() const {
|
|
return *(ptr_->vertid);
|
|
}
|
|
mjFloatVecVec &vertweight() const {
|
|
return *(ptr_->vertweight);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsSkin* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsTendon {
|
|
explicit MjsTendon(mjsTendon *ptr);
|
|
mjsTendon* get() const;
|
|
void set(mjsTendon* ptr);
|
|
emscripten::val stiffness() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->stiffness));
|
|
}
|
|
emscripten::val springlength() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->springlength));
|
|
}
|
|
emscripten::val damping() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->damping));
|
|
}
|
|
double frictionloss() const {
|
|
return ptr_->frictionloss;
|
|
}
|
|
void set_frictionloss(double value) {
|
|
ptr_->frictionloss = value;
|
|
}
|
|
emscripten::val solref_friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref_friction));
|
|
}
|
|
emscripten::val solimp_friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp_friction));
|
|
}
|
|
double armature() const {
|
|
return ptr_->armature;
|
|
}
|
|
void set_armature(double value) {
|
|
ptr_->armature = value;
|
|
}
|
|
mjtLimited limited() const {
|
|
return ptr_->limited;
|
|
}
|
|
void set_limited(mjtLimited value) {
|
|
ptr_->limited = value;
|
|
}
|
|
mjtLimited actfrclimited() const {
|
|
return ptr_->actfrclimited;
|
|
}
|
|
void set_actfrclimited(mjtLimited value) {
|
|
ptr_->actfrclimited = value;
|
|
}
|
|
emscripten::val range() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->range));
|
|
}
|
|
emscripten::val actfrcrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->actfrcrange));
|
|
}
|
|
double margin() const {
|
|
return ptr_->margin;
|
|
}
|
|
void set_margin(double value) {
|
|
ptr_->margin = value;
|
|
}
|
|
emscripten::val solref_limit() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref_limit));
|
|
}
|
|
emscripten::val solimp_limit() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp_limit));
|
|
}
|
|
mjString material() const {
|
|
return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
|
|
}
|
|
void set_material(const mjString& value) {
|
|
if (ptr_ && ptr_->material) {
|
|
*(ptr_->material) = value;
|
|
}
|
|
}
|
|
double width() const {
|
|
return ptr_->width;
|
|
}
|
|
void set_width(double value) {
|
|
ptr_->width = value;
|
|
}
|
|
emscripten::val rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
|
|
}
|
|
int group() const {
|
|
return ptr_->group;
|
|
}
|
|
void set_group(int value) {
|
|
ptr_->group = value;
|
|
}
|
|
mjDoubleVec &userdata() const {
|
|
return *(ptr_->userdata);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsTendon* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsText {
|
|
explicit MjsText(mjsText *ptr);
|
|
mjsText* get() const;
|
|
void set(mjsText* ptr);
|
|
mjString data() const {
|
|
return (ptr_ && ptr_->data) ? *(ptr_->data) : "";
|
|
}
|
|
void set_data(const mjString& value) {
|
|
if (ptr_ && ptr_->data) {
|
|
*(ptr_->data) = value;
|
|
}
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsText* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsTexture {
|
|
explicit MjsTexture(mjsTexture *ptr);
|
|
mjsTexture* get() const;
|
|
void set(mjsTexture* ptr);
|
|
mjtTexture type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(mjtTexture value) {
|
|
ptr_->type = value;
|
|
}
|
|
mjtColorSpace colorspace() const {
|
|
return ptr_->colorspace;
|
|
}
|
|
void set_colorspace(mjtColorSpace value) {
|
|
ptr_->colorspace = value;
|
|
}
|
|
mjtBuiltin builtin() const {
|
|
return ptr_->builtin;
|
|
}
|
|
void set_builtin(mjtBuiltin value) {
|
|
ptr_->builtin = value;
|
|
}
|
|
mjtMark mark() const {
|
|
return ptr_->mark;
|
|
}
|
|
void set_mark(mjtMark value) {
|
|
ptr_->mark = value;
|
|
}
|
|
emscripten::val rgb1() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->rgb1));
|
|
}
|
|
emscripten::val rgb2() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->rgb2));
|
|
}
|
|
emscripten::val markrgb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->markrgb));
|
|
}
|
|
double random() const {
|
|
return ptr_->random;
|
|
}
|
|
void set_random(double value) {
|
|
ptr_->random = value;
|
|
}
|
|
int height() const {
|
|
return ptr_->height;
|
|
}
|
|
void set_height(int value) {
|
|
ptr_->height = value;
|
|
}
|
|
int width() const {
|
|
return ptr_->width;
|
|
}
|
|
void set_width(int value) {
|
|
ptr_->width = value;
|
|
}
|
|
int nchannel() const {
|
|
return ptr_->nchannel;
|
|
}
|
|
void set_nchannel(int value) {
|
|
ptr_->nchannel = value;
|
|
}
|
|
mjString content_type() const {
|
|
return (ptr_ && ptr_->content_type) ? *(ptr_->content_type) : "";
|
|
}
|
|
void set_content_type(const mjString& value) {
|
|
if (ptr_ && ptr_->content_type) {
|
|
*(ptr_->content_type) = value;
|
|
}
|
|
}
|
|
mjString file() const {
|
|
return (ptr_ && ptr_->file) ? *(ptr_->file) : "";
|
|
}
|
|
void set_file(const mjString& value) {
|
|
if (ptr_ && ptr_->file) {
|
|
*(ptr_->file) = value;
|
|
}
|
|
}
|
|
emscripten::val gridsize() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->gridsize));
|
|
}
|
|
emscripten::val gridlayout() const {
|
|
return emscripten::val(emscripten::typed_memory_view(12, ptr_->gridlayout));
|
|
}
|
|
mjStringVec &cubefiles() const {
|
|
return *(ptr_->cubefiles);
|
|
}
|
|
std::vector<uint8_t> &data() const {
|
|
return *(reinterpret_cast<std::vector<uint8_t>*>(ptr_->data));
|
|
}
|
|
mjtBool hflip() const {
|
|
return ptr_->hflip;
|
|
}
|
|
void set_hflip(mjtBool value) {
|
|
ptr_->hflip = value;
|
|
}
|
|
mjtBool vflip() const {
|
|
return ptr_->vflip;
|
|
}
|
|
void set_vflip(mjtBool value) {
|
|
ptr_->vflip = value;
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsTexture* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsTuple {
|
|
explicit MjsTuple(mjsTuple *ptr);
|
|
mjsTuple* get() const;
|
|
void set(mjsTuple* ptr);
|
|
mjIntVec &objtype() const {
|
|
return *(ptr_->objtype);
|
|
}
|
|
mjStringVec &objname() const {
|
|
return *(ptr_->objname);
|
|
}
|
|
mjDoubleVec &objprm() const {
|
|
return *(ptr_->objprm);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsTuple* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsWrap {
|
|
explicit MjsWrap(mjsWrap *ptr);
|
|
mjsWrap* get() const;
|
|
void set(mjsWrap* ptr);
|
|
mjtWrap type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(mjtWrap value) {
|
|
ptr_->type = value;
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsWrap* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
};
|
|
|
|
struct MjsCamera {
|
|
explicit MjsCamera(mjsCamera *ptr);
|
|
mjsCamera* get() const;
|
|
void set(mjsCamera* ptr);
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
|
|
}
|
|
mjtCamLight mode() const {
|
|
return ptr_->mode;
|
|
}
|
|
void set_mode(mjtCamLight value) {
|
|
ptr_->mode = value;
|
|
}
|
|
mjString targetbody() const {
|
|
return (ptr_ && ptr_->targetbody) ? *(ptr_->targetbody) : "";
|
|
}
|
|
void set_targetbody(const mjString& value) {
|
|
if (ptr_ && ptr_->targetbody) {
|
|
*(ptr_->targetbody) = value;
|
|
}
|
|
}
|
|
mjtProjection proj() const {
|
|
return ptr_->proj;
|
|
}
|
|
void set_proj(mjtProjection value) {
|
|
ptr_->proj = value;
|
|
}
|
|
emscripten::val resolution() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->resolution));
|
|
}
|
|
int output() const {
|
|
return ptr_->output;
|
|
}
|
|
void set_output(int value) {
|
|
ptr_->output = value;
|
|
}
|
|
double fovy() const {
|
|
return ptr_->fovy;
|
|
}
|
|
void set_fovy(double value) {
|
|
ptr_->fovy = value;
|
|
}
|
|
double ipd() const {
|
|
return ptr_->ipd;
|
|
}
|
|
void set_ipd(double value) {
|
|
ptr_->ipd = value;
|
|
}
|
|
emscripten::val intrinsic() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->intrinsic));
|
|
}
|
|
emscripten::val sensor_size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->sensor_size));
|
|
}
|
|
emscripten::val focal_length() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->focal_length));
|
|
}
|
|
emscripten::val focal_pixel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->focal_pixel));
|
|
}
|
|
emscripten::val principal_length() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->principal_length));
|
|
}
|
|
emscripten::val principal_pixel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->principal_pixel));
|
|
}
|
|
mjDoubleVec &userdata() const {
|
|
return *(ptr_->userdata);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsCamera* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsOrientation alt;
|
|
};
|
|
|
|
struct MjsFrame {
|
|
explicit MjsFrame(mjsFrame *ptr);
|
|
mjsFrame* get() const;
|
|
void set(mjsFrame* ptr);
|
|
mjString childclass() const {
|
|
return (ptr_ && ptr_->childclass) ? *(ptr_->childclass) : "";
|
|
}
|
|
void set_childclass(const mjString& value) {
|
|
if (ptr_ && ptr_->childclass) {
|
|
*(ptr_->childclass) = value;
|
|
}
|
|
}
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsFrame* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsOrientation alt;
|
|
};
|
|
|
|
struct MjsSite {
|
|
explicit MjsSite(mjsSite *ptr);
|
|
mjsSite* get() const;
|
|
void set(mjsSite* ptr);
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
|
|
}
|
|
emscripten::val fromto() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->fromto));
|
|
}
|
|
emscripten::val size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->size));
|
|
}
|
|
mjtGeom type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(mjtGeom value) {
|
|
ptr_->type = value;
|
|
}
|
|
mjString material() const {
|
|
return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
|
|
}
|
|
void set_material(const mjString& value) {
|
|
if (ptr_ && ptr_->material) {
|
|
*(ptr_->material) = value;
|
|
}
|
|
}
|
|
int group() const {
|
|
return ptr_->group;
|
|
}
|
|
void set_group(int value) {
|
|
ptr_->group = value;
|
|
}
|
|
emscripten::val rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
|
|
}
|
|
mjDoubleVec &userdata() const {
|
|
return *(ptr_->userdata);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsSite* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsOrientation alt;
|
|
};
|
|
|
|
struct MjModel {
|
|
~MjModel();
|
|
explicit MjModel(mjModel *ptr);
|
|
MjModel(const MjModel &);
|
|
std::unique_ptr<MjModel> copy();
|
|
mjModel* get() const;
|
|
void set(mjModel* ptr);
|
|
int nq() const {
|
|
return static_cast<int>(ptr_->nq);
|
|
}
|
|
void set_nq(int value) {
|
|
ptr_->nq = static_cast<mjtSize>(value);
|
|
}
|
|
int nv() const {
|
|
return static_cast<int>(ptr_->nv);
|
|
}
|
|
void set_nv(int value) {
|
|
ptr_->nv = static_cast<mjtSize>(value);
|
|
}
|
|
int nu() const {
|
|
return static_cast<int>(ptr_->nu);
|
|
}
|
|
void set_nu(int value) {
|
|
ptr_->nu = static_cast<mjtSize>(value);
|
|
}
|
|
int nactuator() const {
|
|
return static_cast<int>(ptr_->nactuator);
|
|
}
|
|
void set_nactuator(int value) {
|
|
ptr_->nactuator = static_cast<mjtSize>(value);
|
|
}
|
|
int nout() const {
|
|
return static_cast<int>(ptr_->nout);
|
|
}
|
|
void set_nout(int value) {
|
|
ptr_->nout = static_cast<mjtSize>(value);
|
|
}
|
|
int na() const {
|
|
return static_cast<int>(ptr_->na);
|
|
}
|
|
void set_na(int value) {
|
|
ptr_->na = static_cast<mjtSize>(value);
|
|
}
|
|
int nbody() const {
|
|
return static_cast<int>(ptr_->nbody);
|
|
}
|
|
void set_nbody(int value) {
|
|
ptr_->nbody = static_cast<mjtSize>(value);
|
|
}
|
|
int nbvh() const {
|
|
return static_cast<int>(ptr_->nbvh);
|
|
}
|
|
void set_nbvh(int value) {
|
|
ptr_->nbvh = static_cast<mjtSize>(value);
|
|
}
|
|
int nbvhstatic() const {
|
|
return static_cast<int>(ptr_->nbvhstatic);
|
|
}
|
|
void set_nbvhstatic(int value) {
|
|
ptr_->nbvhstatic = static_cast<mjtSize>(value);
|
|
}
|
|
int nbvhdynamic() const {
|
|
return static_cast<int>(ptr_->nbvhdynamic);
|
|
}
|
|
void set_nbvhdynamic(int value) {
|
|
ptr_->nbvhdynamic = static_cast<mjtSize>(value);
|
|
}
|
|
int noct() const {
|
|
return static_cast<int>(ptr_->noct);
|
|
}
|
|
void set_noct(int value) {
|
|
ptr_->noct = static_cast<mjtSize>(value);
|
|
}
|
|
int njnt() const {
|
|
return static_cast<int>(ptr_->njnt);
|
|
}
|
|
void set_njnt(int value) {
|
|
ptr_->njnt = static_cast<mjtSize>(value);
|
|
}
|
|
int ntree() const {
|
|
return static_cast<int>(ptr_->ntree);
|
|
}
|
|
void set_ntree(int value) {
|
|
ptr_->ntree = static_cast<mjtSize>(value);
|
|
}
|
|
int nM() const {
|
|
return static_cast<int>(ptr_->nM);
|
|
}
|
|
void set_nM(int value) {
|
|
ptr_->nM = static_cast<mjtSize>(value);
|
|
}
|
|
int nB() const {
|
|
return static_cast<int>(ptr_->nB);
|
|
}
|
|
void set_nB(int value) {
|
|
ptr_->nB = static_cast<mjtSize>(value);
|
|
}
|
|
int nC() const {
|
|
return static_cast<int>(ptr_->nC);
|
|
}
|
|
void set_nC(int value) {
|
|
ptr_->nC = static_cast<mjtSize>(value);
|
|
}
|
|
int nD() const {
|
|
return static_cast<int>(ptr_->nD);
|
|
}
|
|
void set_nD(int value) {
|
|
ptr_->nD = static_cast<mjtSize>(value);
|
|
}
|
|
int ngeom() const {
|
|
return static_cast<int>(ptr_->ngeom);
|
|
}
|
|
void set_ngeom(int value) {
|
|
ptr_->ngeom = static_cast<mjtSize>(value);
|
|
}
|
|
int nsite() const {
|
|
return static_cast<int>(ptr_->nsite);
|
|
}
|
|
void set_nsite(int value) {
|
|
ptr_->nsite = static_cast<mjtSize>(value);
|
|
}
|
|
int ncam() const {
|
|
return static_cast<int>(ptr_->ncam);
|
|
}
|
|
void set_ncam(int value) {
|
|
ptr_->ncam = static_cast<mjtSize>(value);
|
|
}
|
|
int nlight() const {
|
|
return static_cast<int>(ptr_->nlight);
|
|
}
|
|
void set_nlight(int value) {
|
|
ptr_->nlight = static_cast<mjtSize>(value);
|
|
}
|
|
int nflex() const {
|
|
return static_cast<int>(ptr_->nflex);
|
|
}
|
|
void set_nflex(int value) {
|
|
ptr_->nflex = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexnode() const {
|
|
return static_cast<int>(ptr_->nflexnode);
|
|
}
|
|
void set_nflexnode(int value) {
|
|
ptr_->nflexnode = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexvert() const {
|
|
return static_cast<int>(ptr_->nflexvert);
|
|
}
|
|
void set_nflexvert(int value) {
|
|
ptr_->nflexvert = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexedge() const {
|
|
return static_cast<int>(ptr_->nflexedge);
|
|
}
|
|
void set_nflexedge(int value) {
|
|
ptr_->nflexedge = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexelem() const {
|
|
return static_cast<int>(ptr_->nflexelem);
|
|
}
|
|
void set_nflexelem(int value) {
|
|
ptr_->nflexelem = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexelemdata() const {
|
|
return static_cast<int>(ptr_->nflexelemdata);
|
|
}
|
|
void set_nflexelemdata(int value) {
|
|
ptr_->nflexelemdata = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexstiffness() const {
|
|
return static_cast<int>(ptr_->nflexstiffness);
|
|
}
|
|
void set_nflexstiffness(int value) {
|
|
ptr_->nflexstiffness = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexbending() const {
|
|
return static_cast<int>(ptr_->nflexbending);
|
|
}
|
|
void set_nflexbending(int value) {
|
|
ptr_->nflexbending = static_cast<mjtSize>(value);
|
|
}
|
|
int nefm0dof() const {
|
|
return static_cast<int>(ptr_->nefm0dof);
|
|
}
|
|
void set_nefm0dof(int value) {
|
|
ptr_->nefm0dof = static_cast<mjtSize>(value);
|
|
}
|
|
int nefm0L() const {
|
|
return static_cast<int>(ptr_->nefm0L);
|
|
}
|
|
void set_nefm0L(int value) {
|
|
ptr_->nefm0L = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexelemedge() const {
|
|
return static_cast<int>(ptr_->nflexelemedge);
|
|
}
|
|
void set_nflexelemedge(int value) {
|
|
ptr_->nflexelemedge = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexshelldata() const {
|
|
return static_cast<int>(ptr_->nflexshelldata);
|
|
}
|
|
void set_nflexshelldata(int value) {
|
|
ptr_->nflexshelldata = static_cast<mjtSize>(value);
|
|
}
|
|
int nflexevpair() const {
|
|
return static_cast<int>(ptr_->nflexevpair);
|
|
}
|
|
void set_nflexevpair(int value) {
|
|
ptr_->nflexevpair = static_cast<mjtSize>(value);
|
|
}
|
|
int nflextexcoord() const {
|
|
return static_cast<int>(ptr_->nflextexcoord);
|
|
}
|
|
void set_nflextexcoord(int value) {
|
|
ptr_->nflextexcoord = static_cast<mjtSize>(value);
|
|
}
|
|
int nJfe() const {
|
|
return static_cast<int>(ptr_->nJfe);
|
|
}
|
|
void set_nJfe(int value) {
|
|
ptr_->nJfe = static_cast<mjtSize>(value);
|
|
}
|
|
int nJfv() const {
|
|
return static_cast<int>(ptr_->nJfv);
|
|
}
|
|
void set_nJfv(int value) {
|
|
ptr_->nJfv = static_cast<mjtSize>(value);
|
|
}
|
|
int nmesh() const {
|
|
return static_cast<int>(ptr_->nmesh);
|
|
}
|
|
void set_nmesh(int value) {
|
|
ptr_->nmesh = static_cast<mjtSize>(value);
|
|
}
|
|
int nmeshvert() const {
|
|
return static_cast<int>(ptr_->nmeshvert);
|
|
}
|
|
void set_nmeshvert(int value) {
|
|
ptr_->nmeshvert = static_cast<mjtSize>(value);
|
|
}
|
|
int nmeshnormal() const {
|
|
return static_cast<int>(ptr_->nmeshnormal);
|
|
}
|
|
void set_nmeshnormal(int value) {
|
|
ptr_->nmeshnormal = static_cast<mjtSize>(value);
|
|
}
|
|
int nmeshtexcoord() const {
|
|
return static_cast<int>(ptr_->nmeshtexcoord);
|
|
}
|
|
void set_nmeshtexcoord(int value) {
|
|
ptr_->nmeshtexcoord = static_cast<mjtSize>(value);
|
|
}
|
|
int nmeshface() const {
|
|
return static_cast<int>(ptr_->nmeshface);
|
|
}
|
|
void set_nmeshface(int value) {
|
|
ptr_->nmeshface = static_cast<mjtSize>(value);
|
|
}
|
|
int nmeshgraph() const {
|
|
return static_cast<int>(ptr_->nmeshgraph);
|
|
}
|
|
void set_nmeshgraph(int value) {
|
|
ptr_->nmeshgraph = static_cast<mjtSize>(value);
|
|
}
|
|
int nmeshpoly() const {
|
|
return static_cast<int>(ptr_->nmeshpoly);
|
|
}
|
|
void set_nmeshpoly(int value) {
|
|
ptr_->nmeshpoly = static_cast<mjtSize>(value);
|
|
}
|
|
int nmeshpolyvert() const {
|
|
return static_cast<int>(ptr_->nmeshpolyvert);
|
|
}
|
|
void set_nmeshpolyvert(int value) {
|
|
ptr_->nmeshpolyvert = static_cast<mjtSize>(value);
|
|
}
|
|
int nmeshpolymap() const {
|
|
return static_cast<int>(ptr_->nmeshpolymap);
|
|
}
|
|
void set_nmeshpolymap(int value) {
|
|
ptr_->nmeshpolymap = static_cast<mjtSize>(value);
|
|
}
|
|
int nskin() const {
|
|
return static_cast<int>(ptr_->nskin);
|
|
}
|
|
void set_nskin(int value) {
|
|
ptr_->nskin = static_cast<mjtSize>(value);
|
|
}
|
|
int nskinvert() const {
|
|
return static_cast<int>(ptr_->nskinvert);
|
|
}
|
|
void set_nskinvert(int value) {
|
|
ptr_->nskinvert = static_cast<mjtSize>(value);
|
|
}
|
|
int nskintexvert() const {
|
|
return static_cast<int>(ptr_->nskintexvert);
|
|
}
|
|
void set_nskintexvert(int value) {
|
|
ptr_->nskintexvert = static_cast<mjtSize>(value);
|
|
}
|
|
int nskinface() const {
|
|
return static_cast<int>(ptr_->nskinface);
|
|
}
|
|
void set_nskinface(int value) {
|
|
ptr_->nskinface = static_cast<mjtSize>(value);
|
|
}
|
|
int nskinbone() const {
|
|
return static_cast<int>(ptr_->nskinbone);
|
|
}
|
|
void set_nskinbone(int value) {
|
|
ptr_->nskinbone = static_cast<mjtSize>(value);
|
|
}
|
|
int nskinbonevert() const {
|
|
return static_cast<int>(ptr_->nskinbonevert);
|
|
}
|
|
void set_nskinbonevert(int value) {
|
|
ptr_->nskinbonevert = static_cast<mjtSize>(value);
|
|
}
|
|
int nhfield() const {
|
|
return static_cast<int>(ptr_->nhfield);
|
|
}
|
|
void set_nhfield(int value) {
|
|
ptr_->nhfield = static_cast<mjtSize>(value);
|
|
}
|
|
int nhfielddata() const {
|
|
return static_cast<int>(ptr_->nhfielddata);
|
|
}
|
|
void set_nhfielddata(int value) {
|
|
ptr_->nhfielddata = static_cast<mjtSize>(value);
|
|
}
|
|
int ntex() const {
|
|
return static_cast<int>(ptr_->ntex);
|
|
}
|
|
void set_ntex(int value) {
|
|
ptr_->ntex = static_cast<mjtSize>(value);
|
|
}
|
|
int ntexdata() const {
|
|
return static_cast<int>(ptr_->ntexdata);
|
|
}
|
|
void set_ntexdata(int value) {
|
|
ptr_->ntexdata = static_cast<mjtSize>(value);
|
|
}
|
|
int nmat() const {
|
|
return static_cast<int>(ptr_->nmat);
|
|
}
|
|
void set_nmat(int value) {
|
|
ptr_->nmat = static_cast<mjtSize>(value);
|
|
}
|
|
int npair() const {
|
|
return static_cast<int>(ptr_->npair);
|
|
}
|
|
void set_npair(int value) {
|
|
ptr_->npair = static_cast<mjtSize>(value);
|
|
}
|
|
int nexclude() const {
|
|
return static_cast<int>(ptr_->nexclude);
|
|
}
|
|
void set_nexclude(int value) {
|
|
ptr_->nexclude = static_cast<mjtSize>(value);
|
|
}
|
|
int neq() const {
|
|
return static_cast<int>(ptr_->neq);
|
|
}
|
|
void set_neq(int value) {
|
|
ptr_->neq = static_cast<mjtSize>(value);
|
|
}
|
|
int ntendon() const {
|
|
return static_cast<int>(ptr_->ntendon);
|
|
}
|
|
void set_ntendon(int value) {
|
|
ptr_->ntendon = static_cast<mjtSize>(value);
|
|
}
|
|
int nJten() const {
|
|
return static_cast<int>(ptr_->nJten);
|
|
}
|
|
void set_nJten(int value) {
|
|
ptr_->nJten = static_cast<mjtSize>(value);
|
|
}
|
|
int nwrap() const {
|
|
return static_cast<int>(ptr_->nwrap);
|
|
}
|
|
void set_nwrap(int value) {
|
|
ptr_->nwrap = static_cast<mjtSize>(value);
|
|
}
|
|
int nsensor() const {
|
|
return static_cast<int>(ptr_->nsensor);
|
|
}
|
|
void set_nsensor(int value) {
|
|
ptr_->nsensor = static_cast<mjtSize>(value);
|
|
}
|
|
int nnumeric() const {
|
|
return static_cast<int>(ptr_->nnumeric);
|
|
}
|
|
void set_nnumeric(int value) {
|
|
ptr_->nnumeric = static_cast<mjtSize>(value);
|
|
}
|
|
int nnumericdata() const {
|
|
return static_cast<int>(ptr_->nnumericdata);
|
|
}
|
|
void set_nnumericdata(int value) {
|
|
ptr_->nnumericdata = static_cast<mjtSize>(value);
|
|
}
|
|
int ntext() const {
|
|
return static_cast<int>(ptr_->ntext);
|
|
}
|
|
void set_ntext(int value) {
|
|
ptr_->ntext = static_cast<mjtSize>(value);
|
|
}
|
|
int ntextdata() const {
|
|
return static_cast<int>(ptr_->ntextdata);
|
|
}
|
|
void set_ntextdata(int value) {
|
|
ptr_->ntextdata = static_cast<mjtSize>(value);
|
|
}
|
|
int ntuple() const {
|
|
return static_cast<int>(ptr_->ntuple);
|
|
}
|
|
void set_ntuple(int value) {
|
|
ptr_->ntuple = static_cast<mjtSize>(value);
|
|
}
|
|
int ntupledata() const {
|
|
return static_cast<int>(ptr_->ntupledata);
|
|
}
|
|
void set_ntupledata(int value) {
|
|
ptr_->ntupledata = static_cast<mjtSize>(value);
|
|
}
|
|
int nkey() const {
|
|
return static_cast<int>(ptr_->nkey);
|
|
}
|
|
void set_nkey(int value) {
|
|
ptr_->nkey = static_cast<mjtSize>(value);
|
|
}
|
|
int nmocap() const {
|
|
return static_cast<int>(ptr_->nmocap);
|
|
}
|
|
void set_nmocap(int value) {
|
|
ptr_->nmocap = static_cast<mjtSize>(value);
|
|
}
|
|
int nplugin() const {
|
|
return static_cast<int>(ptr_->nplugin);
|
|
}
|
|
void set_nplugin(int value) {
|
|
ptr_->nplugin = static_cast<mjtSize>(value);
|
|
}
|
|
int npluginattr() const {
|
|
return static_cast<int>(ptr_->npluginattr);
|
|
}
|
|
void set_npluginattr(int value) {
|
|
ptr_->npluginattr = static_cast<mjtSize>(value);
|
|
}
|
|
int nuser_body() const {
|
|
return static_cast<int>(ptr_->nuser_body);
|
|
}
|
|
void set_nuser_body(int value) {
|
|
ptr_->nuser_body = static_cast<mjtSize>(value);
|
|
}
|
|
int nuser_jnt() const {
|
|
return static_cast<int>(ptr_->nuser_jnt);
|
|
}
|
|
void set_nuser_jnt(int value) {
|
|
ptr_->nuser_jnt = static_cast<mjtSize>(value);
|
|
}
|
|
int nuser_geom() const {
|
|
return static_cast<int>(ptr_->nuser_geom);
|
|
}
|
|
void set_nuser_geom(int value) {
|
|
ptr_->nuser_geom = static_cast<mjtSize>(value);
|
|
}
|
|
int nuser_site() const {
|
|
return static_cast<int>(ptr_->nuser_site);
|
|
}
|
|
void set_nuser_site(int value) {
|
|
ptr_->nuser_site = static_cast<mjtSize>(value);
|
|
}
|
|
int nuser_cam() const {
|
|
return static_cast<int>(ptr_->nuser_cam);
|
|
}
|
|
void set_nuser_cam(int value) {
|
|
ptr_->nuser_cam = static_cast<mjtSize>(value);
|
|
}
|
|
int nuser_tendon() const {
|
|
return static_cast<int>(ptr_->nuser_tendon);
|
|
}
|
|
void set_nuser_tendon(int value) {
|
|
ptr_->nuser_tendon = static_cast<mjtSize>(value);
|
|
}
|
|
int nuser_actuator() const {
|
|
return static_cast<int>(ptr_->nuser_actuator);
|
|
}
|
|
void set_nuser_actuator(int value) {
|
|
ptr_->nuser_actuator = static_cast<mjtSize>(value);
|
|
}
|
|
int nuser_sensor() const {
|
|
return static_cast<int>(ptr_->nuser_sensor);
|
|
}
|
|
void set_nuser_sensor(int value) {
|
|
ptr_->nuser_sensor = static_cast<mjtSize>(value);
|
|
}
|
|
int nnames() const {
|
|
return static_cast<int>(ptr_->nnames);
|
|
}
|
|
void set_nnames(int value) {
|
|
ptr_->nnames = static_cast<mjtSize>(value);
|
|
}
|
|
int npaths() const {
|
|
return static_cast<int>(ptr_->npaths);
|
|
}
|
|
void set_npaths(int value) {
|
|
ptr_->npaths = static_cast<mjtSize>(value);
|
|
}
|
|
int nnames_map() const {
|
|
return static_cast<int>(ptr_->nnames_map);
|
|
}
|
|
void set_nnames_map(int value) {
|
|
ptr_->nnames_map = static_cast<mjtSize>(value);
|
|
}
|
|
int nJmom() const {
|
|
return static_cast<int>(ptr_->nJmom);
|
|
}
|
|
void set_nJmom(int value) {
|
|
ptr_->nJmom = static_cast<mjtSize>(value);
|
|
}
|
|
int ngravcomp() const {
|
|
return static_cast<int>(ptr_->ngravcomp);
|
|
}
|
|
void set_ngravcomp(int value) {
|
|
ptr_->ngravcomp = static_cast<mjtSize>(value);
|
|
}
|
|
int nemax() const {
|
|
return static_cast<int>(ptr_->nemax);
|
|
}
|
|
void set_nemax(int value) {
|
|
ptr_->nemax = static_cast<mjtSize>(value);
|
|
}
|
|
int njmax() const {
|
|
return static_cast<int>(ptr_->njmax);
|
|
}
|
|
void set_njmax(int value) {
|
|
ptr_->njmax = static_cast<mjtSize>(value);
|
|
}
|
|
int nconmax() const {
|
|
return static_cast<int>(ptr_->nconmax);
|
|
}
|
|
void set_nconmax(int value) {
|
|
ptr_->nconmax = static_cast<mjtSize>(value);
|
|
}
|
|
int npolygonmax() const {
|
|
return static_cast<int>(ptr_->npolygonmax);
|
|
}
|
|
void set_npolygonmax(int value) {
|
|
ptr_->npolygonmax = static_cast<mjtSize>(value);
|
|
}
|
|
int nmeshdegmax() const {
|
|
return static_cast<int>(ptr_->nmeshdegmax);
|
|
}
|
|
void set_nmeshdegmax(int value) {
|
|
ptr_->nmeshdegmax = static_cast<mjtSize>(value);
|
|
}
|
|
int nuserdata() const {
|
|
return static_cast<int>(ptr_->nuserdata);
|
|
}
|
|
void set_nuserdata(int value) {
|
|
ptr_->nuserdata = static_cast<mjtSize>(value);
|
|
}
|
|
int nsensordata() const {
|
|
return static_cast<int>(ptr_->nsensordata);
|
|
}
|
|
void set_nsensordata(int value) {
|
|
ptr_->nsensordata = static_cast<mjtSize>(value);
|
|
}
|
|
int npluginstate() const {
|
|
return static_cast<int>(ptr_->npluginstate);
|
|
}
|
|
void set_npluginstate(int value) {
|
|
ptr_->npluginstate = static_cast<mjtSize>(value);
|
|
}
|
|
int nhistory() const {
|
|
return static_cast<int>(ptr_->nhistory);
|
|
}
|
|
void set_nhistory(int value) {
|
|
ptr_->nhistory = static_cast<mjtSize>(value);
|
|
}
|
|
int narena() const {
|
|
return static_cast<int>(ptr_->narena);
|
|
}
|
|
void set_narena(int value) {
|
|
ptr_->narena = static_cast<mjtSize>(value);
|
|
}
|
|
int nbuffer() const {
|
|
return static_cast<int>(ptr_->nbuffer);
|
|
}
|
|
void set_nbuffer(int value) {
|
|
ptr_->nbuffer = static_cast<mjtSize>(value);
|
|
}
|
|
emscripten::val buffer() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbuffer, static_cast<uint8_t*>(ptr_->buffer)));
|
|
}
|
|
emscripten::val qpos0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nq, ptr_->qpos0));
|
|
}
|
|
emscripten::val qpos_spring() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nq, ptr_->qpos_spring));
|
|
}
|
|
emscripten::val body_parentid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_parentid));
|
|
}
|
|
emscripten::val body_rootid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_rootid));
|
|
}
|
|
emscripten::val body_weldid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_weldid));
|
|
}
|
|
emscripten::val body_mocapid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_mocapid));
|
|
}
|
|
emscripten::val body_jntnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_jntnum));
|
|
}
|
|
emscripten::val body_jntadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_jntadr));
|
|
}
|
|
emscripten::val body_dofnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_dofnum));
|
|
}
|
|
emscripten::val body_dofadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_dofadr));
|
|
}
|
|
emscripten::val body_treeid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_treeid));
|
|
}
|
|
emscripten::val body_geomnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_geomnum));
|
|
}
|
|
emscripten::val body_geomadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_geomadr));
|
|
}
|
|
emscripten::val body_simple() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_simple));
|
|
}
|
|
emscripten::val body_sameframe() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_sameframe));
|
|
}
|
|
emscripten::val body_pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 3, ptr_->body_pos));
|
|
}
|
|
emscripten::val body_quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 4, ptr_->body_quat));
|
|
}
|
|
emscripten::val body_ipos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 3, ptr_->body_ipos));
|
|
}
|
|
emscripten::val body_iquat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 4, ptr_->body_iquat));
|
|
}
|
|
emscripten::val body_mass() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_mass));
|
|
}
|
|
emscripten::val body_subtreemass() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_subtreemass));
|
|
}
|
|
emscripten::val body_inertia() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 3, ptr_->body_inertia));
|
|
}
|
|
emscripten::val body_invweight0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * 2, ptr_->body_invweight0));
|
|
}
|
|
emscripten::val body_gravcomp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_gravcomp));
|
|
}
|
|
emscripten::val body_margin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_margin));
|
|
}
|
|
emscripten::val body_user() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody * ptr_->nuser_body, ptr_->body_user));
|
|
}
|
|
emscripten::val body_plugin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_plugin));
|
|
}
|
|
emscripten::val body_contype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_contype));
|
|
}
|
|
emscripten::val body_conaffinity() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_conaffinity));
|
|
}
|
|
emscripten::val body_bvhadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_bvhadr));
|
|
}
|
|
emscripten::val body_bvhnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->body_bvhnum));
|
|
}
|
|
emscripten::val bvh_depth() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbvh, ptr_->bvh_depth));
|
|
}
|
|
emscripten::val bvh_child() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbvh * 2, ptr_->bvh_child));
|
|
}
|
|
emscripten::val bvh_nodeid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbvh, ptr_->bvh_nodeid));
|
|
}
|
|
emscripten::val bvh_aabb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbvhstatic * 6, ptr_->bvh_aabb));
|
|
}
|
|
emscripten::val oct_depth() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->noct, ptr_->oct_depth));
|
|
}
|
|
emscripten::val oct_child() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->noct * 8, ptr_->oct_child));
|
|
}
|
|
emscripten::val oct_aabb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->noct * 6, ptr_->oct_aabb));
|
|
}
|
|
emscripten::val oct_coeff() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->noct * 8, ptr_->oct_coeff));
|
|
}
|
|
emscripten::val jnt_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_type));
|
|
}
|
|
emscripten::val jnt_qposadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_qposadr));
|
|
}
|
|
emscripten::val jnt_dofadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_dofadr));
|
|
}
|
|
emscripten::val jnt_bodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_bodyid));
|
|
}
|
|
emscripten::val jnt_actuatorid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_actuatorid));
|
|
}
|
|
emscripten::val jnt_group() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_group));
|
|
}
|
|
emscripten::val jnt_limited() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_limited));
|
|
}
|
|
emscripten::val jnt_actfrclimited() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_actfrclimited));
|
|
}
|
|
emscripten::val jnt_actgravcomp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_actgravcomp));
|
|
}
|
|
emscripten::val jnt_solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * mjNREF, ptr_->jnt_solref));
|
|
}
|
|
emscripten::val jnt_solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * mjNIMP, ptr_->jnt_solimp));
|
|
}
|
|
emscripten::val jnt_pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * 3, ptr_->jnt_pos));
|
|
}
|
|
emscripten::val jnt_axis() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * 3, ptr_->jnt_axis));
|
|
}
|
|
emscripten::val jnt_stiffness() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_stiffness));
|
|
}
|
|
emscripten::val jnt_stiffnesspoly() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * mjNPOLY, ptr_->jnt_stiffnesspoly));
|
|
}
|
|
emscripten::val jnt_range() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * 2, ptr_->jnt_range));
|
|
}
|
|
emscripten::val jnt_actfrcrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * 2, ptr_->jnt_actfrcrange));
|
|
}
|
|
emscripten::val jnt_margin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->jnt_margin));
|
|
}
|
|
emscripten::val jnt_user() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt * ptr_->nuser_jnt, ptr_->jnt_user));
|
|
}
|
|
emscripten::val dof_bodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_bodyid));
|
|
}
|
|
emscripten::val dof_jntid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_jntid));
|
|
}
|
|
emscripten::val dof_parentid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_parentid));
|
|
}
|
|
emscripten::val dof_treeid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_treeid));
|
|
}
|
|
emscripten::val dof_Madr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_Madr));
|
|
}
|
|
emscripten::val dof_simplenum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_simplenum));
|
|
}
|
|
emscripten::val dof_solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv * mjNREF, ptr_->dof_solref));
|
|
}
|
|
emscripten::val dof_solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv * mjNIMP, ptr_->dof_solimp));
|
|
}
|
|
emscripten::val dof_frictionloss() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_frictionloss));
|
|
}
|
|
emscripten::val dof_armature() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_armature));
|
|
}
|
|
emscripten::val dof_damping() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_damping));
|
|
}
|
|
emscripten::val dof_dampingpoly() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv * mjNPOLY, ptr_->dof_dampingpoly));
|
|
}
|
|
emscripten::val dof_invweight0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_invweight0));
|
|
}
|
|
emscripten::val dof_M0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_M0));
|
|
}
|
|
emscripten::val dof_length() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->dof_length));
|
|
}
|
|
emscripten::val tree_bodyadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_bodyadr));
|
|
}
|
|
emscripten::val tree_bodynum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_bodynum));
|
|
}
|
|
emscripten::val tree_dofadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_dofadr));
|
|
}
|
|
emscripten::val tree_dofnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_dofnum));
|
|
}
|
|
emscripten::val tree_sleep_policy() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntree, ptr_->tree_sleep_policy));
|
|
}
|
|
emscripten::val geom_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_type));
|
|
}
|
|
emscripten::val geom_contype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_contype));
|
|
}
|
|
emscripten::val geom_conaffinity() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_conaffinity));
|
|
}
|
|
emscripten::val geom_condim() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_condim));
|
|
}
|
|
emscripten::val geom_bodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_bodyid));
|
|
}
|
|
emscripten::val geom_dataid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_dataid));
|
|
}
|
|
emscripten::val geom_matid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_matid));
|
|
}
|
|
emscripten::val geom_group() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_group));
|
|
}
|
|
emscripten::val geom_priority() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_priority));
|
|
}
|
|
emscripten::val geom_plugin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_plugin));
|
|
}
|
|
emscripten::val geom_sameframe() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_sameframe));
|
|
}
|
|
emscripten::val geom_solmix() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_solmix));
|
|
}
|
|
emscripten::val geom_solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * mjNREF, ptr_->geom_solref));
|
|
}
|
|
emscripten::val geom_solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * mjNIMP, ptr_->geom_solimp));
|
|
}
|
|
emscripten::val geom_size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 3, ptr_->geom_size));
|
|
}
|
|
emscripten::val geom_aabb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 6, ptr_->geom_aabb));
|
|
}
|
|
emscripten::val geom_rbound() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_rbound));
|
|
}
|
|
emscripten::val geom_pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 3, ptr_->geom_pos));
|
|
}
|
|
emscripten::val geom_quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 4, ptr_->geom_quat));
|
|
}
|
|
emscripten::val geom_friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 3, ptr_->geom_friction));
|
|
}
|
|
emscripten::val geom_margin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_margin));
|
|
}
|
|
emscripten::val geom_gap() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->geom_gap));
|
|
}
|
|
emscripten::val geom_fluid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * mjNFLUID, ptr_->geom_fluid));
|
|
}
|
|
emscripten::val geom_user() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * ptr_->nuser_geom, ptr_->geom_user));
|
|
}
|
|
emscripten::val geom_rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom * 4, ptr_->geom_rgba));
|
|
}
|
|
emscripten::val site_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_type));
|
|
}
|
|
emscripten::val site_bodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_bodyid));
|
|
}
|
|
emscripten::val site_matid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_matid));
|
|
}
|
|
emscripten::val site_group() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_group));
|
|
}
|
|
emscripten::val site_sameframe() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->site_sameframe));
|
|
}
|
|
emscripten::val site_size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * 3, ptr_->site_size));
|
|
}
|
|
emscripten::val site_pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * 3, ptr_->site_pos));
|
|
}
|
|
emscripten::val site_quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * 4, ptr_->site_quat));
|
|
}
|
|
emscripten::val site_user() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * ptr_->nuser_site, ptr_->site_user));
|
|
}
|
|
emscripten::val site_rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite * 4, ptr_->site_rgba));
|
|
}
|
|
emscripten::val cam_mode() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_mode));
|
|
}
|
|
emscripten::val cam_bodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_bodyid));
|
|
}
|
|
emscripten::val cam_targetbodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_targetbodyid));
|
|
}
|
|
emscripten::val cam_pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 3, ptr_->cam_pos));
|
|
}
|
|
emscripten::val cam_quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 4, ptr_->cam_quat));
|
|
}
|
|
emscripten::val cam_poscom0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 3, ptr_->cam_poscom0));
|
|
}
|
|
emscripten::val cam_pos0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 3, ptr_->cam_pos0));
|
|
}
|
|
emscripten::val cam_mat0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 9, ptr_->cam_mat0));
|
|
}
|
|
emscripten::val cam_projection() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_projection));
|
|
}
|
|
emscripten::val cam_fovy() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_fovy));
|
|
}
|
|
emscripten::val cam_ipd() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_ipd));
|
|
}
|
|
emscripten::val cam_resolution() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 2, ptr_->cam_resolution));
|
|
}
|
|
emscripten::val cam_output() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->cam_output));
|
|
}
|
|
emscripten::val cam_sensorsize() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 2, ptr_->cam_sensorsize));
|
|
}
|
|
emscripten::val cam_intrinsic() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * 4, ptr_->cam_intrinsic));
|
|
}
|
|
emscripten::val cam_user() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam * ptr_->nuser_cam, ptr_->cam_user));
|
|
}
|
|
emscripten::val light_mode() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_mode));
|
|
}
|
|
emscripten::val light_bodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_bodyid));
|
|
}
|
|
emscripten::val light_targetbodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_targetbodyid));
|
|
}
|
|
emscripten::val light_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_type));
|
|
}
|
|
emscripten::val light_texid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_texid));
|
|
}
|
|
emscripten::val light_castshadow() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_castshadow));
|
|
}
|
|
emscripten::val light_bulbradius() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_bulbradius));
|
|
}
|
|
emscripten::val light_intensity() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_intensity));
|
|
}
|
|
emscripten::val light_range() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_range));
|
|
}
|
|
emscripten::val light_active() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_active));
|
|
}
|
|
emscripten::val light_pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_pos));
|
|
}
|
|
emscripten::val light_dir() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_dir));
|
|
}
|
|
emscripten::val light_poscom0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_poscom0));
|
|
}
|
|
emscripten::val light_pos0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_pos0));
|
|
}
|
|
emscripten::val light_dir0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_dir0));
|
|
}
|
|
emscripten::val light_attenuation() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_attenuation));
|
|
}
|
|
emscripten::val light_cutoff() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_cutoff));
|
|
}
|
|
emscripten::val light_exponent() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->light_exponent));
|
|
}
|
|
emscripten::val light_ambient() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_ambient));
|
|
}
|
|
emscripten::val light_diffuse() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_diffuse));
|
|
}
|
|
emscripten::val light_specular() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight * 3, ptr_->light_specular));
|
|
}
|
|
emscripten::val flex_contype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_contype));
|
|
}
|
|
emscripten::val flex_conaffinity() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_conaffinity));
|
|
}
|
|
emscripten::val flex_condim() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_condim));
|
|
}
|
|
emscripten::val flex_priority() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_priority));
|
|
}
|
|
emscripten::val flex_solmix() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_solmix));
|
|
}
|
|
emscripten::val flex_solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * mjNREF, ptr_->flex_solref));
|
|
}
|
|
emscripten::val flex_solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * mjNIMP, ptr_->flex_solimp));
|
|
}
|
|
emscripten::val flex_friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * 3, ptr_->flex_friction));
|
|
}
|
|
emscripten::val flex_margin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_margin));
|
|
}
|
|
emscripten::val flex_gap() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_gap));
|
|
}
|
|
emscripten::val flex_internal() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_internal));
|
|
}
|
|
emscripten::val flex_selfcollide() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_selfcollide));
|
|
}
|
|
emscripten::val flex_activelayers() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_activelayers));
|
|
}
|
|
emscripten::val flex_passive() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_passive));
|
|
}
|
|
emscripten::val flex_dim() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_dim));
|
|
}
|
|
emscripten::val flex_matid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_matid));
|
|
}
|
|
emscripten::val flex_group() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_group));
|
|
}
|
|
emscripten::val flex_interp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_interp));
|
|
}
|
|
emscripten::val flex_cellnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * 3, ptr_->flex_cellnum));
|
|
}
|
|
emscripten::val flex_nodeadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_nodeadr));
|
|
}
|
|
emscripten::val flex_nodenum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_nodenum));
|
|
}
|
|
emscripten::val flex_vertadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_vertadr));
|
|
}
|
|
emscripten::val flex_vertnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_vertnum));
|
|
}
|
|
emscripten::val flex_edgeadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgeadr));
|
|
}
|
|
emscripten::val flex_edgenum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgenum));
|
|
}
|
|
emscripten::val flex_elemadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_elemadr));
|
|
}
|
|
emscripten::val flex_elemnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_elemnum));
|
|
}
|
|
emscripten::val flex_elemdataadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_elemdataadr));
|
|
}
|
|
emscripten::val flex_stiffnessadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_stiffnessadr));
|
|
}
|
|
emscripten::val flex_elemedgeadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_elemedgeadr));
|
|
}
|
|
emscripten::val flex_bendingadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_bendingadr));
|
|
}
|
|
emscripten::val flex_shellnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_shellnum));
|
|
}
|
|
emscripten::val flex_shelldataadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_shelldataadr));
|
|
}
|
|
emscripten::val flex_evpairadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_evpairadr));
|
|
}
|
|
emscripten::val flex_evpairnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_evpairnum));
|
|
}
|
|
emscripten::val flex_texcoordadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_texcoordadr));
|
|
}
|
|
emscripten::val flex_nodebodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexnode, ptr_->flex_nodebodyid));
|
|
}
|
|
emscripten::val flex_vertbodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert, ptr_->flex_vertbodyid));
|
|
}
|
|
emscripten::val flex_vertedgeadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert, ptr_->flex_vertedgeadr));
|
|
}
|
|
emscripten::val flex_vertedgenum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert, ptr_->flex_vertedgenum));
|
|
}
|
|
emscripten::val flex_vertedge() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge * 2, ptr_->flex_vertedge));
|
|
}
|
|
emscripten::val flex_edge() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge * 2, ptr_->flex_edge));
|
|
}
|
|
emscripten::val flex_edgeflap() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge * 2, ptr_->flex_edgeflap));
|
|
}
|
|
emscripten::val flex_elem() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexelemdata, ptr_->flex_elem));
|
|
}
|
|
emscripten::val flex_elemtexcoord() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexelemdata, ptr_->flex_elemtexcoord));
|
|
}
|
|
emscripten::val flex_elemedge() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexelemedge, ptr_->flex_elemedge));
|
|
}
|
|
emscripten::val flex_elemlayer() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexelem, ptr_->flex_elemlayer));
|
|
}
|
|
emscripten::val flex_shell() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexshelldata, ptr_->flex_shell));
|
|
}
|
|
emscripten::val flex_evpair() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexevpair * 2, ptr_->flex_evpair));
|
|
}
|
|
emscripten::val flex_vert() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 3, ptr_->flex_vert));
|
|
}
|
|
emscripten::val flex_vert0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 3, ptr_->flex_vert0));
|
|
}
|
|
emscripten::val flex_vertmetric() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 4, ptr_->flex_vertmetric));
|
|
}
|
|
emscripten::val flex_node() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexnode * 3, ptr_->flex_node));
|
|
}
|
|
emscripten::val flex_node0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexnode * 3, ptr_->flex_node0));
|
|
}
|
|
emscripten::val flexedge_length0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_length0));
|
|
}
|
|
emscripten::val flexedge_invweight0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_invweight0));
|
|
}
|
|
emscripten::val flex_radius() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_radius));
|
|
}
|
|
emscripten::val flex_size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * 3, ptr_->flex_size));
|
|
}
|
|
emscripten::val flex_stiffness() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexstiffness, ptr_->flex_stiffness));
|
|
}
|
|
emscripten::val flex_bending() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexbending, ptr_->flex_bending));
|
|
}
|
|
emscripten::val efm0_dofid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0dof, ptr_->efm0_dofid));
|
|
}
|
|
emscripten::val efm0_L_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0dof, ptr_->efm0_L_rownnz));
|
|
}
|
|
emscripten::val efm0_L_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0dof, ptr_->efm0_L_rowadr));
|
|
}
|
|
emscripten::val efm0_L_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0L, ptr_->efm0_L_colind));
|
|
}
|
|
emscripten::val efm0_L() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefm0L, ptr_->efm0_L));
|
|
}
|
|
emscripten::val flex_damping() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_damping));
|
|
}
|
|
emscripten::val flex_edgestiffness() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgestiffness));
|
|
}
|
|
emscripten::val flex_edgedamping() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgedamping));
|
|
}
|
|
emscripten::val flex_edgeequality() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_edgeequality));
|
|
}
|
|
emscripten::val flex_rigid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_rigid));
|
|
}
|
|
emscripten::val flexedge_rigid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_rigid));
|
|
}
|
|
emscripten::val flex_centered() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_centered));
|
|
}
|
|
emscripten::val flex_flatskin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_flatskin));
|
|
}
|
|
emscripten::val flex_bvhadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_bvhadr));
|
|
}
|
|
emscripten::val flex_bvhnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->flex_bvhnum));
|
|
}
|
|
emscripten::val flexedge_J_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_J_rownnz));
|
|
}
|
|
emscripten::val flexedge_J_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexedge, ptr_->flexedge_J_rowadr));
|
|
}
|
|
emscripten::val flexedge_J_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nJfe, ptr_->flexedge_J_colind));
|
|
}
|
|
emscripten::val flexvert_J_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 2, ptr_->flexvert_J_rownnz));
|
|
}
|
|
emscripten::val flexvert_J_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflexvert * 2, ptr_->flexvert_J_rowadr));
|
|
}
|
|
emscripten::val flexvert_J_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nJfv * 2, ptr_->flexvert_J_colind));
|
|
}
|
|
emscripten::val flex_rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex * 4, ptr_->flex_rgba));
|
|
}
|
|
emscripten::val flex_texcoord() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflextexcoord * 2, ptr_->flex_texcoord));
|
|
}
|
|
emscripten::val mesh_vertadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_vertadr));
|
|
}
|
|
emscripten::val mesh_vertnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_vertnum));
|
|
}
|
|
emscripten::val mesh_faceadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_faceadr));
|
|
}
|
|
emscripten::val mesh_facenum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_facenum));
|
|
}
|
|
emscripten::val mesh_bvhadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_bvhadr));
|
|
}
|
|
emscripten::val mesh_bvhnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_bvhnum));
|
|
}
|
|
emscripten::val mesh_octadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_octadr));
|
|
}
|
|
emscripten::val mesh_octnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_octnum));
|
|
}
|
|
emscripten::val mesh_normaladr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_normaladr));
|
|
}
|
|
emscripten::val mesh_normalnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_normalnum));
|
|
}
|
|
emscripten::val mesh_texcoordadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_texcoordadr));
|
|
}
|
|
emscripten::val mesh_texcoordnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_texcoordnum));
|
|
}
|
|
emscripten::val mesh_graphadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_graphadr));
|
|
}
|
|
emscripten::val mesh_vert() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshvert * 3, ptr_->mesh_vert));
|
|
}
|
|
emscripten::val mesh_normal() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshnormal * 3, ptr_->mesh_normal));
|
|
}
|
|
emscripten::val mesh_texcoord() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshtexcoord * 2, ptr_->mesh_texcoord));
|
|
}
|
|
emscripten::val mesh_face() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshface * 3, ptr_->mesh_face));
|
|
}
|
|
emscripten::val mesh_facenormal() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshface * 3, ptr_->mesh_facenormal));
|
|
}
|
|
emscripten::val mesh_facetexcoord() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshface * 3, ptr_->mesh_facetexcoord));
|
|
}
|
|
emscripten::val mesh_graph() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshgraph, ptr_->mesh_graph));
|
|
}
|
|
emscripten::val mesh_scale() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh * 3, ptr_->mesh_scale));
|
|
}
|
|
emscripten::val mesh_pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh * 3, ptr_->mesh_pos));
|
|
}
|
|
emscripten::val mesh_quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh * 4, ptr_->mesh_quat));
|
|
}
|
|
emscripten::val mesh_pathadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_pathadr));
|
|
}
|
|
emscripten::val mesh_polynum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_polynum));
|
|
}
|
|
emscripten::val mesh_polyadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->mesh_polyadr));
|
|
}
|
|
emscripten::val mesh_polynormal() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpoly * 3, ptr_->mesh_polynormal));
|
|
}
|
|
emscripten::val mesh_polyvertadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpoly, ptr_->mesh_polyvertadr));
|
|
}
|
|
emscripten::val mesh_polyvertnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpoly, ptr_->mesh_polyvertnum));
|
|
}
|
|
emscripten::val mesh_polyvert() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpolyvert, ptr_->mesh_polyvert));
|
|
}
|
|
emscripten::val mesh_polymapadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshvert, ptr_->mesh_polymapadr));
|
|
}
|
|
emscripten::val mesh_polymapnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshvert, ptr_->mesh_polymapnum));
|
|
}
|
|
emscripten::val mesh_polymap() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmeshpolymap, ptr_->mesh_polymap));
|
|
}
|
|
emscripten::val skin_matid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_matid));
|
|
}
|
|
emscripten::val skin_group() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_group));
|
|
}
|
|
emscripten::val skin_rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin * 4, ptr_->skin_rgba));
|
|
}
|
|
emscripten::val skin_inflate() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_inflate));
|
|
}
|
|
emscripten::val skin_vertadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_vertadr));
|
|
}
|
|
emscripten::val skin_vertnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_vertnum));
|
|
}
|
|
emscripten::val skin_texcoordadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_texcoordadr));
|
|
}
|
|
emscripten::val skin_faceadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_faceadr));
|
|
}
|
|
emscripten::val skin_facenum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_facenum));
|
|
}
|
|
emscripten::val skin_boneadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_boneadr));
|
|
}
|
|
emscripten::val skin_bonenum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_bonenum));
|
|
}
|
|
emscripten::val skin_vert() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskinvert * 3, ptr_->skin_vert));
|
|
}
|
|
emscripten::val skin_texcoord() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskintexvert * 2, ptr_->skin_texcoord));
|
|
}
|
|
emscripten::val skin_face() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskinface * 3, ptr_->skin_face));
|
|
}
|
|
emscripten::val skin_bonevertadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone, ptr_->skin_bonevertadr));
|
|
}
|
|
emscripten::val skin_bonevertnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone, ptr_->skin_bonevertnum));
|
|
}
|
|
emscripten::val skin_bonebindpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone * 3, ptr_->skin_bonebindpos));
|
|
}
|
|
emscripten::val skin_bonebindquat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone * 4, ptr_->skin_bonebindquat));
|
|
}
|
|
emscripten::val skin_bonebodyid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbone, ptr_->skin_bonebodyid));
|
|
}
|
|
emscripten::val skin_bonevertid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbonevert, ptr_->skin_bonevertid));
|
|
}
|
|
emscripten::val skin_bonevertweight() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskinbonevert, ptr_->skin_bonevertweight));
|
|
}
|
|
emscripten::val skin_pathadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->skin_pathadr));
|
|
}
|
|
emscripten::val hfield_size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield * 4, ptr_->hfield_size));
|
|
}
|
|
emscripten::val hfield_nrow() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->hfield_nrow));
|
|
}
|
|
emscripten::val hfield_ncol() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->hfield_ncol));
|
|
}
|
|
emscripten::val hfield_adr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->hfield_adr));
|
|
}
|
|
emscripten::val hfield_data() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nhfielddata, ptr_->hfield_data));
|
|
}
|
|
emscripten::val hfield_pathadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->hfield_pathadr));
|
|
}
|
|
emscripten::val tex_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_type));
|
|
}
|
|
emscripten::val tex_colorspace() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_colorspace));
|
|
}
|
|
emscripten::val tex_height() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_height));
|
|
}
|
|
emscripten::val tex_width() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_width));
|
|
}
|
|
emscripten::val tex_nchannel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_nchannel));
|
|
}
|
|
emscripten::val tex_adr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_adr));
|
|
}
|
|
emscripten::val tex_data() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntexdata, ptr_->tex_data));
|
|
}
|
|
emscripten::val tex_pathadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->tex_pathadr));
|
|
}
|
|
emscripten::val mat_texid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat * mjNTEXROLE, ptr_->mat_texid));
|
|
}
|
|
emscripten::val mat_texuniform() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_texuniform));
|
|
}
|
|
emscripten::val mat_texrepeat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat * 2, ptr_->mat_texrepeat));
|
|
}
|
|
emscripten::val mat_emission() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_emission));
|
|
}
|
|
emscripten::val mat_specular() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_specular));
|
|
}
|
|
emscripten::val mat_shininess() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_shininess));
|
|
}
|
|
emscripten::val mat_reflectance() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_reflectance));
|
|
}
|
|
emscripten::val mat_metallic() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_metallic));
|
|
}
|
|
emscripten::val mat_roughness() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->mat_roughness));
|
|
}
|
|
emscripten::val mat_rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat * 4, ptr_->mat_rgba));
|
|
}
|
|
emscripten::val pair_dim() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_dim));
|
|
}
|
|
emscripten::val pair_geom1() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_geom1));
|
|
}
|
|
emscripten::val pair_geom2() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_geom2));
|
|
}
|
|
emscripten::val pair_signature() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_signature));
|
|
}
|
|
emscripten::val pair_solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair * mjNREF, ptr_->pair_solref));
|
|
}
|
|
emscripten::val pair_solreffriction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair * mjNREF, ptr_->pair_solreffriction));
|
|
}
|
|
emscripten::val pair_solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair * mjNIMP, ptr_->pair_solimp));
|
|
}
|
|
emscripten::val pair_margin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_margin));
|
|
}
|
|
emscripten::val pair_gap() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->pair_gap));
|
|
}
|
|
emscripten::val pair_friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair * 5, ptr_->pair_friction));
|
|
}
|
|
emscripten::val exclude_signature() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nexclude, ptr_->exclude_signature));
|
|
}
|
|
emscripten::val eq_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_type));
|
|
}
|
|
emscripten::val eq_obj1id() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_obj1id));
|
|
}
|
|
emscripten::val eq_obj2id() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_obj2id));
|
|
}
|
|
emscripten::val eq_objtype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_objtype));
|
|
}
|
|
emscripten::val eq_active0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->eq_active0));
|
|
}
|
|
emscripten::val eq_solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->neq * mjNREF, ptr_->eq_solref));
|
|
}
|
|
emscripten::val eq_solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->neq * mjNIMP, ptr_->eq_solimp));
|
|
}
|
|
emscripten::val eq_data() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->neq * mjNEQDATA, ptr_->eq_data));
|
|
}
|
|
emscripten::val tendon_adr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_adr));
|
|
}
|
|
emscripten::val tendon_num() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_num));
|
|
}
|
|
emscripten::val tendon_matid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_matid));
|
|
}
|
|
emscripten::val tendon_actuatorid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_actuatorid));
|
|
}
|
|
emscripten::val tendon_group() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_group));
|
|
}
|
|
emscripten::val tendon_treenum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_treenum));
|
|
}
|
|
emscripten::val tendon_treeid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 2, ptr_->tendon_treeid));
|
|
}
|
|
emscripten::val ten_J_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->ten_J_rownnz));
|
|
}
|
|
emscripten::val ten_J_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->ten_J_rowadr));
|
|
}
|
|
emscripten::val ten_J_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nJten, ptr_->ten_J_colind));
|
|
}
|
|
emscripten::val tendon_limited() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_limited));
|
|
}
|
|
emscripten::val tendon_actfrclimited() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_actfrclimited));
|
|
}
|
|
emscripten::val tendon_width() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_width));
|
|
}
|
|
emscripten::val tendon_solref_lim() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNREF, ptr_->tendon_solref_lim));
|
|
}
|
|
emscripten::val tendon_solimp_lim() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNIMP, ptr_->tendon_solimp_lim));
|
|
}
|
|
emscripten::val tendon_solref_fri() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNREF, ptr_->tendon_solref_fri));
|
|
}
|
|
emscripten::val tendon_solimp_fri() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNIMP, ptr_->tendon_solimp_fri));
|
|
}
|
|
emscripten::val tendon_range() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 2, ptr_->tendon_range));
|
|
}
|
|
emscripten::val tendon_actfrcrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 2, ptr_->tendon_actfrcrange));
|
|
}
|
|
emscripten::val tendon_margin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_margin));
|
|
}
|
|
emscripten::val tendon_stiffness() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_stiffness));
|
|
}
|
|
emscripten::val tendon_stiffnesspoly() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNPOLY, ptr_->tendon_stiffnesspoly));
|
|
}
|
|
emscripten::val tendon_damping() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_damping));
|
|
}
|
|
emscripten::val tendon_dampingpoly() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * mjNPOLY, ptr_->tendon_dampingpoly));
|
|
}
|
|
emscripten::val tendon_armature() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_armature));
|
|
}
|
|
emscripten::val tendon_frictionloss() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_frictionloss));
|
|
}
|
|
emscripten::val tendon_lengthspring() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 2, ptr_->tendon_lengthspring));
|
|
}
|
|
emscripten::val tendon_length0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_length0));
|
|
}
|
|
emscripten::val tendon_invweight0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->tendon_invweight0));
|
|
}
|
|
emscripten::val tendon_user() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * ptr_->nuser_tendon, ptr_->tendon_user));
|
|
}
|
|
emscripten::val tendon_rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon * 4, ptr_->tendon_rgba));
|
|
}
|
|
emscripten::val wrap_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nwrap, ptr_->wrap_type));
|
|
}
|
|
emscripten::val wrap_objid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nwrap, ptr_->wrap_objid));
|
|
}
|
|
emscripten::val wrap_prm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nwrap, ptr_->wrap_prm));
|
|
}
|
|
emscripten::val actuator_trntype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_trntype));
|
|
}
|
|
emscripten::val actuator_dyntype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_dyntype));
|
|
}
|
|
emscripten::val actuator_gaintype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_gaintype));
|
|
}
|
|
emscripten::val actuator_biastype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_biastype));
|
|
}
|
|
emscripten::val actuator_ctrladr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_ctrladr));
|
|
}
|
|
emscripten::val actuator_ctrlnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_ctrlnum));
|
|
}
|
|
emscripten::val actuator_outadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_outadr));
|
|
}
|
|
emscripten::val actuator_outnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_outnum));
|
|
}
|
|
emscripten::val actuator_actadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_actadr));
|
|
}
|
|
emscripten::val actuator_actnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_actnum));
|
|
}
|
|
emscripten::val actuator_trnid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * 2, ptr_->actuator_trnid));
|
|
}
|
|
emscripten::val actuator_cranklength() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_cranklength));
|
|
}
|
|
emscripten::val actuator_dynprm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * mjNDYN, ptr_->actuator_dynprm));
|
|
}
|
|
emscripten::val actuator_gainprm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * mjNGAIN, ptr_->actuator_gainprm));
|
|
}
|
|
emscripten::val actuator_biasprm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * mjNBIAS, ptr_->actuator_biasprm));
|
|
}
|
|
emscripten::val actuator_actlimited() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_actlimited));
|
|
}
|
|
emscripten::val actuator_actrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * 2, ptr_->actuator_actrange));
|
|
}
|
|
emscripten::val actuator_actearly() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_actearly));
|
|
}
|
|
emscripten::val actuator_history() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * 2, ptr_->actuator_history));
|
|
}
|
|
emscripten::val actuator_historyadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_historyadr));
|
|
}
|
|
emscripten::val actuator_delay() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_delay));
|
|
}
|
|
emscripten::val actuator_damping() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_damping));
|
|
}
|
|
emscripten::val actuator_dampingpoly() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * mjNPOLY, ptr_->actuator_dampingpoly));
|
|
}
|
|
emscripten::val actuator_armature() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_armature));
|
|
}
|
|
emscripten::val actuator_group() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_group));
|
|
}
|
|
emscripten::val actuator_user() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator * ptr_->nuser_actuator, ptr_->actuator_user));
|
|
}
|
|
emscripten::val actuator_plugin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->actuator_plugin));
|
|
}
|
|
emscripten::val actuator_ctrllimited() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nu, ptr_->actuator_ctrllimited));
|
|
}
|
|
emscripten::val actuator_ctrlrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nu * 2, ptr_->actuator_ctrlrange));
|
|
}
|
|
emscripten::val actuator_gear() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nout * 6, ptr_->actuator_gear));
|
|
}
|
|
emscripten::val actuator_forcelimited() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nout, ptr_->actuator_forcelimited));
|
|
}
|
|
emscripten::val actuator_forcerange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nout * 2, ptr_->actuator_forcerange));
|
|
}
|
|
emscripten::val actuator_acc0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nout, ptr_->actuator_acc0));
|
|
}
|
|
emscripten::val actuator_length0() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nout, ptr_->actuator_length0));
|
|
}
|
|
emscripten::val actuator_lengthrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nout * 2, ptr_->actuator_lengthrange));
|
|
}
|
|
emscripten::val sensor_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_type));
|
|
}
|
|
emscripten::val sensor_datatype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_datatype));
|
|
}
|
|
emscripten::val sensor_needstage() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_needstage));
|
|
}
|
|
emscripten::val sensor_objtype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_objtype));
|
|
}
|
|
emscripten::val sensor_objid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_objid));
|
|
}
|
|
emscripten::val sensor_reftype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_reftype));
|
|
}
|
|
emscripten::val sensor_refid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_refid));
|
|
}
|
|
emscripten::val sensor_intprm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor * mjNSENS, ptr_->sensor_intprm));
|
|
}
|
|
emscripten::val sensor_dim() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_dim));
|
|
}
|
|
emscripten::val sensor_adr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_adr));
|
|
}
|
|
emscripten::val sensor_cutoff() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_cutoff));
|
|
}
|
|
emscripten::val sensor_noise() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_noise));
|
|
}
|
|
emscripten::val sensor_history() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor * 2, ptr_->sensor_history));
|
|
}
|
|
emscripten::val sensor_historyadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_historyadr));
|
|
}
|
|
emscripten::val sensor_delay() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_delay));
|
|
}
|
|
emscripten::val sensor_interval() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor * 2, ptr_->sensor_interval));
|
|
}
|
|
emscripten::val sensor_user() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor * ptr_->nuser_sensor, ptr_->sensor_user));
|
|
}
|
|
emscripten::val sensor_plugin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->sensor_plugin));
|
|
}
|
|
emscripten::val plugin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->plugin));
|
|
}
|
|
emscripten::val plugin_stateadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->plugin_stateadr));
|
|
}
|
|
emscripten::val plugin_statenum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->plugin_statenum));
|
|
}
|
|
emscripten::val plugin_attr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npluginattr, ptr_->plugin_attr));
|
|
}
|
|
emscripten::val plugin_attradr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->plugin_attradr));
|
|
}
|
|
emscripten::val numeric_adr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nnumeric, ptr_->numeric_adr));
|
|
}
|
|
emscripten::val numeric_size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nnumeric, ptr_->numeric_size));
|
|
}
|
|
emscripten::val numeric_data() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nnumericdata, ptr_->numeric_data));
|
|
}
|
|
emscripten::val text_adr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntext, ptr_->text_adr));
|
|
}
|
|
emscripten::val text_size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntext, ptr_->text_size));
|
|
}
|
|
emscripten::val text_data() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntextdata, ptr_->text_data));
|
|
}
|
|
emscripten::val tuple_adr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntuple, ptr_->tuple_adr));
|
|
}
|
|
emscripten::val tuple_size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntuple, ptr_->tuple_size));
|
|
}
|
|
emscripten::val tuple_objtype() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntupledata, ptr_->tuple_objtype));
|
|
}
|
|
emscripten::val tuple_objid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntupledata, ptr_->tuple_objid));
|
|
}
|
|
emscripten::val tuple_objprm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntupledata, ptr_->tuple_objprm));
|
|
}
|
|
emscripten::val key_time() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nkey, ptr_->key_time));
|
|
}
|
|
emscripten::val key_qpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nq, ptr_->key_qpos));
|
|
}
|
|
emscripten::val key_qvel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nv, ptr_->key_qvel));
|
|
}
|
|
emscripten::val key_act() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->na, ptr_->key_act));
|
|
}
|
|
emscripten::val key_mpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nmocap*3, ptr_->key_mpos));
|
|
}
|
|
emscripten::val key_mquat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nmocap*4, ptr_->key_mquat));
|
|
}
|
|
emscripten::val key_ctrl() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nkey * ptr_->nu, ptr_->key_ctrl));
|
|
}
|
|
emscripten::val name_bodyadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->name_bodyadr));
|
|
}
|
|
emscripten::val name_jntadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->njnt, ptr_->name_jntadr));
|
|
}
|
|
emscripten::val name_geomadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ngeom, ptr_->name_geomadr));
|
|
}
|
|
emscripten::val name_siteadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsite, ptr_->name_siteadr));
|
|
}
|
|
emscripten::val name_camadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ncam, ptr_->name_camadr));
|
|
}
|
|
emscripten::val name_lightadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nlight, ptr_->name_lightadr));
|
|
}
|
|
emscripten::val name_flexadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nflex, ptr_->name_flexadr));
|
|
}
|
|
emscripten::val name_meshadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmesh, ptr_->name_meshadr));
|
|
}
|
|
emscripten::val name_skinadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nskin, ptr_->name_skinadr));
|
|
}
|
|
emscripten::val name_hfieldadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nhfield, ptr_->name_hfieldadr));
|
|
}
|
|
emscripten::val name_texadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntex, ptr_->name_texadr));
|
|
}
|
|
emscripten::val name_matadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nmat, ptr_->name_matadr));
|
|
}
|
|
emscripten::val name_pairadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npair, ptr_->name_pairadr));
|
|
}
|
|
emscripten::val name_excludeadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nexclude, ptr_->name_excludeadr));
|
|
}
|
|
emscripten::val name_eqadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->neq, ptr_->name_eqadr));
|
|
}
|
|
emscripten::val name_tendonadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntendon, ptr_->name_tendonadr));
|
|
}
|
|
emscripten::val name_actuatoradr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nactuator, ptr_->name_actuatoradr));
|
|
}
|
|
emscripten::val name_sensoradr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nsensor, ptr_->name_sensoradr));
|
|
}
|
|
emscripten::val name_numericadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nnumeric, ptr_->name_numericadr));
|
|
}
|
|
emscripten::val name_textadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntext, ptr_->name_textadr));
|
|
}
|
|
emscripten::val name_tupleadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->ntuple, ptr_->name_tupleadr));
|
|
}
|
|
emscripten::val name_keyadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nkey, ptr_->name_keyadr));
|
|
}
|
|
emscripten::val name_pluginadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nplugin, ptr_->name_pluginadr));
|
|
}
|
|
emscripten::val names() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nnames, ptr_->names));
|
|
}
|
|
emscripten::val names_map() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nnames_map, ptr_->names_map));
|
|
}
|
|
emscripten::val paths() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->npaths, ptr_->paths));
|
|
}
|
|
emscripten::val B_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->B_rownnz));
|
|
}
|
|
emscripten::val B_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nbody, ptr_->B_rowadr));
|
|
}
|
|
emscripten::val B_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nB, ptr_->B_colind));
|
|
}
|
|
emscripten::val M_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->M_rownnz));
|
|
}
|
|
emscripten::val M_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->M_rowadr));
|
|
}
|
|
emscripten::val M_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nC, ptr_->M_colind));
|
|
}
|
|
emscripten::val mapM2M() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nC, ptr_->mapM2M));
|
|
}
|
|
emscripten::val D_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->D_rownnz));
|
|
}
|
|
emscripten::val D_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->D_rowadr));
|
|
}
|
|
emscripten::val D_diag() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nv, ptr_->D_diag));
|
|
}
|
|
emscripten::val D_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nD, ptr_->D_colind));
|
|
}
|
|
emscripten::val mapM2D() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nD, ptr_->mapM2D));
|
|
}
|
|
emscripten::val mapD2M() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nC, ptr_->mapD2M));
|
|
}
|
|
uint64_t signature() const {
|
|
return ptr_->signature;
|
|
}
|
|
void set_signature(uint64_t value) {
|
|
ptr_->signature = value;
|
|
}
|
|
// Generates functions to return accessor classes.
|
|
#define X_ACCESSOR(NAME, Name, OBJTYPE, accessor_name, nfield) \
|
|
MjModel##Name##Accessor accessor_name(const NumberOrString& val) const { \
|
|
if (val.isString()) { \
|
|
int id = mj_name2id(ptr_, OBJTYPE, val.as<std::string>().c_str()); \
|
|
if (id == -1) { \
|
|
mju_error("%s", KeyErrorMessage(ptr_, OBJTYPE, ptr_->nfield, val.as<std::string>(), #accessor_name).c_str()); \
|
|
} \
|
|
return MjModel##Name##Accessor(ptr_, id); \
|
|
} else if (val.isNumber()) { \
|
|
int id = val.as<int>(); \
|
|
if (id < 0 || id >= ptr_->nfield) { \
|
|
mju_error("%s", IndexErrorMessage(id, ptr_->nfield, #accessor_name).c_str()); \
|
|
} \
|
|
return MjModel##Name##Accessor(ptr_, id); \
|
|
} else { \
|
|
mju_error(#accessor_name "() argument must be a string or number"); \
|
|
return MjModel##Name##Accessor(nullptr, 0); \
|
|
} \
|
|
}
|
|
|
|
MJMODEL_ACCESSORS
|
|
#undef X_ACCESSOR
|
|
|
|
private:
|
|
mjModel* ptr_;
|
|
|
|
public:
|
|
MjOption opt;
|
|
MjVisual vis;
|
|
MjStatistic stat;
|
|
};
|
|
|
|
struct MjSpec {
|
|
~MjSpec();
|
|
MjSpec();
|
|
explicit MjSpec(mjSpec *ptr);
|
|
MjSpec(const MjSpec &);
|
|
MjSpec &operator=(const MjSpec &);
|
|
std::unique_ptr<MjSpec> copy();
|
|
mjSpec* get() const;
|
|
void set(mjSpec* ptr);
|
|
emscripten::val timer() const;
|
|
mjString modelname() const {
|
|
return (ptr_ && ptr_->modelname) ? *(ptr_->modelname) : "";
|
|
}
|
|
void set_modelname(const mjString& value) {
|
|
if (ptr_ && ptr_->modelname) {
|
|
*(ptr_->modelname) = value;
|
|
}
|
|
}
|
|
mjtBool strippath() const {
|
|
return ptr_->strippath;
|
|
}
|
|
void set_strippath(mjtBool value) {
|
|
ptr_->strippath = value;
|
|
}
|
|
int memory() const {
|
|
return static_cast<int>(ptr_->memory);
|
|
}
|
|
void set_memory(int value) {
|
|
ptr_->memory = static_cast<mjtSize>(value);
|
|
}
|
|
int nemax() const {
|
|
return ptr_->nemax;
|
|
}
|
|
void set_nemax(int value) {
|
|
ptr_->nemax = value;
|
|
}
|
|
int nuserdata() const {
|
|
return ptr_->nuserdata;
|
|
}
|
|
void set_nuserdata(int value) {
|
|
ptr_->nuserdata = value;
|
|
}
|
|
int nuser_body() const {
|
|
return ptr_->nuser_body;
|
|
}
|
|
void set_nuser_body(int value) {
|
|
ptr_->nuser_body = value;
|
|
}
|
|
int nuser_jnt() const {
|
|
return ptr_->nuser_jnt;
|
|
}
|
|
void set_nuser_jnt(int value) {
|
|
ptr_->nuser_jnt = value;
|
|
}
|
|
int nuser_geom() const {
|
|
return ptr_->nuser_geom;
|
|
}
|
|
void set_nuser_geom(int value) {
|
|
ptr_->nuser_geom = value;
|
|
}
|
|
int nuser_site() const {
|
|
return ptr_->nuser_site;
|
|
}
|
|
void set_nuser_site(int value) {
|
|
ptr_->nuser_site = value;
|
|
}
|
|
int nuser_cam() const {
|
|
return ptr_->nuser_cam;
|
|
}
|
|
void set_nuser_cam(int value) {
|
|
ptr_->nuser_cam = value;
|
|
}
|
|
int nuser_tendon() const {
|
|
return ptr_->nuser_tendon;
|
|
}
|
|
void set_nuser_tendon(int value) {
|
|
ptr_->nuser_tendon = value;
|
|
}
|
|
int nuser_actuator() const {
|
|
return ptr_->nuser_actuator;
|
|
}
|
|
void set_nuser_actuator(int value) {
|
|
ptr_->nuser_actuator = value;
|
|
}
|
|
int nuser_sensor() const {
|
|
return ptr_->nuser_sensor;
|
|
}
|
|
void set_nuser_sensor(int value) {
|
|
ptr_->nuser_sensor = value;
|
|
}
|
|
int nkey() const {
|
|
return ptr_->nkey;
|
|
}
|
|
void set_nkey(int value) {
|
|
ptr_->nkey = value;
|
|
}
|
|
int njmax() const {
|
|
return ptr_->njmax;
|
|
}
|
|
void set_njmax(int value) {
|
|
ptr_->njmax = value;
|
|
}
|
|
int nconmax() const {
|
|
return ptr_->nconmax;
|
|
}
|
|
void set_nconmax(int value) {
|
|
ptr_->nconmax = value;
|
|
}
|
|
int nstack() const {
|
|
return static_cast<int>(ptr_->nstack);
|
|
}
|
|
void set_nstack(int value) {
|
|
ptr_->nstack = static_cast<mjtSize>(value);
|
|
}
|
|
mjString comment() const {
|
|
return (ptr_ && ptr_->comment) ? *(ptr_->comment) : "";
|
|
}
|
|
void set_comment(const mjString& value) {
|
|
if (ptr_ && ptr_->comment) {
|
|
*(ptr_->comment) = value;
|
|
}
|
|
}
|
|
mjString modelfiledir() const {
|
|
return (ptr_ && ptr_->modelfiledir) ? *(ptr_->modelfiledir) : "";
|
|
}
|
|
void set_modelfiledir(const mjString& value) {
|
|
if (ptr_ && ptr_->modelfiledir) {
|
|
*(ptr_->modelfiledir) = value;
|
|
}
|
|
}
|
|
mjtBool hasImplicitPluginElem() const {
|
|
return ptr_->hasImplicitPluginElem;
|
|
}
|
|
void set_hasImplicitPluginElem(mjtBool value) {
|
|
ptr_->hasImplicitPluginElem = value;
|
|
}
|
|
|
|
private:
|
|
mjSpec* ptr_;
|
|
bool owned_ = false;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsCompiler compiler;
|
|
MjOption option;
|
|
MjVisual visual;
|
|
MjStatistic stat;
|
|
MjsAuthored authored;
|
|
};
|
|
|
|
struct MjsActuator {
|
|
explicit MjsActuator(mjsActuator *ptr);
|
|
mjsActuator* get() const;
|
|
void set(mjsActuator* ptr);
|
|
mjtGain gaintype() const {
|
|
return ptr_->gaintype;
|
|
}
|
|
void set_gaintype(mjtGain value) {
|
|
ptr_->gaintype = value;
|
|
}
|
|
emscripten::val gainprm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(10, ptr_->gainprm));
|
|
}
|
|
mjtBias biastype() const {
|
|
return ptr_->biastype;
|
|
}
|
|
void set_biastype(mjtBias value) {
|
|
ptr_->biastype = value;
|
|
}
|
|
emscripten::val biasprm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(10, ptr_->biasprm));
|
|
}
|
|
mjtDyn dyntype() const {
|
|
return ptr_->dyntype;
|
|
}
|
|
void set_dyntype(mjtDyn value) {
|
|
ptr_->dyntype = value;
|
|
}
|
|
emscripten::val dynprm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(10, ptr_->dynprm));
|
|
}
|
|
int actdim() const {
|
|
return ptr_->actdim;
|
|
}
|
|
void set_actdim(int value) {
|
|
ptr_->actdim = value;
|
|
}
|
|
mjtBool actearly() const {
|
|
return ptr_->actearly;
|
|
}
|
|
void set_actearly(mjtBool value) {
|
|
ptr_->actearly = value;
|
|
}
|
|
mjtTrn trntype() const {
|
|
return ptr_->trntype;
|
|
}
|
|
void set_trntype(mjtTrn value) {
|
|
ptr_->trntype = value;
|
|
}
|
|
emscripten::val gear() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->gear));
|
|
}
|
|
mjString target() const {
|
|
return (ptr_ && ptr_->target) ? *(ptr_->target) : "";
|
|
}
|
|
void set_target(const mjString& value) {
|
|
if (ptr_ && ptr_->target) {
|
|
*(ptr_->target) = value;
|
|
}
|
|
}
|
|
mjString refsite() const {
|
|
return (ptr_ && ptr_->refsite) ? *(ptr_->refsite) : "";
|
|
}
|
|
void set_refsite(const mjString& value) {
|
|
if (ptr_ && ptr_->refsite) {
|
|
*(ptr_->refsite) = value;
|
|
}
|
|
}
|
|
mjString slidersite() const {
|
|
return (ptr_ && ptr_->slidersite) ? *(ptr_->slidersite) : "";
|
|
}
|
|
void set_slidersite(const mjString& value) {
|
|
if (ptr_ && ptr_->slidersite) {
|
|
*(ptr_->slidersite) = value;
|
|
}
|
|
}
|
|
double cranklength() const {
|
|
return ptr_->cranklength;
|
|
}
|
|
void set_cranklength(double value) {
|
|
ptr_->cranklength = value;
|
|
}
|
|
emscripten::val lengthrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->lengthrange));
|
|
}
|
|
double inheritrange() const {
|
|
return ptr_->inheritrange;
|
|
}
|
|
void set_inheritrange(double value) {
|
|
ptr_->inheritrange = value;
|
|
}
|
|
emscripten::val damping() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->damping));
|
|
}
|
|
double armature() const {
|
|
return ptr_->armature;
|
|
}
|
|
void set_armature(double value) {
|
|
ptr_->armature = value;
|
|
}
|
|
mjtLimited ctrllimited() const {
|
|
return ptr_->ctrllimited;
|
|
}
|
|
void set_ctrllimited(mjtLimited value) {
|
|
ptr_->ctrllimited = value;
|
|
}
|
|
emscripten::val ctrlrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->ctrlrange));
|
|
}
|
|
mjtLimited forcelimited() const {
|
|
return ptr_->forcelimited;
|
|
}
|
|
void set_forcelimited(mjtLimited value) {
|
|
ptr_->forcelimited = value;
|
|
}
|
|
emscripten::val forcerange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->forcerange));
|
|
}
|
|
mjtLimited actlimited() const {
|
|
return ptr_->actlimited;
|
|
}
|
|
void set_actlimited(mjtLimited value) {
|
|
ptr_->actlimited = value;
|
|
}
|
|
emscripten::val actrange() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->actrange));
|
|
}
|
|
int group() const {
|
|
return ptr_->group;
|
|
}
|
|
void set_group(int value) {
|
|
ptr_->group = value;
|
|
}
|
|
int nsample() const {
|
|
return ptr_->nsample;
|
|
}
|
|
void set_nsample(int value) {
|
|
ptr_->nsample = value;
|
|
}
|
|
int interp() const {
|
|
return ptr_->interp;
|
|
}
|
|
void set_interp(int value) {
|
|
ptr_->interp = value;
|
|
}
|
|
double delay() const {
|
|
return ptr_->delay;
|
|
}
|
|
void set_delay(double value) {
|
|
ptr_->delay = value;
|
|
}
|
|
mjDoubleVec &userdata() const {
|
|
return *(ptr_->userdata);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsActuator* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsPlugin plugin;
|
|
};
|
|
|
|
struct MjsBody {
|
|
explicit MjsBody(mjsBody *ptr);
|
|
mjsBody* get() const;
|
|
void set(mjsBody* ptr);
|
|
mjString childclass() const {
|
|
return (ptr_ && ptr_->childclass) ? *(ptr_->childclass) : "";
|
|
}
|
|
void set_childclass(const mjString& value) {
|
|
if (ptr_ && ptr_->childclass) {
|
|
*(ptr_->childclass) = value;
|
|
}
|
|
}
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
|
|
}
|
|
double mass() const {
|
|
return ptr_->mass;
|
|
}
|
|
void set_mass(double value) {
|
|
ptr_->mass = value;
|
|
}
|
|
emscripten::val ipos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->ipos));
|
|
}
|
|
emscripten::val iquat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->iquat));
|
|
}
|
|
emscripten::val inertia() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->inertia));
|
|
}
|
|
emscripten::val fullinertia() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->fullinertia));
|
|
}
|
|
mjtBool mocap() const {
|
|
return ptr_->mocap;
|
|
}
|
|
void set_mocap(mjtBool value) {
|
|
ptr_->mocap = value;
|
|
}
|
|
double gravcomp() const {
|
|
return ptr_->gravcomp;
|
|
}
|
|
void set_gravcomp(double value) {
|
|
ptr_->gravcomp = value;
|
|
}
|
|
mjtSleepPolicy sleep() const {
|
|
return ptr_->sleep;
|
|
}
|
|
void set_sleep(mjtSleepPolicy value) {
|
|
ptr_->sleep = value;
|
|
}
|
|
mjtByte simple() const {
|
|
return ptr_->simple;
|
|
}
|
|
void set_simple(mjtByte value) {
|
|
ptr_->simple = value;
|
|
}
|
|
mjDoubleVec &userdata() const {
|
|
return *(ptr_->userdata);
|
|
}
|
|
mjtBool explicitinertial() const {
|
|
return ptr_->explicitinertial;
|
|
}
|
|
void set_explicitinertial(mjtBool value) {
|
|
ptr_->explicitinertial = value;
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsBody* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsOrientation alt;
|
|
MjsOrientation ialt;
|
|
MjsPlugin plugin;
|
|
};
|
|
|
|
struct MjsGeom {
|
|
explicit MjsGeom(mjsGeom *ptr);
|
|
mjsGeom* get() const;
|
|
void set(mjsGeom* ptr);
|
|
mjtGeom type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(mjtGeom value) {
|
|
ptr_->type = value;
|
|
}
|
|
emscripten::val pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->pos));
|
|
}
|
|
emscripten::val quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->quat));
|
|
}
|
|
emscripten::val fromto() const {
|
|
return emscripten::val(emscripten::typed_memory_view(6, ptr_->fromto));
|
|
}
|
|
emscripten::val size() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->size));
|
|
}
|
|
int contype() const {
|
|
return ptr_->contype;
|
|
}
|
|
void set_contype(int value) {
|
|
ptr_->contype = value;
|
|
}
|
|
int conaffinity() const {
|
|
return ptr_->conaffinity;
|
|
}
|
|
void set_conaffinity(int value) {
|
|
ptr_->conaffinity = value;
|
|
}
|
|
int condim() const {
|
|
return ptr_->condim;
|
|
}
|
|
void set_condim(int value) {
|
|
ptr_->condim = value;
|
|
}
|
|
int priority() const {
|
|
return ptr_->priority;
|
|
}
|
|
void set_priority(int value) {
|
|
ptr_->priority = value;
|
|
}
|
|
emscripten::val friction() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->friction));
|
|
}
|
|
double solmix() const {
|
|
return ptr_->solmix;
|
|
}
|
|
void set_solmix(double value) {
|
|
ptr_->solmix = value;
|
|
}
|
|
emscripten::val solref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solref));
|
|
}
|
|
emscripten::val solimp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->solimp));
|
|
}
|
|
double margin() const {
|
|
return ptr_->margin;
|
|
}
|
|
void set_margin(double value) {
|
|
ptr_->margin = value;
|
|
}
|
|
double gap() const {
|
|
return ptr_->gap;
|
|
}
|
|
void set_gap(double value) {
|
|
ptr_->gap = value;
|
|
}
|
|
double mass() const {
|
|
return ptr_->mass;
|
|
}
|
|
void set_mass(double value) {
|
|
ptr_->mass = value;
|
|
}
|
|
double density() const {
|
|
return ptr_->density;
|
|
}
|
|
void set_density(double value) {
|
|
ptr_->density = value;
|
|
}
|
|
mjtGeomInertia typeinertia() const {
|
|
return ptr_->typeinertia;
|
|
}
|
|
void set_typeinertia(mjtGeomInertia value) {
|
|
ptr_->typeinertia = value;
|
|
}
|
|
mjtNum fluid_ellipsoid() const {
|
|
return ptr_->fluid_ellipsoid;
|
|
}
|
|
void set_fluid_ellipsoid(mjtNum value) {
|
|
ptr_->fluid_ellipsoid = value;
|
|
}
|
|
emscripten::val fluid_coefs() const {
|
|
return emscripten::val(emscripten::typed_memory_view(5, ptr_->fluid_coefs));
|
|
}
|
|
mjString material() const {
|
|
return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
|
|
}
|
|
void set_material(const mjString& value) {
|
|
if (ptr_ && ptr_->material) {
|
|
*(ptr_->material) = value;
|
|
}
|
|
}
|
|
emscripten::val rgba() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->rgba));
|
|
}
|
|
int group() const {
|
|
return ptr_->group;
|
|
}
|
|
void set_group(int value) {
|
|
ptr_->group = value;
|
|
}
|
|
mjString hfieldname() const {
|
|
return (ptr_ && ptr_->hfieldname) ? *(ptr_->hfieldname) : "";
|
|
}
|
|
void set_hfieldname(const mjString& value) {
|
|
if (ptr_ && ptr_->hfieldname) {
|
|
*(ptr_->hfieldname) = value;
|
|
}
|
|
}
|
|
mjString meshname() const {
|
|
return (ptr_ && ptr_->meshname) ? *(ptr_->meshname) : "";
|
|
}
|
|
void set_meshname(const mjString& value) {
|
|
if (ptr_ && ptr_->meshname) {
|
|
*(ptr_->meshname) = value;
|
|
}
|
|
}
|
|
double fitscale() const {
|
|
return ptr_->fitscale;
|
|
}
|
|
void set_fitscale(double value) {
|
|
ptr_->fitscale = value;
|
|
}
|
|
mjDoubleVec &userdata() const {
|
|
return *(ptr_->userdata);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsGeom* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsOrientation alt;
|
|
MjsPlugin plugin;
|
|
};
|
|
|
|
struct MjsMesh {
|
|
explicit MjsMesh(mjsMesh *ptr);
|
|
mjsMesh* get() const;
|
|
void set(mjsMesh* ptr);
|
|
mjString content_type() const {
|
|
return (ptr_ && ptr_->content_type) ? *(ptr_->content_type) : "";
|
|
}
|
|
void set_content_type(const mjString& value) {
|
|
if (ptr_ && ptr_->content_type) {
|
|
*(ptr_->content_type) = value;
|
|
}
|
|
}
|
|
mjString file() const {
|
|
return (ptr_ && ptr_->file) ? *(ptr_->file) : "";
|
|
}
|
|
void set_file(const mjString& value) {
|
|
if (ptr_ && ptr_->file) {
|
|
*(ptr_->file) = value;
|
|
}
|
|
}
|
|
emscripten::val refpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->refpos));
|
|
}
|
|
emscripten::val refquat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->refquat));
|
|
}
|
|
emscripten::val scale() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->scale));
|
|
}
|
|
mjtMeshInertia inertia() const {
|
|
return ptr_->inertia;
|
|
}
|
|
void set_inertia(mjtMeshInertia value) {
|
|
ptr_->inertia = value;
|
|
}
|
|
mjtBool smoothnormal() const {
|
|
return ptr_->smoothnormal;
|
|
}
|
|
void set_smoothnormal(mjtBool value) {
|
|
ptr_->smoothnormal = value;
|
|
}
|
|
mjtBool needsdf() const {
|
|
return ptr_->needsdf;
|
|
}
|
|
void set_needsdf(mjtBool value) {
|
|
ptr_->needsdf = value;
|
|
}
|
|
int maxhullvert() const {
|
|
return ptr_->maxhullvert;
|
|
}
|
|
void set_maxhullvert(int value) {
|
|
ptr_->maxhullvert = value;
|
|
}
|
|
mjFloatVec &uservert() const {
|
|
return *(ptr_->uservert);
|
|
}
|
|
mjFloatVec &usernormal() const {
|
|
return *(ptr_->usernormal);
|
|
}
|
|
mjFloatVec &usertexcoord() const {
|
|
return *(ptr_->usertexcoord);
|
|
}
|
|
mjIntVec &userface() const {
|
|
return *(ptr_->userface);
|
|
}
|
|
mjIntVec &userfacenormal() const {
|
|
return *(ptr_->userfacenormal);
|
|
}
|
|
mjIntVec &userfacetexcoord() const {
|
|
return *(ptr_->userfacetexcoord);
|
|
}
|
|
mjString material() const {
|
|
return (ptr_ && ptr_->material) ? *(ptr_->material) : "";
|
|
}
|
|
void set_material(const mjString& value) {
|
|
if (ptr_ && ptr_->material) {
|
|
*(ptr_->material) = value;
|
|
}
|
|
}
|
|
int octree_maxdepth() const {
|
|
return ptr_->octree_maxdepth;
|
|
}
|
|
void set_octree_maxdepth(int value) {
|
|
ptr_->octree_maxdepth = value;
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsMesh* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsPlugin plugin;
|
|
};
|
|
|
|
struct MjsSensor {
|
|
explicit MjsSensor(mjsSensor *ptr);
|
|
mjsSensor* get() const;
|
|
void set(mjsSensor* ptr);
|
|
mjtSensor type() const {
|
|
return ptr_->type;
|
|
}
|
|
void set_type(mjtSensor value) {
|
|
ptr_->type = value;
|
|
}
|
|
mjtObj objtype() const {
|
|
return ptr_->objtype;
|
|
}
|
|
void set_objtype(mjtObj value) {
|
|
ptr_->objtype = value;
|
|
}
|
|
mjString objname() const {
|
|
return (ptr_ && ptr_->objname) ? *(ptr_->objname) : "";
|
|
}
|
|
void set_objname(const mjString& value) {
|
|
if (ptr_ && ptr_->objname) {
|
|
*(ptr_->objname) = value;
|
|
}
|
|
}
|
|
mjtObj reftype() const {
|
|
return ptr_->reftype;
|
|
}
|
|
void set_reftype(mjtObj value) {
|
|
ptr_->reftype = value;
|
|
}
|
|
mjString refname() const {
|
|
return (ptr_ && ptr_->refname) ? *(ptr_->refname) : "";
|
|
}
|
|
void set_refname(const mjString& value) {
|
|
if (ptr_ && ptr_->refname) {
|
|
*(ptr_->refname) = value;
|
|
}
|
|
}
|
|
emscripten::val intprm() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->intprm));
|
|
}
|
|
mjtDataType datatype() const {
|
|
return ptr_->datatype;
|
|
}
|
|
void set_datatype(mjtDataType value) {
|
|
ptr_->datatype = value;
|
|
}
|
|
mjtStage needstage() const {
|
|
return ptr_->needstage;
|
|
}
|
|
void set_needstage(mjtStage value) {
|
|
ptr_->needstage = value;
|
|
}
|
|
int dim() const {
|
|
return ptr_->dim;
|
|
}
|
|
void set_dim(int value) {
|
|
ptr_->dim = value;
|
|
}
|
|
double cutoff() const {
|
|
return ptr_->cutoff;
|
|
}
|
|
void set_cutoff(double value) {
|
|
ptr_->cutoff = value;
|
|
}
|
|
double noise() const {
|
|
return ptr_->noise;
|
|
}
|
|
void set_noise(double value) {
|
|
ptr_->noise = value;
|
|
}
|
|
int nsample() const {
|
|
return ptr_->nsample;
|
|
}
|
|
void set_nsample(int value) {
|
|
ptr_->nsample = value;
|
|
}
|
|
int interp() const {
|
|
return ptr_->interp;
|
|
}
|
|
void set_interp(int value) {
|
|
ptr_->interp = value;
|
|
}
|
|
double delay() const {
|
|
return ptr_->delay;
|
|
}
|
|
void set_delay(double value) {
|
|
ptr_->delay = value;
|
|
}
|
|
emscripten::val interval() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->interval));
|
|
}
|
|
mjDoubleVec &userdata() const {
|
|
return *(ptr_->userdata);
|
|
}
|
|
mjString info() const {
|
|
return (ptr_ && ptr_->info) ? *(ptr_->info) : "";
|
|
}
|
|
void set_info(const mjString& value) {
|
|
if (ptr_ && ptr_->info) {
|
|
*(ptr_->info) = value;
|
|
}
|
|
}
|
|
|
|
private:
|
|
mjsSensor* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsPlugin plugin;
|
|
};
|
|
|
|
struct MjData {
|
|
~MjData();
|
|
MjData(MjModel *m);
|
|
explicit MjData(const MjModel &, const MjData &);
|
|
std::vector<MjContact> contact() const;
|
|
std::unique_ptr<MjData> copy();
|
|
mjData* get() const;
|
|
void set(mjData* ptr);
|
|
int narena() const {
|
|
return static_cast<int>(ptr_->narena);
|
|
}
|
|
void set_narena(int value) {
|
|
ptr_->narena = static_cast<mjtSize>(value);
|
|
}
|
|
int nbuffer() const {
|
|
return static_cast<int>(ptr_->nbuffer);
|
|
}
|
|
void set_nbuffer(int value) {
|
|
ptr_->nbuffer = static_cast<mjtSize>(value);
|
|
}
|
|
int nplugin() const {
|
|
return ptr_->nplugin;
|
|
}
|
|
void set_nplugin(int value) {
|
|
ptr_->nplugin = value;
|
|
}
|
|
size_t pstack() const {
|
|
return ptr_->pstack;
|
|
}
|
|
void set_pstack(size_t value) {
|
|
ptr_->pstack = value;
|
|
}
|
|
size_t pbase() const {
|
|
return ptr_->pbase;
|
|
}
|
|
void set_pbase(size_t value) {
|
|
ptr_->pbase = value;
|
|
}
|
|
size_t parena() const {
|
|
return ptr_->parena;
|
|
}
|
|
void set_parena(size_t value) {
|
|
ptr_->parena = value;
|
|
}
|
|
uintptr_t threadpool() const {
|
|
return ptr_->threadpool;
|
|
}
|
|
void set_threadpool(uintptr_t value) {
|
|
ptr_->threadpool = value;
|
|
}
|
|
mjtBool threadlock() const {
|
|
return ptr_->threadlock;
|
|
}
|
|
void set_threadlock(mjtBool value) {
|
|
ptr_->threadlock = value;
|
|
}
|
|
int maxuse_stack() const {
|
|
return static_cast<int>(ptr_->maxuse_stack);
|
|
}
|
|
void set_maxuse_stack(int value) {
|
|
ptr_->maxuse_stack = static_cast<mjtSize>(value);
|
|
}
|
|
int maxuse_arena() const {
|
|
return static_cast<int>(ptr_->maxuse_arena);
|
|
}
|
|
void set_maxuse_arena(int value) {
|
|
ptr_->maxuse_arena = static_cast<mjtSize>(value);
|
|
}
|
|
int maxuse_con() const {
|
|
return ptr_->maxuse_con;
|
|
}
|
|
void set_maxuse_con(int value) {
|
|
ptr_->maxuse_con = value;
|
|
}
|
|
int maxuse_efc() const {
|
|
return ptr_->maxuse_efc;
|
|
}
|
|
void set_maxuse_efc(int value) {
|
|
ptr_->maxuse_efc = value;
|
|
}
|
|
emscripten::val solver_niter() const {
|
|
return emscripten::val(emscripten::typed_memory_view(20, ptr_->solver_niter));
|
|
}
|
|
emscripten::val solver_nnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(20, ptr_->solver_nnz));
|
|
}
|
|
emscripten::val solver_fwdinv() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->solver_fwdinv));
|
|
}
|
|
int ncon() const {
|
|
return ptr_->ncon;
|
|
}
|
|
void set_ncon(int value) {
|
|
ptr_->ncon = value;
|
|
}
|
|
int ne() const {
|
|
return ptr_->ne;
|
|
}
|
|
void set_ne(int value) {
|
|
ptr_->ne = value;
|
|
}
|
|
int nf() const {
|
|
return ptr_->nf;
|
|
}
|
|
void set_nf(int value) {
|
|
ptr_->nf = value;
|
|
}
|
|
int nl() const {
|
|
return ptr_->nl;
|
|
}
|
|
void set_nl(int value) {
|
|
ptr_->nl = value;
|
|
}
|
|
int nefc() const {
|
|
return ptr_->nefc;
|
|
}
|
|
void set_nefc(int value) {
|
|
ptr_->nefc = value;
|
|
}
|
|
int nJ() const {
|
|
return ptr_->nJ;
|
|
}
|
|
void set_nJ(int value) {
|
|
ptr_->nJ = value;
|
|
}
|
|
int efm_active() const {
|
|
return ptr_->efm_active;
|
|
}
|
|
void set_efm_active(int value) {
|
|
ptr_->efm_active = value;
|
|
}
|
|
int nefmK() const {
|
|
return ptr_->nefmK;
|
|
}
|
|
void set_nefmK(int value) {
|
|
ptr_->nefmK = value;
|
|
}
|
|
int nefmdof() const {
|
|
return ptr_->nefmdof;
|
|
}
|
|
void set_nefmdof(int value) {
|
|
ptr_->nefmdof = value;
|
|
}
|
|
int nefmL() const {
|
|
return ptr_->nefmL;
|
|
}
|
|
void set_nefmL(int value) {
|
|
ptr_->nefmL = value;
|
|
}
|
|
int nY() const {
|
|
return ptr_->nY;
|
|
}
|
|
void set_nY(int value) {
|
|
ptr_->nY = value;
|
|
}
|
|
int nA() const {
|
|
return ptr_->nA;
|
|
}
|
|
void set_nA(int value) {
|
|
ptr_->nA = value;
|
|
}
|
|
int nisland() const {
|
|
return ptr_->nisland;
|
|
}
|
|
void set_nisland(int value) {
|
|
ptr_->nisland = value;
|
|
}
|
|
int nidof() const {
|
|
return ptr_->nidof;
|
|
}
|
|
void set_nidof(int value) {
|
|
ptr_->nidof = value;
|
|
}
|
|
int ntree_awake() const {
|
|
return ptr_->ntree_awake;
|
|
}
|
|
void set_ntree_awake(int value) {
|
|
ptr_->ntree_awake = value;
|
|
}
|
|
int nbody_awake() const {
|
|
return ptr_->nbody_awake;
|
|
}
|
|
void set_nbody_awake(int value) {
|
|
ptr_->nbody_awake = value;
|
|
}
|
|
int nparent_awake() const {
|
|
return ptr_->nparent_awake;
|
|
}
|
|
void set_nparent_awake(int value) {
|
|
ptr_->nparent_awake = value;
|
|
}
|
|
int nv_awake() const {
|
|
return ptr_->nv_awake;
|
|
}
|
|
void set_nv_awake(int value) {
|
|
ptr_->nv_awake = value;
|
|
}
|
|
mjtBool flg_energypos() const {
|
|
return ptr_->flg_energypos;
|
|
}
|
|
void set_flg_energypos(mjtBool value) {
|
|
ptr_->flg_energypos = value;
|
|
}
|
|
mjtBool flg_energyvel() const {
|
|
return ptr_->flg_energyvel;
|
|
}
|
|
void set_flg_energyvel(mjtBool value) {
|
|
ptr_->flg_energyvel = value;
|
|
}
|
|
mjtBool flg_subtreevel() const {
|
|
return ptr_->flg_subtreevel;
|
|
}
|
|
void set_flg_subtreevel(mjtBool value) {
|
|
ptr_->flg_subtreevel = value;
|
|
}
|
|
mjtBool flg_rnepost() const {
|
|
return ptr_->flg_rnepost;
|
|
}
|
|
void set_flg_rnepost(mjtBool value) {
|
|
ptr_->flg_rnepost = value;
|
|
}
|
|
mjtNum time() const {
|
|
return ptr_->time;
|
|
}
|
|
void set_time(mjtNum value) {
|
|
ptr_->time = value;
|
|
}
|
|
emscripten::val energy() const {
|
|
return emscripten::val(emscripten::typed_memory_view(2, ptr_->energy));
|
|
}
|
|
emscripten::val buffer() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbuffer, static_cast<uint8_t*>(ptr_->buffer)));
|
|
}
|
|
emscripten::val arena() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->narena, static_cast<uint8_t*>(ptr_->arena)));
|
|
}
|
|
emscripten::val qpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nq, ptr_->qpos));
|
|
}
|
|
emscripten::val qvel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qvel));
|
|
}
|
|
emscripten::val act() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->na, ptr_->act));
|
|
}
|
|
emscripten::val history() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nhistory, ptr_->history));
|
|
}
|
|
emscripten::val qacc_warmstart() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qacc_warmstart));
|
|
}
|
|
emscripten::val plugin_state() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->npluginstate, ptr_->plugin_state));
|
|
}
|
|
emscripten::val ctrl() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nu, ptr_->ctrl));
|
|
}
|
|
emscripten::val qfrc_applied() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_applied));
|
|
}
|
|
emscripten::val xfrc_applied() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->xfrc_applied));
|
|
}
|
|
emscripten::val eq_active() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->neq, ptr_->eq_active));
|
|
}
|
|
emscripten::val mocap_pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nmocap * 3, ptr_->mocap_pos));
|
|
}
|
|
emscripten::val mocap_quat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nmocap * 4, ptr_->mocap_quat));
|
|
}
|
|
emscripten::val qacc() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qacc));
|
|
}
|
|
emscripten::val act_dot() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->na, ptr_->act_dot));
|
|
}
|
|
emscripten::val userdata() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nuserdata, ptr_->userdata));
|
|
}
|
|
emscripten::val sensordata() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nsensordata, ptr_->sensordata));
|
|
}
|
|
emscripten::val tree_asleep() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ntree, ptr_->tree_asleep));
|
|
}
|
|
emscripten::val plugin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nplugin, ptr_->plugin));
|
|
}
|
|
emscripten::val plugin_data() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nplugin, ptr_->plugin_data));
|
|
}
|
|
emscripten::val xpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->xpos));
|
|
}
|
|
emscripten::val xquat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 4, ptr_->xquat));
|
|
}
|
|
emscripten::val xmat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 9, ptr_->xmat));
|
|
}
|
|
emscripten::val xipos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->xipos));
|
|
}
|
|
emscripten::val ximat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 9, ptr_->ximat));
|
|
}
|
|
emscripten::val xanchor() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->njnt * 3, ptr_->xanchor));
|
|
}
|
|
emscripten::val xaxis() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->njnt * 3, ptr_->xaxis));
|
|
}
|
|
emscripten::val geom_xpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ngeom * 3, ptr_->geom_xpos));
|
|
}
|
|
emscripten::val geom_xmat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ngeom * 9, ptr_->geom_xmat));
|
|
}
|
|
emscripten::val site_xpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nsite * 3, ptr_->site_xpos));
|
|
}
|
|
emscripten::val site_xmat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nsite * 9, ptr_->site_xmat));
|
|
}
|
|
emscripten::val cam_xpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ncam * 3, ptr_->cam_xpos));
|
|
}
|
|
emscripten::val cam_xmat() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ncam * 9, ptr_->cam_xmat));
|
|
}
|
|
emscripten::val light_xpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nlight * 3, ptr_->light_xpos));
|
|
}
|
|
emscripten::val light_xdir() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nlight * 3, ptr_->light_xdir));
|
|
}
|
|
emscripten::val subtree_com() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->subtree_com));
|
|
}
|
|
emscripten::val cdof() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv * 6, ptr_->cdof));
|
|
}
|
|
emscripten::val cinert() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 10, ptr_->cinert));
|
|
}
|
|
emscripten::val flexvert_xpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nflexvert * 3, ptr_->flexvert_xpos));
|
|
}
|
|
emscripten::val flexelem_aabb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nflexelem * 6, ptr_->flexelem_aabb));
|
|
}
|
|
emscripten::val flexelem_krot() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nflexstiffness, ptr_->flexelem_krot));
|
|
}
|
|
emscripten::val flexedge_J() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nJfe, ptr_->flexedge_J));
|
|
}
|
|
emscripten::val flexedge_length() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nflexedge, ptr_->flexedge_length));
|
|
}
|
|
emscripten::val flexvert_J() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nJfv * 2, ptr_->flexvert_J));
|
|
}
|
|
emscripten::val flexvert_length() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nflexvert * 2, ptr_->flexvert_length));
|
|
}
|
|
emscripten::val bvh_aabb_dyn() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbvhdynamic * 6, ptr_->bvh_aabb_dyn));
|
|
}
|
|
emscripten::val ten_wrapadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->ten_wrapadr));
|
|
}
|
|
emscripten::val ten_wrapnum() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->ten_wrapnum));
|
|
}
|
|
emscripten::val ten_J() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nJten, ptr_->ten_J));
|
|
}
|
|
emscripten::val ten_length() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->ten_length));
|
|
}
|
|
emscripten::val wrap_obj() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nwrap * 2, ptr_->wrap_obj));
|
|
}
|
|
emscripten::val wrap_xpos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nwrap * 6, ptr_->wrap_xpos));
|
|
}
|
|
emscripten::val actuator_length() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->actuator_length));
|
|
}
|
|
emscripten::val moment_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->moment_rownnz));
|
|
}
|
|
emscripten::val moment_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->moment_rowadr));
|
|
}
|
|
emscripten::val moment_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nJmom, ptr_->moment_colind));
|
|
}
|
|
emscripten::val actuator_moment() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nJmom, ptr_->actuator_moment));
|
|
}
|
|
emscripten::val crb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 10, ptr_->crb));
|
|
}
|
|
emscripten::val M() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nC, ptr_->M));
|
|
}
|
|
emscripten::val qLD() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nC, ptr_->qLD));
|
|
}
|
|
emscripten::val qLDiagInv() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qLDiagInv));
|
|
}
|
|
emscripten::val bvh_active() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbvh, ptr_->bvh_active));
|
|
}
|
|
emscripten::val tree_awake() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ntree, ptr_->tree_awake));
|
|
}
|
|
emscripten::val body_awake() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody, ptr_->body_awake));
|
|
}
|
|
emscripten::val body_awake_ind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody, ptr_->body_awake_ind));
|
|
}
|
|
emscripten::val parent_awake_ind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody, ptr_->parent_awake_ind));
|
|
}
|
|
emscripten::val dof_awake_ind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->dof_awake_ind));
|
|
}
|
|
emscripten::val flexedge_velocity() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nflexedge, ptr_->flexedge_velocity));
|
|
}
|
|
emscripten::val ten_velocity() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->ten_velocity));
|
|
}
|
|
emscripten::val actuator_velocity() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->actuator_velocity));
|
|
}
|
|
emscripten::val cvel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->cvel));
|
|
}
|
|
emscripten::val cdof_dot() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv * 6, ptr_->cdof_dot));
|
|
}
|
|
emscripten::val qfrc_bias() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_bias));
|
|
}
|
|
emscripten::val qfrc_spring() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_spring));
|
|
}
|
|
emscripten::val qfrc_damper() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_damper));
|
|
}
|
|
emscripten::val qfrc_gravcomp() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_gravcomp));
|
|
}
|
|
emscripten::val qfrc_fluid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_fluid));
|
|
}
|
|
emscripten::val qfrc_passive() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_passive));
|
|
}
|
|
emscripten::val subtree_linvel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->subtree_linvel));
|
|
}
|
|
emscripten::val subtree_angmom() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 3, ptr_->subtree_angmom));
|
|
}
|
|
emscripten::val qH() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nC, ptr_->qH));
|
|
}
|
|
emscripten::val qHDiagInv() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qHDiagInv));
|
|
}
|
|
emscripten::val qDeriv() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nD, ptr_->qDeriv));
|
|
}
|
|
emscripten::val qLU() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nD, ptr_->qLU));
|
|
}
|
|
emscripten::val actuator_force() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nout, ptr_->actuator_force));
|
|
}
|
|
emscripten::val qfrc_actuator() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_actuator));
|
|
}
|
|
emscripten::val qfrc_smooth() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_smooth));
|
|
}
|
|
emscripten::val qacc_smooth() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qacc_smooth));
|
|
}
|
|
emscripten::val qfrc_constraint() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_constraint));
|
|
}
|
|
emscripten::val qfrc_inverse() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->qfrc_inverse));
|
|
}
|
|
emscripten::val cacc() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->cacc));
|
|
}
|
|
emscripten::val cfrc_int() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->cfrc_int));
|
|
}
|
|
emscripten::val cfrc_ext() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nbody * 6, ptr_->cfrc_ext));
|
|
}
|
|
// contact field is handled manually in template file struct declaration
|
|
emscripten::val efc_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_type));
|
|
}
|
|
emscripten::val efc_id() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_id));
|
|
}
|
|
emscripten::val efc_J_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_J_rownnz));
|
|
}
|
|
emscripten::val efc_J_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_J_rowadr));
|
|
}
|
|
emscripten::val efc_J_rowsuper() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_J_rowsuper));
|
|
}
|
|
emscripten::val efc_J_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nJ, ptr_->efc_J_colind));
|
|
}
|
|
emscripten::val efc_J() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nJ, ptr_->efc_J));
|
|
}
|
|
emscripten::val efc_pos() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_pos));
|
|
}
|
|
emscripten::val efc_margin() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_margin));
|
|
}
|
|
emscripten::val efc_frictionloss() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_frictionloss));
|
|
}
|
|
emscripten::val efc_diagA() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_diagA));
|
|
}
|
|
emscripten::val efc_KBIP() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc * 4, ptr_->efc_KBIP));
|
|
}
|
|
emscripten::val efc_D() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_D));
|
|
}
|
|
emscripten::val efc_R() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_R));
|
|
}
|
|
emscripten::val tendon_efcadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ntendon, ptr_->tendon_efcadr));
|
|
}
|
|
emscripten::val tree_island() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ntree, ptr_->tree_island));
|
|
}
|
|
emscripten::val island_ntree() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_ntree));
|
|
}
|
|
emscripten::val island_itreeadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_itreeadr));
|
|
}
|
|
emscripten::val map_itree2tree() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->ntree, ptr_->map_itree2tree));
|
|
}
|
|
emscripten::val dof_island() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->dof_island));
|
|
}
|
|
emscripten::val island_nv() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_nv));
|
|
}
|
|
emscripten::val island_idofadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_idofadr));
|
|
}
|
|
emscripten::val island_dofadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_dofadr));
|
|
}
|
|
emscripten::val map_dof2idof() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->map_dof2idof));
|
|
}
|
|
emscripten::val map_idof2dof() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->map_idof2dof));
|
|
}
|
|
emscripten::val ifrc_smooth() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nidof, ptr_->ifrc_smooth));
|
|
}
|
|
emscripten::val iacc_smooth() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nidof, ptr_->iacc_smooth));
|
|
}
|
|
emscripten::val iacc() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nidof, ptr_->iacc));
|
|
}
|
|
emscripten::val efc_island() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_island));
|
|
}
|
|
emscripten::val island_ne() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_ne));
|
|
}
|
|
emscripten::val island_nf() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_nf));
|
|
}
|
|
emscripten::val island_nefc() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_nefc));
|
|
}
|
|
emscripten::val island_iefcadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nisland, ptr_->island_iefcadr));
|
|
}
|
|
emscripten::val map_efc2iefc() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->map_efc2iefc));
|
|
}
|
|
emscripten::val map_iefc2efc() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->map_iefc2efc));
|
|
}
|
|
emscripten::val iefc_type() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_type));
|
|
}
|
|
emscripten::val iefc_id() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_id));
|
|
}
|
|
emscripten::val iefc_frictionloss() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_frictionloss));
|
|
}
|
|
emscripten::val iefc_D() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_D));
|
|
}
|
|
emscripten::val iefc_R() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_R));
|
|
}
|
|
emscripten::val efc_Y_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_Y_rownnz));
|
|
}
|
|
emscripten::val efc_Y_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_Y_rowadr));
|
|
}
|
|
emscripten::val efc_Y_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nY, ptr_->efc_Y_colind));
|
|
}
|
|
emscripten::val efc_Y() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nY, ptr_->efc_Y));
|
|
}
|
|
emscripten::val efc_AR_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_AR_rownnz));
|
|
}
|
|
emscripten::val efc_AR_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_AR_rowadr));
|
|
}
|
|
emscripten::val efc_AR_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nA, ptr_->efc_AR_colind));
|
|
}
|
|
emscripten::val efc_AR() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nA, ptr_->efc_AR));
|
|
}
|
|
emscripten::val efc_vel() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_vel));
|
|
}
|
|
emscripten::val efc_aref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_aref));
|
|
}
|
|
emscripten::val efm_c() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->efm_c));
|
|
}
|
|
emscripten::val efm_K_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->efm_K_rownnz));
|
|
}
|
|
emscripten::val efm_K_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(model->nv, ptr_->efm_K_rowadr));
|
|
}
|
|
emscripten::val efm_K_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefmK, ptr_->efm_K_colind));
|
|
}
|
|
emscripten::val efm_K_val() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefmK, ptr_->efm_K_val));
|
|
}
|
|
emscripten::val efm_dofid() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefmdof, ptr_->efm_dofid));
|
|
}
|
|
emscripten::val efm_L_rownnz() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefmdof, ptr_->efm_L_rownnz));
|
|
}
|
|
emscripten::val efm_L_rowadr() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefmdof, ptr_->efm_L_rowadr));
|
|
}
|
|
emscripten::val efm_L_colind() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefmL, ptr_->efm_L_colind));
|
|
}
|
|
emscripten::val efm_L() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefmL, ptr_->efm_L));
|
|
}
|
|
emscripten::val efc_b() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_b));
|
|
}
|
|
emscripten::val iefc_aref() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_aref));
|
|
}
|
|
emscripten::val iefc_state() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_state));
|
|
}
|
|
emscripten::val iefc_force() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->iefc_force));
|
|
}
|
|
emscripten::val efc_state() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_state));
|
|
}
|
|
emscripten::val efc_force() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nefc, ptr_->efc_force));
|
|
}
|
|
emscripten::val ifrc_constraint() const {
|
|
return emscripten::val(emscripten::typed_memory_view(ptr_->nidof, ptr_->ifrc_constraint));
|
|
}
|
|
uint64_t signature() const {
|
|
return ptr_->signature;
|
|
}
|
|
void set_signature(uint64_t value) {
|
|
ptr_->signature = value;
|
|
}
|
|
// Generates functions to return accessor classes.
|
|
#define X_ACCESSOR(NAME, Name, OBJTYPE, accessor_name, nfield) \
|
|
MjData##Name##Accessor accessor_name(const NumberOrString& val) const { \
|
|
if (val.isString()) { \
|
|
int id = mj_name2id(model, OBJTYPE, val.as<std::string>().c_str()); \
|
|
if (id == -1) { \
|
|
mju_error("%s", KeyErrorMessage(model, OBJTYPE, model->nfield, val.as<std::string>(), #accessor_name).c_str()); \
|
|
} \
|
|
return MjData##Name##Accessor(ptr_, model, id); \
|
|
} else if (val.isNumber()) { \
|
|
int id = val.as<int>(); \
|
|
if (id < 0 || id >= model->nfield) { \
|
|
mju_error("%s", IndexErrorMessage(id, model->nfield, #accessor_name).c_str()); \
|
|
} \
|
|
return MjData##Name##Accessor(ptr_, model, id); \
|
|
} else { \
|
|
mju_error(#accessor_name "() argument must be a string or number"); \
|
|
return MjData##Name##Accessor(nullptr, nullptr, 0); \
|
|
} \
|
|
}
|
|
MJDATA_ACCESSORS
|
|
#undef X_ACCESSOR
|
|
|
|
private:
|
|
mjData* ptr_;
|
|
|
|
public:
|
|
std::vector<MjSolverStat> solver;
|
|
std::vector<MjWarningStat> warning;
|
|
std::vector<MjTimerStat> timer;
|
|
mjModel *model;
|
|
};
|
|
|
|
struct MjsDefault {
|
|
explicit MjsDefault(mjsDefault *ptr);
|
|
mjsDefault* get() const;
|
|
void set(mjsDefault* ptr);
|
|
|
|
private:
|
|
mjsDefault* ptr_;
|
|
|
|
public:
|
|
MjsElement element;
|
|
MjsJoint joint;
|
|
MjsGeom geom;
|
|
MjsSite site;
|
|
MjsCamera camera;
|
|
MjsLight light;
|
|
MjsFlex flex;
|
|
MjsMesh mesh;
|
|
MjsMaterial material;
|
|
MjsPair pair;
|
|
MjsEquality equality;
|
|
MjsTendon tendon;
|
|
MjsActuator actuator;
|
|
};
|
|
|
|
|
|
struct MjvScene {
|
|
MjvScene();
|
|
MjvScene(MjModel *m, int maxgeom);
|
|
~MjvScene();
|
|
std::unique_ptr<MjvScene> copy();
|
|
int GetSumFlexFaces() const;
|
|
|
|
mjvScene* get() const;
|
|
void set(mjvScene* ptr);
|
|
|
|
std::vector<MjvGeom> geoms() const;
|
|
|
|
emscripten::val geomorder() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->ngeom, ptr_->geomorder));
|
|
}
|
|
emscripten::val flexedgeadr() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nflex, ptr_->flexedgeadr));
|
|
}
|
|
emscripten::val flexedgenum() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nflex, ptr_->flexedgenum));
|
|
}
|
|
emscripten::val flexvertadr() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nflex, ptr_->flexvertadr));
|
|
}
|
|
emscripten::val flexvertnum() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nflex, ptr_->flexvertnum));
|
|
}
|
|
emscripten::val flexfaceadr() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nflex, ptr_->flexfaceadr));
|
|
}
|
|
emscripten::val flexfacenum() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nflex, ptr_->flexfacenum));
|
|
}
|
|
emscripten::val flexfaceused() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nflex, ptr_->flexfaceused));
|
|
}
|
|
emscripten::val flexedge() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(2 * model->nflexedge, ptr_->flexedge));
|
|
}
|
|
emscripten::val flexvert() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(3 * model->nflexvert, ptr_->flexvert));
|
|
}
|
|
emscripten::val skinfacenum() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nskin, ptr_->skinfacenum));
|
|
}
|
|
emscripten::val skinvertadr() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nskin, ptr_->skinvertadr));
|
|
}
|
|
emscripten::val skinvertnum() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(ptr_->nskin, ptr_->skinvertnum));
|
|
}
|
|
emscripten::val skinvert() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(3 * model->nskinvert, ptr_->skinvert));
|
|
}
|
|
emscripten::val skinnormal() const {
|
|
return emscripten::val(
|
|
emscripten::typed_memory_view(3 * model->nskinvert, ptr_->skinnormal));
|
|
}
|
|
emscripten::val flexface() const {
|
|
return emscripten::val(emscripten::typed_memory_view(
|
|
9 * MjvScene::GetSumFlexFaces(), ptr_->flexface));
|
|
}
|
|
emscripten::val flexnormal() const {
|
|
return emscripten::val(emscripten::typed_memory_view(
|
|
9 * MjvScene::GetSumFlexFaces(), ptr_->flexnormal));
|
|
}
|
|
emscripten::val flextexcoord() const {
|
|
return emscripten::val(emscripten::typed_memory_view(
|
|
6 * MjvScene::GetSumFlexFaces(), ptr_->flextexcoord));
|
|
}
|
|
// camera field is handled manually in template file struct declaration
|
|
// flexedge field is handled manually in template file struct declaration
|
|
// flexedgeadr field is handled manually in template file struct declaration
|
|
// flexedgenum field is handled manually in template file struct declaration
|
|
// flexface field is handled manually in template file struct declaration
|
|
// flexfaceadr field is handled manually in template file struct declaration
|
|
// flexfacenum field is handled manually in template file struct declaration
|
|
// flexfaceused field is handled manually in template file struct declaration
|
|
// flexnormal field is handled manually in template file struct declaration
|
|
// flextexcoord field is handled manually in template file struct declaration
|
|
// flexvert field is handled manually in template file struct declaration
|
|
// flexvertadr field is handled manually in template file struct declaration
|
|
// flexvertnum field is handled manually in template file struct declaration
|
|
// geomorder field is handled manually in template file struct declaration
|
|
// geoms field is handled manually in template file struct declaration
|
|
// lights field is handled manually in template file struct declaration
|
|
// skinfacenum field is handled manually in template file struct declaration
|
|
// skinnormal field is handled manually in template file struct declaration
|
|
// skinvert field is handled manually in template file struct declaration
|
|
// skinvertadr field is handled manually in template file struct declaration
|
|
// skinvertnum field is handled manually in template file struct declaration
|
|
emscripten::val flags() const {
|
|
return emscripten::val(emscripten::typed_memory_view(11, ptr_->flags));
|
|
}
|
|
emscripten::val framergb() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->framergb));
|
|
}
|
|
emscripten::val rotate() const {
|
|
return emscripten::val(emscripten::typed_memory_view(4, ptr_->rotate));
|
|
}
|
|
emscripten::val translate() const {
|
|
return emscripten::val(emscripten::typed_memory_view(3, ptr_->translate));
|
|
}
|
|
float scale() const {
|
|
return ptr_->scale;
|
|
}
|
|
void set_scale(float value) {
|
|
ptr_->scale = value;
|
|
}
|
|
int framewidth() const {
|
|
return ptr_->framewidth;
|
|
}
|
|
void set_framewidth(int value) {
|
|
ptr_->framewidth = value;
|
|
}
|
|
int maxgeom() const {
|
|
return ptr_->maxgeom;
|
|
}
|
|
void set_maxgeom(int value) {
|
|
ptr_->maxgeom = value;
|
|
}
|
|
int nflex() const {
|
|
return ptr_->nflex;
|
|
}
|
|
void set_nflex(int value) {
|
|
ptr_->nflex = value;
|
|
}
|
|
int ngeom() const {
|
|
return ptr_->ngeom;
|
|
}
|
|
void set_ngeom(int value) {
|
|
ptr_->ngeom = value;
|
|
}
|
|
int nlight() const {
|
|
return ptr_->nlight;
|
|
}
|
|
void set_nlight(int value) {
|
|
ptr_->nlight = value;
|
|
}
|
|
int nskin() const {
|
|
return ptr_->nskin;
|
|
}
|
|
void set_nskin(int value) {
|
|
ptr_->nskin = value;
|
|
}
|
|
int status() const {
|
|
return ptr_->status;
|
|
}
|
|
void set_status(int value) {
|
|
ptr_->status = value;
|
|
}
|
|
int stereo() const {
|
|
return ptr_->stereo;
|
|
}
|
|
void set_stereo(int value) {
|
|
ptr_->stereo = value;
|
|
}
|
|
mjtByte enabletransform() const {
|
|
return ptr_->enabletransform;
|
|
}
|
|
void set_enabletransform(mjtByte value) {
|
|
ptr_->enabletransform = value;
|
|
}
|
|
mjtByte flexedgeopt() const {
|
|
return ptr_->flexedgeopt;
|
|
}
|
|
void set_flexedgeopt(mjtByte value) {
|
|
ptr_->flexedgeopt = value;
|
|
}
|
|
mjtByte flexfaceopt() const {
|
|
return ptr_->flexfaceopt;
|
|
}
|
|
void set_flexfaceopt(mjtByte value) {
|
|
ptr_->flexfaceopt = value;
|
|
}
|
|
mjtByte flexskinopt() const {
|
|
return ptr_->flexskinopt;
|
|
}
|
|
void set_flexskinopt(mjtByte value) {
|
|
ptr_->flexskinopt = value;
|
|
}
|
|
mjtByte flexvertopt() const {
|
|
return ptr_->flexvertopt;
|
|
}
|
|
void set_flexvertopt(mjtByte value) {
|
|
ptr_->flexvertopt = value;
|
|
}
|
|
|
|
private:
|
|
mjvScene* ptr_;
|
|
bool owned_ = false;
|
|
|
|
public:
|
|
mjModel* model;
|
|
std::vector<MjvLight> lights;
|
|
std::vector<MjvGLCamera> camera;
|
|
};
|
|
|
|
struct MjVFS {
|
|
MjVFS() : ptr_(new mjVFS) { mj_defaultVFS(ptr_); }
|
|
~MjVFS() { mj_deleteVFS(ptr_); }
|
|
void AddBuffer(const std::string& name, const emscripten::val& buffer) {
|
|
std::vector<uint8_t> vec = emscripten::vecFromJSArray<uint8_t>(buffer);
|
|
int result = mj_addBufferVFS(ptr_, name.c_str(), vec.data(), vec.size());
|
|
if (result != 0) {
|
|
mju_error("Could not add buffer to VFS: %d", result);
|
|
}
|
|
}
|
|
void DeleteFile(const std::string& filename) {
|
|
mj_deleteFileVFS(ptr_, filename.c_str());
|
|
}
|
|
mjVFS* get() const { return ptr_; }
|
|
|
|
private:
|
|
mjVFS* ptr_;
|
|
};
|
|
|
|
} // namespace mujoco::wasm
|
|
// NOLINTEND(whitespace/semicolon)
|
|
// NOLINTEND(whitespace/line_length)
|
|
|
|
#endif // MUJOCO_WASM_CODEGEN_GENERATED_BINDINGS_H_
|