U Petb@sdZddlmZddlmZddlmZmZmZm Z m Z ddl m Z m Z mZmZmZmZmZmZmZddlmZddlmZddlmZdd lmZd Zd Zd Zd Z dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*GdddeZ+Gddde+Z,Gddde+Z-Gddde+Z.Gd d!d!e+Z/Gd"d#d#e+Z0Gd$d%d%e+Z1Gd&d'd'e+Z2Gd(d)d)e+Z3Gd*d+d+e+Z4Gd,d-d-e Z5Gd.d/d/eZ6d0S)1a EffectWidget ============ .. versionadded:: 1.9.0 The :class:`EffectWidget` is able to apply a variety of fancy graphical effects to its children. It works by rendering to a series of :class:`~kivy.graphics.Fbo` instances with custom opengl fragment shaders. As such, effects can freely do almost anything, from inverting the colors of the widget, to anti-aliasing, to emulating the appearance of a crt monitor! .. warning:: This code is still experimental, and its API is subject to change in a future version. The basic usage is as follows:: w = EffectWidget() w.add_widget(Button(text='Hello!') w.effects = [InvertEffect(), HorizontalBlurEffect(size=2.0)] The equivalent in kv would be:: #: import ew kivy.uix.effectwidget EffectWidget: effects: ew.InvertEffect(), ew.HorizontalBlurEffect(size=2.0) Button: text: 'Hello!' The effects can be a list of effects of any length, and they will be applied sequentially. The module comes with a range of prebuilt effects, but the interface is designed to make it easy to create your own. Instead of writing a full glsl shader, you provide a single function that takes some inputs based on the screen (current pixel color, current widget texture etc.). See the sections below for more information. Usage Guidelines ---------------- It is not efficient to resize an :class:`EffectWidget`, as the :class:`~kivy.graphics.Fbo` is recreated on each resize event. If you need to resize frequently, consider doing things a different way. Although some effects have adjustable parameters, it is *not* efficient to animate these, as the entire shader is reconstructed every time. You should use glsl uniform variables instead. The :class:`AdvancedEffectBase` may make this easier. .. note:: The :class:`EffectWidget` *cannot* draw outside its own widget area (pos -> pos + size). Any child widgets overlapping the boundary will be cut off at this point. Provided Effects ---------------- The module comes with several pre-written effects. Some have adjustable properties (e.g. blur radius). Please see the individual effect documentation for more details. - :class:`MonochromeEffect` - makes the widget grayscale. - :class:`InvertEffect` - inverts the widget colors. - :class:`ChannelMixEffect` - swaps color channels. - :class:`ScanlinesEffect` - displays flickering scanlines. - :class:`PixelateEffect` - pixelates the image. - :class:`HorizontalBlurEffect` - Gaussuan blurs horizontally. - :class:`VerticalBlurEffect` - Gaussuan blurs vertically. - :class:`FXAAEffect` - applies a very basic anti-aliasing. Creating Effects ---------------- Effects are designed to make it easy to create and use your own transformations. You do this by creating and using an instance of :class:`EffectBase` with your own custom :attr:`EffectBase.glsl` property. The glsl property is a string representing part of a glsl fragment shader. You can include as many functions as you like (the string is simply spliced into the whole shader), but it must implement a function :code:`effect` as below:: vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords) { // ... your code here return something; // must be a vec4 representing the new color } The full shader will calculate the normal pixel color at each point, then call your :code:`effect` function to transform it. The parameters are: - **color**: The normal color of the current pixel (i.e. texture sampled at tex_coords). - **texture**: The texture containing the widget's normal background. - **tex_coords**: The normal texture_coords used to access texture. - **coords**: The pixel indices of the current pixel. The shader code also has access to two useful uniform variables, :code:`time` containing the time (in seconds) since the program start, and :code:`resolution` containing the shape (x pixels, y pixels) of the widget. For instance, the following simple string (taken from the `InvertEffect`) would invert the input color but set alpha to 1.0:: vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords) { return vec4(1.0 - color.xyz, 1.0); } You can also set the glsl by automatically loading the string from a file, simply set the :attr:`EffectBase.source` property of an effect. )Clock)RelativeLayout)StringPropertyObjectProperty ListPropertyNumericProperty DictProperty) RenderContextFboColor Rectangle Translate PushMatrix PopMatrix ClearColor ClearBuffers)EventDispatcher) EventLoop) resource_find)Logger) EffectWidget EffectBaseAdvancedEffectBaseMonochromeEffect InvertEffectChannelMixEffectScanlinesEffectPixelateEffectHorizontalBlurEffectVerticalBlurEffect FXAAEffectz #ifdef GL_ES precision highp float; #endif /* Outputs from the vertex shader */ varying vec4 frag_color; varying vec2 tex_coord0; /* uniform texture samplers */ uniform sampler2D texture0; z. uniform vec2 resolution; uniform float time; zW void main (void){ gl_FragColor = frag_color * texture2D(texture0, tex_coord0); } z void main (void){ vec4 normal_color = frag_color * texture2D(texture0, tex_coord0); vec4 effect_color = effect(normal_color, texture0, tex_coord0, gl_FragCoord.xy); gl_FragColor = effect_color; } z` vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords) { return color; } z vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords) { float mag = 1.0/3.0 * (color.x + color.y + color.z); return vec4(mag, mag, mag, color.w); } zy vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords) { return vec4(1.0 - color.xyz, color.w); } z vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords) {{ return vec4(color.{}, color.{}, color.{}, color.w); }} aB vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords) {{ float dt = ({} / 4.0) * 1.0 / resolution.x; vec4 sum = vec4(0.0); sum += texture2D(texture, vec2(tex_coords.x - 4.0*dt, tex_coords.y)) * 0.05; sum += texture2D(texture, vec2(tex_coords.x - 3.0*dt, tex_coords.y)) * 0.09; sum += texture2D(texture, vec2(tex_coords.x - 2.0*dt, tex_coords.y)) * 0.12; sum += texture2D(texture, vec2(tex_coords.x - dt, tex_coords.y)) * 0.15; sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y)) * 0.16; sum += texture2D(texture, vec2(tex_coords.x + dt, tex_coords.y)) * 0.15; sum += texture2D(texture, vec2(tex_coords.x + 2.0*dt, tex_coords.y)) * 0.12; sum += texture2D(texture, vec2(tex_coords.x + 3.0*dt, tex_coords.y)) * 0.09; sum += texture2D(texture, vec2(tex_coords.x + 4.0*dt, tex_coords.y)) * 0.05; return vec4(sum.xyz, color.w); }} aW vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords) {{ float dt = ({} / 4.0) * 1.0 / resolution.x; vec4 sum = vec4(0.0); sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y - 4.0*dt)) * 0.05; sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y - 3.0*dt)) * 0.09; sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y - 2.0*dt)) * 0.12; sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y - dt)) * 0.15; sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y)) * 0.16; sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y + dt)) * 0.15; sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y + 2.0*dt)) * 0.12; sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y + 3.0*dt)) * 0.09; sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y + 4.0*dt)) * 0.05; return vec4(sum.xyz, color.w); }} a, vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords) { vec2 q = tex_coords * vec2(1, -1); vec2 uv = 0.5 + (q-0.5);//*(0.9);// + 0.1*sin(0.2*time)); vec3 oricol = texture2D(texture,vec2(q.x,1.0-q.y)).xyz; vec3 col; col.r = texture2D(texture,vec2(uv.x+0.003,-uv.y)).x; col.g = texture2D(texture,vec2(uv.x+0.000,-uv.y)).y; col.b = texture2D(texture,vec2(uv.x-0.003,-uv.y)).z; col = clamp(col*0.5+0.5*col*col*1.2,0.0,1.0); //col *= 0.5 + 0.5*16.0*uv.x*uv.y*(1.0-uv.x)*(1.0-uv.y); col *= vec3(0.8,1.0,0.7); col *= 0.9+0.1*sin(10.0*time+uv.y*1000.0); col *= 0.97+0.03*sin(110.0*time); float comp = smoothstep( 0.2, 0.7, sin(time) ); //col = mix( col, oricol, clamp(-2.0+2.0*q.x+3.0*comp,0.0,1.0) ); return vec4(col, color.w); } z vec4 effect(vec4 vcolor, sampler2D texture, vec2 texcoord, vec2 pixel_coords) {{ vec2 pixelSize = {} / resolution; vec2 xy = floor(texcoord/pixelSize)*pixelSize + pixelSize/2.0; return texture2D(texture, xy); }} a vec4 effect( vec4 color, sampler2D buf0, vec2 texCoords, vec2 coords) { vec2 frameBufSize = resolution; float FXAA_SPAN_MAX = 8.0; float FXAA_REDUCE_MUL = 1.0/8.0; float FXAA_REDUCE_MIN = 1.0/128.0; vec3 rgbNW=texture2D(buf0,texCoords+(vec2(-1.0,-1.0)/frameBufSize)).xyz; vec3 rgbNE=texture2D(buf0,texCoords+(vec2(1.0,-1.0)/frameBufSize)).xyz; vec3 rgbSW=texture2D(buf0,texCoords+(vec2(-1.0,1.0)/frameBufSize)).xyz; vec3 rgbSE=texture2D(buf0,texCoords+(vec2(1.0,1.0)/frameBufSize)).xyz; vec3 rgbM=texture2D(buf0,texCoords).xyz; vec3 luma=vec3(0.299, 0.587, 0.114); float lumaNW = dot(rgbNW, luma); float lumaNE = dot(rgbNE, luma); float lumaSW = dot(rgbSW, luma); float lumaSE = dot(rgbSE, luma); float lumaM = dot(rgbM, luma); float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE))); float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE))); vec2 dir; dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE)); dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE)); float dirReduce = max( (lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN); float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce); dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX), max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX), dir * rcpDirMin)) / frameBufSize; vec3 rgbA = (1.0/2.0) * ( texture2D(buf0, texCoords.xy + dir * (1.0/3.0 - 0.5)).xyz + texture2D(buf0, texCoords.xy + dir * (2.0/3.0 - 0.5)).xyz); vec3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * ( texture2D(buf0, texCoords.xy + dir * (0.0/3.0 - 0.5)).xyz + texture2D(buf0, texCoords.xy + dir * (3.0/3.0 - 0.5)).xyz); float lumaB = dot(rgbB, luma); vec4 return_color; if((lumaB < lumaMin) || (lumaB > lumaMax)){ return_color = vec4(rgbA, color.w); }else{ return_color = vec4(rgbB, color.w); } return return_color; } csLeZdZdZeeZedZedddZ fddZ dd Z d d Z Z S) rzwThe base class for GLSL effects. It simply returns its input. See the module documentation for more details. NT)Z allownonecsBtt|j|||j}|j}|d||d||d|jdS)Nfboglslsource)superr__init__fbindset_fbo_shader_load_from_source)selfargskwargsr'Z fbo_shader __class__9/tmp/pip-unpacked-wheel-xzebddm3/kivy/uix/effectwidget.pyr&s   zEffectBase.__init__cGs,|jdkrdS|jtt|jtdS)zSets the :class:`~kivy.graphics.Fbo`'s shader by splicing the :attr:`glsl` string into a full fragment shader. The full shader is made up of :code:`shader_header + shader_uniforms + self.glsl + shader_footer_effect`. N)r"set_fs shader_headershader_uniformsr#shader_footer_effectr*r+r/r/r0r(s  zEffectBase.set_fbo_shaderc GsR|j}|sdSt|}|dkr0tdj|dSt|}||_W5QRXdS)z4(internal) Loads the glsl string from a source file.NzError reading file {filename})filename)r$rrerrorformatopenreadr#)r*r+r$r6Zfilehr/r/r0r)s zEffectBase._load_from_source)__name__ __module__ __qualname____doc__reffect_trivialr#r$rr"r&r(r) __classcell__r/r/r-r0rhs    rcs<eZdZdZeiZfddZddZfddZZ S)ra~An :class:`EffectBase` with additional behavior to easily set and update uniform variables in your shader. This class is provided for convenience when implementing your own effects: it is not used by any of those provided with Kivy. In addition to your base glsl string that must be provided as normal, the :class:`AdvancedEffectBase` has an extra property :attr:`uniforms`, a dictionary of name-value pairs. Whenever a value is changed, the new value for the uniform variable is uploaded to the shader. You must still manually declare your uniform variables at the top of your glsl string. cs$tt|j|||d|jdS)Nuniforms)r%rr&r'_update_uniformsr*r+r,r-r/r0r&szAdvancedEffectBase.__init__cGs0|jdkrdS|jD]\}}||j|<qdSN)r"rAitems)r*r+keyvaluer/r/r0rBs z#AdvancedEffectBase._update_uniformscstt|j||dSrD)r%rr(rBr5r-r/r0r(sz!AdvancedEffectBase.set_fbo_shader) r;r<r=r>rrAr&rBr(r@r/r/r-r0rs  rcs eZdZdZfddZZS)rz'Returns its input colors in monochrome.cstt|j||t|_dSrD)r%rr&effect_monochromer#rCr-r/r0r&szMonochromeEffect.__init__r;r<r=r>r&r@r/r/r-r0rsrcs eZdZdZfddZZS)rz Inverts the colors in the input.cstt|j||t|_dSrD)r%rr& effect_invertr#rCr-r/r0r&szInvertEffect.__init__rIr/r/r-r0rsrcs eZdZdZfddZZS)rzAdds scanlines to the input.cstt|j||t|_dSrD)r%rr&effect_postprocessingr#rCr-r/r0r&szScanlinesEffect.__init__rIr/r/r-r0rsrcs>eZdZdZedddgZfddZddZd d ZZ S) rz~Mixes the color channels of the input according to the order property. Channels may be arbitrarily rearranged or repeated.rcstt|j|||dSrD)r%rr&do_glslrCr-r/r0r&szChannelMixEffect.__init__cGs |dSrDrNr5r/r/r0on_orderszChannelMixEffect.on_ordercCs dd|jD}tj||_dS)NcSsg|]}dddd|qS)xyz)rrLrMr/).0ir/r/r0 sz,ChannelMixEffect.do_glsl..)order effect_mixr8r#)r*lettersr/r/r0rNszChannelMixEffect.do_glsl) r;r<r=r>rrWr&rPrNr@r/r/r-r0rs  rcs8eZdZdZedZfddZddZddZZ S) rzKPixelates the input according to its :attr:`~PixelateEffect.pixel_size` cstt|j|||dSrD)r%rr&rNrCr-r/r0r& szPixelateEffect.__init__cGs |dSrDrOr5r/r/r0 on_pixel_sizeszPixelateEffect.on_pixel_sizecCstt|j|_dSrD)effect_pixelater8float pixel_sizer#r*r/r/r0rNszPixelateEffect.do_glsl) r;r<r=r>rr^r&r[rNr@r/r/r-r0rs  rcs8eZdZdZedZfddZddZddZZ S) rz]Blurs the input horizontally, with the width given by :attr:`~HorizontalBlurEffect.size`.@cstt|j|||dSrD)r%rr&rNrCr-r/r0r& szHorizontalBlurEffect.__init__cGs |dSrDrOr5r/r/r0on_size$szHorizontalBlurEffect.on_sizecCstt|j|_dSrD) effect_blur_hr8r]sizer#r_r/r/r0rN'szHorizontalBlurEffect.do_glsl r;r<r=r>rrcr&rarNr@r/r/r-r0rs  rcs8eZdZdZedZfddZddZddZZ S) rzYBlurs the input vertically, with the width given by :attr:`~VerticalBlurEffect.size`.r`cstt|j|||dSrD)r%rr&rNrCr-r/r0r&6szVerticalBlurEffect.__init__cGs |dSrDrOr5r/r/r0ra:szVerticalBlurEffect.on_sizecCstt|j|_dSrD) effect_blur_vr8r]rcr#r_r/r/r0rN=szVerticalBlurEffect.do_glslrdr/r/r-r0r+s  rcs eZdZdZfddZZS)r z+Applies very simple anti-aliasing via fxaa.cstt|j||t|_dSrD)r%r r& effect_fxaar#rCr-r/r0r&CszFXAAEffect.__init__rIr/r/r-r0r Asr cs(eZdZdZfddZddZZS) EffectFboz~An :class:`~kivy.graphics.Fbo` with extra functionality that allows attempts to set a new shader. See :meth:`set_fs`. cs(|ddtt|j||d|_dS)NZwith_stencilbufferT) setdefaultr%rgr&texture_rectanglerCr-r/r0r&Ls zEffectFbo.__init__cCs*|j}|j}||_|js&||_tddS)zAttempt to set the fragment shader to the given value. If setting the shader fails, the existing one is preserved and an exception is raised. zSetting new shader failed.N)shaderfssuccess Exception)r*rGrj old_valuer/r/r0r1Qs zEffectFbo.set_fs)r;r<r=r>r&r1r@r/r/r-r0rgHs rgcseZdZdZedZedZegZegZ egZ fddZ ddZ dd Z d d Zfd d ZfddZfddZZS)rz Widget with the ability to apply a series of graphical effects to its children. See the module documentation for more information on setting effects and creating your own. )rrrrNc s ttddd|_|jt|jd|_W5QRX|jj tW5QRX|j4t ddddt t |j |_ t|jd|_W5QRX|jj tW5QRXtt|jf|t|jd|j}|j}|d||d||d|j||dS)NT)Zuse_parent_projectionZuse_parent_modelviewrcrrceffectsbackground_color)rZ ensure_windowr canvasr rcr"beforerrrr rq_background_colorr fbo_rectangleafterrr%rr&rZschedule_interval _update_glslr'refresh_fbo_setup_refresh_background_color)r*r,r'Z fbo_setupr-r/r0r&s0      zEffectWidget.__init__cGs|j|j_dSrD)rqrtZrgbar5r/r/r0rysz&EffectWidget._refresh_background_colorcGsLt}dd|jD}||jd<||jd<|jD]}||d<||d<q2dS)z[(internal) Passes new time and resolution uniform variables to the shader. cSsg|] }t|qSr/)r])rTrcr/r/r0rVsz-EffectWidget._update_glsl..time resolutionN)rZ get_boottimercrrfbo_list)r*largsrzr{r"r/r/r0rws   zEffectWidget._update_glslc Gst|jt|jkr|jt|jd}W5QRX|@tddddttddddt |jd|_ |j|j _W5QRX|j |qt|jt|jkr|j }|j |q|jD]}||jkrd|_q|j|_|j|j_|j|j_tt|jD]"}|j|j|_|j|j|j _qt|jdkr>|jj|_dStdt|jD]$}|j|}|j|dj|j _qNt|j|jD]\}}||_q|jj|jdj _|jdj|_|jD]}|q|jdS)z(internal) Creates and assigns one :class:`~kivy.graphics.Fbo` per effect, and makes sure all sizes etc. are correct and consistent. rorrLN)lenr|rprrrgrcrrr r riappendpopremove_bound_effectsr"rurangetexturezipZdraw)r*r+Znew_fboZold_fboZeffectrUr"r/r/r0rxsF          zEffectWidget.refresh_fbo_setupcs*|j}|j|_tt|j||||_dSrD)rrr"r%r add_widgetr*r+r,cr-r/r0rszEffectWidget.add_widgetcs*|j}|j|_tt|j||||_dSrD)rrr"r%r remove_widgetrr-r/r0rszEffectWidget.remove_widgetcs*|j}|j|_tt|j||||_dSrD)rrr"r%r clear_widgetsrr-r/r0rszEffectWidget.clear_widgets)r;r<r=r>rrqrrrpr|rr&ryrwrxrrrr@r/r/r-r0r^s ! 6  rN)7r>Z kivy.clockrZkivy.uix.relativelayoutrZkivy.propertiesrrrrrZ kivy.graphicsr r r r r rrrrZ kivy.eventrZ kivy.baserZkivy.resourcesrZ kivy.loggerr__all__r2r3Zshader_footer_trivialr4r?rHrJrXrbrerKr\rfrrrrrrrrrr rgrr/r/r/r0sDz  ,       <A(