def add_background(self,
user_pos,
user_color=(),
opacity=0.69,
shader_code=plasma_hearts_shader_code,
last_canvas=None):
""" add another render context """
if not user_color:
root = App.get_running_app().root
if root:
ids = root.ids
user_color = (ids.color_red.value, ids.color_green.value,
ids.color_blue.value, ids.color_alpha.value)
else:
user_color = (.69, .36, .39, .6)
# noinspection PyUnresolvedReferences
import kivy.core.window # not needed directly, import to ensure creation of window render context
render_ctx = RenderContext(opacity=opacity,
use_parent_modelview=True,
use_parent_projection=True,
use_parent_frag_modelview=True)
with render_ctx:
rectangle = Rectangle(pos=self.pos, size=self.size)
self.compile_fragment_shader(render_ctx, shader_code)
print("ADDING RENDER CONTEXT OK=", render_ctx.shader.success, user_pos,
user_color, opacity)
background_idx = len(self.backgrounds) if hasattr(self,
'backgrounds') else 0
if background_idx:
last_canvas = self.backgrounds[-1]['render_ctx']
else:
self.backgrounds = list()
self.user_pos = user_pos = list((self.center_x, 0))
if last_canvas:
# rc.add(last_canvas)
last_canvas.add(render_ctx)
self.backgrounds.append(
dict(render_ctx=render_ctx,
rectangle=rectangle,
user_pos=user_pos,
user_color=user_color,
opacity=opacity))
Clock.schedule_interval(partial(self.update_glsl, background_idx),
1 / 30.)
def __init__(self, *args, **kwargs):
# We must do this, if no other widget has been loaded the
# GL context may not be fully prepared
EventLoop.ensure_window()
# Most likely you will want to use the parent projection
# and modelviev in order for your widget to behave the same
# as the rest of the widgets
self.canvas = RenderContext(use_parent_projection=True,
use_parent_modelview=True)
self.canvas.shader.source = 'shaders/flame.glsl'
Clock.schedule_interval(self.update_shader, 0)
self.effects = {}
self.count = 0.
self.center = (0, 0)
self.scale_obj = config.get_scale_object()
super(self.__class__, self).__init__(*args, **kwargs)
def assign(self, widget, scrollview_container=None):
if self._anim:
Logger.info('Placeholder: assign with animation')
return
# first update our size to the new texture size.
self.size = self.newtexture.size
self.texture_size = self.newtexture.size
self._hotspots = widget.get_hotspots()
visual_bbox = None
if scrollview_container:
visual_bbox = StableScrollView.BBox(
*scrollview_container._get_pure_viewbox())
if not visual_bbox or not self.collide_widget(visual_bbox):
self.anim_on_complete(1.0)
else:
self._cntx = RenderContext(use_parent_projection=True)
self._cntx.shader.fs = FADE_TRANSITION_FS
with self._cntx:
# here, we are binding a custom texture at index 1
# this will be used as texture1 in shader.
BindTexture(texture=self.newtexture, index=1)
# create a rectangle with texture (will be at index 0)
pos = self.to_window(self.x, self.y)
self._cntx_rect = Rectangle(size=self.size,
pos=pos,
texture=self.holder,
tex_coords=self.holder.tex_coords)
# callback to update position
#Callback(self._cntx_callback)
# set the texture1 to use texture index 1
self._cntx['t'] = 0.0
self._cntx['tex_in'] = 1
self._cntx['tex_out'] = 0
self.canvas.add(self._cntx)
# set the animation in progress
self._anim = Animation(duration=0.250, s=0)
self._anim.bind(on_progress=self.anim_on_progress,
on_complete=self.anim_on_complete)
self._anim.start(self)
def create_drawings(self):
from kivy.graphics import PushMatrix, PopMatrix
#from kivy.utils import get_color_from_hex as rgb
from kivy.graphics import RenderContext
self._grc = RenderContext(use_parent_modelview=True,
use_parent_projection=True)
with self._grc.before:
PushMatrix()
with self._grc:
self._gcolor = Color(*self.color)
self._ellipses = [Ellipse() for i in xrange(len(self.points))]
with self._grc.after:
PopMatrix()
return [self._grc]
def __init__(self, grid, **kwargs):
self.canvas = RenderContext()
self.canvas.shader.source = SIMPLE_SHADER
self._atlas = Atlas(BG_ATLAS_ATLAS)
self._tex = CoreImage(BG_ATLAS_IMAGE).texture
super().__init__(size_hint=(1, 1), **kwargs)
with self.canvas:
PushMatrix()
UpdateNormalMatrix()
vertices = []
indices = []
rows = 40
cols = 40
blk_h = 1. / rows
blk_w = 1. / cols
n = 0
tex_names = list(self._atlas.textures.keys())
for i, j in product(range(cols), range(rows)):
tex_name = tex_names[(i + j) % len(tex_names)]
win_x1, win_y1 = blk_w * i - .5, blk_h * j - .5
win_x2, win_y2 = blk_w * (i + 1) - .5, blk_h * (j + 1) - .5
tex_pos = self._atlas[tex_name].uvpos
tex_size = self._atlas[tex_name].uvsize
tex_x1, tex_y1 = tex_pos
tex_x2, tex_y2 = tex_pos[0] + tex_size[0], tex_pos[
1] + tex_size[1]
vertices.extend([
win_x1, win_y1, 0, tex_x1, tex_y1, win_x2, win_y1, 0,
tex_x2, tex_y1, win_x1, win_y2, 0, tex_x1, tex_y2, win_x2,
win_y2, 0, tex_x2, tex_y2
])
indices.extend([n, n + 1, n + 2, n + 2, n + 1, n + 3])
n += 4
fmt = [(b'v_pos', 3, 'float'), (b'v_uv', 2, 'float')]
self.mesh = Mesh(texture=self._tex,
vertices=vertices,
indices=indices,
fmt=fmt,
mode="triangles")
PopMatrix()
def __init__(self, **kwargs):
# Make sure opengl context exists
EventLoop.ensure_window()
self.mask_effect = kwargs.get("mask_effect", None)
self.motion_effect = kwargs.get("motion_effect", None)
self.canvas = RenderContext(use_parent_projection=True,
use_parent_modelview=True)
self.size = C_SIZE
with self.canvas:
#self._viewport = Rectangle(size=(800,600), pos=self.pos)
self.fbo = Fbo(size=C_SIZE,
with_depthbuffer=True,
compute_normal_mat=True,
clear_color=(0.3, 0.3, 0.7, 1))
with self.fbo.before:
#Rectangle(size=(800, 600))
PushMatrix()
self.fbo_translation = Translate(-self.x, -self.y, 0)
BindTexture(texture=self.mask_effect.texture, index=4)
BindTexture(texture=self.motion_effect.texture, index=5)
with self.fbo:
Color(0, 0, 0)
BindTexture(texture=self.mask_effect.texture, index=4)
BindTexture(texture=self.motion_effect.texture, index=5)
self.fbo_rectangle = Rectangle(size=C_SIZE)
self._instructions = InstructionGroup()
with self.fbo.after:
PopMatrix()
self.cbs = Callback(self.reset_gl_context)
super(EffectWidget, self).__init__()
self.size = C_SIZE
Clock.schedule_interval(self.update_glsl, 0)
self._instructions.add(Callback(self.setup_gl_context))
self.refresh_fbo_setup()
Clock.schedule_interval(self.update_fbos, 0)
def create_drawings(self):
from kivy.graphics import Line, RenderContext
# very first time, create a texture for the shader
if not hasattr(SmoothLinePlot, '_texture'):
tex = Texture.create(size=(1, 64), colorfmt='rgb')
tex.add_reload_observer(SmoothLinePlot._smooth_reload_observer)
SmoothLinePlot._texture = tex
SmoothLinePlot._smooth_reload_observer(tex)
self._grc = RenderContext(fs=SmoothLinePlot.SMOOTH_FS,
use_parent_modelview=True,
use_parent_projection=True)
with self._grc:
self._gcolor = Color(*self.color)
self._gline = Line(points=[], cap='none', width=8.,
texture=SmoothLinePlot._texture)
return [self._grc]
def add_screen(self, screen):
self.screen_in.pos = self.screen_out.pos
self.screen_in.size = self.screen_out.size
self.manager.real_remove_widget(self.screen_out)
self.fbo_in = self.make_screen_fbo(self.screen_in)
self.fbo_out = self.make_screen_fbo(self.screen_out)
self.manager.canvas.add(self.fbo_in)
self.manager.canvas.add(self.fbo_out)
self.render_ctx = RenderContext(fs=self.fs)
with self.render_ctx:
BindTexture(texture=self.fbo_out.texture, index=1)
BindTexture(texture=self.fbo_in.texture, index=2)
Rectangle(size=(1, -1), pos=(0, 1))
self.render_ctx['projection_mat'] = Matrix().\
view_clip(0, 1, 0, 1, 0, 1, 0)
self.render_ctx['tex_out'] = 1
self.render_ctx['tex_in'] = 2
self.manager.canvas.add(self.render_ctx)
def __init__(self,controller,width = 480,height = 320, **kwargs):
App.__init__(self)
self.controller = controller
self.productFound = ""
self.wid = Widget()
self.canvas = RenderContext()
self.image_Found = None
self.RealTimeImageOfProduct = None
self.event = None
self.lblProductName = None
self.wid.height = height
self.wid.width = width
self.btnheight = 10
self.btnwidth = 90
self.stock_layout = None
self.stock_root = None
self.stocklblWdith = None
self.stocklblHeight = 50
self.imgSaving = False
def create_drawings(self):
from kivy.graphics import Line, RenderContext
from kivy.graphics.texture import Texture
# very first time, create a texture for the shader
if not hasattr(SmoothLinePlot, '_texture'):
tex = Texture.create(size=(1, 64), colorfmt='rgb')
tex.blit_buffer(SmoothLinePlot.GRADIENT_DATA, colorfmt='rgb')
SmoothLinePlot._texture = tex
self._grc = RenderContext(fs=SmoothLinePlot.SMOOTH_FS,
use_parent_modelview=True,
use_parent_projection=True)
with self._grc:
self._gcolor = Color(*self.color)
self._gline = Line(points=[],
cap='none',
width=2.,
texture=SmoothLinePlot._texture)
return [self._grc]
def __init__(self, **kwargs):
Window.bind(mouse_pos=self.get_mouse_pos)
self.canvas = RenderContext(use_parent_projection=True,
use_parent_modelview=True,
use_parent_frag_modelview=True)
with self.canvas:
self.fbo = Fbo(size=self.size)
self.fbo_color = Color(1, 1, 1, 1)
self.fbo_rect = Rectangle(size=self.size, pos=self.pos)
with self.fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
super(ShaderWidget, self).__init__(**kwargs)
self.fs = shader_watter_bubble
Clock.schedule_interval(self.update_glsl, 0)
def add_screen(self, screen):
self.screen_in.pos = self.screen_out.pos
self.screen_in.size = self.screen_out.size
self.manager.real_remove_widget(self.screen_out)
self.fbo_in = self.make_screen_fbo(self.screen_in)
self.fbo_out = self.make_screen_fbo(self.screen_out)
self.manager.canvas.add(self.fbo_in)
self.manager.canvas.add(self.fbo_out)
self.render_ctx = RenderContext(fs=self.fs, vs=self.vs,
use_parent_modelview=True, use_parent_projection=True)
with self.render_ctx:
BindTexture(texture=self.fbo_out.texture, index=1)
BindTexture(texture=self.fbo_in.texture, index=2)
x, y = self.screen_in.pos
w, h = self.fbo_in.texture.size
Rectangle(size=(w, h), pos=(x, y),
tex_coords=self.fbo_in.texture.tex_coords)
self.render_ctx['tex_out'] = 1
self.render_ctx['tex_in'] = 2
self.manager.canvas.add(self.render_ctx)
def __init__(self, **kwargs):
# Instead of using canvas, we will use a RenderContext,
# and change the default shader used.
self.canvas = RenderContext(use_parent_projection=True,
use_parent_modelview=True,
use_parent_frag_modelview=True)
with self.canvas:
self.fbo = Fbo(size=self.size)
self.fbo_color = Color(1, 1, 1, 1)
self.fbo_rect = Rectangle()
with self.fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
# call the constructor of parent
# if they are any graphics object, they will be added on our new canvas
super(ShaderWidget, self).__init__(**kwargs)
# We'll update our glsl variables in a clock
Clock.schedule_interval(self.update_glsl, 0)
def __init__(self, **kwargs):
super(Paintbrush, self).__init__(**kwargs)
self.fbo = Fbo(size=(10, 10))
self.mesh = Mesh()
self.points = []
self.vertices = []
self.indices = []
self.line_widths = []
self.cap_vertices_index = 0
self.cap_indices_index = 0
self.mask_lines = []
self.mask_alphas = []
self.canvas = RenderContext()
self.canvas.shader.fs = mask_shader
self.buffer_container = None
self.rgb = (0, 1, 1)
# We'll update our glsl variables in a clock
Clock.schedule_interval(self.update_glsl, 0)
# Maintain a window of history for autocorrelations
self.ac_window = []
self.ac_position = 0
self.periodicity_factor = 1.0
class MainApp(App):
canvas = RenderContext()
felproc_ova_regel = 2
antal = 1
def build(self):
return GUI
def on_start(self):
#hämta firebase datan
result = requests.get("https://derivataapp1.firebaseio.com/" + str(self.antal) + ".json")
#print("was it okay?", result.ok)
#dekoda binär data från firebase
data = json.loads(result.content.decode())
#print(data)
def change_screen(self, screen_name):
screen_manager = self.root.ids['screen_manager']
screen_manager.current = screen_name
def __init__(self, **kwargs):
# change the default canvas to RenderContext, we can change the shader
self.canvas = RenderContext()
self.canvas.shader.fs = hsv_kinect
# add kinect depth provider, and start the thread
self.kinect = KinectDepth()
self.kinect.start()
# parent init
super(KinectViewer, self).__init__(**kwargs)
# allocate texture for pushing depth
self.texture = Texture.create(
size=(640, 480), colorfmt='luminance', bufferfmt='ushort')
self.texture.flip_vertical()
# create default canvas element
with self.canvas:
Color(1, 1, 1)
Rectangle(size=Window.size, texture=self.texture)
# add a little clock to update our glsl
Clock.schedule_interval(self.update_transformation, 0)
def __init__(self, **kwargs):
# Instead of using canvas, we will use a RenderContext,
# and change the default shader used.
self.canvas = RenderContext(use_parent_projection=True)
# We create a framebuffer at the size of the window
# FIXME: this should be created at the size of the widget
with self.canvas:
self.fbo = Fbo(size=Window.size, use_parent_projection=True)
# Set the fbo background to black.
with self.fbo:
Color(0, 0, 0)
Rectangle(size=Window.size)
# call the constructor of parent
# if they are any graphics object, they will be added on our new canvas
super(ShaderWidget, self).__init__(**kwargs)
# We'll update our glsl variables in a clock
Clock.schedule_interval(self.update_glsl, 0)
# Don't forget to set the texture property to the texture of framebuffer
self.texture = self.fbo.texture
def __init__(self, **kwargs):
self.canvas = RenderContext(use_parent_projection=True)
self.canvas.shader.source = 'multiquad.glsl'
super(QuadRenderer, self).__init__(**kwargs)
self.draw_quads(6000)
def __init__(self):
self.ctx = RenderContext()
self.root = root = Widget()
for x in range(10000):
root.add_widget(Widget())
self.ctx.add(self.root.canvas)
def __init__(self, **kwargs):
super(Renderer, self).__init__(**kwargs)
self.canvas = RenderContext(compute_normal_mat=True)
self.canvas.shader.source = resource_find('simple.glsl')
self._touches = []
def __init__(self, **kwargs):
self.canvas = RenderContext()
super(ShaderViewer, self).__init__(**kwargs)
Clock.schedule_interval(self.update_shader, 0)
def __init__(self, **kwargs):
super(ShaderEditor, self).__init__(**kwargs)
self.test_canvas = RenderContext()
s = self.test_canvas.shader
self.trigger_compile = Clock.create_trigger(self.compile_shaders, -1)
self.bind(fs=self.trigger_compile, vs=self.trigger_compile)
def __init__(self, **kwargs):
self.canvas = RenderContext()
super(ShaderViewer, self).__init__(**kwargs)
self.canvas.shader.fs = fs_header + self.fs
self.canvas.shader.vs = vs_header + self.vs
Clock.schedule_interval(self.update_shader, 0)
def __init__(self, other_widget, **kwargs):
self.other_widget = other_widget
self.canvas = RenderContext(use_parent_projection=True)
self.canvas.shader.source = 'niceline.glsl'
super(NiceLineRenderer, self).__init__(**kwargs)
def __init__(self, **kwargs):
self.canvas = RenderContext(use_parent_projection=True)
self.canvas.shader.source = 'multiquad.glsl'
super(MultiQuadRenderer, self).__init__(**kwargs)
self.draw_mesh_rectangle(20)
self.draw_mesh_rectangle(200)
def __init__(self, *args, **kwargs):
self.canvas = RenderContext(use_parent_projection=True,
use_parent_modelview=True)
Clock.schedule_once(self.post_init, 0)
super().__init__(*args, **kwargs)
def __init__(self, **kwargs):
self.canvas = RenderContext()
self.canvas.shader.fs = alpha_fragment
super(AlphaScatter, self).__init__(**kwargs)
Clock.schedule_once(self.init_shader, 0)
