diff options
author | Steve Wills <swills@FreeBSD.org> | 2021-09-15 09:30:06 +0000 |
---|---|---|
committer | Michael Zhilin <mizhka@FreeBSD.org> | 2021-09-15 09:32:10 +0000 |
commit | 8a4af427075f66baf4fedbbaba03ffc7f3f1f536 (patch) | |
tree | 886f4cfa57d18553b607758842186da88a1a9228 | |
parent | b433d97f2aa0ad1087dbcd06b7805e185f54ca6f (diff) | |
download | ports-8a4af427075f66baf4fedbbaba03ffc7f3f1f536.tar.gz ports-8a4af427075f66baf4fedbbaba03ffc7f3f1f536.zip |
cad/PrusaSlicer: Update to 2.3.3
- Update to 2.3.3
- Change the dependency from devel/tbb to devel/onetbb
ChangeLog: https://github.com/prusa3d/PrusaSlicer/releases/tag/version_2.3.3
PR: 258483
Submitted by: Steve Wills <swills@FreeBSD.org>
Reported by: teodorsigaev@gmail.com (tested), eborisch+FreeBSD@gmail.com (tested)
27 files changed, 1493 insertions, 49 deletions
diff --git a/cad/PrusaSlicer/Makefile b/cad/PrusaSlicer/Makefile index 9d796c3778e8..00ba345caa48 100644 --- a/cad/PrusaSlicer/Makefile +++ b/cad/PrusaSlicer/Makefile @@ -10,9 +10,7 @@ COMMENT= Slicing application for 3D printers LICENSE= AGPLv3 LICENSE_FILE= ${WRKSRC}/LICENSE -BROKEN= pending update to OneTBB-compatible version, see bug#255363 - -LIB_DEPENDS= libtbb.so:devel/tbb \ +LIB_DEPENDS= libtbb.so:devel/onetbb \ libboost_log.so:devel/boost-libs \ libImath.so:math/Imath \ libnlopt.so:math/nlopt \ diff --git a/cad/PrusaSlicer/distinfo b/cad/PrusaSlicer/distinfo index 1d66ee41deaa..f25d7ad594d1 100644 --- a/cad/PrusaSlicer/distinfo +++ b/cad/PrusaSlicer/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1610441839 -SHA256 (prusa3d-PrusaSlicer-version_2.3.0_GH0.tar.gz) = cd3bac5e29b5441fc4690f28cd7b1064e97dc00207bbdc88f7bd7832308d6ca5 -SIZE (prusa3d-PrusaSlicer-version_2.3.0_GH0.tar.gz) = 34785471 +TIMESTAMP = 1628978092 +SHA256 (prusa3d-PrusaSlicer-version_2.3.3_GH0.tar.gz) = deda209505f740ac3d6f59cb2a960f4df908269ee09bd30cd4edb9fc472d29ac +SIZE (prusa3d-PrusaSlicer-version_2.3.3_GH0.tar.gz) = 40659538 diff --git a/cad/PrusaSlicer/files/patch-CMakeLists.txt b/cad/PrusaSlicer/files/patch-CMakeLists.txt index 375a24916abe..ad640b3d895b 100644 --- a/cad/PrusaSlicer/files/patch-CMakeLists.txt +++ b/cad/PrusaSlicer/files/patch-CMakeLists.txt @@ -1,4 +1,4 @@ ---- CMakeLists.txt.orig 2021-01-11 13:01:51 UTC +--- CMakeLists.txt.orig 2021-04-16 11:41:00 UTC +++ CMakeLists.txt @@ -3,6 +3,7 @@ project(PrusaSlicer) @@ -8,7 +8,7 @@ set(SLIC3R_RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/resources") file(TO_NATIVE_PATH "${SLIC3R_RESOURCES_DIR}" SLIC3R_RESOURCES_DIR_WIN) -@@ -154,7 +155,7 @@ if (APPLE) +@@ -166,7 +167,7 @@ if (APPLE) endif () endif () @@ -17,7 +17,7 @@ find_package(PkgConfig REQUIRED) if (CMAKE_VERSION VERSION_LESS "3.1") -@@ -513,8 +514,8 @@ elseif (SLIC3R_FHS) +@@ -525,8 +526,8 @@ elseif (SLIC3R_FHS) # CMAKE_INSTALL_FULL_DATAROOTDIR: read-only architecture-independent data root (share) set(SLIC3R_FHS_RESOURCES "${CMAKE_INSTALL_FULL_DATAROOTDIR}/PrusaSlicer") install(DIRECTORY "${SLIC3R_RESOURCES_DIR}/" DESTINATION "${SLIC3R_FHS_RESOURCES}") diff --git a/cad/PrusaSlicer/files/patch-cmake_modules_FindTBB.cmake b/cad/PrusaSlicer/files/patch-cmake_modules_FindTBB.cmake new file mode 100644 index 000000000000..4faa74ef3698 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-cmake_modules_FindTBB.cmake @@ -0,0 +1,738 @@ +--- cmake/modules/FindTBB.cmake.orig 2021-07-16 10:14:03 UTC ++++ cmake/modules/FindTBB.cmake +@@ -1,332 +1,456 @@ +-# The MIT License (MIT) ++# - Find ThreadingBuildingBlocks include dirs and libraries ++# Use this module by invoking find_package with the form: ++# find_package(TBB ++# [REQUIRED] # Fail with error if TBB is not found ++# ) # ++# Once done, this will define + # +-# Copyright (c) 2015 Justus Calvin +-# +-# 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. +- ++# TBB_FOUND - system has TBB ++# TBB_INCLUDE_DIRS - the TBB include directories ++# TBB_LIBRARIES - TBB libraries to be lined, doesn't include malloc or ++# malloc proxy ++# TBB::tbb - imported target for the TBB library + # +-# FindTBB +-# ------- ++# TBB_VERSION_MAJOR - Major Product Version Number ++# TBB_VERSION_MINOR - Minor Product Version Number ++# TBB_INTERFACE_VERSION - Engineering Focused Version Number ++# TBB_COMPATIBLE_INTERFACE_VERSION - The oldest major interface version ++# still supported. This uses the engineering ++# focused interface version numbers. + # +-# Find TBB include directories and libraries. ++# TBB_MALLOC_FOUND - system has TBB malloc library ++# TBB_MALLOC_INCLUDE_DIRS - the TBB malloc include directories ++# TBB_MALLOC_LIBRARIES - The TBB malloc libraries to be lined ++# TBB::malloc - imported target for the TBB malloc library + # +-# Usage: ++# TBB_MALLOC_PROXY_FOUND - system has TBB malloc proxy library ++# TBB_MALLOC_PROXY_INCLUDE_DIRS = the TBB malloc proxy include directories ++# TBB_MALLOC_PROXY_LIBRARIES - The TBB malloc proxy libraries to be lined ++# TBB::malloc_proxy - imported target for the TBB malloc proxy library + # +-# find_package(TBB [major[.minor]] [EXACT] +-# [QUIET] [REQUIRED] +-# [[COMPONENTS] [components...]] +-# [OPTIONAL_COMPONENTS components...]) + # +-# where the allowed components are tbbmalloc and tbb_preview. Users may modify +-# the behavior of this module with the following variables: ++# This module reads hints about search locations from variables: ++# ENV TBB_ARCH_PLATFORM - for eg. set it to "mic" for Xeon Phi builds ++# ENV TBB_ROOT or just TBB_ROOT - root directory of tbb installation ++# ENV TBB_BUILD_PREFIX - specifies the build prefix for user built tbb ++# libraries. Should be specified with ENV TBB_ROOT ++# and optionally... ++# ENV TBB_BUILD_DIR - if build directory is different than ${TBB_ROOT}/build + # +-# * TBB_ROOT_DIR - The base directory the of TBB installation. +-# * TBB_INCLUDE_DIR - The directory that contains the TBB headers files. +-# * TBB_LIBRARY - The directory that contains the TBB library files. +-# * TBB_<library>_LIBRARY - The path of the TBB the corresponding TBB library. +-# These libraries, if specified, override the +-# corresponding library search results, where <library> +-# may be tbb, tbb_debug, tbbmalloc, tbbmalloc_debug, +-# tbb_preview, or tbb_preview_debug. +-# * TBB_USE_DEBUG_BUILD - The debug version of tbb libraries, if present, will +-# be used instead of the release version. +-# * TBB_STATIC - Static linking of libraries with a _static suffix. +-# For example, on Windows a tbb_static.lib will be searched for +-# instead of tbb.lib. + # +-# Users may modify the behavior of this module with the following environment +-# variables: ++# Modified by Robert Maynard from the original OGRE source + # +-# * TBB_INSTALL_DIR +-# * TBBROOT +-# * LIBRARY_PATH ++#------------------------------------------------------------------- ++# This file is part of the CMake build system for OGRE ++# (Object-oriented Graphics Rendering Engine) ++# For the latest info, see http://www.ogre3d.org/ + # +-# This module will set the following variables: ++# The contents of this file are placed in the public domain. Feel ++# free to make use of it in any way you like. ++#------------------------------------------------------------------- + # +-# * TBB_FOUND - Set to false, or undefined, if we haven’t found, or +-# don’t want to use TBB. +-# * TBB_<component>_FOUND - If False, optional <component> part of TBB sytem is +-# not available. +-# * TBB_VERSION - The full version string +-# * TBB_VERSION_MAJOR - The major version +-# * TBB_VERSION_MINOR - The minor version +-# * TBB_INTERFACE_VERSION - The interface version number defined in +-# tbb/tbb_stddef.h. +-# * TBB_<library>_LIBRARY_RELEASE - The path of the TBB release version of +-# <library>, where <library> may be tbb, tbb_debug, +-# tbbmalloc, tbbmalloc_debug, tbb_preview, or +-# tbb_preview_debug. +-# * TBB_<library>_LIBRARY_DEGUG - The path of the TBB release version of +-# <library>, where <library> may be tbb, tbb_debug, +-# tbbmalloc, tbbmalloc_debug, tbb_preview, or +-# tbb_preview_debug. ++#============================================================================= ++# Copyright 2010-2012 Kitware, Inc. ++# Copyright 2012 Rolf Eike Beer <eike@sf-mail.de> + # +-# The following varibles should be used to build and link with TBB: ++# Distributed under the OSI-approved BSD License (the "License"); ++# see accompanying file Copyright.txt for details. + # +-# * TBB_INCLUDE_DIRS - The include directory for TBB. +-# * TBB_LIBRARIES - The libraries to link against to use TBB. +-# * TBB_LIBRARIES_RELEASE - The release libraries to link against to use TBB. +-# * TBB_LIBRARIES_DEBUG - The debug libraries to link against to use TBB. +-# * TBB_DEFINITIONS - Definitions to use when compiling code that uses +-# TBB. +-# * TBB_DEFINITIONS_RELEASE - Definitions to use when compiling release code that +-# uses TBB. +-# * TBB_DEFINITIONS_DEBUG - Definitions to use when compiling debug code that +-# uses TBB. ++# This software is distributed WITHOUT ANY WARRANTY; without even the ++# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ++# See the License for more information. ++#============================================================================= ++# (To distribute this file outside of CMake, substitute the full ++# License text for the above reference.) ++ ++ ++#============================================================================= ++# FindTBB helper functions and macros + # +-# This module will also create the "tbb" target that may be used when building +-# executables and libraries. + +-unset(TBB_FOUND CACHE) +-unset(TBB_INCLUDE_DIRS CACHE) +-unset(TBB_LIBRARIES) +-unset(TBB_LIBRARIES_DEBUG) +-unset(TBB_LIBRARIES_RELEASE) ++# Use TBBConfig.cmake if possible. + +-include(FindPackageHandleStandardArgs) ++set(_tbb_find_quiet) ++if (TBB_FIND_QUIETLY) ++ set(_tbb_find_quiet QUIET) ++endif () ++set(_tbb_find_components) ++set(_tbb_find_optional_components) ++foreach (_tbb_find_component IN LISTS TBB_FIND_COMPONENTS) ++ if (TBB_FIND_REQUIRED_${_tbb_find_component}) ++ list(APPEND _tbb_find_components "${_tbb_find_component}") ++ else () ++ list(APPEND _tbb_find_optional_components "${_tbb_find_component}") ++ endif () ++endforeach () ++unset(_tbb_find_component) ++find_package(TBB CONFIG ${_tbb_find_quiet} ++ COMPONENTS ${_tbb_find_components} ++ OPTIONAL_COMPONENTS ${_tbb_find_optional_components}) ++unset(_tbb_find_quiet) ++unset(_tbb_find_components) ++unset(_tbb_find_optional_components) ++if (TBB_FOUND) ++ return () ++endif () + +-find_package(Threads QUIET REQUIRED) ++#==================================================== ++# Fix the library path in case it is a linker script ++#==================================================== ++function(tbb_extract_real_library library real_library) ++ if(NOT UNIX OR NOT EXISTS ${library}) ++ set(${real_library} "${library}" PARENT_SCOPE) ++ return() ++ endif() + +-if(NOT TBB_FOUND) ++ #Read in the first 4 bytes and see if they are the ELF magic number ++ set(_elf_magic "7f454c46") ++ file(READ ${library} _hex_data OFFSET 0 LIMIT 4 HEX) ++ if(_hex_data STREQUAL _elf_magic) ++ #we have opened a elf binary so this is what ++ #we should link to ++ set(${real_library} "${library}" PARENT_SCOPE) ++ return() ++ endif() + +- ################################## +- # Check the build type +- ################################## +- +- if(NOT DEFINED TBB_USE_DEBUG_BUILD) +- if(CMAKE_BUILD_TYPE MATCHES "(Debug|DEBUG|debug)") +- set(TBB_BUILD_TYPE DEBUG) +- else() +- set(TBB_BUILD_TYPE RELEASE) +- endif() +- elseif(TBB_USE_DEBUG_BUILD) +- set(TBB_BUILD_TYPE DEBUG) ++ file(READ ${library} _data OFFSET 0 LIMIT 1024) ++ if("${_data}" MATCHES "INPUT \\(([^(]+)\\)") ++ #extract out the .so name from REGEX MATCH command ++ set(_proper_so_name "${CMAKE_MATCH_1}") ++ ++ #construct path to the real .so which is presumed to be in the same directory ++ #as the input file ++ get_filename_component(_so_dir "${library}" DIRECTORY) ++ set(${real_library} "${_so_dir}/${_proper_so_name}" PARENT_SCOPE) + else() +- set(TBB_BUILD_TYPE RELEASE) ++ #unable to determine what this library is so just hope everything works ++ #and pass it unmodified. ++ set(${real_library} "${library}" PARENT_SCOPE) + endif() +- +- ################################## +- # Set the TBB search directories +- ################################## +- +- # Define search paths based on user input and environment variables +- set(TBB_SEARCH_DIR ${TBB_ROOT_DIR} $ENV{TBB_INSTALL_DIR} $ENV{TBBROOT}) +- +- # Define the search directories based on the current platform +- if(CMAKE_SYSTEM_NAME STREQUAL "Windows") +- set(TBB_DEFAULT_SEARCH_DIR "C:/Program Files/Intel/TBB" +- "C:/Program Files (x86)/Intel/TBB") ++endfunction() + +- # Set the target architecture +- if(CMAKE_SIZEOF_VOID_P EQUAL 8) +- set(TBB_ARCHITECTURE "intel64") +- else() +- set(TBB_ARCHITECTURE "ia32") +- endif() ++#=============================================== ++# Do the final processing for the package find. ++#=============================================== ++macro(findpkg_finish PREFIX TARGET_NAME) ++ if (${PREFIX}_INCLUDE_DIR AND ${PREFIX}_LIBRARY) ++ set(${PREFIX}_FOUND TRUE) ++ set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIR}) ++ set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARY}) ++ else () ++ if (${PREFIX}_FIND_REQUIRED AND NOT ${PREFIX}_FIND_QUIETLY) ++ message(FATAL_ERROR "Required library ${PREFIX} not found.") ++ endif () ++ endif () + +- # Set the TBB search library path search suffix based on the version of VC +- if(WINDOWS_STORE) +- set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc11_ui") +- elseif(MSVC14) +- set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc14") +- elseif(MSVC12) +- set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc12") +- elseif(MSVC11) +- set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc11") +- elseif(MSVC10) +- set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc10") +- endif() ++ if (NOT TARGET "TBB::${TARGET_NAME}") ++ if (${PREFIX}_LIBRARY_RELEASE) ++ tbb_extract_real_library(${${PREFIX}_LIBRARY_RELEASE} real_release) ++ endif () ++ if (${PREFIX}_LIBRARY_DEBUG) ++ tbb_extract_real_library(${${PREFIX}_LIBRARY_DEBUG} real_debug) ++ endif () ++ add_library(TBB::${TARGET_NAME} UNKNOWN IMPORTED) ++ set_target_properties(TBB::${TARGET_NAME} PROPERTIES ++ INTERFACE_INCLUDE_DIRECTORIES "${${PREFIX}_INCLUDE_DIR}") ++ if (${PREFIX}_LIBRARY_DEBUG AND ${PREFIX}_LIBRARY_RELEASE) ++ set_target_properties(TBB::${TARGET_NAME} PROPERTIES ++ IMPORTED_LOCATION "${real_release}" ++ IMPORTED_LOCATION_DEBUG "${real_debug}" ++ IMPORTED_LOCATION_RELEASE "${real_release}") ++ elseif (${PREFIX}_LIBRARY_RELEASE) ++ set_target_properties(TBB::${TARGET_NAME} PROPERTIES ++ IMPORTED_LOCATION "${real_release}") ++ elseif (${PREFIX}_LIBRARY_DEBUG) ++ set_target_properties(TBB::${TARGET_NAME} PROPERTIES ++ IMPORTED_LOCATION "${real_debug}") ++ endif () ++ endif () + +- # Add the library path search suffix for the VC independent version of TBB +- list(APPEND TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc_mt") ++ #mark the following variables as internal variables ++ mark_as_advanced(${PREFIX}_INCLUDE_DIR ++ ${PREFIX}_LIBRARY ++ ${PREFIX}_LIBRARY_DEBUG ++ ${PREFIX}_LIBRARY_RELEASE) ++endmacro() + +- elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") +- # OS X +- set(TBB_DEFAULT_SEARCH_DIR "/opt/intel/tbb") +- +- # TODO: Check to see which C++ library is being used by the compiler. +- if(NOT ${CMAKE_SYSTEM_VERSION} VERSION_LESS 13.0) +- # The default C++ library on OS X 10.9 and later is libc++ +- set(TBB_LIB_PATH_SUFFIX "lib/libc++" "lib") +- else() +- set(TBB_LIB_PATH_SUFFIX "lib") +- endif() +- elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") +- # Linux +- set(TBB_DEFAULT_SEARCH_DIR "/opt/intel/tbb") +- +- # TODO: Check compiler version to see the suffix should be <arch>/gcc4.1 or +- # <arch>/gcc4.1. For now, assume that the compiler is more recent than +- # gcc 4.4.x or later. +- if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64") +- set(TBB_LIB_PATH_SUFFIX "lib/intel64/gcc4.4") +- elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^i.86$") +- set(TBB_LIB_PATH_SUFFIX "lib/ia32/gcc4.4") +- endif() +- endif() +- +- ################################## +- # Find the TBB include dir +- ################################## +- +- find_path(TBB_INCLUDE_DIRS tbb/tbb.h +- HINTS ${TBB_INCLUDE_DIR} ${TBB_SEARCH_DIR} +- PATHS ${TBB_DEFAULT_SEARCH_DIR} +- PATH_SUFFIXES include) ++#=============================================== ++# Generate debug names from given release names ++#=============================================== ++macro(get_debug_names PREFIX) ++ foreach(i ${${PREFIX}}) ++ set(${PREFIX}_DEBUG ${${PREFIX}_DEBUG} ${i}d ${i}D ${i}_d ${i}_D ${i}_debug ${i}) ++ endforeach() ++endmacro() + +- ################################## +- # Set version strings +- ################################## ++#=============================================== ++# See if we have env vars to help us find tbb ++#=============================================== ++macro(getenv_path VAR) ++ set(ENV_${VAR} $ENV{${VAR}}) ++ # replace won't work if var is blank ++ if (ENV_${VAR}) ++ string( REGEX REPLACE "\\\\" "/" ENV_${VAR} ${ENV_${VAR}} ) ++ endif () ++endmacro() + +- if(TBB_INCLUDE_DIRS) +- file(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _tbb_version_file) +- string(REGEX REPLACE ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1" +- TBB_VERSION_MAJOR "${_tbb_version_file}") +- string(REGEX REPLACE ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1" +- TBB_VERSION_MINOR "${_tbb_version_file}") +- string(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" +- TBB_INTERFACE_VERSION "${_tbb_version_file}") +- set(TBB_VERSION "${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR}") +- endif() ++#=============================================== ++# Couple a set of release AND debug libraries ++#=============================================== ++macro(make_library_set PREFIX) ++ if (${PREFIX}_RELEASE AND ${PREFIX}_DEBUG) ++ set(${PREFIX} optimized ${${PREFIX}_RELEASE} debug ${${PREFIX}_DEBUG}) ++ elseif (${PREFIX}_RELEASE) ++ set(${PREFIX} ${${PREFIX}_RELEASE}) ++ elseif (${PREFIX}_DEBUG) ++ set(${PREFIX} ${${PREFIX}_DEBUG}) ++ endif () ++endmacro() + +- ################################## +- # Find TBB components +- ################################## + +- if(TBB_VERSION VERSION_LESS 4.3) +- set(TBB_SEARCH_COMPOMPONENTS tbb_preview tbbmalloc tbb) +- else() +- set(TBB_SEARCH_COMPOMPONENTS tbb_preview tbbmalloc_proxy tbbmalloc tbb) +- endif() ++#============================================================================= ++# Now to actually find TBB ++# + +- if(TBB_STATIC) +- set(TBB_STATIC_SUFFIX "_static") +- endif() ++# Get path, convert backslashes as ${ENV_${var}} ++getenv_path(TBB_ROOT) + +- # Find each component +- foreach(_comp ${TBB_SEARCH_COMPOMPONENTS}) +- if(";${TBB_FIND_COMPONENTS};tbb;" MATCHES ";${_comp};") ++# initialize search paths ++set(TBB_PREFIX_PATH ${TBB_ROOT} ${ENV_TBB_ROOT}) ++set(TBB_INC_SEARCH_PATH "") ++set(TBB_LIB_SEARCH_PATH "") + +- unset(TBB_${_comp}_LIBRARY_DEBUG CACHE) +- unset(TBB_${_comp}_LIBRARY_RELEASE CACHE) + +- # Search for the libraries +- find_library(TBB_${_comp}_LIBRARY_RELEASE ${_comp}${TBB_STATIC_SUFFIX} +- HINTS ${TBB_LIBRARY} ${TBB_SEARCH_DIR} +- PATHS ${TBB_DEFAULT_SEARCH_DIR} ENV LIBRARY_PATH +- PATH_SUFFIXES ${TBB_LIB_PATH_SUFFIX}) ++# If user built from sources ++set(TBB_BUILD_PREFIX $ENV{TBB_BUILD_PREFIX}) ++if (TBB_BUILD_PREFIX AND ENV_TBB_ROOT) ++ getenv_path(TBB_BUILD_DIR) ++ if (NOT ENV_TBB_BUILD_DIR) ++ set(ENV_TBB_BUILD_DIR ${ENV_TBB_ROOT}/build) ++ endif () + +- find_library(TBB_${_comp}_LIBRARY_DEBUG ${_comp}${TBB_STATIC_SUFFIX}_debug +- HINTS ${TBB_LIBRARY} ${TBB_SEARCH_DIR} +- PATHS ${TBB_DEFAULT_SEARCH_DIR} ENV LIBRARY_PATH +- PATH_SUFFIXES ${TBB_LIB_PATH_SUFFIX}) ++ # include directory under ${ENV_TBB_ROOT}/include ++ list(APPEND TBB_LIB_SEARCH_PATH ++ ${ENV_TBB_BUILD_DIR}/${TBB_BUILD_PREFIX}_release ++ ${ENV_TBB_BUILD_DIR}/${TBB_BUILD_PREFIX}_debug) ++endif () + +- if(TBB_${_comp}_LIBRARY_DEBUG) +- list(APPEND TBB_LIBRARIES_DEBUG "${TBB_${_comp}_LIBRARY_DEBUG}") +- endif() +- if(TBB_${_comp}_LIBRARY_RELEASE) +- list(APPEND TBB_LIBRARIES_RELEASE "${TBB_${_comp}_LIBRARY_RELEASE}") +- endif() +- if(TBB_${_comp}_LIBRARY_${TBB_BUILD_TYPE} AND NOT TBB_${_comp}_LIBRARY) +- set(TBB_${_comp}_LIBRARY "${TBB_${_comp}_LIBRARY_${TBB_BUILD_TYPE}}") +- endif() + +- if(TBB_${_comp}_LIBRARY AND EXISTS "${TBB_${_comp}_LIBRARY}") +- set(TBB_${_comp}_FOUND TRUE) +- else() +- set(TBB_${_comp}_FOUND FALSE) +- endif() ++# For Windows, let's assume that the user might be using the precompiled ++# TBB packages from the main website. These use a rather awkward directory ++# structure (at least for automatically finding the right files) depending ++# on platform and compiler, but we'll do our best to accommodate it. ++# Not adding the same effort for the precompiled linux builds, though. Those ++# have different versions for CC compiler versions and linux kernels which ++# will never adequately match the user's setup, so there is no feasible way ++# to detect the "best" version to use. The user will have to manually ++# select the right files. (Chances are the distributions are shipping their ++# custom version of tbb, anyway, so the problem is probably nonexistent.) ++if (WIN32 AND MSVC) ++ set(COMPILER_PREFIX "vc7.1") ++ if (MSVC_VERSION EQUAL 1400) ++ set(COMPILER_PREFIX "vc8") ++ elseif(MSVC_VERSION EQUAL 1500) ++ set(COMPILER_PREFIX "vc9") ++ elseif(MSVC_VERSION EQUAL 1600) ++ set(COMPILER_PREFIX "vc10") ++ elseif(MSVC_VERSION EQUAL 1700) ++ set(COMPILER_PREFIX "vc11") ++ elseif(MSVC_VERSION EQUAL 1800) ++ set(COMPILER_PREFIX "vc12") ++ elseif(MSVC_VERSION GREATER_EQUAL 1900) ++ set(COMPILER_PREFIX "vc14") ++ endif () + +- # Mark internal variables as advanced +- mark_as_advanced(TBB_${_comp}_LIBRARY_RELEASE) +- mark_as_advanced(TBB_${_comp}_LIBRARY_DEBUG) +- mark_as_advanced(TBB_${_comp}_LIBRARY) ++ # for each prefix path, add ia32/64\${COMPILER_PREFIX}\lib to the lib search path ++ foreach (dir IN LISTS TBB_PREFIX_PATH) ++ if (CMAKE_CL_64) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia64/${COMPILER_PREFIX}/lib) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia64/${COMPILER_PREFIX}) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/${COMPILER_PREFIX}/lib) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64/${COMPILER_PREFIX}) ++ else () ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/${COMPILER_PREFIX}/lib) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32/${COMPILER_PREFIX}) ++ endif () ++ endforeach () ++endif () + +- endif() +- endforeach() ++# For OS X binary distribution, choose libc++ based libraries for Mavericks (10.9) ++# and above and AppleClang ++if (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND ++ NOT CMAKE_SYSTEM_VERSION VERSION_LESS 13.0) ++ set (USE_LIBCXX OFF) ++ cmake_policy(GET CMP0025 POLICY_VAR) + +- ################################## +- # Set compile flags and libraries +- ################################## ++ if (POLICY_VAR STREQUAL "NEW") ++ if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang") ++ set (USE_LIBCXX ON) ++ endif () ++ else () ++ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") ++ set (USE_LIBCXX ON) ++ endif () ++ endif () + +- set(TBB_DEFINITIONS_RELEASE "") +- set(TBB_DEFINITIONS_DEBUG "TBB_USE_DEBUG=1") +- +- if(TBB_LIBRARIES_${TBB_BUILD_TYPE}) +- set(TBB_LIBRARIES "${TBB_LIBRARIES_${TBB_BUILD_TYPE}}") ++ if (USE_LIBCXX) ++ foreach (dir IN LISTS TBB_PREFIX_PATH) ++ list (APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/libc++ ${dir}/libc++/lib) ++ endforeach () ++ endif () ++endif () ++ ++# check compiler ABI ++if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") ++ set(COMPILER_PREFIX) ++ if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8) ++ list(APPEND COMPILER_PREFIX "gcc4.8") + endif() +- +- if(NOT MSVC AND NOT TBB_LIBRARIES) +- set(TBB_LIBRARIES ${TBB_LIBRARIES_RELEASE}) ++ if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7) ++ list(APPEND COMPILER_PREFIX "gcc4.7") + endif() ++ if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4) ++ list(APPEND COMPILER_PREFIX "gcc4.4") ++ endif() ++ list(APPEND COMPILER_PREFIX "gcc4.1") ++elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") ++ set(COMPILER_PREFIX) ++ if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.0) # Complete guess ++ list(APPEND COMPILER_PREFIX "gcc4.8") ++ endif() ++ if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.6) ++ list(APPEND COMPILER_PREFIX "gcc4.7") ++ endif() ++ list(APPEND COMPILER_PREFIX "gcc4.4") ++else() # Assume compatibility with 4.4 for other compilers ++ list(APPEND COMPILER_PREFIX "gcc4.4") ++endif () + +- set(TBB_DEFINITIONS "") +- if (MSVC AND TBB_STATIC) +- set(TBB_DEFINITIONS __TBB_NO_IMPLICIT_LINKAGE) +- endif () ++# if platform architecture is explicitly specified ++set(TBB_ARCH_PLATFORM $ENV{TBB_ARCH_PLATFORM}) ++if (TBB_ARCH_PLATFORM) ++ foreach (dir IN LISTS TBB_PREFIX_PATH) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/${TBB_ARCH_PLATFORM}/lib) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/${TBB_ARCH_PLATFORM}) ++ endforeach () ++endif () + +- unset (TBB_STATIC_SUFFIX) ++foreach (dir IN LISTS TBB_PREFIX_PATH) ++ foreach (prefix IN LISTS COMPILER_PREFIX) ++ if (CMAKE_SIZEOF_VOID_P EQUAL 8) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64/${prefix}) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/lib) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/${prefix}/lib) ++ else () ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32/${prefix}) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/lib) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/${prefix}/lib) ++ endif () ++ endforeach() ++endforeach () + +- find_package_handle_standard_args(TBB +- REQUIRED_VARS TBB_INCLUDE_DIRS TBB_LIBRARIES +- FAIL_MESSAGE "TBB library cannot be found. Consider set TBBROOT environment variable." +- HANDLE_COMPONENTS +- VERSION_VAR TBB_VERSION) ++# add general search paths ++foreach (dir IN LISTS TBB_PREFIX_PATH) ++ list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib ${dir}/Lib ${dir}/lib/tbb ++ ${dir}/Libs) ++ list(APPEND TBB_INC_SEARCH_PATH ${dir}/include ${dir}/Include ++ ${dir}/include/tbb) ++endforeach () + +- ################################## +- # Create targets +- ################################## ++set(TBB_LIBRARY_NAMES tbb) ++get_debug_names(TBB_LIBRARY_NAMES) + +- if(NOT CMAKE_VERSION VERSION_LESS 3.0 AND TBB_FOUND) +- add_library(TBB::tbb UNKNOWN IMPORTED) +- set_target_properties(TBB::tbb PROPERTIES +- INTERFACE_COMPILE_DEFINITIONS "${TBB_DEFINITIONS}" +- INTERFACE_LINK_LIBRARIES "Threads::Threads;${CMAKE_DL_LIBS}" +- INTERFACE_INCLUDE_DIRECTORIES ${TBB_INCLUDE_DIRS} +- IMPORTED_LOCATION ${TBB_LIBRARIES}) +- if(TBB_LIBRARIES_RELEASE AND TBB_LIBRARIES_DEBUG) +- set_target_properties(TBB::tbb PROPERTIES +- INTERFACE_COMPILE_DEFINITIONS "${TBB_DEFINITIONS};$<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:${TBB_DEFINITIONS_DEBUG}>;$<$<CONFIG:Release>:${TBB_DEFINITIONS_RELEASE}>" +- IMPORTED_LOCATION_DEBUG ${TBB_LIBRARIES_DEBUG} +- IMPORTED_LOCATION_RELWITHDEBINFO ${TBB_LIBRARIES_RELEASE} +- IMPORTED_LOCATION_RELEASE ${TBB_LIBRARIES_RELEASE} +- IMPORTED_LOCATION_MINSIZEREL ${TBB_LIBRARIES_RELEASE} +- ) +- endif() +- endif() + +- mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARIES) ++find_path(TBB_INCLUDE_DIR ++ NAMES tbb/tbb.h ++ PATHS ${TBB_INC_SEARCH_PATH}) + +- unset(TBB_ARCHITECTURE) +- unset(TBB_BUILD_TYPE) +- unset(TBB_LIB_PATH_SUFFIX) +- unset(TBB_DEFAULT_SEARCH_DIR) ++find_library(TBB_LIBRARY_RELEASE ++ NAMES ${TBB_LIBRARY_NAMES} ++ PATHS ${TBB_LIB_SEARCH_PATH}) ++find_library(TBB_LIBRARY_DEBUG ++ NAMES ${TBB_LIBRARY_NAMES_DEBUG} ++ PATHS ${TBB_LIB_SEARCH_PATH}) ++make_library_set(TBB_LIBRARY) + +- if(TBB_DEBUG) +- message(STATUS " TBB_FOUND = ${TBB_FOUND}") +- message(STATUS " TBB_INCLUDE_DIRS = ${TBB_INCLUDE_DIRS}") +- message(STATUS " TBB_DEFINITIONS = ${TBB_DEFINITIONS}") +- message(STATUS " TBB_LIBRARIES = ${TBB_LIBRARIES}") +- message(STATUS " TBB_DEFINITIONS_DEBUG = ${TBB_DEFINITIONS_DEBUG}") +- message(STATUS " TBB_LIBRARIES_DEBUG = ${TBB_LIBRARIES_DEBUG}") +- message(STATUS " TBB_DEFINITIONS_RELEASE = ${TBB_DEFINITIONS_RELEASE}") +- message(STATUS " TBB_LIBRARIES_RELEASE = ${TBB_LIBRARIES_RELEASE}") ++findpkg_finish(TBB tbb) ++ ++#if we haven't found TBB no point on going any further ++if (NOT TBB_FOUND) ++ return() ++endif () ++ ++#============================================================================= ++# Look for TBB's malloc package ++set(TBB_MALLOC_LIBRARY_NAMES tbbmalloc) ++get_debug_names(TBB_MALLOC_LIBRARY_NAMES) ++ ++find_path(TBB_MALLOC_INCLUDE_DIR ++ NAMES tbb/tbb.h ++ PATHS ${TBB_INC_SEARCH_PATH}) ++ ++find_library(TBB_MALLOC_LIBRARY_RELEASE ++ NAMES ${TBB_MALLOC_LIBRARY_NAMES} ++ PATHS ${TBB_LIB_SEARCH_PATH}) ++find_library(TBB_MALLOC_LIBRARY_DEBUG ++ NAMES ${TBB_MALLOC_LIBRARY_NAMES_DEBUG} ++ PATHS ${TBB_LIB_SEARCH_PATH}) ++make_library_set(TBB_MALLOC_LIBRARY) ++ ++findpkg_finish(TBB_MALLOC tbbmalloc) ++ ++#============================================================================= ++# Look for TBB's malloc proxy package ++set(TBB_MALLOC_PROXY_LIBRARY_NAMES tbbmalloc_proxy) ++get_debug_names(TBB_MALLOC_PROXY_LIBRARY_NAMES) ++ ++find_path(TBB_MALLOC_PROXY_INCLUDE_DIR ++ NAMES tbb/tbbmalloc_proxy.h ++ PATHS ${TBB_INC_SEARCH_PATH}) ++ ++find_library(TBB_MALLOC_PROXY_LIBRARY_RELEASE ++ NAMES ${TBB_MALLOC_PROXY_LIBRARY_NAMES} ++ PATHS ${TBB_LIB_SEARCH_PATH}) ++find_library(TBB_MALLOC_PROXY_LIBRARY_DEBUG ++ NAMES ${TBB_MALLOC_PROXY_LIBRARY_NAMES_DEBUG} ++ PATHS ${TBB_LIB_SEARCH_PATH}) ++make_library_set(TBB_MALLOC_PROXY_LIBRARY) ++ ++findpkg_finish(TBB_MALLOC_PROXY tbbmalloc_proxy) ++ ++ ++#============================================================================= ++#parse all the version numbers from tbb ++if(NOT TBB_VERSION) ++ if (EXISTS "${TBB_INCLUDE_DIR}/oneapi/tbb/version.h") ++ file(STRINGS ++ "${TBB_INCLUDE_DIR}/oneapi/tbb/version.h" ++ TBB_VERSION_CONTENTS ++ REGEX "VERSION") ++ else() ++ #only read the start of the file ++ file(STRINGS ++ "${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h" ++ TBB_VERSION_CONTENTS ++ REGEX "VERSION") + endif() ++ ++ string(REGEX REPLACE ++ ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1" ++ TBB_VERSION_MAJOR "${TBB_VERSION_CONTENTS}") ++ ++ string(REGEX REPLACE ++ ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1" ++ TBB_VERSION_MINOR "${TBB_VERSION_CONTENTS}") ++ ++ string(REGEX REPLACE ++ ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" ++ TBB_INTERFACE_VERSION "${TBB_VERSION_CONTENTS}") ++ ++ string(REGEX REPLACE ++ ".*#define TBB_COMPATIBLE_INTERFACE_VERSION ([0-9]+).*" "\\1" ++ TBB_COMPATIBLE_INTERFACE_VERSION "${TBB_VERSION_CONTENTS}") + + endif() diff --git a/cad/PrusaSlicer/files/patch-src_avrdude_main.c b/cad/PrusaSlicer/files/patch-src_avrdude_main.c new file mode 100644 index 000000000000..19381b05b4a7 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_avrdude_main.c @@ -0,0 +1,11 @@ +--- src/avrdude/main.c.orig 2021-08-13 03:29:34 UTC ++++ src/avrdude/main.c +@@ -806,7 +806,7 @@ int avrdude_main(int argc, char * argv []) + avrdude_message(MSG_NOTICE, "\n%s: Version %s, compiled on %s at %s\n" + "%sCopyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/\n" + "%sCopyright (c) 2007-2014 Joerg Wunsch\n\n", +- progname, version, __DATE__, __TIME__, progbuf, progbuf); ++ progname, version, "REDACTED", "REDACTED", progbuf, progbuf); + // avrdude_message(MSG_NOTICE, "%sSystem wide configuration file is \"%s\"\n", + // progbuf, sys_config); + diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_CMakeLists.txt b/cad/PrusaSlicer/files/patch-src_libslic3r_CMakeLists.txt index b87e4be74f3f..0ad79d2f8993 100644 --- a/cad/PrusaSlicer/files/patch-src_libslic3r_CMakeLists.txt +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_CMakeLists.txt @@ -1,6 +1,6 @@ ---- src/libslic3r/CMakeLists.txt.orig 2021-02-16 20:42:21 UTC +--- src/libslic3r/CMakeLists.txt.orig 2021-07-16 10:14:03 UTC +++ src/libslic3r/CMakeLists.txt -@@ -297,7 +297,6 @@ target_include_directories(libslic3r PUBLIC ${EXPAT_IN +@@ -300,7 +300,6 @@ target_include_directories(libslic3r PUBLIC ${EXPAT_IN target_link_libraries(libslic3r libnest2d admesh diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_Platform.cpp b/cad/PrusaSlicer/files/patch-src_libslic3r_Platform.cpp new file mode 100644 index 000000000000..c584b09b4bef --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_Platform.cpp @@ -0,0 +1,13 @@ +--- src/libslic3r/Platform.cpp.orig 2021-04-20 12:16:52 UTC ++++ src/libslic3r/Platform.cpp +@@ -49,6 +49,10 @@ void detect_platform() + BOOST_LOG_TRIVIAL(info) << "Platform: OpenBSD"; + s_platform = Platform::BSDUnix; + s_platform_flavor = PlatformFlavor::OpenBSD; ++#elif defined(__FreeBSD__) ++ BOOST_LOG_TRIVIAL(info) << "Platform: FreeBSD"; ++ s_platform = Platform::BSDUnix; ++ s_platform_flavor = PlatformFlavor::FreeBSD; + #else + // This should not happen. + BOOST_LOG_TRIVIAL(info) << "Platform: Unknown"; diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_Platform.hpp b/cad/PrusaSlicer/files/patch-src_libslic3r_Platform.hpp new file mode 100644 index 000000000000..17da981d267a --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_Platform.hpp @@ -0,0 +1,10 @@ +--- src/libslic3r/Platform.hpp.orig 2021-04-20 12:26:01 UTC ++++ src/libslic3r/Platform.hpp +@@ -28,6 +28,7 @@ enum class PlatformFlavor + WSL2, + // For Platform::BSDUnix + OpenBSD, ++ FreeBSD, + }; + + // To be called on program start-up. diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_Print.cpp b/cad/PrusaSlicer/files/patch-src_libslic3r_Print.cpp new file mode 100644 index 000000000000..497cce5467a7 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_Print.cpp @@ -0,0 +1,29 @@ +--- src/libslic3r/Print.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/libslic3r/Print.cpp +@@ -36,7 +36,7 @@ template class PrintState<PrintObjectStep, posCount>; + + void Print::clear() + { +- tbb::mutex::scoped_lock lock(this->state_mutex()); ++ std::scoped_lock<std::mutex> lock(this->state_mutex()); + // The following call should stop background processing if it is running. + this->invalidate_all_steps(); + for (PrintObject *object : m_objects) +@@ -262,7 +262,7 @@ bool Print::is_step_done(PrintObjectStep step) const + { + if (m_objects.empty()) + return false; +- tbb::mutex::scoped_lock lock(this->state_mutex()); ++ std::scoped_lock<std::mutex> lock(this->state_mutex()); + for (const PrintObject *object : m_objects) + if (! object->is_step_done_unguarded(step)) + return false; +@@ -617,7 +617,7 @@ Print::ApplyStatus Print::apply(const Model &model, Dy + update_apply_status(false); + + // Grab the lock for the Print / PrintObject milestones. +- tbb::mutex::scoped_lock lock(this->state_mutex()); ++ std::scoped_lock<std::mutex> lock(this->state_mutex()); + + // The following call may stop the background processing. + if (! print_diff.empty()) diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_PrintBase.cpp b/cad/PrusaSlicer/files/patch-src_libslic3r_PrintBase.cpp new file mode 100644 index 000000000000..7f903f9adaa4 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_PrintBase.cpp @@ -0,0 +1,11 @@ +--- src/libslic3r/PrintBase.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/libslic3r/PrintBase.cpp +@@ -97,7 +97,7 @@ void PrintBase::status_update_warnings(ObjectID object + printf("%s warning: %s\n", (object_id == this->id()) ? "print" : "print object", message.c_str()); + } + +-tbb::mutex& PrintObjectBase::state_mutex(PrintBase *print) ++std::mutex& PrintObjectBase::state_mutex(PrintBase *print) + { + return print->state_mutex(); + } diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_PrintBase.hpp b/cad/PrusaSlicer/files/patch-src_libslic3r_PrintBase.hpp new file mode 100644 index 000000000000..0db7f4672dfd --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_PrintBase.hpp @@ -0,0 +1,118 @@ +--- src/libslic3r/PrintBase.hpp.orig 2021-07-16 10:14:03 UTC ++++ src/libslic3r/PrintBase.hpp +@@ -6,13 +6,9 @@ + #include <vector> + #include <string> + #include <functional> ++#include <atomic> ++#include <mutex> + +-// tbb/mutex.h includes Windows, which in turn defines min/max macros. Convince Windows.h to not define these min/max macros. +-#ifndef NOMINMAX +- #define NOMINMAX +-#endif +-#include "tbb/mutex.h" +- + #include "ObjectID.hpp" + #include "Model.hpp" + #include "PlaceholderParser.hpp" +@@ -84,23 +80,23 @@ class PrintState : public PrintStateBase + public: + PrintState() {} + +- StateWithTimeStamp state_with_timestamp(StepType step, tbb::mutex &mtx) const { +- tbb::mutex::scoped_lock lock(mtx); ++ StateWithTimeStamp state_with_timestamp(StepType step, std::mutex &mtx) const { ++ std::scoped_lock<std::mutex> lock(mtx); + StateWithTimeStamp state = m_state[step]; + return state; + } + +- StateWithWarnings state_with_warnings(StepType step, tbb::mutex &mtx) const { +- tbb::mutex::scoped_lock lock(mtx); ++ StateWithWarnings state_with_warnings(StepType step, std::mutex &mtx) const { ++ std::scoped_lock<std::mutex> lock(mtx); + StateWithWarnings state = m_state[step]; + return state; + } + +- bool is_started(StepType step, tbb::mutex &mtx) const { ++ bool is_started(StepType step, std::mutex &mtx) const { + return this->state_with_timestamp(step, mtx).state == STARTED; + } + +- bool is_done(StepType step, tbb::mutex &mtx) const { ++ bool is_done(StepType step, std::mutex &mtx) const { + return this->state_with_timestamp(step, mtx).state == DONE; + } + +@@ -121,8 +117,8 @@ class PrintState : public PrintStateBase + // This is necessary to block until the Print::apply() updates its state, which may + // influence the processing step being entered. + template<typename ThrowIfCanceled> +- bool set_started(StepType step, tbb::mutex &mtx, ThrowIfCanceled throw_if_canceled) { +- tbb::mutex::scoped_lock lock(mtx); ++ bool set_started(StepType step, std::mutex &mtx, ThrowIfCanceled throw_if_canceled) { ++ std::scoped_lock<std::mutex> lock(mtx); + // If canceled, throw before changing the step state. + throw_if_canceled(); + #ifndef NDEBUG +@@ -154,8 +150,8 @@ class PrintState : public PrintStateBase + // Timestamp when this stepentered the DONE state. + // bool indicates whether the UI has to update the slicing warnings of this step or not. + template<typename ThrowIfCanceled> +- std::pair<TimeStamp, bool> set_done(StepType step, tbb::mutex &mtx, ThrowIfCanceled throw_if_canceled) { +- tbb::mutex::scoped_lock lock(mtx); ++ std::pair<TimeStamp, bool> set_done(StepType step, std::mutex &mtx, ThrowIfCanceled throw_if_canceled) { ++ std::scoped_lock<std::mutex> lock(mtx); + // If canceled, throw before changing the step state. + throw_if_canceled(); + assert(m_state[step].state == STARTED); +@@ -266,9 +262,9 @@ class PrintState : public PrintStateBase + // Return value: + // Current milestone (StepType). + // bool indicates whether the UI has to be updated or not. +- std::pair<StepType, bool> active_step_add_warning(PrintStateBase::WarningLevel warning_level, const std::string &message, int message_id, tbb::mutex &mtx) ++ std::pair<StepType, bool> active_step_add_warning(PrintStateBase::WarningLevel warning_level, const std::string &message, int message_id, std::mutex &mtx) + { +- tbb::mutex::scoped_lock lock(mtx); ++ std::scoped_lock<std::mutex> lock(mtx); + assert(m_step_active != -1); + StateWithWarnings &state = m_state[m_step_active]; + assert(state.state == STARTED); +@@ -314,7 +310,7 @@ class PrintObjectBase : public ObjectBase (protected) + PrintObjectBase(ModelObject *model_object) : m_model_object(model_object) {} + virtual ~PrintObjectBase() {} + // Declared here to allow access from PrintBase through friendship. +- static tbb::mutex& state_mutex(PrintBase *print); ++ static std::mutex& state_mutex(PrintBase *print); + static std::function<void()> cancel_callback(PrintBase *print); + // Notify UI about a new warning of a milestone "step" on this PrintObjectBase. + // The UI will be notified by calling a status callback registered on print. +@@ -461,7 +457,7 @@ class PrintBase : public ObjectBase (protected) + friend class PrintObjectBase; + friend class BackgroundSlicingProcess; + +- tbb::mutex& state_mutex() const { return m_state_mutex; } ++ std::mutex& state_mutex() const { return m_state_mutex; } + std::function<void()> cancel_callback() { return m_cancel_callback; } + void call_cancel_callback() { m_cancel_callback(); } + // Notify UI about a new warning of a milestone "step" on this PrintBase. +@@ -486,7 +482,7 @@ class PrintBase : public ObjectBase (protected) + status_callback_type m_status_callback; + + private: +- tbb::atomic<CancelStatus> m_cancel_status; ++ std::atomic<CancelStatus> m_cancel_status; + + // Callback to be evoked to stop the background processing before a state is updated. + cancel_callback_type m_cancel_callback = [](){}; +@@ -494,7 +490,7 @@ class PrintBase : public ObjectBase (protected) + // Mutex used for synchronization of the worker thread with the UI thread: + // The mutex will be used to guard the worker thread against entering a stage + // while the data influencing the stage is modified. +- mutable tbb::mutex m_state_mutex; ++ mutable std::mutex m_state_mutex; + }; + + template<typename PrintStepEnum, const size_t COUNT> diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_PrintObject.cpp b/cad/PrusaSlicer/files/patch-src_libslic3r_PrintObject.cpp new file mode 100644 index 000000000000..3239fa337a41 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_PrintObject.cpp @@ -0,0 +1,10 @@ +--- src/libslic3r/PrintObject.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/libslic3r/PrintObject.cpp +@@ -19,7 +19,6 @@ + #include <float.h> + + #include <tbb/parallel_for.h> +-#include <tbb/atomic.h> + + #include <Shiny/Shiny.h> + diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_SLAPrint.cpp b/cad/PrusaSlicer/files/patch-src_libslic3r_SLAPrint.cpp new file mode 100644 index 000000000000..0b9990bc2b1e --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_SLAPrint.cpp @@ -0,0 +1,47 @@ +--- src/libslic3r/SLAPrint.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/libslic3r/SLAPrint.cpp +@@ -19,8 +19,6 @@ + #include <libnest2d/tools/benchmark.h> + #endif + +-//#include <tbb/spin_mutex.h>//#include "tbb/mutex.h" +- + #include "I18N.hpp" + + //! macro used to mark string used at localization, +@@ -118,7 +116,7 @@ bool validate_pad(const TriangleMesh &pad, const sla:: + + void SLAPrint::clear() + { +- tbb::mutex::scoped_lock lock(this->state_mutex()); ++ std::scoped_lock<std::mutex> lock(this->state_mutex()); + // The following call should stop background processing if it is running. + this->invalidate_all_steps(); + for (SLAPrintObject *object : m_objects) +@@ -212,7 +210,7 @@ SLAPrint::ApplyStatus SLAPrint::apply(const Model &mod + update_apply_status(false); + + // Grab the lock for the Print / PrintObject milestones. +- tbb::mutex::scoped_lock lock(this->state_mutex()); ++ std::scoped_lock<std::mutex> lock(this->state_mutex()); + + // The following call may stop the background processing. + bool invalidate_all_model_objects = false; +@@ -514,7 +512,7 @@ SLAPrint::ApplyStatus SLAPrint::apply(const Model &mod + void SLAPrint::set_task(const TaskParams ¶ms) + { + // Grab the lock for the Print / PrintObject milestones. +- tbb::mutex::scoped_lock lock(this->state_mutex()); ++ std::scoped_lock<std::mutex> lock(this->state_mutex()); + + int n_object_steps = int(params.to_object_step) + 1; + if (n_object_steps == 0) +@@ -884,7 +882,7 @@ bool SLAPrint::is_step_done(SLAPrintObjectStep step) c + { + if (m_objects.empty()) + return false; +- tbb::mutex::scoped_lock lock(this->state_mutex()); ++ std::scoped_lock<std::mutex> lock(this->state_mutex()); + for (const SLAPrintObject *object : m_objects) + if (! object->is_step_done_unguarded(step)) + return false; diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_SLA_Concurrency.hpp b/cad/PrusaSlicer/files/patch-src_libslic3r_SLA_Concurrency.hpp new file mode 100644 index 000000000000..673e157e0775 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_SLA_Concurrency.hpp @@ -0,0 +1,20 @@ +--- src/libslic3r/SLA/Concurrency.hpp.orig 2021-08-14 22:14:14 UTC ++++ src/libslic3r/SLA/Concurrency.hpp +@@ -2,7 +2,7 @@ + #define SLA_CONCURRENCY_H + + #include <tbb/spin_mutex.h> +-#include <tbb/mutex.h> ++#include <mutex> + #include <tbb/parallel_for.h> + #include <tbb/parallel_reduce.h> + +@@ -23,7 +23,7 @@ template<bool> struct _ccr {}; + template<> struct _ccr<true> + { + using SpinningMutex = tbb::spin_mutex; +- using BlockingMutex = tbb::mutex; ++ using BlockingMutex = std::mutex; + + template<class Fn, class It> + static IteratorOnly<It, void> loop_(const tbb::blocked_range<It> &range, Fn &&fn) diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_SLA_SupportTree.cpp b/cad/PrusaSlicer/files/patch-src_libslic3r_SLA_SupportTree.cpp new file mode 100644 index 000000000000..128667eac2d0 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_SLA_SupportTree.cpp @@ -0,0 +1,12 @@ +--- src/libslic3r/SLA/SupportTree.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/libslic3r/SLA/SupportTree.cpp +@@ -16,9 +16,6 @@ + #include <libnest2d/optimizers/nlopt/genetic.hpp> + #include <libnest2d/optimizers/nlopt/subplex.hpp> + #include <boost/log/trivial.hpp> +-#include <tbb/parallel_for.h> +-#include <tbb/mutex.h> +-#include <tbb/spin_mutex.h> + #include <libslic3r/I18N.hpp> + + //! macro used to mark string used at localization, diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_SupportMaterial.cpp b/cad/PrusaSlicer/files/patch-src_libslic3r_SupportMaterial.cpp new file mode 100644 index 000000000000..569e440ec707 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_SupportMaterial.cpp @@ -0,0 +1,10 @@ +--- src/libslic3r/SupportMaterial.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/libslic3r/SupportMaterial.cpp +@@ -12,7 +12,6 @@ + #include <boost/log/trivial.hpp> + + #include <tbb/parallel_for.h> +-#include <tbb/atomic.h> + #include <tbb/spin_mutex.h> + #include <tbb/task_group.h> + diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_Thread.cpp b/cad/PrusaSlicer/files/patch-src_libslic3r_Thread.cpp index d48272fed2fe..23d0e75df413 100644 --- a/cad/PrusaSlicer/files/patch-src_libslic3r_Thread.cpp +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_Thread.cpp @@ -2,45 +2,44 @@ Note that this patch may be removed after FreeBSD 11.x EoL as latest FreeBSD versions have proper pthread_setname_np/pthread_getname_np support. ---- src/libslic3r/Thread.cpp.orig 2021-01-11 13:01:51 UTC +--- src/libslic3r/Thread.cpp.orig 2021-07-16 10:14:03 UTC +++ src/libslic3r/Thread.cpp -@@ -4,6 +4,7 @@ - #else - // any posix system - #include <pthread.h> -+ #include <pthread_np.h> - #endif - +@@ -9,10 +9,10 @@ #include <atomic> -@@ -161,26 +162,27 @@ std::optional<std::string> get_current_thread_name() - // posix - bool set_thread_name(std::thread &thread, const char *thread_name) - { -- pthread_setname_np(thread.native_handle(), thread_name); -+ pthread_set_name_np(thread.native_handle(), thread_name); - return true; - } + #include <condition_variable> + #include <mutex> ++#include <thread> ++#include <tbb/global_control.h> + #include <tbb/parallel_for.h> +-#include <tbb/tbb_thread.h> + #include <tbb/task_arena.h> +-#include <tbb/task_scheduler_init.h> - bool set_thread_name(boost::thread &thread, const char *thread_name) - { -- pthread_setname_np(thread.native_handle(), thread_name); -+ pthread_set_name_np(thread.native_handle(), thread_name); - return true; - } + #include "Thread.hpp" - bool set_current_thread_name(const char *thread_name) - { -- pthread_setname_np(pthread_self(), thread_name); -+ pthread_set_name_np(pthread_self(), thread_name); - return true; - } +@@ -206,13 +206,13 @@ void name_tbb_thread_pool_threads() + nthreads = 1; + #endif - std::optional<std::string> get_current_thread_name() - { - char buf[16]; -- return std::string(pthread_getname_np(pthread_self(), buf, 16) == 0 ? buf : ""); -+ pthread_get_name_np(pthread_self(), buf, 16); -+ return std::string(buf); - } +- if (nthreads != nthreads_hw) +- new tbb::task_scheduler_init(int(nthreads)); ++ if (nthreads != nthreads_hw) ++ tbb::global_control(tbb::global_control::max_allowed_parallelism, nthreads); - #endif + std::atomic<size_t> nthreads_running(0); + std::condition_variable cv; + std::mutex cv_m; +- auto master_thread_id = tbb::this_tbb_thread::get_id(); ++ auto master_thread_id = std::this_thread::get_id(); + tbb::parallel_for( + tbb::blocked_range<size_t>(0, nthreads, 1), + [&nthreads_running, nthreads, &master_thread_id, &cv, &cv_m](const tbb::blocked_range<size_t> &range) { +@@ -226,7 +226,7 @@ void name_tbb_thread_pool_threads() + std::unique_lock<std::mutex> lk(cv_m); + cv.wait(lk, [&nthreads_running, nthreads]{return nthreads_running == nthreads;}); + } +- auto thread_id = tbb::this_tbb_thread::get_id(); ++ auto thread_id = std::this_thread::get_id(); + if (thread_id == master_thread_id) { + // The calling thread runs the 0'th task. + assert(range.begin() == 0); diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_pchheader.hpp b/cad/PrusaSlicer/files/patch-src_libslic3r_pchheader.hpp new file mode 100644 index 000000000000..11b6b726c0c4 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_pchheader.hpp @@ -0,0 +1,15 @@ +--- src/libslic3r/pchheader.hpp.orig 2021-07-16 10:14:03 UTC ++++ src/libslic3r/pchheader.hpp +@@ -93,12 +93,9 @@ + #include <boost/thread.hpp> + #include <boost/version.hpp> + +-#include <tbb/atomic.h> + #include <tbb/parallel_for.h> + #include <tbb/spin_mutex.h> +-#include <tbb/mutex.h> + #include <tbb/task_group.h> +-#include <tbb/task_scheduler_init.h> + + #include <Eigen/Dense> + #include <Eigen/Geometry> diff --git a/cad/PrusaSlicer/files/patch-src_libslic3r_utils.cpp b/cad/PrusaSlicer/files/patch-src_libslic3r_utils.cpp new file mode 100644 index 000000000000..4eb0a65020b3 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_libslic3r_utils.cpp @@ -0,0 +1,22 @@ +--- src/libslic3r/utils.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/libslic3r/utils.cpp +@@ -43,7 +43,7 @@ + #include <boost/nowide/convert.hpp> + #include <boost/nowide/cstdio.hpp> + +-#include <tbb/task_scheduler_init.h> ++#include <tbb/global_control.h> + + #if defined(__linux__) || defined(__GNUC__ ) + #include <strings.h> +@@ -118,9 +118,7 @@ void trace(unsigned int level, const char *message) + void disable_multi_threading() + { + // Disable parallelization so the Shiny profiler works +- static tbb::task_scheduler_init *tbb_init = nullptr; +- if (tbb_init == nullptr) +- tbb_init = new tbb::task_scheduler_init(1); ++ tbb::global_control(tbb::global_control::max_allowed_parallelism, 1); + } + + static std::string g_var_dir; diff --git a/cad/PrusaSlicer/files/patch-src_slic3r_GUI_BackgroundSlicingProcess.cpp b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_BackgroundSlicingProcess.cpp new file mode 100644 index 000000000000..f56446391229 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_BackgroundSlicingProcess.cpp @@ -0,0 +1,29 @@ +--- src/slic3r/GUI/BackgroundSlicingProcess.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/slic3r/GUI/BackgroundSlicingProcess.cpp +@@ -465,7 +465,7 @@ void BackgroundSlicingProcess::schedule_export(const s + return; + + // Guard against entering the export step before changing the export path. +- tbb::mutex::scoped_lock lock(m_print->state_mutex()); ++ std::scoped_lock<std::mutex> lock(m_print->state_mutex()); + this->invalidate_step(bspsGCodeFinalize); + m_export_path = path; + m_export_path_on_removable_media = export_path_on_removable_media; +@@ -478,7 +478,7 @@ void BackgroundSlicingProcess::schedule_upload(Slic3r: + return; + + // Guard against entering the export step before changing the export path. +- tbb::mutex::scoped_lock lock(m_print->state_mutex()); ++ std::scoped_lock<std::mutex> lock(m_print->state_mutex()); + this->invalidate_step(bspsGCodeFinalize); + m_export_path.clear(); + m_upload_job = std::move(upload_job); +@@ -491,7 +491,7 @@ void BackgroundSlicingProcess::reset_export() + m_export_path.clear(); + m_export_path_on_removable_media = false; + // invalidate_step expects the mutex to be locked. +- tbb::mutex::scoped_lock lock(m_print->state_mutex()); ++ std::scoped_lock<std::mutex> lock(m_print->state_mutex()); + this->invalidate_step(bspsGCodeFinalize); + } + } diff --git a/cad/PrusaSlicer/files/patch-src_slic3r_GUI_BackgroundSlicingProcess.hpp b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_BackgroundSlicingProcess.hpp new file mode 100644 index 000000000000..e35befaa435a --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_BackgroundSlicingProcess.hpp @@ -0,0 +1,11 @@ +--- src/slic3r/GUI/BackgroundSlicingProcess.hpp.orig 2021-08-14 22:52:55 UTC ++++ src/slic3r/GUI/BackgroundSlicingProcess.hpp +@@ -213,7 +213,7 @@ class BackgroundSlicingProcess (private) + State m_state = STATE_INITIAL; + + PrintState<BackgroundSlicingProcessStep, bspsCount> m_step_state; +- mutable tbb::mutex m_step_state_mutex; ++ mutable std::mutex m_step_state_mutex; + bool set_step_started(BackgroundSlicingProcessStep step); + void set_step_done(BackgroundSlicingProcessStep step); + bool is_step_done(BackgroundSlicingProcessStep step) const; diff --git a/cad/PrusaSlicer/files/patch-src_slic3r_GUI_InstanceCheck.hpp b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_InstanceCheck.hpp new file mode 100644 index 000000000000..0c32c309a1d8 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_InstanceCheck.hpp @@ -0,0 +1,11 @@ +--- src/slic3r/GUI/InstanceCheck.hpp.orig 2021-07-16 10:14:03 UTC ++++ src/slic3r/GUI/InstanceCheck.hpp +@@ -13,7 +13,7 @@ + + #if __linux__ + #include <boost/thread.hpp> +-#include <tbb/mutex.h> ++#include <mutex> + #include <condition_variable> + #endif // __linux__ + diff --git a/cad/PrusaSlicer/files/patch-src_slic3r_GUI_Mouse3DController.cpp b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_Mouse3DController.cpp new file mode 100644 index 000000000000..f1122392e483 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_Mouse3DController.cpp @@ -0,0 +1,154 @@ +--- src/slic3r/GUI/Mouse3DController.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/slic3r/GUI/Mouse3DController.cpp +@@ -66,7 +66,7 @@ void update_maximum(std::atomic<T>& maximum_value, T c + + void Mouse3DController::State::append_translation(const Vec3d& translation, size_t input_queue_max_size) + { +- tbb::mutex::scoped_lock lock(m_input_queue_mutex); ++ std::scoped_lock<std::mutex> lock(m_input_queue_mutex); + while (m_input_queue.size() >= input_queue_max_size) + m_input_queue.pop_front(); + m_input_queue.emplace_back(QueueItem::translation(translation)); +@@ -77,7 +77,7 @@ void Mouse3DController::State::append_translation(cons + + void Mouse3DController::State::append_rotation(const Vec3f& rotation, size_t input_queue_max_size) + { +- tbb::mutex::scoped_lock lock(m_input_queue_mutex); ++ std::scoped_lock<std::mutex> lock(m_input_queue_mutex); + while (m_input_queue.size() >= input_queue_max_size) + m_input_queue.pop_front(); + m_input_queue.emplace_back(QueueItem::rotation(rotation.cast<double>())); +@@ -92,7 +92,7 @@ void Mouse3DController::State::append_rotation(const V + + void Mouse3DController::State::append_button(unsigned int id, size_t /* input_queue_max_size */) + { +- tbb::mutex::scoped_lock lock(m_input_queue_mutex); ++ std::scoped_lock<std::mutex> lock(m_input_queue_mutex); + m_input_queue.emplace_back(QueueItem::buttons(id)); + #if ENABLE_3DCONNEXION_DEVICES_DEBUG_OUTPUT + update_maximum(input_queue_max_size_achieved, m_input_queue.size()); +@@ -277,7 +277,7 @@ void Mouse3DController::device_attached(const std::str + #if ENABLE_CTRL_M_ON_WINDOWS + m_device_str = format_device_string(vid, pid); + if (auto it_params = m_params_by_device.find(m_device_str); it_params != m_params_by_device.end()) { +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + m_params = m_params_ui = it_params->second; + } + else +@@ -295,7 +295,7 @@ void Mouse3DController::device_detached(const std::str + int pid = 0; + if (sscanf(device.c_str(), "\\\\?\\HID#VID_%x&PID_%x&", &vid, &pid) == 2) { + if (std::find(_3DCONNEXION_VENDORS.begin(), _3DCONNEXION_VENDORS.end(), vid) != _3DCONNEXION_VENDORS.end()) { +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + m_params_by_device[format_device_string(vid, pid)] = m_params_ui; + } + } +@@ -307,12 +307,12 @@ void Mouse3DController::device_detached(const std::str + // Filter out mouse scroll events produced by the 3DConnexion driver. + bool Mouse3DController::State::process_mouse_wheel() + { +- tbb::mutex::scoped_lock lock(m_input_queue_mutex); +- if (m_mouse_wheel_counter == 0) +- // No 3DConnexion rotation has been captured since the last mouse scroll event. ++ std::scoped_lock<std::mutex> lock(m_input_queue_mutex); ++ if (m_mouse_wheel_counter == 0) ++ // No 3DConnexion rotation has been captured since the last mouse scroll event. + return false; + if (std::find_if(m_input_queue.begin(), m_input_queue.end(), [](const QueueItem &item){ return item.is_rotation(); }) != m_input_queue.end()) { +- // There is a rotation stored in the queue. Suppress one mouse scroll event. ++ // There is a rotation stored in the queue. Suppress one mouse scroll event. + -- m_mouse_wheel_counter; + return true; + } +@@ -329,7 +329,7 @@ bool Mouse3DController::State::apply(const Mouse3DCont + std::deque<QueueItem> input_queue; + { + // Atomically move m_input_queue to input_queue. +- tbb::mutex::scoped_lock lock(m_input_queue_mutex); ++ std::scoped_lock<std::mutex> lock(m_input_queue_mutex); + input_queue = std::move(m_input_queue); + m_input_queue.clear(); + } +@@ -418,7 +418,7 @@ bool Mouse3DController::apply(Camera& camera) + #if ENABLE_CTRL_M_ON_WINDOWS + #ifdef _WIN32 + { +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + if (m_params_ui_changed) { + m_params = m_params_ui; + m_params_ui_changed = false; +@@ -447,7 +447,7 @@ void Mouse3DController::render_settings_dialog(GLCanva + Params params_copy; + bool params_changed = false; + { +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + params_copy = m_params_ui; + } + +@@ -565,7 +565,7 @@ void Mouse3DController::render_settings_dialog(GLCanva + + if (params_changed) { + // Synchronize front end parameters to back end. +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + auto pthis = const_cast<Mouse3DController*>(this); + #if ENABLE_3DCONNEXION_DEVICES_DEBUG_OUTPUT + if (params_copy.input_queue_max_size != params_copy.input_queue_max_size) +@@ -586,7 +586,7 @@ void Mouse3DController::connected(std::string device_n + m_device_str = device_name; + // Copy the parameters for m_device_str into the current parameters. + if (auto it_params = m_params_by_device.find(m_device_str); it_params != m_params_by_device.end()) { +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + m_params = m_params_ui = it_params->second; + } + m_connected = true; +@@ -597,7 +597,7 @@ void Mouse3DController::disconnected() + // Copy the current parameters for m_device_str into the parameter database. + assert(m_connected == ! m_device_str.empty()); + if (m_connected) { +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + m_params_by_device[m_device_str] = m_params_ui; + m_device_str.clear(); + m_connected = false; +@@ -621,7 +621,7 @@ bool Mouse3DController::handle_input(const DataPacketA + { + // Synchronize parameters between the UI thread and the background thread. + //FIXME is this necessary on OSX? Are these notifications triggered from the main thread or from a worker thread? +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + if (m_params_ui_changed) { + m_params = m_params_ui; + m_params_ui_changed = false; +@@ -733,7 +733,7 @@ void Mouse3DController::run() + + for (;;) { + { +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + if (m_stop) + break; + if (m_params_ui_changed) { +@@ -998,7 +998,7 @@ bool Mouse3DController::connect_device() + #endif // ENABLE_3DCONNEXION_DEVICES_DEBUG_OUTPUT + // Copy the parameters for m_device_str into the current parameters. + if (auto it_params = m_params_by_device.find(m_device_str); it_params != m_params_by_device.end()) { +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + m_params = m_params_ui = it_params->second; + } + } +@@ -1023,7 +1023,7 @@ void Mouse3DController::disconnect_device() + BOOST_LOG_TRIVIAL(info) << "Disconnected device: " << m_device_str; + // Copy the current parameters for m_device_str into the parameter database. + { +- tbb::mutex::scoped_lock lock(m_params_ui_mutex); ++ std::scoped_lock<std::mutex> lock(m_params_ui_mutex); + m_params_by_device[m_device_str] = m_params_ui; + } + m_device_str.clear(); diff --git a/cad/PrusaSlicer/files/patch-src_slic3r_GUI_Mouse3DController.hpp b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_Mouse3DController.hpp new file mode 100644 index 000000000000..47600dece5a7 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_Mouse3DController.hpp @@ -0,0 +1,49 @@ +--- src/slic3r/GUI/Mouse3DController.hpp.orig 2021-07-16 10:14:03 UTC ++++ src/slic3r/GUI/Mouse3DController.hpp +@@ -10,12 +10,12 @@ + + #include <queue> + #include <atomic> ++#include <mutex> + #include <thread> + #include <vector> + #include <chrono> + #include <condition_variable> + +-#include <tbb/mutex.h> + + namespace Slic3r { + +@@ -85,7 +85,7 @@ class Mouse3DController + // m_input_queue is accessed by the background thread and by the UI thread. Access to m_input_queue + // is guarded with m_input_queue_mutex. + std::deque<QueueItem> m_input_queue; +- mutable tbb::mutex m_input_queue_mutex; ++ mutable std::mutex m_input_queue_mutex; + + #ifdef WIN32 + // When the 3Dconnexion driver is running the system gets, by default, mouse wheel events when rotations around the X axis are detected. +@@ -112,12 +112,12 @@ class Mouse3DController + + #if ENABLE_3DCONNEXION_DEVICES_DEBUG_OUTPUT + Vec3d get_first_vector_of_type(unsigned int type) const { +- tbb::mutex::scoped_lock lock(m_input_queue_mutex); ++ std::scoped_lock<std::mutex> lock(m_input_queue_mutex); + auto it = std::find_if(m_input_queue.begin(), m_input_queue.end(), [type](const QueueItem& item) { return item.type_or_buttons == type; }); + return (it == m_input_queue.end()) ? Vec3d::Zero() : it->vector; + } + size_t input_queue_size_current() const { +- tbb::mutex::scoped_lock lock(m_input_queue_mutex); ++ std::scoped_lock<std::mutex> lock(m_input_queue_mutex); + return m_input_queue.size(); + } + std::atomic<size_t> input_queue_max_size_achieved; +@@ -133,7 +133,7 @@ class Mouse3DController + // UI thread will read / write this copy. + Params m_params_ui; + bool m_params_ui_changed { false }; +- mutable tbb::mutex m_params_ui_mutex; ++ mutable std::mutex m_params_ui_mutex; + + // This is a database of parametes of all 3DConnexion devices ever connected. + // This database is loaded from AppConfig on application start and it is stored to AppConfig on application exit. diff --git a/cad/PrusaSlicer/files/patch-src_slic3r_GUI_OpenGLManager.cpp b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_OpenGLManager.cpp index ede8451a494f..fb6931a7fe86 100644 --- a/cad/PrusaSlicer/files/patch-src_slic3r_GUI_OpenGLManager.cpp +++ b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_OpenGLManager.cpp @@ -1,6 +1,6 @@ ---- src/slic3r/GUI/OpenGLManager.cpp.orig 2021-08-03 16:17:35 UTC +--- src/slic3r/GUI/OpenGLManager.cpp.orig 2021-04-16 11:41:00 UTC +++ src/slic3r/GUI/OpenGLManager.cpp -@@ -237,7 +237,8 @@ bool OpenGLManager::init_gl() +@@ -239,7 +239,8 @@ bool OpenGLManager::init_gl() if (!m_gl_initialized) { if (glewInit() != GLEW_OK) { BOOST_LOG_TRIVIAL(error) << "Unable to init glew library"; diff --git a/cad/PrusaSlicer/files/patch-src_slic3r_GUI_RemovableDriveManager.cpp b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_RemovableDriveManager.cpp new file mode 100644 index 000000000000..1f810f561423 --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_RemovableDriveManager.cpp @@ -0,0 +1,104 @@ +--- src/slic3r/GUI/RemovableDriveManager.cpp.orig 2021-07-16 10:14:03 UTC ++++ src/slic3r/GUI/RemovableDriveManager.cpp +@@ -84,7 +84,7 @@ void RemovableDriveManager::eject_drive() + this->update(); + #endif // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS + BOOST_LOG_TRIVIAL(info) << "Ejecting started"; +- tbb::mutex::scoped_lock lock(m_drives_mutex); ++ std::scoped_lock<std::mutex> lock(m_drives_mutex); + auto it_drive_data = this->find_last_save_path_drive_data(); + if (it_drive_data != m_current_drives.end()) { + // get handle to device +@@ -130,7 +130,7 @@ std::string RemovableDriveManager::get_removable_drive + this->update(); + #endif // REMOVABLE_DRIVE_MANAGER_OS_CALLBACKS + +- tbb::mutex::scoped_lock lock(m_drives_mutex); ++ std::scoped_lock<std::mutex> lock(m_drives_mutex); + if (m_current_drives.empty()) + return std::string(); + std::size_t found = path.find_last_of("\\"); +@@ -146,7 +146,7 @@ std::string RemovableDriveManager::get_removable_drive + + std::string RemovableDriveManager::get_removable_drive_from_path(const std::string& path) + { +- tbb::mutex::scoped_lock lock(m_drives_mutex); ++ std::scoped_lock<std::mutex> lock(m_drives_mutex); + std::size_t found = path.find_last_of("\\"); + std::string new_path = path.substr(0, found); + int letter = PathGetDriveNumberW(boost::nowide::widen(new_path).c_str()); +@@ -285,7 +285,7 @@ void RemovableDriveManager::eject_drive() + + DriveData drive_data; + { +- tbb::mutex::scoped_lock lock(m_drives_mutex); ++ std::scoped_lock<std::mutex> lock(m_drives_mutex); + auto it_drive_data = this->find_last_save_path_drive_data(); + if (it_drive_data == m_current_drives.end()) + return; +@@ -341,7 +341,7 @@ void RemovableDriveManager::eject_drive() + if (success) { + // Remove the drive_data from m_current drives, searching by value, not by pointer, as m_current_drives may get modified during + // asynchronous execution on m_eject_thread. +- tbb::mutex::scoped_lock lock(m_drives_mutex); ++ std::scoped_lock<std::mutex> lock(m_drives_mutex); + auto it = std::find(m_current_drives.begin(), m_current_drives.end(), drive_data); + if (it != m_current_drives.end()) + m_current_drives.erase(it); +@@ -361,7 +361,7 @@ std::string RemovableDriveManager::get_removable_drive + std::size_t found = path.find_last_of("/"); + std::string new_path = found == path.size() - 1 ? path.substr(0, found) : path; + +- tbb::mutex::scoped_lock lock(m_drives_mutex); ++ std::scoped_lock<std::mutex> lock(m_drives_mutex); + for (const DriveData &data : m_current_drives) + if (search_for_drives_internal::compare_filesystem_id(new_path, data.path)) + return path; +@@ -377,7 +377,7 @@ std::string RemovableDriveManager::get_removable_drive + new_path = new_path.substr(0, found); + + // check if same filesystem +- tbb::mutex::scoped_lock lock(m_drives_mutex); ++ std::scoped_lock<std::mutex> lock(m_drives_mutex); + for (const DriveData &drive_data : m_current_drives) + if (search_for_drives_internal::compare_filesystem_id(new_path, drive_data.path)) + return drive_data.path; +@@ -452,7 +452,7 @@ RemovableDriveManager::RemovableDrivesStatus Removable + + RemovableDriveManager::RemovableDrivesStatus out; + { +- tbb::mutex::scoped_lock lock(m_drives_mutex); ++ std::scoped_lock<std::mutex> lock(m_drives_mutex); + out.has_eject = + // Cannot control eject on Chromium. + platform_flavor() != PlatformFlavor::LinuxOnChromium && +@@ -468,17 +468,17 @@ RemovableDriveManager::RemovableDrivesStatus Removable + // Update is called from thread_proc() and from most of the public methods on demand. + void RemovableDriveManager::update() + { +- tbb::mutex::scoped_lock inside_update_lock; ++ std::unique_lock<std::mutex> inside_update_lock(m_inside_update_mutex, std::defer_lock); + #ifdef _WIN32 + // All wake up calls up to now are now consumed when the drive enumeration starts. + m_wakeup = false; + #endif // _WIN32 +- if (inside_update_lock.try_acquire(m_inside_update_mutex)) { ++ if (inside_update_lock.try_lock()) { + // Got the lock without waiting. That means, the update was not running. + // Run the update. + std::vector<DriveData> current_drives = this->search_for_removable_drives(); + // Post update events. +- tbb::mutex::scoped_lock lock(m_drives_mutex); ++ std::scoped_lock<std::mutex> lock(m_drives_mutex); + std::sort(current_drives.begin(), current_drives.end()); + if (current_drives != m_current_drives) { + assert(m_callback_evt_handler); +@@ -489,7 +489,7 @@ void RemovableDriveManager::update() + } else { + // Acquiring the m_iniside_update lock failed, therefore another update is running. + // Just block until the other instance of update() finishes. +- inside_update_lock.acquire(m_inside_update_mutex); ++ inside_update_lock.lock(); + } + } + diff --git a/cad/PrusaSlicer/files/patch-src_slic3r_GUI_RemovableDriveManager.hpp b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_RemovableDriveManager.hpp new file mode 100644 index 000000000000..a09b359b6dbf --- /dev/null +++ b/cad/PrusaSlicer/files/patch-src_slic3r_GUI_RemovableDriveManager.hpp @@ -0,0 +1,23 @@ +--- src/slic3r/GUI/RemovableDriveManager.hpp.orig 2021-07-16 10:14:03 UTC ++++ src/slic3r/GUI/RemovableDriveManager.hpp +@@ -5,7 +5,7 @@ + #include <string> + + #include <boost/thread.hpp> +-#include <tbb/mutex.h> ++#include <mutex> + #include <condition_variable> + + // Custom wxWidget events +@@ -111,9 +111,9 @@ class RemovableDriveManager (private) + // m_current_drives is guarded by m_drives_mutex + // sorted ascending by path + std::vector<DriveData> m_current_drives; +- mutable tbb::mutex m_drives_mutex; ++ mutable std::mutex m_drives_mutex; + // Locking the update() function to avoid that the function is executed multiple times. +- mutable tbb::mutex m_inside_update_mutex; ++ mutable std::mutex m_inside_update_mutex; + + // Returns drive path (same as path in DriveData) if exists otherwise empty string. + std::string get_removable_drive_from_path(const std::string& path); |