[pmachines.git] / pmachines / app.py

import argparse
import simplepbr
#import gltf
from glob import glob
from importlib import import_module
from inspect import isclass
from sys import platform, argv, exit
from logging import info, debug
from os.path import exists
from os import makedirs
from multiprocessing import cpu_count
from panda3d.core import Filename, load_prc_file_data, AntialiasAttrib, \
    Texture, WindowProperties, LVector2i, TextNode
from panda3d.bullet import BulletWorld, BulletDebugNode
from direct.showbase.ShowBase import ShowBase
from direct.gui.OnscreenText import OnscreenText
from direct.fsm.FSM import FSM
from pmachines.audio.music import MusicMgr
from pmachines.items.background import Background
from pmachines.gui.menu import Menu
from pmachines.scene import Scene
from pmachines.scenes.scene_basketball import SceneBasketBall
from pmachines.scenes.scene_box import SceneBox
from pmachines.scenes.scene_domino_box_basketball import SceneDominoBoxBasketball
from pmachines.scenes.scene_domino_box import SceneDominoBox
from pmachines.scenes.scene_domino import SceneDomino
from pmachines.scenes.scene_teeter_domino_box_basketball import SceneTeeterDominoBoxBasketball
from pmachines.scenes.scene_teeter_tooter import SceneTeeterTooter
from pmachines.posmgr import PositionMgr
from ya2.utils.dictfile import DctFile
from ya2.p3d.p3d import LibP3d
from ya2.utils.lang import LangMgr
from ya2.utils.log import LogMgr
from ya2.utils.functional import FunctionalTest
from ya2.p3d.asserts import assert_threads, assert_tasks, assert_render3d, \
    assert_render2d, assert_aspect2d, assert_events, assert_buffers


class MainFsm(FSM):

    def __init__(self, pmachines):
        super().__init__('Main FSM')
        self._pmachines = pmachines

    def enterMenu(self):
        self._pmachines.on_menu_enter()

    def exitMenu(self):
        self._pmachines.on_menu_exit()
        self.__do_asserts()

    def enterScene(self, cls):
        self._pmachines.on_scene_enter(cls)

    def exitScene(self):
        self._pmachines.on_scene_exit()
        self.__do_asserts()

    def __do_asserts(self):
        args = self._pmachines._args
        if not LibP3d.runtime() or args.functional_test or args.functional_ref:
            assert_threads()
            assert_tasks()
            assert_render3d()
            assert_render2d()
            assert_aspect2d()
            assert_events()
            assert_buffers()


class PmachinesApp:

    scenes = [
        SceneDomino,
        SceneBox,
        SceneDominoBox,
        SceneBasketBall,
        SceneDominoBoxBasketball,
        SceneTeeterTooter,
        SceneTeeterDominoBoxBasketball]

    def __init__(self):
        info('platform: %s' % platform)
        info('exists main.py: %s' % exists('main.py'))
        self._args = args = self._parse_args()
        self._configure(args)
        self.base = ShowBase()
        self._pipeline = None
        self.updating = args.update
        self.version = args.version
        self.log_mgr = LogMgr.init_cls()()
        self._pos_mgr = PositionMgr()
        self._prepare_window(args)
        if args.update:
            return
        if args.functional_test:
            self._options['settings']['volume'] = 0
        self._music = MusicMgr(self._options['settings']['volume'])
        self.lang_mgr = LangMgr(self._options['settings']['language'],
                                'pmachines',
                                'assets/locale/')
        self._fsm = MainFsm(self)
        if args.screenshot:
            cls = [cls for cls in self.scenes if cls.__name__ == args.screenshot][0]
            scene = cls(BulletWorld(), None, True, False, lambda: None, self.scenes)
            scene.screenshot()
            scene.destroy()
            exit()
        elif self._options['development']['auto_start']:
            mod_name = 'pmachines.scenes.scene_' + self._options['development']['auto_start']
            for member in import_module(mod_name).__dict__.values():
                if isclass(member) and issubclass(member, Scene) and \
                        member != Scene:
                    cls = member
            self._fsm.demand('Scene', cls)
        else:
            self._fsm.demand('Menu')
        if args.functional_test or args.functional_ref:
            FunctionalTest(args.functional_ref, self._pos_mgr)
        if not LibP3d.runtime() or args.functional_test or args.functional_ref:
            self.__fps_lst = []
            taskMgr.do_method_later(1.0, self.__assert_fps, 'assert_fps')

    def on_menu_enter(self):
        self._menu_bg = Background()
        self._menu = Menu(
            self._fsm, self.lang_mgr, self._options, self._music,
            self._pipeline, self.scenes, self._args.functional_test or self._args.functional_ref,
            self._pos_mgr)

    def on_home(self):
        self._fsm.demand('Menu')

    def on_menu_exit(self):
        self._menu_bg.destroy()
        self._menu.destroy()

    def on_scene_enter(self, cls):
        self._set_physics()
        self._scene = cls(
            self.world, self.on_home,
            self._options['development']['auto_close_instructions'],
            self._options['development']['debug_items'],
            self.reload,
            self.scenes,
            self._pos_mgr,
            self._args.functional_test or self._args.functional_ref,
            self._options['development']['mouse_coords'])

    def on_scene_exit(self):
        self._unset_physics()
        self._scene.destroy()

    def reload(self, cls):
        self._fsm.demand('Scene', cls)

    def _configure(self, args):
        load_prc_file_data('', 'window-title pmachines')
        load_prc_file_data('', 'framebuffer-srgb true')
        load_prc_file_data('', 'sync-video true')
        if args.functional_test or args.functional_ref:
            load_prc_file_data('', 'win-size 1360 768')
            # otherwise it is not centered in exwm
        # load_prc_file_data('', 'threading-model Cull/Draw')
        # it freezes when you go to the next scene
        if args.screenshot:
            load_prc_file_data('', 'window-type offscreen')
            load_prc_file_data('', 'audio-library-name null')

    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')
        parser.add_argument('--screenshot')
        parser.add_argument('--functional-test', action='store_true')
        parser.add_argument('--functional-ref', action='store_true')
        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,
                'language': 'en',
                'fullscreen': 1,
                'resolution': '',
                'antialiasing': 1,
                'shadows': 1},
            'development': {
                'simplepbr': 1,
                'verbose_log': 0,
                'physics_debug': 0,
                'auto_start': 0,
                'auto_close_instructions': 0,
                'show_buffers': 0,
                'debug_items': 0,
                'mouse_coords': 0,
                'fps': 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()
        res = self._options['settings']['resolution']
        if res:
            res = LVector2i(*[int(_res) for _res in res.split('x')])
        else:
            resolutions = []
            if not self.version:
                d_i = base.pipe.get_display_information()
                def _res(idx):
                    return d_i.get_display_mode_width(idx), \
                        d_i.get_display_mode_height(idx)
                resolutions = [
                    _res(idx) for idx in range(d_i.get_total_display_modes())]
            res = sorted(resolutions)[-1]
        fullscreen = self._options['settings']['fullscreen']
        props = WindowProperties()
        if args.functional_test or args.functional_ref:
            fullscreen = False
        else:
            props.set_size(res)
        props.set_fullscreen(fullscreen)
        props.set_icon_filename('assets/images/icon/pmachines.ico')
        if not args.screenshot and not self.version:
            base.win.request_properties(props)
        #gltf.patch_loader(base.loader)
        if self._options['development']['simplepbr'] and not self.version:
            self._pipeline = simplepbr.init(
                use_normal_maps=True,
                use_emission_maps=False,
                use_occlusion_maps=True,
                msaa_samples=4 if self._options['settings']['antialiasing'] else 1,
                enable_shadows=int(self._options['settings']['shadows']))
            debug(f'msaa: {self._pipeline.msaa_samples}')
            debug(f'shadows: {self._pipeline.enable_shadows}')
        render.setAntialias(AntialiasAttrib.MAuto)
        self.base.set_background_color(0, 0, 0, 1)
        self.base.disable_mouse()
        if self._options['development']['show_buffers']:
            base.bufferViewer.toggleEnable()
        if self._options['development']['fps']:
            base.set_frame_rate_meter(True)
        #self.base.accept('window-event', self._on_win_evt)
        self.base.accept('aspectRatioChanged', self._on_aspect_ratio_changed)
        if self._options['development']['mouse_coords']:
            coords_txt = OnscreenText(
                '', parent=base.a2dTopRight, scale=0.04,
                pos=(-.03, -.06), fg=(.9, .9, .9, 1), align=TextNode.A_right)
            def update_coords(task):
                txt = '%s %s' % (int(base.win.get_pointer(0).x),
                                 int(base.win.get_pointer(0).y))
                coords_txt['text'] = txt
                return task.cont
            taskMgr.add(update_coords, 'update_coords')

    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)
            self._debug_np = render.attach_new_node(debug_node)
            self._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(self._debug_np.node())
        def update(task):
            dt = globalClock.get_dt()
            self.world.do_physics(dt, 10, 1/180)
            return task.cont
        self._phys_tsk = taskMgr.add(update, 'update')

    def _unset_physics(self):
        if self._options['development']['physics_debug']:
            self._debug_np.remove_node()
        self.world = None
        taskMgr.remove(self._phys_tsk)

    def _on_aspect_ratio_changed(self):
        if self._fsm.state == 'Scene':
            self._scene.on_aspect_ratio_changed()

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