^ jdZddlmZddlZddlmZmZddlmZm Z m Z m Z ddl Z ddl mZddlmZmZmZmZmZmZmZddlmZmZdd lmZerdd lmZd Zd ZdGdZ dHdZ!dIdZ" dJdKd%Z#Gd&d'eZ$Gd(d)eZ%Gd*d+e%Z&Gd,d-e%Z'Gd.d/e%Z(Gd0d1e%Z)Gd2d3e%Z*Gd4d5e%Z+Gd6d7e%Z,Gd8d9e%Z-Gd:d;e%Z.e e/e e/e/ffZ0Gd<d=e j1j%Z2Gd>d?e%Z3Gd@dAe%Z4GdBdCe%Z5GdDdEe%Z6dFZ7dS)La2D shapes. This module provides classes for a variety of simplistic 2D shapes, such as Rectangles, Circles, and Lines. These shapes are made internally from OpenGL primitives, and provide excellent performance when drawn as part of a :py:class:`~pyglet.graphics.Batch`. Convenience methods are provided for positioning, changing color, opacity, and rotation. The Python ``in`` operator can be used to check whether a point is inside a shape. (This is approximated with some shapes, such as Star). If the shapes in this module don't suit your needs, you have two options: .. list-table:: :header-rows: 1 * - Your Goals - Best Approach * - Simple shapes like those here - Subclass :py:class:`ShapeBase` * - Complex & optimized shapes - See :ref:`guide_graphics` to learn about the low-level graphics API. A simple example of drawing shapes:: import pyglet from pyglet import shapes window = pyglet.window.Window(960, 540) batch = pyglet.graphics.Batch() circle = shapes.Circle(700, 150, 100, color=(50, 225, 30), batch=batch) square = shapes.Rectangle(200, 200, 200, 200, color=(55, 55, 255), batch=batch) rectangle = shapes.Rectangle(250, 300, 400, 200, color=(255, 22, 20), batch=batch) rectangle.opacity = 128 rectangle.rotation = 33 line = shapes.Line(100, 100, 100, 200, thickness=19, batch=batch) line2 = shapes.Line(150, 150, 444, 111, thickness=4, color=(200, 20, 20), batch=batch) star = shapes.Star(800, 400, 60, 40, num_spikes=20, color=(255, 255, 0), batch=batch) @window.event def on_draw(): window.clear() batch.draw() pyglet.app.run() .. note:: Some Shapes, such as :py:class:`.Line` and :py:class:`.Triangle`, have multiple coordinates. These shapes treat their :py:attr:`~ShapeBase.position` as their primary coordinate. Changing it or its components (the :py:attr:`~ShapeBase.x` or :py:attr:`~ShapeBase.y` properties) also moves all secondary coordinates by the same offset from the previous :py:attr:`~ShapeBase.position` value. This allows you to move these shapes without distorting them. .. versionadded:: 1.5.4 ) annotationsN)ABCabstractmethod) TYPE_CHECKINGSequenceTupleUnion)earcut)GL_BLENDGL_ONE_MINUS_SRC_ALPHA GL_SRC_ALPHA GL_TRIANGLES glBlendFunc glDisableglEnable)BatchGroup)Vec2) ShaderPrograma#version 150 core in vec2 position; in vec2 translation; in vec4 colors; in float zposition; in float rotation; out vec4 vertex_colors; uniform WindowBlock { mat4 projection; mat4 view; } window; mat4 m_rotation = mat4(1.0); mat4 m_translate = mat4(1.0); void main() { m_translate[3][0] = translation.x; m_translate[3][1] = translation.y; 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 * vec4(position, zposition, 1.0); vertex_colors = colors; } a#version 150 core in vec4 vertex_colors; out vec4 final_color; void main() { final_color = vertex_colors; // No GL_ALPHA_TEST in core, use shader to discard. if(final_color.a < 0.01){ discard; } } returnrchtjjtdft dfS)Nvertexfragment)pygletglcurrent_contextcreate_program vertex_sourcefragment_sourceH/home/agentuser/manim-venv/lib/python3.11/site-packages/pyglet/shapes.pyget_default_shaderr#s1 9 $ 3 3]H4M5Dj4Q S SSr!centertuple[float, float]pointanglefloatctj|d|dz |d|dz }||z}tj||}|d|tj|zz|d|tj|zzfSNr)mathatan2distcossin)r$r&r' prev_angle now_anglers r" _rotate_pointr4sE!Hvay0%(VAY2FGGJU"I %  A !9q48I... .q A@S@Sp2 will have the correct "miter" angle for each end respectively. This returns computed miter and scale values which can be supplied to the next call of the method for a minor performance improvement. If they are not supplied then they will be computed. Args: p0: The "previous" point for the segment p1->p2 which is used to compute the "miter" angle of the start of the segment. If None is supplied then the start of the line is 90 degrees to the segment p1->p2. p1: The origin of the segment p1->p2. p2: The end of the segment p1->p2 p3: The "following" point for the segment p1->p2 which is used to compute the "miter" angle to the end of the segment. If None is supplied then the end of the line is 90 degrees to the segment p1->p2. thickness: Thickness of the miter. prev_miter: The miter value to be used. prev_scale: The scale value to be used. rr+g@gr>) r normalizeyxmaxmindotr,r0acosZeroDivisionError)r?rArBrCrDrErGv_np1p2v_normalv_miter2scale1scale2v_miter1v_np0p1 v_normal_p0p1rOv_np2p3 v_normal_p2p3miter1_scaled_pmiter2_scaled_pv1v2v3v4v5v6s r" _get_segmentrds>2a52a5="Q%"Q%-00::<>@@giZ33  (*4mo 6RSS]]__ %dCW[[%:%:;;<>@@giZ33  (*4mo 6RSS]]__ %dCW[[%:%:;;< DNDO44444r!c`tt|jdSrt)rr rjunbindrvs r" unset_statez_ShapeGroup.unset_states*( r!otherGroup | _ShapeGroupc|j|juo?|j|jko/|j|jko|j|jko|j|jkSrt)rrrjrkrgri)rqr{s r"__eq__z_ShapeGroup.__eq__#s\4>14  -4 u|+4%/145#33  5r!cPt|j|j|j|jfSrt)hashrjrkrgrirvs r"__hash__z_ShapeGroup.__hash__*s!T\4;PQQQr!rt) rgrhrirhrjrrkrlrrmrrm)r{r|rrmrrh) __name__ __module__ __qualname____doc__rprwrzr~r __classcell__rrs@r"rfrfs %%%%%%%*5555 5555RRRRRRRRr!rfceZdZUdZdZdZded<dZded<dZded <dZ ded <dZ ded <dZ ded <dZ ded <dZ ded<dZded<dZded<dZded<dZeZded<eZded<eedddfdWd$ZdXd%ZdYd(ZdZd*ZdXd+ZdXd,ZdXd-ZedXd.Z e!d[d0Z"e"j#d\d2Z"e!d]d4Z$e$j#d^d5Z$e!d_d6Z%e%j#d`d8Z%dXd9Z&dXd:Z'e!d_d;Z(e(j#dad=Z(e!d_d>Z)e)j#dad?Z)e!d_d@Z*e*j#dadAZ*e!dbdBZ+e+j#dcdDZ+e!d_dEZ,e,j#dadFZ,e!d_dGZ-e-j#dadHZ-e!dbdIZ.e.j#dcdJZ.e!dddLZ/e/j#dedNZ/e!dfdOZ0e0j#dgdPZ0e!dhdQZ1e1j#didRZ1e!djdSZ2e2j#dkdTZ2e!dldUZ3e3j#dmdVZ3dS)n ShapeBaseaIBase class for all shape objects. A number of default shapes are provided in this module. Curves are approximated using multiple vertices. If you need shapes or functionality not provided in this module, you can write your own custom subclass of ``ShapeBase`` by using the provided shapes as reference. rrrr( _rotationTr7_visible_x_y_z _anchor_x _anchor_yN Batch | None_batchz_ShapeGroup | Group | None_grouprrh _num_vertsrl _user_group _draw_moder group_class vertex_countrgribatchgrouprjShaderProgram | Nonerrmc||_||_||_||_||_|p t |_||_| dS)a.Initialize attributes that all Shape object's require. Args: vertex_count: The amount of vertices this Shape object has. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch object. group: Optional group object. program: Optional ShaderProgram object. N) r _blend_src _blend_destrrr#_programget_shape_groupr_create_vertex_list)rqrrgrirrrjs r"rpzShapeBase.__init__Ksg0'#%  7#5#7#7 **,,    """""r!cX|j"|jd|_dSdSrt _vertex_listdeletervs r"__del__zShapeBase.__del__ls6   (   $ $ & & & $D    ) (r!r&r%c:td|jj)z'Test whether a point is inside a shape.z'The `in` operator is not supported for )NotImplementedErrorrrrrqr&s r" __contains__zShapeBase.__contains__qs!"eDNLc"e"efffr!_ShapeGroup | GroupcZ||j|j|j|jS)aCreates and returns a group to be used to render the shap[e. 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 )rrrrrrvs r"rzShapeBase.get_shape_groupus)1A4=RVRbcccr!cB|j|jz|jjdd<dS)a5Send the new colors for each vertex to the GPU. This method must set the contents of `self._vertex_list.colors` using a list or tuple that contains the RGBA color components for each vertex in the shape. This is usually done by repeating `self._rgba` for each vertex. N_rgbarrcolorsrvs r" _update_colorzShapeBase._update_colors''+j4?&B ###r!cP|j|jf|jz|jjdd<dSrt)rrrr translationrvs r"_update_translationzShapeBase._update_translations,,0GTW+=+O%aaa(((r!c td)aBuild internal vertex list. This method must create a vertex list and assign it to `self._vertex_list`. It is advisable to use it during `__init__` and to then update the vertices accordingly with `self._update_vertices`. While it is not mandatory to implement it, some properties ( namely `batch` and `group`) rely on this method to properly recreate the vertex list. zM_create_vertex_list must be defined in order to use group or batch propertiesrrvs r"rzShapeBase._create_vertex_lists""qrrrr!c td)aSGenerate up-to-date vertex positions & send them to the GPU. This method must set the contents of `self._vertex_list.vertices` using a list or tuple that contains the new vertex coordinates for each vertex in the shape. See the `ShapeBase` subclasses in this module for examples of how to do this. z=_update_vertices must be defined for every ShapeBase subclassrrvs r"_update_verticeszShapeBase._update_verticess""abbbr!tuple[int, int]c|j|jfS)zThe current blend mode applied to this shape. .. note:: Changing this can be an expensive operation as it involves a group creation and transfer. )rrrvs r" blend_modezShapeBase.blend_modes  000r!modesc\|\}}||jkr ||jkrdS||_||_||_|j3|j|j|j|j|jdS|j| dSrt) rrrrrmigraterrrr)rqrsrcdsts r"rzShapeBase.blend_modesS $/ ! !cT-=&=&= F**,, ; " K   14?DKQUQ\ ] ] ] ] ]   $ $ & & &  $ $ & & & & &r!rc|jS)zThe current shader program. .. note:: Changing this can be an expensive operation as it involves a group creation and transfer. )rrvs r"rjzShapeBase.program }r!c$|j|krdS||_||_|jr.|j|jt |j|rdS|j|dSrt) rrrr update_shaderrrrr)rqrjs r"rjzShapeBase.programs =G # # F **,, K  ))$*;\4;X_``  F   """   """""r!c|jS)aGet/set the shape's clockwise rotation in degrees. All shapes rotate around their :attr:`.anchor_position`. For most shapes, this defaults to both: * The shape's first vertex of the shape * The lower left corner Shapes with a ``radius`` property rotate around the point the radius is measured from. This will be either their center or the center of the circle they're cut from: These shapes rotate around their center: * :py:class:`.Circle` * :py:class:`.Ellipse` * :py:class:`.Star` These shapes rotate around the point of their angles: * :py:class:`.Arc` * :py:class:`.Sector` )rrvs r"rotationzShapeBase.rotations 4~r!rcH||_|f|jz|jjdd<dSrt)rrrr)rqrs r"rzShapeBase.rotations,!)1 do(E"111%%%r!c|j|j|j|jdS)aDebug method to draw a single shape at its current position. .. warning:: Avoid this inefficient method for everyday use! Regular drawing should add shapes to a :py:class:`Batch` and call its :py:meth:`~Batch.draw` method. N)rset_state_recursiverdrawrunset_state_recursivervs r"rzShapeBase.drawsK ''))) t/// ))+++++r!cX|j"|jd|_dSdS)a,Force immediate removal of the shape from video memory. You should usually call this whenever you no longer need the shape. Otherwise, Python may call the finalizer of the shape instance only some time after the shape has fallen out of scope, and the shape's video memory will not be freed until the finalizer is eventually called by garbage collection. Implementing manual garbage collection may satisfy the same concern without using the current method, but is a very advanced technique. Nrrvs r"rzShapeBase.deletes8   (   $ $ & & & $D    ) (r!c|jS)a&Get/set the X coordinate of the shape's :py:attr:`.position`. #. To update both :py:attr:`.x` and :py:attr:`.y`, use :attr:`.position` instead. #. Shapes may vary slightly in how they use :py:attr:`.position` See :py:attr:`.position` to learn more. )rrvs r"rLz ShapeBase.xs wr!valuec<||_|dSrt)rrrqrs r"rLz ShapeBase.x!!   """""r!c|jS)aYGet/set the Y coordinate of the shape's :py:attr:`.position`. This property has the following pitfalls: #. To update both :py:attr:`.x` and :py:attr:`.y`, use :py:attr:`.position` instead. #. Shapes may vary slightly in how they use :py:attr:`.position` See :attr:`.position` to learn more. )rrvs r"rKz ShapeBase.y&s wr!c<||_|dSrt)rrrs r"rKz ShapeBase.y4rr!c|jS)a?Get/set the Z coordinate of the shape. You must enable depth testing for this to have any effect. For example: create a custom parent :py:class:`~pyglet.graphics.Group` that enables and disables depth testing, and use that with all of your shapes that will have non-0 Z values. )rrvs r"zz ShapeBase.z9s wr!c>||_|f|jz|j_dSrt)rrr zpositionrs r"rz ShapeBase.zDs#',h&@###r!c|j|jfS)a<Get/set the ``(x, y)`` coordinates of the shape. .. tip:: This is more efficient than setting :py:attr:`.x` and :py:attr:`.y` separately! All shapes default to rotating around their position. However, the way they do so varies. Shapes with a ``radius`` property will use this as their center: * :py:class:`.Circle` * :py:class:`.Ellipse` * :py:class:`.Arc` * :py:class:`.Sector` * :py:class:`.Star` Others default to using it as their lower left corner. )rrrvs r"positionzShapeBase.positionIs*wr!valuescL|\|_|_|dSrt)rrrrqrs r"rzShapeBase.position`s(!   """""r!c|jS)zGet/set the X coordinate of the anchor point. If you need to set both this and :py:attr:`.anchor_x`, use :py:attr:`.anchor_position` instead. )rrvs r"anchor_xzShapeBase.anchor_xe ~r!c<||_|dSrt)rrrs r"rzShapeBase.anchor_xn! r!c|jS)zGet/set the Y coordinate of the anchor point. If you need to set both this and :py:attr:`.anchor_x`, use :py:attr:`.anchor_position` instead. )rrvs r"anchor_yzShapeBase.anchor_ysrr!c<||_|dSrt)rrrs r"rzShapeBase.anchor_y|rr!c|j|jfS)a6Get/set the anchor's ``(x, y)`` offset from :py:attr:`.position`. This defines the point a shape rotates around. By default, it is ``(0.0, 0.0)``. However: * Its behavior may vary between shape classes. * On many shapes, you can set the anchor or its components (:py:attr:`.anchor_x` and :attr:`.anchor_y`) to custom values. Since all anchor updates recalculate a shape's vertices on the CPU, this property is faster than updating :py:attr:`.anchor_x` and :py:attr:`.anchor_y` separately. )rrrvs r"anchor_positionzShapeBase.anchor_positions~t~--r!cL|\|_|_|dSrt)rrrrs r"rzShapeBase.anchor_positions()/& r!tuple[int, int, int, int]c|jS)aGet/set the shape's color. The color may set to: - An RGBA tuple of integers ``(red, green, blue, alpha)`` - An RGB tuple of integers ``(red, green, blue)`` If an RGB color is set, the current alpha will be preserved. Otherwise, the new alpha value will be used for the shape. Each color component must be in the range 0 (dark) to 255 (saturated). rrvs r"colorzShapeBase.colors zr!0tuple[int, int, int, int] | tuple[int, int, int]c|^}}}}|r||||df|_n||||jdf|_|dSNrrr)rqrr3gbas r"rzShapeBase.colors\  1a!  0Aq!A$DJJAq$*Q-/DJ r!c|jdS)aGet/set the blend opacity of the shape. .. tip:: To toggle visibility on/off, :py:attr:`.visible` may be more efficient! Opacity is implemented as the alpha component of a shape's :py:attr:`.color`. When part of a group with a default blend mode of ``(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)``, opacities below ``255`` draw with fractional opacity over the background: .. list-table:: Example Values & Effects :header-rows: 1 * - Opacity - Effect * - ``255`` (Default) - Shape is fully opaque * - ``128`` - Shape looks translucent * - ``0`` - Invisible rrrvs r"opacityzShapeBase.opacitys8z!}r!c`g|jdd|R|_|dS)Nrrrs r"rzShapeBase.opacitys8-tz"1"~-u--  r!c|jS)zhGet/set whether the shape will be drawn at all. For absolute showing / hiding, this is )rrvs r"visiblezShapeBase.visiblerr!c<||_|dSrt)rrrs r"rzShapeBase.visibles!  r!c|jS)a-Get/set the shape's :class:`Group`. You can migrate a shape from one group to another by setting this property. Note that it can be an expensive (slow) operation. If :py:attr:`.batch` isn't ``None``, setting this property will also trigger a batch migration. )rrvs r"rzShapeBase.groups r!c|j|krdS||_||_|jr3|j|j|j|j|jdSdSrt)rrrrrrr)rqrs r"rzShapeBase.groupst  u $ $ F **,, ; ^ K   14?DKQUQ\ ] ] ] ] ] ^ ^r!c|jS)aOGet/set the :py:class:`Batch` for this shape. .. warning:: Setting this to ``None`` currently breaks things! Known issues include :py:attr:`.group` breaking. You can migrate a shape from one batch to another by setting this property, but it can be an expensive (slow) operation. )rrvs r"rzShapeBase.batchs {r!c|j|krdS|<|j5|j|j|j|j|||_dS|j||_|dSrt)rrrrrrr)rqrs r"rzShapeBase.batchs ;%   F  !8 K   14?DKQV W W WDKKK   $ $ & & &DK  $ $ & & & & &r!)rrhrgrhrirhrrrrlrjrrrmrr&r%rr7)rr)rr)rrrrmrr)rjrrrmrr()rr(rrmrr(rrm)rr%)rr%rrmrrrrrrmrrrhrrm)rr7)rr7rrm)rrl)rrrrm)rr)rrrrm)4rrrrrr__annotations__rrrrrrrrrrrrrrfrr r rprrrrrrrrpropertyrsetterrjrrrrLrKrrrrrrrrrrr r!r"rr.s !EIHBOOOOBOOOOBOOOOIIF)-F----J $K$$$$L"J""""$K$$$$#/#9'+'+15 #####B%%%% gggg d d d dCCCCPPPP s s s sccc^c111X1 ' ' ' 'X ^ # # #^ #X6_FFF_F , , , ,%%%%    X X###X#   X X###X#XXAAAXA   X ,_###_#X_   _ X_   _ ...X.        X  \   \ X: ^^X ^   ^     X   \^^^\^   X  \ ' ' '\ ' ' 'r!rc 8eZdZddddddeedddf d-fd Zd.d Zd/d"Zd.d#Ze d0d$Z e j d1d&Z e d0d'Z e j d2d(Z e d0d)Z e j d1d*Z e d0d+Zej d3d,ZxZS)4ArcNv@rFr>rrLr(rKradiussegments int | Noner' start_angleclosedr7rDrrrgrhrirrrrlrjrrrmc||_||_d|_||_|pt dt |dz |_| ^}}}}||||r|dndf|_||_||_ ||_ ttj |j z dkr|nd|_d|_t!|jdz|jrdndz| | | | |d S) awCreate an Arc. The Arc's anchor point (x, y) defaults to its center. Args: x: X coordinate of the circle. y: Y coordinate of the circle. radius: The desired radius. segments: You can optionally specify how many distinct line segments the arc should be made from. If not specified it will be automatically calculated using the formula: ``max(14, int(radius / 1.25))``. angle: The angle of the arc, in degrees. Defaults to 360.0, which is a full circle. start_angle: The start angle of the arc, in degrees. Defaults to 0. closed: If ``True``, the ends of the arc will be connected with a line. defaults to ``False``. thickness: The desired thickness or width of the line used for the arc. color: The RGB or RGBA color of the arc, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. r?rr& .>FN)rrr_radiusrMrh _segmentsr _thickness_angle _start_angleabsr,tau_closedrrorp)rqrLrKrrr'rrrDrrgrirrrjr3rrrrrs r"rpz Arc.__init__sr !@SS$-?-?%@%@ 1a!1a0addS0 # '!$TX %;!? 6AAr!Sequence[float]c @ |js d|jzS|j |j |j t j|j|jz t j|j |j z  fdt|jdzD}g}d}d}tt|dz D]}d}d}|dkr ||dz }n=|j r |d}n-t|jt jz dkr|d}|dzt|kr ||dz}n=|j r |d}n-t|jt jz dkr|d}t!|||||dz||j||^}}}|||j red}d}t|dkr|d}|d}t!||d|d||j||^}}}|||S) Nrrc g|]B}tj|zzzztj|zzzzfCSr r,r/r0.0r;r3segment_radians start_radiansrLrKs r" z%Arc._get_vertices..ytrrrRSDHa/&9]%JKKKLDHa/&9]%JKKKLNrrrr!r+rr)rrrrrr,radiansrrrrranger9r!rr rdrextend)rqpointsverticesrErGr; prev_point next_pointsegmentr3r2r3rLrKs @@@@@r"r)zArc._get_verticesns} ,DO+ + ^O ^O L,t{33dnD T%6%GHH rrrrrrrrW\]a]kno]oWpWprrr  s6{{Q'' % %AJJ1uu#AE]  (#BZ T[48+,,44#BZ 1us6{{""#AE]  '#AY T[48+,,44#AY /;Jq SYZ[^_Z_S`bl<@OZYc0e0e ,J W OOG $ $ $ $ < %JJ6{{Q#BZ #AY /;Jr TZ[\T]_i<@OZYc0e0e ,J W OOG $ $ $r!cL||jjdd<dSrtr)rrrvs r"rzArc._update_vertices((,(:(:(<(<"111%%%r!c|jS)zGet/set the radius of the arc.rrvs r"rz Arc.radius |r!rc<||_|dSrtrrrs r"rz Arc.radius!  r!c|jS)z!Get/set the thickness of the Arc.rrvs r"rDz Arc.thickness r!c<||_|dSrtrrrqrDs r"rDz Arc.thickness!# r!c|jS)z!The angle of the arc, in degrees.rrvs r"r'z Arc.angle {r!c<||_|dSrtrrrs r"r'z Arc.angle!  r!c|jS)z'The start angle of the arc, in degrees.rrvs r"rzArc.start_angle   r!c<||_|dSrtrrrqr's r"rzArc.start_angle"! r!)rLr(rKr(rr(rrr'r(rr(rr7rDr(rrrgrhrirhrrrrlrjrrrmrrr+rrrDr(rrmr'r(rrm)rrrr r rprr)rr rr rDr'rrrs@r"rrs $( !$ "FZ)4"&"&,0N N N N N N N `AAAA1111f====X ]   ] X    X \   \ !!!X!        r!rc eZdZddddeedddd d(fdZd)dZd*dZd+dZd*dZ e d,d!Z e j d-d#Z e d.d$Z e j d/d%Z e d.d&Zej d0d'ZxZS)1 BezierCurver>drN) trrDrrgrirrrjr<r%rdr(rrhrDrrrgrirrrrlrjrrrmc  t| |_|jd\|_|_||_||_||_|^} } } }| | | |r|dndf|_t |jdz||||| dS)u2Create a Bézier curve. The curve's anchor point (x, y) defaults to its first control point. Args: points: Control points of the curve. Points can be specified as multiple lists or tuples of point pairs. Ex. (0,0), (2,3), (1,9) t: Draw `100*t` percent of the curve. 0.5 means the curve is half drawn and 1.0 means draw the whole curve. segments: You can optionally specify how many line segments the curve should be made from. thickness: The desired thickness or width of the line used for the curve. color: The RGB or RGBA color of the curve, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrrN) list_pointsrr_trrrrorp)rqrdrrDrrgrirrrjr<r3rrrrrs r"rpzBezierCurve.__init__sXF|| <?!# 1a!1a0addS0   NQ  z5%     r! list[float]cDt|jdz }ddg}t|dzD]q}tj||d|z ||z zz||zz}|dxx||j|dzz cc<|dxx||j|dzz cc<r|Sr*)r9rgr:r,comb)rqrdnpr;ms r" _make_curvezBezierCurve._make_curves    ! Fq1u + +A !Q1q5a!e"44qAv=A aDDDA Q** *DDD aDDDA Q** *DDDDr!c |j|j|j|j|jd|fd|j|jzfd|j|j f|jzfd|j f|jzf|_ dSr#r'rvs r"rzBezierCurve._create_vertex_listr*r!r+c V js djzSj jz j jz fdt jdzD}|d\ jz jz fd|D}g}d}d}t t|dz D]y}d}d}|dkr ||dz }|dzt|kr ||dz}t|||||dz|j ||^}}} | | z|S)Nr-cg|]^}j|zjz dzj|zjz dzf_S)rr+)rorhr)r1rdrqrLrKs r"r4z-BezierCurve._get_vertices..!snnnNOt''! dn(DEEaHHt''! dn(DEEaHHJnnnr!r+rc*g|]\}}|z |z gSr r r1rLrKtrans_xtrans_ys r"r4z-BezierCurve._get_vertices..&s*@@@A1w;G ,@@@r!r8) rrrrrrr:rr9rdrr;)rqr<coordsr=rErGr;r>r?r@rurvrLrKs` @@@@r"r)zBezierCurve._get_verticess} ,DO+ + ^Odg % ^Odg %nnnnnnSXY]YgjkYkSlSlnnn!!94>!4>!@@@@@@@@  s6{{Q'' % %AJJ1uu#AE] 1us6{{""#AE] /;Jq SYZ[^_Z_S`bl<@OZYc0e0e ,J W OOG $ $ $ $r!cL||jjdd<dSrtrBrvs r"rzBezierCurve._update_vertices;rCr!list[tuple[float, float]]c|jS)u0Get/set the control points of the Bézier curve.)rgrvs r"r<zBezierCurve.points>rFr!rc<||_|dSrt)rgrrs r"r<zBezierCurve.pointsCrIr!c|jS)z8Get/set the t in ``100*t`` percent of the curve to draw.)rhrvs r"rdz BezierCurve.tH wr!c<||_|dSrt)rhrrs r"rdz BezierCurve.tM! r!c|jS)u1Get/set the line thickness for the Bézier curve.rKrvs r"rDzBezierCurve.thicknessRrLr!c<||_|dSrtrNrOs r"rDzBezierCurve.thicknessWrPr!)r<r%rdr(rrhrDrhrrrgrhrirhrrrrlrjrrrm)rdr(rrirr^)rry)rryrrmrrr_)rrrr r rprorr)rr r<r rdrDrrs@r"rbrbs  FZ)4"&"&,07 7 7 7 7 7 7 7 rAAAA    D====X ]   ] XX   X X        r!rbceZdZddeedddfd"fd Zd#dZd$dZd%dZd$dZ e d&dZ e j d'd!Z xZ S)(CircleNrrLr(rKrrrrrrgrhrirrrrlrjrrrmc  ||_||_d|_||_|pt dt |dz |_|^} } } }| | | |r|dndf|_t |jdz|||| | dS)aCreate a circle. The circle's anchor point (x, y) defaults to the center of the circle. Args: x: X coordinate of the circle. y: Y coordinate of the circle. radius: The desired radius. segments: You can optionally specify how many distinct triangles the circle should be made from. If not specified it will be automatically calculated using the formula: `max(14, int(radius / 1.25))`. color: The RGB or RGBA color of the circle, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrrrrrN) rrrrrMrhrrrorp)rqrLrKrrrrgrirrrjr3rrrrrs r"rpzCircle.__init___sV !@SS$-?-?%@%@ 1a!1a0addS0   NQ  z5%     r!r&r%r7ct|dksJtj|j|jz |j|jz f||jkSNr8)r9r,r.rrrrrrs r"rzCircle.__contains__sG5zzQy$'DN2DGdn4LMuUUX\Xdddr!c |j|jdz|j|j|jd|fd|j|jzfd|j |j f|jzfd|j f|jzf|_ dSNrr$r%r& rr(rrrrr)rrrrrrrvs r"rzCircle._create_vertex_list M55 NQ dk4--//0$*t67tw04?BCDN,t>? 6AAr!r+cN |js d|jzS|j |j |jt jdz|jz  fdt|jD}g}t|D],\}} g||dz |R}| |-|S)Nr-r8c g|]<}tj|zzztj|zzzf=Sr r/)r1r;r3tau_segsrLrKs r"r4z(Circle._get_vertices..sgUUU9:DHQ\2223DHQ\22235UUUr!r+) rrrrrr,pirr: enumerater;) rqr<r=r;r&triangler3rrLrKs @@@@r"r)zCircle._get_verticess} ,DO+ + ^O ^O L7Q;/UUUUUUU>CDN>S>SUUU!&)) & &HAu!3fQUm3e33H OOH % % % %r!cL||jjdd<dSrtrBrvs r"rzCircle._update_verticesrCr!c|jS)zGets/set radius of the circle.rErvs r"rz Circle.radiusrFr!rc<||_|dSrtrHrs r"rz Circle.radiusrIr!)rLr(rKr(rr(rrrrrgrhrirhrrrrlrjrrrmrrr^rr)rrrr r rprrr)rr rr rrs@r"rr]s $(FZ)4"&"&,06 6 6 6 6 6 6 peeeeAAAA*====X ]   ]     r!rceZdZddeedddfd%fd Zd&dZd'dZd(dZd'dZ e d)d Z e j d*d"Z e d)d#Z e j d*d$Z xZS)+EllipseNrrLr(rKrrrrrrrgrhrirrrrlrjrrrmc <||_||_d|_||_||_|^} } }}| | ||r|dndf|_d|_|ptt||dz |_ t |j dz||| | | dS)aCreate an ellipse. The ellipse's anchor point ``(x, y)`` defaults to the center of the ellipse. Args: x: X coordinate of the ellipse. y: Y coordinate of the ellipse. a: Semi-major axes of the ellipse. b: Semi-minor axes of the ellipse. segments: You can optionally specify how many distinct line segments the ellipse should be made from. If not specified it will be automatically calculated using the formula: ``int(max(a, b) / 1.25)``. color: The RGB or RGBA color of the ellipse, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrrrrN) rrr_a_brrrhrMrrorp)rqrLrKrrrrrgrirrrjcolor_rcolor_gcolor_bcolor_arrs r"rpzEllipse.__init__s\/4+'Ggwg0N 3N !:SQT)9%:%:  NQ  z5%     r!r&r%r7clt|dksJt|j|jf|t j|j}|j|jz |dz|df}|j|jz |j|j z z|j|j z f}t j |||jkSNr8rr+) r9r4rrr,r9rrrrrr.)rqr& shape_centers r"rzEllipse.__contains__ s5zzQtw0%dn9U9UVV47"U1X-uQx8$')TWt~-EFRVR`H`a yu--77r!c |j|jdz|j|j|jd|fd|j|jzfd|j |j f|jzfd|j f|jzf|_ dSrrrvs r"rzEllipse._create_vertex_listrr!r+c@js djzSj j tjdzjz fdtjD}g}t|D],\}}g||dz |R}| |-|S)Nr-r8c g|]F}jtj|zzzjtj|zzzfGSr )rr,r/rr0)r1r;rqrrLrKs r"r4z)Ellipse._get_vertices..#skYYY=>tw!h,!7!777tw!h,!7!7779YYYr!r+) rrrrr,rrr:rr;) rqr<r=r;r&rrrLrKs ` @@@r"r)zEllipse._get_verticess} ,DO+ + ^O ^O7Q;/YYYYYYYBGBWBWYYY!&)) & &HAu!3fQUm3e33H OOH % % % %r!cL||jjdd<dSrtrBrvs r"rzEllipse._update_vertices.rCr!c|jS)z+Get/set the semi-major axes of the ellipse.)rrvs r"rz Ellipse.a1r}r!rc<||_|dSrt)rrrs r"rz Ellipse.a6rr!c|jS)z+Get/set the semi-minor axes of the ellipse.)rrvs r"rz Ellipse.b;r}r!c<||_|dSrt)rrrs r"rz Ellipse.b@rr!)rLr(rKr(rr(rr(rrrrrgrhrirhrrrrlrjrrrmrrr^rr)rrrr r rprrr)rr rr rrrs@r"rrs2 $(FZ)4"&"&,0? ? ? ? ? ? ? B8888AAAA(====XX   X XX   X     r!rc eZdZddddeedddf d*fd Zd+dZd,dZd-d!Zd,d"Z e d.d#Z e j d/d%Z e d.d&Z e j d0d'Z e d.d(Zej d/d)ZxZS)1SectorNrrrrLr(rKrrrr'rrrrgrhrirrrrlrjrrrmc J||_||_d|_||_|pt dt |dz |_|^} }}}| |||r|dndf|_||_||_ d|_ t |jdz|| | | | dS)aCreate a Sector of a circle. By default, ``(x, y)`` is used as: * The sector's anchor point * The center of the circle the sector is cut from Args: x: X coordinate of the sector. y: Y coordinate of the sector. radius: The desired radius. segments: You can optionally specify how many distinct triangles the sector should be made from. If not specified it will be automatically calculated using the formula: `max(14, int(radius / 1.25))`. angle: The angle of the sector, in degrees. Defaults to 360, which is a full circle. start_angle: The start angle of the sector, in degrees. Defaults to 0. color: The RGB or RGBA color of the circle, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrrrrrN) rrrrrMrhrrrrrrorp)rqrLrKrrr'rrrgrirrrjr3rrrrrs r"rpzSector.__init__Hsh !@SS$-?-?%@%@ 1a!1a0addS0  '  NQ  z5%     r!r&r%r7ct|dksJt|j|jf|t j|j}t j|j|jz |j|j z f||j krdSt j t j |d|jz |j z|d|jz |jz}|dz}|j dz}||jzdz}|jdkr"||kr||cxko|kncS||kp||kS||kr||cxko|kncS||kp||kS)Nr8Fr+rih)r9r4rrr,r9rr.rrrdegreesr-rr)rqr&r'r end_angles r"rzSector.__contains__sn5zzQtw0%dn9U9UVV 9dg.$.0HI5 Q QTXT` ` `5 TZa47(:T^(KUSTXX\X_M_bfbpMpqqrr '#-  4;.#5 ;!  i''"e8888y88888 +Au /AAK'' E8888[88888 )AUk-AAr!c |j|j|j|j|jd|fd|j|jzfd|j|j f|jzfd|j f|jzf|_ dSr#r'rvs r"rzSector._create_vertex_listr*r!r+c |js d|jzS|j |j |jt j|j|jz t j|j  fdt|jdzD}g}t|dddD],\}} g||dz |R}| |-|S)Nr-c g|]B}tj|zzzztj|zzzzfCSr r/r0s r"r4z(Sector._get_vertices..r5r!r+)start) rrrrrr,r9rrrr:rr;) rqr<r=r;r&rr3r2r3rLrKs @@@@@r"r)zSector._get_verticess"} ,DO+ + ^O ^O L,t{33dnD T%677 rrrrrrrrW\]a]kno]oWpWprrr!&*A666 & &HAu!3fQUm3e33H OOH % % % %r!cL||jjdd<dSrtrBrvs r"rzSector._update_verticesrCr!c|jS)z$The angle of the sector, in degrees.rRrvs r"r'z Sector.anglerSr!rc<||_|dSrtrUrs r"r'z Sector.anglerVr!c|jS)z*The start angle of the sector, in degrees.rXrvs r"rzSector.start_anglerYr!c<||_|dSrtr[r\s r"rzSector.start_angler]r!c|jS)zGet/set the radius of the sector. By default, this is in screen pixels. Your drawing / GL settings may alter how this is drawn. rErvs r"rz Sector.radius |r!c<||_|dSrtrHrs r"rz Sector.radiusrIr!)rLr(rKr(rr(rrr'r(rr(rrrgrhrirhrrrrlrjrrrmrrr^rrr`)rrrr r rprrr)rr r'r rrrrs@r"rrFs $( !$FZ)4"&"&,0D D D D D D D LBBBB(AAAA,====X \   \ !!!X!    X ]   ]     r!rceZdZddeedddfd'fd Zd(dZd)dZd*dZd)dZ e d+d Z e j d,d!Z e d+d"Z e j d-d$Z e d+d%Zej d-d&ZxZS).Liner>rNrLr(rKx2y2rDrrrgrhrirrrrlrjrc ||_||_d|_||_||_||_d|_|^} } }}| | ||r|dndf|_t d||| | | dS)auCreate a line. The line's anchor point defaults to the center of the line's thickness on the X axis, and the Y axis. Args: x: The first X coordinate of the line. y: The first Y coordinate of the line. x2: The second X coordinate of the line. y2: The second Y coordinate of the line. thickness: The desired width of the line. color: The RGB or RGBA color of the line, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrrrN) rrr_x2_y2rrrrorp)rqrLrKrrrDrrgrirrrjr3rrrrrs r"rpz Line.__init__sT# 1a!1a0addS0  9j%HHHHHr!r&r%rr7ct|dksJt|j|jz |j|jz }t|j|jz |j|jz }t|d|jz |jz |d|jz |jz}t|d|jz |jz |d|jz |jz}||||zdkrdS|d|jz|d|jz }}|j|j|j|jf\}} } } t|| z|| zz|| zz| | zz || zz ||zz } | tj |j|jf|j|jfz } | |j dz kS)Nr8rr+F) r9rrrrrrrrOrr,r.r)rqr&vec_abvec_bavec_apvec_bprrx1y1rr double_areahs r"rzLine.__contains__ s5zzQdh($(TW*<==dg($'DH*<==eAh(4>958dg;MPTP^;^__eAh)DN:E!Htx? 6AAr!r+c ||js d|jzSd}|j dz }|tj|j|jz |j|jz z}||jz}tj |j|jz |j|jz }tj |}tj |}|j }|j } ||z||zz |z } ||z||zz| z } ||z||zz |z } ||z||zz| z } ||z||zz |z }||z||zz| z }||z||zz |z }||z||zz| z }| | | | ||| | ||||f S)Nr-rr8)rrrr,hypotrrrrr-r/r0rr)rqrrrrr3crsrrraxaybxbycxcydxdys r"r)zLine._get_vertices9s} ,DO+ + o  ! $*TX/DG1CDD D $/ ! Jtx$')48dg+= > > Xa[[ Xa[[>> "WrBw  ) "WrBw  ) "WrBw  ) "WrBw  ) "WrBw  ) "WrBw  ) "WrBw  ) "WrBw  )2r2r2r2r2r2==r!cL||jjdd<dSrtrBrvs r"rzLine._update_verticesRrCr!c|jS)zThe thickness of the line.rKrvs r"rDzLine.thicknessUrLr!c<||_|dSrtrNrOs r"rDzLine.thicknessZrPr!c|jS)z)Get/set the 2nd X coordinate of the line.)rrvs r"rzLine.x2_ xr!rc<||_|dSrtrrrs r"rzLine.x2d! r!c|jS)z)Get/set the 2nd Y coordinate of the line.)rrvs r"rzLine.y2irr!c<||_|dSrtrrrs r"rzLine.y2nrr!)rLr(rKr(rr(rr(rDr(rrrgrhrirhrrrrlrjrrrr^rr_r)rrrr r rprrr)rr rDr rrrrs@r"rrs} #FZ)4"&"&,06I6I6I6I6I6I6Ip''''"AAAA>>>>2====X    XY   Y XY   Y     r!rceZdZdeedddfd#fd Zd$dZd%dZd&dZd%dZ e d'dZ e j d(d Z e d'd!Z e j d(d"Z xZS)) RectanglerNrLr(rKwidthheightrrrgrhrirrrrlrjrc ||_||_d|_||_||_d|_|^} } } }| | | |r|dndf|_td|||| | dS)a1Create a rectangle or square. The rectangle's anchor point defaults to the ``(x, y)`` coordinates, which are at the bottom left. Args: x: The X coordinate of the rectangle. y: The Y coordinate of the rectangle. width: The width of the rectangle. height: The height of the rectangle. color: The RGB or RGBA color of the circle, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrrrN) rrr_width_heightrrrorp)rqrLrKrrrrgrirrrjr3rrrrrs r"rpzRectangle.__init__vsP   1a!1a0addS0  Iz5%IIIIIr!r&r%rr7cHt|dksJt|j|jf|t j|j}|j|jz |j|jz }}||dcxko ||j zknco||dcxko ||j zkncSr r9r4rrr,r9rrrrrrqr&rLrKs r"rzRectangle.__contains__5zzQtw0%dn9U9UVVw'4>)A158----a$+o----Q!eAh2Q2Q2Q2QT\AQ2Q2Q2Q2QQr!rmc |jd|j|j|jd|fd|j|jzfd|j|j f|jzfd|j f|jzf|_ dSrrrvs r"rzRectangle._create_vertex_listrr!r+c |js d|jzS|j }|j }||jz}||jz}||||||||||||f SNr-)rrrrrr)rqrrrrs r"r)zRectangle._get_verticessc} BDO+ +.B.Bdk!Bdl"Br2r2r2r2r2rA Ar!cL||jjdd<dSrtrBrvs r"rzRectangle._update_verticesrCr!c|jSzGet/set width of the rectangle. The new left and right of the rectangle will be set relative to its :py:attr:`.anchor_x` value. rrvs r"rzRectangle.width {r!rc<||_|dSrtrrrs r"rzRectangle.widthrVr!c|jSzGet/set the height of the rectangle. The bottom and top of the rectangle will be positioned relative to its :py:attr:`.anchor_y` value. rrvs r"rzRectangle.heightrr!c<||_|dSrtrrrs r"rzRectangle.heightrIr!)rLr(rKr(rr(rr(rrrgrhrirhrrrrlrjrrrr^rr)rrrr r rprrr)rr rr rrrs@r"rrts@ G[)4"&"&,02J2J2J2J2J2J2JhRRRR AAAA B B B B====X \   \ X ]   ]     r!rc|eZdZdddeedddfd1fd Zd2dZd3dZd3dZd4d!Z d3d"Z e d5d#Z e j d6d%Z e d5d&Zej d7d(Ze d5d)Zej d7d*Ze d8d,Zej d9d.Ze d:d/Zej d9d0ZxZS);BorderedRectangler>)rrr)rcrcrcNrLr(rKrrborderrr border_colorrgrhrirrrrlrjrc r||_||_d|_||_||_d|_||_|^} }}}|^}}}}d}|r#|r!|d|dkrtd|r |d}n |r|d}| |||f|_||||f|_ t d|| | | | dS)aMCreate a bordered rectangle. The rectangle's anchor point defaults to the ``(x, y)`` coordinates, which are at the bottom left. Args: x: The X coordinate of the rectangle. y: The Y coordinate of the rectangle. width: The width of the rectangle. height: The height of the rectangle. border: The thickness of the border. color: The RGB or RGBA fill color of the rectangle, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. border_color: The RGB or RGBA fill color of the border, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. The alpha values must match if you pass RGBA values to both this argument and `border_color`. If they do not, a `ValueError` will be raised informing you of the ambiguity. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrrzUWhen color and border_color are both RGBA values,they must both have the same opacityN) rrrrrr_border ValueErrorr _border_rgbarorp)rqrLrKrrrrrrgrirrrjfill_rfill_gfill_bfill_aborder_rborder_gborder_bborder_aalpharrs r"rpzBorderedRectangle.__init__sh   */'2>/(Hx  h 6!9 #;#;DEE E 1IEE  QKE VVU2 $h%? Iz5%IIIIIr!r&r%rr7cHt|dksJt|j|jf|t j|j}|j|jz |j|jz }}||dcxko ||j zknco||dcxko ||j zkncSrrrs r"rzBorderedRectangle.__contains__9rr!rmc gd}|jd|j||j|jd|fd|jdz|jdzzfd|j|j f|j zfd|j f|j zf |_ dS)N)rr+r8rr8rrrrrrr+rrrr+r8rrr8rrr8rrrrrr$r%rr&) rvertex_list_indexedrrrr)rrrrrrrrqindicess r"rz%BorderedRectangle._create_vertex_list?slll M== tdk4--//0$*q.4+? >AAr!cN|jdz|jdzz|jjdd<dS)Nr)rrrrrvs r"rzBorderedRectangle._update_colorHs/&*j1nt7H17L&L ###r!r+c|js d|jzS|j }|j }||jz}||jz}|j}||z}||z}||z }||z } |||||| || ||||||||fSr)rrrrrrr) rqbx1by1bx2by2rix1iy1ix2iy2s r"r)zBorderedRectangle._get_verticesKs} ,DO+ +~o~oDKDL  LAgAgAgAgS#sCc3S#sCc38 8r!cL||jjdd<dSrtrBrvs r"rz"BorderedRectangle._update_vertices\rCr!c|jS)zThe border thickness of the bordered rectangle. This extends inward from the edge of the rectangle toward the center. )rrvs r"rzBorderedRectangle.border_rr!rDc<||_|dSrt)rrrOs r"rzBorderedRectangle.borderhs!   r!c|jS)zGet/set width of the bordered rectangle. The new left and right of the rectangle will be set relative to its :py:attr:`.anchor_x` value. rrvs r"rzBorderedRectangle.widthmrr!rc<||_|dSrtrrs r"rzBorderedRectangle.widthvrVr!c|jS)zGet/set the height of the bordered rectangle. The bottom and top of the rectangle will be positioned relative to its :py:attr:`.anchor_y` value. rrvs r"rzBorderedRectangle.height{rr!c<||_|dSrtrrs r"rzBorderedRectangle.heightrIr!rc|jS)aGet/set the bordered rectangle's border color. To set the color of the interior fill, see :py:attr:`.color`. You can set the border color to either of the following: * An RGBA tuple of integers ``(red, green, blue, alpha)`` * An RGB tuple of integers ``(red, green, blue)`` Setting the alpha on this property will change the alpha of the entire shape, including both the fill and the border. Each color component must be in the range 0 (dark) to 255 (saturated). )rrvs r"rzBorderedRectangle.border_colors   r!rc|^}}}}|r |d}n |jd}||||f|_g|jdd|R|_|dSrrrrrqrr3rrrrs r"rzBorderedRectangle.border_colorsu  1a!  "aDEEJqMEq!UN+dj!n+e++  r!c|jS)a6Get/set the bordered rectangle's interior fill color. To set the color of the border outline, see :py:attr:`.border_color`. The color may be specified as either of the following: * An RGBA tuple of integers ``(red, green, blue, alpha)`` * An RGB tuple of integers ``(red, green, blue)`` Setting the alpha through this property will change the alpha of the entire shape, including both the fill and the border. Each color component must be in the range 0 (dark) to 255 (saturated). rrvs r"rzBorderedRectangle.colors $zr!c|^}}}}|r |d}n |jd}||||f|_g|jdd|R|_|dSrr,r-s r"rzBorderedRectangle.colorsw  1a!  "aDEEJqME1e^ 9T.rr29E99 r!)rLr(rKr(rr(rr(rr(rrrrrgrhrirhrrrrlrjrrrr^rr_rrr)rr)rrrr r rprrrr)rr rr rrrrrrs@r"rrs'  FUM\)4"&"&,0RJRJRJRJRJRJRJhRRRR AAAAMMMM8888"====X ]   ] X \   \ X ]   ] !!!X!" X& \   \     r!rceZdZddeedddfd(fd Zd)dZd*dZdZd+dZ d*d Z e d,d!Z e j d-d#Z e d,d$Zej d-d%Ze d,d&Zej d.d'ZxZS)/Boxr>rNrLr(rKrrrDrrrgrhrirrrrlrjrrrmc ||_||_d|_||_||_||_|^} } }}| | ||r|dndf|_td||| | | dS)a Create an unfilled rectangular shape, with optional thickness. The box's anchor point defaults to the ``(x, y)`` coordinates, which are placed at the bottom left. Changing the thickness of the box will extend the walls inward; the outward dimensions will not be affected. Args: x: The X coordinate of the box. y: The Y coordinate of the box. width: The width of the box. height: The height of the box. thickness: The thickness of the lines that make up the box. color: The RGB or RGBA color of the box, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrrrN) rrrrrrrrorp)rqrLrKrrrDrrgrirrrjr3rrrrrs r"rpz Box.__init__sZ  # 1a!1a0addS0  Iz5%IIIIIr!r&r%r7cHt|dksJt|j|jf|t j|j}|j|jz |j|jz }}||dcxko ||j zknco||dcxko ||j zkncSrrrs r"rzBox.__contains__ rr!c gd}|j|j|j||j|jd|fd|j|jzfd|j|j f|jzfd|j f|jzf |_ dS)N)rr+r8rr8rrrrrrr+rrrrrrr8rrr8rrr$r%r&) rrrrrrr)rrrrrrs r"rzBox._create_vertex_lists [ZZ M== OT_gt{DK4--//0$*t67tw04?BCDN,t>? >AAr!cB|j|jz|jjdd<dSrtrrvs r"rzBox._update_colors%&*j4?&B ###r!r+c|js d|jzS|j}|j }|j }||jz}||jz}|}||z}||z }|} |} ||z} ||z } |} || || || || || | | | | || fSr)rrrrrrr)rqrdleftbottomrighttoprrx3x4rry3y4s r"r)zBox._get_vertices"s} ,DO+ + O.t{"t|#  AX QY   aZ 1W 2r2r2r2r2r2r2r2MMr!cL||jjdd<dSrtrBrvs r"rzBox._update_vertices7rCr!c|jS)zGet/set the width of the box. Setting the width will position the left and right sides relative to the box's :py:attr:`.anchor_x` value. rrvs r"rz Box.width:rr!rc<||_|dSrtrrs r"rz Box.widthCrVr!c|jS)zGet/set the height of the Box. Setting the height will set the bottom and top relative to the box's :py:attr:`.anchor_y` value. rrvs r"rz Box.heightHrr!cVt||_|dSrt)r(rrrs r"rz Box.heightQs'U||  r!c|jS)z&Get/set the line thickness of the Box.rKrvs r"rDz Box.thicknessVrLr!c<||_|dSrtrNrOs r"rDz Box.thickness[rPr!)rLr(rKr(rr(rr(rDr(rrrgrhrirhrrrrlrjrrrmrrr^rrr_)rrrr r rprrrr)rr rr rrDrrs@r"r1r1s #FZ)4"&"&,07J7J7J7J7J7J7JrRRRR A A A ACCCNNNN*====X \   \ X ]   ] X        r!r1ceZdZddeedddfd,fd Zd-dZd.dZd/dZd0d Z d1d"Z d0d#Z e d2d$Z e jd3d&Z e d2d'Zejd3d(Ze d4d*Zejd5d+ZxZS)6RoundedRectangleNrrLr(rKrrr8_RadiusT | tuple[_RadiusT, _RadiusT, _RadiusT, _RadiusT]r&int | tuple[int, int, int, int] | Nonerrrgrhrirrrrlrjrrrmc b||_||_d|_||_||_||||d|_|^} }}}| |||r|dndf|_t t|j dzdz|| | | | dS)aCreate a rectangle with rounded corners. The rectangle's anchor point defaults to the ``(x, y)`` coordinates, which are at the bottom left. Args: x: The X coordinate of the rectangle. y: The Y coordinate of the rectangle. width: The width of the rectangle. height: The height of the rectangle. radius: One or four values to specify the radii used for the rounded corners. If one value is given, all corners will use the same value. If four values are given, it will specify the radii used for the rounded corners clockwise: bottom-left, top-left, top-right, bottom-right. A value can be either a single float, or a tuple of two floats to specify different x,y dimensions. segments: You can optionally specify how many distinct triangles each rounded corner should be made from. This can be one int for all corners, or a tuple of four ints for each corner, specified clockwise: bottom-left, top-left, top-right, bottom-right. If no value is specified, it will automatically calculated using the formula: ``max(14, int(radius / 1.25))``. color: The RGB or RGBA color of the rectangle, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrrrrN) rrrrr _set_radius _set_segmentsrrrorpsumr)rqrLrKrrrrrrgrirrrjr3rrrrrs r"rpzRoundedRectangle.__init__fsl       8$$$ 1a!1a0addS0    1 $ ) z5%     r!ct|ttfr||ffdz|_dSt |dkr |fdz|_dSt |dksJg|_|D]j}t|ttfr|j||f;t |dksJ|j|kdS)Nrr8) isinstancerhr(rr9append)rqrrs r"rKzRoundedRectangle._set_radiuss fsEl + + /#V,.2DLLL [[A  "9q=DLLLv;;!####DL / /ec5\22/L''7777u::????L''....  / /r!c|%td|jD|_dSt|tr |fdz|_dSt |dksJ||_dS)Nc3\K|]'\}}tt||dz V(dS)rN)rhrM)r1rrs r" z1RoundedRectangle._set_segments..s;"R"RTQ3s1ayy4'7#8#8"R"R"R"R"R"Rr!r)tuplerrrOrhr9)rqrs r"rLzRoundedRectangle._set_segmentssq  ""R"RT\"R"R"RRRDNNN # & & &&[1_DNNNx==A%%%%%DNNNr!r&r%r7cHt|dksJt|j|jf|t j|j}|j|jz |j|jz }}||dcxko ||j zknco||dcxko ||j zkncSrrrs r"rzRoundedRectangle.__contains__rr!c |j|j|j|j|jd|fd|j|jzfd|j|j f|jzfd|j f|jzf|_ dSr#r'rvs r"rz$RoundedRectangle._create_vertex_listr*r!r+c  |js d|jzS|j }|j }g}||jddz||jddzt jdzdz f||jddz||jz|jddz t jf||jz|jddz ||jz|jddz t jdz f||jz|jddz ||jddzdfg}t|j||j D]V\\\  }t j dz |z | fdt|dzDW|jdz }|jdz }g}t|D],\} } ||g|| dz | R} | | -|S)Nr-rr+rr8c g|]B}tj|zzzztj|zzzzfCSr r/)r1r; arc_startarc_xarc_yrxryrs r"r4z2RoundedRectangle._get_vertices..srkkkQR"B!h,2J)K)K$KK!B!h,2J)K)K$KKMkkkr!)rrrrrr,rrrziprr;r:r)rqrLrKr< arc_positionsrcenter_xcenter_yr=r;r&rrYrZr[r\r]rs @@@@@@r"r)zRoundedRectangle._get_verticess[} ,DO+ + ^O ^Oa# # a# #TWq[1_ 6a# #   Q 2 2DG =_t|Aq1 1   Q 2 2DGaK A_t|Aq1 1 a# #Q (  >A}^b^l=m=m l l 9HR/ueYx!|h.H MMkkkkkkkkkV[\dgh\hViVikkk l l l l;?y''&00r!c |j|j|j|j|jd|fd|j|jzfd|j|j f|jzfd|j f|jzf|_ dSr#r'rvs r"rzStar._create_vertex_list r*r!r+c |js d|jzS|j }|j }|j}|j}t j|jz }g}t|jD]}| ||t j d|z|zzz||t j d|z|zzzf| ||t j d|zdz|zzz||t j d|zdz|zzzfg}t|D],\}} ||g||dz | R} || -|S)Nr-r8r+)rrrrrrr,rrr:rPr/r0rr;) rqrLrKr_ir_od_thetar<r;r=r&rs r"r)zStar._get_vertices s} ,DO+ + ^O ^O  'D,,t'(( I IA MM1dhq1uw&?&? ?@dhq1uw&?&? ?@B C C C MM1dhA W/D&E&E EFdhA W/D&E&E EFH I I I I!&)) & &HAu!3fQUm3e33H OOH % % % %r!cL||jjdd<dSrtrBrvs r"rzStar._update_vertices rCr!c|jS)z!Get/set outer radius of the star.)rrvs r"r~zStar.outer_radius !!r!rc<||_|dSrt)rrrs r"r~zStar.outer_radius "" r!c|jS)z%Get/set the inner radius of the star.)rrvs r"rzStar.inner_radius rr!c<||_|dSrt)rrrs r"rzStar.inner_radius" rr!c|jS)zNumber of spikes of the star.)rrvs r"rzStar.num_spikes' s r!c<||_|dSrt)rrrs r"rzStar.num_spikes, s"  r!)rLr(rKr(r~r(rr(rrhrr(rrrgrhrirhrrrrlrjrrrmrrr^rrrr )rrrr r rprrr)rr r~r rrrrs@r"r}r} sz"FZ)4"&"&,0? ? ? ? ? ? ? B1111AAAA8===="""X"    """X"       X         r!r}cPeZdZdeedddddfdZddZddZddZddZ xZ S) PolygonrN)rrgrirrrj coordinates%tuple[float, float] | Sequence[float]rrrgrhrirrrrlrjrrrmcd|_t||_|jd\|_|_|^}} } } || | | r| dndf|_t t|j|||||dS)aCreate a polygon. The polygon's anchor point defaults to the first vertex point. Args: coordinates: The coordinates for each point in the polygon. Each one must be able to unpack to a pair of float-like X and Y values. color: The RGB or RGBA color of the polygon, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrN) rrf _coordinatesrrrrorpr9) rqrrgrirrrjrr3rrrrrs r"rpzPolygon.__init__3 sF --,Q/ 1a!1a0addS0   ! " " z5%     r!r&r%r7ct|dksJt|jd|tj|j}t |j|jdgz|S)Nr8r)r9r4rr,r9rr=rs r"rzPolygon.__contains__a s]5zzQd/2E4<;W;WXX !2d6G6J5K!KUSSSr!c 8|}|j|j|jt j||j|jd|fd|j|jzfd|j |j f|jzfd|j f|jzf |_ dSr#) r)rrrrr rrrrrrr)rqr=s r"rzPolygon._create_vertex_listf s%%'' M== OT_ M( # # K8_$*t67tw04?BCDN,t>?>AAr!r+c|js d|jzS|jd\|jz |jz fd|jD}t j|gdS)Nr-rc*g|]\}}|z |z gSr r rts r"r4z)Polygon._get_vertices..y s*KKKA1w;G ,KKKr!r=)rrrrrr flatten)rqrwrurvs @@r"r)zPolygon._get_verticesq s} ,DO+ + ,Q/4>!4>!KKKKK9JKKK~vh'' 33r!cL||jjdd<dSrtrBrvs r"rzPolygon._update_vertices~ rCr!)rrrrrgrhrirhrrrrlrjrrrmrrr^) rrrr r rprrr)rrrs@r"rr2 sG[)4"&"&,0, , , , , , , , \TTTT A A A A 4 4 4 4========r!rc eZdZdddeeddddd fdZd!dZd"dZd!dZe d#dZ e j d$dZ xZ S)% MultiLineFr>rN)rrDrrgrirrrjrrrr7rDr(rrrgrhrirrrrlrjrrrmc||_||_d|_t| |_|r%|j|jd|jd\|_|_|^} } } } | | | | r| dndf|_t t|jdz dz|||||dS)aCreate multiple connected lines from a series of coordinates. The shape's anchor point defaults to the first vertex point. Args: coordinates: The coordinates for each point in the shape. Each must unpack like a tuple consisting of an X and Y float-like value. closed: Set this to ``True`` to add a line connecting the first and last points. The default is ``False`` thickness: The desired thickness or width used for the line segments. color: The RGB or RGBA color of the shape, specified as a tuple of 3 or 4 ints in the range of 0-255. RGB colors will be treated as having an opacity of 255. blend_src: OpenGL blend source mode; for example, ``GL_SRC_ALPHA``. blend_dest: OpenGL blend destination mode; for example, ``GL_ONE_MINUS_SRC_ALPHA``. batch: Optional batch to add the shape to. group: Optional parent group of the shape. program: Optional shader program of the shape. rrr+rN) rr!rrfrrPrrrrorpr9)rqrrDrrgrirrrjrr3rrrrrs r"rpzMultiLine.__init__ sT$  --  ;   $ $T%6q%9 : : :,Q/ 1a!1a0addS0   " # #a '1 , z5%     r!c |j|j|j|j|jd|fd|j|jzfd|j|j f|jzfd|j f|jzf|_ dSr#r'rvs r"rzMultiLine._create_vertex_list r*r!r+c  |js d|jzS|jd\ |jz |jz fd|jD}g}d}d}t t |dz D]y}d}d}|dkr ||dz }|dzt |kr ||dz}t|||||dz||j||^}}}| |z|S)Nr-rc*g|]\}}|z |z gSr r rts r"r4z+MultiLine._get_vertices.. s*$^$^$^DAqa'k1w;%?$^$^$^r!r+r8) rrrrrr:r9rdrr;) rqrw trianglesrErGr;r>r?r@rurvs @@r"r)zMultiLine._get_vertices s1} ,DO+ +,Q/4>!4>!$^$^$^$^$^DL]$^$^$^   s6{{Q'' & &A-1J-1J1uu#AE] 1us6{{""#AE] /;Jq SYZ[^_Z_S`bl<@OZYc0e0e ,J W   W % % % %r!cL||jjdd<dSrtrBrvs r"rzMultiLine._update_vertices rCr!c|jS)z-Get/set the line thickness of the multi-line.rKrvs r"rDzMultiLine.thickness rLr!c<||_|dSrtrNrOs r"rDzMultiLine.thickness rPr!)rrrr7rDr(rrrgrhrirhrrrrlrjrrrmrr^rr_) rrrr r rprr)rr rDr rrs@r"rr s !"/C)4"&"&,09 9 9 9 9 9 9 9 vAAAA8====X        r!r)rr1rbrrrrrrrkr}rrrr)r$r%r&r%r'r(rr%)r5r6r&r%rr7)r>NN)r?r@rAr@rBr@rCr@rDr(rErFrGrFrrH)8r __future__rr,abcrrtypingrrrr rpyglet.extlibsr pyglet.glr r r rrrrpyglet.graphicsrr pyglet.mathrpyglet.graphics.shaderrrrr#r4r=rdrfrrrbrrrrrrr1r(_RadiusTshapesrGrkr}rr__all__r r!r"rsAAD#""""" ########888888888888 !!!!!!tttttttttttttttttt((((((((5444444  D SSSS TTTT4dhTpTpTpTpTpn-R-R-R-R-R%-R-R-R`c'c'c'c'c'c'c'c'Lv v v v v )v v v rM M M M M )M M M `f f f f f Yf f f R} } } } } i} } } @] ] ] ] ] Y] ] ] @K K K K K 9K K K \l l l l l l l l ^kkkkk kkk\M M M M M )M M M ` eUl++ ,{ { { { { v}.{ { { |~ ~ ~ ~ ~ y~ ~ ~ BL L L L L 9L L L ^M=M=M=M=M=iM=M=M=`l l l l l l l l ^ Vr!