Skip to content

build_system.md

Latest commit

 

History

History
158 lines (103 loc) · 3.69 KB

build_system.md

File metadata and controls

158 lines (103 loc) · 3.69 KB

Build System

1. You Run

pip install -e .

This tells pip to:

  • Perform an editable install of the current project.
  • Use the pyproject.toml as the single source of truth for building and packaging.

2. pip Reads pyproject.toml

It sees:

[build-system]
build-backend = "scikit_build_core.build"

So pip uses scikit-build-core as the build backend (instead of legacy setuptools).

3. scikit-build-core Invokes CMake

It starts a CMake build, just like if you had run:

cmake -S . -B build
cmake --build build

It uses the CMakeLists.txt at the project root, which:

  • Declares the project:

    project(rcs LANGUAGES C CXX VERSION 0.4.0)

  • Sets modern C++20 and compiler policies.

  • Locates external dependencies:

    • Eigen3, Python3, MuJoCo, pinocchio

  • Downloads with FetchContent: rl, pybind11

  • Includes:

    add_subdirectory(src)

4. CMake Enters src/CMakeLists.txt

add_subdirectory(rcs)
target_include_directories(rcs INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
add_subdirectory(sim)
add_subdirectory(pybind)

This loads and builds 3 subcomponents.

5. Subcomponent Builds

src/rcs/CMakeLists.txt

add_library(rcs SHARED)
target_sources(rcs PRIVATE Pose.cpp Robot.cpp IK.cpp utils.cpp)
target_link_libraries(rcs PUBLIC Eigen3::Eigen mdl pinocchio::all)
  • Builds a shared C++ library: rcs
  • Contains your robot control logic
  • Exposes include/ headers
  • Linked against external libraries

src/sim/CMakeLists.txt

add_library(sim)
target_sources(sim PRIVATE sim.cpp SimRobot.cpp ...)
target_link_libraries(sim PUBLIC rcs MuJoCo::MuJoCo)
  • Builds a C++ simulation library
  • Depends on:
    • Your own rcs library
    • MuJoCo physics engine

src/pybind/CMakeLists.txt

pybind11_add_module(_core MODULE rcs.cpp)
target_link_libraries(_core PRIVATE sim rcs)

  • Compiles a Python extension module: _core.so

  • Uses pybind11 to bind C++ classes/functions

  • Links to both sim and rcs native libraries

  • Adds install instructions:

    install(TARGETS _core rcs DESTINATION rcs COMPONENT python_package)

6. Packaging into Python

From pyproject.toml:

[tool.scikit-build]
build.targets = ["_core", "scenes", "rcs"]
wheel.packages = ["python/rcs"]
install.components = ["python_package"]

  • scikit-build-core installs _core.so into:

    python/rcs/_core.so

  • That directory becomes a valid Python package

7. Result: Python Import Works

After install:

from rcs import _core
  • You now access the C++ functionality exposed in rcs.cpp through Python.
  • _core contains Python-wrapped C++ objects/functions via pybind11.

Summary Diagram

pip install -e .
        │
        ▼
Reads pyproject.toml (scikit_build_core used)
        │
        ▼
CMakeLists.txt (root) → add_subdirectory(src)
        │
        ▼
src/rcs → builds C++ library `rcs`
src/sim → builds C++ library `sim`
src/pybind → builds Python extension `_core`
        │
        ▼
All .so libraries installed in `python/rcs/`
`_core` accessible from Python as import

Recap of Build Layers

Layer Role Tool
pyproject.toml Project metadata, build backend pip, scikit-build-core
CMakeLists.txt (root) Configure the full C++ build CMake
src/rcs Core robot logic in C++ C++, Eigen, pinocchio
src/sim Simulation logic, MuJoCo C++, MuJoCo
src/pybind Bindings to Python pybind11
python/rcs/ Python package with compiled .so scikit-build, pip