pmachines/app.py

   1 import argparse
   2 import simplepbr
   3 #import gltf
   4 from glob import glob
   5 from importlib import import_module
   6 from inspect import isclass
   7 from sys import platform, argv, exit
   8 from logging import info, debug
   9 from os.path import exists
  10 from os import makedirs
  11 from panda3d.core import Filename, load_prc_file_data, AntialiasAttrib, \
  12     Texture, WindowProperties, LVector2i, TextNode
  13 from panda3d.bullet import BulletWorld, BulletDebugNode
  14 from direct.showbase.ShowBase import ShowBase
  15 from direct.gui.OnscreenText import OnscreenText
  16 from direct.fsm.FSM import FSM
  17 from pmachines.audio.music import MusicMgr
  18 from pmachines.items.background import Background
  19 from pmachines.gui.menu import Menu
  20 from pmachines.scene import Scene
  21 from pmachines.scenes.scene_basketball import SceneBasketBall
  22 from pmachines.scenes.scene_box import SceneBox
  23 from pmachines.scenes.scene_domino_box_basketball import SceneDominoBoxBasketball
  24 from pmachines.scenes.scene_domino_box import SceneDominoBox
  25 from pmachines.scenes.scene_domino import SceneDomino
  26 from pmachines.scenes.scene_teeter_domino_box_basketball import SceneTeeterDominoBoxBasketball
  27 from pmachines.scenes.scene_teeter_tooter import SceneTeeterTooter
  28 from pmachines.posmgr import PositionMgr
  29 from ya2.utils.dictfile import DctFile
  30 from ya2.p3d.p3d import LibP3d
  31 from ya2.utils.lang import LangMgr
  32 from ya2.utils.log import LogMgr
  33 from ya2.utils.functional import FunctionalTest
  34 from ya2.p3d.asserts import assert_threads, assert_tasks, assert_render3d, \
  35     assert_render2d, assert_aspect2d, assert_events, assert_buffers
  36
  37
  38 class MainFsm(FSM):
  39
  40     def __init__(self, pmachines):
  41         super().__init__('Main FSM')
  42         self._pmachines = pmachines
  43
  44     def enterMenu(self):
  45         self._pmachines.on_menu_enter()
  46
  47     def exitMenu(self):
  48         self._pmachines.on_menu_exit()
  49         self.__do_asserts()
  50
  51     def enterScene(self, cls):
  52         self._pmachines.on_scene_enter(cls)
  53
  54     def exitScene(self):
  55         self._pmachines.on_scene_exit()
  56         self.__do_asserts()
  57
  58     def __do_asserts(self):
  59         args = self._pmachines._args
  60         if args.functional_test or args.functional_ref:
  61             assert_threads()
  62             assert_tasks()
  63             assert_render3d()
  64             assert_render2d()
  65             assert_aspect2d()
  66             assert_events()
  67             assert_buffers()
  68
  69
  70 class PmachinesApp:
  71
  72     scenes = [
  73         SceneDomino,
  74         SceneBox,
  75         SceneDominoBox,
  76         SceneBasketBall,
  77         SceneDominoBoxBasketball,
  78         SceneTeeterTooter,
  79         SceneTeeterDominoBoxBasketball]
  80
  81     def __init__(self):
  82         info('platform: %s' % platform)
  83         info('exists main.py: %s' % exists('main.py'))
  84         self._args = args = self._parse_args()
  85         self._configure(args)
  86         self.base = ShowBase()
  87         self._pipeline = None
  88         self.updating = args.update
  89         self.version = args.version
  90         self.log_mgr = LogMgr.init_cls()()
  91         self._pos_mgr = PositionMgr()
  92         self._prepare_window(args)
  93         if args.update:
  94             return
  95         if args.functional_test:
  96             self._options['settings']['volume'] = 0
  97         self._music = MusicMgr(self._options['settings']['volume'])
  98         self.lang_mgr = LangMgr(self._options['settings']['language'],
  99                                 'pmachines',
 100                                 'assets/locale/')
 101         self._fsm = MainFsm(self)
 102         if args.screenshot:
 103             cls = [cls for cls in self.scenes if cls.__name__ == args.screenshot][0]
 104             scene = cls(BulletWorld(), None, True, False, lambda: None, self.scenes)
 105             scene.screenshot()
 106             scene.destroy()
 107             exit()
 108         elif self._options['development']['auto_start']:
 109             mod_name = 'pmachines.scenes.scene_' + self._options['development']['auto_start']
 110             for member in import_module(mod_name).__dict__.values():
 111                 if isclass(member) and issubclass(member, Scene) and \
 112                         member != Scene:
 113                     cls = member
 114             self._fsm.demand('Scene', cls)
 115         else:
 116             self._fsm.demand('Menu')
 117         if args.functional_test or args.functional_ref:
 118             FunctionalTest(args.functional_ref, self._pos_mgr)
 119             self.__fps_lst = []
 120             taskMgr.do_method_later(1.0, self.__assert_fps, 'assert_fps')
 121
 122     def on_menu_enter(self):
 123         self._menu_bg = Background()
 124         self._menu = Menu(
 125             self._fsm, self.lang_mgr, self._options, self._music,
 126             self._pipeline, self.scenes, self._args.functional_test or self._args.functional_ref,
 127             self._pos_mgr)
 128
 129     def on_home(self):
 130         self._fsm.demand('Menu')
 131
 132     def on_menu_exit(self):
 133         self._menu_bg.destroy()
 134         self._menu.destroy()
 135
 136     def on_scene_enter(self, cls):
 137         self._set_physics()
 138         self._scene = cls(
 139             self.world, self.on_home,
 140             self._options['development']['auto_close_instructions'],
 141             self._options['development']['debug_items'],
 142             self.reload,
 143             self.scenes,
 144             self._pos_mgr,
 145             self._args.functional_test or self._args.functional_ref,
 146             self._options['development']['mouse_coords'])
 147
 148     def on_scene_exit(self):
 149         self._unset_physics()
 150         self._scene.destroy()
 151
 152     def reload(self, cls):
 153         self._fsm.demand('Scene', cls)
 154
 155     def _configure(self, args):
 156         load_prc_file_data('', 'window-title pmachines')
 157         load_prc_file_data('', 'framebuffer-srgb true')
 158         load_prc_file_data('', 'sync-video true')
 159         if args.functional_test or args.functional_ref:
 160             load_prc_file_data('', 'win-size 1360 768')
 161             # otherwise it is not centered in exwm
 162         # load_prc_file_data('', 'threading-model Cull/Draw')
 163         # it freezes when you go to the next scene
 164         if args.screenshot:
 165             load_prc_file_data('', 'window-type offscreen')
 166             load_prc_file_data('', 'audio-library-name null')
 167
 168     def _parse_args(self):
 169         parser = argparse.ArgumentParser()
 170         parser.add_argument('--update', action='store_true')
 171         parser.add_argument('--version', action='store_true')
 172         parser.add_argument('--optfile')
 173         parser.add_argument('--screenshot')
 174         parser.add_argument('--functional-test', action='store_true')
 175         parser.add_argument('--functional-ref', action='store_true')
 176         cmd_line = [arg for arg in iter(argv[1:]) if not arg.startswith('-psn_')]
 177         args = parser.parse_args(cmd_line)
 178         return args
 179
 180     def _prepare_window(self, args):
 181         data_path = ''
 182         if (platform.startswith('win') or platform.startswith('linux')) and (
 183                 not exists('main.py') or __file__.startswith('/app/bin/')):
 184             # it is the deployed version for windows
 185             data_path = str(Filename.get_user_appdata_directory()) + '/pmachines'
 186             home = '/home/flavio'  # we must force this for wine
 187             if data_path.startswith('/c/users/') and exists(home + '/.wine/'):
 188                 data_path = home + '/.wine/drive_' + data_path[1:]
 189             info('creating dirs: %s' % data_path)
 190             makedirs(data_path, exist_ok=True)
 191         optfile = args.optfile if args.optfile else 'options.ini'
 192         info('data path: %s' % data_path)
 193         info('option file: %s' % optfile)
 194         info('fixed path: %s' % LibP3d.fixpath(data_path + '/' + optfile))
 195         default_opt = {
 196             'settings': {
 197                 'volume': 1,
 198                 'language': 'en',
 199                 'fullscreen': 1,
 200                 'resolution': '',
 201                 'antialiasing': 1,
 202                 'shadows': 1},
 203             'development': {
 204                 'simplepbr': 1,
 205                 'verbose_log': 0,
 206                 'physics_debug': 0,
 207                 'auto_start': 0,
 208                 'auto_close_instructions': 0,
 209                 'show_buffers': 0,
 210                 'debug_items': 0,
 211                 'mouse_coords': 0,
 212                 'fps': 0}}
 213         opt_path = LibP3d.fixpath(data_path + '/' + optfile) if data_path else optfile
 214         opt_exists = exists(opt_path)
 215         self._options = DctFile(
 216             LibP3d.fixpath(data_path + '/' + optfile) if data_path else optfile,
 217             default_opt)
 218         if not opt_exists:
 219             self._options.store()
 220         res = self._options['settings']['resolution']
 221         if res:
 222             res = LVector2i(*[int(_res) for _res in res.split('x')])
 223         else:
 224             resolutions = []
 225             if not self.version:
 226                 d_i = base.pipe.get_display_information()
 227                 def _res(idx):
 228                     return d_i.get_display_mode_width(idx), \
 229                         d_i.get_display_mode_height(idx)
 230                 resolutions = [
 231                     _res(idx) for idx in range(d_i.get_total_display_modes())]
 232             res = sorted(resolutions)[-1]
 233         fullscreen = self._options['settings']['fullscreen']
 234         props = WindowProperties()
 235         if args.functional_test or args.functional_ref:
 236             fullscreen = False
 237         else:
 238             props.set_size(res)
 239         props.set_fullscreen(fullscreen)
 240         props.set_icon_filename('assets/images/icon/pmachines.ico')
 241         if not args.screenshot and not self.version:
 242             base.win.request_properties(props)
 243         #gltf.patch_loader(base.loader)
 244         if self._options['development']['simplepbr'] and not self.version:
 245             self._pipeline = simplepbr.init(
 246                 use_normal_maps=True,
 247                 use_emission_maps=False,
 248                 use_occlusion_maps=True,
 249                 msaa_samples=4 if self._options['settings']['antialiasing'] else 1,
 250                 enable_shadows=int(self._options['settings']['shadows']))
 251             debug(f'msaa: {self._pipeline.msaa_samples}')
 252             debug(f'shadows: {self._pipeline.enable_shadows}')
 253         render.setAntialias(AntialiasAttrib.MAuto)
 254         self.base.set_background_color(0, 0, 0, 1)
 255         self.base.disable_mouse()
 256         if self._options['development']['show_buffers']:
 257             base.bufferViewer.toggleEnable()
 258         if self._options['development']['fps']:
 259             base.set_frame_rate_meter(True)
 260         #self.base.accept('window-event', self._on_win_evt)
 261         self.base.accept('aspectRatioChanged', self._on_aspect_ratio_changed)
 262         if self._options['development']['mouse_coords']:
 263             coords_txt = OnscreenText(
 264                 '', parent=base.a2dTopRight, scale=0.04,
 265                 pos=(-.03, -.06), fg=(.9, .9, .9, 1), align=TextNode.A_right)
 266             def update_coords(task):
 267                 txt = '%s %s' % (int(base.win.get_pointer(0).x),
 268                                  int(base.win.get_pointer(0).y))
 269                 coords_txt['text'] = txt
 270                 return task.cont
 271             taskMgr.add(update_coords, 'update_coords')
 272
 273     def _set_physics(self):
 274         if self._options['development']['physics_debug']:
 275             debug_node = BulletDebugNode('Debug')
 276             debug_node.show_wireframe(True)
 277             debug_node.show_constraints(True)
 278             debug_node.show_bounding_boxes(True)
 279             debug_node.show_normals(True)
 280             self._debug_np = render.attach_new_node(debug_node)
 281             self._debug_np.show()
 282         self.world = BulletWorld()
 283         self.world.set_gravity((0, 0, -9.81))
 284         if self._options['development']['physics_debug']:
 285             self.world.set_debug_node(self._debug_np.node())
 286         def update(task):
 287             dt = globalClock.get_dt()
 288             self.world.do_physics(dt, 10, 1/180)
 289             return task.cont
 290         self._phys_tsk = taskMgr.add(update, 'update')
 291
 292     def _unset_physics(self):
 293         if self._options['development']['physics_debug']:
 294             self._debug_np.remove_node()
 295         self.world = None
 296         taskMgr.remove(self._phys_tsk)
 297
 298     def _on_aspect_ratio_changed(self):
 299         if self._fsm.state == 'Scene':
 300             self._scene.on_aspect_ratio_changed()
 301
 302     def __assert_fps(self, task):
 303         if len(self.__fps_lst) > 3:
 304             self.__fps_lst.pop(0)
 305         self.__fps_lst += [globalClock.average_frame_rate]
 306         if len(self.__fps_lst) == 4:
 307             assert(any(fps > 55 for fps in self.__fps_lst))
 308         return task.again