
#
# This is the CMakeLists.txt file for the GSE
#

# ========== Minimum cmake version required ==========
CMAKE_MINIMUM_REQUIRED(VERSION 3.13)

SET(CMAKE_CXX_STANDARD 11)

IF("${PATH_COMMON}" STREQUAL "")
  SET(PATH_COMMON "${CMAKE_CURRENT_SOURCE_DIR}/../CMake" CACHE PATH "CMake common files directory path")
ENDIF("${PATH_COMMON}" STREQUAL "")

IF(NOT EXISTS "${PATH_COMMON}/Common_settings.cmake")
  MESSAGE(FATAL_ERROR "Please set PATH_COMMON to the CMake-folder")
ENDIF(NOT EXISTS "${PATH_COMMON}/Common_settings.cmake")

SET(GSE_GFXWRAP "GL" CACHE STRING "use which GfxWrap?")
set_property(CACHE GSE_GFXWRAP PROPERTY STRINGS EGML GL)

SET(GSE_FNTWRAP "FREETYPE" CACHE STRING "use which FntWrap?")
set_property(CACHE GSE_FNTWRAP PROPERTY STRINGS FREETYPE EGML)

IF("${GSE_GFXWRAP}" STREQUAL "EGML")
    LIST(APPEND GSE_WRAPPER_DEFINITION "GFX_USE_EGML")
ELSEIF("${GSE_GFXWRAP}" STREQUAL "GL")
    LIST(APPEND GSE_WRAPPER_DEFINITION "GFX_USE_GL")
ENDIF("${GSE_GFXWRAP}" STREQUAL "EGML")

IF("${GSE_FNTWRAP}" STREQUAL "FREETYPE")
    LIST(APPEND GSE_WRAPPER_DEFINITION "FNT_USE_FREETYPE")
ELSEIF("${GSE_FNTWRAP}" STREQUAL "EGML")
    LIST(APPEND GSE_WRAPPER_DEFINITION "FNT_USE_EGML")
ENDIF("${GSE_FNTWRAP}" STREQUAL "FREETYPE")

IF(GUILIANI_USE_SDL2_PLATFORM)
    LIST(APPEND GSE_WRAPPER_DEFINITION "GFX_USE_SDL2")
ENDIF(GUILIANI_USE_SDL2_PLATFORM)

# ========== Setup configurations ==========
INCLUDE("${PATH_COMMON}/Common_settings.cmake")

# check if paths are set correctly 
INCLUDE("${PATH_COMMON}/CheckPaths.cmake")

# Configuration for SDK Installer
IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CPackConfiguration.cmake")
  # Only add SDK settings if cmake installer files exists
  SET(SDK_PACKAGE_GENERATOR CACHE BOOL "Generate Guiliani SDK Install Packages")
ELSE(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CPackConfiguration.cmake")
  MESSAGE(STATUS "GSE SDK Project.")
  SET(GSE_SDK_PROJECT 1) # Variable for activating SKD build
ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/CPackConfiguration.cmake")

#Activate OGL per default
SET(FORCE_ADD_OGL_PLATFORM 1)

#Activate RTTI
SET(FORCE_USE_RTTI 1)

# ========== Set project name and version number ==========
PROJECT(GSE VERSION "2.4.0")

# run for correct platform-architecture
INCLUDE("${PATH_COMMON}/CheckArchitecture.cmake")

# StreamRuntime root path to find the custom extension
SET(GSE_ROOT_PATH_STREAMRUNTIME "${PROJECT_SOURCE_DIR}/../StreamRuntime" CACHE PATH "StreamRuntime root path")
SET(GSE_ROOT_PATH_RESOURCECOMPILER "${PROJECT_SOURCE_DIR}/GUIResourceCompiler")

IF(NOT EXISTS "${GSE_ROOT_PATH_STREAMRUNTIME}/CMakeLists.txt")
  MESSAGE(FATAL_ERROR "Please set path to StreamRuntime")
ENDIF(NOT EXISTS "${GSE_ROOT_PATH_STREAMRUNTIME}/CMakeLists.txt")

IF(SDK_PACKAGE_GENERATOR OR GSE_SDK_PROJECT)
  SET(PATH_GSE "${PROJECT_SOURCE_DIR}" CACHE PATH
    "This path has to point to the GSE root directory. This path is set empty, so the variable GSE_PATH is used."
    FORCE
  )
ELSE(SDK_PACKAGE_GENERATOR OR GSE_SDK_PROJECT)
  SET(PATH_GSE "${PROJECT_SOURCE_DIR}" CACHE PATH "This path has to point to the GSE root directory.")
ENDIF(SDK_PACKAGE_GENERATOR OR GSE_SDK_PROJECT)

IF(NOT GSE_SDK_PROJECT) #Default case to build GSE
  # ========== GSElib Source files ==========
  # SOURCE_GROUP creates the "folder-structure" in VS
  FILE(GLOB GSELIB_MAIN_CPP "${PROJECT_SOURCE_DIR}/Source/*.cpp")
  FILE(GLOB GSELIB_ANIMATION_CPP "${PROJECT_SOURCE_DIR}/Source/Animation/*.cpp")
  FILE(GLOB GSELIB_ATTRIBUTE_CPP "${PROJECT_SOURCE_DIR}/Source/Attribute/*.cpp")
  FILE(GLOB GSELIB_BEHAVIOUR_CPP "${PROJECT_SOURCE_DIR}/Source/Behaviour/*.cpp")
  FILE(GLOB GSELIB_COMMAND_CPP "${PROJECT_SOURCE_DIR}/Source/Command/*.cpp")
  FILE(GLOB GSELIB_CONTROL_CPP "${PROJECT_SOURCE_DIR}/Source/Control/*.cpp")
  FILE(GLOB GSELIB_CUSTOMEXTENSION_CPP "${PROJECT_SOURCE_DIR}/Source/CustomExtension/*.cpp")
  FILE(GLOB GSELIB_DIALOG_CPP "${PROJECT_SOURCE_DIR}/Source/Dialog/*.cpp")
  FILE(GLOB GSELIB_IDMANAGER_CPP "${PROJECT_SOURCE_DIR}/Source/IDManager/*.cpp")
  FILE(GLOB GSELIB_IMPORT_CPP "${PROJECT_SOURCE_DIR}/Source/Import/*.cpp")
  FILE(GLOB GSELIB_EXPORT_CPP "${PROJECT_SOURCE_DIR}/Source/Export/*.cpp")
  FILE(GLOB GSELIB_STREAMING_CPP "${PROJECT_SOURCE_DIR}/Source/Streaming/*.cpp")
  FILE(GLOB GSELIB_UTILS_CPP "${PROJECT_SOURCE_DIR}/Source/Utils/*.cpp")
  FILE(GLOB GSELIB_CUSTOM_TEMPLATES "${PROJECT_SOURCE_DIR}/Resources/CustomTemplates/*.tpl")
  SOURCE_GROUP("Source Files" FILES ${GSELIB_MAIN_CPP})
  SOURCE_GROUP("Source Files\\Animation" FILES ${GSELIB_ANIMATION_CPP})
  SOURCE_GROUP("Source Files\\Attribute" FILES ${GSELIB_ATTRIBUTE_CPP})
  SOURCE_GROUP("Source Files\\Behaviour" FILES ${GSELIB_BEHAVIOUR_CPP})
  SOURCE_GROUP("Source Files\\Command" FILES ${GSELIB_COMMAND_CPP})
  SOURCE_GROUP("Source Files\\Control" FILES ${GSELIB_CONTROL_CPP})
  SOURCE_GROUP("Source Files\\CustomExtension" FILES ${GSELIB_CUSTOMEXTENSION_CPP})
  SOURCE_GROUP("Source Files\\Dialog" FILES ${GSELIB_DIALOG_CPP})
  SOURCE_GROUP("Source Files\\IDManager" FILES ${GSELIB_IDMANAGER_CPP})
  SOURCE_GROUP("Source Files\\Import" FILES ${GSELIB_IMPORT_CPP})
  SOURCE_GROUP("Source Files\\Export" FILES ${GSELIB_EXPORT_CPP})
  SOURCE_GROUP("Source Files\\Streaming" FILES ${GSELIB_STREAMING_CPP})
  SOURCE_GROUP("Source Files\\Utils" FILES ${GSELIB_UTILS_CPP})
  SOURCE_GROUP("Custom Templates" FILES ${GSELIB_CUSTOM_TEMPLATES})

  FILE(GLOB GSELIB_MAIN_H "${PROJECT_SOURCE_DIR}/Include/*.h")
  FILE(GLOB GSELIB_ANIMATION_H "${PROJECT_SOURCE_DIR}/Include/Animation/*.h")
  FILE(GLOB GSELIB_ATTRIBUTE_H "${PROJECT_SOURCE_DIR}/Include/Attribute/*.h")
  FILE(GLOB GSELIB_BEHAVIOUR_H "${PROJECT_SOURCE_DIR}/Include/Behaviour/*.h")
  FILE(GLOB GSELIB_COMMAND_H "${PROJECT_SOURCE_DIR}/Include/Command/*.h")
  FILE(GLOB GSELIB_CONTROL_H "${PROJECT_SOURCE_DIR}/Include/Control/*.h")
  FILE(GLOB GSELIB_CUSTOMEXTENSION_H "${PROJECT_SOURCE_DIR}/Include/CustomExtension/*.h")
  FILE(GLOB GSELIB_DIALOG_H "${PROJECT_SOURCE_DIR}/Include/Dialog/*.h")
  FILE(GLOB GSELIB_IDMANAGER_H "${PROJECT_SOURCE_DIR}/Include/IDManager/*.h")
  FILE(GLOB GSELIB_IMPORT_H "${PROJECT_SOURCE_DIR}/Include/Import/*.h")
  FILE(GLOB GSELIB_EXPORT_H "${PROJECT_SOURCE_DIR}/Include/Export/*.h")
  FILE(GLOB GSELIB_STREAMING_H "${PROJECT_SOURCE_DIR}/Include/Streaming/*.h")
  FILE(GLOB GSELIB_UTILS_H "${PROJECT_SOURCE_DIR}/Include/Utils/*.h")
  FILE(GLOB GSELIB_GUICONFIG_H "${PROJECT_SOURCE_DIR}/Include/GUIConfig/*.h")
  SOURCE_GROUP("Header Files" FILES ${GSELIB_MAIN_H})
  SOURCE_GROUP("Header Files\\Animation" FILES ${GSELIB_ANIMATION_H})
  SOURCE_GROUP("Header Files\\Attribute" FILES ${GSELIB_ATTRIBUTE_H})
  SOURCE_GROUP("Header Files\\Behaviour" FILES ${GSELIB_BEHAVIOUR_H})
  SOURCE_GROUP("Header Files\\Command" FILES ${GSELIB_COMMAND_H})
  SOURCE_GROUP("Header Files\\Control" FILES ${GSELIB_CONTROL_H})
  SOURCE_GROUP("Header Files\\CustomExtension" FILES ${GSELIB_CUSTOMEXTENSION_H})
  SOURCE_GROUP("Header Files\\Dialog" FILES ${GSELIB_DIALOG_H})
  SOURCE_GROUP("Header Files\\IDManager" FILES ${GSELIB_IDMANAGER_H})
  SOURCE_GROUP("Header Files\\Import" FILES ${GSELIB_IMPORT_H})
  SOURCE_GROUP("Header Files\\Export" FILES ${GSELIB_EXPORT_H})
  SOURCE_GROUP("Header Files\\Streaming" FILES ${GSELIB_STREAMING_H})
  SOURCE_GROUP("Header Files\\Utils" FILES ${GSELIB_UTILS_H})
  SOURCE_GROUP("Header Files\\GUIConfig" FILES ${GSELIB_GUICONFIG_H})
  
  FILE(GLOB GSELIB_LANGUAGE_FILES "${PROJECT_SOURCE_DIR}/Resources/LanguageFiles/*.lng")
  SOURCE_GROUP("Language Files" FILES ${GSELIB_LANGUAGE_FILES})

  # ========== Create complete list of files for GSElib ==========
  SET(GSELIB_SOURCES_LIST 
    ${GSELIB_MAIN_CPP}
    ${GSELIB_ANIMATION_CPP} 
    ${GSELIB_ATTRIBUTE_CPP} 
    ${GSELIB_BEHAVIOUR_CPP} 
    ${GSELIB_COMMAND_CPP}
    ${GSELIB_CONTROL_CPP}
    ${GSELIB_CUSTOMEXTENSION_CPP}
    ${GSELIB_DIALOG_CPP}
    ${GSELIB_IDMANAGER_CPP}
    ${GSELIB_IMPORT_CPP}
    ${GSELIB_EXPORT_CPP}
    ${GSELIB_STREAMING_CPP}
    ${GSELIB_UTILS_CPP}
    ${GSELIB_CUSTOM_TEMPLATES}
    ${GSELIB_MAIN_H}
    ${GSELIB_ANIMATION_H} 
    ${GSELIB_ATTRIBUTE_H} 
    ${GSELIB_BEHAVIOUR_H} 
    ${GSELIB_COMMAND_H}
    ${GSELIB_CONTROL_H}
    ${GSELIB_CUSTOMEXTENSION_H}
    ${GSELIB_DIALOG_H}
    ${GSELIB_IDMANAGER_H}
    ${GSELIB_IMPORT_H}
    ${GSELIB_EXPORT_H}
    ${GSELIB_STREAMING_H}
    ${GSELIB_UTILS_H}
    ${GSELIB_GUICONFIG_H}
    ${GSELIB_LANGUAGE_FILES}
  )
ENDIF(NOT GSE_SDK_PROJECT)

SET(GSE_GUICONFIG_CPP "${PATH_GUILIANI}/Share/GUIConfig.cpp") # GUIConfig.cpp from inside Guiliani

# ========== GSE Source files ==========
# SOURCE_GROUP creates the "folder-structure" in VS
SOURCE_GROUP("GUIConfig" FILES ${GSE_GUICONFIG_CPP})

FILE(GLOB GSE_COMMON_CUSTOM_SOURCE_H "${GSE_ROOT_PATH_STREAMRUNTIME}/Common/Include/CustomExtension/*.h")
FILE(GLOB GSE_CUSTOM_SOURCE_H "${GSE_ROOT_PATH_STREAMRUNTIME}/Include/CustomExtension/*.h")
SOURCE_GROUP("Header Files\\Custom Extension" FILES ${GSE_COMMON_CUSTOM_SOURCE_H} ${GSE_CUSTOM_SOURCE_H})

FILE(GLOB GSE_COMMON_CUSTOM_SOURCE_CPP "${GSE_ROOT_PATH_STREAMRUNTIME}/Common/Source/CustomExtension/*.cpp")
FILE(GLOB GSE_CUSTOM_SOURCE_CPP "${GSE_ROOT_PATH_STREAMRUNTIME}/Source/CustomExtension/*.cpp")
SOURCE_GROUP("Source Files\\Custom Extension" FILES ${GSE_COMMON_CUSTOM_SOURCE_CPP} ${GSE_CUSTOM_SOURCE_CPP})

FILE(GLOB GSE_PLATFORM_GENERAL_CPP "${PROJECT_SOURCE_DIR}/Source/Platform/general/*.cpp")
SOURCE_GROUP("Source Files\\Platform\\General" FILES ${GSE_PLATFORM_GENERAL_CPP})

# ========== Create complete list of files for GSE binary ==========
SET(GSE_SOURCES_LIST 
  ${GSE_GUICONFIG_CPP}
  ${GSE_COMMON_CUSTOM_SOURCE_CPP}
  ${GSE_COMMON_CUSTOM_SOURCE_H}
  ${GSE_CUSTOM_SOURCE_CPP}
  ${GSE_CUSTOM_SOURCE_H}
  ${GSE_PLATFORM_GENERAL_CPP}
)

SET(GSE_PROJECT 1) #this variable is used in StreamRuntime and ResourceCompiler to avoid adding Guiliani and eGaC project twice.

# ========== Build GSE binary ==========
ADD_EXECUTABLE(${PROJECT_NAME} ${ADD_EXECUTABLE_PARAMETERS} ${GSE_SOURCES_LIST})

TARGET_INCLUDE_DIRECTORIES(${PROJECT_NAME}
  PRIVATE "${PATH_GUILIANI}/Include/CustomExtension"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/GUIConfig"
  PRIVATE "${GSE_ROOT_PATH_STREAMRUNTIME}/Common/Include/CustomExtension"
  PRIVATE "${GSE_ROOT_PATH_STREAMRUNTIME}/Include/CustomExtension"
)

# ========== Add StreamRuntime ==========
ADD_SUBDIRECTORY("${GSE_ROOT_PATH_STREAMRUNTIME}" ./StreamRuntime)

IF(NOT GSE_SDK_PROJECT) #if no SDK we add to solution: GSElib, Guiliani, GUIResourceCompiler and link against these projects. 
  INCLUDE("${PATH_COMMON}/AddSources.cmake")

  # ========== Add GUIResourceCompiler ==========
  IF(EXISTS "${GSE_ROOT_PATH_RESOURCECOMPILER}/CMakeLists.txt")
      ADD_SUBDIRECTORY("${GSE_ROOT_PATH_RESOURCECOMPILER}" ./GUIResourceCompiler)
  ELSE(EXISTS "${GSE_ROOT_PATH_RESOURCECOMPILER}/CMakeLists.txt")
      MESSAGE(FATAL_ERROR "Cannot find ResourceCompiler")
  ENDIF(EXISTS "${GSE_ROOT_PATH_RESOURCECOMPILER}/CMakeLists.txt")
  
  # ========== Build GSE library ==========
  ADD_LIBRARY(GSElib STATIC ${GSELIB_SOURCES_LIST})

  # ========== Include correct platform file ==========
  INCLUDE("${PATH_COMMON}/Platform.cmake")

  TARGET_SOURCES(GSElib 
    PRIVATE ${PLATFORM_FILES_GSELIB}
  )

  # ========== Set application specific includes ==========
TARGET_INCLUDE_DIRECTORIES(GSElib
  PRIVATE "${PATH_EGAC}/comps/eC/code"
  PRIVATE "${PATH_EGAC}/comps/eDBG/code"
  PRIVATE "${PATH_EGAC}/comps/eFnt/code"
  PRIVATE "${PATH_EGAC}/comps/eImg/code"
  PRIVATE "${PATH_EGAC}/comps/eGML/code"
  PRIVATE "${PATH_EGAC}/comps/eMem/code"
  PRIVATE "${PATH_GUILIANI}/Include/Connection"
  PRIVATE "${PATH_GUILIANI}/Include/Core"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Animation"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Behaviour"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Command"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Control"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Exception"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Layouter"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Streaming"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Transition"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Utils"
  PRIVATE "${PATH_GUILIANI}/Include/Core/Video"
  PRIVATE "${PATH_GUILIANI}/Include/CustomExtension"
  PRIVATE "${PATH_GUILIANI}/Include/GUIConfig"
  PRIVATE "${PATH_GUILIANI}/Include/ImageDecoder"
  PRIVATE "${PATH_GUILIANI}/Include/Platform/general"
  PRIVATE "${GSE_ROOT_PATH_RESOURCECOMPILER}/Include"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Animation"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Attribute"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Behaviour"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Command"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Control"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/CustomExtension"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Dialog"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/GUIConfig"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/IDManager"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Import"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Export"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Streaming"
  PRIVATE "${PROJECT_SOURCE_DIR}/Include/Utils"
)
ELSE(NOT GSE_SDK_PROJECT)
  # ========== Include correct platform file ==========
  INCLUDE("${PATH_COMMON}/Platform.cmake")
ENDIF(NOT GSE_SDK_PROJECT)

# ========== Set include directories ==========
INCLUDE("${PATH_COMMON}/Include_directories.cmake")

# ========== Output some information ==========
INCLUDE("${PATH_COMMON}/Build_information.cmake")

TARGET_SOURCES(${PROJECT_NAME} 
  PRIVATE ${RESOURCE_FILE}
)

# ========== Add pre-built libraries ==========
INCLUDE("${PATH_COMMON}/AddLibs.cmake")

# ========== Link the executable to the needed libraries ==========
TARGET_LINK_LIBRARIES(${PROJECT_NAME}
  ${TOOLCHAIN_LIBS}
  GSElib
  GUIResourceCompilerLib
  Guiliani
  eGaC
  ${PLATFORM_LIBS}
)

# ========== StreamRuntime must be build prior to GSE ==========
ADD_DEPENDENCIES(${PROJECT_NAME} ${STREAMRUNTIME_APPNAME})

# ========== Set output directories ==========
SET(SIMULATOR_DIR "${PROJECT_SOURCE_DIR}/Simulator")

IF(MSVC_IDE)
  SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}")
ENDIF(MSVC_IDE)

SET(BINARY_DIR "${PROJECT_SOURCE_DIR}")
SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${BINARY_DIR})
SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${BINARY_DIR})
SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_NAME "GSE")

SET_TARGET_PROPERTIES(${STREAMRUNTIME_APPNAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${SIMULATOR_DIR})
SET_TARGET_PROPERTIES(${STREAMRUNTIME_APPNAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${SIMULATOR_DIR})
SET_TARGET_PROPERTIES(${STREAMRUNTIME_APPNAME} PROPERTIES RUNTIME_OUTPUT_NAME "${STREAMRUNTIME_APPNAME}")

SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES COMPILE_DEFINITIONS "${PREPROCESSOR_DEFINES};${GSE_WRAPPER_DEFINITION};PATH_GSE=\"${PATH_GSE}\"")

IF(NOT GSE_SDK_PROJECT) # Target GSElib doesn't exists in SDK build
  SET_TARGET_PROPERTIES(GSElib PROPERTIES COMPILE_DEFINITIONS "${PREPROCESSOR_DEFINES};${GSE_WRAPPER_DEFINITION};GSE_GSELIB")
ENDIF(NOT GSE_SDK_PROJECT)

IF(SDK_PACKAGE_GENERATOR)
  # documentation
  IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../Documentation/CPackPackages.cmake")
    INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/../Documentation/CPackPackages.cmake)
  ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../Documentation/CPackPackages.cmake")
  
  IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../CPackPackages.cmake")
    INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/../CPackPackages.cmake)
  ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../CPackPackages.cmake")
  
  # add common to package
  IF(EXISTS "${PATH_COMMON}/CPackPackages.cmake")
    INCLUDE (${PATH_COMMON}/CPackPackages.cmake)
  ENDIF(EXISTS "${PATH_COMMON}/CPackPackages.cmake")
  
  # add GUIResourceCompiler to package
  IF(EXISTS "${GSE_ROOT_PATH_RESOURCECOMPILER}/CPackPackages.cmake")
    INCLUDE (${GSE_ROOT_PATH_RESOURCECOMPILER}/CPackPackages.cmake)
  ENDIF(EXISTS "${GSE_ROOT_PATH_RESOURCECOMPILER}/CPackPackages.cmake")
  
  # add Libs to package
  IF(EXISTS "${PATH_LIBS}/CPackPackages.cmake")
    INCLUDE (${PATH_LIBS}/CPackPackages.cmake)
  ENDIF(EXISTS "${PATH_LIBS}/CPackPackages.cmake")
  
  # add own package-file
  INCLUDE(CPackPackages.cmake)
  INCLUDE(CPackConfiguration.cmake)
  IF(EXISTS "CPackAdditionalPackages.cmake")
    INCLUDE(CPackAdditionalPackages.cmake)
  ENDIF(EXISTS "CPackAdditionalPackages.cmake")
ENDIF(SDK_PACKAGE_GENERATOR)
