bastd.actor.background

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Defines Actor(s)."""
  4
  5from __future__ import annotations
  6
  7import random
  8import weakref
  9from typing import TYPE_CHECKING
 10
 11import ba
 12
 13if TYPE_CHECKING:
 14    from typing import Any
 15
 16
 17class Background(ba.Actor):
 18    """Simple Fading Background Actor."""
 19
 20    def __init__(
 21        self,
 22        fade_time: float = 0.5,
 23        start_faded: bool = False,
 24        show_logo: bool = False,
 25    ):
 26        super().__init__()
 27        self._dying = False
 28        self.fade_time = fade_time
 29        # We're special in that we create our node in the session
 30        # scene instead of the activity scene.
 31        # This way we can overlap multiple activities for fades
 32        # and whatnot.
 33        session = ba.getsession()
 34        self._session = weakref.ref(session)
 35        with ba.Context(session):
 36            self.node = ba.newnode(
 37                'image',
 38                delegate=self,
 39                attrs={
 40                    'fill_screen': True,
 41                    'texture': ba.gettexture('bg'),
 42                    'tilt_translate': -0.3,
 43                    'has_alpha_channel': False,
 44                    'color': (1, 1, 1),
 45                },
 46            )
 47            if not start_faded:
 48                ba.animate(
 49                    self.node,
 50                    'opacity',
 51                    {0.0: 0.0, self.fade_time: 1.0},
 52                    loop=False,
 53                )
 54            if show_logo:
 55                logo_texture = ba.gettexture('logo')
 56                logo_model = ba.getmodel('logo')
 57                logo_model_transparent = ba.getmodel('logoTransparent')
 58                self.logo = ba.newnode(
 59                    'image',
 60                    owner=self.node,
 61                    attrs={
 62                        'texture': logo_texture,
 63                        'model_opaque': logo_model,
 64                        'model_transparent': logo_model_transparent,
 65                        'scale': (0.7, 0.7),
 66                        'vr_depth': -250,
 67                        'color': (0.15, 0.15, 0.15),
 68                        'position': (0, 0),
 69                        'tilt_translate': -0.05,
 70                        'absolute_scale': False,
 71                    },
 72                )
 73                self.node.connectattr('opacity', self.logo, 'opacity')
 74                # add jitter/pulse for a stop-motion-y look unless we're in VR
 75                # in which case stillness is better
 76                if not ba.app.vr_mode:
 77                    self.cmb = ba.newnode(
 78                        'combine', owner=self.node, attrs={'size': 2}
 79                    )
 80                    for attr in ['input0', 'input1']:
 81                        ba.animate(
 82                            self.cmb,
 83                            attr,
 84                            {0.0: 0.693, 0.05: 0.7, 0.5: 0.693},
 85                            loop=True,
 86                        )
 87                    self.cmb.connectattr('output', self.logo, 'scale')
 88                    cmb = ba.newnode(
 89                        'combine', owner=self.node, attrs={'size': 2}
 90                    )
 91                    cmb.connectattr('output', self.logo, 'position')
 92                    # Gen some random keys for that stop-motion-y look.
 93                    keys = {}
 94                    timeval = 0.0
 95                    for _i in range(10):
 96                        keys[timeval] = (random.random() - 0.5) * 0.0015
 97                        timeval += random.random() * 0.1
 98                    ba.animate(cmb, 'input0', keys, loop=True)
 99                    keys = {}
100                    timeval = 0.0
101                    for _i in range(10):
102                        keys[timeval] = (random.random() - 0.5) * 0.0015 + 0.05
103                        timeval += random.random() * 0.1
104                    ba.animate(cmb, 'input1', keys, loop=True)
105
106    def __del__(self) -> None:
107        # Normal actors don't get sent DieMessages when their
108        # activity is shutting down, but we still need to do so
109        # since our node lives in the session and it wouldn't die
110        # otherwise.
111        self._die()
112        super().__del__()
113
114    def _die(self, immediate: bool = False) -> None:
115        session = self._session()
116        if session is None and self.node:
117            # If session is gone, our node should be too,
118            # since it was part of the session's scene.
119            # Let's make sure that's the case.
120            # (since otherwise we have no way to kill it)
121            ba.print_error(
122                'got None session on Background _die'
123                ' (and node still exists!)'
124            )
125        elif session is not None:
126            with ba.Context(session):
127                if not self._dying and self.node:
128                    self._dying = True
129                    if immediate:
130                        self.node.delete()
131                    else:
132                        ba.animate(
133                            self.node,
134                            'opacity',
135                            {0.0: 1.0, self.fade_time: 0.0},
136                            loop=False,
137                        )
138                        ba.timer(self.fade_time + 0.1, self.node.delete)
139
140    def handlemessage(self, msg: Any) -> Any:
141        assert not self.expired
142        if isinstance(msg, ba.DieMessage):
143            self._die(msg.immediate)
144        else:
145            super().handlemessage(msg)