#include <webots/supervisor.h>

WbNodeRef wb_supervisor_node_get_root();
WbNodeRef wb_supervisor_node_get_self();
WbNodeRef wb_supervisor_node_get_from_def(const char *def);
WbNodeRef wb_supervisor_node_get_from_id(int id);
WbNodeRef wb_supervisor_node_get_from_device(WbDeviceTag tag);
WbNodeRef wb_supervisor_node_get_selected();

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    Node *getRoot();
    Node *getSelf();
    Node *getFromDef(const std::string &name);
    Node *getFromId(int id);
    Node *getFromDevice(const Device *device);
    Node *getSelected();
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    def getRoot(self):
    def getSelf(self):
    def getFromDef(self, name):
    def getFromId(self, id):
    def getFromDevice(self, device):
    def getSelected(self):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public Node getRoot();
  public Node getSelf();
  public Node getFromDef(String name);
  public Node getFromId(int id);
  public Node getFromDevice(Device device);
  public Node getSelected();
  // ...
}

node = wb_supervisor_node_get_root()
node = wb_supervisor_node_get_self()
node = wb_supervisor_node_get_from_def('def')
node = wb_supervisor_node_get_from_id(id)
node = wb_supervisor_node_get_from_device(tag)
node = wb_supervisor_node_get_selected()

#include <webots/supervisor.h>

const char *wb_supervisor_node_get_def(WbNodeRef node);
int wb_supervisor_node_get_id(WbNodeRef node);
WbNodeRef wb_supervisor_node_get_parent_node(WbNodeRef node);
bool wb_supervisor_node_is_proto(WbNodeRef node);
WbProtoRef wb_supervisor_node_get_proto(WbNodeRef node);
WbNodeRef wb_supervisor_node_get_from_proto_def(WbNodeRef node, const char *def);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    int getId() const;
    std::string getDef() const;
    Node *getParentNode() const;
    bool isProto() const;
    Proto *getProto() const;
    Node *getFromProtoDef(const std::string &name);
    // ...
  }
}

from controller import Node

class Node:
    def getId(self):
    def getDef(self):
    def getParentNode(self):
    def isProto(self):
    def getProto(self):
    def getFromProtoDef(self, name):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public int getId();
  public String getDef();
  public Node getParentNode();
  public boolean isProto();
  public Proto getProto();
  public Node getFromProtoDef(String name);
  // ...
}

id = wb_supervisor_node_get_id(node)
s = wb_supervisor_node_get_def(node)
node = wb_supervisor_node_get_parent_node(node)
b = wb_supervisor_node_is_proto(node)
proto = wb_supervisor_node_get_proto(node)
node = wb_supervisor_node_get_from_proto_def(node, 'def')

#include <webots/supervisor.h>
#include <webots/node.h>

typedef enum {
  WB_NODE_NO_NODE,
  /* 3D rendering */
  WB_NODE_APPEARANCE,
  WB_NODE_BACKGROUND,
  WB_NODE_BILLBOARD,
  WB_NODE_BOX,
  WB_NODE_CAD_SHAPE,
  WB_NODE_CAPSULE,
  WB_NODE_COLOR,
  WB_NODE_CONE,
  WB_NODE_COORDINATE,
  WB_NODE_CYLINDER,
  WB_NODE_DIRECTIONAL_LIGHT,
  WB_NODE_ELEVATION_GRID,
  WB_NODE_FOG,
  WB_NODE_GROUP,
  WB_NODE_IMAGE_TEXTURE,
  WB_NODE_INDEXED_FACE_SET,
  WB_NODE_INDEXED_LINE_SET,
  WB_NODE_MATERIAL,
  WB_NODE_MESH,
  WB_NODE_MUSCLE,
  WB_NODE_NORMAL,
  WB_NODE_PBR_APPEARANCE,
  WB_NODE_PLANE,
  WB_NODE_POINT_LIGHT,
  WB_NODE_POINT_SET,
  WB_NODE_POSE,
  WB_NODE_SHAPE,
  WB_NODE_SPHERE,
  WB_NODE_SPOT_LIGHT,
  WB_NODE_TEXTURE_COORDINATE,
  WB_NODE_TEXTURE_TRANSFORM,
  WB_NODE_TRANSFORM,
  WB_NODE_VIEWPOINT,
  /* robots */
  WB_NODE_ROBOT,
  /* devices */
  WB_NODE_ACCELEROMETER,
  WB_NODE_ALTIMETER,
  WB_NODE_BRAKE,
  WB_NODE_CAMERA,
  WB_NODE_COMPASS,
  WB_NODE_CONNECTOR,
  WB_NODE_DISPLAY,
  WB_NODE_DISTANCE_SENSOR,
  WB_NODE_EMITTER,
  WB_NODE_GPS,
  WB_NODE_GYRO,
  WB_NODE_INERTIAL_UNIT,
  WB_NODE_LED,
  WB_NODE_LIDAR,
  WB_NODE_LIGHT_SENSOR,
  WB_NODE_LINEAR_MOTOR,
  WB_NODE_PEN,
  WB_NODE_POSITION_SENSOR,
  WB_NODE_PROPELLER,
  WB_NODE_RADAR,
  WB_NODE_RANGE_FINDER,
  WB_NODE_RECEIVER,
  WB_NODE_ROTATIONAL_MOTOR,
  WB_NODE_SKIN,
  WB_NODE_SPEAKER,
  WB_NODE_TOUCH_SENSOR,
  WB_NODE_VACUUM_GRIPPER,
  /* misc */
  WB_NODE_BALL_JOINT,
  WB_NODE_BALL_JOINT_PARAMETERS,
  WB_NODE_CHARGER,
  WB_NODE_CONTACT_PROPERTIES,
  WB_NODE_DAMPING,
  WB_NODE_FLUID,
  WB_NODE_FOCUS,
  WB_NODE_HINGE_JOINT,
  WB_NODE_HINGE_JOINT_PARAMETERS,
  WB_NODE_HINGE_2_JOINT,
  WB_NODE_IMMERSION_PROPERTIES,
  WB_NODE_JOINT_PARAMETERS,
  WB_NODE_LENS,
  WB_NODE_LENS_FLARE,
  WB_NODE_PHYSICS,
  WB_NODE_RECOGNITION,
  WB_NODE_SLIDER_JOINT,
  WB_NODE_SLOT,
  WB_NODE_SOLID,
  WB_NODE_SOLID_REFERENCE,
  WB_NODE_TRACK,
  WB_NODE_TRACK_WHEEL,
  WB_NODE_WORLD_INFO,
  WB_NODE_ZOOM
} WbNodeType;

WbNodeType wb_supervisor_node_get_type(WbNodeRef node);
const char *wb_supervisor_node_get_type_name(WbNodeRef node);
const char *wb_supervisor_node_get_base_type_name(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    typedef enum {
      NO_NODE,
      // 3D rendering
      APPEARANCE, BACKGROUND, BILLBOARD, BOX, CAPSULE, COLOR, CONE, COORDINATE,
      CYLINDER, DIRECTIONAL_LIGHT, ELEVATION_GRID, FOG, GROUP, IMAGE_TEXTURE,
      INDEXED_FACE_SET, INDEXED_LINE_SET, MATERIAL, MESH, MUSCLE, NORMAL, PBR_APPEARANCE,
      PLANE, POINT_LIGHT, POINT_SET, POSE, SHAPE, SPHERE, SPOT_LIGHT, TEXTURE_COORDINATE,
      TEXTURE_TRANSFORM, TRANSFORM, VIEWPOINT,
      // robots
      ROBOT,
      // devices
      ACCELEROMETER, ALTIMETER, BRAKE, CAMERA, COMPASS, CONNECTOR, DISPLAY,
      DISTANCE_SENSOR, EMITTER, GPS, GYRO, INERTIAL_UNIT, LED, LIDAR,
      LIGHT_SENSOR, LINEAR_MOTOR, PEN, POSITION_SENSOR, PROPELLER,
      RADAR, RANGE_FINDER, RECEIVER, ROTATIONAL_MOTOR, SKIN, SPEAKER, TOUCH_SENSOR,
      VACUUM_GRIPPER,
      // misc
      BALL_JOINT, BALL_JOINT_PARAMETERS, CHARGER, CONTACT_PROPERTIES,
      DAMPING, FLUID, FOCUS, HINGE_JOINT, HINGE_JOINT_PARAMETERS, HINGE_2_JOINT,
      IMMERSION_PROPERTIES, JOINT_PARAMETERS, LENS, LENS_FLARE, PHYSICS, RECOGNITION,
      SLIDER_JOINT, SLOT, SOLID, SOLID_REFERENCE, TRACK, TRACK_WHEEL, WORLD_INFO, ZOOM
    } Type;

    Type getType() const;
    std::string getTypeName() const;
    std::string getBaseTypeName() const;
    // ...
  }
}

from controller import Node

class Node:
    NO_NODE,
    # 3D rendering
    APPEARANCE, BACKGROUND, BILLBOARD, BOX, CAPSULE, COLOR, CONE, COORDINATE,
    CYLINDER, DIRECTIONAL_LIGHT, ELEVATION_GRID, FOG, GROUP, IMAGE_TEXTURE,
    INDEXED_FACE_SET, INDEXED_LINE_SET, MATERIAL, MESH, MUSCLE, NORMAL, PBR_APPEARANCE,
    PLANE, POINT_LIGHT, POINT_SET, POSE, SHAPE, SPHERE, SPOT_LIGHT, TEXTURE_COORDINATE,
    TEXTURE_TRANSFORM, TRANSFORM, VIEWPOINT,
    # robots
    ROBOT,
    # devices
    ACCELEROMETER, ALTIMETER, BRAKE, CAMERA, COMPASS, CONNECTOR, DISPLAY,
    DISTANCE_SENSOR, EMITTER, GPS, GYRO, INERTIAL_UNIT, LED, LIDAR,
    LIGHT_SENSOR, LINEAR_MOTOR, PEN, POSITION_SENSOR, PROPELLER,
    RADAR, RANGE_FINDER, RECEIVER, ROTATIONAL_MOTOR, SKIN, SPEAKER, TOUCH_SENSOR,
    VACUUM_GRIPPER,
    # misc
    BALL_JOINT, BALL_JOINT_PARAMETERS, CHARGER, CONTACT_PROPERTIES,
    DAMPING, FLUID, FOCUS, HINGE_JOINT, HINGE_JOINT_PARAMETERS, HINGE_2_JOINT,
    IMMERSION_PROPERTIES, JOINT_PARAMETERS, LENS, LENS_FLARE, PHYSICS, RECOGNITION,
    SLIDER_JOINT, SLOT, SOLID, SOLID_REFERENCE, TRACK, TRACK_WHEEL, WORLD_INFO, ZOOM

    def getType(self):
    def getTypeName(self):
    def getBaseTypeName(self):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public final static int
    NO_NODE,
    // 3D rendering
    APPEARANCE, BACKGROUND, BILLBOARD, BOX, CAPSULE, COLOR, CONE, COORDINATE,
    CYLINDER, DIRECTIONAL_LIGHT, ELEVATION_GRID, FOG, GROUP, IMAGE_TEXTURE,
    INDEXED_FACE_SET, INDEXED_LINE_SET, MATERIAL, MESH, MUSCLE, NORMAL, PBR_APPEARANCE,
    PLANE, POINT_LIGHT, POINT_SET, POSE, SHAPE, SPHERE, SPOT_LIGHT, TEXTURE_COORDINATE,
    TEXTURE_TRANSFORM, TRANSFORM, VIEWPOINT,
    // robots
    ROBOT,
    // devices
    ACCELEROMETER, ALTIMETER, BRAKE, CAMERA, COMPASS, CONNECTOR, DISPLAY,
    DISTANCE_SENSOR, EMITTER, GPS, GYRO, INERTIAL_UNIT, LED, LIDAR,
    LIGHT_SENSOR, LINEAR_MOTOR, PEN, POSITION_SENSOR, PROPELLER,
    RADAR, RANGE_FINDER, RECEIVER, ROTATIONAL_MOTOR, SKIN, SPEAKER, TOUCH_SENSOR,
    VACUUM_GRIPPER,
    // misc
    BALL_JOINT, BALL_JOINT_PARAMETERS, CHARGER, CONTACT_PROPERTIES,
    DAMPING, FLUID, FOCUS, HINGE_JOINT, HINGE_JOINT_PARAMETERS, HINGE_2_JOINT,
    IMMERSION_PROPERTIES, JOINT_PARAMETERS, LENS, LENS_FLARE, PHYSICS, RECOGNITION,
    SLIDER_JOINT, SLOT, SOLID, SOLID_REFERENCE, TRACK, TRACK_WHEEL, WORLD_INFO, ZOOM;

  public int getType();
  public String getTypeName();
  public String getBaseTypeName();
  // ...
}

WB_NODE_NO_NODE,
% 3D rendering
WB_NODE_APPEARANCE, WB_NODE_BACKGROUND, WB_NODE_BILLBOARD, WB_NODE_BOX, WB_NODE_CAPSULE,
WB_NODE_COLOR, WB_NODE_CONE, WB_NODE_COORDINATE,
WB_NODE_CYLINDER, WB_NODE_DIRECTIONAL_LIGHT, WB_NODE_ELEVATION_GRID, WB_NODE_FOG,
WB_NODE_GROUP, WB_NODE_IMAGE_TEXTURE, WB_NODE_INDEXED_FACE_SET, WB_NODE_INDEXED_LINE_SET,
WB_NODE_MATERIAL, WB_NODE_MESH, WB_NODE_MUSCLE, WB_NODE_NORMAL,
WB_NODE_PBR_APPEARANCE, WB_NODE_PLANE, WB_NODE_POINT_LIGHT, WB_NODE_POINT_SET, WB_NODE_POSE,
WB_NODE_SHAPE, WB_NODE_SPHERE, WB_NODE_SPOT_LIGHT, WB_NODE_TEXTURE_COORDINATE,
WB_NODE_TEXTURE_TRANSFORM, WB_NODE_TRANSFORM, WB_NODE_VIEWPOINT,
% robots
WB_NODE_ROBOT,
% devices
WB_NODE_ACCELEROMETER, WB_NODE_ALTIMETER, WB_NODE_BRAKE, WB_NODE_CAMERA, WB_NODE_COMPASS,
WB_NODE_CONNECTOR, WB_NODE_DISPLAY, WB_NODE_DISTANCE_SENSOR, WB_NODE_EMITTER,
WB_NODE_GPS, WB_NODE_GYRO, WB_NODE_INERTIAL_UNIT, WB_NODE_LED, WB_NODE_LIDAR,
WB_NODE_LIGHT_SENSOR, WB_NODE_LINEAR_MOTOR, WB_NODE_PEN,
WB_NODE_POSITION_SENSOR, WB_NODE_PROPELLER, WB_NODE_RADAR,
WB_NODE_RANGE_FINDER, WB_NODE_RECEIVER, WB_NODE_ROTATIONAL_MOTOR,
WB_NODE_SKIN, WB_NODE_SPEAKER, WB_NODE_TOUCH_SENSOR, WB_NODE_VACUUM_GRIPPER,
% misc
WB_NODE_BALL_JOINT, WB_NODE_BALL_JOINT_PARAMETERS, WB_NODE_CHARGER,
WB_NODE_CONTACT_PROPERTIES, WB_NODE_DAMPING, WB_NODE_FLUID,
WB_NODE_FOCUS, WB_NODE_HINGE_JOINT, WB_NODE_HINGE_JOINT_PARAMETERS,
WB_NODE_HINGE_2_JOINT, WB_NODE_IMMERSION_PROPERTIES, WB_NODE_JOINT_PARAMETERS,
WB_NODE_LENS, WB_NODE_LENS_FLARE, WB_NODE_PHYSICS, WB_NODE_RECOGNITION,
WB_NODE_SLIDER_JOINT, WB_NODE_SLOT, WB_NODE_SOLID, WB_NODE_SOLID_REFERENCE,
WB_NODE_TRACK, WB_NODE_TRACK_WHEEL, WB_NODE_WORLD_INFO, WB_NODE_ZOOM

type = wb_supervisor_node_get_type(node)
name = wb_supervisor_node_get_type_name(node)
name = wb_supervisor_node_get_base_type_name(node)

#include <webots/supervisor.h>

void wb_supervisor_node_remove(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    virtual void remove();
    // ...
  }
}

from controller import Node

class Node:
    def remove(self):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public void remove();
  // ...
}

wb_supervisor_node_remove(node)

#include <webots/supervisor.h>

const char * wb_supervisor_node_export_string(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    std::string exportString() const;
    // ...
  }
}

from controller import Node

class Node:
    def exportString(self):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public String exportString();
  // ...
}

node_string = wb_supervisor_node_export_string(node)

#include <webots/supervisor.h>

WbFieldRef wb_supervisor_node_get_field(WbNodeRef node, const char *field_name);
WbFieldRef wb_supervisor_node_get_field_by_index(WbNodeRef node, int index);
int wb_supervisor_node_get_number_of_fields(WbNodeRef node);
WbFieldRef wb_supervisor_node_get_base_node_field(WbNodeRef node, const char *field_name);
WbFieldRef wb_supervisor_node_get_base_node_field_by_index(WbNodeRef node, int index);
int wb_supervisor_node_get_number_of_base_node_fields(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    Field *getField(const std::string &fieldName) const;
    Field *getFieldByIndex(int index) const;
    int getNumberOfFields() const;
    Field *getBaseNodeField(const std::string &fieldName) const;
    Field *getBaseNodeFieldByIndex(int index) const;
    int getNumberOfBaseNodeFields() const;
    // ...
  }
}

from controller import Node

class Node:
    def getField(self, fieldName):
    def getFieldByIndex(self, index):
    def getNumberOfFields(self):
    def getBaseNodeField(self, fieldName):
    def getBaseNodeFieldByIndex(self, index):
    def getNumberOfBaseNodeFields(self):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public Field getField(String fieldName);
  public Field getFieldByIndex(int index);
  public int getNumberOfFields();
  public Field getBaseNodeField(String fieldName);
  public Field getBaseNodeFieldByIndex(int index);
  public int getNumberOfBaseNodeFields();
  // ...
}

field = wb_supervisor_node_get_field(node, 'field_name')
field = wb_supervisor_node_get_field_by_index(node, index)
size = wb_supervisor_node_get_number_of_fields(node)
field = wb_supervisor_node_get_base_node_field(node, 'field_name')
field = wb_supervisor_node_get_base_node_field_by_index(node, index)
size = wb_supervisor_node_get_number_of_base_node_fields(node)

#include <webots/supervisor.h>

const double *wb_supervisor_node_get_position(WbNodeRef node);
const double *wb_supervisor_node_get_orientation(WbNodeRef node);
const double *wb_supervisor_node_get_pose(WbNodeRef node, WbNodeRef from_node);
void wb_supervisor_node_enable_pose_tracking(WbNodeRef node, int sampling_period, WbNodeRef from_node);
void wb_supervisor_node_disable_pose_tracking(WbNodeRef node, WbNodeRef from_node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    const double *getPosition() const;
    const double *getOrientation() const;
    const double *getPose(const Node* fromNode = nullptr) const;
    void enablePoseTracking(int samplingPeriod, const Node *fromNode = nullprt) const;
    void disablePoseTracking(const Node *fromNode = nullptr) const;
    // ...
  }
}

from controller import Node

class Node:
    def getPosition(self):
    def getOrientation(self):
    def getPose(self, fromNode=None):
    def enablePoseTracking(self, samplingPeriod, fromNode=None):
    def disablePoseTracking(self, fromNode=None):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public double[] getPosition();
  public double[] getOrientation();
  public double[] getPose(Node fromNode=null);
  public void enablePoseTracking(int samplingPeriod, fromNode=null);
  public void disablePoseTracking(fromNode=null);
  // ...
}

position = wb_supervisor_node_get_position(node)
orientation = wb_supervisor_node_get_orientation(node)
pose = wb_supervisor_node_get_pose(node)
pose = wb_supervisor_node_get_pose(node, from_node)
wb_supervisor_node_enable_pose_tracking(sampling_period, node, from_node)
wb_supervisor_node_disable_pose_tracking(node, from_node)

#include <webots/supervisor.h>

const double *wb_supervisor_node_get_center_of_mass(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    const double *getCenterOfMass() const;
    // ...
  }
}

from controller import Node

class Node:
    def getCenterOfMass(self):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public double[] getCenterOfMass();
  // ...
}

com = wb_supervisor_node_get_center_of_mass(node)

#include <webots/supervisor.h>

WbContactPoint *wb_supervisor_node_get_contact_points(WbNodeRef node, bool include_descendants, int *size);
wb_supervisor_node_enable_contact_points_tracking(WbNodeRef node, int sampling_period, bool include_descendants);
wb_supervisor_node_disable_contact_points_tracking(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    ContactPoint *getContactPoints(bool includeDescendants, int *size) const;
    void enableContactPointsTracking(int samplingPeriod, bool includeDescendants = false) const;
    void disableContactPointsTracking() const;
    // ...
  }
}

from controller import Node

class Node:
    def getContactPoints(includeDescendants=False):
    def enableContactPointsTracking(samplingPeriod, includeDescendants=False):
    def disableContactPointsTracking():
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public ContactPoint[] getContactPoints(boolean includeDescendants);
  public enableContactPointsTracking(int samplingPeriod, boolean includeDescendants = false);
  public disableContactPointsTracking();
  // ...
}

contact_point = wb_supervisor_node_get_contact_points(include_descendants):
wb_supervisor_node_enable_contact_points_tracking(sampling_period, include_descendants):
wb_supervisor_node_disable_contact_points_tracking():

#include <webots/supervisor.h>

bool wb_supervisor_node_get_static_balance(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    bool getStaticBalance() const;
    // ...
  }
}

from controller import Node

class Node:
    def getStaticBalance(self):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public boolean getStaticBalance();
  // ...
}

balance = wb_supervisor_node_get_static_balance(node)

#include <webots/supervisor.h>

const double *wb_supervisor_node_get_velocity(WbNodeRef node);
void wb_supervisor_node_set_velocity(WbNodeRef node, const double velocity[6]);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    const double *getVelocity() const;
    void setVelocity(const double velocity[6]);
    // ...
  }
}

from controller import Node

class Node:
    def getVelocity(self):
    def setVelocity(self, velocity):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public double[] getVelocity();
  public void setVelocity(double velocity[6]);
  // ...
}

velocity = wb_supervisor_node_get_velocity(node)
wb_supervisor_node_set_velocity(node, velocity)

#include <webots/supervisor.h>

void wb_supervisor_node_save_state(WbNodeRef node, const char *state_name);
void wb_supervisor_node_load_state(WbNodeRef node, const char *state_name);
void wb_supervisor_node_reset_physics(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    void saveState(const std::string &stateName);
    void loadState(const std::string &stateName);
    void resetPhysics();
    // ...
  }
}

from controller import Node

class Node:
    def saveState(self, stateName):
    def loadState(self, stateName):
    def resetPhysics(self):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public void saveState(String stateName);
  public void loadState(String stateName);
  public void resetPhysics();
  // ...
}

wb_supervisor_node_save_state(node, state_name)
wb_supervisor_node_load_state(node, state_name)
wb_supervisor_node_reset_physics(node)

#include <webots/supervisor.h>

void wb_supervisor_node_set_joint_position(WbNodeRef node, double position, int index);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    void setJointPosition(double position, int index = 1);
    // ...
  }
}

from controller import Node

class Node:
    def setJointPosition(self, position, index=1):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public void setJointPosition(double position, int index);
  // ...
}

wb_supervisor_node_set_joint_position(node, position, index)

#include <webots/supervisor.h>

void wb_supervisor_node_restart_controller(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    void restartController();
    // ...
  }
}

from controller import Node

class Node:
    def restartController(self):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public void restartController();
  // ...
}

wb_supervisor_node_restart_controller(node)

#include <webots/supervisor.h>

void wb_supervisor_node_move_viewpoint(WbNodeRef node);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    void moveViewpoint() const;
    // ...
  }
}

from controller import Node

class Node:
    def moveViewpoint(self):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public void moveViewpoint();
  // ...
}

wb_supervisor_node_move_viewpoint(node)

#include <webots/supervisor.h>

void wb_supervisor_node_set_visibility(WbNodeRef node, WbNodeRef from, bool visible);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    void setVisibility(Node *from, bool visible);
    // ...
  }
}

from controller import Node

class Node:
    def setVisibility(self, from, visible):
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public void setVisibility(Node from, boolean visible);
  // ...
}

wb_supervisor_node_set_visibility(node, from, visible)

#include <webots/supervisor.h>

void wb_supervisor_node_add_force(WbNodeRef node, const double force[3], bool relative);
void wb_supervisor_node_add_force_with_offset(WbNodeRef node, const double force[3], const double offset[3], bool relative);
void wb_supervisor_node_add_torque(WbNodeRef node, const double torque[3], bool relative);

#include <webots/Node.hpp>

namespace webots {
  class Node {
    void addForce(const double force[3], bool relative);
    void addForceWithOffset(const double force[3], const double offset[3], bool relative);
    void addTorque(const double torque[3], bool relative);
    // ...
  }
}

from controller import Node

class Node:
    def addForce(self, force, relative)
    def addForceWithOffset(self, force, offset, relative)
    def addTorque(self, torque, relative)
    # ...

import com.cyberbotics.webots.controller.Node;

public class Node {
  public void addForce(double force[3], boolean relative);
  public void addForceWithOffset(double force[3], double offset[3], boolean relative);
  public void addTorque(double torque[3], boolean relative);
  // ...
}

void wb_supervisor_node_add_force(node, force, relative)
void wb_supervisor_node_add_force_with_offset(node, force, offset, relative)
void wb_supervisor_node_add_torque(node, torque, relative)

#include <webots/supervisor.h>

void wb_supervisor_set_label(int id, const char *text, double x, double y, double size, int color, double transparency, const char *font);

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    virtual void setLabel(int id, const std::string &label, double xpos, double ypos,
      double size, int color, double transparency = 0, const std::string &font = "Arial");
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    def setLabel(self, id, label, x, y, size, color, transparency=0, font='Arial'):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public void setLabel(int id, String label, double xpos, double ypos,
     double size, int color, double transparency = 0, String font = "Arial");
  // ...
}

wb_supervisor_set_label(id, 'text', x, y, size, [r g b], transparency, font)

#include <webots/supervisor.h>

void wb_supervisor_simulation_quit(int status);

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    virtual void simulationQuit(int status);
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    def simulationQuit(self, status):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public void simulationQuit(int status);
  // ...
}

wb_supervisor_simulation_quit(status)

#include <webots/supervisor.h>

typedef enum {
  WB_SUPERVISOR_SIMULATION_MODE_PAUSE,
  WB_SUPERVISOR_SIMULATION_MODE_REAL_TIME,
  WB_SUPERVISOR_SIMULATION_MODE_FAST
} WbSimulationMode;

WbSimulationMode wb_supervisor_simulation_get_mode();
void wb_supervisor_simulation_set_mode(WbSimulationMode mode);

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    typedef enum {
      SIMULATION_MODE_PAUSE, SIMULATION_MODE_REAL_TIME, SIMULATION_MODE_FAST
    } SimulationMode;

    SimulationMode simulationGetMode() const;
    virtual void simulationSetMode(SimulationMode mode);
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    SIMULATION_MODE_PAUSE, SIMULATION_MODE_REAL_TIME, SIMULATION_MODE_FAST

    def simulationGetMode(self):
    def simulationSetMode(self, mode):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public final static int SIMULATION_MODE_PAUSE, SIMULATION_MODE_REAL_TIME, SIMULATION_MODE_FAST;

  public int simulationGetMode();
  public void simulationSetMode(int mode);
  // ...
}

WB_SUPERVISOR_SIMULATION_MODE_PAUSE, WB_SUPERVISOR_SIMULATION_MODE_REAL_TIME, WB_SUPERVISOR_SIMULATION_MODE_FAST

mode = wb_supervisor_simulation_get_mode()
wb_supervisor_simulation_set_mode(mode)

#include <webots/supervisor.h>

void wb_supervisor_simulation_reset();

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    virtual void simulationReset();
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    def simulationReset(self):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public void simulationReset();
  // ...
}

wb_supervisor_simulation_reset()

#include <webots/supervisor.h>

void wb_supervisor_simulation_reset_physics();

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    virtual void simulationResetPhysics();
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    def simulationResetPhysics(self):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public void simulationResetPhysics();
  // ...
}

wb_supervisor_simulation_reset_physics()

#include <webots/supervisor.h>

void wb_supervisor_world_load(const char *filename);
bool wb_supervisor_world_save(const char *filename);
void wb_supervisor_world_reload();

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    virtual void worldLoad(const std::string &file);
    virtual bool worldSave();
    virtual bool worldSave(const std::string &file);
    virtual void worldReload();
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    def worldLoad(self, file):
    def worldSave(self, file=None):
    def worldReload(self):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public void worldLoad(String file);
  public boolean worldSave();
  public boolean worldSave(String file);
  public void worldReload();
  // ...
}

wb_supervisor_world_load('filename')
success = wb_supervisor_world_save()
success = wb_supervisor_world_save('filename')
wb_supervisor_world_reload()

#include <webots/supervisor.h>

void wb_supervisor_export_image(const char *filename, int quality);

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    void exportImage(const std::string &file, int quality) const;
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    def exportImage(self, file, quality):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public void exportImage(String file, int quality);
  // ...
}

wb_supervisor_export_image('filename', quality)

#include <webots/supervisor.h>

void wb_supervisor_movie_start_recording(const char *filename, int width, int height, int codec, int quality, int acceleration, bool caption);
void wb_supervisor_movie_stop_recording();
bool wb_supervisor_movie_is_ready();
bool wb_supervisor_movie_failed();

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    virtual void movieStartRecording(const std::string &file, int width, int height, int codec, int quality, int acceleration, bool caption) const;
    virtual void movieStopRecording();
    bool movieIsReady() const;
    bool movieFailed() const;
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    def movieStartRecording(self, file, width, height, codec, quality, acceleration, caption):
    def movieStopRecording(self):
    def movieIsReady(self):
    def movieFailed(self):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public void movieStartRecording(String file, int width, int height, int codec, int quality, int acceleration, boolean caption);
  public void movieStopRecording();
  public boolean movieIsReady();
  public boolean movieFailed();
  // ...
}

wb_supervisor_movie_start_recording('filename', width, height, codec, quality,
acceleration, caption)
wb_supervisor_movie_stop_recording()
status = wb_supervisor_movie_is_ready()
status = wb_supervisor_movie_failed()

#include <webots/supervisor.h>

bool wb_supervisor_animation_start_recording(const char *filename);
bool wb_supervisor_animation_stop_recording();

#include <webots/Supervisor.hpp>

namespace webots {
  class Supervisor : public Robot {
    virtual bool animationStartRecording(const std::string &file);
    virtual bool animationStopRecording();
    // ...
  }
}

from controller import Supervisor

class Supervisor (Robot):
    def animationStartRecording(self, file):
    def animationStopRecording(self):
    # ...

import com.cyberbotics.webots.controller.Supervisor;

public class Supervisor extends Robot {
  public boolean animationStartRecording(String file);
  public boolean animationStopRecording();
  // ...
}

success = wb_supervisor_animation_start_recording('filename')
success = wb_supervisor_animation_stop_recording()

#include <webots/supervisor.h>

typedef enum {
  WB_NO_FIELD, WB_SF_BOOL, WB_SF_INT32, WB_SF_FLOAT, WB_SF_VEC2F, WB_SF_VEC3F, WB_SF_ROTATION,
  WB_SF_COLOR, WB_SF_STRING, WB_SF_NODE, WB_MF, WB_MF_BOOL, WB_MF_INT32, WB_MF_FLOAT,
  WB_MF_VEC2F, WB_MF_VEC3F, WB_MF_ROTATION, WB_MF_COLOR, WB_MF_STRING, WB_MF_NODE
} WbFieldType;

const char *wb_supervisor_field_get_name(WbFieldRef field);
WbFieldType wb_supervisor_field_get_type(WbFieldRef field);
const char *wb_supervisor_field_get_type_name(WbFieldRef field);
int wb_supervisor_field_get_count(WbFieldRef field);
WbFieldRef wb_supervisor_field_get_actual_field(WbFieldRef field);
void wb_supervisor_field_enable_sf_tracking(WbFieldRef field, int sampling_period);
void wb_supervisor_field_disable_sf_tracking(WbFieldRef field);

#include <webots/Field.hpp>

namespace webots {
  class Field {
    typedef enum {
      SF_BOOL, SF_INT32, SF_FLOAT, SF_VEC2F, SF_VEC3F, SF_ROTATION, SF_COLOR, SF_STRING,
      SF_NODE, MF, MF_BOOL, MF_INT32, MF_FLOAT, MF_VEC2F, MF_VEC3F, MF_ROTATION, MF_COLOR,
      MF_STRING, MF_NODE
    } Type;

    std::string getName() const;
    Type getType() const;
    std::string getTypeName() const;
    int getCount() const;
    WbFieldRef getActualField() const;
    void enableSFTracking(int samplingPeriod);
    void disableSFTracking();
    // ...
  }
}

from controller import Field

class Field:
    SF_BOOL, SF_INT32, SF_FLOAT, SF_VEC2F, SF_VEC3F, SF_ROTATION, SF_COLOR, SF_STRING,
    SF_NODE, MF, MF_BOOL, MF_INT32, MF_FLOAT, MF_VEC2F, MF_VEC3F, MF_ROTATION, MF_COLOR,
    MF_STRING, MF_NODE

    def getName(self):
    def getType(self):
    def getTypeName(self):
    def getCount(self):
    def getActualField(self):
    def enableSFTracking(self, samplingPeriod):
    def disableSFTracking(self):
    # ...

import com.cyberbotics.webots.controller.Field;

public class Field {
  public final static int SF_BOOL, SF_INT32, SF_FLOAT, SF_VEC2F, SF_VEC3F, SF_ROTATION,
    SF_COLOR, SF_STRING, SF_NODE, MF, MF_BOOL, MF_INT32, MF_FLOAT, MF_VEC2F, MF_VEC3F,
    MF_ROTATION, MF_COLOR, MF_STRING, MF_NODE;

  public String getName();
  public int getType();
  public String getTypeName();
  public int getCount();
  public Field getActualField();
  public void enableSFTracking(int samplingPeriod);
  public void disableSFTracking();
  // ...
}

WB_SF_BOOL, WB_SF_INT32, WB_SF_FLOAT, WB_SF_VEC2F, WB_SF_VEC3F, WB_SF_ROTATION, WB_SF_COLOR,
WB_SF_STRING, WB_SF_NODE, WB_MF, WB_BOOL, WB_MF_INT32, WB_MF_FLOAT, B_MF_VEC2F, WB_MF_VEC3F,
WB_ROTATION, WB_MF_COLOR, WB_MF_STRING, WB_MF_NODE

name = wb_supervisor_field_get_name(field)
type = wb_supervisor_field_get_type(field)
name = wb_supervisor_field_get_type_name(field)
count = wb_supervisor_field_get_count(field)
actual_field = wb_supervisor_field_get_actual_field(field)
wb_supervisor_field_enable_sf_tracking(field, sampling_period)
wb_supervisor_field_disable_sf_tracking(field)

#include <webots/supervisor.h>

bool wb_supervisor_field_get_sf_bool(WbFieldRef field);
int wb_supervisor_field_get_sf_int32(WbFieldRef field);
double wb_supervisor_field_get_sf_float(WbFieldRef field);
const double *wb_supervisor_field_get_sf_vec2f(WbFieldRef sf_field);
const double *wb_supervisor_field_get_sf_vec3f(WbFieldRef field);
const double *wb_supervisor_field_get_sf_rotation(WbFieldRef field);
const double *wb_supervisor_field_get_sf_color(WbFieldRef field);
const char *wb_supervisor_field_get_sf_string(WbFieldRef field);
WbNodeRef wb_supervisor_field_get_sf_node(WbFieldRef field);
bool wb_supervisor_field_get_mf_bool(WbFieldRef field, int index);
int wb_supervisor_field_get_mf_int32(WbFieldRef field, int index);
double wb_supervisor_field_get_mf_float(WbFieldRef field, int index);
const double *wb_supervisor_field_get_mf_vec2f(WbFieldRef field, int index);
const double *wb_supervisor_field_get_mf_vec3f(WbFieldRef field, int index);
const double *wb_supervisor_field_get_mf_rotation(WbFieldRef field, int index);
const double *wb_supervisor_field_get_mf_color(WbFieldRef field, int index);
const char *wb_supervisor_field_get_mf_string(WbFieldRef field, int index);
WbNodeRef wb_supervisor_field_get_mf_node(WbFieldRef field, int index);

#include <webots/Field.hpp>

namespace webots {
  class Field {
    bool getSFBool() const;
    int getSFInt32() const;
    double getSFFloat() const;
    const double *getSFVec2f() const;
    const double *getSFVec3f() const;
    const double *getSFRotation() const;
    const double *getSFColor() const;
    std::string getSFString() const;
    Node *getSFNode() const;
    bool getMFBool(int index) const;
    int getMFInt32(int index) const;
    double getMFFloat(int index) const;
    const double *getMFVec2f(int index) const;
    const double *getMFVec3f(int index) const;
    const double *getMFRotation(int index) const;
    const double *getMFColor(int index) const;
    std::string getMFString(int index) const;
    Node *getMFNode(int index) const;
    // ...
  }
}

from controller import Field

class Field:
    def getSFBool(self):
    def getSFInt32(self):
    def getSFFloat(self):
    def getSFVec2f(self):
    def getSFVec3f(self):
    def getSFRotation(self):
    def getSFColor(self):
    def getSFString(self):
    def getSFNode(self):
    def getMFBool(self, index):
    def getMFInt32(self, index):
    def getMFFloat(self, index):
    def getMFVec2f(self, index):
    def getMFVec3f(self, index):
    def getMFRotation(self, index):
    def getMFColor(self, index):
    def getMFString(self, index):
    def getMFNode(self, index):
    # ...

import com.cyberbotics.webots.controller.Field;

public class Field {
  public boolean getSFBool();
  public int getSFInt32();
  public double getSFFloat();
  public double[] getSFVec2f();
  public double[] getSFVec3f();
  public double[] getSFRotation();
  public double[] getSFColor();
  public String getSFString();
  public Node getSFNode();
  public boolean getMFBool(int index);
  public int getMFInt32(int index);
  public double getMFFloat(int index);
  public double[] getMFVec2f(int index);
  public double[] getMFVec3f(int index);
  public double[] getMFColor(int index);
  public double[] getMFRotation(int index);
  public String getMFString(int index);
  public Node getMFNode(int index);
  // ...
}

b = wb_supervisor_field_get_sf_bool(field)
i = wb_supervisor_field_get_sf_int32(field)
f = wb_supervisor_field_get_sf_float(field)
x_y_array = wb_supervisor_field_get_sf_vec2f(field)
x_y_z_array = wb_supervisor_field_get_sf_vec3f(field)
x_y_z_alpha_array = wb_supervisor_field_get_sf_rotation(field)
r_g_b_array = wb_supervisor_field_get_sf_color(field)
s = wb_supervisor_field_get_sf_string(field)
node = wb_supervisor_field_get_sf_node(field)
b = wb_supervisor_field_get_mf_bool(field, index)
i = wb_supervisor_field_get_mf_int32(field, index)
f = wb_supervisor_field_get_mf_float(field, index)
x_y_array = wb_supervisor_field_get_mf_vec2f(field, index)
x_y_z_array = wb_supervisor_field_get_mf_vec3f(field, index)
x_y_z_a_array = wb_supervisor_field_get_mf_rotation(field, index)
r_g_b_array = wb_supervisor_field_get_mf_color(field, index)
s = wb_supervisor_field_get_mf_string(field, index)
node = wb_supervisor_field_get_mf_node(field, index)

#include <webots/supervisor.h>

void wb_supervisor_field_set_sf_bool(WbFieldRef field, bool value);
void wb_supervisor_field_set_sf_int32(WbFieldRef field, int value);
void wb_supervisor_field_set_sf_float(WbFieldRef field, double value);
void wb_supervisor_field_set_sf_vec2f(WbFieldRef sf_field, const double values[2]);
void wb_supervisor_field_set_sf_vec3f(WbFieldRef field, const double values[3]);
void wb_supervisor_field_set_sf_rotation(WbFieldRef field, const double values[4]);
void wb_supervisor_field_set_sf_color(WbFieldRef field, const double values[3]);
void wb_supervisor_field_set_sf_string(WbFieldRef field, const char *value);
void wb_supervisor_field_set_mf_bool(WbFieldRef field, int index, bool value);
void wb_supervisor_field_set_mf_int32(WbFieldRef field, int index, int value);
void wb_supervisor_field_set_mf_float(WbFieldRef field, int index, double value);
void wb_supervisor_field_set_mf_vec2f(WbFieldRef field, int index, const double values[2]);
void wb_supervisor_field_set_mf_vec3f(WbFieldRef field, int index, const double values[3]);
void wb_supervisor_field_set_mf_rotation(WbFieldRef field, int index, const double values[4]);
void wb_supervisor_field_set_mf_color(WbFieldRef field, int index, const double values[3]);
void wb_supervisor_field_set_mf_string(WbFieldRef field, int index, const char *value);

#include <webots/Field.hpp>

namespace webots {
  class Field {
    void setSFBool(bool value);
    void setSFInt32(int value);
    void setSFFloat(double value);
    void setSFVec2f(const double values[2]);
    void setSFVec3f(const double values[3]);
    void setSFRotation(const double values[4]);
    void setSFColor(const double values[3]);
    void setSFString(const std::string &value);
    void setMFBool(int index, bool value);
    void setMFInt32(int index, int value);
    void setMFFloat(int index, double value);
    void setMFVec2f(int index, const double values[2]);
    void setMFVec3f(int index, const double values[3]);
    void setMFRotation(int index, const double values[4]);
    void setMFColor(int index, const double values[3]);
    void setMFString(int index, const std::string &value);
    // ...
  }
}

from controller import Field

class Field:
    def setSFBool(self, value):
    def setSFInt32(self, value):
    def setSFFloat(self, value):
    def setSFVec2f(self, values):
    def setSFVec3f(self, values):
    def setSFRotation(self, values):
    def setSFColor(self, values):
    def setSFString(self, value):
    def setMFBool(self, index, value):
    def setMFInt32(self, index, value):
    def setMFFloat(self, index, value):
    def setMFVec2f(self, index, values):
    def setMFVec3f(self, index, values):
    def setMFRotation(self, index, values):
    def setMFColor(self, index, values):
    def setMFString(self, index, value):
    # ...

import com.cyberbotics.webots.controller.Field;

public class Field {
  public void setSFBool(boolean value);
  public void setSFInt32(int value);
  public void setSFFloat(double value);
  public void setSFVec2f(double values[2]);
  public void setSFVec3f(double values[3]);
  public void setSFRotation(double values[4]);
  public void setSFColor(double values[3]);
  public void setSFString(String value);
  public void setMFBool(int index, boolean value);
  public void setMFInt32(int index, int value);
  public void setMFFloat(int index, double value);
  public void setMFVec2f(int index, double values[2]);
  public void setMFVec3f(int index, double values[3]);
  public void setMFRotation(int index, double values[4]);
  public void setMFColor(int index, double values[3]);
  public void setMFString(int index, String value);
  // ...
}

wb_supervisor_field_set_sf_bool(field, value)
wb_supervisor_field_set_sf_int32(field, value)
wb_supervisor_field_set_sf_float(field, value)
wb_supervisor_field_set_sf_vec2f(field, [x y])
wb_supervisor_field_set_sf_vec3f(field, [x y z])
wb_supervisor_field_set_sf_rotation(field, [x y z alpha])
wb_supervisor_field_set_sf_color(field, [r g b])
wb_supervisor_field_set_sf_string(field, 'value')
wb_supervisor_field_set_mf_bool(field, index, value)
wb_supervisor_field_set_mf_int32(field, index, value)
wb_supervisor_field_set_mf_float(field, index, value)
wb_supervisor_field_set_mf_vec2f(field, index, [x y])
wb_supervisor_field_set_mf_vec3f(field, index, [x y z])
wb_supervisor_field_set_mf_rotation(field, index, [x y z a])
wb_supervisor_field_set_mf_color(field, index, [r g b])
wb_supervisor_field_set_mf_string(field, index, 'value')

#include <webots/supervisor.h>

void wb_supervisor_field_insert_mf_bool(WbFieldRef field, int index, bool value);
void wb_supervisor_field_insert_mf_int32(WbFieldRef field, int index, int value);
void wb_supervisor_field_insert_mf_float(WbFieldRef field, int index, double value);
void wb_supervisor_field_insert_mf_vec2f(WbFieldRef field, int index, const double values[2]);
void wb_supervisor_field_insert_mf_vec3f(WbFieldRef field, int index, const double values[3]);
void wb_supervisor_field_insert_mf_rotation(WbFieldRef field, int index, const double values[4]);
void wb_supervisor_field_insert_mf_color(WbFieldRef field, int index, const double values[3]);
void wb_supervisor_field_insert_mf_string(WbFieldRef field, int index, const char *value);

void wb_supervisor_field_remove_mf(WbFieldRef field, int index);
void wb_supervisor_field_remove_sf(WbFieldRef field);

#include <webots/Field.hpp>

namespace webots {
  class Field {
    void insertSFBool(bool value);
    void insertSFInt32(int value);
    void insertSFFloat(double value);
    void insertSFVec2f(const double values[2]);
    void insertSFVec3f(const double values[3]);
    void insertSFRotation(const double values[4]);
    void insertSFColor(const double values[3]);
    void insertSFString(const std::string &value);
    void insertMFBool(int index, bool value);
    void insertMFInt32(int index, int value);
    void insertMFFloat(int index, double value);
    void insertMFVec2f(int index, const double values[2]);
    void insertMFVec3f(int index, const double values[3]);
    void insertMFRotation(int index, const double values[4]);
    void insertMFColor(int index, const double values[3]);
    void insertMFString(int index, const std::string &value);
    void removeMF(int index);
    void removeSF();
    // ...
  }
}

from controller import Field

class Field:
    def insertMFBool(self, index, value):
    def insertMFInt32(self, index, value):
    def insertMFFloat(self, index, value):
    def insertMFVec2f(self, index, values):
    def insertMFVec3f(self, index, values):
    def insertMFRotation(self, index, values):
    def insertMFColor(self, index, values):
    def insertMFString(self, index, value):
    def removeMF(self, index):
    def removeSF(self):
    # ...

import com.cyberbotics.webots.controller.Field;

public class Field {
  public void insertMFBool(int index, boolean value);
  public void insertMFInt32(int index, int value);
  public void insertMFFloat(int index, double value);
  public void insertMFVec2f(int index, double values[2]);
  public void insertMFVec3f(int index, double values[3]);
  public void insertMFRotation(int index, double values[4]);
  public void insertMFColor(int index, double values[3]);
  public void insertMFString(int index, String value);
  public void removeMF(int index);
  public void removeSF();
  // ...
}

wb_supervisor_field_insert_mf_bool(field, index, value)
wb_supervisor_field_insert_mf_int32(field, index, value)
wb_supervisor_field_insert_mf_float(field, index, value)
wb_supervisor_field_insert_mf_vec2f(field, index, [x y])
wb_supervisor_field_insert_mf_vec3f(field, index, [x y z])
wb_supervisor_field_insert_mf_rotation(field, index, [x y z a])
wb_supervisor_field_insert_mf_color(field, index, [r g b])
wb_supervisor_field_insert_mf_string(field, index, 'value')
wb_supervisor_field_remove_mf(field, index)
wb_supervisor_field_remove_sf(field)

#include <webots/supervisor.h>

void wb_supervisor_field_import_mf_node_from_string(WbFieldRef field, int position, const char *node_string);
void wb_supervisor_field_import_sf_node_from_string(WbFieldRef field, const char *node_string);

#include <webots/Field.hpp>

namespace webots {
  class Field {
    void importMFNodeFromString(int position, const std::string &nodeString);
    void importSFNodeFromString(const std::string &nodeString);
    // ...
  }
}

from controller import Field

class Field:
    def importMFNodeFromString(self, position, nodeString):
    def importSFNodeFromString(self, nodeString):
    # ...

import com.cyberbotics.webots.controller.Field;

public class Field {
  public void importMFNodeFromString(int position, String nodeString);
  public void importSFNodeFromString(String nodeString);
  // ...
}

wb_supervisor_field_import_mf_node_from_string(field, position, 'node_string')
wb_supervisor_field_import_sf_node_from_string(field, 'node_string')

#include <webots/robot.h>
#include <webots/supervisor.h>

#define TIME_STEP 32

int main(int argc, char **argv) {
  wb_robot_init();

  WbNodeRef root_node = wb_supervisor_node_get_root();
  WbFieldRef root_children_field = wb_supervisor_node_get_field(root_node, "children");
  wb_supervisor_field_import_mf_node_from_string(root_children_field, 4, "DEF MY_ROBOT Robot { controller \"my_controller\" }");

  ...
}

from controller import Supervisor

supervisor = Supervisor()

rootNode = supervisor.getRoot()  # get root of the scene tree
rootChildrenField = rootNode.getField('children')
rootChildrenField.importMFNodeFromString(4, 'DEF MY_ROBOT Robot { controller "my_controller" }')

...

#include <webots/supervisor.h>

const char *wb_supervisor_proto_get_type_name(WbProtoRef proto);
bool wb_supervisor_proto_is_derived(WbProtoRef proto, const char *type_name);
WbProtoRef wb_supervisor_proto_get_parent(WbProtoRef proto);

#include <webots/Proto.hpp>

namespace webots {
  class Proto {
    std::string getTypeName();
    bool isDerived();
    Node getParent();
    // ...
  }
}

from controller import Proto

class Proto:
    def getTypeName(self):
    def isDerived(self):
    def getParent(self):
    # ...

import com.cyberbotics.webots.controller.Proto;

public class Proto {
  public String getTypeName();
  public boolean isDerived();
  public Node getParent();
  // ...
}

type_name = wb_supervisor_proto_get_type_name(proto)
is_derived = wb_supervisor_proto_is_derived(proto)
parent = wb_supervisor_proto_get_parent(proto)

#include <webots/supervisor.h>

WbFieldRef wb_supervisor_proto_get_field(WbProtoRef proto, const char *field_name);
WbFieldRef wb_supervisor_proto_get_field_by_index(WbProtoRef proto, int index);
int        wb_supervisor_proto_get_number_of_fields(WbProtoRef proto);