INDEX - Add Magnum - Draft recipe

recipes/emsdk/all/conandata.yml

@@ -0,0 +1,4 @@
+sources:
+  "2.0.30":
+    url: https://github.com/emscripten-core/emsdk/archive/refs/tags/2.0.30.tar.gz
+    sha256: 69050d76c8907a58f99b08831e8cb7a4fba857efec6037d5e59df4b73111ba36

recipes/emsdk/all/conanfile.py

@@ -0,0 +1,140 @@
+from conans import ConanFile, tools
+from conans.errors import ConanInvalidConfiguration
+import os
+import json
+
+required_conan_version = ">=1.33.0"
+
+
+class EmSDKConan(ConanFile):
+    name = "emsdk"
+    description = "Emscripten SDK. Emscripten is an Open Source LLVM to JavaScript compiler"
+    url = "https://github.com/conan-io/conan-center-index"
+    homepage = "https://github.com/kripken/emscripten"
+    topics = ("emsdk", "emscripten", "sdk")
+    license = "MIT"
+    settings = "os", "arch"
+
+    short_paths = True
+
+    @property
+    def _source_subfolder(self):
+        return "source_subfolder"
+
+    def requirements(self):
+        self.requires("nodejs/16.3.0")
+        # self.requires("python")  # FIXME: Not available as Conan package
+        # self.requires("wasm")  # FIXME: Not available as Conan package
+
+    def validate(self):
+        if hasattr(self, "settings_target") and self.settings_target:
+            if self.settings_target.os != "Emscripten":
+                raise ConanInvalidConfiguration("When using {}, target os must be Emscripten".format(self.name))
+
+    def package_id(self):
+        del self.info.settings.os
+
+    def source(self):
+        tools.get(**self.conan_data["sources"][self.version],
+                  destination=self._source_subfolder, strip_root=True)
+
+    @staticmethod
+    def _chmod_plus_x(filename):
+        if os.name == "posix":
+            os.chmod(filename, os.stat(filename).st_mode | 0o111)
+
+    def _tools_for_version(self):
+        ret = {}
+        # Select release-upstream from version (wasm-binaries)
+        with open(os.path.join(self.build_folder, self._source_subfolder, "emscripten-releases-tags.json"), 'r') as f:
+            data = json.load(f)
+            ret['wasm'] = "releases-upstream-{}-64bit".format(data["releases"][self.version])
+        # Select python and node versions
+        with open(os.path.join(self.build_folder, self._source_subfolder, "emsdk_manifest.json"), 'r') as f:
+            data = json.load(f)
+            tools = data["tools"]
+            if self.settings.os != "Linux":
+                python = next((it for it in tools if (it["id"] == "python" and not it.get("is_old", False))), None)
+                ret["python"] = "python-{}-64bit".format(python["version"])
+            node = next((it for it in tools if (it["id"] == "node" and not it.get("is_old", False))), None)
+            ret["nodejs"] = "node-{}-64bit".format(node["version"])
+        return ret
+
+    def build(self):
+        with tools.chdir(self._source_subfolder):
+            emsdk = "emsdk.bat" if tools.os_info.is_windows else "./emsdk"
+            self._chmod_plus_x("emsdk")
+
+            # Install required tools
+            required_tools = self._tools_for_version()
+            for key, value in required_tools.items():
+                if key != 'nodejs':
+                    self.run("%s install %s" % (emsdk, value))
+                    self.run("%s activate %s" % (emsdk, value))
+
+    def package(self):
+        self.copy(pattern="LICENSE", dst="licenses", src=self._source_subfolder)
+        self.copy(pattern="*", dst="bin", src=self._source_subfolder)
+        emscripten = os.path.join(self.package_folder, "bin", "upstream", "emscripten")
+        toolchain = os.path.join(emscripten, "cmake", "Modules", "Platform", "Emscripten.cmake")
+        # FIXME: conan should add the root of conan package requirements to CMAKE_PREFIX_PATH (LIBRARY/INCLUDE -> ONLY; PROGRAM -> NEVER)
+        # allow to find conan libraries
+        tools.replace_in_file(toolchain,
+                              "set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)",
+                              "set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH)")
+        tools.replace_in_file(toolchain,
+                              "set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)",
+                              "set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH)")
+        tools.replace_in_file(toolchain,
+                              "set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)",
+                              "set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH)")
+
+    def _define_tool_var(self, name, value):
+        suffix = ".bat" if self.settings.os == "Windows" else ""
+        path = os.path.join(self.package_folder, "bin", "upstream",
+                            "emscripten", "%s%s" % (value, suffix))
+        self._chmod_plus_x(path)
+        self.output.info("Creating %s environment variable: %s" % (name, path))
+        return path
+
+    def package_info(self):
+        emsdk = self.package_folder
+        em_config = os.path.join(emsdk, "bin", ".emscripten")
+        emscripten = os.path.join(emsdk, "bin", "upstream", "emscripten")
+        em_cache = os.path.join(emsdk,  "bin", ".emscripten_cache")
+        toolchain = os.path.join(emscripten, "cmake", "Modules", "Platform", "Emscripten.cmake")
+
+        self.output.info("Appending PATH environment variable: %s" % emsdk)
+        self.env_info.PATH.append(emsdk)
+
+        self.output.info("Appending PATH environment variable: %s" % emscripten)
+        self.env_info.PATH.append(emscripten)
+
+        self.output.info("Creating EMSDK environment variable: %s" % emsdk)
+        self.env_info.EMSDK = emsdk
+
+        self.output.info("Creating EMSCRIPTEN environment variable: %s" % emscripten)
+        self.env_info.EMSCRIPTEN = emscripten
+
+        self.output.info("Creating EM_CONFIG environment variable: %s" % em_config)
+        self.env_info.EM_CONFIG = em_config
+
+        self.output.info("Creating EM_CACHE environment variable: %s" % em_cache)
+        self.env_info.EM_CACHE = em_cache
+
+        self.output.info("Creating CONAN_CMAKE_TOOLCHAIN_FILE environment variable: %s" % toolchain)
+        self.env_info.CONAN_CMAKE_TOOLCHAIN_FILE = toolchain
+
+        self.env_info.CC = self._define_tool_var("CC", "emcc")
+        self.env_info.CXX = self._define_tool_var("CXX", "em++")
+        self.env_info.RANLIB = self._define_tool_var("RANLIB", "emranlib")
+        self.env_info.AR = self._define_tool_var("AR", "emar")
+        self.cpp_info.builddirs = [
+            "bin/releases/src",
+            "bin/upstream/emscripten/cmake/Modules",
+            "bin/upstream/emscripten/cmake/Modules/Platform",
+            "bin/upstream/emscripten/system/lib/libunwind/cmake/Modules",
+            "bin/upstream/emscripten/system/lib/libunwind/cmake",
+            "bin/upstream/emscripten/tests/cmake/target_library",
+            "bin/upstream/lib/cmake/llvm",
+        ]

recipes/emsdk/all/test_package/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.18.2)
+project(test_package)
+
+option(USE_CONANBUILDINFO "Use conanbuildinfo.cmake")
+
+if(USE_CONANBUILDINFO)
+    include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
+    conan_basic_setup()
+else()
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY bin)
+endif()
+
+add_executable(${PROJECT_NAME} test_package.cpp)
+target_link_libraries(${PROJECT_NAME} ${CONAN_LIBS})

recipes/emsdk/all/test_package/conanfile.py

@@ -0,0 +1,30 @@
+from conans import ConanFile, CMake, tools
+import os
+
+required_conan_version = ">=1.36.0"
+
+
+class TestPackageConan(ConanFile):
+    settings = "os", "arch", "compiler", "build_type"
+    test_type = "build_requires"
+    generators = "cmake"
+
+    @property
+    def _settings_build(self):
+        return getattr(self, "settings_build", self.settings)
+
+    def build_requirements(self):
+        if self._settings_build.os == "Windows":
+            self.build_requires("make/4.3")
+
+    def build(self):
+        cmake = CMake(self, generator="Unix Makefiles")
+        cmake.definitions["USE_CONANBUILDINFO"] = self.settings.os == "Emscripten"
+        cmake.configure()
+        cmake.build()
+
+    def test(self):
+        test_file = os.path.join("bin", "test_package.js")
+        assert os.path.isfile(test_file)
+        if tools.which("node"):
+            self.run("node %s" % test_file, run_environment=True)

recipes/emsdk/all/test_package/test_package.cpp

@@ -0,0 +1,8 @@
+#include <cstdlib>
+#include <iostream>
+
+int main()
+{
+    std::cout << "conan-center-index\n";
+    return EXIT_SUCCESS;
+}

recipes/emsdk/config.yml

@@ -0,0 +1,3 @@
+versions:
+  "2.0.30":
+    folder: all

recipes/magnum-extras/all/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.1)
+project(cmake_wrapper)
+
+include(conanbuildinfo.cmake)
+conan_basic_setup()
+
+set(MAGNUM_INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/Magnum)
+#set(MAGNUM_EXTERNAL_INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/MagnumExternal)
+
+add_subdirectory("source_subfolder")

recipes/magnum-extras/all/conandata.yml

@@ -0,0 +1,11 @@
+sources:
+  "2020.06":
+    url: "https://github.com/mosra/magnum-extras/archive/refs/tags/v2020.06.tar.gz"
+    sha256: "a8d7babc50ac070984d39f6cc15c3ce2af7b41fe980fe81b0405da6f5ba3c36d"
+patches:
+  "2020.06":
+    - base_path: "source_subfolder"
+      patch_file: "patches/2020.06/0001-emscripten-toolchain.patch"
+      # patch_type: "portability" 
+      # description: "Remove unnecessary dependency on UseEmscripten"
+      # source: "https://github.com/mosra/magnum/issues/490"

recipes/magnum-extras/all/conanfile.py

@@ -0,0 +1,137 @@
+from conans import ConanFile, CMake, tools
+from conans.errors import ConanInvalidConfiguration
+import os
+
+required_conan_version = ">=1.33.0"
+
+
+class MagnumExtrasConan(ConanFile):
+    name = "magnum-extras"
+    description = "Extras for the Magnum C++11/C++14 graphics engine"
+    license = "MIT"
+    topics = ("magnum", "graphics", "rendering", "3d", "2d", "opengl")
+    url = "https://github.com/conan-io/conan-center-index"
+    homepage = "https://magnum.graphics"
+
+    settings = "os", "compiler", "build_type", "arch"
+
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "player": [True, False],
+        "ui": [True, False],
+        "ui_gallery": [True, False],
+        "application": ["android", "emscripten", "glfw", "glx", "sdl2", "xegl"],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "player": True,
+        "ui": True,
+        "ui_gallery": True,
+        "application": "sdl2",
+    }
+    generators = "cmake", "cmake_find_package"
+    exports_sources = ["CMakeLists.txt", "patches/*"]
+
+    _cmake = None
+
+    @property
+    def _source_subfolder(self):
+        return "source_subfolder"
+
+    def source(self):
+        tools.get(**self.conan_data["sources"][self.version], destination=self._source_subfolder, strip_root=True)
+        tools.replace_in_file(os.path.join(self._source_subfolder, "CMakeLists.txt"),
+                              'set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/modules/" ${CMAKE_MODULE_PATH})',
+                              "")
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+
+        if self.settings.os == "Android":
+            self.options.application = "android"
+        if self.settings.os == "Emscripten":
+            self.options.application = "emscripten"
+            # FIXME: Requires 'magnum:basis_importer=True' 
+            self.options.player = False
+            # #FIXME: Fails to compile
+            self.options.ui_gallery = False
+
+    def configure(self):
+        if self.options.shared:
+            del self.options.fPIC
+
+    def requirements(self):
+        self.requires("magnum/{}".format(self.version))
+        self.requires("corrade/{}".format(self.version))
+        if self.settings.os in ["iOS", "Emscripten", "Android"] and self.options.ui_gallery:
+            self.requires("magnum-plugins/{}".format(self.version))
+
+    def build_requirements(self):
+        self.build_requires("corrade/{}".format(self.version))
+
+    def validate(self):
+        opt_name = "{}_application".format(self.options.application)
+        if not getattr(self.options["magnum"], opt_name):
+            raise ConanInvalidConfiguration("Magnum needs option '{opt}=True'".format(opt=opt_name))
+        if self.settings.os == "Emscripten" and self.options["magnum"].target_gl == "gles2":
+            raise ConanInvalidConfiguration("OpenGL ES 3 required, use option 'magnum:target_gl=gles3'")
+
+    def _configure_cmake(self):
+        if self._cmake:
+            return self._cmake
+
+        self._cmake = CMake(self)
+        self._cmake.definitions["BUILD_STATIC"] = not self.options.shared
+        self._cmake.definitions["BUILD_STATIC_PIC"] = self.options.get_safe("fPIC", False)
+        self._cmake.definitions["BUILD_TESTS"] = False
+        self._cmake.definitions["BUILD_GL_TESTS"] = False
+
+        self._cmake.definitions["WITH_PLAYER"] = self.options.player
+        self._cmake.definitions["WITH_UI"] = self.options.ui
+        self._cmake.definitions["WITH_UI_GALLERY"] = self.options.ui_gallery
+
+        self._cmake.configure()
+        return self._cmake
+
+    def _patch_sources(self):
+        for patch in self.conan_data.get("patches", {}).get(self.version, []):
+            tools.patch(**patch)
+
+        cmakelists = [os.path.join("src", "Magnum", "Ui", "CMakeLists.txt"), 
+                      os.path.join("src", "player","CMakeLists.txt")]
+        app_name = "{}Application".format("XEgl" if self.options.application == "xegl" else str(self.options.application).capitalize())
+        for cmakelist in cmakelists:
+            tools.replace_in_file(os.path.join(self._source_subfolder, cmakelist),
+                                  "Magnum::Application",
+                                  "Magnum::{}".format(app_name))
+
+    def build(self):
+        self._patch_sources()
+
+        cm = self._configure_cmake()
+        cm.build()
+
+    def package(self):
+        cm = self._configure_cmake()
+        cm.install()
+
+        tools.rmdir(os.path.join(self.package_folder, "share"))
+        self.copy("COPYING", src=self._source_subfolder, dst="licenses")
+
+    def package_info(self):
+        self.cpp_info.names["cmake_find_package"] = "MagnumExtras"
+        self.cpp_info.names["cmake_find_package_multi"] = "MagnumExtras"
+
+        if self.options.ui:
+            self.cpp_info.components["ui"].names["cmake_find_package"] = "Ui"
+            self.cpp_info.components["ui"].names["cmake_find_package_multi"] = "Ui"
+            self.cpp_info.components["ui"].libs = ["MagnumUi"]
+            self.cpp_info.components["ui"].requires = ["corrade::interconnect", "magnum::magnum_main", "magnum::gl", "magnum::text"]
+
+        if self.options.player or self.options.ui_gallery:
+            bin_path = os.path.join(self.package_folder, "bin")
+            self.output.info('Appending PATH environment variable: %s' % bin_path)
+            self.env_info.path.append(bin_path)

recipes/magnum-extras/all/patches/2020.06/0001-emscripten-toolchain.patch

@@ -0,0 +1,15 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index e0e0eb7..65083df 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -58,10 +58,6 @@ if(CORRADE_TARGET_EMSCRIPTEN OR CORRADE_TARGET_ANDROID)
+     set(BUILD_STATIC ON)
+ endif()
+
+-if(CORRADE_TARGET_EMSCRIPTEN)
+-    include(UseEmscripten)
+-endif()
+-
+ if(BUILD_TESTS)
+     find_package(Corrade REQUIRED TestSuite)
+     if(CORRADE_TARGET_IOS)

recipes/magnum-extras/config.yml

@@ -0,0 +1,3 @@
+versions:
+  "2020.06":
+    folder: all

recipes/magnum-integration/all/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.1)
+project(cmake_wrapper)
+
+include(conanbuildinfo.cmake)
+conan_basic_setup()
+
+set(MAGNUM_INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/Magnum)
+set(MAGNUM_EXTERNAL_INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/MagnumExternal)
+
+add_subdirectory("source_subfolder")