wscript

#!/usr/bin/env python
# encoding: utf-8
import sys
import subprocess
import os
import fnmatch
import glob
import copy
sys.path.insert(0, sys.path[0]+'/waf_tools')

VERSION = '1.0.0'
APPNAME = 'robot_dart'

srcdir = '.'
blddir = 'build'

from waflib.Build import BuildContext
from waflib import Logs
from waflib.Tools import waf_unit_test
import dart
import boost
import eigen
import corrade
import magnum
import magnum_integration
import magnum_plugins
import pybind

def options(opt):
    opt.load('compiler_cxx')
    opt.load('compiler_c')
    opt.load('waf_unit_test')
    opt.load('boost')
    opt.load('eigen')
    opt.load('dart')
    opt.load('corrade')
    opt.load('magnum')
    opt.load('magnum_integration')
    opt.load('magnum_plugins')
    opt.load('python')
    opt.load('pybind')

    opt.add_option('--shared', action='store_true', help='build shared library', dest='build_shared')
    opt.add_option('--tests', action='store_true', help='compile tests or not', dest='tests')
    opt.add_option('--python', action='store_true', help='compile python bindings', dest='pybind')
    opt.add_option('--no-robot_dart', action='store_true', help='only install the URDF library (utheque) / deactivate RobotDART', dest='utheque_only')
    opt.add_option('--no-pic', action='store_true', help='do not compile with position independent code', dest='no_pic')
    opt.add_option('--magnum', type='string', help='path to all magnum related deps installation path', dest='magnum')


def configure(conf):
    if not conf.options.utheque_only:
        try:
            Logs.pprint("GREEN", "=== Configuring RobotDART ===")
            configure_robot_dart(conf)
            Logs.pprint("GREEN", "=== RobotDART ready to build ===")
            conf.env['BUILD_ROBOT_DART'] = True
        except:
            conf.env['BUILD_ROBOT_DART'] = False

            conf.end_msg("ERROR", color="RED")
    else:
            conf.env['BUILD_ROBOT_DART'] = False

    if not conf.env['BUILD_ROBOT_DART']:
        Logs.pprint("RED", "=== RobotDART will NOT be compiled/installed ===")

    print("\n=== Summary: ===")
    if conf.env['BUILD_ROBOT_DART']:
        conf.msg("Build/install RobotDart", "yes")
    else:
        conf.msg("Build/install RobotDart", "no", color="YELLOW")
    conf.msg("Install Utheque (URDF library)", "yes")

def test_filesystem(bld, experimental = False):
    fl_node = bld.srcnode.make_node('fl.cpp')
    fl_node.parent.mkdir()
    lflags = []
    if experimental:
        fl_node.write('#include <experimental/filesystem>\nint main(void) { return 0;}\n', 'w')
        lflags = ['-lstdc++fs']
    else:
        fl_node.write('#include <filesystem>\nint main(void) { return 0;}\n', 'w')
    bld(features='cxx cxxprogram', source=[fl_node], linkflags=lflags, cxxflags=['-std=c++17'], target='fl')

def configure_robot_dart(conf):
    conf.get_env()['BUILD_GRAPHIC'] = False

    conf.load('compiler_cxx')
    conf.load('compiler_c')
    conf.load('waf_unit_test')
    conf.load('boost')
    conf.load('eigen')
    conf.load('dart')
    conf.load('avx')
    conf.load('corrade')
    conf.load('magnum')
    conf.load('magnum_integration')
    conf.load('magnum_plugins')
    if conf.options.pybind:
        conf.load('python')
        conf.load('pybind')

    # we need pthread for video saving
    conf.check(features='cxx cxxprogram', lib=['pthread'], uselib_store='PTHREAD')
    conf.check_eigen(required=True, min_version=(3,2,92))
    conf.check_dart(required=True)
    if conf.env['DART_REQUIRES_BOOST'] or conf.options.tests:
        conf.check_boost(lib='regex system filesystem unit_test_framework', min_version='1.58')
    conf.check_corrade(components='Utility PluginManager', required=False)
    conf.env['magnum_dep_libs'] = 'MeshTools Primitives Shaders SceneGraph GlfwApplication Text MagnumFont'
    if conf.env['DEST_OS'] == 'darwin':
        conf.env['magnum_dep_libs'] += ' WindowlessCglApplication'
    else:
        conf.env['magnum_dep_libs'] += ' WindowlessEglApplication'
    if len(conf.env.INCLUDES_Corrade):
        conf.check_magnum(components=conf.env['magnum_dep_libs'], required=False)
    if len(conf.env.INCLUDES_Magnum):
        conf.check_magnum_plugins(components='AssimpImporter StbTrueTypeFont', required=False)
        conf.check_magnum_integration(components='Dart Eigen', required=False)

    conf.env['py_flags'] = ''
    conf.env['BUILD_PYTHON'] = False
    if conf.options.pybind:
        conf.check_python_version((2, 7))
        conf.check_python_headers(features='pyext')
        conf.check_python_module('numpy')
        conf.check_python_module('dartpy')
        conf.check_pybind11(required=True)
        conf.env['BUILD_PYTHON'] = True
        if not conf.options.build_shared:
            conf.env['py_flags'] = ' -fPIC' # we need -fPIC for python if building static

    # We require Magnum DartIntegration, EigenIntegration, AssimpImporter, and StbTrueTypeFont
    if len(conf.env.INCLUDES_MagnumIntegration_Dart) > 0 and len(conf.env.INCLUDES_MagnumIntegration_Eigen) > 0 and len(conf.env.INCLUDES_MagnumPlugins_AssimpImporter) > 0 and len(conf.env.INCLUDES_MagnumPlugins_StbTrueTypeFont) > 0:
        conf.get_env()['BUILD_MAGNUM'] = True
        conf.env['magnum_libs'] = magnum.get_magnum_dependency_libs(conf, conf.env['magnum_dep_libs']) + magnum_integration.get_magnum_integration_dependency_libs(conf, 'Dart Eigen')

    try:
        avx_dart = conf.check_avx(lib='dart', required=['dart', 'dart-utils', 'dart-utils-urdf'])
    except:
        avx_dart = False

    native = ''
    native_icc = ''
    if avx_dart:
        conf.msg('-march=native (AVX support)', 'yes', color='GREEN')
        native = ' -march=native'
        native_icc = ' mtune=native'
    else:
        conf.msg('-march=native (AVX support)', 'no (optional)', color='YELLOW')

    conf.env['lib_type'] = 'cxxstlib'
    if conf.options.build_shared:
        conf.env['lib_type'] = 'cxxshlib'

    # We require C++17
    if conf.env.CXX_NAME in ["icc", "icpc"]:
        common_flags = "-Wall -std=c++17"
        opt_flags = " -O3 -xHost -unroll -g " + native_icc
    elif conf.env.CXX_NAME in ["clang"]:
        common_flags = "-Wall -std=c++17"
        # no-stack-check required for Catalina
        opt_flags = " -O3 -g -faligned-new -fno-stack-check -Wno-narrowing" + native
    else:
        gcc_version = int(conf.env['CC_VERSION'][0]+conf.env['CC_VERSION'][1])
        if gcc_version < 50:
            conf.fatal('We need C++17 features. Your compiler does not support them!')
        else:
            common_flags = "-Wall -std=c++17"
        opt_flags = " -O3 -g" + native
        if gcc_version >= 71:
            opt_flags = opt_flags + " -faligned-new"

    if (not conf.options.build_shared) and (not conf.options.no_pic):
        common_flags += ' -fPIC'

    has_filesystem = conf.check(build_fun=test_filesystem, msg='Checking support for <filesystem>', mandatory=False)
    has_experimental_filesystem = None
    if has_filesystem is None:
        has_experimental_filesystem = conf.check(build_fun=lambda c : test_filesystem(c, True), msg='Checking support for <experimental/filesystem>', mandatory=False)

    if has_filesystem is None and has_experimental_filesystem is None:
        conf.fatal('We need std::filesystem or std::experimental::filesystem')
    elif has_filesystem is None:
        conf.env.LIB_CPPFS = ['stdc++fs']
    all_flags = common_flags + conf.env['py_flags'] + opt_flags
    conf.env['CXXFLAGS'] = conf.env['CXXFLAGS'] + all_flags.split(' ')

    if conf.env.CXX_NAME in ["icc", "icpc"]:
        conf.env['PUBLIC_CXXFLAGS'] = native_icc.split(' ')
    elif conf.env.CXX_NAME in ["clang"]:
        conf.env['PUBLIC_CXXFLAGS'] = ("-faligned-new -fno-stack-check" + native).split(' ')
    else:
        conf.env['PUBLIC_CXXFLAGS'] = ("-faligned-new" + native).split(' ')
    # We require C++17
    conf.env['PUBLIC_CXXFLAGS'] += ['-std=c++17']

    # add strict flags for warnings
    corrade.corrade_enable_pedantic_flags(conf)

    # keep only one time each flag
    conf.env['CXXFLAGS'] = list(set(conf.env['CXXFLAGS']))
    print(conf.env['CXXFLAGS'])

def summary(bld):
    lst = getattr(bld, 'utest_results', [])
    total = 0
    tfail = 0
    if lst:
        total = len(lst)
        tfail = len([x for x in lst if x[1]])
    waf_unit_test.summary(bld)
    if tfail > 0:
        bld.fatal("Build failed, because some tests failed!")


def build(bld):
    if bld.env['BUILD_ROBOT_DART']:
        Logs.pprint("GREEN", "=== Building RobotDART ===")
        build_robot_dart(bld)
    build_utheque(bld)


#### install the URDF library (utheque)
def build_utheque(bld):
    prefix = bld.get_env()['PREFIX']

    ###### URDF
    bld.install_files("${PREFIX}/share/utheque/",
                    bld.path.ant_glob('utheque/**'),
                    cwd=bld.path.find_dir('utheque/'),
                    relative_trick=True)
    ###### HEADER
    bld.install_files("${PREFIX}/include/utheque/",
                    bld.path.ant_glob('src/utheque/**'),
                    cwd=bld.path.find_dir('src/utheque/'),
                    relative_trick=True)
    #### CMake
    cxx_flags = ''.join(x + ';' for x in bld.env['PUBLIC_CXXFLAGS'])
    cmake_deps = ''
    if 'LIB_CPPFS' in bld.env and len(bld.env.LIB_CPPFS) > 0:
        cmake_deps = '\nINTERFACE_LINK_LIBRARIES "stdc++fs"'
    with open('cmake/UthequeConfig.cmake.in') as f:
        newText=f.read() \
            .replace('@Utheque_INCLUDE_DIRS@', prefix + "/include") \
            .replace('@Utheque_CMAKE_MODULE_PATH@', prefix + "/lib/cmake/Utheque/") \
            .replace('@Utheque_PREFIX@', "UTHEQUE_PREFIX=\"" + prefix + "\"") \
            .replace('@Utheque_CXX_FLAGS@', cxx_flags) \
            .replace('@Utheque_DEPS@', cmake_deps)

    with open(blddir + '/UthequeConfig.cmake', "w") as f:
        f.write(newText)
    with open('cmake/UthequeConfigVersion.cmake.in') as f:
        newText = f.read().replace('@utheque_VERSION@', str(VERSION))
    with open(blddir + '/UthequeConfigVersion.cmake', "w") as f:
        f.write(newText)

    bld.install_files('${PREFIX}/lib/cmake/Utheque/', blddir + '/UthequeConfig.cmake')
    bld.install_files('${PREFIX}/lib/cmake/Utheque/', blddir + '/UthequeConfigVersion.cmake')


def build_robot_dart(bld):
    prefix = bld.get_env()['PREFIX']

    if len(bld.env.INCLUDES_DART) == 0 or len(bld.env.INCLUDES_EIGEN) == 0 or (bld.env['DART_REQUIRES_BOOST'] and len(bld.env.INCLUDES_BOOST) == 0):
        bld.fatal('Some libraries were not found! Cannot proceed!')

    if bld.options.tests:
        bld.recurse('src/tests')

    #### compilation of RobotDARTSimu
    path = bld.path.abspath() + '/res'
    files = []
    magnum_files = []
    for root, dirnames, filenames in os.walk(bld.path.abspath()+'/src/robot_dart/'):
        for filename in fnmatch.filter(filenames, '*.cpp'):
            ffile = os.path.join(root, filename)
            if 'robot_dart/gui/magnum' in ffile:
                magnum_files.append(ffile)
            else:
                files.append(ffile)
    # External (TinyProcessLib)
    for root, dirnames, filenames in os.walk(bld.path.abspath()+'/src/external/'):
        for filename in fnmatch.filter(filenames, '*.cpp'):
            ffile = os.path.join(root, filename)
            magnum_files.append(ffile)

    files = [f[len(bld.path.abspath())+1:] for f in files]
    robot_dart_srcs = " ".join(files)
    magnum_files = [f[len(bld.path.abspath())+1:] for f in magnum_files]
    robot_dart_magnum_srcs = " ".join(magnum_files)

    libs = 'BOOST EIGEN DART PTHREAD CPPFS'
    defines = ["ROBOT_DART_PREFIX=\"" + bld.env['PREFIX'] + "\""]
    defines += ["UTHEQUE_PREFIX=\"" + bld.env['PREFIX'] + "\""]

    bld.program(features = 'cxx ' + bld.env['lib_type'],
                source = robot_dart_srcs,
                includes = './src',
                uselib = libs,
                defines = defines,
                target = 'RobotDARTSimu')

    build_graphic = False

    #### compilation of RobotDARTMagnum
    if bld.get_env()['BUILD_MAGNUM'] == True:
        shaders_resource = corrade.corrade_add_resource(bld, name = 'RobotDARTShaders', config_file = 'src/robot_dart/gui/magnum/resources/resources.conf')

        bld.program(features = 'cxx ' + bld.env['lib_type'],
                    source = robot_dart_magnum_srcs + ' ' + shaders_resource,
                    includes = './src',
                    uselib = bld.env['magnum_libs'] + libs,
                    use = 'RobotDARTSimu',
                    defines = defines,
                    target = 'RobotDARTMagnum')

        build_graphic = True

    #### compilation of the Python3 bindings
    if bld.env['BUILD_PYTHON'] == True:
        graphic_libs = ''
        graphic_lib = ''
        if bld.get_env()['BUILD_MAGNUM'] == True:
            graphic_libs = bld.env['magnum_libs']
            graphic_lib = 'RobotDARTMagnum'
            defines = ['GRAPHIC']

        # fix for native flags from pyext
        native_flags = ['-march=x86-64', '-mtune=generic']
        for flag in native_flags:
            if flag in bld.env['CXXFLAGS_PYEXT']:
                bld.env['CXXFLAGS_PYEXT'].remove(flag)
        for flag in bld.env['CXXFLAGS']:
            if flag in bld.env['CXXFLAGS_PYEXT']:
                bld.env['CXXFLAGS_PYEXT'].remove(flag)

        py_files = []
        for root, dirnames, filenames in os.walk(bld.path.abspath()+'/src/python/'):
            for filename in fnmatch.filter(filenames, '*.cpp'):
                ffile = os.path.join(root, filename)
                py_files.append(ffile)

        py_files = [f[len(bld.path.abspath())+1:] for f in py_files]
        py_srcs = " ".join(py_files)

        # Read suffix to be sure! Do not rely on waf!
        if len(bld.env['PYTHON_CONFIG']) > 0 and len(bld.env['PYTHON_CONFIG'][0]) > 0:
            py_suffix = bld.cmd_and_log('%s --extension-suffix' % bld.env['PYTHON_CONFIG'][0], quiet=True)[:-1] # ignore end of line!
            bld.env['pyext_PATTERN'] = "%s" + py_suffix
        bld.program(features = 'c cshlib pyext',
                    source = './src/python/robot_dart.cc ' + py_srcs,
                    includes = './src',
                    uselib = graphic_libs + ' PYBIND11 ' + libs,
                    use = 'RobotDARTSimu ' + graphic_lib,
                    defines = defines,
                    target = 'RobotDART')

    bld.add_post_fun(summary)

    ##### Create the config file and install it
    config_file = blddir + '/config.hpp'
    with open(config_file, 'w') as f:
        version = VERSION.split('.')
        f.write('#define ROBOT_DART_VERSION_MAJOR ' + version[0] + '\n')
        f.write('#define ROBOT_DART_VERSION_MINOR ' + version[1] + '\n')
        f.write('#define ROBOT_DART_VERSION_PATCH ' + version[2] + '\n')
        f.write('#define ROBOT_DART_ROBOTS_DIR \"' + prefix + '/share/utheque/\"\n')
    bld.install_files("${PREFIX}/include/robot_dart/", config_file)

    #### installation (waf install)
    install_files = []
    for root, dirnames, filenames in os.walk(bld.path.abspath()+'/src/robot_dart/'):
        for filename in fnmatch.filter(filenames, '*.hpp'):
            ffile = os.path.join(root, filename)
            if build_graphic == False and 'robot_dart/gui/magnum' in ffile:
                continue
            if filename in ["stb_image_write.h", "create_compatibility_shader.hpp"]:
                continue
            install_files.append(os.path.join(root, filename))
    install_files = [f[len(bld.path.abspath())+1:] for f in install_files]

    for f in install_files:
        end_index = f.rfind('/')
        if end_index == -1:
            end_index = len(f)
        bld.install_files('${PREFIX}/include/' + f[4:end_index], f)
    if bld.env['lib_type'] == 'cxxstlib':
        bld.install_files('${PREFIX}/lib', blddir + '/libRobotDARTSimu.a')
        if bld.get_env()['BUILD_MAGNUM'] == True:
            bld.install_files('${PREFIX}/lib', blddir + '/libRobotDARTMagnum.a')
    else:
        # OSX/Mac uses .dylib and GNU/Linux .so
        suffix = 'dylib' if bld.env['DEST_OS'] == 'darwin' else 'so'
        bld.install_files('${PREFIX}/lib', blddir + '/libRobotDARTSimu.' + suffix)
        if bld.get_env()['BUILD_MAGNUM'] == True:
            bld.install_files('${PREFIX}/lib', blddir + '/libRobotDARTMagnum.' + suffix)

    #### installation of the cmake config (waf install)
    cmake_deps = ''
    if 'LIB_CPPFS' in bld.env and len(bld.env.LIB_CPPFS) > 0:
        cmake_deps = ';stdc++fs'
    # CMAKE config
    with open('cmake/RobotDARTConfig.cmake.in') as f:
        magnum_dep_libs = bld.get_env()['magnum_dep_libs']
        if build_graphic == True:
            defines_magnum = ''.join((x + ';').replace('"', '\\"') for x in bld.get_env()['DEFINES_Magnum'])
            magnum_libs = ''.join(x + ';' for x in bld.env['magnum_libs'].split(' '))
            magnum_libs = magnum_libs.replace('_', '::')[:-2]
        else:
            defines_magnum = ''
            magnum_libs = ''

        dart_extra_libs = ''
        if 'dart-collision-bullet' in bld.env.LIB_DART:
            dart_extra_libs += ' collision-bullet '
        if 'dart-collision-ode' in bld.env.LIB_DART:
            dart_extra_libs += ' collision-ode '

        cxx_flags = ''.join(x + ';' for x in bld.env['PUBLIC_CXXFLAGS'])

        lib_type = '.a'
        if bld.env['lib_type'] == 'cxxshlib':
            lib_type = '.so'
        newText=f.read() \
            .replace('@RobotDART_INCLUDE_DIRS@', prefix + "/include") \
            .replace('@RobotDART_LIBRARY_DIRS@', prefix + "/lib") \
            .replace('@DART_EXTRA_LIBS@', dart_extra_libs) \
            .replace('@RobotDART_CXX_FLAGS@', cxx_flags) \
            .replace('@RobotDART_LIB_TYPE@', lib_type) \
            .replace('@RobotDART_MAGNUM_DEP_LIBS@', magnum_dep_libs) \
            .replace('@RobotDART_MAGNUM_DEFINITIONS@', defines_magnum) \
            .replace('@RobotDART_MAGNUM_LIBS@', magnum_libs) \
            .replace('@RobotDART_CMAKE_MODULE_PATH@', prefix + "/lib/cmake/RobotDART/") \
            .replace('@RobotDART_EXTRA_LIBS@', cmake_deps)
    with open(blddir + '/RobotDARTConfig.cmake', "w") as f:
        f.write(newText)
    # CMAKE configVersion
    with open('cmake/RobotDARTConfigVersion.cmake.in') as f:
        newText = f.read().replace('@robot_dart_VERSION@', str(VERSION))
    with open(blddir + '/RobotDARTConfigVersion.cmake', "w") as f:
        f.write(newText)

    bld.install_files('${PREFIX}/lib/cmake/RobotDART/', blddir + '/RobotDARTConfig.cmake')
    bld.install_files('${PREFIX}/lib/cmake/RobotDART/', blddir + '/RobotDARTConfigVersion.cmake')
    bld.install_files('${PREFIX}/lib/cmake/RobotDART/', 'cmake/FindGLFW.cmake')
    bld.install_files('${PREFIX}/lib/cmake/RobotDART/', 'cmake/FindEGL.cmake')

def build_examples(bld):
    # we first build the library
    build(bld)
    print("Bulding examples...")
    libs = 'BOOST EIGEN DART PTHREAD CPPFS'
    path = bld.path.abspath() + '/res'

    # these examples should not be compiled without magnum
    magnum_only = ['magnum_contexts.cpp', 'cameras.cpp', 'transparent.cpp', 'graphics_tutorial.cpp', 'sensors_tutorial.cpp']
    # these examples should be compiled only without grpahics
    simu_only = ['scheduler.cpp', 'robot_pool.cpp']
    # these examples have their own rules
    exclude = []

    # generic builder
    for root, dirnames, filenames in os.walk(bld.path.abspath() + '/src/examples/'):
        for filename in fnmatch.filter(filenames, '*.cpp'):
            ffile = os.path.join(root, filename)
            if 'old' in ffile:
                continue
            basename = filename.replace('.cpp', '')
            # plain version
            if (filename not in exclude) and (filename not in magnum_only):
                bld.program(features = 'cxx',
                    install_path = None,
                    source = '/src/examples/' + filename,
                    includes = './src',
                    uselib = libs,
                    defines = [],
                    use = 'RobotDARTSimu',
                    target = basename + '_plain')
            # graphics version
            if (filename not in exclude) and (filename not in simu_only) and bld.get_env()['BUILD_MAGNUM'] == True:
                bld.program(features = 'cxx',
                            install_path = None,
                            source = '/src/examples/' + filename,
                            includes = './src',
                            uselib = bld.env['magnum_libs'] + libs,
                            use = 'RobotDARTSimu RobotDARTMagnum',
                            defines = ['GRAPHIC'],
                            target = basename)

def build_docs(bld):
    import macros
    variables = macros.grab()
    f = open(bld.path.abspath() + '/src/docs/include/macros.py', 'w')
    vv = str(variables)
    f.write('\ndef define_env(env):\n')
    f.write('    variables = ' + vv.replace('\n', '\\n') + '\n')
    f.write('    for v in variables.items():\n')
    f.write('        env.variables[v[0]] = variables[v[0]]\n')
    f.close()
    Logs.pprint('NORMAL', "Generating HTML docs...")
    s = 'cd ' + bld.path.abspath() + '/src/docs && mkdocs build'
    retcode = subprocess.call(s, shell=True, env=None)

class BuildExamples(BuildContext):
    cmd = 'examples'
    fun = 'build_examples'

class BuildUtheque(BuildContext):
    cmd = 'utheque'
    fun = 'build_utheque'