^ jpUdZddlmZddlZddlZddlmZmZmZddl Z ddl m Z m Z m Z m Z ddlmZmZmZmZmZmZmZmZmZmZeedoejZerddlmZmZdd lm Z dd l!m"Z"m#Z#m$Z$d Z%d e&d <dZ'd e&d<dZ(d e&d<ddZ)ddZ*Gdde jZ+Gdde j,Z-e-.ddS)a Display positioned, scaled and rotated images. A sprite is an instance of an image displayed on-screen. Multiple sprites can display the same image at different positions on the screen. Sprites can also be scaled larger or smaller, rotated at any angle and drawn at a fractional opacity. The following complete example loads a ``"ball.png"`` image and creates a sprite for that image. The sprite is then drawn in the window's draw event handler:: import pyglet ball_image = pyglet.image.load('ball.png') ball = pyglet.sprite.Sprite(ball_image, x=50, y=50) window = pyglet.window.Window() @window.event def on_draw(): ball.draw() pyglet.app.run() The sprite can be moved by modifying the :py:attr:`~pyglet.sprite.Sprite.x` and :py:attr:`~pyglet.sprite.Sprite.y` properties. Other properties determine the sprite's :py:attr:`~pyglet.sprite.Sprite.rotation`, :py:attr:`~pyglet.sprite.Sprite.scale` and :py:attr:`~pyglet.sprite.Sprite.opacity`. By default, sprite coordinates are restricted to integer values to avoid sub-pixel artifacts. If you require to use floats, for example for smoother animations, you can set the ``subpixel`` parameter to ``True`` when creating the sprite (:since: pyglet 1.2). The sprite's positioning, rotation and scaling all honor the original image's anchor (:py:attr:`~pyglet.image.AbstractImage.anchor_x`, :py:attr:`~pyglet.image.AbstractImage.anchor_y`). Drawing multiple sprites ======================== Sprites can be "batched" together and drawn at once more quickly than if each of their ``draw`` methods were called individually. The following example creates one hundred ball sprites and adds each of them to a :py:class:`~pyglet.graphics.Batch`. The entire batch of sprites is then drawn in one call:: batch = pyglet.graphics.Batch() ball_sprites = [] for i in range(100): x, y = i * 10, 50 ball_sprites.append(pyglet.sprite.Sprite(ball_image, x, y, batch=batch)) @window.event def on_draw(): batch.draw() Sprites can be freely modified in any way even after being added to a batch, however a sprite can belong to at most one batch. See the documentation for :py:mod:`pyglet.graphics` for more details on batched rendering, and grouping of sprites within batches. .. versionadded:: 1.1 ) annotationsN) TYPE_CHECKINGClassVarLiteral)clockeventgraphicsimage) GL_BLENDGL_ONE_MINUS_SRC_ALPHA GL_SRC_ALPHA GL_TEXTURE0 GL_TRIANGLESglActiveTexture glBindTexture glBlendFunc glDisableglEnableis_pyglet_doc_run)BatchGroup) ShaderProgram) AbstractImage AnimationTexturea#version 150 core in vec3 translate; in vec4 colors; in vec3 tex_coords; in vec2 scale; in vec3 position; in float rotation; out vec4 vertex_colors; out vec3 texture_coords; uniform WindowBlock { mat4 projection; mat4 view; } window; mat4 m_scale = mat4(1.0); mat4 m_rotation = mat4(1.0); mat4 m_translate = mat4(1.0); void main() { m_scale[0][0] = scale.x; m_scale[1][1] = scale.y; m_translate[3][0] = translate.x; m_translate[3][1] = translate.y; m_translate[3][2] = translate.z; m_rotation[0][0] = cos(-radians(rotation)); m_rotation[0][1] = sin(-radians(rotation)); m_rotation[1][0] = -sin(-radians(rotation)); m_rotation[1][1] = cos(-radians(rotation)); gl_Position = window.projection * window.view * m_translate * m_rotation * m_scale * vec4(position, 1.0); vertex_colors = colors; texture_coords = tex_coords; } str vertex_sourcez#version 150 core in vec4 vertex_colors; in vec3 texture_coords; out vec4 final_colors; uniform sampler2D sprite_texture; void main() { final_colors = texture(sprite_texture, texture_coords.xy) * vertex_colors; } fragment_sourcez#version 150 core in vec4 vertex_colors; in vec3 texture_coords; out vec4 final_colors; uniform sampler2DArray sprite_texture; void main() { final_colors = texture(sprite_texture, texture_coords) * vertex_colors; } fragment_array_sourcereturnrchtjjtdft dfS)z~Create and return the default sprite shader. This method allows the module to be imported without an OpenGL Context. vertexfragment)pygletglcurrent_contextcreate_programrrH/home/agentuser/manim-venv/lib/python3.11/site-packages/pyglet/sprite.pyget_default_shaderr+s3 9 $ 3 3]H4M5Dj4Q S SSr)chtjjtdft dfS)zCreate and return the default array sprite shader. This method allows the module to be imported without an OpenGL Context. r"r#)r$r%r&r'rrr(r)r*get_default_array_shaderr-s3 9 $ 3 3]H4M5JJ4W Y YYr)cPeZdZdZ ddfd ZddZddZddZddZddZ xZ S) SpriteGroupzShared Sprite rendering Group. The Group defines custom ``__eq__`` and ``__hash__`` methods, and so will be automatically coalesced with other Sprite Groups sharing the same parent Group, Texture and blend parameters. Ntexturer blend_srcint blend_destprogramrparent Group | Noner Nonect|||_||_||_||_dS)aCreate a sprite group. The group is created internally when a :py:class:`~pyglet.sprite.Sprite` is created; applications usually do not need to explicitly create it. Args: texture: The (top-level) texture containing the sprite image. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. program: A custom ShaderProgram. parent: Optional parent group. )r5N)super__init__r0r1r3r4)selfr0r1r3r4r5 __class__s r*r:zSpriteGroup.__init__s@* ''' "$ r)c|jttt |jj|jjttt|j |j dSN) r4userrrr0targetidrr rr1r3r;s r* set_statezSpriteGroup.set_statese  $$$dl)4)rr r4stoprBs r* unset_statezSpriteGroup.unset_states*( r)rc0|jjd|jdS)N())r<__name__r0rBs r*__repr__zSpriteGroup.__repr__s .);;DL;;;;r)otherboolc|j|juoq|j|juoc|j|jkoS|jj|jjko9|jj|jjko|j|jko|j|jkSr>)r<r4r5r0r@rAr1r3)r;rLs r*__eq__zSpriteGroup.__eq__s4>14  -4 u|+4 #u}';;4 5=#33 4 %/1 4 5#33  5r)c|t|j|j|jj|jj|j|jfSr>)hashr4r5r0rAr@r1r3rBs r*__hash__zSpriteGroup.__hash__s8T\4;\_dl&9^T_677 7r)r>) r0rr1r2r3r2r4rr5r6r r7r r7)r r)rLr/r rMr r2) rJ __module__ __qualname____doc__r:rCrFrKrOrR __classcell__)r<s@r*r/r/sAE65555<<<<555577777777r)r/c deZdZUdZdZdZdZdZdZdZ de d<dZ dZ dZ d ZdZeZd e d <dddeeddddf dmdZdnd Zdnd!Zdod#Zedpd%Zejdqd'Zedrd)Zejdsd*Zedtd,Zejdud-Zedvd/Zejdwd0Zedxd1Zejdyd2Zdzd5Zdnd6Z d{d8Z!dnd9Z"d|d;Z#ed}d=Z$e$jd~d?Z$edd@Z%e%jddAZ%eddBZ&e&jddCZ&eddDZ'e'jddEZ'eddFZ(e(jddHZ(eddIZ)e)jddKZ)eddLZ*e*jddNZ*eddOZ+e+jddQZ+ dddSZ,eddTZ-e-jddVZ-eddWZ.e.jddYZ.eddZZ/e/jdd\Z/edd]Z0e0jdd`Z0eddaZ1e1jddcZ1edddZ2e2jddfZ2eddgZ3e3jddiZ3dndjZ4e5rddlZ6dSdS)SpritezPManipulate an on-screen image. See the module documentation for usage. NrF)r[r[r[tuple[int, int, int, int]_rgbag?Tz#ClassVar[type[SpriteGroup | Group]] group_classimgAbstractImage | Animationxfloatyzr1r2r3batch Batch | Nonegroupr6subpixelrMr4ShaderProgram | Noner r7c ||_||_||_t|tjrn||_|jdj|_ |jdj |_ |j rtj |j|j n||_ | s7t|tjrt!} nt#} | |_||_||_||_||_||_| |_|dS)aCreate a Sprite instance. Args: img: Image or Animation to display. x: X coordinate of the sprite. y: Y coordinate of the sprite. z: Z coordinate of the sprite. blend_src: OpenGL blend source mode. The default is suitable for compositing sprites drawn from back-to-front. blend_dest: OpenGL blend destination mode. The default is suitable for compositing sprites drawn from back-to-front. batch: Optional batch to add the sprite to. group: Optional parent group of the sprite. subpixel: Allow floating-point coordinates for the sprite. By default, coordinates are restricted to integer values. program: A specific shader program to initialize the sprite with. By default, a pre-made shader will be chosen based on the texture type passed. .. versionadded:: 2.0.16 The *program* parameter. rN)_x_y_z isinstancer r _animationframes get_texture_textureduration_next_dtr schedule_once_animateTextureArrayRegionr-r+_program_batch _blend_src _blend_dest _user_groupget_sprite_group_group _subpixel_create_vertex_list) r;r_rarcrdr1r3rergrhr4s r*r:zSprite.__init__ s!P c5? + + .!DOJqM/;;==DMJqM2DM} B#DM4=AAAOO--DM /#u788 /244,..  #% ++-- !   """""r)cn |j|jdSdS#t$rYdSwxYwr>) _vertex_listdelete ExceptionrBs r*__del__zSprite.__del__OsU  ,!((*****-,    DD s & 44c|jrtj|j|jd|_d|_d|_dS)a Force immediate removal of the sprite from video memory. It is recommended to call this whenever you delete a sprite, as the Python garbage collector will not necessarily call the finalizer as soon as the sprite falls out of scope. N)ror unschedulervrrrrr~rBs r*rz Sprite.deleteVsR ? ,  T] + + +   """   r)dtc"|xjdz c_|jt|jjkr%d|_|d|jdS|jj|j}||j|j X|j |j |z z }ttd||j }tj|j|||_ dS|ddS)Nron_animation_end) _frame_indexlenrorpdispatch_eventr _set_texturer rqrsrtminmaxrrurv)r;rframerss r*rvzSprite._animatefs Q  DO$: ; ; ; ; !D     2 3 3 3 (&t'89 %+1133444 > %~);)rzr{r}r~rymigraterr)r;rsrcdsts r*rzSprite.blend_modesS $/ ! !cT-=&=&= F++-- ; " K   1<dk Z Z Z Z Z # "r)rc|jS)zThe current shader program. .. note:: Changing this can be an expensive operation as it involves a group creation and transfer. )rxrBs r*r4zSprite.programs }r)c$|j|krdS||_||_|jr.|j|jt |j|rdS|j|dSr>) rxr}r~ry update_shaderrrrr)r;r4s r*r4zSprite.programs =G # # F ++-- K  ))$*;\4;X_``  F   """   """""r)rc|jS)a Graphics batch. The sprite can be migrated from one batch to another, or removed from its batch (for individual drawing). .. note:: Changing this can be an expensive operation as it involves deleting the vertex list and recreating it. )ryrBs r*rez Sprite.batchs {r)c|j|krdS|<|j5|j|jt|j|||_dS|j||_|dSr>)ryrrrr~rr)r;res r*rez Sprite.batchs ;%   F  !8 K   1<e T T TDKKK   $ $ & & &DK  $ $ & & & & &r)rc|jS)zParent graphics group specified by the user. This group will always be the parent of the internal sprite group. .. note:: Changing this can be an expensive operation as it involves a group creation and transfer. )r|rBs r*rgz Sprite.groups r)c|j|krdS||_||_|j3|j|jt |j|jdSdSr>)r|r}r~ryrrr)r;rgs r*rgz Sprite.groupsi  u $ $ F ++-- ; " K   1<dk Z Z Z Z Z # "r)c,|jr|jS|jS)zThe Sprite's Image or Animation to display. .. note:: Changing this can be an expensive operation if the texture is not part of the same texture or atlas. )rorrrBs r*r z Sprite.images ? #? "}r)c|j tj|jd|_t |t jr||_d|_||j dj |j dj |_ |j rtj |j|j n'|| |dS)Nr)rorrrvrnr rrrrprqrsrtru_update_position)r;r_s r*r z Sprite.images ? &  T] + + +"DO c5? + + 1!DO !D    cjm1==?? @ @ @JqM2DM} B#DM4=AAA   coo// 0 0 0 r)r0rc|j|jjurN|j||_||_|n|j|jjdd<||_dSr>)rArrrrr}r~r tex_coords)r;r0s r*rzSprite._set_texturesz :T]- - -   $ $ & & &#DM//11DK  $ $ & & & &.5.@D  ( + r)cV|jdtgd|j|jd|fd|jdzfd|j|j|j fdzfd|j |j z|j |j zfdzfd|j fdzfd|jjf |_dS)N)rrrrfBn)positioncolors translatescalerotationr)r4vertex_list_indexedrryr~ _get_verticesr]rkrlrm_scale_scale_x_scale_y _rotationrrrrrBs r*rzSprite._create_vertex_lists L<< |///dk4--//0$*q.)TWdgtw7!;<t}4dkDM6QRUVVWDN,q01T]56=88r)tuplec |jsdS|j}|j }|j }||jz}||jz}|jsvt|t|dt|t|dt|t|dt|t|df S||d||d||d||df S)N) rrrrrrrrrrrrr)_visiblerranchor_xanchor_ywidthheightrr2)r;r_x1y1x2y2s r*rzSprite._get_verticess} 655ml]l] #)^ #*_~ >GGSWWaR#b''1GGSWWaR#b''1> >2q"b!RQB99r)cL||jjdd<dSr>)rrrrBs r*rzSprite._update_positions((,(:(:(<(<"111%%%r)SpriteGroup | Groupcf||j|j|j|j|jS)aCreates and returns a group to be used to render the sprite. This is used internally to create a consolidated group for rendering. .. note:: This is for advanced usage. This is a group automatically created internally as a child of ``group``, and does not need to be modified unless the parameters of your custom group changes. .. versionadded:: 2.0.16 )r^rrrzr{rxr|rBs r*r}zSprite.get_sprite_groups/ t@PRVR_aeaqrrrr)tuple[float, float, float]c*|j|j|jfS)z4The (x, y, z) coordinates of the sprite, as a tuple.)rkrlrmrBs r*rzSprite.positionsw((r)rcX|\|_|_|_|dz|jjdd<dSNrrkrlrmrr)r;rs r*rzSprite.position$s2$,!$')1A#AAA&&&r)c|jS)zX coordinate of the sprite.)rkrBs r*razSprite.x) wr)cV||_||j|jfdz|jjdd<dSrr)r;ras r*razSprite.x.s3*+TWdg)>)B#AAA&&&r)c|jS)zY coordinate of the sprite.)rlrBs r*rczSprite.y3rr)cV||_|j||jfdz|jjdd<dSr)rlrkrmrr)r;rcs r*rczSprite.y8s3*.'1dg)>)B#AAA&&&r)c|jS)zZ coordinate of the sprite.)rmrBs r*rdzSprite.z=rr)cV||_|j|j|fdz|jjdd<dSr)rmrkrlrr)r;rds r*rdzSprite.zBs3*.'47A)>)B#AAA&&&r)c|jS)zClockwise rotation of the sprite, in degrees. The sprite image will be rotated about its image's (anchor_x, anchor_y) position. )rrBs r*rzSprite.rotationGs ~r)rcH||_|jfdz|jjdd<dSr)rrr)r;rs r*rzSprite.rotationPs-!)-(9A(="111%%%r)c|jS)zBase Scaling factor. A scaling factor of 1.0 (the default) has no effect. A scale of 2.0 will draw the sprite at twice the native size of its image. )rrBs r*rz Sprite.scaleUs {r)rc`||_||jz||jzfdz|jjdd<dSr)rrrrr)r;rs r*rz Sprite.scale^s< &+dm&;UT]=R%SVW%W"""r)c|jS)zHorizontal scaling factor. A scaling factor of 1.0 (the default) has no effect. A scale of 2.0 will draw the sprite at twice the native width of its image. )rrBs r*scale_xzSprite.scale_xc }r)rcj||_|j|z|j|jzfdz|jjdd<dSr)rrrrr)r;rs r*rzSprite.scale_xls> &*kG&;T[4==X%Y\]%]"""r)c|jS)zVertical scaling factor. A scaling factor of 1.0 (the default) has no effect. A scale of 2.0 will draw the sprite at twice the native height of its image. )rrBs r*scale_yzSprite.scale_yqrr)rcj||_|j|jz|j|zfdz|jjdd<dSr)rrrrr)r;rs r*rzSprite.scale_yzs? &*kDM&A4;QXCX%Y\]%]"""r) float | Nonecd}| ||_d}| ||_d}| ||_d}|r&|j|j|jfdz|jjdd<|'||jkr||_|fdz|jjdd<d} | ||_d} | ||_d} | ||_ d} | r2|j|jz|j|j zfdz|jj dd<dSdS)aSimultaneously change the position, rotation or scale. This method is provided for convenience. There is not much performance benefit to updating multiple Sprite attributes at once. Args: x: X coordinate of the sprite. y: Y coordinate of the sprite. z: Z coordinate of the sprite. rotation: Clockwise rotation of the sprite, in degrees. scale: Scaling factor. scale_x: Horizontal scaling factor. scale_y: Vertical scaling factor. .. deprecated:: 2.0.x No longer calculated with the vertices on the CPU. Now calculated within a shader. * Use ``x``, ``y``, ``z``, or ``position`` to update position. * Use ``rotation`` to update rotation. * Use ``scale_x``, ``scale_y``, or ``scale`` to update scale. FNTr) rkrlrmrrrrrrrr) r;rarcrdrrrrtranslations_outdatedscales_outdateds r*updatez Sprite.updates/>!& =DG$( ! =DG$( ! =DG$( !  M.2gtw-H1-LD  ' *  H$>$>%DN-5K!OD  &qqq )  DK"O  #DM"O  #DM"O  h*.+ *Et{UYUbGb)cfg)gD  #AAA & & & h hr)c|jjt|jzt|jz}|jr|nt |S)zGScaled width of the sprite. Invariant under rotation. )rrrabsrrrr2)r;ws r*rz Sprite.widthsC M #dm"4"4 4s4;7G7G GN.qqA.r)rcX||jjt|jzz |_dSr>)rrrrrr)r;rs r*rz Sprite.widths& 3c$+6F6F FG r)c|jjt|jzt|jz}|jr|nt |S)zHScaled height of the sprite. Invariant under rotation. )rrrrrrrr2)r;hs r*rz Sprite.heightsC M 3t}#5#5 5DK8H8H HN.qqA.r)rcX||jjt|jzz |_dSr>)rrrrrr)r;rs r*rz Sprite.heights&!5DK8H8H!HI r)c|jdS)aBlend opacity. This property sets the alpha component of the colour of the sprite's vertices. With the default blend mode (see the constructor), this allows the sprite to be drawn with fractional opacity, blending with the background. An opacity of 255 (the default) has no effect. An opacity of 128 will make the sprite appear translucent. rr]rBs r*opacityzSprite.opacitysz!}r)rcf|j\}}}}||||f|_|jdz|jjdd<dSrr]rr)r;rrgb_s r*rzSprite.opacitysAZ 1a1g% &*j1n ###r)c|jS)a?Blend color. This property sets the color of the sprite's vertices. This allows the sprite to be drawn with a color tint. The color is specified as either an RGBA tuple of integers '(red, green, blue, opacity)' or an RGB tuple of integers `(red, blue, green)`. If there are fewer than three components, a :py:func`ValueError` will be raised. Each color component must be an int in the range 0 (dark) to 255 (saturated). If any component is not an int, a :py:class:`TypeError` will be raised. rrBs r*colorz Sprite.colors zr)rgba0tuple[int, int, int, int] | tuple[int, int, int]c|^}}}}||||r|dndf}||jkr||_|dz|jjdd<dSdS)Nrr[rr)r;rrrra new_colors r*rz Sprite.colorsh 1a!q!Q/QqTTC/   " ""DJ*3a-D  $QQQ ' ' ' # "r)c|jS)z!True if the sprite will be drawn.)rrBs r*visiblezSprite.visible s }r)rc<||_|dSr>)rr)r;rs r*rzSprite.visibles!  r)c|jS)zPause/resume the Sprite's Animation. If ``Sprite.image`` is an Animation, you can pause or resume the animation by setting this property to True or False. If not an Animation, this has no effect. )_pausedrBs r*pausedz Sprite.pauseds |r)pausect|dr ||jkrdS|durtj|jnI|jj|j}|j|_ |j rtj |j|j ||_dS)NroT) hasattrrrrrvrorprrsrtru)r;rrs r*rz Sprite.paused!st\** et|.C.C F D==  T] + + + +O*4+<=E!NDM} B#DM4=AAA r)c|jS)zThe current Animation frame. If the ``Sprite.image`` is an ``Animation``, you can query or set the current frame. If not an Animation, this will always be 0. )rrBs r* frame_indexzSprite.frame_index.s   r)indexc |jdStdt|t|jjdz |_|jj|j}||jdS)aSet the current Animation frame. Args: index: The desired frame index. Updates the currently displayed frame of an animation immediately even if the animation is paused. If not an Animation, this has no effect. Nrr) rorrrrprrr rq)r;rrs r*rzSprite.frame_index7sy ? " F3uc$/2H.I.IA.M#N#NOO&t'89 %+113344444r)c|j|jt|jdS)zDraw the sprite at its current position. See the module documentation for hints on drawing multiple sprites efficiently. N)r~set_state_recursiverdrawrunset_state_recursiverBs r*rz Sprite.drawIsI ''))) |,,, ))+++++r)None | Literal[True]cdS)a The sprite animation reached the final frame. The event is triggered only if the sprite has an animation, not an image. For looping animations, the event is triggered each time the animation loops. :event: Nr(rBs r*rzSprite.on_animation_endVsr))r_r`rarbrcrbrdrbr1r2r3r2rerfrgr6rhrMr4rir r7rS)rrbr r7)r r)rrr r7r r)r4rr r7)r r)rerr r7)r r)rgrr r7)r r`)r_r`r r7)r0rr r7)r r)r r)r r)rrr r7)r rb)rarbr r7)rcrbr r7)rdrbr r7)rrbr r7)rrbr r7)rrbr r7)rrbr r7)NNNNNNN)rarrcrrdrrrrrrrrrr r7)rrbr r7)rrbr r7rT)rr2)r r\)rr)r rM)rrMr r7)rrMr r7)rr2r r7)r r )7rJrUrVrWryrorrrr]__annotations__rrrrrr/r^r r r:rrrvpropertyrsetterr4rergr rrrrr}rrarcrdrrrrrrrrrrrrr_is_pyglet_doc_runrr(r)r*rZrZs FJLGI';E;;;; FHHHL8CKBBBB!".#9'+'+"'15B#B#B#B#B#H 4444&111X1 [ [ [ [X ^ # # #^ #X \ ' ' '\ '   X  \[[[\[X \   \     8888:::: ==== s s s s)))X)_666_6XXCCCXCXXCCCXCXXCCCXCX_>>>_>X \XXX\XX ^^^^^^X ^^^^^^X\DHEIAhAhAhAhAhF///X/ \HHH\H///X/ ]JJJ]J   X  ^555^5 X" \888\8X ^   ^ X ]   ] !!!X!5555",,,,         r)rZrr )/rW __future__rsyswarningstypingrrrr$rrr r pyglet.glr r r rrrrrrrrrrpyglet.graphicsrrpyglet.graphics.shaderr pyglet.imagerrrrr rrr+r-r/EventDispatcherrZregister_event_typer(r)r*rsqAAAD#""""" 3333333333 000000000000                        WS"566P3;P?,,,,,,,,444444>>>>>>>>>>& &&&&P          SSSSYYYY?7?7?7?7?7(.?7?7?7Dh h h h h U "h h h V-.....r)