V0

.github/workflows/AutoApprove.yml

@@ -0,0 +1,23 @@
+# will be removed when this project has more than one maintainers
+
+name: AutoApprove
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
+
+jobs:
+  approve:
+    if: |
+      github.event.pull_request.user.login == 'kanarus' &&
+      !github.event.pull_request.draft
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: approve
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh pr review ${{ github.event.number }} --approve

.github/workflows/CI.yml

@@ -6,7 +6,7 @@ on:
     branches: [main, v*]
 
 jobs:
-  CI:
+  build:
     runs-on: ubuntu-latest
 
     strategy:
@@ -16,6 +16,18 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - run: rustup update && rustup default ${{ matrix.toolchain }}
-
-      - run: cargo test
+      - run: |
+          rustup update
+          rustup default ${{ matrix.toolchain }}
+          rustup component add rustfmt  ### required for rusty_mujoco to build ###
+
+      - name: install mujoco and set MUJOCO_DIR
+        run: |
+          mkdir -p $HOME/.mujoco
+          cd $HOME/.mujoco
+          wget https://github.com/google-deepmind/mujoco/releases/download/3.3.2/mujoco-3.3.2-linux-x86_64.tar.gz
+          tar -xzf mujoco-3.3.2-linux-x86_64.tar.gz
+          echo "MUJOCO_DIR=$HOME/.mujoco/mujoco-3.3.2" >> $GITHUB_ENV
+          echo "LD_LIBRARY_PATH=$HOME/.mujoco/mujoco-3.3.2/lib:$LD_LIBRARY_PATH" >> $GITHUB_ENV
+
+      - run: cargo build

.gitignore

@@ -1,2 +1,2 @@
-/target
-Cargo.lock
+**/target
+**/Cargo.lock

Cargo.toml

@@ -8,9 +8,9 @@ homepage      = "https://crates.io/crates/oxide_control"
 repository    = "https://github.com/rust-control/oxide_control"
 readme        = "README.md"
 license       = "MIT"
-description   = ""
+description   = "Rust software stack for physics-based simulation and Reinforcement Learning environments, using MuJoCo"
 keywords      = ["mujoco", "rl", "ml", "physics", "robotics"]
 categories    = ["science::robotics", "simulation"]
 
 [dependencies]
-rusty_mujoco = { path = "../rusty_mujoco" }
+rusty_mujoco = "0.1.0"

README.md

@@ -0,0 +1,13 @@
+<div align="center">
+    <h1><code>oxide_control</code>: The <a href="https://github.com/google-deepmind/dm_control"><code>dm_control</code></a> layer for Rust</h1>
+</div>
+
+`oxide_control` is a Rust software stack for
+physics-based simulation and Reinforcement Learning environments, using MuJoCo.
+
+This is built up on [rusty_mujoco](https://github.com/rust-control/rusty_mujoco) binding,
+and provides a high-level interface similar to [dm_control](https://github.com/google-deepmind/dm_control) in Python.
+
+## Features
+
+

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 160

src/error.rs

@@ -0,0 +1,82 @@
+use rusty_mujoco::{obj, ObjectId};
+
+pub enum Error {
+    Mujoco(::rusty_mujoco::MjError),
+    Mjs(String),
+    NameNotFound(&'static str),
+    PhysicsDiverged,
+    JointTypeNotMatch {
+        expected: ::rusty_mujoco::bindgen::mjtJoint,
+        found: ::rusty_mujoco::bindgen::mjtJoint,
+    },
+    ActuatorStateless(ObjectId<obj::Actuator>),
+    PluginStateless(ObjectId<obj::Plugin>),
+    BodyNotMocap(ObjectId<obj::Body>),
+}
+
+impl From<::rusty_mujoco::MjError> for Error {
+    fn from(e: ::rusty_mujoco::MjError) -> Self {
+        Error::Mujoco(e)
+    }
+}
+
+impl std::fmt::Debug for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::Mujoco(e) => write!(f, "Error::MuJoCo({e:?})"),
+            Error::Mjs(msg) => write!(f, "Error::Mjs({msg})"),
+            Error::NameNotFound(name) => write!(f, "Error::NameNotFound({name})"),
+            Error::PhysicsDiverged => write!(f, "Error::PhysicsDiverged"),
+            Error::JointTypeNotMatch { expected, found } => {
+                write!(f, "Error::JointTypeNotMatch(expected: {expected:?}, found: {found:?})")
+            }
+            Error::ActuatorStateless(actuator_id) => {
+                write!(f, "Error::ActuatorStateless({actuator_id:?})")
+            }
+            Error::PluginStateless(plugin_id) => {
+                write!(f, "Error::PluginStateless({plugin_id:?})")
+            }
+            Error::BodyNotMocap(body_id) => {
+                write!(f, "Error::BodyNotMocap({body_id:?})")
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::Mujoco(e) => write!(f, "MuJoCo error: {e}"),
+            Error::Mjs(msg) => write!(f, "MuJoCo error: {msg}"),
+            Error::NameNotFound(name) => write!(f, "Given name not found: `{name}`"),
+            Error::PhysicsDiverged => write!(f, "Physics simulation diverged"),
+            Error::JointTypeNotMatch { expected, found } => {
+                write!(f, "Joint type mismatch: expected {expected:?}, found {found:?}")
+            }
+            Error::ActuatorStateless(actuator_id) => {
+                write!(f, "Actuator with ID {actuator_id:?} is stateless unexpectedly")
+            }
+            Error::PluginStateless(plugin_id) => {
+                write!(f, "Plugin with ID {plugin_id:?} is stateless unexpectedly")
+            }
+            Error::BodyNotMocap(body_id) => {
+                write!(f, "Body with ID {body_id:?} is not a mocap body")
+            }
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::Mujoco(e) => Some(e),
+            Error::Mjs(_) => None,
+            Error::NameNotFound(_) => None,
+            Error::PhysicsDiverged => None,
+            Error::JointTypeNotMatch { .. } => None,
+            Error::ActuatorStateless(_) => None,
+            Error::PluginStateless(_) => None,
+            Error::BodyNotMocap(_) => None,
+        }
+    }
+}

src/lib.rs

@@ -1,14 +1,88 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
+pub mod error;
+pub mod physics;
+
+pub use physics::Physics as RawPhysics;
+
+pub trait Physics: std::ops::DerefMut<Target = RawPhysics> {}
+
+pub trait Task {
+    type Physics: Physics;
+    type Observation: Observation<Physics = Self::Physics>;
+    type Action: Action<Physics = Self::Physics>;
+    fn discount(&self) -> f64;
+    fn init_episode(&self, physics: &mut Self::Physics);
+    fn should_finish_episode(&self, observation: &Self::Observation) -> bool;
+    fn get_reward(&self, observation: &Self::Observation, action: &Self::Action) -> f64;
+}
+
+pub trait Observation {
+    type Physics: Physics;
+    fn generate(physics: &Self::Physics) -> Self;
+}
+
+pub trait Action {
+    type Physics: Physics;
+    fn apply(&self, actuators: &mut physics::Actuators<'_>);
+}
+
+pub struct Environment<T: Task> {
+    task: T,
+    physics: T::Physics,
+}
+
+impl<T: Task> Environment<T> {
+    pub fn new(physics: T::Physics, task: T) -> Self {
+        Self { task, physics }
+    }
+
+    pub fn task(&self) -> &T {
+        &self.task
+    }
+
+    pub fn physics(&self) -> &T::Physics {
+        &self.physics
+    }
+    pub fn physics_mut(&mut self) -> &mut T::Physics {
+        &mut self.physics
+    }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+pub enum TimeStep<O> {
+    Step {
+        observation: O,
+        reward: f64,
+        discount: f64,
+    },
+    Finish {
+        observation: O,
+        reward: f64,
+    },
+}
+
+impl<T: Task> Environment<T> {
+    pub fn reset(&mut self) -> T::Observation {
+        self.task.init_episode(&mut self.physics);
+        T::Observation::generate(&self.physics)
+    }
+
+    pub fn step(&mut self, action: T::Action) -> TimeStep<T::Observation> {
+        action.apply(&mut self.physics.actuators());
+        self.physics.step();
+
+        let observation = T::Observation::generate(&self.physics);
+        let reward = self.task.get_reward(&observation, &action);
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
+        if self.task.should_finish_episode(&observation) {
+            TimeStep::Finish {
+                observation,
+                reward,
+            }
+        } else {
+            TimeStep::Step {
+                observation,
+                reward,
+                discount: self.task.discount(),
+            }
+        }
     }
 }