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, ) )