README.md

---
license: cc-by-4.0
pretty_name: Atech module SimReady assets
tags:
  - simulation
  - robotics
  - usd
  - simready
  - isaac-sim
  - mujoco
  - urdf
  - gltf
  - glb
  - unity
  - threejs
  - 3d
---

# Atech SimReady modules and boards

3-D simulation assets for the Atech boards and modules on [atech.dev](https://atech.dev):
every module in the [Atech SDK](https://pypi.org/project/atech/) catalog, the products
the SDK has no firmware for yet (USB-C, Power Jack, Micro-SD Card, Big Screen, Camera,
Soil Sensor, Load Cell), and the 8-, 10- and 14-port boards.

Every asset comes in four formats: **USD** (Isaac Sim / Omniverse), **MJCF** (MuJoCo),
**URDF** (ROS / Gazebo) and **glTF** (`.glb`: Unity, three.js, Blender, Unreal, Godot,
Babylon.js, any web page).

![A 14-port Atech board with nine modules, rendered in three.js from the .glb files](images/threejs_14port.png)

*Rendered in three.js straight from the `.glb` files: each module seated on its port
with the frames inside the files.*

## License: free to use, credit Atech

These assets are open under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/):
use, change and redistribute them, in research, teaching and commercial products,
as long as you **credit Atech**. In anything you publish or ship with them (a paper,
a video, a game, a product, a modified copy), say so, for example:

> 3D models: Atech SimReady assets by Atech ([atech.dev](https://atech.dev)), CC BY 4.0,
> https://huggingface.co/datasets/atechdev/simready-assets

Note if you changed them. CC BY 4.0 covers these 3-D files. It gives no rights to the
Atech name or logo beyond that credit, and it does not suggest Atech endorses your work.

## Build with the real hardware

- **Firmware and drivers: the `atech` Python library.** `pip install atech` gives you
  the module catalog, Atech's module drivers, and the commands that turn a small
  `project.yaml` into firmware, build it, flash the board and talk to it from your
  laptop (`atech new`, `atech build`, `atech upload`, `atech monitor`). It can also
  run that firmware on an emulated board (`atech emulate`) and export these assets
  (`atech sim-assets`). Source: [github.com/atechdotdev/python-sdk](https://github.com/atechdotdev/python-sdk).
- **Building on the Atech platform: [atech.dev](https://atech.dev).** The boards and
  modules these assets model, and the platform to build projects with them.

## Layout

Each top-level folder is one SimReady asset package, in four formats:

```
NN_<asset>/
├── com.nvidia.simready.packaging.json         package marker (license, BOM hash)
├── .metadata/                                 root USD list, bill of materials (sha256 per file)
├── simready_usd/<asset>.usd                   USD (crate), following NVIDIA SimReady: Isaac Sim / Omniverse
│   └── .thumbs/256x256/<asset>.usd{,_light,_transparent}.png
├── mjcf/<asset>.xml + mjcf/meshes/<asset>/*.stl    MuJoCo
├── urdf/<asset>.urdf + urdf/meshes/<asset>/*.stl   ROS / Gazebo
└── gltf/<asset>.glb                           Unity, three.js, Blender, Unreal, Godot (one file)
```

Folders are numbered (`01_atech_board_14port`, `02_atech_board_10port`, ...) only to set
the order the Hub lists them in; the files inside carry the plain asset name.
Asset names are `atech_<module id>` (e.g. `atech_distance_sensor`) and
`atech_board_<board id>` (e.g. `atech_board_14port`); the robot-arm module is
`atech_robot_arm_integrator`, its product name.

Generated with `atech sim-assets --all --board 8port,10port,14port` (USD, MJCF, URDF, glTF)
(`pip install "atech[sim]"`) on the SDK's development version, then repackaged one
folder per asset. The thumbnails
are MuJoCo renders of the MJCF, so they show the CAD's flat material colours, not
the USD's PBR shading or the display's screen texture.

## Unity, three.js and other engines: `gltf/<asset>.glb`

One self-contained file per asset, glTF 2.0 binary. It passes the Khronos glTF validator
with no errors or warnings. It keeps the CAD's own materials (metallic-roughness, the
clear glass lids through `KHR_materials_transmission` and `_ior`, emissive strength,
unlit silkscreen, and the textures embedded), which STL cannot carry. Nodes:

```
atech_<asset>                 root: turns the asset's +z up into glTF +y up
├── atech_<asset>_visual      the mesh, one primitive per material
├── atech_<asset>_connector   where a module meets a board port
├── atech_<asset>_sensor | _actuator
└── atech_<asset>_port_<n>    boards: one empty node per port
```

**Put a module on a board:** module root = `port node (world)` x `inverse(connector node
(world))`. glTF has no colliders or mass, so the root's `extras.atech` (`userData.atech`
in three.js) holds the collision boxes, the mass, the centre of mass and the friction.

**three.js:**

```js
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
const url = (folder) => `https://huggingface.co/datasets/atechdev/simready-assets/resolve/main/${folder}/gltf/${folder.slice(3)}.glb`;
const loader = new GLTFLoader();
const board = (await loader.loadAsync(url('01_atech_board_14port'))).scene;
const button = (await loader.loadAsync(url('15_atech_button'))).scene;
scene.add(board, button);
board.updateMatrixWorld(true); button.updateMatrixWorld(true);
const port = board.getObjectByName('atech_board_14port_port_1');
const conn = button.getObjectByName('atech_button_connector');
port.matrixWorld.clone().multiply(conn.matrixWorld.clone().invert())
  .decompose(button.position, button.quaternion, button.scale);
```

Give the scene an environment map (`RoomEnvironment`, or any HDRI) so the metals and
glass look right.

**Unity:** install glTFast (`com.unity.cloud.gltfast`, Package Manager) and drop the
`.glb` into `Assets/`. It imports as a prefab with the same node names, already
converted to Unity's frame. To seat a module:

```csharp
var m = port.localToWorldMatrix * connector.worldToLocalMatrix * module.localToWorldMatrix;
module.SetPositionAndRotation(m.GetPosition(), m.rotation);
```

glTFast does not import `extras`. Add a `BoxCollider` by hand, or read the boxes from
the file's JSON. Unity's URDF Importer also reads `urdf/` (STL meshes, URDF colours,
box colliders, mass).

**Blender, Unreal, Godot, Babylon.js, `<model-viewer>`:** open or import the `.glb` as is.

## What is real and what is not

- **Visuals** are Atech's production CAD (module-renders release v1.7), with the
  GLB's own PBR materials. **Colliders are boxes**: the bounds of that CAD.
- **The 8-port board** is Atech's CAD of it ("Node 8 Position Motherboard", from
  Atech's website models), not yet in the module-renders release; its source says so.
- **Derived models.** The PIR, CO₂ (SCD40), robot-arm, stepper, power-jack, soil-sensor
  and load-cell modules have no model in the CAD release. Theirs are built from the CAD that
  exists plus placeholder parts, and say `derived:` in every format
  (`atech:visual:source` in USD, the MJCF text, the URDF comment). They are not Atech CAD.
  The CO₂, robot-arm, power-jack, soil-sensor and load-cell modules follow Atech's
  product renders; the PIR is drawn as its
  AM312 sensor. The Robot Arm Integrator (`atech_robot_arm_integrator`, catalog id `robot_arm`) plugs into one port, but its housing is two cells
  long: its `connector` frame is the centre of the -x cell.
- **Masses and inertias are placeholders.** Atech has not published them.
- **Tested:** the `.glb` files pass the Khronos glTF validator and render in three.js
  (r170), as in the image above. They have not been opened in Unity here.
- With real CAD, NVIDIA's SimReady validator reports VG.007 warnings: the CAD
  tessellation has non-manifold vertices.

`atech guide sim` (in the SDK) documents every attribute and the full layout.