on aspect ratio changed

[pmachines.git] / pmachines / pmachines.py

import argparse
import simplepbr
import gltf
from sys import platform, argv
from logging import info
from os.path import exists
from os import makedirs
from panda3d.core import Filename, load_prc_file_data, AntialiasAttrib
from panda3d.bullet import BulletWorld, BulletDebugNode
from direct.showbase.ShowBase import ShowBase
from pmachines.scene import Scene
from pmachines.music import MusicMgr
from lib.dictfile import DctFile
from lib.lib.p3d.p3d import LibP3d


class Pmachines:

    def __init__(self):
        self._configure()
        self.base = ShowBase()
        info('platform: %s' % platform)
        info('exists main.py: %s' % exists('main.py'))
        args = self._parse_args()
        self._prepare_window(args)
        self.updating = args.update
        self.version = args.version
        if args.update:
            return
        MusicMgr(self._options['settings']['volume'])
        self._set_physics()
        self._scene = Scene(self.world)

    def _configure(self):
        load_prc_file_data('', 'window-title pmachines')
        load_prc_file_data('', 'framebuffer-multisample 1')
        load_prc_file_data('', 'multisamples 4')
        load_prc_file_data('', 'framebuffer-srgb true')

    def _parse_args(self):
        parser = argparse.ArgumentParser()
        parser.add_argument('--update', action='store_true')
        parser.add_argument('--version', action='store_true')
        parser.add_argument('--optfile')
        cmd_line = [arg for arg in iter(argv[1:]) if not arg.startswith('-psn_')]
        args = parser.parse_args(cmd_line)
        return args

    def _prepare_window(self, args):
        data_path = ''
        if (platform.startswith('win') or platform.startswith('linux')) and (
                not exists('main.py') or __file__.startswith('/app/bin/')):
            # it is the deployed version for windows
            data_path = str(Filename.get_user_appdata_directory()) + '/pmachines'
            home = '/home/flavio'  # we must force this for wine
            if data_path.startswith('/c/users/') and exists(home + '/.wine/'):
                data_path = home + '/.wine/drive_' + data_path[1:]
            info('creating dirs: %s' % data_path)
            makedirs(data_path, exist_ok=True)
        optfile = args.optfile if args.optfile else 'options.ini'
        info('data path: %s' % data_path)
        info('option file: %s' % optfile)
        info('fixed path: %s' % LibP3d.fixpath(data_path + '/' + optfile))
        default_opt = {
            'settings': {
                'volume': 1},
            'development': {
                'verbose_log': 0,
                'physics_debug': 0}}
        opt_path = LibP3d.fixpath(data_path + '/' + optfile) if data_path else optfile
        opt_exists = exists(opt_path)
        self._options = DctFile(
            LibP3d.fixpath(data_path + '/' + optfile) if data_path else optfile,
            default_opt)
        if not opt_exists:
            self._options.store()
        gltf.patch_loader(base.loader)
        pipeline = simplepbr.init(
            use_normal_maps=True,
            use_emission_maps=False,
            use_occlusion_maps=True,
            msaa_samples=4)
        render.setAntialias(AntialiasAttrib.MAuto)
        self.base.set_background_color(0, 0, 0, 1)
        self.base.disable_mouse()
        #self.base.accept('window-event', self._on_win_evt)
        self.base.accept('aspectRatioChanged', self._on_aspect_ratio_changed)

    def _set_physics(self):
        if self._options['development']['physics_debug']:
            debug_node = BulletDebugNode('Debug')
            debug_node.show_wireframe(True)
            debug_node.show_constraints(True)
            debug_node.show_bounding_boxes(True)
            debug_node.show_normals(True)
            debug_np = render.attach_new_node(debug_node)
            debug_np.show()
        self.world = BulletWorld()
        self.world.set_gravity((0, 0, -9.81))
        if self._options['development']['physics_debug']:
            self.world.set_debug_node(debug_np.node())
        def update(task):
            dt = globalClock.get_dt()
            self.world.do_physics(dt)
            return task.cont
        taskMgr.add(update, 'update')

    def _on_aspect_ratio_changed(self):
        self._scene.on_aspect_ratio_changed()