memartel/SQCSimulator2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Ajout version Release/x64 avec les libraries x64 et tuning de la version Debug

Browse Source
This commit is contained in:
MarcEricMartel
2021-12-10 07:16:43 -05:00
parent 9b56a9b4a5
commit f4ec4816af
2745 changed files with 292873 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

241
SQCSim2021/external/glew210/build/cmake/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,241 @@
if ( NOT DEFINED CMAKE_BUILD_TYPE )
set( CMAKE_BUILD_TYPE Release CACHE STRING "Build type" )
endif ()
project (glew)
cmake_minimum_required (VERSION 2.8.12)
include(GNUInstallDirs)
if (COMMAND cmake_policy)
cmake_policy (SET CMP0003 NEW)
cmake_policy (SET CMP0042 NEW)
endif()
set(CMAKE_DEBUG_POSTFIX d)
option (BUILD_UTILS "utilities" ON)
option (GLEW_REGAL "Regal mode" OFF)
option (GLEW_OSMESA "OSMesa mode" OFF)
if (APPLE)
option (BUILD_FRAMEWORK "Build Framework bundle for OSX" OFF)
endif ()
set (GLEW_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../..)
# get version from config/version
file (STRINGS ${GLEW_DIR}/config/version _VERSION_MAJOR_STRING REGEX "GLEW_MAJOR[ ]*=[ ]*[0-9]+.*")
string (REGEX REPLACE "GLEW_MAJOR[ ]*=[ ]*([0-9]+)" "\\1" CPACK_PACKAGE_VERSION_MAJOR ${_VERSION_MAJOR_STRING})
file (STRINGS ${GLEW_DIR}/config/version _VERSION_MINOR_STRING REGEX "GLEW_MINOR[ ]*=[ ]*[0-9]+.*")
string (REGEX REPLACE "GLEW_MINOR[ ]*=[ ]*([0-9]+)" "\\1" CPACK_PACKAGE_VERSION_MINOR ${_VERSION_MINOR_STRING})
file (STRINGS ${GLEW_DIR}/config/version _VERSION_PATCH_STRING REGEX "GLEW_MICRO[ ]*=[ ]*[0-9]+.*")
string (REGEX REPLACE "GLEW_MICRO[ ]*=[ ]*([0-9]+)" "\\1" CPACK_PACKAGE_VERSION_PATCH ${_VERSION_PATCH_STRING})
set (GLEW_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
find_package (OpenGL REQUIRED)
# X11 required when builing visualinfo and glewinfo,
# but not for Windows or Apple OSX platforms
if (BUILD_UTILS AND NOT WIN32 AND NOT APPLE)
find_package (X11)
endif()
if (WIN32)
set (GLEW_LIB_NAME glew32)
else ()
set (GLEW_LIB_NAME GLEW)
set (DLL_PREFIX lib)
endif ()
set (GLEW_LIBRARIES ${OPENGL_LIBRARIES})
add_definitions (-DGLEW_NO_GLU)
#### Regal mode ####
if (GLEW_REGAL)
if (WIN32)
set (REGAL_LIB_NAME regal32)
else ()
set (REGAL_LIB_NAME Regal)
endif ()
add_definitions (-DGLEW_REGAL)
set (GLEW_LIBRARIES ${REGAL_LIB_NAME})
endif ()
#### OSMesa mode ####
if (GLEW_OSMESA)
if (WIN32)
set (OSMESA_LIB_NAME osmesa)
else ()
set (OSMESA_LIB_NAME OSMesa)
endif ()
add_definitions (-DGLEW_OSMESA)
set (GLEW_LIBRARIES ${OSMESA_LIB_NAME} ${OPENGL_LIBRARIES})
set (X11_LIBRARIES)
endif ()
#### GLEW ####
include_directories (${GLEW_DIR}/include)
set (GLEW_PUBLIC_HEADERS_FILES ${GLEW_DIR}/include/GL/wglew.h ${GLEW_DIR}/include/GL/glew.h ${GLEW_DIR}/include/GL/glxew.h)
set (GLEW_SRC_FILES ${GLEW_DIR}/src/glew.c)
if (WIN32)
list (APPEND GLEW_SRC_FILES ${GLEW_DIR}/build/glew.rc)
endif ()
add_library (glew SHARED ${GLEW_PUBLIC_HEADERS_FILES} ${GLEW_SRC_FILES})
set_target_properties (glew PROPERTIES COMPILE_DEFINITIONS "GLEW_BUILD" OUTPUT_NAME "${GLEW_LIB_NAME}" PREFIX "${DLL_PREFIX}"
VERSION ${GLEW_VERSION}
SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR})
add_library (glew_s STATIC ${GLEW_PUBLIC_HEADERS_FILES} ${GLEW_SRC_FILES})
set_target_properties (glew_s PROPERTIES COMPILE_DEFINITIONS "GLEW_STATIC" OUTPUT_NAME "${GLEW_LIB_NAME}" PREFIX lib)
if (MSVC)
# add options from visual studio project
target_compile_definitions (glew PRIVATE "GLEW_BUILD;VC_EXTRALEAN")
target_compile_definitions (glew_s PRIVATE "GLEW_STATIC;VC_EXTRALEAN")
target_link_libraries (glew LINK_PRIVATE -BASE:0x62AA0000)
# kill security checks which are dependent on stdlib
target_compile_options (glew PRIVATE -GS-)
target_compile_options (glew_s PRIVATE -GS-)
# remove stdlib dependency
target_link_libraries (glew LINK_PRIVATE -nodefaultlib -noentry)
string(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
elseif (WIN32 AND ((CMAKE_C_COMPILER_ID MATCHES "GNU") OR (CMAKE_C_COMPILER_ID MATCHES "Clang")))
# remove stdlib dependency on windows with GCC and Clang (for similar reasons
# as to MSVC - to allow it to be used with any Windows compiler)
target_compile_options (glew PRIVATE -fno-builtin -fno-stack-protector)
target_compile_options (glew_s PRIVATE -fno-builtin -fno-stack-protector)
target_link_libraries (glew LINK_PRIVATE -nostdlib)
endif ()
if (BUILD_FRAMEWORK)
set_target_properties(glew PROPERTIES
FRAMEWORK TRUE
FRAMEWORK_VERSION ${GLEW_VERSION}
MACOSX_FRAMEWORK_IDENTIFIER net.sourceforge.glew
MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${GLEW_VERSION}
MACOSX_FRAMEWORK_BUNDLE_VERSION ${GLEW_VERSION}
XCODE_ATTRIBUTE_INSTALL_PATH "@rpath"
PUBLIC_HEADER "${GLEW_PUBLIC_HEADERS_FILES}"
OUTPUT_NAME GLEW
)
endif()
target_link_libraries (glew LINK_PUBLIC ${GLEW_LIBRARIES})
target_link_libraries (glew_s ${GLEW_LIBRARIES})
if(CMAKE_VERSION VERSION_LESS 2.8.12)
set(MAYBE_EXPORT "")
else()
target_compile_definitions(glew_s INTERFACE "GLEW_STATIC")
foreach(t glew glew_s)
target_include_directories(${t} PUBLIC $<INSTALL_INTERFACE:include>)
endforeach()
set(MAYBE_EXPORT EXPORT glew-targets)
endif()
set(targets_to_install "")
if(NOT DEFINED BUILD_SHARED_LIBS OR BUILD_SHARED_LIBS)
list(APPEND targets_to_install glew)
endif()
if(NOT DEFINED BUILD_SHARED_LIBS OR NOT BUILD_SHARED_LIBS)
list(APPEND targets_to_install glew_s)
endif()
install ( TARGETS ${targets_to_install}
${MAYBE_EXPORT}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
FRAMEWORK DESTINATION ${CMAKE_INSTALL_PREFIX}
)
if (BUILD_UTILS)
set (GLEWINFO_SRC_FILES ${GLEW_DIR}/src/glewinfo.c)
if (WIN32)
list (APPEND GLEWINFO_SRC_FILES ${GLEW_DIR}/build/glewinfo.rc)
endif ()
add_executable (glewinfo ${GLEWINFO_SRC_FILES})
target_link_libraries (glewinfo glew)
if (NOT WIN32)
target_link_libraries(glewinfo ${X11_LIBRARIES})
endif ()
set (VISUALINFO_SRC_FILES ${GLEW_DIR}/src/visualinfo.c)
if (WIN32)
list (APPEND VISUALINFO_SRC_FILES ${GLEW_DIR}/build/visualinfo.rc)
endif ()
add_executable (visualinfo ${VISUALINFO_SRC_FILES})
target_link_libraries (visualinfo glew)
if (NOT WIN32)
target_link_libraries(visualinfo ${X11_LIBRARIES})
endif ()
install ( TARGETS glewinfo visualinfo
DESTINATION ${CMAKE_INSTALL_BINDIR})
endif ()
set (prefix ${CMAKE_INSTALL_PREFIX})
set (exec_prefix ${CMAKE_INSTALL_PREFIX})
set (libdir ${CMAKE_INSTALL_FULL_LIBDIR})
set (includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
set (version ${GLEW_VERSION})
set (libname ${GLEW_LIB_NAME})
set (cflags)
set (requireslib glu)
# Mac OSX has no glu.pc unless optional X11/GLX is installed
if (APPLE)
set (requireslib)
endif ()
configure_file (${GLEW_DIR}/glew.pc.in ${GLEW_DIR}/glew.pc @ONLY)
install(FILES ${GLEW_DIR}/glew.pc
DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
)
if(WIN32 AND MSVC AND (NOT MSVC_VERSION LESS 1600) AND (NOT CMAKE_VERSION VERSION_LESS "3.1"))
install(
FILES $<TARGET_PDB_FILE:glew>
DESTINATION ${CMAKE_INSTALL_LIBDIR}
CONFIGURATIONS Debug RelWithDebInfo
)
endif()
install (FILES
${GLEW_DIR}/include/GL/wglew.h
${GLEW_DIR}/include/GL/glew.h
${GLEW_DIR}/include/GL/glxew.h
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GL)
if(MAYBE_EXPORT)
install(EXPORT glew-targets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/glew
NAMESPACE GLEW::)
install(FILES
${CMAKE_CURRENT_SOURCE_DIR}/glew-config.cmake
${CMAKE_CURRENT_SOURCE_DIR}/CopyImportedTargetProperties.cmake
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/glew)
endif()
if(NOT TARGET uninstall)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
IMMEDIATE @ONLY)
add_custom_target(uninstall
COMMAND ${CMAKE_COMMAND} -P
${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
endif()

88
SQCSim2021/external/glew210/build/cmake/CopyImportedTargetProperties.cmake vendored Normal file
View File

@@ -0,0 +1,88 @@
#.rst:
# CopyImportedTargetProperties
# --------------------------
#
# Copies the `INTERFACE*` and `IMPORTED*` properties from a target
# to another one.
# This function can be used to duplicate an `IMPORTED` or an `ALIAS` library
# with a different name since ``add_library(... ALIAS ...)`` does not work
# for those targets.
#
# ::
#
# copy_imported_target_properties(<source-target> <destination-target>)
#
# The function copies all the `INTERFACE*` and `IMPORTED*` target
# properties from `<source-target>` to `<destination-target>`.
#
# The function uses the `IMPORTED_CONFIGURATIONS` property to determine
# which configuration-dependent properties should be copied
# (`IMPORTED_LOCATION_<CONFIG>`, etc...)
#
# Example:
#
# Internally the CMake project of ZLIB builds the ``zlib`` and
# ``zlibstatic`` targets which can be exported in the ``ZLIB::`` namespace
# with the ``install(EXPORT ...)`` command.
#
# The config-module will then create the import libraries ``ZLIB::zlib`` and
# ``ZLIB::zlibstatic``. To use ``ZLIB::zlibstatic`` under the standard
# ``ZLIB::ZLIB`` name we need to create the ``ZLIB::ZLIB`` imported library
# and copy the appropriate properties:
#
# add_library(ZLIB::ZLIB STATIC IMPORTED)
# copy_imported_target_properties(ZLIB::zlibstatic ZLIB::ZLIB)
#
function(copy_imported_target_properties src_target dest_target)
set(config_dependent_props
IMPORTED_IMPLIB
IMPORTED_LINK_DEPENDENT_LIBRARIES
IMPORTED_LINK_INTERFACE_LANGUAGES
IMPORTED_LINK_INTERFACE_LIBRARIES
IMPORTED_LINK_INTERFACE_MULTIPLICITY
IMPORTED_LOCATION
IMPORTED_NO_SONAME
IMPORTED_SONAME
)
# copy configuration-independent properties
foreach(prop
${config_dependent_props}
IMPORTED_CONFIGURATIONS
INTERFACE_AUTOUIC_OPTIONS
INTERFACE_COMPILE_DEFINITIONS
INTERFACE_COMPILE_FEATURES
INTERFACE_COMPILE_OPTIONS
INTERFACE_INCLUDE_DIRECTORIES
INTERFACE_LINK_LIBRARIES
INTERFACE_POSITION_INDEPENDENT_CODE
INTERFACE_SOURCES
INTERFACE_SYSTEM_INCLUDE_DIRECTORIES
)
get_property(is_set TARGET ${src_target} PROPERTY ${prop} SET)
if(is_set)
get_target_property(v ${src_target} ${prop})
set_target_properties(${dest_target} PROPERTIES ${prop} "${v}")
# message(STATUS "set_target_properties(${dest_target} PROPERTIES ${prop} ${v})")
endif()
endforeach()
# copy configuration-dependent properties
get_target_property(imported_configs ${src_target}
IMPORTED_CONFIGURATIONS)
foreach(config ${imported_configs})
foreach(prop_prefix ${config_dependent_props})
set(prop ${prop_prefix}_${config})
get_property(is_set TARGET ${src_target} PROPERTY ${prop} SET)
if(is_set)
get_target_property(v ${src_target} ${prop})
set_target_properties(${dest_target}
PROPERTIES ${prop} "${v}")
# message(STATUS "set_target_properties(${dest_target} PROPERTIES ${prop} ${v})")
endif()
endforeach()
endforeach()
endfunction()

26
SQCSim2021/external/glew210/build/cmake/cmake_uninstall.cmake.in vendored Normal file
View File

@@ -0,0 +1,26 @@
if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
message(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
if (NOT DEFINED CMAKE_INSTALL_PREFIX)
set (CMAKE_INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@")
endif ()
message(${CMAKE_INSTALL_PREFIX})
file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
string(REGEX REPLACE "\n" ";" files "${files}")
foreach(file ${files})
message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
exec_program(
"@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
OUTPUT_VARIABLE rm_out
RETURN_VALUE rm_retval
)
if(NOT "${rm_retval}" STREQUAL 0)
message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
endif(NOT "${rm_retval}" STREQUAL 0)
else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
endforeach(file)

60
SQCSim2021/external/glew210/build/cmake/glew-config.cmake vendored Normal file
View File

@@ -0,0 +1,60 @@
# This config-module creates the following import libraries:
#
# - GLEW::glew shared lib
# - GLEW::glew_s static lib
#
# Additionally GLEW::GLEW will be created as an
# copy of either the shared (default) or the static libs.
#
# Dependending on the setting of BUILD_SHARED_LIBS at GLEW build time
# either the static or shared versions may not be available.
#
# Set GLEW_USE_STATIC_LIBS to OFF or ON to force using the shared
# or static lib for GLEW::GLEW
#
include(${CMAKE_CURRENT_LIST_DIR}/glew-targets.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CopyImportedTargetProperties.cmake)
# decide which import library (glew/glew_s)
# needs to be copied to GLEW::GLEW
set(_glew_target_postfix "")
set(_glew_target_type SHARED)
if(DEFINED GLEW_USE_STATIC_LIBS)
# if defined, use only static or shared
if(GLEW_USE_STATIC_LIBS)
set(_glew_target_postfix "_s")
endif()
# else use static only if no shared
elseif(NOT TARGET GLEW::glew AND TARGET GLEW::glew_s)
set(_glew_target_postfix "_s")
endif()
if(_glew_target_postfix STREQUAL "")
set(_glew_target_type SHARED)
else()
set(_glew_target_type STATIC)
endif()
# CMake doesn't allow creating ALIAS lib for an IMPORTED lib
# so create imported ones and copy the properties
foreach(_glew_target glew)
set(_glew_src_target "GLEW::${_glew_target}${_glew_target_postfix}")
string(TOUPPER "GLEW::${_glew_target}" _glew_dest_target)
if(TARGET ${_glew_dest_target})
get_target_property(_glew_previous_src_target ${_glew_dest_target}
_GLEW_SRC_TARGET)
if(NOT _glew_previous_src_target STREQUAL _glew_src_target)
message(FATAL_ERROR "find_package(GLEW) was called the second time with "
"different GLEW_USE_STATIC_LIBS setting. Previously, "
"`glew-config.cmake` created ${_glew_dest_target} as a copy of "
"${_glew_previous_src_target}. Now it attempted to copy it from "
"${_glew_src_target}. ")
endif()
else()
add_library(${_glew_dest_target} ${_glew_target_type} IMPORTED)
# message(STATUS "add_library(${_glew_dest_target} ${_glew_target_type} IMPORTED)")
copy_imported_target_properties(${_glew_src_target} ${_glew_dest_target})
set_target_properties(${_glew_dest_target} PROPERTIES
_GLEW_SRC_TARGET ${_glew_src_target})
endif()
endforeach()

25
SQCSim2021/external/glew210/build/cmake/testbuild/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,25 @@
cmake_minimum_required(VERSION 2.8.12)
project(glew-cmake-test)
find_package(GLEW REQUIRED CONFIG)
find_package(GLEW REQUIRED CONFIG) # call twice to test multiple call
find_package(OpenGL REQUIRED)
add_executable(cmake-test main.c)
set_target_properties(cmake-test PROPERTIES DEBUG_POSTFIX _d)
target_link_libraries(cmake-test PRIVATE GLEW::GLEW ${OPENGL_LIBRARIES})
target_include_directories(cmake-test PRIVATE ${OPENGL_INCLUDE_DIR})
if(CMAKE_VERSION VERSION_LESS 3.0)
set(cgex $<CONFIGURATION>)
else()
set(cgex $<CONFIG>)
endif()
target_compile_definitions(cmake-test PRIVATE
-DGLEW_CMAKE_TEST_CONFIG=${cgex}
-DGLEW_CMAKE_TEST_TARGET_FILE_NAME=$<TARGET_FILE_NAME:GLEW::GLEW>
-DGLEW_CMAKE_TEST_TARGET_TYPE=$<TARGET_PROPERTY:GLEW::GLEW,TYPE>
)
install(TARGETS cmake-test DESTINATION bin)

23
SQCSim2021/external/glew210/build/cmake/testbuild/main.c vendored Normal file
View File

@@ -0,0 +1,23 @@
#include <GL/glew.h>
#include <stdio.h>
#include <stdlib.h>
#define S(x) SS(x)
#define SS(x) #x
int main(int argc, char* argv[]) {
printf("GLEW CMake test, %s build\n",
S(GLEW_CMAKE_TEST_CONFIG));
printf("-- linked to %s which is %s\n",
S(GLEW_CMAKE_TEST_TARGET_FILE_NAME),
S(GLEW_CMAKE_TEST_TARGET_TYPE));
const GLubyte* v = glewGetString(GLEW_VERSION);
if(v) {
printf("-- glewGetString(GLEW_VERSION) returns %s\n-- test passed.\n", v);
return EXIT_SUCCESS;
} else {
printf("-- glewGetString(GLEW_VERSION) returns NULL\n-- test failed.\n");
return EXIT_FAILURE;
}
}