\ jgdZddlZddlmZddlmZmZmZddlm Z ddl m Z GddZ Gd d Z Gd d Zead ZdZddZdZdZdZdZdZdZdZdS)aPrecise framerate calculation function scheduling. Measuring time ============== The `tick` and `get_fps` functions can be used in conjunction to fulfil most games' basic requirements:: from pyglet import clock while True: dt = clock.tick() # ... update and render ... print(f"FPS is {clock.get_fps()}") The ``dt`` value returned gives the number of seconds (as a float) since the last "tick". The `get_fps` function averages the framerate over a sliding window of approximately 1 second. (You can calculate the instantaneous framerate by taking the reciprocal of ``dt``). Always remember to `tick` the clock! Scheduling ========== You can schedule a function to be called every time the clock is ticked:: def callback(dt): print(f"{dt} seconds since last callback") clock.schedule(callback) The `schedule_interval` method causes a function to be called every "n" seconds:: clock.schedule_interval(callback, .5) # called twice a second The `schedule_once` method causes a function to be called once "n" seconds in the future:: clock.schedule_once(callback, 5) # called in 5 seconds All of the `schedule` methods will pass on any additional args or keyword args you specify to the callback function:: def move(dt, velocity, sprite): sprite.position += dt * velocity clock.schedule(move, velocity=5.0, sprite=alien) You can cancel a function scheduled with any of these methods using `unschedule`:: clock.unschedule(move) Using multiple clocks ===================== The clock functions are all relayed to an instance of :py:class:`~pyglet.clock.Clock` which is initialised with the module. You can get this instance to use directly:: clk = clock.get_default() You can also replace the default clock with your own: myclk = clock.Clock() clock.set_default(myclk) Each clock maintains its own set of scheduled functions and FPS measurement. Each clock must be "ticked" separately. Multiple and derived clocks potentially allow you to separate "game-time" and "wall-time", or to synchronise your clock to an audio or video stream instead of the system clock. N) attrgetter)heappushheappop heappushpop)deque)compat_platformceZdZgdZdZdS)_ScheduledItemfuncargskwargsc0||_||_||_dSNr )selfr r rs F/DATA/AppData/hermes/venv/lib/python3.11/site-packages/pyglet/clock.py__init__z_ScheduledItem.__init__~s   N)__name__ __module__ __qualname__ __slots__rrrr r {s.***Irr c"eZdZgdZdZdZdS)_ScheduledIntervalItemr intervallast_tsnext_tsr rcZ||_||_||_||_||_||_dSrr)rr rrrr rs rrz_ScheduledIntervalItem.__init__s0       rcZ |j|jkS#t$r|j|kcYSwxYwr)rAttributeError)rothers r__lt__z_ScheduledIntervalItem.__lt__sD (<%-/ / ( ( (<%' ' ' ' (s **N)rrrrrr$rrrrrs=LLLI(((((rrceZdZdZedvrdndZedz ZdZdZdZ e j ffd Z e d Zd Zd Zdd Zd ZdZdZdZdZdZdZdZdZxZS)ClockzhClass for calculating and limiting framerate. It is also used for calling scheduled functions. )win32cygwingMb?g{Gzt?gMbP?NFctt|||_||_d|_t |_d|_d|_ g|_ g|_ d|_ dS)aWInitialise a Clock, with optional custom time function. :Parameters: `time_function` : function Function to return the elapsed time of the application, in seconds. Defaults to time.time, but can be replaced to allow for easy time dilation effects or game pausing. Nr<) superr&rtimerrrtimescumulative_time window_size_schedule_items_schedule_interval_items_current_interval_item)r time_function __class__s rrzClock.__init__sy eT##%%%! yy{{  WW  !(*%&*###rc4tj|dzdS)Ngư>)r,sleep) microsecondss rr6z Clock.sleeps <$&'''''rc@|}|jd}nh||jz }|j|t |j|jkr'|xj|jzc_|xj|z c_||_|S)aGet the elapsed time since the last call to `update_time`. This updates the clock's internal measure of time and returns the difference since the last update (or since the clock was created). .. versionadded:: 1.2 :rtype: float :return: The number of seconds since the last `update_time`, or 0 if this was the first time it was called. Nr)r,rr- appendleftlenr/r.pop)rtsdelta_ts r update_timezClock.update_timesYY[[ < GG4<'G J ! !' * * *4:!111$$ (8(88$$ ' rc|j}d}|jr4d}t|jD]}|j|g|jRi|j|j} |dj|kr|Sn#t$r|cYSwxYwdx|_ }|j }|r|t|}nt||}||_ |j|krn|j||jz g|jRi|j|j ro|j|j z|_||_|j|krH||jz dkr||j z|_n4|||j |_|j|j z |_n dx|_ }||t||dS)aCall scheduled functions that elapsed on the last `update_time`. .. versionadded:: 1.2 :Parameters: dt : float The elapsed time since the last update to pass to each scheduled function. This is *not* used to calculate which functions have elapsed. :rtype: bool :return: True if any functions were called, otherwise False. FTrNg?)rr0listr r rr1r IndexErrorr2_get_soft_next_tsrrrr)rdtnowresultiteminterval_itemsget_soft_next_tss rcall_scheduled_functionszClock.call_scheduled_functionssl   9FT122 9 9 "8ty888DK88886 a (3.. /   MMM  .21#d1/ : |~..">488 +/D '|c!! DIcDL( D49 D D D D D D} : $|dm; " <3&&T\)D00(+T]': (8'7T]'K'K '+|dm'C 6:9+d_/ :b   ^T * * *ts A!! A0/A0c|s|jr|d|}|||S)a9Signify that one frame has passed. This will call any scheduled functions that have elapsed. :Parameters: `poll` : bool If True, the function will call any scheduled functions but will not sleep or busy-wait for any reason. Recommended for advanced applications managing their own sleep timers only. Since pyglet 1.1. :rtype: float :return: The number of seconds since the last "tick", or 0 if this was the first frame. r) _force_sleepr6r>rI)rpollr=s rtickz Clock.tickFsO$ )  JJqMMM""$$ %%g...rc|js|sdS|jr5t|jdj|z dSdS)aGet the time until the next item is scheduled. Applications can choose to continue receiving updates at the maximum framerate during idle time (when no functions are scheduled), or they can sleep through their idle time and allow the CPU to switch to other processes or run in low-power mode. If `sleep_idle` is ``True`` the latter behaviour is selected, and ``None`` will be returned if there are no scheduled items. Otherwise, if `sleep_idle` is ``False``, or if any scheduled items exist, a value of 0 is returned. :Parameters: `sleep_idle` : bool If True, the application intends to sleep through its idle time; otherwise it will continue ticking at the maximum frame rate allowed. :rtype: float :return: Time until the next scheduled event in seconds, or ``None`` if there is no event scheduled. .. versionadded:: 1.1 grN)r0r1maxrr,)r sleep_idles rget_sleep_timezClock.get_sleep_time_sT4   z 3  ( Tt4Q7?$))++MsSS StrcL|jsdSt|j|jz S)aVGet the average clock update frequency of recent history. The result is the average of a sliding window of the last "n" updates, where "n" is some number designed to cover approximately 1 second. This is **not** the Window redraw rate. :rtype: float :return: The measured updates per second. r)r.r:r-)rs rget_fpsz Clock.get_fpss*# 14:!555rc`|jp|j}|}||z dkr|S|S)aGet the nearest timestamp. Schedule from now, unless now is sufficiently close to last_ts, in which case use last_ts. This clusters together scheduled items that probably want to be scheduled together. The old (pre 1.1.1) behaviour was to always use self.last_ts, and not look at ts. The new behaviour is needed because clock ticks can now be quite irregular, and span several seconds. g?)rrr,)rrr<s r_get_nearest_tszClock._get_nearest_tss8,.$, YY[[ <#  Ircfd}jtd||z}|||dz s|S|}d} |}t|dz D]}||z }|||dz s|cS|dz}|dz}|dkr|SB) NczjD]1}t|j|z |krdS|j||zkrdS2dS)z7Check if `ts` has already got an item scheduled nearby.TF)r1absr)r<erFrs rtakenz&Clock._get_soft_next_ts..takens\5 ! !t|b())Q..44\BF** 55+5rr)keyT)r1sortrrange)rrrrZrrCdivsis` rrBzClock._get_soft_next_tss     " %**z)/D/D*EEE"H$uWhl++ N  G4!8__ # #2 uWb1f--#"NNN# !GB AIDbyy rc\t|||}|j|dS)aSchedule a function to be called every frame. The function should have a prototype that includes ``dt`` as the first argument, which gives the elapsed time, in seconds, since the last clock tick. Any additional arguments given to this function are passed on to the callback:: def callback(dt, *args, **kwargs): pass :Parameters: `func` : callable The function to call each frame. N)r r0append)rr r rrFs rschedulezClock.schedules2dD&11 ##D)))))rc|}||z}t|d||||}t|j|dS)a`Schedule a function to be called once after `delay` seconds. The callback function prototype is the same as for `schedule`. :Parameters: `func` : callable The function to call when the timer lapses. `delay` : float The number of seconds to wait before the timer lapses. rNrUrrr1)rr delayr rrrrFs r schedule_oncezClock.schedule_oncesN&&((E/%dAwvNN.55555rc|}||z}t||||||}t|j|dS)aSchedule a function to be called every `interval` seconds. Specifying an interval of 0 prevents the function from being called again (see `schedule` to call a function as often as possible). The callback function prototype is the same as for `schedule`. :Parameters: `func` : callable The function to call when the timer lapses. `interval` : float The number of seconds to wait between each call. Nrh)rr rr rrrrFs rschedule_intervalzClock.schedule_intervalsO&&((H$%dHgwfUU.55555rc|||}||z }t||||||}t|j|dS)aSchedule a function to be called every ``interval`` seconds. This method is similar to `schedule_interval`, except that the clock will move the interval out of phase with other scheduled functions so as to distribute CPU more load evenly over time. This is useful for functions that need to be called regularly, but not relative to the initial start time. :py:mod:`pyglet.media` does this for scheduling audio buffer updates, which need to occur regularly -- if all audio updates are scheduled at the same time (for example, mixing several tracks of a music score, or playing multiple videos back simultaneously), the resulting load on the CPU is excessive for those intervals but idle outside. Using the soft interval scheduling, the load is more evenly distributed. Soft interval scheduling can also be used as an easy way to schedule graphics animations out of phase; for example, multiple flags waving in the wind. .. versionadded:: 1.1 :Parameters: `func` : callable The function to call when the timer lapses. `interval` : float The number of seconds to wait between each call. N)rBrUrrr1)rr rr rrrrFs rschedule_interval_softzClock.schedule_interval_soft s_:(()=)=)?)?JJH$%dHgwfUU.55555rctfd|jD}|jr*|jjkr||j|D]}d|_d|_fd|jD|_dS)a:Remove a function from the schedule. If the function appears in the schedule more than once, all occurrences are removed. If the function was not scheduled, no error is raised. :Parameters: `func` : callable The function to remove from the schedule. c32K|]}|jk |VdSrr ).0rFr s r z#Clock.unschedule..;s<00"!Y$......00rrc|Srr)xr rs rz"Clock.unschedule..Es1rc*g|]}|jk |Srrq)rrrcr s r z$Clock.unschedule..Gs RRRa16T>>>>>rN)setr1r2r addrr0)rr valid_itemsrFs ` r unschedulezClock.unschedule-s0000&*&C00000   & =*/477 ;<<< 5 5DDM44DIIRRRR4+?RRRrF)rrr__doc__r MIN_SLEEPSLEEP_UNDERSHOOTr0r1rKr, perf_counterr staticmethodr6r>rIrMrQrSrUrBrfrjrlrnr| __classcell__)r4s@rr&r&sh),???UI!5(O $L%)%6++++++0((\(2[[[z2   D 6 6 6 444l***$666 666( 6 6 6DSSSSSSSrr&c |adS)zSet the default clock to use for all module-level functions. By default an instance of :py:class:`~pyglet.clock.Clock` is used. :Parameters: `default` : `Clock` The default clock to use. N_default)defaults r set_defaultrNs HHHrctS)zGet the pyglet default Clock. Return the :py:class:`~pyglet.clock.Clock` instance that is used by all module-level clock functions. :rtype: `Clock` :return: The default clock. rrrr get_defaultr[s  OrFc6t|S)aSignify that one frame has passed on the default clock. This will call any scheduled functions that have elapsed. :Parameters: `poll` : bool If True, the function will call any scheduled functions but will not sleep or busy-wait for any reason. Recommended for advanced applications managing their own sleep timers only. Since pyglet 1.1. :rtype: float :return: The number of seconds since the last "tick", or 0 if this was the first frame. )rrM)rLs rrMrMgs$ ==  rc6t|S)aGet the time until the next item is scheduled on the default clock. See `Clock.get_sleep_time` for details. :Parameters: `sleep_idle` : bool If True, the application intends to sleep through its idle time; otherwise it will continue ticking at the maximum frame rate allowed. :rtype: float :return: Time until the next scheduled event in seconds, or ``None`` if there is no event scheduled. .. versionadded:: 1.1 )rrQ)rPs rrQrQ|s"  " ": . ..rc4tS)aGet the average clock update frequency. The result is the sliding average of the last "n" updates, where "n" is some number designed to cover approximately 1 second. This is the internal clock update rate, **not** the Window redraw rate. Platform events, such as moving the mouse rapidly, will cause the clock to refresh more often. :rtype: float :return: The measured updates per second. )rrSrrrrSrSs     rc0tj|g|Ri|dS)aSchedule 'func' to be called every frame on the default clock. The arguments passed to func are ``dt``, followed by any ``*args`` and ``**kwargs`` given here. :Parameters: `func` : callable The function to call each frame. N)rrfr s rrfrfs+ d,T,,,V,,,,,rc2tj||g|Ri|dS)aSchedule ``func`` on the default clock every interval seconds. The arguments passed to ``func`` are ``dt`` (time since last function call), followed by any ``*args`` and ``**kwargs`` given here. :Parameters: `func` : callable The function to call when the timer lapses. `interval` : float The number of seconds to wait between each call. N)rrlr rr rs rrlrls- tX?????????rc2tj||g|Ri|dS)a\Schedule ``func`` on the default clock every interval seconds. The clock will move the interval out of phase with other scheduled functions so as to distribute CPU more load evenly over time. The arguments passed to ``func`` are ``dt`` (time since last function call), followed by any ``*args`` and ``**kwargs`` given here. :see: `Clock.schedule_interval_soft` .. versionadded:: 1.1 :Parameters: `func` : callable The function to call when the timer lapses. `interval` : float The number of seconds to wait between each call. N)rrnrs rrnrns-( #D(DTDDDVDDDDDrc2tj||g|Ri|dS)aNSchedule ``func`` to be called once after ``delay`` seconds. This function uses the default clock. ``delay`` can be a float. The arguments passed to ``func`` are ``dt`` (time since last function call), followed by any ``*args`` and ``**kwargs`` given here. If no default clock is set, the func is queued and will be scheduled on the default clock as soon as it is created. :Parameters: `func` : callable The function to call when the timer lapses. `delay` : float The number of seconds to wait before the timer lapses. N)rrj)r rir rs rrjrjs-  4888888888rc:t|dS)zRemove ``func`` from the default clock's schedule. No error is raised if the ``func`` was never scheduled. :Parameters: `func` : callable The function to remove from the schedule. N)rr|rqs rr|r|s rr})r~r,operatorrheapqrrr collectionsrpygletrr rr&rrrrMrQrSrfrlrnrjr|rrrrsHLL\ 0000000000""""""(((((((($qSqSqSqSqSqSqSqSj 577      *///(    - - - @ @ @EEE.999&     r