carla-canvas 0.1.1__tar.gz

carla_canvas-0.1.1/.github/actions/wheel/action.yml

@@ -0,0 +1,50 @@
+# One carla-canvas wheel for an architecture, on a runner of that architecture:
+# the sensor plugin with gRPC, protobuf and yaml-cpp built from source and linked
+# in statically (CARLA_CANVAS_FETCH_DEPS), checked as installed. Shared by CI and
+# the release workflow; the dependencies' build is cached between runs.
+name: carla-canvas wheel
+description: Builds and checks one carla-canvas manylinux wheel for an architecture
+inputs:
+  arch:
+    description: x86_64 or aarch64 (the runner's)
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Restore the dependencies' build
+      uses: actions/cache@v4
+      with:
+        path: ${{ runner.temp }}/wheel-build
+        # Keep the cibuildwheel version in step with `uses:` below.
+        # One entry (~1 GB) per dependency set: cmake/FetchDeps.cmake pins them.
+        key: wheel-manylinux_2_28-${{ inputs.arch }}-cibuildwheel-v3.1.4-${{ hashFiles('cmake/**') }}
+    - uses: pypa/cibuildwheel@v3.1.4
+      env:
+        CIBW_BUILD: cp312-manylinux_${{ inputs.arch }}
+        CIBW_ARCHS: ${{ inputs.arch }}
+        CIBW_MANYLINUX_X86_64_IMAGE: manylinux_2_28
+        CIBW_MANYLINUX_AARCH64_IMAGE: manylinux_2_28
+        # FetchDeps needs CMake 3.28+: scikit-build-core fetches it if the image's is older.
+        CIBW_ENVIRONMENT: SKBUILD_CMAKE_VERSION=">=3.28"
+        CIBW_CONTAINER_ENGINE: "docker; create_args: --volume=${{ runner.temp }}/wheel-build:/wheel-build"
+        CIBW_CONFIG_SETTINGS: >-
+          build-dir=/wheel-build/build
+          cmake.define.CARLA_CANVAS_FETCH_DEPS=ON
+          cmake.define.CARLA_CANVAS_REQUIRE_PLUGIN=ON
+        # Checked in the next step, as installed outside the source tree.
+        CIBW_TEST_SKIP: "*"
+      with:
+        output-dir: dist
+    # The container wrote the build directory as root; actions/cache saves it
+    # as the runner user.
+    - name: Hand the build back to the runner user
+      shell: bash
+      run: sudo chown -R "$(id -u):$(id -g)" "$RUNNER_TEMP/wheel-build"
+    - uses: actions/setup-python@v5
+      with: { python-version: "3.12" }
+    - name: Check the wheel (plugin, exports, no system gRPC/protobuf/yaml-cpp)
+      shell: bash
+      run: |
+        python -m venv /tmp/check
+        /tmp/check/bin/pip install dist/*.whl
+        cd /tmp && /tmp/check/bin/python "$GITHUB_WORKSPACE/tools/check_wheel.py"

carla_canvas-0.1.1/.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+env:
+  # typesafe_carla with the sensor source C ABI (5.3); mock backend: no CARLA server.
+  TYPESAFE_CARLA_REPO: hakuturu583/typesafe_carla
+  TYPESAFE_CARLA_REF: main
+
+jobs:
+  test:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ env.TYPESAFE_CARLA_REPO }}
+          ref: ${{ env.TYPESAFE_CARLA_REF }}
+          path: typesafe_carla
+      - name: System packages
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y g++ cmake zlib1g-dev libgrpc++-dev protobuf-compiler-grpc \
+            libprotobuf-dev protobuf-compiler libyaml-cpp-dev
+      - uses: astral-sh/setup-uv@v5
+      - name: Environment
+        run: |
+          uv venv
+          uv pip install scikit-build-core grpcio grpcio-tools protobuf numpy pyyaml pytest cyclonedds
+          TSC_BACKEND=mock uv pip install ./typesafe_carla
+          uv pip install --no-build-isolation --no-deps -e .
+      - name: Native tests
+        run: |
+          cmake -S . -B build -DCARLA_CANVAS_REQUIRE_PLUGIN=ON \
+            -DTYPESAFE_CARLA_INCLUDE_DIR=$PWD/typesafe_carla/native/include
+          cmake --build build -j
+          ctest --test-dir build --output-on-failure
+      - name: Python tests
+        run: PATH=$PWD/.venv/bin:$PATH .venv/bin/python -m pytest -v
+
+  wheel:
+    # The release wheel (x86_64): the plugin with gRPC, protobuf and yaml-cpp
+    # built from source, no system packages (.github/actions/wheel).
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/wheel
+        with:
+          arch: x86_64

carla_canvas-0.1.1/.github/workflows/release-label.yml

@@ -0,0 +1,45 @@
+# The release labels of the auto-release (release.yml): a PR merged to main with
+# release:major, release:minor or release:patch is released; with none, it is
+# not. This creates the labels if they are missing and fails a PR that carries
+# more than one.
+name: Release label
+
+on:
+  pull_request:
+    types: [opened, reopened, labeled, unlabeled, synchronize]
+
+permissions:
+  contents: read
+
+jobs:
+  label:
+    runs-on: ubuntu-24.04
+    permissions:
+      issues: write  # creating the labels
+    steps:
+      - name: Create the release labels
+        # A fork's PR gets a read-only token: the labels are created by the next
+        # PR from this repository instead.
+        if: github.event.pull_request.head.repo.full_name == github.repository
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          REPO: ${{ github.repository }}
+        run: |
+          gh label create release:major --repo "$REPO" --color b60205 --force \
+            --description "Merging releases a new major version (X.0.0)"
+          gh label create release:minor --repo "$REPO" --color fbca04 --force \
+            --description "Merging releases a new minor version (x.Y.0)"
+          gh label create release:patch --repo "$REPO" --color 0e8a16 --force \
+            --description "Merging releases a new patch version (x.y.Z)"
+      - name: At most one release label
+        env:
+          LABELS: ${{ toJSON(github.event.pull_request.labels.*.name) }}
+        run: |
+          count=$(echo "$LABELS" | jq '[.[] | select(test("^release:(major|minor|patch)$"))] | length')
+          if [ "$count" -gt 1 ]; then
+            echo "::error::More than one release label: pick one of release:major, release:minor, release:patch"
+            exit 1
+          fi
+          if [ "$count" -eq 0 ]; then
+            echo "No release label: merging does not release"
+          fi

carla_canvas-0.1.1/.github/workflows/release.yml

@@ -0,0 +1,280 @@
+# Cuts releases of carla-canvas and publishes its wheels and sdist to PyPI.
+#
+# The wheels carry the sensor plugin with gRPC, protobuf and yaml-cpp built
+# from source and linked in statically (CARLA_CANVAS_FETCH_DEPS), so
+# `pip install 'carla-canvas[client]'` needs no system packages: one
+# py3-none-manylinux_2_28 wheel per architecture.
+#
+# There are three ways in, and the first is the everyday one:
+#
+#   push to main   the auto-release path. When the merged PR carries exactly one
+#                  `release:major|minor|patch` label, the `release` job bumps the
+#                  version (tools/bump_version.py), commits it to main, tags
+#                  v<version> and drafts a GitHub release; the tag is built and
+#                  published to PyPI in this same run, and the GitHub release is
+#                  published last. No label, no release.
+#   push a tag v<version>   a hand-cut release: built and published directly
+#                  (the tag must match python/carla_canvas/__init__.py).
+#   workflow_dispatch       a dry run: builds and checks; with publish=true it
+#                  uploads to TestPyPI.
+#
+# It is one workflow rather than a separate `on: push: tags` one on purpose: the
+# auto-release tag is pushed with GITHUB_TOKEN, and a tag pushed with
+# GITHUB_TOKEN starts no new workflow runs, so the follow-up jobs of the run
+# that cut it build and publish it.
+#
+# Publishing uses PyPI Trusted Publishing (OIDC) from the "pypi" / "testpypi"
+# environments: register this workflow as the project's trusted publisher on
+# both indexes. No API tokens are stored.
+name: Release
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: "Upload to TestPyPI"
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+jobs:
+  # Reads the release label off the merged PR and, if there is one, bumps the
+  # version and pushes the tag. Only on a push to main.
+  release:
+    name: cut the release tag
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+      pull-requests: read
+    # Never two release cuts at once; a queued one runs after (and fails on the
+    # non-fast-forward push if main moved).
+    concurrency:
+      group: release-main
+      cancel-in-progress: false
+    outputs:
+      bump: ${{ steps.pr.outputs.bump }}
+      tag: ${{ steps.bump.outputs.tag }}
+    steps:
+      - name: Read the release label off the merged PR
+        id: pr
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -euo pipefail
+          # An API error fails the job; only an empty list means "no PR".
+          pr_json=$(gh api "repos/${{ github.repository }}/commits/${{ github.sha }}/pulls" \
+            --jq '.[0] // empty')
+          if [ -z "$pr_json" ]; then
+            echo "No PR associated with this push: nothing to release"
+            echo "bump=none" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          labels=$(echo "$pr_json" | jq -r '[.labels[].name] | join(",")')
+          bump=none
+          count=0
+          for lvl in major minor patch; do
+            if echo ",$labels," | grep -q ",release:${lvl},"; then
+              bump=$lvl
+              count=$((count + 1))
+            fi
+          done
+          if [ "$count" -gt 1 ]; then
+            echo "::error::More than one release label on the PR: pick exactly one"
+            exit 1
+          fi
+          echo "bump=${bump}" >> "$GITHUB_OUTPUT"
+          echo "Resolved bump level: ${bump}"
+
+      # The pushed commit, not whatever main is now: the bump is pushed to main
+      # without force, so if main has moved since, the push fails loudly.
+      - uses: actions/checkout@v4
+        if: steps.pr.outputs.bump != 'none'
+        with:
+          ref: ${{ github.sha }}
+          fetch-depth: 0
+
+      - name: Bump the version
+        if: steps.pr.outputs.bump != 'none'
+        id: bump
+        env:
+          BUMP: ${{ steps.pr.outputs.bump }}
+        run: |
+          set -euo pipefail
+          next=$(python3 tools/bump_version.py "$BUMP")
+          echo "version=${next}" >> "$GITHUB_OUTPUT"
+          echo "tag=v${next}" >> "$GITHUB_OUTPUT"
+          echo "Bumped to ${next} (${BUMP})"
+
+      - name: Fail if the version is already tagged or on PyPI
+        if: steps.pr.outputs.bump != 'none'
+        env:
+          VERSION: ${{ steps.bump.outputs.version }}
+          TAG: ${{ steps.bump.outputs.tag }}
+        run: |
+          set -euo pipefail
+          if git rev-parse "refs/tags/${TAG}" >/dev/null 2>&1; then
+            echo "::error::Tag ${TAG} already exists"
+            exit 1
+          fi
+          code=$(curl -s -o /dev/null -w '%{http_code}' "https://pypi.org/pypi/carla-canvas/${VERSION}/json")
+          if [ "$code" = 200 ]; then
+            echo "::error::carla-canvas ${VERSION} is already on PyPI"
+            exit 1
+          fi
+
+      - name: Commit, tag and push
+        if: steps.pr.outputs.bump != 'none'
+        env:
+          TAG: ${{ steps.bump.outputs.tag }}
+        run: |
+          set -euo pipefail
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add python/carla_canvas/__init__.py
+          git commit -m "chore(release): ${TAG}"
+          git tag -a "${TAG}" -m "Release ${TAG}"
+          # Both or neither: a main bump without its tag could not be re-run.
+          git push --atomic origin "HEAD:main" "refs/tags/${TAG}"
+
+      # A draft until `github-release` publishes it, after PyPI.
+      - name: Draft the GitHub release with generated notes
+        if: steps.pr.outputs.bump != 'none'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ steps.bump.outputs.tag }}
+        run: gh release create "${TAG}" --draft --verify-tag --title "${TAG}" --generate-notes
+
+  # For all three entry points: whether to build, which commit, and where to
+  # publish. Runs even when `release` is skipped (tag push, dispatch).
+  resolve:
+    name: resolve what to build
+    needs: [release]
+    if: always() && needs.release.result != 'failure' && needs.release.result != 'cancelled'
+    runs-on: ubuntu-24.04
+    outputs:
+      proceed: ${{ steps.r.outputs.proceed }}
+      ref: ${{ steps.r.outputs.ref }}
+      tag: ${{ steps.r.outputs.tag }}
+      index: ${{ steps.r.outputs.index }}
+    steps:
+      - id: r
+        env:
+          EVENT: ${{ github.event_name }}
+          REF_TYPE: ${{ github.ref_type }}
+          REF_NAME: ${{ github.ref_name }}
+          SHA: ${{ github.sha }}
+          BUMP: ${{ needs.release.outputs.bump }}
+          CUT_TAG: ${{ needs.release.outputs.tag }}
+          INPUT_PUBLISH: ${{ inputs.publish }}
+        run: |
+          set -euo pipefail
+          proceed=true; ref="$SHA"; tag=""; index=none
+          if [ "$EVENT" = push ] && [ "$REF_TYPE" = branch ]; then
+            if [ "${BUMP:-none}" = none ]; then
+              proceed=false
+            else
+              ref="refs/tags/${CUT_TAG}"; tag="$CUT_TAG"; index=pypi
+            fi
+          elif [ "$EVENT" = push ]; then
+            ref="refs/tags/${REF_NAME}"; tag="$REF_NAME"; index=pypi
+          elif [ "$INPUT_PUBLISH" = true ]; then
+            index=testpypi
+          fi
+          {
+            echo "proceed=$proceed"; echo "ref=$ref"; echo "tag=$tag"; echo "index=$index"
+          } >> "$GITHUB_OUTPUT"
+          echo "proceed=$proceed ref=$ref tag=$tag index=$index"
+
+  version:
+    needs: resolve
+    if: always() && needs.resolve.outputs.proceed == 'true'
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with: { ref: "${{ needs.resolve.outputs.ref }}" }
+      - name: The tag matches the package version
+        env:
+          TAG: ${{ needs.resolve.outputs.tag }}
+        run: |
+          version=$(python3 tools/bump_version.py --current)
+          echo "carla-canvas ${version}"
+          if [ -n "$TAG" ] && [ "$TAG" != "v$version" ]; then
+            echo "::error::tag $TAG does not match the package version $version"
+            exit 1
+          fi
+
+  wheel:
+    name: wheel (${{ matrix.arch.name }})
+    needs: [resolve, version]
+    if: always() && needs.version.result == 'success'
+    strategy:
+      fail-fast: false
+      matrix:
+        arch:
+          - { name: x86_64, runner: ubuntu-24.04 }
+          - { name: aarch64, runner: ubuntu-24.04-arm }
+    runs-on: ${{ matrix.arch.runner }}
+    steps:
+      - uses: actions/checkout@v4
+        with: { ref: "${{ needs.resolve.outputs.ref }}" }
+      - uses: ./.github/actions/wheel
+        with:
+          arch: ${{ matrix.arch.name }}
+      - uses: actions/upload-artifact@v4
+        with: { name: "dist-wheel-${{ matrix.arch.name }}", path: dist/*.whl }
+
+  sdist:
+    needs: [resolve, version]
+    if: always() && needs.version.result == 'success'
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with: { ref: "${{ needs.resolve.outputs.ref }}" }
+      - uses: actions/setup-python@v5
+        with: { python-version: "3.12" }
+      - run: pipx run build --sdist
+      - uses: actions/upload-artifact@v4
+        with: { name: dist-sdist, path: dist/*.tar.gz }
+
+  publish:
+    needs: [resolve, wheel, sdist]
+    if: >-
+      always() && needs.wheel.result == 'success' && needs.sdist.result == 'success'
+      && needs.resolve.outputs.index != 'none'
+    runs-on: ubuntu-24.04
+    environment: ${{ needs.resolve.outputs.index }}
+    permissions:
+      id-token: write  # Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with: { pattern: "dist-*", path: dist, merge-multiple: true }
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: ${{ needs.resolve.outputs.index == 'pypi' && 'https://upload.pypi.org/legacy/' || 'https://test.pypi.org/legacy/' }}
+
+  # Publishes the GitHub release once PyPI has the version: the auto-release
+  # path drafted it in `release`; a hand-cut tag gets one here.
+  github-release:
+    needs: [resolve, publish]
+    if: always() && needs.publish.result == 'success' && needs.resolve.outputs.tag != ''
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+    steps:
+      - env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ needs.resolve.outputs.tag }}
+          REPO: ${{ github.repository }}
+        run: |
+          set -euo pipefail
+          if gh release view "$TAG" --repo "$REPO" >/dev/null 2>&1; then
+            gh release edit "$TAG" --repo "$REPO" --draft=false
+          else
+            gh release create "$TAG" --repo "$REPO" --verify-tag --title "$TAG" --generate-notes
+          fi

carla_canvas-0.1.1/.gitignore

@@ -0,0 +1,7 @@
+build/
+dist/
+.venv/
+__pycache__/
+*.egg-info/
+*.so
+demo_assets/

carla_canvas-0.1.1/CLAUDE.md

@@ -0,0 +1,54 @@
+# carla_canvas
+
+Swaps CARLA's camera/LiDAR rendering (3D Gaussian splatting or any renderer)
+behind the CARLA API for typesafe_carla programs: a typesafe_carla sensor
+plugin (C++, `native/`) ↔ gRPC (`proto/carla_canvas/v1/renderer.proto`) ↔
+renderer service (Python, `python/carla_canvas/`). Design: `docs/design.md`.
+
+## Commands
+
+```sh
+uv venv && TSC_BACKEND=mock uv pip install -e ../typesafe_carla   # typesafe_carla with ABI >= 5.3
+uv pip install scikit-build-core grpcio grpcio-tools protobuf numpy pyyaml pytest cyclonedds
+uv pip install --no-build-isolation -e .                 # builds libcarla_canvas_plugin.so
+cmake -S . -B build && cmake --build build -j && ctest --test-dir build
+PATH=$PWD/.venv/bin:$PATH .venv/bin/python -m pytest     # e2e tests run Codon programs (mock CARLA)
+.venv/bin/python tools/gen_proto.py                      # after editing proto/ (commit the output)
+CARLA_CANVAS_CONFIG=examples/primitives.yaml typesafe-codon run examples/camera_lidar.py
+```
+
+The plugin uses the system's gRPC C++, protobuf and yaml-cpp (`libgrpc++-dev
+protobuf-compiler-grpc libprotobuf-dev protobuf-compiler libyaml-cpp-dev`), or
+builds them from source with `-DCARLA_CANVAS_FETCH_DEPS=ON` (`cmake/FetchDeps.cmake`,
+pinned versions; what the release wheels do: `.github/actions/wheel`,
+`tools/check_wheel.py`).
+
+Releases: a PR merged to main with one `release:major|minor|patch` label is
+released by `.github/workflows/release.yml` (bumps `__version__` with
+`tools/bump_version.py`, tags `v<version>`, publishes to PyPI). Do not bump the
+version or tag by hand.
+
+## Rules
+
+- The user's program never changes: everything is chosen by the file in
+  `CARLA_CANVAS_CONFIG`. Do not add carla_canvas imports to examples or tests
+  of programs (`examples/camera_lidar.py` is typesafe_carla's example).
+- The protocol mirrors the CARLA API (names, units, Unreal's left-handed
+  frame, world transforms, CARLA's raw measurement layouts). A protocol
+  change bumps `kProtocolVersion` (plugin.cpp) and `PROTOCOL_VERSION`
+  (server/service.py) together, and regenerates `python/carla_canvas/v1/`.
+- CARLA semantics live in the service, not in renderers: encodings
+  (`encodings.py`), the LiDAR model (`lidar.py`, mirrors RayCastLidar), sensor
+  attributes and defaults (`sensors.py`), ROS 2 (`ros/`). A renderer only
+  implements `load_world` / `render_camera` (and optionally `cast_rays`).
+- ROS 2 output mirrors CARLA's publishers (`LibCarla/source/carla/ros2`):
+  topic names, types, frame ids, y negation, TransformFromCarlaRotation.
+  Renderers never implement DDS.
+- The plugin talks to typesafe_carla only through `get_proc` (`tsc_api.hpp`);
+  it must not link against the library. It needs typesafe_carla's C ABI 5.3+.
+- 3D Gaussian splatting for real use is splatsim's backend (its repository
+  depends on carla_canvas). `renderers/gaussian_splatting.py` and
+  `primitives.py` are reference and test renderers: keep them numpy-only and
+  covered by the CPU tests.
+- `ros/dds_types.py` must not use `from __future__ import annotations`
+  (cyclonedds resolves field types from the module's globals).

carla_canvas-0.1.1/CMakeLists.txt

@@ -0,0 +1,155 @@
+cmake_minimum_required(VERSION 3.20)
+project(carla_canvas LANGUAGES C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+# The sensor plugin needs gRPC C++, protobuf, yaml-cpp and typesafe_carla's
+# header. Without them (a renderer-only install: the Python SDK is all a
+# renderer host needs) it is skipped, unless CARLA_CANVAS_REQUIRE_PLUGIN is ON.
+# With CARLA_CANVAS_FETCH_DEPS, the missing ones are built from source (the
+# published wheels; a source build without system packages).
+option(CARLA_CANVAS_REQUIRE_PLUGIN "Fail when the sensor plugin cannot be built" OFF)
+option(CARLA_CANVAS_FETCH_DEPS
+       "Build missing gRPC, protobuf and yaml-cpp from source, and download typesafe_carla's header"
+       OFF)
+find_package(Threads REQUIRED)
+find_package(Protobuf QUIET)
+find_package(gRPC CONFIG QUIET)
+find_package(yaml-cpp QUIET)
+find_program(GRPC_CPP_PLUGIN grpc_cpp_plugin)
+if(CARLA_CANVAS_FETCH_DEPS)
+  include(cmake/FetchDeps.cmake)
+endif()
+# gRPC and protobuf: the system's, or both from gRPC's source tree.
+if(Protobuf_FOUND AND gRPC_FOUND AND GRPC_CPP_PLUGIN)
+  set(_protoc protobuf::protoc)
+  set(_grpc_cpp_plugin "${GRPC_CPP_PLUGIN}")
+  set(_protobuf_lib protobuf::libprotobuf)
+  set(_grpc_lib gRPC::grpc++)
+elseif(CARLA_CANVAS_FETCH_DEPS)
+  carla_canvas_fetch_grpc()
+  set(_protoc protoc)
+  set(_grpc_cpp_plugin "$<TARGET_FILE:grpc_cpp_plugin>")
+  set(_protobuf_lib libprotobuf)
+  set(_grpc_lib grpc++)
+  # protobuf's well-known types (google/protobuf/struct.proto)
+  set(_proto_include --proto_path "${grpc_SOURCE_DIR}/third_party/protobuf/src")
+endif()
+if(NOT yaml-cpp_FOUND AND CARLA_CANVAS_FETCH_DEPS)
+  carla_canvas_fetch_yaml_cpp()
+endif()
+# ---------------------------------------------------------------------------
+# typesafe_carla's C ABI header (typesafe_carla/ffi.h, ABI 5.3 or later).
+# The plugin does not link against the library (it gets the functions through
+# get_proc at load time), it only needs the declarations. Found, in order:
+# TYPESAFE_CARLA_INCLUDE_DIR, the installed typesafe_carla Python package
+# (typesafe_carla.paths.include_dir()), a sibling checkout ../typesafe_carla.
+# ---------------------------------------------------------------------------
+set(TYPESAFE_CARLA_INCLUDE_DIR "$ENV{TYPESAFE_CARLA_INCLUDE_DIR}" CACHE PATH
+    "Directory containing typesafe_carla/ffi.h")
+if(NOT TYPESAFE_CARLA_INCLUDE_DIR)
+  find_package(Python COMPONENTS Interpreter QUIET)
+  if(Python_EXECUTABLE)
+    execute_process(
+      COMMAND "${Python_EXECUTABLE}" -c
+              "from typesafe_carla import paths; print(paths.include_dir())"
+      OUTPUT_VARIABLE _tsc_include OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET
+      RESULT_VARIABLE _tsc_result)
+    if(_tsc_result EQUAL 0 AND EXISTS "${_tsc_include}/typesafe_carla/ffi.h")
+      set(TYPESAFE_CARLA_INCLUDE_DIR "${_tsc_include}")
+    endif()
+  endif()
+endif()
+if(NOT TYPESAFE_CARLA_INCLUDE_DIR AND
+   EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../typesafe_carla/native/include/typesafe_carla/ffi.h")
+  set(TYPESAFE_CARLA_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../typesafe_carla/native/include")
+endif()
+if(NOT TYPESAFE_CARLA_INCLUDE_DIR AND CARLA_CANVAS_FETCH_DEPS)
+  carla_canvas_fetch_tsc_header(TYPESAFE_CARLA_INCLUDE_DIR)
+endif()
+set(_missing "")
+if(NOT EXISTS "${TYPESAFE_CARLA_INCLUDE_DIR}/typesafe_carla/ffi.h")
+  list(APPEND _missing "typesafe_carla/ffi.h (install typesafe-carla or set TYPESAFE_CARLA_INCLUDE_DIR)")
+endif()
+if(NOT _grpc_lib)
+  list(APPEND _missing "gRPC C++ and protobuf")
+endif()
+if(NOT TARGET yaml-cpp::yaml-cpp)
+  list(APPEND _missing "yaml-cpp")
+endif()
+if(_missing AND NOT CARLA_CANVAS_FETCH_DEPS)
+  list(APPEND _missing "(or -DCARLA_CANVAS_FETCH_DEPS=ON to build them from source)")
+endif()
+if(_missing)
+  if(CARLA_CANVAS_REQUIRE_PLUGIN)
+    message(FATAL_ERROR "carla_canvas: cannot build the sensor plugin, missing: ${_missing}")
+  endif()
+  message(WARNING "carla_canvas: not building the sensor plugin (renderer-only install), "
+                  "missing: ${_missing}")
+  return()
+endif()
+message(STATUS "carla_canvas: typesafe_carla header from ${TYPESAFE_CARLA_INCLUDE_DIR}")
+
+# ---------------------------------------------------------------------------
+# gRPC / protobuf / yaml-cpp (Ubuntu: libgrpc++-dev protobuf-compiler-grpc
+# libprotobuf-dev protobuf-compiler libyaml-cpp-dev)
+# ---------------------------------------------------------------------------
+
+set(_proto_dir "${CMAKE_CURRENT_SOURCE_DIR}/proto")
+set(_proto "${_proto_dir}/carla_canvas/v1/renderer.proto")
+set(_gen "${CMAKE_CURRENT_BINARY_DIR}/generated")
+set(_gen_srcs
+  "${_gen}/carla_canvas/v1/renderer.pb.cc"
+  "${_gen}/carla_canvas/v1/renderer.grpc.pb.cc")
+add_custom_command(
+  OUTPUT ${_gen_srcs}
+         "${_gen}/carla_canvas/v1/renderer.pb.h"
+         "${_gen}/carla_canvas/v1/renderer.grpc.pb.h"
+  COMMAND "${CMAKE_COMMAND}" -E make_directory "${_gen}"
+  COMMAND ${_protoc}
+          --proto_path "${_proto_dir}" ${_proto_include}
+          --cpp_out "${_gen}"
+          --grpc_out "${_gen}"
+          --plugin=protoc-gen-grpc=${_grpc_cpp_plugin}
+          "${_proto}"
+  DEPENDS "${_proto}" ${_protoc} $<$<TARGET_EXISTS:grpc_cpp_plugin>:grpc_cpp_plugin>
+  COMMENT "Generating the renderer protocol (C++)")
+
+# ---------------------------------------------------------------------------
+# The sensor plugin (loaded by typesafe_carla: TYPESAFE_CARLA_SENSOR_PLUGIN)
+# ---------------------------------------------------------------------------
+add_library(carla_canvas_plugin MODULE
+  native/src/plugin.cpp
+  native/src/config.cpp
+  ${_gen_srcs})
+target_include_directories(carla_canvas_plugin PRIVATE
+  "${TYPESAFE_CARLA_INCLUDE_DIR}" "${_gen}" native/src)
+target_link_libraries(carla_canvas_plugin PRIVATE
+  ${_grpc_lib} ${_protobuf_lib} yaml-cpp::yaml-cpp Threads::Threads)
+set_target_properties(carla_canvas_plugin PROPERTIES
+  OUTPUT_NAME carla_canvas_plugin
+  CXX_VISIBILITY_PRESET hidden
+  VISIBILITY_INLINES_HIDDEN ON)
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+  target_compile_options(carla_canvas_plugin PRIVATE -Wall -Wextra)
+  # Export only tsc_sensor_plugin_init.
+  target_link_options(carla_canvas_plugin PRIVATE
+    "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/native/src/exports.map")
+endif()
+
+install(TARGETS carla_canvas_plugin LIBRARY DESTINATION carla_canvas/_native
+        COMPONENT carla_canvas)
+
+option(CARLA_CANVAS_BUILD_TESTS "Build native tests" ON)
+if(CARLA_CANVAS_BUILD_TESTS)
+  enable_testing()
+  add_executable(test_config native/tests/test_config.cpp native/src/config.cpp)
+  target_include_directories(test_config PRIVATE native/src)
+  target_link_libraries(test_config PRIVATE ${_protobuf_lib} yaml-cpp::yaml-cpp)
+  add_test(NAME test_config COMMAND test_config "${CMAKE_CURRENT_SOURCE_DIR}/native/tests")
+endif()

carla_canvas-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 carla_canvas contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.