def _find_include_directories(self, include_directories):
env_dirs = self._env_include_directories()
if not self.find_includes:
return tools.unique(self._env_include_directories() + include_directories)
all_found = True
for include in self.find_includes:
all_found = any(
path.exists(dir_, include) for dir_ in env_dirs
)
tools.debug("Search '%s':" % include, all_found)
if not all_found: break
if all_found:
tools.debug("Include directories for", self.name, "found in env variables")
return env_dirs
tools.debug("Include directories for", self.name, "not found in env variables")
results = []
include_directories += env_dirs
for p in self.prefixes:
include_directories.append(path.join(p, 'include'))
if self.use_system_paths:
include_directories += self.include_system_paths()
tools.debug("Search include directories for library", self.name)
dirs = []
for directory_name in self.include_directory_names:
dirs.extend(path.join(dir_, directory_name) for dir_ in include_directories)
include_directories = tools.unique(dirs)
for include in self.find_includes:
dirname, basename = path.split(include)
name, ext = path.splitext(basename)
found = False
for dir_ in include_directories:
tools.debug("Searching '%s' in directory '%s'" % (include, dir_))
files = tools.find_files(
working_directory = path.join(dir_, dirname),
name = name,
extensions = [ext],
recursive = False,
)
if files:
found = True
tools.verbose("Found %s header '%s' in '%s'" % (self.name, include, dir_))
results.append(dir_)
break
if not found:
tools.fatal(
"Cannot find include file '%s' for library %s:" % (include, self.name),
"\t* Set 'include_directories' when creating the library",
"\t* Set the environment variable '%s_INCLUDE_DIRECTORY'" % self.name.upper(),
"\t* Set the environment variable '%s_INCLUDE_DIRECTORIES'" % self.name.upper(),
"\t* Set the environment variable '%s_PREFIX'" % self.name.upper(),
"\t* Set the environment variable '%s_PREFIXES'" % self.name.upper(),
"\t* Set the environment variable 'PREFIX'",
"\t* Set the environment variable 'PREFIXES'",
sep='\n'
)
return results
def __init__(self, compiler,
preferred_shared=True,
executable=None,
**kw):
include_dir = var('INCLUDEPY')
assert include_dir is not None
prefix = path.clean(var('prefix'))
assert prefix is not None
directories = []
if var('LIBPL'):
directories.append(path.clean(var('LIBPL')))
if var('base'):
directories.append(path.join(var('base'), 'libs'))
directories.append(path.join(var('base'), 'DLLs'))
self.version = (var('py_version')[0], var('py_version')[2])
name_suffixes = [''.join(self.version), '']
for k in ['LDVERSION', 'py_version_nodot', 'py_version_short']:
if var(k):
name_suffixes.append(var(k))
super().__init__(
"python",
compiler,
find_includes = ['Python.h'],
name_suffixes = name_suffixes,
prefixes = [prefix],
include_directories = var('INCLUDEPY') and [var('INCLUDEPY')] or [],
directories = directories,
preferred_shared = preferred_shared,
shared = kw.get('shared'),
)
components = []
if platform.IS_WINDOWS and not self.shared:
components = ['pyexpat', 'unicodedata']
self.components = list(
Library(
component,
compiler,
prefixes = [prefix],
include_directories = var('INCLUDEPY') and [var('INCLUDEPY')] or [],
directories = directories,
shared = self.shared,
) for component in components
)
self.ext = var('SO')[1:]
self.libraries = [self] + self.components
def include_system_paths(self):
res = [
'/usr/include',
]
if platform.IS_OSX and self.macosx_framework:
res.extend(
path.join(dir_, self.name + '.framework', 'include')
for dir_ in self.library_system_paths()
)
return res
def __init__(self, build, **kw):
if platform.IS_MACOSX:
kw.setdefault('stdlib', 'libc++')
kw.setdefault('standard', 'c++11')
super().__init__(build, **kw)
if platform.IS_OSX and self.stdlib == 'libc++':
prefix = path.join(path.dirname(path.absolute(self.binary, real = True)), '..', absolute = True)
self.libraries.extend([
self.find_library(
'libc++',
name_suffixes = ['', '.1'],
include_directories = [
path.join(prefix, 'lib/c++/v1'),
path.join(prefix, 'include/c++/v1'),
],
find_includes = ['__config', 'cxxabi.h'],
prefixes = [
prefix,
path.join(prefix, 'usr')
]
),
#self.find_library('libc++abi'),
])
def library_system_paths(self):
libs = []
if platform.IS_WINDOWS:
libs.extend([
{
'32bit': path.join(os.environ['WINDIR'], 'System32'),
'64bit': path.join(os.environ['WINDIR'], 'SysWOW64'),
}[self.compiler.target_architecture],
])
elif platform.IS_MACOSX:
if self.macosx_framework:
libs.extend([
"/System/Library/Frameworks",
"/Library/Frameworks",
])
elif platform.IS_LINUX:
libs.extend(
{
'32bit': ['/lib/i386-linux-gnu', '/usr/lib/i386-linux-gnu'],
'64bit': ['/lib/x86_64-linux-gnu', '/usr/lib/x86_64-linux-gnu'],
}[self.compiler.target_architecture]
)
libs.append('/usr/lib')
return libs
def __init__(self,
build,
compiler,
source_directory,
shared = True,
directx = False,
atomic = True,
audio = True,
cpuinfo = True,
dlopen = True,
events = True,
file = True,
filesystem = True,
haptic = True,
joystick = True,
loadso = True,
power = True,
render = True,
threads = True,
timers = True,
video = True,
dynamic_api = True):
if platform.IS_MACOSX and shared:
name = 'SDL2-2.0'
else:
name = 'SDL2'
if not dynamic_api:
with open(path.join(source_directory, 'src/dynapi/SDL_dynapi.h')) as f:
hdr = f.read()
if '#define SDL_DYNAMIC_API 1' in hdr:
with open(path.join(source_directory, 'src/dynapi/SDL_dynapi.h'), 'w') as f:
f.write(hdr.replace('#define SDL_DYNAMIC_API 1', '#define SDL_DYNAMIC_API 0'))
configure_variables = {
'DIRECTX': directx,
'SDL_SHARED': shared,
'SDL_STATIC': not shared,
'RPATH': True,
'SDL_AUDIO': audio,
'SDL_ATOMIC': atomic,
'SDL_CPUINFO': cpuinfo,
'SDL_DLOPEN': dlopen,
'SDL_EVENTS': events,
'SDL_FILE': file,
'SDL_FILESYSTEM': filesystem,
'SDL_HAPTIC': haptic,
'SDL_JOYSTICK': joystick,
'SDL_LOADSO': loadso,
'SDL_POWER': power,
'SDL_RENDER': render,
'SDL_THREADS': threads,
'SDL_TIMERS': timers,
'SDL_VIDEO': video,
}
if platform.IS_WINDOWS and not shared:
# XXX Bug in SDL CMake files
configure_variables['SDL_SHARED'] = True
super().__init__(
build,
'SDL',
compiler,
source_directory,
libraries = [
{
'name': name,
'prefix': compiler.name != 'msvc' and 'lib' or '',
'shared': shared,
'source_include_directories': ['include'],
'directory': compiler.name == 'msvc' and 'bin' or 'lib',
'imp_directory': 'lib',
}
],
configure_variables = configure_variables,
)
def _set_directories_and_files(self, directories):
dirs = self._env_directories()
files = self._env_files()
if dirs and files:
self.directories = dirs
self.files = files
tools.debug("Found %s library directories and files from environment" % self.name)
return
else:
self.directories = []
self.files = []
tools.debug("Searching %s library directories and files" % self.name)
dirs.extend(directories)
if self.macosx_framework:
dirs.extend(path.join(p, 'Library', 'Frameworks') for p in self.prefixes)
else:
dirs.extend(path.join(p, 'lib') for p in self.prefixes)
if self.use_system_paths:
dirs.extend(self.library_system_paths())
if self.macosx_framework:
dirs = (path.join(dir_, self.name + '.framework', 'lib') for dir_ in dirs)
dirs = list(path.clean(d) for d in tools.unique(dirs) if path.exists(d))
if self.binary_file_names is not None:
names = self.binary_file_names
else:
names = [self.name]
extensions_list = []
if self.macosx_framework:
extensions_list = [None]
if self.shared is not None:
extensions_list = [
(
self.shared,
self.compiler.library_extensions(
self.shared,
for_linker = True,
)
)
]
else:
extensions_list = [
(
self.preferred_shared,
self.compiler.library_extensions(self.preferred_shared, for_linker = True)
),
(
not self.preferred_shared,
self.compiler.library_extensions(not self.preferred_shared, for_linker = True)
),
]
for name in names:
files = []
for shared, extensions in extensions_list:
for dir_ in dirs:
files.extend(self._find_files(dir_, name, extensions))
if files and self.only_one_binary_file:
if self.shared is None:
self.shared = shared
files = files[:1]
tools.debug("Stopping search for %s library files." % name)
break
if files:
break # do not mix shared and non shared extensions
if not files:
tools.fatal(
"Cannot find %s library files:" % self.name,
"\t* Set 'directories' when creating the library",
"\t* Set the environment variable '%s_DIRECTORY'" % self.name.upper(),
"\t* Set the environment variable '%s_DIRECTORIES'" % self.name.upper(),
"\t* Set the environment variable '%s_PREFIX'" % self.name.upper(),
"\t* Set the environment variable '%s_PREFIXES'" % self.name.upper(),
"\t* Set the environment variable 'PREFIX'",
"\t* Set the environment variable 'PREFIXES'",
"NOTE: Directories checked: %s" % ', '.join(dirs),
sep='\n'
)
else:
self.files.extend(files)
self.directories.extend(path.dirname(f) for f in files)
def main(build):
build_type = build.env.get('BUILD_TYPE', 'DEBUG')
build.env.BUILD_TYPE = build_type
status("Configuring project", build.env.NAME, '(%s)' % build.env.VERSION_NAME,
'in', build.directory, '(%s)' % build_type)
from configure.lang import cxx
if build.env.BUILD_TYPE == 'DEBUG':
defines = [
'ETC_DEBUG',
'CUBE_DEBUG',
'CUBEAPP_DEBUG',
]
optimization = cxx.compiler.Compiler.dont_optimize
elif build.env.BUILD_TYPE == 'RELEASE':
defines = ['NDEBUG']
if platform.IS_WINDOWS:
defines.append(('_SCL_SECURE', '0'))
optimization = cxx.compiler.Compiler.optimize_fastest
else:
raise Exception("Unknown build type '%s'" % build_type)
defines += ['BOOST_ALL_NO_LIB', 'GLEW_NO_GLU', 'GLM_FORCE_RADIANS', ]
if platform.IS_WINDOWS:
defines.extend([
'NOMINMAX'
# ('_WIN32_WINNT', '0x0600'),
# ('WINVER', '0x0600'),
])
#if platform.IS_LINUX:
# defines += ['CUBE_WITH_GLX']
library_directories = [
#'/home/hotgloupi/sandbox/raspberry/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/arm-linux-gnueabihf/libc/lib',
#'/home/hotgloupi/sandbox/raspberry/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/arm-linux-gnueabihf/libc/lib/arm-linux-gnueabihf',
#'/home/hotgloupi/sandbox/raspberry/root/usr/lib',
#'/home/hotgloupi/sandbox/raspberry/root/usr/lib/arm-linux-gnueabihf',
]
include_directories = [
path.join(build.directory, 'src'),
# '/home/hotgloupi/sandbox/raspberry/root/usr/include',
# '/home/hotgloupi/sandbox/raspberry/root/usr/include/arm-linux-gnueabihf',
path.absolute(build.project.directory, 'src'),
path.absolute(build.project.directory, 'src/glew'),
]
compiler = cxx.find_compiler(
build,
position_independent_code = True,
standard = 'c++11',
defines = defines,
library_directories = library_directories,
include_directories = include_directories,
static_libstd = False,
hidden_visibility = (build_type != 'DEBUG'),
optimization = optimization,
#force_architecture = True,
#target_architecture = '32bit',
forbidden_warnings = ['return-type',]
# additional_link_flags = {
# 'gcc': ['-ldl', '-lpthread', '-lutil', '-lz', '-lX11', '-Xlinker', '-export-dynamic'],
# }
)
c_compiler = c.find_compiler(
build,
force_architecture = False,
optimization = optimization
)
status("Using %s as C++ compiler" % compiler)
status("Using %s as C compiler" % c_compiler)
freetype2 = build.add_dependency(
c.libraries.FreetypeDependency,
c_compiler,
'deps/freetype2'
)
zlib = build.add_dependency(
ZLibDependency,
c_compiler,
'deps/zlib-1.2.8'
)
bz2 = build.add_dependency(
BZ2Dependency,
c_compiler,
'deps/bzip2-1.0.6',
)
if not platform.IS_WINDOWS:
idn = build.add_dependency(
IDNDependency,
c_compiler,
'deps/libidn-1.28',
)
else:
idn = None
curl = build.add_dependency(
c.libraries.CURLDependency,
c_compiler,
"deps/curl-7.35.0",
shared = False, #platform.IS_WINDOWS,
with_ldap = False,
with_ldaps = False,
with_ftp = False,
with_tftp = False,
with_telnet = False,
with_dict = False,
with_file = False,
with_cookies = True,
idn = idn,
)
bullet_physics = build.add_dependency(
BulletPhysics,
compiler,
"deps/bullet-2.82-r2704",
shared = False, #platform.IS_WINDOWS,
)
librocket = build.add_dependency(
LibRocketDependency,
compiler,
"deps/libRocket",
c_compiler = c_compiler,
freetype2 = freetype2,
shared = False, #platform.IS_WINDOWS,
)
if platform.IS_WINDOWS:
python = c.libraries.PythonLibrary(c_compiler, shared = True)
else:
python = build.add_dependency(
c.libraries.PythonDependency,
c_compiler,
'deps/Python-v3.4.0',
shared = False,
version = (3, 4),
pymalloc = False,
with_valgrind_support = False,
threads = False,
)
boost = build.add_dependency(
cxx.libraries.BoostDependency,
compiler,
'deps/boost_1_57_0',
version = (1, 57),
python = python,
export_python = True,
components = [
'format',
'timer',
'system',
'filesystem',
'python',
'signals2',
'thread',
'coroutine',
'context',
],
#preferred_shared = False,
# python3_shared = True,
#thread_shared = True,
)
glm = build.add_dependency(GLM, compiler, "deps/glm")
# XXX needed ?
compiler.include_directories.extend(tools.unique(
sum((l.include_directories for l in boost.libraries), [])
))
assimp = build.add_dependency(
Assimp,
compiler,
'deps/assimp',
boost = boost,
c_compiler = c_compiler,
zlib = zlib,
shared = False, #platform.IS_WINDOWS
)
if platform.IS_OSX and platform.OSX_VERSION_MAJOR <= 10 and platform.OSX_VERSION_MINOR <= 6:
sdl = c.libraries.SDLLibrary(
c_compiler,
macosx_framework = True,
search_macosx_framework_files = True
)
else:
sdl = build.add_dependency(
c.libraries.SDLDependency,
c_compiler,
'deps/SDL',
shared = platform.IS_WINDOWS,
audio = False,
haptic = False, # Fails on windows
dynamic_api = False,
)
sdl_image = build.add_dependency(
c.libraries.SDLImageDependency, c_compiler, 'deps/SDL_image',
sdl = sdl,
shared = False
)
#sdl = c.libraries.SDLLibrary(
# compiler,
# components=['image'],
# shared=True
#)
opengl = c.libraries.OpenGLLibrary(
compiler,
system = True,
shared = compiler.name != 'msvc'
)
graphic_libraries = (
sdl.libraries +
sdl_image.libraries +
opengl.libraries +
#assimp.libraries +
freetype2.libraries +
glm.libraries +
bullet_physics.libraries +
librocket.libraries
)
#if not platform.IS_WINDOWS:
# list(c.libraries.simple(s, compiler) for s in ['png', 'jpeg'])
base_libraries = zlib.libraries + bz2.libraries
if platform.IS_WINDOWS:
base_libraries.extend(
c.libraries.simple(name, compiler, system = True) for name in [
'Shlwapi',
'ws2_32',
'Gdi32',
'mswsock',
'Dbghelp',
'winmm',
'version',
'imm32',
'Shell32',
'User32',
'Ole32',
'OleAut32',
'Advapi32',
'Kernel32',
'msvcrt',
'msvcprt',
#'libcmt'
]
)
else: # OSX and Linux
if platform.IS_LINUX:
base_libraries.extend(
c.libraries.simple(name, compiler, system = True) for name in [
'rt',
'util',
]
)
# SDL audio disabled
#base_libraries.extend(
# c.libraries.simple(name, compiler, system = True) for name in ['audio',]
#)
elif platform.IS_MACOSX:
base_libraries.extend(
c.libraries.simple(name, compiler, macosx_framework = True)
for name in [
'ForceFeedback', 'IOKit', 'Cocoa', 'Carbon', 'CoreVideo'
# 'AudioUnit', 'CoreAudio', 'AudioToolbox', # SDL Audio disabled
]
)
libglew = compiler.link_static_library(
'libglew',
['src/glew/glew.c'],
directory = 'release/lib',
libraries = opengl.libraries,
defines = ['GLEW_NO_GLU', 'GLEW_STATIC'],
)
graphic_libraries.insert(0, libglew)
precompiled_headers = []
with_pch = False
if with_pch:
precompiled_headers.append(
compiler.generate_precompiled_header(
"src/wrappers/stl.hpp",
force_include = True,
)
)
base_libraries.extend([
boost.component_library('filesystem'),
boost.component_library('system'),
boost.component_library('thread'),
boost.component_library('coroutine'),
boost.component_library('context'),
])
libetc = compiler.link_library(
'libetc',
rglob("src/etc/*.cpp"),
directory = 'release/lib',
libraries = base_libraries + curl.libraries,
defines = ['ETC_BUILD_DYNAMIC_LIBRARY', ('CURL_STATICLIB', 1)],
shared = True,
precompiled_headers = precompiled_headers,
)
libetc_static = compiler.link_library(
'libetc-static',
rglob("src/etc/*.cpp"),
directory = 'release/lib',
object_directory = 'etc-static',
libraries = base_libraries + curl.libraries,
defines = ['ETC_BUILD_STATIC_LIBRARY', ('CURL_STATICLIB', 1)],
shared = False,
position_independent_code = True,
static_libstd = not platform.IS_MACOSX,
precompiled_headers = precompiled_headers,
)
################### libcube
if with_pch:
precompiled_headers.extend([
compiler.generate_precompiled_header(
"src/wrappers/boost/signals2.hpp",
libraries = boost.libraries
),
])
libcube_libs = base_libraries + [libetc] + assimp.libraries + graphic_libraries
libcube = compiler.link_dynamic_library(
'libcube',
rglob("src/cube/*.cpp"),
directory = 'release/lib',
libraries = libcube_libs,
precompiled_headers = precompiled_headers,
defines = ['CUBE_BUILD_DYNAMIC_LIBRARY', 'ROCKET_STATIC_LIB'],
)
if with_pch:
precompiled_headers.extend([
compiler.generate_precompiled_header(
"src/wrappers/boost/python.hpp",
libraries = boost.libraries + python.libraries,
),
])
python_module_libraries = boost.libraries
if platform.IS_WINDOWS:
python_module_libraries.extend([libcube, libetc])
for binding in rglob("cube/*.py++", dir='src'):
t = compiler.link_dynamic_library(
path.splitext(path.basename(binding))[0],
[binding],
ext = python.ext,
directory = path.dirname("release/lib/python", binding[4:]),
libraries = python_module_libraries + base_libraries,
include_directories = glm.libraries[0].include_directories,
precompiled_headers = precompiled_headers,
allow_unresolved_symbols = True,
)
################### libcubeapp
libcubeapp = compiler.link_dynamic_library(
'libcubeapp',
(src for src in rglob("src/cubeapp/*.cpp") if not src.endswith('main.cpp')),
directory = 'release/lib',
libraries = [libetc, libcube] + boost.libraries + glm.libraries,
precompiled_headers = precompiled_headers,
defines = ['CUBEAPP_BUILD_DYNAMIC_LIBRARY'],
)
for binding in rglob("cubeapp/*.py++", dir='src'):
compiler.link_dynamic_library(
path.splitext(path.basename(binding))[0],
[binding],
ext = python.ext,
directory = path.dirname("release/lib/python", binding[4:]),
libraries=[libcubeapp, libcube, libetc] + graphic_libraries + boost.libraries + base_libraries,
precompiled_headers = precompiled_headers,
)
infinit_cube_libraries = [
libcubeapp,
libcube,
libetc,
] + graphic_libraries + boost.libraries + base_libraries
cube_exe = compiler.link_executable(
"8cube",
["src/cubeapp/main.cpp"],
directory = "release/bin",
libraries = infinit_cube_libraries,
export_libraries = [boost.component_library('python')],
)
if platform.IS_WINDOWS:
seen = set()
for lib in infinit_cube_libraries + assimp.libraries:
if not isinstance(lib, Target):
#print("lib %s" % lib.files, lib.shared, lib.system)
if lib.shared and not lib.system:
for f in lib.files:
if f not in seen:
seen.add(f)
build.fs.copy(f, dest_dir = 'release/bin')
else:
if lib.shared:
if lib.path not in seen:
seen.add(lib.path)
build.fs.copy(lib, dest_dir = 'release/bin')
exts = ['py', 'bmp', 'ttf', 'rml']
for ext in exts:
for src in rglob("cube/*.%s" % ext, dir = 'src'):
build.fs.copy(src, 'release/lib/python/' + src[4:])
for src in rglob("cubeapp/*.%s" % ext, dir = 'src'):
build.fs.copy(src, 'release/lib/python/' + src[4:])
import os
for ext in exts:
for src in rglob(path.join('share/games/default', '*.%s' % ext)):
build.fs.copy(src, "release/" + src[6:])
# Default game launcher
#
# By default, it will launch the default game (named "default"). The
# environment variable "GAME_ID" is used takes precedence over the default
# game
#
compiler.link_executable(
"launch",
list(rglob("*.cpp", dir = "src/launch")),
directory = 'release/bin',
defines = [('GAME_ID', "default"), 'ETC_STATIC_LIBRARY'],
static_libstd = not platform.IS_MACOSX and not platform.IS_WINDOWS,
libraries =
[libetc_static] +
base_libraries +
(
not platform.IS_WINDOWS and
[c.libraries.simple('pthread', compiler, system = True)] or
[]
) +
curl.libraries
)
tests = [
'simple_window', 'cube/gl/shader_generator',
]
def __init__(self,
build,
compiler,
source_directory,
boost = None,
shared = True,
c_compiler = None,
zlib = None):
super().__init__(
build,
"Assimp",
compiler = compiler,
source_directory = source_directory,
libraries = [
{
'prefix': compiler.name != 'msvc' and 'lib' or '',
'name': 'assimp',
'shared': shared,
}
],
configure_variables = [
('CMAKE_C_COMPILER', c_compiler.binary),
('Boost_DEBUG', True),
('Boost_DETAILED_FAILURE_MSG', True),
('Boost_NO_SYSTEM_PATHS', True),
('Boost_NO_CMAKE', True,),
('Boost_ADDITIONAL_VERSIONS', "%s.%s.0" % boost.version),
('ASSIMP_BUILD_ASSIMP_TOOLS', False),
('ASSIMP_BUILD_STATIC_LIB', not shared),
('ASSIMP_BUILD_SAMPLES', False),
('ASSIMP_BUILD_TESTS', False),
('ASSIMP_NO_EXPORT', True),
('ASSIMP_DEBUG_POSTFIX', ''),
],
configure_env = {
'BOOST_ROOT': boost.root_directory,
'BOOST_INCLUDEDIR': boost.include_directory,
'BOOST_LIBRARYDIR': boost.library_directory,
}
)
if zlib is not None:
self.libraries.extend(zlib.libraries)
elif not shared and platform.IS_WINDOWS:
dir = self.absolute_build_path('build/contrib/zlib')
if compiler.name == 'msvc':
dir = path.join(dir, self.build_type)
files = [path.join(dir, 'zlib.lib')]
else:
files = [path.join(dir, 'libzlib.a')]
self.libraries.append(
compiler.Library(
'libz',
self.compiler,
shared = False,
search_binary_files = False,
include_directories = [],
directories = [dir],
files = files,
save_env_vars = False,
)
)
