^ jU&dZddlmZddlZddlmZmZddlm Z ddlm Z ddlm ZddlmZdd lmZGd d ZGd d ZGddZead,dZd-dZd.d/dZd0dZd1dZd2d#Zd3d%Zd4d'Z d5d(Z!d6d*Z"d7d+Z#dS)8aPrecise framerate calculation function scheduling. The :py:mod:`~pyglet.clock` module allows you to schedule functions to run periodically, or for one-shot future execution. pyglet's default event loop (:py:func:`~pyglet.app.run`) keeps an internal instance of a :py:class:`~pyglet.clock.Clock`, which is ticked automatically. .. note:: Some internal modules will schedule items on the clock. If you are using a custom event loop, 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, 0.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 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 = pyglet.clock.get_default() You can also replace the default clock with your own: myclk = pyglet.clock.Clock() pyglet.clock.set_default(myclk) Each clock maintains its own set of scheduled functions and frequency 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. ) annotationsN)AnyCallable)heappop)heappush) heappushpop) attrgetter)dequeceZdZgdZd d Zd S) _ScheduledItemfuncargskwargsrrrrrreturnNonec0||_||_||_dSNr )selfrrrs G/home/agentuser/manim-venv/lib/python3.11/site-packages/pyglet/clock.py__init__z_ScheduledItem.__init__Qs   Nrrrrrrrr)__name__ __module__ __qualname__ __slots__rrrr r Ns3***Irr c&eZdZgdZdd ZddZdS)_ScheduledIntervalItemrintervallast_tsnext_tsrrrrr"floatr#r$rrrrrcZ||_||_||_||_||_||_dSrr!)rrr"r#r$rrs rrz_ScheduledIntervalItem.__init__Zs0       rotherboolc"|j|jkSr)r$)rr's r__lt__z_ScheduledIntervalItem.__lt__bs|em++rN)rrr"r%r#r%r$r%rrrrrr)r'r rr()rrrrrr*rrrr r WsGLLLI,,,,,,rr ceZdZUded<ded<dZded<ejfd)d Zed*dZ d+dZ d,dZ d-d.dZ d/dZ d+dZd+dZd0dZd1d Zd2d"Zd3d#Zd4d%Zd3d&Zd5d'Zd(S)6Clocklist_schedule_items_schedule_interval_itemsFr( _force_sleep time_functionrrrc||_d|_||_t|_d|_d|_g|_g|_d|_ dS)a3Initialise a Clock, with optional custom time function. You can provide a custom time function to return the elapsed time of the application, in seconds. Defaults to ``time.perf_counter``, but can be replaced to allow for easy time dilation effects or game pausing. N<) timer#r$_dequetimescumulative_time window_sizer.r/_current_interval_item)rr1s rrzClock.__init__qs\"  yy{{ $XX "!(*%&*###r microsecondsr%c4tj|dzdS)Ngư>)_timesleep)r;s rr>z Clock.sleeps L4'(((((rc@|}|jd}nh||jz }|j|t |j|jkr'|xj|jzc_|xj|z c_||_|S)a Get the elapsed time since the last call to `update_time`. This updates the clock's internal measure of time and returns the difference (in seconds) since the last time it was called. The first call of this method always returns 0. Nr3)r5r#r7 appendleftlenr9r8pop)rtsdelta_ts r update_timezClock.update_timesYY[[ < GG4<'G J ! !' * * *4:!111$$ (8(88$$ ' rdtc |jp|}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|jro|j|jz|_||_|j|krH||jz dkr||jz|_n4|||j|_|j|jz |_n dx|_ }||t||dS)aCall scheduled functions that elapsed on the last `update_time`. This method is called automatically when the clock is ticked (see :py:meth:`~pyglet.clock.tick`), so you need not call it yourself in most cases. Args: dt: The elapsed time since the last update to pass to each scheduled function. This is *not* used to calculate which functions have elapsed. Returns: ``True`` if any functions were called, else ``False``. FTrNg?)r#r5r.r-rrrr/r$ IndexErrorr:_get_soft_next_ts_heappop _heappushpopr" _heappush)rrFnowresultiteminterval_itemsget_soft_next_tss rcall_scheduled_functionszClock.call_scheduled_functionss l)diikk   9FT122 9 9 "8ty888DK88886 a (3.. /   MMM  .21#d1/ : |//#ND99 +/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   nd + + +ts!A55 BBpollc|s|jr|d|}|||S)a$Signify that one frame has passed. This will call any scheduled functions that have elapsed, and returns the number of seconds since the last time this method has been called. The first time this method is called, 0 is returned. Args: poll: 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. r)r0r>rErR)rrSrDs rtickz Clock.ticksO )  JJqMMM""$$ %%g...r sleep_idle float | Nonec|js|sdS|jr5t|jdj|z dSdS)a;Get the time until the next item is scheduled, if any. 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. Args: sleep_idle: If True, the application intends to sleep through its idle time; otherwise it will continue ticking at the maximum frame rate allowed. r3rN)r.r/maxr$r5)rrVs rget_sleep_timezClock.get_sleep_timesT(   z 3  ( Tt4Q7?$))++MsSS StrcL|jsdSt|j|jz S)a(Get 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 the clock frequency, **not** the Window redraw rate (fps). r)r8rAr7)rs r get_frequencyzClock.get_frequency-s*# 14:!555rc`|jp|j}|}||z dkr|S|S)zGet 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. g?)r#r$r5)rr#rCs r_get_nearest_tszClock._get_nearest_ts8s8,.$, YY[[ <#  Irr#r"cdfd }jtd||z}|||d z s|S|}d } |}t|d z D]}||z }|||d z s|cS|d z}|d z}|d kr|SB)NrCr%err(czjD]1}t|j|z |krdS|j||zkrdS2dS)z7Check if `ts` has already got an item scheduled nearby.TF)r/absr$)rCr`rOrs rtakenz&Clock._get_soft_next_ts..takenGs\5 ! !t|b())Q..44\BF** 55+5rr$)keyT)rCr%r`r%rr()r/sort _attrgetterrange)rr#r"rcr$rFdivs_s` rrIzClock._get_soft_next_tsEs      " %**{9/E/E*FFF"H$uWhl++ N  G4!8__ # #2 uWb1f--#"NNN# !GB AIDbyy rrrrrc\t|||}|j|dS)aSchedule a function to be called every tick. The scheduled 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 args or kwargs given to this method are passed on to the callback:: def callback(dt, *args, **kwargs): pass .. note:: Functions scheduled using this method will be called every tick by the default pyglet event loop, which can lead to high CPU usage. It is usually better to use :py:meth:`~pyglet.clock.schedule_interval` unless this is desired. N)r r.append)rrrrrOs rschedulezClock.schedule|s2$dD&11 ##D)))))rdelayc|}||z}t|d||||}t|j|dS)zSchedule a function to be called once after ``delay`` seconds. The callback function prototype is the same as for :py:meth:`~pyglet.clock.Clock.schedule`. rNr^r rLr/)rrrqrrr#r$rOs r schedule_oncezClock.schedule_oncesN &&((E/%dAwvNN$/66666rc|}||z}t||||||}t|j|dS)aSchedule a function to be called every ``interval`` seconds. To schedule a function to be called at 60Hz (60fps), you would use ``1/60`` for the interval, and so on. If pyglet is unable to call the function on time, the schedule will be skipped (not accumulated). This can occur if the main thread is overloaded, or other hard blocking calls taking place. The callback function prototype is the same as for :py:meth:`~pyglet.clock.Clock.schedule`. .. note:: Specifying an interval of ``0`` will prevent the function from being called again. If you want to schedule a function to be called as often as possible, see :py:meth:`~pyglet.clock.Clock.schedule`. Nrs)rrr"rrr#r$rOs rschedule_intervalzClock.schedule_intervalsO&&((H$%dHgwfUU$/66666rdurationcfd fd }j||g|Ri||||dS) aTemporarily schedule a function to be called every ``interval`` seconds. This method will schedule a function to be called every ``interval`` seconds (see :py:meth:`~pyglet.clock.Clock.schedule_interval`), but will automatically unschedule it after ``duration`` seconds. The callback function prototype is the same as for :py:meth:`~pyglet.clock.Clock.schedule`. :Args: func: The function to call when the timer lapses. interval: The number of seconds to wait between each call. duration: The number of seconds for which the function is scheduled. _dtr%_funcrrrc2|dSr) unschedule)ryrzrs r _unschedulez9Clock.schedule_interval_for_duration.._unschedules OOE " " " " "rN)ryr%rzrrr)rvrt)rrr"rwrrr}s` rschedule_interval_for_durationz$Clock.schedule_interval_for_durationsf( # # # # # # tX??????? ;$77777rc|||}||z }t||||||}t|j|dS)a8Schedule a function to be called approximately every ``interval`` seconds. This method is similar to :py:meth:`~pyglet.clock.Clock.schedule_interval`, except that the clock will move the interval out of phase with other scheduled functions in order to distribute CPU load more evenly. 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. N)rIr^r rLr/)rrr"rrr$r#rOs rschedule_interval_softzClock.schedule_interval_softs_((()=)=)?)?JJH$%dHgwfUU$/66666rcfd|jD}|jr*|jjkr||j|D]}d|_d|_fd|jD|_dS)zRemove 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. c*h|]}|jk |Srr).0rOrs r z#Clock.unschedule..s&[[[VZIZIZtIZIZIZrrc|Srr)xrrs rz"Clock.unschedule..s1rc*g|]}|jk |Srr)rirs r z$Clock.unschedule..s RRRa16T>>>>>rN)r/r:raddr"r.)rr valid_itemsrOs ` rr|zClock.unschedules\[[[(E[[[  & 94+F+Kt+S+S OOD7 8 8 8 5 5DDM44DIIRRRR4+?RRRrN)r1rrr)r;r%rrrr%)rFr%rr(FrSr(rr%rVr(rrW)r#r%r"r%rr%r) rrrqr%rrrrrr rrr"r%rrrrrr) rrr"r%rwr%rrrrrrrrrr)rrr__annotations__r0r= perf_counterr staticmethodr>rErRrUrZr\r^rIrprtrvr~rr|rrrr,r,fs#"""L161C+++++*)))\)([[[[z,8 6 6 6 6    5555n***** 7 7 7 77777(8888477772SSSSSSrr,defaultrrc |adS)zSet the default clock to use for all module-level functions. By default, an instance of :py:class:`~pyglet.clock.Clock` is used. N_default)rs r set_defaultrs HHHrctS)zGet the pyglet default Clock. Return the :py:class:`~pyglet.clock.Clock` instance that is used by all module-level clock functions. rrrr get_defaultrs OrFrSr(r%c6t|S)z*:see: :py:meth:`~pyglet.clock.Clock.tick`.)rrU)rSs rrUrUs ==  rrVrWc6t|S)z4:see: :py:meth:`~pyglet.clock.Clock.get_sleep_time`.)rrZ)rVs rrZrZs  " ": . ..rc4tS)z3:see: :py:meth:`~pyglet.clock.Clock.get_frequency`.)rr\rrrr\r\s  ! ! # ##rrrrrrc0tj|g|Ri|dS)z.:see: :py:meth:`~pyglet.clock.Clock.schedule`.N)rrpr s rrprps) d,T,,,V,,,,,rr"c2tj||g|Ri|dS)z7:see: :py:meth:`~pyglet.clock.Clock.schedule_interval`.N)rrvrr"rrs rrvrv"s+ tX?????????rrwc4tj|||g|Ri|dS)zD:see: :py:meth:`~pyglet.clock.Clock.schedule_interval_for_duration`.N)rr~)rr"rwrrs rr~r~'s- +D(HVtVVVvVVVVVrc2tj||g|Ri|dS)z<:see: :py:meth:`~pyglet.clock.Clock.schedule_interval_soft`.N)rrrs rrr,s+ #D(DTDDDVDDDDDrrqc2tj||g|Ri|dS)z3:see: :py:meth:`~pyglet.clock.Clock.schedule_once`.N)rrt)rrqrrs rrtrt1s+ 4888888888rc:t|dS)z0:see: :py:meth:`~pyglet.clock.Clock.unschedule`.N)rr|rs rr|r|6s r)rr,rr)rr,rrrrrr)rrr"r%rwr%rr)rrr"r%rr)rrrqr%rrr)$__doc__ __future__rr5r=typingrrheapqrrJrrLrrKoperatorr rj collectionsr r6r r r,rrrrUrZr\rprvr~rrtr|rrrrs/??@#""""" %%%%%%''''''------......'''''' , , , , , , , ,OSOSOSOSOSOSOSOSf 577 //// $$$$ ---- @@@@ WWWW EEEE 9999 r