Developer Guide

Installation & Setup

Getting started with Project Iris is straightforward. You can install the plugin from the Unreal Marketplace (search "Project Iris") or via our GitHub releases. After installation, enable the **ProjectIris** plugin in your Unreal Engine project settings and restart the editor. The plugin does not require a separate ROS 2 installation – all necessary communication libraries (Fast DDS and message definitions) are bundled:contentReference[oaicite:25]{index=25}. (On Windows, ensure Visual C++ redistributables are installed if deploying, as the DDS library may depend on them. On Linux, the plugin ships with precompiled libraries for easy setup.)

By default, Project Iris will use ROS 2’s default domain (ID 0). If you need to change the DDS domain to match your ROS 2 network (for example, if isolating multiple simulations), you can do so in the Project Settings under **Project Iris → Networking**. Similarly, you can specify if the plugin should use a ROS 2 Discovery Server or other advanced DDS options if your deployment requires it (see advanced documentation).

Quick Start Example

Let’s walk through a simple use-case: **Streaming a Camera to ROS 2**.

1. In Unreal Editor, select the Camera actor in your scene (or add a new Camera).
2. In the **Details** panel, click **Add Component** and choose IrisPublisher (from the Project Iris category).
3. With the IrisPublisher component selected, find its settings:
   • Set **Message Type** to sensor_msgs/Image (this tells IrisCore what type of ROS 2 message to use for the camera feed).
   • Set **Topic Name** to something like /camera_front/image_raw – this is the ROS 2 topic name that will be used.
   • Optionally adjust the **Publish Rate** (for example, 30 Hz for a reasonable frame rate).
   • Ensure **QoS** is set as desired (e.g., reliability = Best Effort for images by default, which is typical).
4. Press Play. Now, on the ROS 2 side (on any machine reachable on the network, or the same machine), you can run:

   $ ros2 topic list

   You should see /camera_front/image_raw in the list. ROS 2 nodes can subscribe to this topic (e.g., ros2 topic echo /camera_front/image_raw or view it in RViz) and receive the images from Unreal in real time.

That’s it – you have a live Unreal Engine camera publishing to ROS 2! The process for other sensors or data (Lidar scans, IMUs, etc.) is similar: attach an Iris publisher component, select the appropriate message type (e.g., sensor_msgs/LaserScan, sensor_msgs/Imu) and configure the topic name. For controlling Unreal from ROS 2, you would use IrisSubscriber components in a similar fashion to receive data.

Key Components & API

Project Iris provides both Blueprint and C++ APIs. Here’s a brief overview of the primary components and classes:

• IrisCoreSubsystem – A subsystem (likely a singleton) that manages the IrisCore functionalities. It may not be directly used often by end users, but it's good to know it's there handling DDS initialization, etc.
• IrisPublisher Component – A Blueprintable Unreal Actor Component that publishes a specified ROS 2 message type. You configure topic name, QoS, and can call its Publish() method in C++ or Blueprint (or let it auto-publish at a fixed rate if supported).
• IrisSubscriber Component – Similarly, an Actor Component that subscribes to a ROS 2 topic. You set the message type and topic, and bind an event or implement a callback to handle incoming messages (e.g., update your actor state when a message arrives).
• IrisServiceClient / IrisServiceServer (if provided) – For ROS 2 Services support. These would let you call or implement ROS 2 services from within Unreal. (Project Iris’s initial release focuses on topics; service/action support may be in roadmap depending on demand.)
• Message Type Support – Under the hood, Project Iris includes definitions for the common ROS 2 interface packages (std_msgs, sensor_msgs, geometry_msgs, etc.), so you can select those types in the editor. For custom messages, you'll use our code generation tool or scripts to import the ROS 2 IDL and generate an Unreal-compatible message struct (documentation for this process is provided). :contentReference[oaicite:26]{index=26}:contentReference[oaicite:27]{index=27}
• QoS Settings – Each publisher/subscriber component exposes QoS parameters (Reliability, Durability, History, Depth, etc.) with sensible defaults. You can tweak these as needed to simulate different network conditions or requirements (e.g., simulate unreliable networks by switching to Best Effort, or ensure critical telemetry is reliable).

The C++ API mirrors these capabilities. For instance, you can include the Project Iris headers and use classes like UIrisPublisherComponent in C++ to create a publisher programmatically, or call functions to send messages. Consult the full API reference for details on each class and method.

Further Documentation & Support

For more detailed documentation, please refer to our **Project Iris Documentation Portal** (link) which includes a full user manual, troubleshooting guide, and API reference. There you’ll find information on advanced configuration, using Discovery Servers, performance tuning tips (like adjusting thread priorities or buffer sizes), and more.

If you encounter any issues or have questions, check out the **Community & Support** channels. We have an active Discord community and GitHub discussions where you can ask questions, report bugs, or share your use cases. Links to these can be found on our Contact page. We’re committed to making Project Iris useful for the community – contributions and feedback are welcome!