def initialize_particles(self):
# position (x, y) and velocity (vx, vy) are set on 16 bits.
# value is fitted into [0..2048] range, with 0.03 px precision
texsize = self.texsize
datasize = texsize**2
# initialize positions to be x = y = 1024
v = [32768 for x in xrange(datasize * 2)]
self.particles_pos = pack('H' * datasize * 2, *v)
# initialize velocity to be random, 1024 == 0
v = [
int((random() - 0.5) * 32 + 1024) * 32
for x in xrange(datasize * 2)
]
print[x / 32. - 1024 for x in v[:2]]
self.particles_vel = pack('H' * datasize * 2, *v)
# create textures
self.tex_pos = self._create_texture(self.particles_pos)
self.tex_vel = self._create_texture(self.particles_vel)
self.tex_pos2 = self._create_texture('\x00' * datasize * 4)
self.tex_vel2 = self._create_texture('\x00' * datasize * 4)
self.fbo_pos = Fbo(texture=self.tex_pos, size=self.tex_pos.size)
self.fbo_vel = Fbo(texture=self.tex_vel, size=self.tex_vel.size)
self.fbo_pos2 = Fbo(texture=self.tex_pos2, size=self.tex_pos2.size)
self.fbo_vel2 = Fbo(texture=self.tex_vel2, size=self.tex_vel2.size)
def widgetshot(widget, filename='output.png'):
# detach the widget from the parent
parent = widget.parent
if parent:
parent.remove_widget(widget)
# put the widget canvas on a Fbo
texture = Texture.create(size=widget.size, colorfmt='rgb')
fbo = Fbo(size=widget.size, texture=texture)
fbo.add(widget.canvas)
# clear the fbo background
fbo.bind()
fbo.clear_buffer()
fbo.release()
# draw!
fbo.draw()
# get the fbo data
fbo.bind()
data = glReadPixels(0, 0, widget.size[0], widget.size[1], GL_RGBA,
GL_UNSIGNED_BYTE)
fbo.release()
# save to a file
surf = pygame.image.fromstring(data, widget.size, 'RGBA', True)
pygame.image.save(surf, filename)
# reattach to the parent
if parent:
parent.add_widget(widget)
return True
def __init__(self, **kwargs):
#self.canvas = RenderContext(compute_normal_mat=True)
#self.canvas.shader.source = resource_find('simple.glsl')
self.canvas = Canvas()
self.scene = ObjFileLoader(resource_find("testnurbs.obj"))
self.meshes = []
with self.canvas:
self.fbo = Fbo(size=self.size, with_depthbuffer=True, compute_normal_mat=True, clear_color=(0., 0., 0., 0.))
self.viewport = Rectangle(size=self.size, pos=self.pos)
self.fbo.shader.source = resource_find('simple.glsl')
#self.texture = self.fbo.texture
super(Renderer, self).__init__(**kwargs)
with self.fbo:
#ClearBuffers(clear_depth=True)
self.cb = Callback(self.setup_gl_context)
PushMatrix()
self.setup_scene()
PopMatrix()
self.cb = Callback(self.reset_gl_context)
Clock.schedule_interval(self.update_scene, 1 / 60.)
self._touches = []
def __init__(self, **kwargs):
self.canvas = Canvas()
with self.canvas.before:
Callback(self._set_blend_func)
#self.size
self.fbo_texture = Texture.create(size=self.size, colorfmt='rgba')
self.fbo_texture.mag_filter = 'linear'
self.fbo_texture.min_filter = 'linear'
with self.canvas:
#self.cbs = Callback(self.prepare_canvas)
self.fbo = Fbo(size=self.size, texture=self.fbo_texture)
#Color(1, 1, 1, 0)
#self.fbo_rect = Rectangle()
with self.fbo:
ClearColor(0.0, 0.0, 0.0, 0.0)
ClearBuffers()
self.fbo_rect = Rectangle(size=self.size)
#self.fbo.shader.source = resource_find('./kivy3dgui/gles2.0/shaders/invert.glsl')
#with self.fbo.after:
# self.cbr = Callback(self.reset_gl_context)
# PopMatrix()
with self.canvas.before:
Callback(self._set_blend_func)
# wait that all the instructions are in the canvas to set texture
self.texture = self.fbo.texture
super(FboFloatLayout, self).__init__(**kwargs)
def __init__(self, app):
super(World, self).__init__()
self.size_hint = None, None
self.size = SIZE
self.pos_hint = {'center': (.5, 5)}
self.hive = None
self.rocks = []
self.add_ground()
w, h = SIZE
with self.canvas:
ground_fbo = Fbo(size=self.size)
Rectangle(pos=(0, 0),
size=(w * 2, h * 2),
texture=ground_fbo.texture)
Rectangle(pos=(0, 0), size=(w * 2, h * 2), texture=app.texture)
Rectangle(pos=(0, 0),
size=(w * 2, h * 2),
texture=app.returning_paths_texture)
with ground_fbo:
Color(*STONE_COLOR_FLOAT)
Line(rectangle=[0, 0, w, h], width=4)
for rock in self.rocks:
Line(points=rock.points, close=False, width=4)
ground_fbo.draw()
turn_to_world_array(ground_fbo.texture.pixels)
self.populate()
def screenshot(path, root_widget=None):
"""
Take screenshot of the current state of the app and save it under ``path``.
The sleep- and mainthread-decorator ensure that the app shows the current state properly.
"""
if root_widget is None:
root_widget = MDApp.get_running_app().root
fbo = Fbo(
size=(root_widget.width, root_widget.height),
with_stencilbuffer=True,
)
with fbo:
ClearColor(*MDApp.get_running_app().theme_cls.bg_normal)
ClearBuffers()
Scale(1, -1, 1)
Translate(-root_widget.x, -root_widget.y - root_widget.height, 0)
fbo.add(root_widget.canvas)
fbo.draw()
img = KivyImage(fbo.texture)
img.save(path)
def __init__(self):
self.widget = self.DummyWidget()
self.widget.canvas = Fbo(size=BLOCK_SIZE, clear_color=(0., 0., 0., 0.))
self.texture = GameContext.resources['textures']['water']
self.set_animation(GameContext.resources['animations']['water'])
with self.widget.canvas:
Rectangle(pos=(0, 0), size=BLOCK_SIZE, texture=self.texture)
def __init__(self, **kwargs):
# Make sure opengl context exists
EventLoop.ensure_window()
self.canvas = RenderContext(use_parent_projection=True,
use_parent_modelview=True)
self._callbacks = {}
with self.canvas:
self.fbo = Fbo(size=self.size)
with self.fbo.before: # noqa
PushMatrix()
with self.fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
self._background_color = Color(*self.background_color)
self.fbo_rectangle = Rectangle(size=self.size)
with self.fbo.after: # noqa
PopMatrix()
super(EffectWidget, self).__init__(**kwargs)
fbind = self.fbind
fbo_setup = self.refresh_fbo_setup
fbind('size', fbo_setup)
fbind('effects', fbo_setup)
fbind('background_color', self._refresh_background_color)
self.refresh_fbo_setup()
self._refresh_background_color() # In case thi was changed in kwargs
def __init__(self, **kwargs):
self.canvas = Canvas()
with self.canvas:
self.fbo = Fbo(size=self.size)
super(FboFloatLayout, self).__init__(**kwargs)
def on_parent(self, *args):
if not self.canvas:
Clock.schedule_once(self.on_parent, 0)
return
with self.canvas:
self._fbo = Fbo(size=self.size)
self._translate = Translate(x=self.x, y=self.y)
self._rectangle = Rectangle(size=self.size,
texture=self._fbo.texture)
def __init__(self, **kwargs):
self.canvas = Canvas()
with self.canvas:
self.fbo = Fbo(size=self.size)
Color(1, 1, 1)
self.fbo_rect = Rectangle()
# wait that all the instructions are in the canvas to set texture
self.texture = self.fbo.texture
super(FboFloatLayout, self).__init__(**kwargs)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.add_background(self.user_pos, opacity=self.opacity)
self.canvas = self.backgrounds[0]['render_ctx']
with self.canvas:
self.fbo = Fbo(opacity=self.opacity, size=self.size)
self.fbo_color = Color(1, 1, 1, 1)
self.fbo_rect = Rectangle()
with self.fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
def _redraw(self, *args):
if not self._ffplayer:
return
next_frame = self._next_frame
if not next_frame:
return
img, pts = next_frame
if img.get_size() != self._size or self._texture is None:
self._size = w, h = img.get_size()
if self._out_fmt == 'yuv420p':
w2 = int(w / 2)
h2 = int(h / 2)
self._tex_y = Texture.create(
size=(w, h), colorfmt='luminance')
self._tex_u = Texture.create(
size=(w2, h2), colorfmt='luminance')
self._tex_v = Texture.create(
size=(w2, h2), colorfmt='luminance')
self._fbo = fbo = Fbo(size=self._size)
with fbo:
BindTexture(texture=self._tex_u, index=1)
BindTexture(texture=self._tex_v, index=2)
Rectangle(size=fbo.size, texture=self._tex_y)
fbo.shader.fs = VideoFFPy.YUV_RGB_FS
fbo['tex_y'] = 0
fbo['tex_u'] = 1
fbo['tex_v'] = 2
self._texture = fbo.texture
else:
self._texture = Texture.create(size=self._size,
colorfmt='rgba')
# XXX FIXME
# self.texture.add_reload_observer(self.reload_buffer)
self._texture.flip_vertical()
self.dispatch('on_load')
if self._texture:
if self._out_fmt == 'yuv420p':
dy, du, dv, _ = img.to_memoryview()
if dy and du and dv:
self._tex_y.blit_buffer(dy, colorfmt='luminance')
self._tex_u.blit_buffer(du, colorfmt='luminance')
self._tex_v.blit_buffer(dv, colorfmt='luminance')
self._fbo.ask_update()
self._fbo.draw()
else:
self._texture.blit_buffer(
img.to_memoryview()[0], colorfmt='rgba')
self.dispatch('on_frame')
def __init__(self, **kwargs):
self.canvas = Canvas()
with self.canvas:
self.fbo = Fbo(size=self.size,
with_depthbuffer=True,
compute_normal_mat=True,
clear_color=(0., 0., 0., 0.))
self.viewport = Rectangle(size=self.size, pos=self.pos)
self.fbo.shader.source = resource_find(
join(dirname(__file__), 'simple.glsl'))
super(ObjectRenderer, self).__init__(**kwargs)
def render_widget(self, widget):
# create an FBO to render the widget to
self.tmp_fbo = Fbo(size=self.size)
self.tmp_fbo.add(ClearColor(0, 0, 0, 0))
self.tmp_fbo.add(ClearBuffers())
self.tmp_fbo.add(widget.canvas)
self.tmp_fbo.draw()
# render a rectangle in the main fbo containing the content from the widget
with self.fbo:
Color(1, 1, 1, 1)
Rectangle(texture=self.tmp_fbo.texture, size=self.tmp_fbo.size)
def __init__(self, **kw):
self.shader_file = kw.pop("shader_file", None)
self.canvas = Canvas()
super(Renderer, self).__init__(**kw)
with self.canvas:
self._viewport = Rectangle(size=self.size, pos=self.pos)
self.fbo = Fbo(size=self.size,
with_depthbuffer=True, compute_normal_mat=True,
clear_color=(0., 0., 0., 0.))
self._config_fbo()
self.texture = self.fbo.texture
self.camera = None
self.scene = None
def __init__(self, colors=(Color(1, 0, 1)), *args, **kwargs):
if 'height' not in kwargs:
kwargs['height'] = 32
self.fbo = Fbo()
with self.fbo:
Color(1, 1, 1)
self.fboscrollrect = Rectangle(pos=(-1, 0))
Color(0, 0, 0)
self.fboclearrect = Rectangle()
self.points = []
self.colors = []
for color in colors:
self.colors.append(Color(*color.rgba))
self.points.append(Point(points=(), pointsize=0.5))
super().__init__(*args, **kwargs)
def export(self, wid, *largs):
fbo = Fbo(size=wid.size, with_stencilbuffer=True)
with fbo:
ClearColor(1, 1, 1, 1)
ClearBuffers()
#Scale(1, -1, 1)
#Translate(-self.x, -self.y - self.height, 0)
fbo.add(wid.canvas)
fbo.draw()
img = fbo.texture
img.save('test.png')
fbo.remove(wid.canvas)
def __init__(self, **kwargs):
LOP, dm = initFiles()
#self.canvas = RenderContext(compute_normal_mat=True)
#self.canvas.shader.source = resource_find('simple.glsl')
self.canvas = Canvas()
self.scene = ObjFileLoader(resource_find("testnurbs.obj"))
self.LOP = LOP
self.dm = dm
self.meshes = []
self.panCamera = False # KEITH EDIT
self.pause = True # KEITH EDIT
with self.canvas:
self.fbo = Fbo(size=self.size, with_depthbuffer=True, compute_normal_mat=True, clear_color=(0., 0., 0., 0.))
self.viewport = Rectangle(size=self.size, pos=self.pos)
self.fbo.shader.source = resource_find('simple.glsl')
#self.texture = self.fbo.texture
# *&Y*&Y*&YH*&Y*&Y*&Y*Y&*
# Keith: This allows keyboard interaction
# http://stackoverflow.com/questions/22137786/
self._keyboard = Window.request_keyboard(None, self)
if not self._keyboard:
return
self._keyboard.bind(on_key_down=self.on_keyboard_down)
# *&Y*&Y*&YH*&Y*&Y*&Y*Y&*
super(NSpect, self).__init__(**kwargs)
with self.fbo:
#ClearBuffers(clear_depth=True)
self.cb = Callback(self.setup_gl_context)
PushMatrix()
self.setup_scene(self.LOP, dm)
PopMatrix()
self.cb = Callback(self.reset_gl_context)
Clock.schedule_interval(self.update_scene, 1 / 60.)
self._touches = []
def _setup_fbo(self, element, settings):
"""Setup FBO for a display."""
source = self.machine.displays[element]
# put the widget canvas on a Fbo
texture = Texture.create(size=source.size, colorfmt='rgb')
fbo = Fbo(size=source.size, texture=texture)
effect_widget = EffectWidget()
effect_list = list()
effect_widget.effects = effect_list
effect_widget.size = source.size
fbo.add(effect_widget.canvas)
return [fbo, effect_widget, source, settings, True]
def _setup_fbo(self, element, settings, context):
"""Setup FBO for a display."""
if element not in self.machine.displays:
raise AssertionError("Display {} not found. Please create it to use display_light_player.".format(element))
source = self.machine.displays[element]
# put the widget canvas on a Fbo
texture = Texture.create(size=source.size, colorfmt='rgba')
fbo = Fbo(size=source.size, texture=texture)
effect_widget = RelativeLayout()
effect_widget.size = source.size
fbo.add(effect_widget.canvas)
with source.canvas:
callback = Callback(partial(self._trigger_render, context, element))
return [fbo, effect_widget, source, settings, True, True, True, callback]
def __init__(self, mc: "MpfMc", name: str, config: dict) -> None:
"""Initialise DMD."""
self.mc = mc
self.name = name
self.mc.log.info('Initializing DMD')
self.config = self._get_validated_config(config)
self.source = self.mc.displays[self.config['source_display']]
self.prev_data = None
self._dirty = True
# put the widget canvas on a Fbo
texture = Texture.create(size=self.source.size, colorfmt='rgb')
self.fbo = Fbo(size=self.source.size, texture=texture)
self.effect_widget = EffectWidget()
effect_list = list()
effect_list.append(FlipVerticalEffect())
if self.config['brightness'] != 1.0:
if not 0.0 <= self.config['brightness'] <= 1.0:
raise ValueError("DMD brightness value should be between 0.0 "
"and 1.0. Yours is {}".format(
self.config['brightness']))
effect_list.append(GainEffect(gain=self.config['brightness']))
if self.config['gamma'] != 1.0:
effect_list.append(GammaEffect(gamma=self.config['gamma']))
self.effect_widget.effects = effect_list
self.effect_widget.size = self.source.size
self.fbo.add(self.effect_widget.canvas)
with self.source.canvas:
self.callback = Callback(self._trigger_rendering)
self._set_dmd_fps()
def create_image(self):
parent = self.parent
if parent:
canvas_parent_index = parent.canvas.indexof(self.canvas)
if canvas_parent_index > -1:
parent.canvas.remove(self.canvas)
fbo = Fbo(size=self.size, with_stencilbuffer=True)
with fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
Scale(1, -1, 1)
Translate(-self.x, -self.y - self.height, 0)
fbo.add(self.canvas)
fbo.draw()
image = Image.frombytes('RGBA', list(map(int, self.size)),
fbo.texture.pixels, 'raw', 'RGBA', 0, 1)
fbo.remove(self.canvas)
if parent is not None and canvas_parent_index > -1:
parent.canvas.insert(canvas_parent_index, self.canvas)
return image
def __init__(self, **kwargs):
self.canvas = Canvas()
with self.canvas:
self.fbo = Fbo(
size=self.size,
with_depthbuffer=True,
)
self.fbo_color = Color(1, 1, 1, 1)
self.viewport = Rectangle(
pos=self.pos,
size=self.size,
)
with self.fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
self.texture = self.fbo.texture
super(TransparentLayout, self).__init__(**kwargs)
def screenshot(widget, filename='output.png', region=None):
if widget.parent is not None:
canvas_parent_index = widget.parent.canvas.indexof(widget.canvas)
widget.parent.canvas.remove(widget.canvas)
fbo = Fbo(size=widget.size)
with fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
Translate(-widget.x, -widget.y, 0)
fbo.add(widget.canvas)
fbo.draw()
fbo.texture.save(filename)
fbo.remove(widget.canvas)
if widget.parent is not None:
widget.parent.canvas.insert(canvas_parent_index, widget.canvas)
return True
def __init__(self, **kwargs):
self.canvas = Canvas()
self.scene = ObjFileLoader(resource_find("brain.obj"))
self.meshes = []
with self.canvas:
self.fbo = Fbo(size=self.size,
with_depthbuffer=True,
compute_normal_mat=True,
clear_color=(0., 0., 0., 0.))
self.viewport = Rectangle(size=self.size, pos=(0, -150))
self.fbo.shader.source = resource_find('simple.glsl')
super(Renderer, self).__init__(**kwargs)
with self.fbo:
self.cb = Callback(self.setup_gl_context)
PushMatrix()
self.setup_scene()
PopMatrix()
self.cb = Callback(self.reset_gl_context)
def _setup_fbo(self, element, settings):
"""Setup FBO for a display."""
if element not in self.machine.displays:
raise AssertionError(
"Display {} not found. Please create it to use display_light_player."
.format(element))
source = self.machine.displays[element]
# put the widget canvas on a Fbo
texture = Texture.create(size=source.size, colorfmt='rgb')
fbo = Fbo(size=source.size, texture=texture)
effect_widget = EffectWidget()
effect_list = list()
effect_widget.effects = effect_list
effect_widget.size = source.size
fbo.add(effect_widget.canvas)
return [fbo, effect_widget, source, settings, True]
def screenshot_texture(widget, factory_func):
if widget.parent is not None:
canvas_parent_index = widget.parent.canvas.indexof(widget.canvas)
widget.parent.canvas.remove(widget.canvas)
fbo = Fbo(size=widget.size)
with fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
Translate(-widget.x, -widget.y, 0)
fbo.add(widget.canvas)
fbo.draw()
result = factory_func(fbo.texture)
fbo.remove(widget.canvas)
if widget.parent is not None:
widget.parent.canvas.insert(canvas_parent_index, widget.canvas)
return result
def __init__(self, mc, name, config):
"""Initialise DMD."""
self.mc = mc
self.name = name
self.mc.log.info('Initializing Physical DMD')
self.config = self._get_validated_config(config)
self.source = self.mc.displays[self.config['source_display']]
self.prev_data = None
# put the widget canvas on a Fbo
texture = Texture.create(size=self.source.size, colorfmt='rgb')
self.fbo = Fbo(size=self.source.size, texture=texture)
self.effect_widget = EffectWidget()
effect_list = list()
effect_list.append(FlipVertical())
if self.config['brightness'] != 1.0:
if not 0.0 <= self.config['brightness'] <= 1.0:
raise ValueError("DMD brightness value should be between 0.0 "
"and 1.0. Yours is {}".format(
self.config['brightness']))
effect_list.append(Gain(gain=self.config['brightness']))
self.effect_widget.effects = effect_list
self.effect_widget.size = self.source.size
self.fbo.add(self.effect_widget.canvas)
self._set_dmd_fps()
def __init__(self,
filename=None,
onload=None,
maxtexsize=(1024, 1024),
**kwargs):
if maxtexsize == None:
maxtexsize = (1024, 1024)
self.canvas = Canvas()
with self.canvas:
self.fbo = Fbo(size=maxtexsize)
self.fbo.add_reload_observer(self.updateFbo)
self.border_image = CoreImage('data/shadow32.png')
self.img_texture = Texture.create(size=(16, 16), colorfmt="rgba")
self.alpha = 0
self.fbo_texture = self.fbo.texture
super(Picture, self).__init__(**kwargs)
self.loadImage(filename, onload)
