prefer_discrete_gpu

[pmachines.git] / setup.py

'''e.g. python setup.py bdist_apps --cores=1 --no-windows=1'''


from ya2.utils.log import LogManager
LogManager.before_init_setup('pmachines')
import sys, os
from sys import argv
from setuptools import setup
from subprocess import Popen
from setuptools import Command
from setuptools.command.develop import develop
from multiprocessing import cpu_count
from textwrap import dedent
from direct.dist.commands import bdist_apps
from p3d_appimage import AppImageBuilder
from ya2.build.build import _branch, find_file_names, _version, FindFileNamesInfo
from ya2.build.lang import LanguageBuilder
from ya2.build.screenshots import ScreenshotsBuilder
from ya2.build.images import ImagesBuilder
from ya2.build.models import ModelsBuilder
from pmachines.application.application import Pmachines


app_name = long_name = 'pmachines'


class SetupDevelopmentCommand(develop):

    def run(self):
        super().run(self)
        for argument in ['lang', 'models', 'images']:
            p = Popen([sys.executable, __file__, argument])
            p.communicate()


class BaseCommand(Command):

    user_options = [('cores=', None, '#cores')]
    cores = cpu_count()

    def initialize_options(self):
        BaseCommand.cores = cpu_count()
        for a in argv[:]: self.__process_argument(a)

    def __process_argument(self, argument):
        if argument.startswith('--cores='):
            BaseCommand.cores = int(argument.split('=')[1])

    def finalize_options(self): pass  # must override


class ModelsCommand(BaseCommand):

    def run(self):
        m = ModelsBuilder('assets/models', int(BaseCommand.cores))
        m.build()


class ImagesCommand(BaseCommand):

    def run(self):
        s = ScreenshotsBuilder(Pmachines.scenes())
        s.build()
        find_info = FindFileNamesInfo(
            ['jpg', 'png'],
            ['models', 'gltf', 'bam'],
            ['_png.png'])
        images = find_file_names(find_info)
        i = ImagesBuilder(images, int(BaseCommand.cores))
        i.build()


class L10nCommand(BaseCommand):

    def run(self):
        l = LanguageBuilder(
            app_name, 'assets/locale/po/', 'assets/scenes/', 'assets/locale/')
        l.build()


class BDistAppsCommand(bdist_apps):

    user_options = bdist_apps.user_options + [
        ('cores', None, '#cores'),
        ('nowindows=', None, "don't build for windows"),  # letters, numbers and hypens only
        ('nolinux=', None, "don't build for linux")]

    def initialize_options(self):
        super().initialize_options()
        self.nowindows, self.nolinux = None, None
        for a in argv[:]: self.__process_argument(a)

    def __process_argument(self, argument):
        if argument.startswith('--no-windows='):
            self.nowindows = int(argument.split('=')[1])
        if argument.startswith('--no-linux='):
            self.nolinux = int(argument.split('=')[1])

    def run(self):
        assets_creation_message = dedent('''NOTE: please be sure that you've already created the assets with:
            * python setup.py images models lang''')
        print(assets_creation_message)
        self.__patch_commands_py()
        super().run()
        self.__eventually_build_appimage()

    def __patch_commands_py(self):
        command = 'patch --forward ' + \
              '../venv/lib/python3.7/site-packages/direct/dist/commands.py' + \
              ' ya2/build/commands.patch'
        os.system(command)

    def __eventually_build_appimage(self):
        if not self.nolinux:
            a = AppImageBuilder(self)
            filename_branch = {'master': 'alpha', 'rc': 'rc', 'stable': ''}
            branch = filename_branch[_branch()]
            a.build(long_name, branch, 'https://www.ya2.it/downloads/')


def _build_setup_arguments():
    d = {
        'name': app_name,
        'version': _version(),
        'packages': ['pmachines', 'ya2', 'assets', 'licenses'],
        'cmdclass': {
            'develop': SetupDevelopmentCommand,
            'models': ModelsCommand,
            'images': ImagesCommand,
            'lang': L10nCommand,
            'bdist_apps': BDistAppsCommand},
        'install_requires': ['panda3d'],
        'options': {
            'build_apps': {
                'exclude_patterns': [
                    'build/*', 'built/*', 'setup.py', 'requirements.txt',
                    'venv/*', '.git*', '*.pyc', 'options.ini', '__pycache__',
                    'assets/models/gltf/*', 'assets/models/**/*.blend',
                    'assets/models/**/models/*.png',
                    'assets/models/**/models/*.jpg'],
                'log_filename_strftime': True,
                'log_filename': '$USER_APPDATA/pmachines/logs/%Y/%B/%d/%H_%M_%S.log',
                'plugins': ['pandagl', 'p3openal_audio', 'pandadx9'],
                'gui_apps': {app_name: 'main.py'},
                'package_data_dirs': {'simplepbr': [('simplepbr/shaders*', '', {})]},
                'icons': {
                    app_name: [
                        'assets/images/icon/icon256.png',
                        'assets/images/icon/icon128.png',
                        'assets/images/icon/icon48.png',
                        'assets/images/icon/icon32.png',
                        'assets/images/icon/icon16.png']},
                'include_patterns': [
                    '**/ya2/licenses/*',
                    '**/licenses/*',
                    '**/*.bam',
                    '**/*.dds',
                    '**/*.bin',
                    #'**/*.png',
                    #'**/*.jpg',
                    '**/*.ico',
                    '**/*.json',
                    '**/track_tr.py',
                    '**/*.txt',
                    '**/*.ttf',
                    '**/*.vert',
                    '**/*.frag',
                    '**/*.ogg',
                    '**/*.wav',
                    '**/*.mo'],
                'platforms': __platform_list(),
                'include_modules': {'*': ['encodings.hex_codec']},
                'prefer_discrete_gpu': True},
            'bdist_apps': {'installers': __installers_dictionary()}}}
    return d

def __platform_list():
    platforms = []
    if all('--no-windows' not in a for a in argv):
        platforms += ['win_amd64']
    if all('--no-linux' not in a for a in argv):
        platforms += ['manylinux2010_x86_64']
    return platforms

def __installers_dictionary():
    installers = {}
    if all('--no-windows' not in a for a in argv):
        installers['win_amd64'] = ['nsis']
    if all('--no-linux' not in a for a in argv):
        installers['manylinux2010_x86_64'] = []
    return installers

if __name__ == '__main__':
    setup(**_build_setup_arguments())