gettext: --no-location

[pmachines.git] / ya2 / build / models.py

from logging import info
from os import system, walk, makedirs
from os.path import exists, dirname, join, basename, splitext
from sys import executable
from functools import reduce
from multiprocessing import Pool
from hashlib import md5
from shutil import rmtree
from ya2.build.build import to_be_built


class ModelsBuilder():

    def __init__(self, blend_path, cores):
        self.__blend_path = blend_path
        self.__cores = cores
        self.__manifest = ModelsManifest()

    def build(self):
        self.__compute_files_to_build()
        return self.__run_build()

    def __compute_files_to_build(self):
        self.__blend_files = []
        for root, _, file_names in walk(self.__blend_path):
            b = [f for f in file_names if f.endswith('.blend')]
            if '/prototypes/' in root:
                b = []
            b = [join(root, f)
                 for f in b
                 if to_be_built(join(root, f), [join(root, f)])]
            self.__blend_files += b

    def __run_build(self):
        with Pool(self.__cores) as p:
            just_built = p.map(self.blend2bam, self.__blend_files)
            p.close()
            p.join()
        just_built = [assets for b in just_built for assets in b]
        self.__manifest.update(just_built)
        return just_built

    def blend2bam(self, file_path):
        built = []
        if to_be_built(self.gltf_name(file_path), [file_path]):
            self.__clean_gltf_dir(file_path)
            built += self.__blend2gltf(file_path)
            built += self.__gltf2bam(file_path)
        return built

    def __clean_gltf_dir(self, file_path):
        gltf_dir = dirname(file_path)
        gltf_dir = gltf_dir.replace('assets/models/blend/', 'assets/models/gltf/')
        rmtree(gltf_dir, ignore_errors=True)

    @staticmethod
    def gltf_name(file_path):
        gltf_name = file_path.replace('assets/models/blend/', 'assets/models/gltf/')
        return gltf_name.replace('.blend', '.gltf')

    def __blend2gltf(self, file_path):
        b2g = Blend2Gltf(file_path)
        return b2g.export()

    def __gltf2bam(self, file_path):
        g2b = Gltf2Bam(file_path)
        return g2b.export()


class ModelsManifest:

    def __init__(self):
        self.__lines = []
        self.__manifest = []
        self.__file_name = 'models_manifest.txt'

    def update(self, just_built):
        self.__just_built = just_built
        self.__load()
        self.__add_just_built()
        self.__discard_old_entries()
        self.__rewrite()

    def __load(self):
        if exists(self.__file_name):
            with open(self.__file_name) as f: self.__lines = f.readlines()
        for l in self.__lines:  # line's e.g. assets/path/to/gltf_or_png.ext 68ced1
            self.__process_line(l)

    def __process_line(self, l):
        line_splitted = l.split()
        hash_value = line_splitted[-1]
        file_name = ' '.join(line_splitted[:-1])
        if file_name not in self.__just_built:
            self.__manifest += [(file_name, hash_value)]

    def __add_just_built(self):
        for f in self.__just_built:
            self.__manifest += [(f, md5(open(f, 'rb').read()).hexdigest())]

    def __discard_old_entries(self):
        self.__manifest = self.__manifest[-2048:]

    def __rewrite(self):
        with open(self.__file_name, 'w') as f:
            f.write('\n'.join([' '.join(l) for l in self.__manifest]))


class Blend2Gltf:

    def __init__(self, file_path):
        self.__file_path = file_path

    def export(self):
        gltf_dir, file_name = dirname(self.__file_path), basename(self.__file_path)
        gltf_dir = gltf_dir.replace('assets/models/blend/', 'assets/models/gltf/')
        makedirs(gltf_dir, exist_ok=True)
        file_path = splitext(gltf_dir + '/' + file_name)[0]
        command = f'blender {self.__file_path} --background --python ya2/build/blend2gltf.py -- {file_path}.gltf'
        system(command)
        return [self.__file_path, ModelsBuilder.gltf_name(self.__file_path)]


class Gltf2Bam:

    def __init__(self, file_path):
        self.__gltf_name = (file_path[:-5] + 'gltf').replace('/blend/', '/gltf/', 1)
        self.__bam_name = (file_path[:-5] + 'bam').replace('/blend/', '/bam/', 1)

    def export(self):
        self.__build_dds_from_jpg_and_png()
        self.__rewrite_gltf()
        return self.__export_bam()

    def __build_dds_from_jpg_and_png(self):
        with open(self.__gltf_name) as f: self.__lines = f.readlines()
        self.__jpg_png_files = []
        for l in self.__lines:
            if ('.png' in l or '.jpg' in l) and '"uri"' in l:
                r = l[l.index('"uri"') + 7:].rstrip(',\n"')
                t = f'{dirname(self.__gltf_name)}/{r}'
                self.__jpg_png_files += [t.replace('/models/blend/', '/models/gltf/', 1)]
        self.__create_dds_files()

    def __create_dds_files(self):
        for d in self.__jpg_png_files:
            t = d.replace('/gltf/', '/bam/', 1)
            t = t.replace('.png', '.dds').replace('.jpg', '.dds')
            makedirs(dirname(t), exist_ok=True)
            info(f'convert {d} {t}')
            system(f'convert {d} {t}')

    def __rewrite_gltf(self):
        def r(lin):
            e = [('.png', '.dds'), ('.jpg', '.dds'),
                 ('/png', '/dds'), ('/jpg', '/dds')]
            return reduce(lambda s, p: s.replace(*p), e, lin)
        with open(self.__gltf_name, 'w') as f:
            f.write(''.join([r(line) for line in self.__lines]))

    def __export_bam(self):
        makedirs(dirname(self.__bam_name), exist_ok=True)
        if to_be_built(self.__bam_name, self.__jpg_png_files):
            venv_path = dirname(executable)
            gltf2bam_path = join(venv_path, 'gltf2bam')
            system(f'{gltf2bam_path} {self.__gltf_name} {self.__bam_name}')
        return [self.__bam_name] + self.__jpg_png_files