CMakeLists.txt

# Example Audio Plugin CMakeLists.txt

# To get started on a new plugin, copy this entire folder (containing this file and C++ sources) to a convenient
# location, and then start making modifications.

# The first line of any CMake project should be a call to `cmake_minimum_required`, which checks that the installed
# CMake will be able to understand the following CMakeLists, and ensures that CMake's behaviour is compatible with the
# named version. This is a standard CMake command, so more information can be found in the CMake docs.

cmake_minimum_required(VERSION 3.15)

# TODO docs

set(PROJECT plugin-example)

# TODO docs

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

# The top-level CMakeLists.txt file for a project must contain a literal, direct call to the `project()` command.
# `project()` sets up some helpful variables that describe source/binary directories, and the current project version.
# This is a standard CMake command.

project(${PROJECT}
    LANGUAGES C CXX
    VERSION 0.0.1
)

# If you've installed JUCE somehow (via a package manager, or directly using the CMake install target), you'll need to
# tell this project that it depends on the installed copy of JUCE. If you've included JUCE directly in your source tree
# (perhaps as a submodule), you'll need to tell CMake to include that subdirectory as part of the build.

# In here we use a specific JUCE version if doing MOD builds, otherwise we use our local JUCE copy.

if(JUCE_MOD_BUILD)
    find_package(JUCE-8.0.4 REQUIRED)
else()
    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/JUCE)
endif()

# Set which plugin formats to build for. Some formats might require additional arguments to be passed in the
# `juce_add_plugin` call below.

set(PLUGIN_FORMATS LV2)

# for local testing
# list(APPEND PLUGIN_FORMATS Standalone)

# `juce_add_plugin` adds a static library target with the name passed as the first argument. This target is a normal
# CMake target, but has a lot of extra properties set up by default. As well as this shared code static library, this
# function adds targets for each of the formats specified by the FORMATS arguments. This function accepts many optional
# arguments. Check the readme at `docs/CMake API.md` in the JUCE repo for the full list.

juce_add_plugin(${PROJECT}
    FORMATS ${PLUGIN_FORMATS}
    LV2URI "urn:modaudio:juce-example"
)

# If your target needs extra binary assets, you can add them here. The first argument is the name of a new static
# library target that will include all the binary resources. There is an optional `NAMESPACE` argument that can specify
# the namespace of the generated binary data class. Finally, the SOURCES argument should be followed by a list of
# source files that should be built into the static library. These source files can be of any kind (wav data, images,
# fonts, icons etc.). Conversion to binary-data will happen when your target is built.

# juce_add_binary_data(AudioPluginData SOURCES ...)

# `juce_generate_juce_header` will create a JuceHeader.h for a given target, which will be generated into your build
# tree. This should be included with `#include <JuceHeader.h>`. The include path for this header will be automatically
# added to the target. The main function of the JuceHeader is to include all your JUCE module headers; if you're happy
# to include module headers directly, you probably don't need to call this.

# juce_generate_juce_header(SimpleGainPlugin)

# `target_compile_definitions` adds some preprocessor definitions to our target. In a Projucer project, these might be
# passed in the 'Preprocessor Definitions' field. JUCE modules also make use of compile definitions to switch certain
# features on/off, so if there's a particular feature you need that's not on by default, check the module header for
# the correct flag to set here. These definitions will be visible both to your code, and also the JUCE module code, so
# for new definitions, pick unique names that are unlikely to collide! This is a standard CMake command.

target_compile_definitions(${PROJECT}
    PUBLIC
        # JUCE_WEB_BROWSER and JUCE_USE_CURL would be on by default, but you might not need them.
        JUCE_WEB_BROWSER=0  # If you remove this, add `NEEDS_WEB_BROWSER TRUE` to the `juce_add_plugin` call
        JUCE_USE_CURL=0     # If you remove this, add `NEEDS_CURL TRUE` to the `juce_add_plugin` call
        JUCE_VST3_CAN_REPLACE_VST2=0
)

# `target_link_libraries` links libraries and JUCE modules to other libraries or executables. Here, we're linking our
# executable target to the `juce::juce_audio_utils` module. Inter-module dependencies are resolved automatically, so
# `juce_core`, `juce_events` and so on will also be linked automatically. If we'd generated a binary data target above,
# we would need to link to it here too. This is a standard CMake command.

target_link_libraries(${PROJECT}
    PRIVATE
        # AudioPluginData           # If we'd created a binary data target, we'd link to it here
        juce::juce_audio_utils
    PUBLIC
        juce::juce_recommended_config_flags
        juce::juce_recommended_lto_flags
        juce::juce_recommended_warning_flags
)

# `target_sources` adds source files to a target. We pass the target that needs the sources as the first argument, then
# a visibility parameter for the sources which should normally be PRIVATE. Finally, we supply a list of source files
# that will be built into the target. This is a standard CMake command.

target_sources(${PROJECT}
    PRIVATE
        $<$<NOT:$<BOOL:${JUCE_AUDIOPROCESSOR_NO_GUI}>>:src/PluginEditor.cpp>
        src/PluginProcessor.cpp
)