cmake: converge to generic find_package(Avendish) + avnd_addon_* setup (#2)

* ci: use ossia/actions/avendish-template composite action

* ci: point avendish-template action at @master

* cmake: migrate to find_package(Avendish) + avnd_addon_* (builds as score addon or standalone)

* cmake: bump avendish pin

* ci: replace legacy CI with avnd-addon.yml + portability workflows

builds.yaml calls avnd-addon.yml@master with the texture/video back-ends
this template emits (max, gstreamer, touchdesigner, godot, python).
portability.yml calls avnd-portability.yml@master (iOS off). Drop legacy
build_cmake.yml; re-pin avendish to main (7f7dac9).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* cmake: add explicit dump backend for the portability CI

The BACKENDS form (unlike the CATEGORY presets) doesn't emit the
<C_NAME>_dump target, so the portability workflow had nothing plain-C++
to build and failed (no dump target + halp/ headers off the include
path). List `dump` explicitly — better than relying on an implicit
avendish-side change.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* cmake: bump avendish pin to main (post enum-control fix #107)

Moves off the temporary feature-branch SHA to avendish main, which now
includes the wasm enum-control fix.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jcelerier

.github/workflows/build_cmake.yml

@@ -0,0 +1,24 @@
+name: Build
+
+on:
+  pull_request:
+  push:
+    branches: [main, master]
+    tags: ['v*']
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  ci:
+    uses: ossia/actions/.github/workflows/avnd-addon.yml@master
+    secrets: inherit
+    with:
+      # Texture / video back-ends:
+      # BACKENDS ossia max gstreamer:TEXTURE touchdesigner:TOP godot:TEXTURE python
+      max: true
+      gstreamer: true
+      touchdesigner: true
+      godot: true
+      python: true

.github/workflows/builds.yaml

@@ -0,0 +1,19 @@
+name: Portability
+
+on:
+  pull_request:
+  push:
+    branches: [main, master]
+
+concurrency:
+  group: ${{ github.workflow }}-portability-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  smoke:
+    uses: ossia/actions/.github/workflows/avnd-portability.yml@master
+    secrets: inherit
+    with:
+      # iOS off: Xcode multi-config plumbing fails and iOS isn't a meaningful
+      # target. The other 20 lanes cover the portability surface.
+      ios: false

.github/workflows/portability.yml

@@ -1,82 +1,68 @@
-cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.24 FATAL_ERROR)
 
 project(MyVideo CXX)
 
-include(dependencies.cmake)
+# Use the Avendish the host already provides (e.g. ossia score); otherwise fetch it.
+# The same CMakeLists builds these as ossia/score add-on objects or as standalone objects.
+find_package(Avendish QUIET)
+if(NOT Avendish_FOUND)
+  include(FetchContent)
+  FetchContent_Declare(
+    Avendish
+    GIT_REPOSITORY "https://github.com/celtera/avendish"
+    GIT_TAG 6dacc12)
+  FetchContent_Populate(Avendish)
+  list(APPEND CMAKE_PREFIX_PATH "${avendish_SOURCE_DIR}")
+  find_package(Avendish REQUIRED)
+endif()
+
+avnd_addon_init(NAME MyVideo)
 
 # This template ships three canonical video objects, one per role:
-#
 #   * MyVideoGenerator (src/Generator.hpp) - a source: texture output, no input
 #   * MyVideoFilter    (src/Filter.hpp)    - a filter: texture input + output
-#   * MyVideoSink       (src/Sink.hpp)      - a sink:   texture input, no output
-#
-# avnd_make_texture instantiates, for each object, the video / texture back-ends:
-#   - ossia (for use inside ossia score)
-#   - Max/MSP (a Jitter matrix / texture object)
-#   - GStreamer (a video/x-raw element: source / transform / sink)
-#   - TouchDesigner TOP (Texture Operator)
-#   - Godot GDExtension (a Node exposing an ImageTexture)
+#   * MyVideoSink      (src/Sink.hpp)      - a sink:   texture input, no output
 #
-# avnd_make_python additionally emits a Python extension module (py<c_name>) per
-# object, importable from Python (requires pybind11 + the Python dev headers).
-#
-# The relevant SDK paths must be passed to CMake for the optional back-ends to be
-# built (see the README). Back-ends whose SDK is not found are silently skipped.
-function(add_video_object target main_class c_name source impl)
-  add_library(${target} STATIC "${impl}" "${source}")
-
-  avnd_make_texture(
-    TARGET ${target}
-    MAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/${source}"
-    MAIN_CLASS ${main_class}
+# BACKENDS lists the texture back-ends (ossia, Max/MSP Jitter, GStreamer video, TD TOP,
+# Godot) plus a Python extension module, and `dump` — the plain-C++ introspection
+# target the portability CI builds (the CATEGORY presets include it implicitly; the
+# explicit BACKENDS form does not, so we list it). In a score build the back-end list
+# is ignored and only the ossia process is produced. Back-ends whose SDK is absent
+# are skipped.
+function(add_video_object main_class c_name source impl)
+  avnd_addon_object(
+    BASE MyVideo
     C_NAME ${c_name}
-  )
-
-  avnd_make_python(
-    TARGET ${target}
+    CLASS ${main_class}
+    BACKENDS dump ossia max gstreamer:TEXTURE touchdesigner:TOP godot:TEXTURE python
     MAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/${source}"
-    MAIN_CLASS ${main_class}
-    C_NAME ${c_name}
-  )
+    SOURCES "${impl}" "${source}")
 
-  # Workaround: avnd_make_python builds the module as a plain shared library, so it
-  # inherits the platform-default name (lib-prefixed .dylib on macOS, .dll on Windows).
-  # CPython only imports an extension module from a file named "<module>.so" (Unix) or
-  # "<module>.pyd" (Windows) with no "lib" prefix, so force that here — otherwise the
-  # module is unimportable on macOS/Windows (Linux's default .so happens to work).
-  if(TARGET ${target}_python)
-    set_target_properties(${target}_python PROPERTIES PREFIX "")
+  # avnd_make_python builds the module as a plain shared library, so it inherits the
+  # platform-default name (lib-prefixed .dylib on macOS, .dll on Windows). CPython only
+  # imports an extension module named "<module>.so" (Unix) / "<module>.pyd" (Windows)
+  # with no "lib" prefix, so force that here (no-op in a score build: no _python target).
+  if(TARGET ${c_name}_python)
+    set_target_properties(${c_name}_python PROPERTIES PREFIX "")
     if(WIN32)
-      set_target_properties(${target}_python PROPERTIES SUFFIX ".pyd")
+      set_target_properties(${c_name}_python PROPERTIES SUFFIX ".pyd")
     else()
-      set_target_properties(${target}_python PROPERTIES SUFFIX ".so")
+      set_target_properties(${c_name}_python PROPERTIES SUFFIX ".so")
     endif()
   endif()
-
-  # Workaround: when godot-cpp is pulled in via FetchContent, its only targets are
-  # `godot-cpp` (+ alias `godot::cpp`) — there is no `godot-cpp::godot-cpp`. Avendish's
-  # avnd_make_godot doesn't always resolve the target, so the generated headers under
-  # <godot-cpp-build>/gen/include never make it onto the GDExtension's include path and
-  # compilation fails with "godot_cpp/classes/node.hpp not found". Re-linking the target
-  # here (at a scope where it is visible) propagates godot-cpp's PUBLIC include dirs.
-  if(TARGET ${target}_TEXTURE_godot AND TARGET godot-cpp)
-    target_link_libraries(${target}_TEXTURE_godot PRIVATE godot-cpp)
-  endif()
 endfunction()
 
-add_video_object(MyVideoGenerator MyVideoGenerator my_video_generator src/Generator.hpp src/Generator.cpp)
-add_video_object(MyVideoFilter    MyVideoFilter    my_video_filter    src/Filter.hpp    src/Filter.cpp)
-add_video_object(MyVideoSink      MyVideoSink      my_video_sink      src/Sink.hpp      src/Sink.cpp)
+add_video_object(MyVideoGenerator my_video_generator src/Generator.hpp src/Generator.cpp)
+add_video_object(MyVideoFilter    my_video_filter    src/Filter.hpp    src/Filter.cpp)
+add_video_object(MyVideoSink      my_video_sink      src/Sink.hpp      src/Sink.cpp)
+
+avnd_addon_finalize(NAME MyVideo UUID 7ecd8671-33ca-4362-a514-1076c579c1c2 VERSION 1.0.0)
 
 # Unit tests exercising the Python back-end (tests/test_python_bindings.py). Registered
 # only when the Python modules were actually built (pybind11 + Python dev headers found).
 # Run with: ctest --test-dir <build> --output-on-failure
-#
-# Re-resolve the interpreter in this scope (Avendish found it GLOBAL, but the
-# Python_EXECUTABLE variable lives in the package's scope, not ours); this reuses the
-# cache and is the same interpreter the modules were compiled against.
 find_package(Python COMPONENTS Interpreter QUIET)
-if(TARGET MyVideoGenerator_python AND Python_EXECUTABLE)
+if(TARGET my_video_generator_python AND Python_EXECUTABLE)
   enable_testing()
 
   add_test(
@@ -85,9 +71,7 @@ if(TARGET MyVideoGenerator_python AND Python_EXECUTABLE)
             -s "${CMAKE_CURRENT_SOURCE_DIR}/tests" -p "test_*.py" -v
   )
 
-  # The compiled extension modules only import under the interpreter that built them;
-  # point the test at the build's python/ output dir and run it with that same Python.
   set_tests_properties(python_bindings PROPERTIES
-    ENVIRONMENT "AVND_PYTHON_MODULE_DIR=$<TARGET_FILE_DIR:MyVideoGenerator_python>"
+    ENVIRONMENT "AVND_PYTHON_MODULE_DIR=$<TARGET_FILE_DIR:my_video_generator_python>"
   )
 endif()

CMakeLists.txt

@@ -27,7 +27,7 @@ what makes it a sink is the absence of a *texture* output.
 
 ## What gets built
 
-The `avnd_make_texture(...)` calls in `CMakeLists.txt` instantiate the texture back-ends.
+The `avnd_addon_object(... BACKENDS ...)` calls in `CMakeLists.txt` instantiate the texture back-ends (and a Python module). The same file also builds as an ossia/score add-on via `find_package(Avendish)`.
 For each of the three objects you get:
 
 | Back-end | Object kind | SDK required |