ViennaPS 4.1.0__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

viennaps.libs/cmake/vtk-9.3/FindNetCDF.cmake

@@ -0,0 +1,131 @@
+#[==[
+Provides the following variables:
+
+  * `NetCDF_FOUND`: Whether NetCDF was found or not.
+  * `NetCDF_INCLUDE_DIRS`: Include directories necessary to use NetCDF.
+  * `NetCDF_LIBRARIES`: Libraries necessary to use NetCDF.
+  * `NetCDF_VERSION`: The version of NetCDF found.
+  * `NetCDF::NetCDF`: A target to use with `target_link_libraries`.
+  * `NetCDF_HAS_PARALLEL`: Whether or not NetCDF was found with parallel IO support.
+#]==]
+
+function(FindNetCDF_get_is_parallel_aware include_dir)
+  file(STRINGS "${include_dir}/netcdf_meta.h" _netcdf_lines
+    REGEX "#define[ \t]+NC_HAS_PARALLEL[ \t]")
+  string(REGEX REPLACE ".*NC_HAS_PARALLEL[ \t]*([0-1]+).*" "\\1" _netcdf_has_parallel "${_netcdf_lines}")
+  if (_netcdf_has_parallel)
+    set(NetCDF_HAS_PARALLEL TRUE PARENT_SCOPE)
+  else()
+    set(NetCDF_HAS_PARALLEL FALSE PARENT_SCOPE)
+  endif()
+endfunction()
+
+# Try to find a CMake-built NetCDF.
+find_package(netCDF CONFIG QUIET)
+if (netCDF_FOUND)
+  # Forward the variables in a consistent way.
+  set(NetCDF_FOUND "${netCDF_FOUND}")
+  set(NetCDF_INCLUDE_DIRS "${netCDF_INCLUDE_DIR}")
+  set(NetCDF_LIBRARIES "${netCDF_LIBRARIES}")
+  set(NetCDF_VERSION "${NetCDFVersion}")
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(NetCDF
+    REQUIRED_VARS NetCDF_INCLUDE_DIRS NetCDF_LIBRARIES
+    VERSION_VAR NetCDF_VERSION)
+
+  if (NOT TARGET NetCDF::NetCDF)
+    add_library(NetCDF::NetCDF INTERFACE IMPORTED)
+    if (TARGET "netCDF::netcdf")
+      # 4.7.3
+      set_target_properties(NetCDF::NetCDF PROPERTIES
+        INTERFACE_LINK_LIBRARIES "netCDF::netcdf")
+    elseif (TARGET "netcdf")
+      set_target_properties(NetCDF::NetCDF PROPERTIES
+        INTERFACE_LINK_LIBRARIES "netcdf")
+    else ()
+      set_target_properties(NetCDF::NetCDF PROPERTIES
+        INTERFACE_LINK_LIBRARIES "${netCDF_LIBRARIES}")
+    endif ()
+  endif ()
+
+  FindNetCDF_get_is_parallel_aware("${NetCDF_INCLUDE_DIRS}")
+  # Skip the rest of the logic in this file.
+  return ()
+endif ()
+
+find_package(PkgConfig QUIET)
+if (PkgConfig_FOUND)
+  pkg_check_modules(_NetCDF QUIET netcdf IMPORTED_TARGET)
+  if (_NetCDF_FOUND)
+    # Forward the variables in a consistent way.
+    set(NetCDF_FOUND "${_NetCDF_FOUND}")
+    set(NetCDF_INCLUDE_DIRS "${_NetCDF_INCLUDE_DIRS}")
+    set(NetCDF_LIBRARIES "${_NetCDF_LIBRARIES}")
+    set(NetCDF_VERSION "${_NetCDF_VERSION}")
+
+    include(FindPackageHandleStandardArgs)
+    find_package_handle_standard_args(NetCDF
+      REQUIRED_VARS NetCDF_LIBRARIES
+      # This is not required because system-default include paths are not
+      # reported by `FindPkgConfig`, so this might be empty. Assume that if we
+      # have a library, the include directories are fine (if any) since
+      # PkgConfig reported that the package was found.
+      # NetCDF_INCLUDE_DIRS
+      VERSION_VAR NetCDF_VERSION)
+
+    if (NOT TARGET NetCDF::NetCDF)
+      add_library(NetCDF::NetCDF INTERFACE IMPORTED)
+      set_target_properties(NetCDF::NetCDF PROPERTIES
+        INTERFACE_LINK_LIBRARIES "PkgConfig::_NetCDF")
+    endif ()
+
+    FindNetCDF_get_is_parallel_aware("${_NetCDF_INCLUDEDIR}")
+    # Skip the rest of the logic in this file.
+    return ()
+  endif ()
+endif ()
+
+find_path(NetCDF_INCLUDE_DIR
+  NAMES netcdf.h
+  DOC "netcdf include directories")
+mark_as_advanced(NetCDF_INCLUDE_DIR)
+
+find_library(NetCDF_LIBRARY
+  NAMES netcdf
+  DOC "netcdf library")
+mark_as_advanced(NetCDF_LIBRARY)
+
+if (NetCDF_INCLUDE_DIR)
+  file(STRINGS "${NetCDF_INCLUDE_DIR}/netcdf_meta.h" _netcdf_version_lines
+    REGEX "#define[ \t]+NC_VERSION_(MAJOR|MINOR|PATCH|NOTE)")
+  string(REGEX REPLACE ".*NC_VERSION_MAJOR *\([0-9]*\).*" "\\1" _netcdf_version_major "${_netcdf_version_lines}")
+  string(REGEX REPLACE ".*NC_VERSION_MINOR *\([0-9]*\).*" "\\1" _netcdf_version_minor "${_netcdf_version_lines}")
+  string(REGEX REPLACE ".*NC_VERSION_PATCH *\([0-9]*\).*" "\\1" _netcdf_version_patch "${_netcdf_version_lines}")
+  string(REGEX REPLACE ".*NC_VERSION_NOTE *\"\([^\"]*\)\".*" "\\1" _netcdf_version_note "${_netcdf_version_lines}")
+  set(NetCDF_VERSION "${_netcdf_version_major}.${_netcdf_version_minor}.${_netcdf_version_patch}${_netcdf_version_note}")
+  unset(_netcdf_version_major)
+  unset(_netcdf_version_minor)
+  unset(_netcdf_version_patch)
+  unset(_netcdf_version_note)
+  unset(_netcdf_version_lines)
+
+  FindNetCDF_get_is_parallel_aware("${NetCDF_INCLUDE_DIR}")
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(NetCDF
+  REQUIRED_VARS NetCDF_LIBRARY NetCDF_INCLUDE_DIR
+  VERSION_VAR NetCDF_VERSION)
+
+if (NetCDF_FOUND)
+  set(NetCDF_INCLUDE_DIRS "${NetCDF_INCLUDE_DIR}")
+  set(NetCDF_LIBRARIES "${NetCDF_LIBRARY}")
+
+  if (NOT TARGET NetCDF::NetCDF)
+    add_library(NetCDF::NetCDF UNKNOWN IMPORTED)
+    set_target_properties(NetCDF::NetCDF PROPERTIES
+      IMPORTED_LOCATION "${NetCDF_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${NetCDF_INCLUDE_DIR}")
+  endif ()
+endif ()

viennaps.libs/cmake/vtk-9.3/FindODBC.cmake

@@ -0,0 +1,79 @@
+#[==[
+Provides the following variables:
+
+  * `ODBC_INCLUDE_DIRS`: Include directories necessary to use ODBC.
+  * `ODBC_LIBRARIES`: Libraries necessary to use ODBC.
+  * A `ODBC::ODBC` imported target.
+#]==]
+
+# No .pc files are shipped with ODBC on Windows.
+set(_ODBC_use_pkgconfig 0)
+if (NOT MSVC)
+  find_package(PkgConfig QUIET)
+  if (PkgConfig_FOUND)
+    set(_ODBC_use_pkgconfig 1)
+  endif ()
+endif ()
+
+if (_ODBC_use_pkgconfig)
+  pkg_check_modules(_iodbc "libiodbc" QUIET IMPORTED_TARGET)
+  unset(_odbc_target)
+  if (NOT _iodbc_FOUND)
+    pkg_check_modules(_unixodbc "odbc" QUIET IMPORTED_TARGET)
+    if (_unixodbc_FOUND)
+      set(_odbc_target "_unixodbc")
+    endif ()
+  else ()
+    set(_odbc_target "_iodbc")
+  endif ()
+
+  set(ODBC_FOUND 0)
+  if (_odbc_target)
+    set(ODBC_FOUND 1)
+    set(ODBC_INCLUDE_DIRS ${${_odbc_target}_INCLUDE_DIRS})
+    set(ODBC_LIBRARIES ${${_odbc_target}_LINK_LIBRARIES})
+    if (NOT TARGET ODBC::ODBC)
+      add_library(ODBC::ODBC INTERFACE IMPORTED)
+      target_link_libraries(ODBC::ODBC
+        INTERFACE "PkgConfig::${_odbc_target}")
+      if (MINGW AND _odbc_target STREQUAL "_unixodbc")
+        set_target_properties(ODBC::ODBC PROPERTIES
+          INTERFACE_COMPILE_DEFINITIONS SQL_WCHART_CONVERT)
+      endif ()
+    endif ()
+  endif ()
+  unset(_odbc_target)
+else ()
+  find_path(ODBC_INCLUDE_DIR
+    NAMES sql.h
+    PATHS
+      "C:/Program Files/ODBC"
+      "C:/ODBC"
+    PATH_SUFFIXES include include/odbc libiodbc
+    DOC "Location of sql.h")
+  mark_as_advanced(ODBC_INCLUDE_DIR)
+  find_library(ODBC_LIBRARY
+    NAMES odbc iodbc unixodbc odbc32
+    PATHS
+      "C:/Program Files/ODBC"
+      "C:/ODBC"
+    PATH_SUFFIXES lib lib/debug
+    DOC "Location of the ODBC library")
+  mark_as_advanced(ODBC_LIBRARY)
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(ODBC
+    REQUIRED_VARS ODBC_INCLUDE_DIR ODBC_LIBRARY)
+
+  if (ODBC_FOUND)
+    set(ODBC_INCLUDE_DIRS "${ODBC_INCLUDE_DIR}")
+    set(ODBC_LIBRARIES "${ODBC_LIBRARY}")
+    if (NOT TARGET ODBC::ODBC)
+      add_library(ODBC::ODBC UNKNOWN IMPORTED)
+      set_target_properties(ODBC::ODBC PROPERTIES
+        IMPORTED_LOCATION "${ODBC_LIBRARY}"
+        INTERFACE_INCLUDE_DIRECTORIES "${ODBC_INCLUDE_DIR}")
+    endif ()
+  endif ()
+endif ()
+unset(_ODBC_use_pkgconfig)

viennaps.libs/cmake/vtk-9.3/FindOGG.cmake

@@ -0,0 +1,26 @@
+find_path(OGG_INCLUDE_DIR
+  NAMES
+    ogg/ogg.h
+  DOC "ogg include directory")
+mark_as_advanced(OGG_INCLUDE_DIR)
+
+find_library(OGG_LIBRARY
+  NAMES
+    ogg
+  DOC "ogg library")
+mark_as_advanced(OGG_LIBRARY)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OGG REQUIRED_VARS OGG_LIBRARY OGG_INCLUDE_DIR)
+
+if (OGG_FOUND)
+  set(OGG_LIBRARIES "${OGG_LIBRARY}")
+  set(OGG_INCLUDE_DIRS "${OGG_INCLUDE_DIR}")
+
+  if (NOT TARGET OGG::OGG)
+    add_library(OGG::OGG UNKNOWN IMPORTED)
+    set_target_properties(OGG::OGG PROPERTIES
+      IMPORTED_LOCATION "${OGG_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${OGG_INCLUDE_DIR}")
+  endif ()
+endif ()

viennaps.libs/cmake/vtk-9.3/FindOSMesa.cmake

@@ -0,0 +1,56 @@
+# Try to find Mesa off-screen library and include dir.
+# Once done this will define
+#
+# OSMesa_FOUND        - true if OSMesa has been found
+# OSMesa_INCLUDE_DIRS - where the GL/osmesa.h can be found
+# OSMesa_LIBRARIES    - Link this to use OSMesa
+# OSMesa_VERSION      - Version of OSMesa found
+# OSMesa::OSMesa      - Imported target
+
+find_path(OSMESA_INCLUDE_DIR
+  NAMES GL/osmesa.h
+  PATHS "${OSMESA_ROOT}/include"
+        "$ENV{OSMESA_ROOT}/include"
+        /usr/openwin/share/include
+        /opt/graphics/OpenGL/include
+  DOC   "OSMesa include directory")
+mark_as_advanced(OSMESA_INCLUDE_DIR)
+
+find_library(OSMESA_LIBRARY
+  NAMES OSMesa OSMesa16 OSMesa32
+  PATHS "${OSMESA_ROOT}/lib"
+        "$ENV{OSMESA_ROOT}/lib"
+        /opt/graphics/OpenGL/lib
+        /usr/openwin/lib
+  DOC   "OSMesa library")
+mark_as_advanced(OSMESA_LIBRARY)
+
+if (OSMESA_INCLUDE_DIR AND EXISTS "${OSMESA_INCLUDE_DIR}/GL/osmesa.h")
+  file(STRINGS "${OSMESA_INCLUDE_DIR}/GL/osmesa.h" _OSMesa_version_lines
+    REGEX "OSMESA_[A-Z]+_VERSION")
+  string(REGEX REPLACE ".*# *define +OSMESA_MAJOR_VERSION +([0-9]+).*" "\\1" _OSMesa_version_major "${_OSMesa_version_lines}")
+  string(REGEX REPLACE ".*# *define +OSMESA_MINOR_VERSION +([0-9]+).*" "\\1" _OSMesa_version_minor "${_OSMesa_version_lines}")
+  string(REGEX REPLACE ".*# *define +OSMESA_PATCH_VERSION +([0-9]+).*" "\\1" _OSMesa_version_patch "${_OSMesa_version_lines}")
+  set(OSMesa_VERSION "${_OSMesa_version_major}.${_OSMesa_version_minor}.${_OSMesa_version_patch}")
+  unset(_OSMesa_version_major)
+  unset(_OSMesa_version_minor)
+  unset(_OSMesa_version_patch)
+  unset(_OSMesa_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OSMesa
+  REQUIRED_VARS OSMESA_INCLUDE_DIR OSMESA_LIBRARY
+  VERSION_VAR OSMesa_VERSION)
+
+if (OSMesa_FOUND)
+  set(OSMesa_INCLUDE_DIRS "${OSMESA_INCLUDE_DIR}")
+  set(OSMesa_LIBRARIES "${OSMESA_LIBRARY}")
+
+  if (NOT TARGET OSMesa::OSMesa)
+    add_library(OSMesa::OSMesa UNKNOWN IMPORTED)
+    set_target_properties(OSMesa::OSMesa PROPERTIES
+      IMPORTED_LOCATION "${OSMESA_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${OSMESA_INCLUDE_DIR}")
+  endif ()
+endif ()

viennaps.libs/cmake/vtk-9.3/FindOpenSlide.cmake

@@ -0,0 +1,40 @@
+# A CMake find module for the OpenSlide microscopy file reader library.
+#
+# http://openslide.org
+#
+# Once done, this module will define
+#   OPENSLIDE_FOUND         - system has OpenSlide
+#   OPENSLIDE_INCLUDE_DIRS  - the OpenSlide include directory
+#   OPENSLIDE_LIBRARIES     - link to these to use OpenSlide
+#   OpenSlide::OpenSlide    - imported target
+
+# Look for the header.
+find_path(OPENSLIDE_INCLUDE_DIR
+  NAMES
+    openslide/openslide.h
+  PATHS
+    /usr/local/include
+    /usr/include
+  DOC "OpenSlide include directory")
+mark_as_advanced(OPENSLIDE_INCLUDE_DIR)
+
+# Look for the library.
+find_library(OPENSLIDE_LIBRARY
+  NAMES openslide
+  DOC "OpenSlide library")
+mark_as_advanced(OPENSLIDE_LIBRARY)
+
+find_package(PackageHandleStandardArgs)
+find_package_handle_standard_args(OpenSlide
+  REQUIRED_VARS OPENSLIDE_LIBRARY OPENSLIDE_INCLUDE_DIR)
+
+if (OPENSLIDE_FOUND)
+  set(OPENSLIDE_LIBRARIES "${OPENSLIDE_LIBRARY}")
+  set(OPENSLIDE_INCLUDE_DIRS "${OPENSLIDE_INCLUDE_DIR}")
+  if (NOT TARGET OpenSlide::OpenSlide)
+    add_library(OpenSlide::OpenSlide UNKNOWN IMPORTED)
+    set_target_properties(OpenSlide::OpenSlide PROPERTIES
+      IMPORTED_LOCATION "${OPENSLIDE_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${OPENSLIDE_INCLUDE_DIR}")
+  endif ()
+endif ()

viennaps.libs/cmake/vtk-9.3/FindOpenVR.cmake

@@ -0,0 +1,61 @@
+# Note that OpenVR lacks a useful install tree. This should work if
+# `OpenVR_ROOT` is set to the source directory of OpenVR.
+
+# TODO: fails for universal builds
+if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+  set(_openvr_bitness 64)
+else ()
+  set(_openvr_bitness 32)
+endif ()
+
+set(_openvr_platform_base)
+if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
+  set(_openvr_platform_base osx)
+  # SteamVR only supports 32-bit on OS X
+  set(OpenVR_PLATFORM osx32)
+else ()
+  if (CMAKE_SYSTEM_NAME MATCHES "Linux")
+    set(_openvr_platform_base linux)
+  elseif (WIN32)
+    set(_openvr_platform_base win)
+  endif ()
+  set(OpenVR_PLATFORM ${_openvr_platform_base}${_openvr_bitness})
+endif ()
+
+find_path(OpenVR_INCLUDE_DIR
+  NAMES
+    openvr.h
+  PATH_SUFFIXES
+    openvr
+    headers
+    public/headers
+    steam
+    public/steam
+  DOC "OpenVR include directory")
+mark_as_advanced(OpenVR_INCLUDE_DIR)
+
+find_library(OpenVR_LIBRARY
+  NAMES openvr_api64 openvr_api
+  PATH_SUFFIXES
+    "${OpenVR_PLATFORM}"
+    "bin/${OpenVR_PLATFORM}"
+  DOC "OpenVR API library")
+mark_as_advanced(OpenVR_LIBRARY)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OpenVR
+  REQUIRED_VARS OpenVR_LIBRARY OpenVR_INCLUDE_DIR)
+
+if (OpenVR_FOUND)
+  set(OpenVR_INCLUDE_DIRS "${OpenVR_INCLUDE_DIR}")
+  set(OpenVR_LIBRARIES "${OpenVR_LIBRARY}")
+  if (NOT TARGET OpenVR::OpenVR)
+    add_library(OpenVR::OpenVR UNKNOWN IMPORTED)
+    set_target_properties(OpenVR::OpenVR PROPERTIES
+      IMPORTED_LOCATION "${OpenVR_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${OpenVR_INCLUDE_DIR}")
+  endif ()
+endif ()
+
+unset(_openvr_bitness)
+unset(_openvr_platform_base)

viennaps.libs/cmake/vtk-9.3/FindOpenXR.cmake

@@ -0,0 +1,64 @@
+# Note that OpenXR lacks a useful install tree. This should work if
+# `OpenXR_ROOT` is set to the source directory of OpenXR.
+
+# TODO: fails for universal builds
+if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+  set(_openxr_bitness 64)
+else ()
+  set(_openxr_bitness 32)
+endif ()
+
+set(_openxr_platform_base)
+if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
+  set(_openxr_platform_base osx)
+  # SteamVR only supports 32-bit on OS X
+  set(OpenXR_PLATFORM osx32)
+else ()
+  if (CMAKE_SYSTEM_NAME MATCHES "Linux")
+    set(_openxr_platform_base linux)
+  elseif (WIN32)
+    set(_openxr_platform_base win)
+  endif ()
+  set(OpenXR_PLATFORM ${_openxr_platform_base}${_openxr_bitness})
+endif ()
+
+find_path(OpenXR_INCLUDE_DIR
+  NAMES
+    openxr.h
+    openxr_platform.h
+  PATH_SUFFIXES
+    openxr
+    headers
+    public/headers
+    steam
+    public/steam
+  DOC "OpenXR include directory")
+mark_as_advanced(OpenXR_INCLUDE_DIR)
+
+find_library(OpenXR_LIBRARY
+  NAMES openxr_loader
+  PATH_SUFFIXES
+    "${OpenXR_PLATFORM}"
+    "bin/${OpenXR_PLATFORM}"
+  DOC "OpenXR API library")
+mark_as_advanced(OpenXR_LIBRARY)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OpenXR
+  REQUIRED_VARS OpenXR_LIBRARY OpenXR_INCLUDE_DIR)
+
+if (OpenXR_FOUND)
+  set(OpenXR_INCLUDE_DIRS "${OpenXR_INCLUDE_DIR}")
+  set(OpenXR_LIBRARIES "${OpenXR_LIBRARY}")
+  if (NOT TARGET OpenXR::OpenXR)
+    add_library(OpenXR::OpenXR UNKNOWN IMPORTED)
+    set_target_properties(OpenXR::OpenXR PROPERTIES
+      IMPORTED_LOCATION "${OpenXR_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${OpenXR_INCLUDE_DIR}")
+  endif ()
+endif ()
+
+unset(_openxr_bitness)
+unset(_openxr_platform_base)
+
+# See https://github.com/KhronosGroup/OpenXR-Hpp/blob/master/cmake/FindOpenXR.cmake

viennaps.libs/cmake/vtk-9.3/FindOpenXRRemoting.cmake

@@ -0,0 +1,52 @@
+find_path(OpenXRRemoting_INCLUDE_DIR
+  NAMES
+    openxr_msft_holographic_remoting.h
+    openxr_msft_remoting_frame_mirroring.h
+    openxr_msft_remoting_speech.h
+  PATH_SUFFIXES
+    openxr
+    openxrremoting
+  DOC "OpenXR Remoting include directory")
+mark_as_advanced(OpenXRRemoting_INCLUDE_DIR)
+
+find_path(OpenXRRemoting_BIN_DIR
+  NAMES
+    Microsoft.Holographic.AppRemoting.OpenXr.dll
+    RemotingXR.json
+  PATH_SUFFIXES
+    "x64/Desktop"
+    "bin/x64/Desktop"
+  DOC "OpenXR Remoting bin directory")
+mark_as_advanced(OpenXRRemoting_BIN_DIR)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OpenXRRemoting
+  REQUIRED_VARS OpenXRRemoting_INCLUDE_DIR OpenXRRemoting_BIN_DIR)
+
+if (OpenXRRemoting_FOUND)
+
+  # OpenXR remoting headers
+  if (NOT TARGET OpenXR::Remoting)
+    add_library(OpenXR::Remoting INTERFACE IMPORTED)
+    set_target_properties(OpenXR::Remoting PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${OpenXRRemoting_INCLUDE_DIR}")
+  endif()
+
+  # OpenXR remoting runtime library
+  if (NOT TARGET OpenXR::RemotingRuntime)
+    add_library(OpenXR::RemotingRuntime MODULE IMPORTED)
+    set_target_properties(OpenXR::RemotingRuntime PROPERTIES
+      IMPORTED_LOCATION "${OpenXRRemoting_BIN_DIR}/Microsoft.Holographic.AppRemoting.OpenXr.dll")
+  endif()
+
+  # OpenXR remoting PerceptionDevice library
+  if (NOT TARGET OpenXR::PerceptionDevice)
+    add_library(OpenXR::PerceptionDevice MODULE IMPORTED)
+    set_target_properties(OpenXR::PerceptionDevice PROPERTIES
+      IMPORTED_LOCATION "${OpenXRRemoting_BIN_DIR}/PerceptionDevice.dll")
+  endif()
+
+  # RemotingXR.json
+  set(RemotingXR_JSON "${OpenXRRemoting_BIN_DIR}/RemotingXR.json")
+
+endif()

viennaps.libs/cmake/vtk-9.3/FindPEGTL.cmake

@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+# SPDX-FileCopyrightText: Copyright (c) 2006, 2007 Montel Laurent, <montel@kde.org>
+# SPDX-FileCopyrightText: Copyright (c) 2008, 2009 Gael Guennebaud, <g.gael@free.fr>
+# SPDX-FileCopyrightText: Copyright (c) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+# SPDX-License-Identifier: BSD-2-Clause 
+
+# - Try to find PEGTL lib
+#
+# This module supports requiring a minimum version, e.g. you can do
+#   find_package(PEGTL 3.1.2)
+# to require version 3.1.2 or newer of PEGTL.
+#
+# Once done this will define
+#
+#  PEGTL_FOUND - system has eigen lib with correct version
+#  PEGTL_INCLUDE_DIRS - the eigen include directory
+#  PEGTL_VERSION - eigen version
+#
+# And the following imported target:
+#
+#  PEGTL::PEGTL
+
+find_path(PEGTL_INCLUDE_DIR
+  NAMES pegtl/version.hpp
+  PATH_SUFFIXES tao
+  DOC "Path to PEGTL headers")
+mark_as_advanced(PEGTL_INCLUDE_DIR)
+
+if (PEGTL_INCLUDE_DIR)
+  file(STRINGS "${PEGTL_INCLUDE_DIR}/pegtl/version.hpp" _pegtl_version_header
+    REGEX "TAO_PEGTL_VERSION")
+  string(REGEX MATCH "define[ \t]+TAO_PEGTL_VERSION[ \t]+\"([0-9.]+)\"" _pegtl_version_match "${_pegtl_version_header}")
+  set(PEGTL_VERSION "${CMAKE_MATCH_1}")
+  unset(_pegtl_version_header)
+  unset(_pegtl_version_match)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(PEGTL
+  REQUIRED_VARS PEGTL_INCLUDE_DIR
+  VERSION_VAR PEGTL_VERSION)
+
+if (PEGTL_FOUND)
+  set(PEGTL_INCLUDE_DIRS "${PEGTL_INCLUDE_DIR}")
+  if (NOT TARGET PEGTL::PEGTL)
+    add_library(PEGTL::PEGTL INTERFACE IMPORTED)
+    set_target_properties(PEGTL::PEGTL PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${PEGTL_INCLUDE_DIR}")
+  endif ()
+endif ()