fixed the width of the menu buttons

[pmachines.git] / pmachines / scene.py

from panda3d.core import AmbientLight, DirectionalLight, Point3, Texture, \
    TextPropertiesManager, TextNode, Spotlight, PerspectiveLens, BitMask32
from panda3d.bullet import BulletPlaneShape, BulletGhostNode
from direct.gui.OnscreenImage import OnscreenImage
from direct.gui.OnscreenText import OnscreenText
from direct.gui.DirectGui import DirectButton, DirectFrame
from direct.gui.DirectGuiGlobals import FLAT, DISABLED, NORMAL
from direct.showbase.DirectObject import DirectObject
from pmachines.items.background import Background
from pmachines.items.box import Box
from pmachines.sidepanel import SidePanel
from lib.engine.gui.cursor import MouseCursor
from lib.lib.p3d.gfx import P3dGfxMgr


class Scene(DirectObject):

    def __init__(self, world, exit_cb, auto_close_instr):
        super().__init__()
        self._world = world
        self._exit_cb = exit_cb
        self._set_camera()
        self._cursor = MouseCursor(
            'assets/buttons/arrowUpLeft.png', (.04, 1, .04), (.5, .5, .5, 1),
            (.01, .01))
        self._set_gui()
        self._set_lights()
        self._set_input()
        self._set_mouse_plane()
        self.items = [Box(world, self._mouse_plane_node, 3, self.cb_inst)]
        self._paused = True
        self.__store_state()
        if auto_close_instr:
            self.__restore_state()
        else:
            self._set_instructions()
        self._bg = Background()
        self._side_panel = SidePanel(world, self._mouse_plane_node, (-5, 4), (-3, 1), 1, self.items)
        self._scene_tsk = taskMgr.add(self.on_frame, 'on_frame')

    def destroy(self):
        self._unset_gui()
        self._unset_lights()
        self._unset_input()
        self._unset_mouse_plane()
        [itm.destroy() for itm in self.items]
        self._bg.destroy()
        self._side_panel.destroy()
        self._cursor.destroy()
        taskMgr.remove(self._scene_tsk)

    def _set_camera(self):
        base.camera.set_pos(0, -20, 0)
        base.camera.look_at(0, 0, 0)

    def __load_img_btn(self, path, col):
        img = OnscreenImage('assets/buttons/%s.png' % path)
        img.set_transparency(True)
        img.set_color(col)
        img.detach_node()
        return img

    def _set_gui(self):
        def load_images_btn(path, col):
            colors = {
                'gray': [
                    (.6, .6, .6, 1),  # ready
                    (1, 1, 1, 1), # press
                    (.8, .8, .8, 1), # rollover
                    (.4, .4, .4, .4)],
                'green': [
                    (.1, .68, .1, 1),
                    (.1, 1, .1, 1),
                    (.1, .84, .1, 1),
                    (.4, .1, .1, .4)]}[col]
            return [self.__load_img_btn(path, col) for col in colors]
        abl, abr = base.a2dBottomLeft, base.a2dBottomRight
        btn_info = [
            ('home', self.on_home, NORMAL, abl, 'gray'),
            ('information', self.on_information, DISABLED, abl, 'gray'),
            ('right', self.on_play, NORMAL, abr, 'green'),
            ('next', self.on_next, DISABLED, abr, 'gray'),
            ('previous', self.on_prev, DISABLED, abr, 'gray'),
            ('rewind', self.on_rewind, DISABLED, abr, 'gray')]
        num_l = num_r = 0
        btns = []
        for binfo in btn_info:
            imgs = load_images_btn(binfo[0], binfo[4])
            if binfo[3] == base.a2dBottomLeft:
                sign, num = 1, num_l
                num_l += 1
            else:
                sign, num = -1, num_r
                num_r += 1
            fcols = (.4, .4, .4, .14), (.3, .3, .3, .05)
            btn = DirectButton(
                image=imgs, scale=.05, pos=(sign * (.06 + .11 * num), 1, .06),
                parent=binfo[3], command=binfo[1], state=binfo[2], relief=FLAT,
                frameColor=fcols[0] if binfo[2] == NORMAL else fcols[1],
                rolloverSound=loader.load_sfx('assets/audio/sfx/rollover.ogg'),
                clickSound=loader.load_sfx('assets/audio/sfx/click.ogg'))
            btn.set_transparency(True)
            btns += [btn]
        self.__home_btn, self.__info_btn, self.__right_btn, self.__next_btn, \
            self.__prev_btn, self.__rewind_btn = btns

    def _unset_gui(self):
        btns = [
            self.__home_btn, self.__info_btn, self.__right_btn,
            self.__next_btn, self.__prev_btn, self.__rewind_btn]
        [btn.destroy() for btn in btns]

    def _set_spotlight(self, name, pos, look_at, color, shadows=False):
        light = Spotlight(name)
        if shadows:
            light.setLens(PerspectiveLens())
        light_np = render.attach_new_node(light)
        light_np.set_pos(pos)
        light_np.look_at(look_at)
        light.set_color(color)
        render.set_light(light_np)
        return light_np

    def _set_lights(self):
        alight = AmbientLight('alight')  # for ao
        alight.set_color((.15, .15, .15, 1))
        self._alnp = render.attach_new_node(alight)
        render.set_light(self._alnp)
        self._key_light = self._set_spotlight(
            'key light', (-5, -80, 5), (0, 0, 0), (2.8, 2.8, 2.8, 1))
        self._shadow_light = self._set_spotlight(
            'key light', (-5, -80, 5), (0, 0, 0), (.58, .58, .58, 1), True)
        self._shadow_light.node().set_shadow_caster(True, 2048, 2048)
        self._shadow_light.node().get_lens().set_film_size(2048, 2048)
        self._shadow_light.node().get_lens().set_near_far(1, 256)
        self._shadow_light.node().set_camera_mask(BitMask32(0x01))

    def _unset_lights(self):
        for light in [self._alnp, self._key_light, self._shadow_light]:
            render.clear_light(light)
            light.remove_node()

    def _set_input(self):
        self.accept('mouse1', self.on_click_l)
        self.accept('mouse1-up', self.on_release)
        self.accept('mouse3', self.on_click_r)
        self.accept('mouse3-up', self.on_release)

    def _unset_input(self):
        for evt in ['mouse1', 'mouse1-up', 'mouse3', 'mouse3-up']:
            self.ignore(evt)

    def _set_mouse_plane(self):
        shape = BulletPlaneShape((0, -1, 0), 0)
        #self._mouse_plane_node = BulletRigidBodyNode('mouse plane')
        self._mouse_plane_node = BulletGhostNode('mouse plane')
        self._mouse_plane_node.addShape(shape)
        #np = render.attachNewNode(self._mouse_plane_node)
        #self._world.attachRigidBody(self._mouse_plane_node)
        self._world.attach_ghost(self._mouse_plane_node)

    def _unset_mouse_plane(self):
        self._world.remove_ghost(self._mouse_plane_node)

    def _get_hits(self):
        if not base.mouseWatcherNode.has_mouse(): return []
        p_from, p_to = P3dGfxMgr.world_from_to(base.mouseWatcherNode.get_mouse())
        return self._world.ray_test_all(p_from, p_to).get_hits()

    def _on_click(self, method):
        if self._paused:
            return
        for hit in self._get_hits():
            if hit.get_node() == self._mouse_plane_node:
                pos = hit.get_hit_pos()
        for hit in self._get_hits():
            for item in [i for i in self.items if hit.get_node() == i.node]:
                getattr(item, method)(pos)
                img = 'move' if method == 'on_click_l' else 'rotate'
                self._cursor.set_image('assets/buttons/%s.png' % img)

    def on_click_l(self):
        self._on_click('on_click_l')

    def on_click_r(self):
        self._on_click('on_click_r')

    def on_release(self):
        [item.on_release() for item in self.items]
        self._cursor.set_image('assets/buttons/arrowUpLeft.png')

    def on_aspect_ratio_changed(self):
        [item.on_aspect_ratio_changed() for item in self.items]
        self._side_panel.update(self.items)

    def on_frame(self, task):
        hits = self._get_hits()
        pos = None
        for hit in self._get_hits():
            if hit.get_node() == self._mouse_plane_node:
                pos = hit.get_hit_pos()
        hit_nodes = [hit.get_node() for hit in hits]
        items_hit = [itm for itm in self.items if itm.node in hit_nodes]
        items_no_hit = [itm for itm in self.items if itm not in items_hit]
        [itm.on_mouse_on() for itm in items_hit]
        [itm.on_mouse_off() for itm in items_no_hit]
        if pos:
            [itm.on_mouse_move(pos) for itm in self.items]
        return task.cont

    def cb_inst(self, item):
        self.items += [item]

    def on_play(self):
        [itm.play() for itm in self.items]

    def on_next(self):
        print('on_next')

    def on_prev(self):
        print('on_prev')

    def on_rewind(self):
        print('on_rewind')

    def on_home(self):
        self._exit_cb()

    def on_information(self):
        print('on_information')

    def _set_instructions(self):
        mgr = TextPropertiesManager.get_global_ptr()
        for name in ['mouse_l', 'mouse_r']:
            graphic = OnscreenImage('assets/buttons/%s.png' % name)
            graphic.set_scale(.5)
            graphic.get_texture().set_minfilter(Texture.FTLinearMipmapLinear)
            graphic.get_texture().set_anisotropic_degree(2)
            mgr.set_graphic(name, graphic)
            graphic.set_z(-.2)
            graphic.set_transparency(True)
            graphic.detach_node()
        frm = DirectFrame(frameColor=(.4, .4, .4, .06),
                          frameSize=(-.6, .6, -.3, .3))
        font = base.loader.load_font('assets/fonts/Hanken-Book.ttf')
        font.clear()
        font.set_pixels_per_unit(60)
        font.set_minfilter(Texture.FTLinearMipmapLinear)
        font.set_outline((0, 0, 0, 1), .8, .2)
        txt = _('keep \5mouse_l\5 pressed to drag an item\n\n'
                'keep \5mouse_r\5 pressed to rotate an item')
        self._txt = OnscreenText(
            txt, parent=frm, font=font, scale=0.06, fg=(.9, .9, .9, 1),
            align=TextNode.A_left)
        u_l = self._txt.textNode.get_upper_left_3d()
        l_r = self._txt.textNode.get_lower_right_3d()
        w, h = l_r[0] - u_l[0], u_l[2] - l_r[2]
        btn_scale = .05
        mar = .06  # margin
        z = h / 2 - font.get_line_height() * self._txt['scale'][1]
        z += (btn_scale + 2 * mar) / 2
        self._txt['pos'] = -w / 2, z
        u_l = self._txt.textNode.get_upper_left_3d()
        l_r = self._txt.textNode.get_lower_right_3d()
        c_l_r = l_r[0], l_r[1], l_r[2] - 2 * mar - btn_scale
        fsz = u_l[0] - mar, l_r[0] + mar, c_l_r[2] - mar, u_l[2] + mar
        frm['frameSize'] = fsz
        colors = [
            (.6, .6, .6, 1),  # ready
            (1, 1, 1, 1), # press
            (.8, .8, .8, 1), # rollover
            (.4, .4, .4, .4)]
        imgs = [self.__load_img_btn('exitRight', col) for col in colors]
        btn = DirectButton(
            image=imgs, scale=btn_scale,
            pos=(l_r[0] - btn_scale, 1, l_r[2] - mar - btn_scale),
            parent=frm, command=self.__on_close_instructions, extraArgs=[frm],
            relief=FLAT, frameColor=(.6, .6, .6, .08),
            rolloverSound=loader.load_sfx('assets/audio/sfx/rollover.ogg'),
            clickSound=loader.load_sfx('assets/audio/sfx/click.ogg'))
        btn.set_transparency(True)

    def __store_state(self):
        btns = [
            self.__home_btn, self.__info_btn, self.__right_btn,
            self.__next_btn, self.__prev_btn, self.__rewind_btn]
        self.__btn_state = [btn['state'] for btn in btns]
        for btn in btns:
            btn['state'] = DISABLED
        [itm.store_state() for itm in self.items]

    def __restore_state(self):
        btns = [
            self.__home_btn, self.__info_btn, self.__right_btn,
            self.__next_btn, self.__prev_btn, self.__rewind_btn]
        for btn, state in zip(btns, self.__btn_state):
            btn['state'] = state
        [itm.restore_state() for itm in self.items]
        self._paused = False

    def __on_close_instructions(self, frm):
        frm.remove_node()
        self.__restore_state()