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, 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.0) self._touches = []
def resolve_font_name(self): options = self.options fontname = options['font_name'] fonts = self._fonts fontscache = self._fonts_cache # is the font registered? if fontname in fonts: # return the preferred font for the current bold/italic combination italic = int(options['italic']) if options['bold']: bold = FONT_BOLD else: bold = FONT_REGULAR options['font_name_r'] = fonts[fontname][italic | bold] elif fontname in fontscache: options['font_name_r'] = fontscache[fontname] else: filename = resource_find(fontname) if not filename and not fontname.endswith('.ttf'): fontname = '{}.ttf'.format(fontname) filename = resource_find(fontname) if filename is None: # XXX for compatibility, check directly in the data dir filename = os.path.join(kivy_data_dir, fontname) if not os.path.exists(filename): raise IOError('Label: File %r not found' % fontname) fontscache[fontname] = filename options['font_name_r'] = filename
def setup_scene(self): self.scene = App.get_running_app().map_model normal_txt = resource_find('apps/population/map/iowa_tex.png') map_txt = resource_find(self.map_texture) Translate(0,-.12,-2) self.rot = Rotate(0, 0,1,0) # tilt Rotate(-0, 0,1,0) # tilt self.roty = Rotate(0,1,0,0) Rotate(-30, 1,0,0) # tilt Scale(1.8) Translate(0,.25, 0.05) self.meshes = {} self.mesh_transforms = {} self.mesh_colors = {} self.start_t = {} Color(1,1,1,1) for name, mesh in self.scene.objects.iteritems(): self.tex_binding_1 = BindTexture(source=self.map_texture, index=1) self.render_ctx['texture1'] = 1 PushMatrix() self.start_t[name] = 1.0# random.random() self.mesh_colors[name] = Color(1,1,1,1) self.mesh_transforms[name] = MatrixInstruction() self.meshes[name] = Mesh( vertices=mesh.vertices, indices=mesh.indices, fmt = mesh.vertex_format, mode = 'triangles', source = normal_txt ) Color(1,1,1,1) PopMatrix()
def resolve_font_name(self): options = self.options fontname = options["font_name"] fonts = self._fonts fontscache = self._fonts_cache # is the font is registered ? if fontname in fonts: # return the prefered font for the current bold/italic combinaison italic = int(options["italic"]) if options["bold"]: bold = FONT_BOLD else: bold = FONT_REGULAR options["font_name_r"] = fonts[fontname][italic | bold] elif fontname in fontscache: options["font_name_r"] = fontscache[fontname] else: filename = resource_find(fontname) if not filename: fontname = fontname + ("" if fontname.endswith(".ttf") else ".ttf") filename = resource_find(fontname) if filename is None: # XXX for compatibility, check directly in the data dir filename = os.path.join(kivy_data_dir, fontname) if not os.path.exists(filename): raise IOError("Label: File %r not found" % fontname) fontscache[fontname] = filename options["font_name_r"] = filename
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.canvas = Canvas() self.c_front = RenderContext() self.c_front.shader.source = resource_find('front.glsl') self.c_back = RenderContext() self.c_back.shader.source = resource_find('back.glsl') self.c_backshadow = RenderContext() self.c_backshadow.shader.source = resource_find('backshadow.glsl') self.canvas.add(self.c_front) self.canvas.add(self.c_back) self.canvas.add(self.c_backshadow) with self.canvas.before: Color(1, 1, 1) Rectangle( size=self.fbo_in.size, texture=self.fbo_in.texture) Callback(self._enter_3d) self._build_mesh(self.fbo_in.size) with self.canvas.after: Callback(self._leave_3d) self.manager.canvas.add(self.canvas)
def get_application_icon(self): """Return the icon of the application. """ if not resource_find(self.icon): return "" else: return resource_find(self.icon)
def __init__(self, **kwargs): _vs = kwargs.pop('vs', "") _fs = kwargs.pop('fs', "") self.canvas = Canvas() with self.canvas: fbo_size = self.width*2, self.height*2 self.fbo = Fbo(size=fbo_size, with_depthbuffer=True, do_clear=True) self.fbo_color = Color(1, 1, 1, 1) self.fbo_rect = Rectangle() with self.fbo: self.cb = Callback(self.setup_gl_context) self.render_ctx = RenderContext(with_normal_mat=True) self.cb2 = Callback(self.reset_gl_context) with self.render_ctx: PushMatrix() self.setup_scene() PopMatrix(); # wait that all the instructions are in the canvas to set texture self.texture = self.fbo.texture super(Renderer, self).__init__(**kwargs) #must be set in right order on some gpu, or fs will fail linking self.vs = open(resource_find("data/shaders/map.vs")).read() self.fs = open(resource_find("data/shaders/map.fs")).read() self.population_data = json.load(open(resource_find('data/county_population.json'), 'r')) self.calulcate_population_bounds() Clock.schedule_interval(self.update_glsl, 1 / 60.)
def __init__(self, **kwargs): self.aspect = 1.0 self.app = App.get_running_app() self.map_model = self.app.map_model self.counties = self.app.counties self.setup() self.canvas = Canvas() with self.canvas: fbo_size = self.width, self.height self.fbo = Fbo(size=fbo_size, with_depthbuffer=True, do_clear=True) self.fbo_color = Color(1, 1, 1, 1) self.fbo_rect = Rectangle() with self.fbo: self.cb = Callback(self.setup_gl_context) self.render_ctx = RenderContext(with_normal_mat=True) self.cb2 = Callback(self.reset_gl_context) self.init_scene() with self.render_ctx: PushMatrix() self.render_canvas = Canvas() PopMatrix(); with self.render_canvas: self.render_scene() self.texture = self.fbo.texture super(MapView, self).__init__(**kwargs) #must be set in right order on some gpu, or fs will fail linking self.render_ctx.shader.vs = open(resource_find("data/shaders/map.vs")).read() self.render_ctx.shader.fs = open(resource_find('data/shaders/map.fs')).read() Clock.schedule_interval(self.update_glsl, 1 / 60.)
def get_application_icon(self): '''Return the icon of the application. ''' if not resource_find(self.icon): return '' else: return resource_find(self.icon)
def _setup_object(self): self.clear_widgets() if is_ios(): # TODO enable this when iOS bug is resolved return shader_file = resource_find(os.path.join('resource', 'models', 'shaders.glsl')) obj_path = resource_find(self.model_path) self.renderer = Renderer(shader_file=shader_file) scene = Scene() camera = PerspectiveCamera(15, 1, 1, 1000) loader = OBJLoader() obj = loader.load(obj_path) scene.add(*obj.children) for obj in scene.children: obj.pos.x = self.position_x obj.pos.y = self.position_y obj.pos.z = self.position_z obj.rotation.x = self.rotation_x obj.rotation.y = self.rotation_y obj.rotation.z = self.rotation_z obj.material.specular = .85, .85, .85 obj.material.color = 1.0, 1.0, 1.0 obj.material.diffuse = 0.5, 0.5, 0.5 obj.material.transparency = 1.0 obj.material.intensity = 0.5 self.imu_obj = obj # obj.material.shininess = 1.0 self.renderer.render(scene, camera) self.renderer.bind(size=self._adjust_aspect) Clock.schedule_once(lambda dt: self.add_widget(self.renderer))
def on_source(self, *args): v = self.source.split(".") source_down = ''.join(v[:-1])+"_down"+v[-1] self._fname_normal = resource_find(self.source) self._fname_down = resource_find(source_down) or self._fname_normal self.image_size = CoreImage.load(self._fname_normal).size self.background_normal = self._fname_normal self.background_down = self._fname_down
def load_kv(self, filename=None): '''This method is invoked the first time the app is being run if no widget tree has been constructed before for this app. This method then looks for a matching kv file in the same directory as the file that contains the application class. For example, say you have a file named main.py that contains:: class ShowcaseApp(App): pass This method will search for a file named `showcase.kv` in the directory that contains main.py. The name of the kv file has to be the lowercase name of the class, without the 'App' postfix at the end if it exists. You can define rules and a root widget in your kv file:: <ClassName>: # this is a rule ... ClassName: # this is a root widget ... There must be only one root widget. See the :doc:`api-kivy.lang` documentation for more information on how to create kv files. If your kv file contains a root widget, it will be used as self.root, the root widget for the application. ''' # Detect filename automatically if it was not specified. if filename: filename = resource_find(filename) else: try: default_kv_directory = dirname(getfile(self.__class__)) if default_kv_directory == '': default_kv_directory = '.' except TypeError: # if it's a builtin module.. use the current dir. default_kv_directory = '.' kv_directory = self.kv_directory or default_kv_directory clsname = self.__class__.__name__.lower() if (clsname.endswith('app') and not isfile(join(kv_directory, '%s.kv' % clsname))): clsname = clsname[:-3] filename = join(kv_directory, '%s.kv' % clsname) # Load KV file Logger.debug('App: Loading kv <{0}>'.format(filename)) rfilename = resource_find(filename) if rfilename is None or not exists(rfilename): Logger.debug('App: kv <%s> not found' % filename) return False root = Builder.load_file(rfilename) if root: self.root = root return True
def build_layout(self): self.bg = Image(source=resource_find("joystick_bg.png"), keep_ratio=False, allow_stretch=True) self.stick = Image(source=resource_find("joystick_fg.png"), keep_ratio=False, allow_stretch=True) self.add_widget(self.bg) self.add_widget(self.stick) Link(self.bg, size=self, align_xy=self) Link(self.stick, size=(0.5, self)) self.bind(pos=self.reposition_stick, size=self.reposition_stick)
def __init__(self, client, **kwargs): self.canvas = RenderContext(use_parent_projection=True) self.client = client super(Section, self).__init__(**kwargs) self.canvas.shader.fs = open(resource_find('shaders/section_fragment.glsl')).read() self.canvas.shader.vs = open(resource_find('shaders/section_vertex.glsl')).read() self.recalc()
def __init__(self, **kwargs): super(Knobs3D, self).__init__(**kwargs) with self.canvas: self.fbo = Fbo(with_depthbuffer = True,compute_normal_mat=True,size = Window.size) Rectangle(size=Window.size, texture=self.fbo.texture) self.fbo.add_reload_observer(self.test) self.fbo.shader.source = resource_find('simple.glsl') #self.canvas = RenderContext(compute_normal_mat=True) #self.canvas.shader.source = resource_find('simple.glsl') self.scene = ObjFile(resource_find("obj/knobs3D.obj"))
def start_stage(self, restart=False): '''Called to start the experiment. If restart is True, it'll try to recover the experiment using :attr:`recovery_file`. It creates and starts the :class:`RootStage`. ''' self.exception_value = '' try: self.barst_stage = None self.app_state = 'running' root = self.base_stage self.base_stage = None if root is not None: def clear_name(stage): stage.name = '' for child in stage.stages: clear_name(child) clear_name(root) parser = self.dev_configparser config_path = resources.resource_find('config.ini') if parser is None: parser = self.dev_configparser = \ ConfigParser(name=device_config_name) if not config_path: config_path = join(self.data_directory, 'config.ini') with open(config_path, 'w'): pass parser.read(config_path) parser.write() parser = self.experiment_configparser config_path = resources.resource_find(self.exp_config_path) if parser is None: parser = self.experiment_configparser = \ ConfigParser(name=exp_config_name) if not config_path: self.exp_config_path = config_path = join(self.data_directory, 'experiment.ini') with open(config_path, 'w'): pass parser.read(config_path) parser.write() root = self.base_stage = RootStage() except Exception as e: self.exception_value = '{}\n\n\n{}'.format(e, traceback.format_exc()) logging.exception(self.exception_value) self.app_state = 'clear' return if restart and isfile(self.recovery_file): self.recover_state(self.recovery_file, stage=root) root.step_stage()
def __init__(self, **kwargs): self.canvas = RenderContext() self._tpath = resource_find('mini-diffuse.png') self.canvas.shader.source = resource_find('simple.glsl') super(Renderer, self).__init__(**kwargs) with self.canvas: PushMatrix() self.setup_scene() PopMatrix() Clock.schedule_interval(self.update_glsl, 1 / 60.)
def __init__(self, **kwargs): self.canvas = RenderContext(compute_normal_mat=True) self.canvas.shader.source = resource_find('simple.glsl') self.scene = ObjFile(resource_find("monkey.obj")) super(Renderer, self).__init__(**kwargs) with self.canvas: self.cb = Callback(self.setup_gl_context) PushMatrix() self.setup_scene() PopMatrix() self.cb = Callback(self.reset_gl_context) Clock.schedule_interval(self.update_glsl, 1 / 60.)
def draw_keys(self): layout = self.available_layouts[self.layout] layout_rows = layout['rows'] layout_geometry = self.layout_geometry layout_mode = self.layout_mode # draw background w, h = self.size background = resource_find(self.background) texture = Image(background, mipmap=True).texture self.background_key_layer.clear() with self.background_key_layer: Color(*self.background_color) BorderImage(texture=texture, size=self.size, border=self.background_border) # XXX seperate drawing the keys and the fonts to avoid # XXX reloading the texture each time # first draw keys without the font key_normal = resource_find(self.key_background_normal) texture = Image(key_normal, mipmap=True).texture with self.background_key_layer: for line_nb in range(1, layout_rows + 1): for pos, size in layout_geometry['LINE_%d' % line_nb]: BorderImage(texture=texture, pos=pos, size=size, border=self.key_border) self.labels = [] font_size = int(w) / 60 key_nb = 0 for pos, size in layout_geometry['LINE_1']: # retrieve the relative text text = layout[layout_mode + '_1'][key_nb][0] l = Label(text=text, font_size=font_size, pos=pos, size=size, font_name=self.font_name) self.add_widget(l) self.labels.append(l) key_nb += 1 # then draw the text # calculate font_size font_size = int(w) / 46 # draw for line_nb in range(2, layout_rows + 1): key_nb = 0 for pos, size in layout_geometry['LINE_%d' % line_nb]: # retrieve the relative text text = layout[layout_mode + '_' + str(line_nb)][key_nb][0] l = Label(text=text, font_size=font_size, pos=pos, size=size, font_name=self.font_name) self.add_widget(l) key_nb += 1
def __init__(self, **kwargs): super(PageCurl, self).__init__(**kwargs) self.c_front = RenderContext() self.c_front.shader.source = resource_find('front.glsl') self.c_back = RenderContext() self.c_back.shader.source = resource_find('back.glsl') self.c_backshadow = RenderContext() self.c_backshadow.shader.source = resource_find('backshadow.glsl') self.canvas.add(self.c_front) self.canvas.add(self.c_back) self.canvas.add(self.c_backshadow) self.texture = CoreImage(self.source).texture Clock.schedule_interval(self.update_glsl, 1 / 60.)
def __init__(self, grasp, **kwargs): self.grasp = grasp self.canvas = RenderContext(compute_normasl_mat=True) self.canvas.shader.source = resource_find('simple.glsl') self.scene = ObjFile(resource_find(self.grasp.obj_file)) #self.scene = ObjFile(resource_find('Co_clean.obj')) super(Renderer, self).__init__(**kwargs) with self.canvas: self.cb = Callback(self.setup_gl_context) PushMatrix() self.setup_scene() PopMatrix() self.cb = Callback(self.reset_gl_context) Clock.schedule_once(self.rot_up) Clock.schedule_once(self.rot_left)
def __init__(self, **kwargs): # self.canvas=InstructionGroup() self.canvas = RenderContext(compute_normal_mat=True) self.canvas.shader.source = resource_find("simple.glsl") print sys.argv[1] self.scene = ObjFile(resource_find(sys.argv[1])) # print self.scene.mtl super(meshv, self).__init__(**kwargs) # self.add_widget(Sprite( # size=(200,200), # center=(1000,200) # )) global texture_id_ texture_id_ = {} global global_texture_filename global_texture_filename = "checkerboard.jpg" global global_uv_filename global_uv_filename = "checkerboard.jpg" for id in range(0, len(self.scene.objects)): shutil.copyfile( os.path.split(sys.argv[1])[0] + "/texture/" + self.scene.material.values()[id] + ".png", os.path.split(sys.argv[1])[0] + "/texture/tmp_" + self.scene.material.values()[id] + ".png", ) self.checkerboard_statue = 0 with self.canvas: self.cb = Callback(self.setup_gl_context) PushMatrix() self.setup_scene() PopMatrix() # Color(0, 1, 1, 0.6) # self.rect = Rectangle(size=self.size,pos=self.pos) self.cb = Callback(self.reset_gl_context) self.camera_loc = [0, 1, 0] self.camera_up = [0, 0, 1] self.camera_r = 2 Clock.schedule_once(self.update_glsl, 1 / 60.0) self._touches = [] self.texture_id = 0 # self.btn_next_texture() self._keyboard = Window.request_keyboard(self._keyboard_closed, self) self._keyboard.bind(on_key_down=self._on_keyboard_down)
def draw_object(self, obj_id): m = self._scene.objects[obj_id] self.obj_rot_x = Rotate(self.obj_rotation[0], 1, 0, 0) self.obj_rot_y = Rotate(self.obj_rotation[1], 0, 1, 0) self.obj_rot_z = Rotate(self.obj_rotation[2], 0, 0, 1) self.obj_translate = Translate(xyz=self.obj_translation) if len(m.indices) > 2 ** 16: print('%s too big! %s indices' % (obj_id, len(m.indices))) if m.texture: print("loading texture %s " % m.texture) img = Image(source=resource_find( join(dirname(self.scene), m.texture))) texture = img.texture if texture: texture.wrap = 'repeat' else: texture = None vertex_lenght = sum(x[1] for x in m.vertex_format) if len(m.vertices) % vertex_lenght: print(( ( 'warning: vertices lenght (%s)' 'is not a multiple of vertex_format lenght(%s)' ) % (len(m.vertices), vertex_lenght))) Mesh( vertices=m.vertices, indices=m.indices, fmt=m.vertex_format, texture=texture, mode=self.mode)
def create_motion_blur(self): self.motion_blur_fbo = Fbo(size=PICKING_BUFFER_SIZE, with_depthbuffer=True, compute_normal_mat=True, clear_color=(1.0, 1.0, 1.0, 0.0)) self.motion_blur_fbo.shader.source = resource_find('./kivy3dgui/gles2.0/shaders/dop.glsl')
def texture_update(self, *largs): if not self.source: self.texture = None else: filename = resource_find(self.source) self._loops = 0 if filename is None: return Logger.error('Image: Error reading file {filename}'. format(filename=self.source)) mipmap = self.mipmap if self._coreimage is not None: self._coreimage.unbind(on_texture=self._on_tex_change) try: if PY2 and isinstance(filename, str): filename = filename.decode('utf-8') self._coreimage = ci = CoreImage(filename, mipmap=mipmap, anim_delay=self.anim_delay, keep_data=self.keep_data, nocache=self.nocache) except: Logger.error('Image: Error loading texture {filename}'. format(filename=self.source)) self._coreimage = ci = None if ci: ci.bind(on_texture=self._on_tex_change) self.texture = ci.texture
def _do_video_load(self, *largs): if self._video: self._video.stop() if not self.source: self._video = None self.textures = [None, None, None] self.texture = None else: filename = self.source if filename.split(':')[0] not in ( 'http', 'https', 'file', 'udp', 'rtp', 'rtsp'): filename = resource_find(filename) self._video = VideoYuv(filename=filename, format=self.format, colorfmt=self.colorfmt, size=self.yuv_size, fps=self.yuv_fps) self._video.volume = self.volume self._video.bind(on_load=self._on_video_load, on_frame=self._on_video_frame, on_eos=self._on_eos) if self.state == 'play' or self.play: self._video.play() self.duration = 1. self.position = 0.
def register(name, fn_regular, fn_italic=None, fn_bold=None, fn_bolditalic=None): '''Register an alias for a Font. .. versionadded:: 1.1.0 If you're using a ttf directly, you might not be able to use the bold/italic properties of the ttf version. If the font is delivered in multiple files (one regular, one italic and one bold), then you need to register these files and use the alias instead. All the fn_regular/fn_italic/fn_bold parameters are resolved with :func:`kivy.resources.resource_find`. If fn_italic/fn_bold are None, fn_regular will be used instead. ''' fonts = [] for font_type in fn_regular, fn_italic, fn_bold, fn_bolditalic: if font_type is not None: font = resource_find(font_type) if font is None: raise IOError('File {0}s not found'.format(font_type)) else: fonts.append(font) else: fonts.append(fonts[-1]) # add regular font to list again LabelBase._fonts[name] = tuple(fonts)
def on_source(self, instance, value): if not value: self.texture = None else: filename = resource_find(value) image = CoreImage(filename) self.texture = image.texture
def load_file(self, filename, **kwargs): '''Insert a file into the language builder and return the root widget (if defined) of the kv file. :parameters: `rulesonly`: bool, defaults to False If True, the Builder will raise an exception if you have a root widget inside the definition. ''' filename = resource_find(filename) or filename if __debug__: trace('Lang: load file %s' % filename) with open(filename, 'r') as fd: kwargs['filename'] = filename data = fd.read() # remove bom ? if PY2: if data.startswith((codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE)): raise ValueError('Unsupported UTF16 for kv files.') if data.startswith((codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE)): raise ValueError('Unsupported UTF32 for kv files.') if data.startswith(codecs.BOM_UTF8): data = data[len(codecs.BOM_UTF8):] return self.load_string(data, **kwargs)
def _set_shape(self, shape_image, mode='default', cutoff=False, color_key=None): modes = ('default', 'binalpha', 'reversebinalpha', 'colorkey') color_key = color_key or (0, 0, 0, 1) if mode not in modes: Logger.warning( 'Window: shape mode can be only ' '{}'.format(', '.join(modes)) ) return if not isinstance(color_key, (tuple, list)): return if len(color_key) not in (3, 4): return if len(color_key) == 3: color_key = (color_key[0], color_key[1], color_key[2], 1) Logger.warning( 'Window: Shape color_key must be only tuple or list' ) return color_key = ( color_key[0] * 255, color_key[1] * 255, color_key[2] * 255, color_key[3] * 255 ) assert cutoff in (1, 0) shape_image = shape_image or Config.get('kivy', 'window_shape') shape_image = resource_find(shape_image) or shape_image self._win.set_shape(shape_image, mode, cutoff, color_key)
def __init__(self, *args, **kwargs): super(LineRenderer, self).__init__(**kwargs) self.render_context.shader.source = resource_find('line_renderer.glsl') self.mesh = Mesh(fmt=[(b'v_pos', 2, 'float'), (b'v_parm', 1, 'float')]) self.mesh.mode = 'lines' self.render_context.add(self.mesh) self.updateModelViewMatrix()
def load_kv(self, filename=None): '''This method is invoked the first time the app is being run if no widget tree has been constructed before for this app. This method then looks for a matching kv file in the same directory as the file that contains the application class. For example, if you have a file named main.py that contains:: class ShowcaseApp(App): pass This method will search for a file named `showcase.kv` in the directory that contains main.py. The name of the kv file has to be the lowercase name of the class, without the 'App' postfix at the end if it exists. You can define rules and a root widget in your kv file:: <ClassName>: # this is a rule ... ClassName: # this is a root widget ... There must be only one root widget. See the :doc:`api-kivy.lang` documentation for more information on how to create kv files. If your kv file contains a root widget, it will be used as self.root, the root widget for the application. ''' # Detect filename automatically if it was not specified. if filename: filename = resource_find(filename) else: try: default_kv_directory = dirname(getfile(self.__class__)) if default_kv_directory == '': default_kv_directory = '.' except TypeError: # if it's a builtin module.. use the current dir. default_kv_directory = '.' kv_directory = self.options.get('kv_directory', default_kv_directory) clsname = self.__class__.__name__ if clsname.endswith('App'): clsname = clsname[:-3] filename = join(kv_directory, '%s.kv' % clsname.lower()) # Load KV file Logger.debug('App: Loading kv <{0}>'.format(filename)) if not exists(filename): Logger.debug('App: kv <%s> not found' % filename) return False root = Builder.load_file(filename) if root: self.root = root return True
def __init__(self, **kwargs): self.shadow = kwargs.get("shadow", False) global PICKING_BUFFER_SIZE PICKING_BUFFER_SIZE = kwargs.get("canvas_size", Window.size) self.shadow = True self.picking = True self.co = self.canvas self.canvas = RenderContext(compute_normal_mat=False) #self.canvas.shader.source = resource_find('./kivy3dgui/gles2.0/shaders/simple_no_light.glsl') self.canvas.shader.source = resource_find( './kivy3dgui/gles2.0/toonshader/toon.glsl') self.alpha = 0.0 self._touches = [] with self.canvas: self._translate = Translate(0, 0, 0) self._rotate = Rotate(0.0, 1.0, 0.0, 0.0) PushMatrix() self.cbs = Callback(self.setup_gl_context) if self.shadow: self.create_fbo() if self.picking: self.create_picking_fbo() self.create_motion_blur() with self.canvas.before: self.cbs = Callback(self.setup_gl_context) if self.shadow: BindTexture(texture=self.fbo.texture, index=1) BindTexture(texture=self.motion_blur_fbo.texture, index=5) PushMatrix() self.setup_scene() PopMatrix() PushMatrix() self.cc = Callback(self.check_context) PopMatrix() UpdateNormalMatrix() with self.canvas.after: self.cbr = Callback(self.reset_gl_context) PopMatrix() #Fixing Shadow and Picking self.shadow = True self.picking = True if self.shadow: self.init_fbo() if self.picking: self.init_picking() self.init_motion_blur() super(Canvas3D, self).__init__(**kwargs) Clock.schedule_interval(self.update_glsl, 1 / 60.) self._touches = {}
def draw_keys(self): layout = self.available_layouts[self.layout] layout_rows = layout['rows'] layout_geometry = self.layout_geometry layout_mode = self.layout_mode # draw background background = resource_find(self.background_disabled if self.disabled else self.background) texture = Image(background, mipmap=True).texture self.background_key_layer.clear() with self.background_key_layer: Color(*self.background_color) BorderImage(texture=texture, size=self.size, border=self.background_border) # XXX separate drawing the keys and the fonts to avoid # XXX reloading the texture each time # first draw keys without the font key_normal = resource_find(self.key_background_disabled_normal if self.disabled else self.key_background_normal) texture = Image(key_normal, mipmap=True).texture with self.background_key_layer: Color(*self.key_background_color) for line_nb in range(1, layout_rows + 1): for pos, size in layout_geometry['LINE_%d' % line_nb]: BorderImage(texture=texture, pos=pos, size=size, border=self.key_border) # then draw the text for line_nb in range(1, layout_rows + 1): key_nb = 0 for pos, size in layout_geometry['LINE_%d' % line_nb]: # retrieve the relative text text = layout[layout_mode + '_' + str(line_nb)][key_nb][0] z = Label(text=text, font_size=self.font_size, pos=pos, size=size, font_name=self.font_name) self.add_widget(z) key_nb += 1
def redraw_board(self): self.update_board() # clearing out widgets that made up the previous board display self.board_grid.clear_widgets() for j in range(5): for i in range(5): # adding yellow piece if current space belongs to user if self.board[4 - j][i] == self.piece: self.board_grid.add_widget( Image(source=resource_find( "images/connect4/bestchipyellow.png"))) # adding red piece if current space belongs to AI elif self.board[4 - j][i] == self.opponent: self.board_grid.add_widget( Image(source=resource_find( "images/connect4/bestchipred.png"))) # adding blank image for empty space else: self.board_grid.add_widget( Image(source="", color=(0, 0, 0)))
def atlas_texture_exists(uri): try: textures = get_atlas_textures( resource_find(dirname(uri).replace("atlas://", "") + ".atlas")) return basename(uri) in textures except OSError: return False except: print "EXCEPTION IN atlas_texture_exists" traceback.print_exc()
def load(filename): '''Load a sound, and return a Sound() instance''' rfn = resource_find(filename) if rfn is not None: filename = rfn ext = filename.split('.')[-1].lower() for classobj in SoundLoader._classes: if ext in classobj.extensions(): return classobj(source=filename) Logger.warning('Audio: Unable to find a loader for <%s>' % filename) return None
class Example(MDApp): path_to_kv_file = resource_find("my.kv") print(path_to_kv_file) def build(self): self.theme_cls.theme_style = "Dark" return Builder.load_string(KV) def update_kv_file(self, text): with open(self.path_to_kv_file, "w") as kv_file: kv_file.write(text)
def load_domains(program_type): file_string = "" with open(resource_find(f'data/{program_type}/Domains.txt'), 'r') as file: for line in file: file_string += line domains = [] domain_data = file_string.split('-\n') for domain in domain_data: name, description, small_description = domain.split('~\n') domains.append(Domain(name.strip(), description.strip(), small_description.strip())) return domains
def add(self, res_name: str): res = resource_find(res_name) if res is None: raise RuntimeError(f"Couldn't find resource {res_name}") sound = SoundLoader.load(res) if sound is None: raise RuntimeError(f"Failed at loading sound '{res_name}'!") print( f"Added '{res_name}' ({sound.length} seconds) to bucket-o-sounds") self._sounds.append(sound)
def on_source(self, instance, value): if not value: self.texture = None else: filename = resource_find(value) texture = Cache.get('kv.texture', filename) if not texture: image = CoreImage(filename) texture = image.texture Cache.append('kv.texture', filename, texture) self.texture = texture
def _load_from_source(self, *args): '''(internal) Loads the glsl string from a source file.''' source = self.source if not source: return filename = resource_find(source) if filename is None: return Logger.error( 'Error reading file {filename}'.format(filename=source)) with open(filename) as fileh: self.glsl = fileh.read()
def register(name, fn_regular, fn_italic=None, fn_bold=None, fn_bolditalic=None): '''Register an alias for a Font. .. versionadded:: 1.1.0 If you're using directly a ttf, you might not be able to use bold/italic of the ttf version. If the font is delivered with different version of it (one regular, one italic and one bold), then you need to register it and use the alias instead. All the fn_regular/fn_italic/fn_bold parameters are resolved with :func:`kivy.resources.resource_find`. If fn_italic/fn_bold are None, fn_regular will be used instead. ''' _fn_regular = resource_find(fn_regular) if _fn_regular is None: raise IOError('File %r not found' % fn_regular) if fn_italic is None: _fn_italic = _fn_regular else: _fn_italic = resource_find(fn_italic) if _fn_italic is None: raise IOError('File %r not found' % fn_italic) if fn_bold is None: _fn_bold = _fn_regular else: _fn_bold = resource_find(fn_bold) if _fn_bold is None: raise IOError('File %r not found' % fn_bold) if fn_bolditalic is None: _fn_bolditalic = _fn_regular else: _fn_bolditalic = resource_find(fn_bolditalic) if _fn_bolditalic is None: raise IOError('Label: File %r not found' % fn_bolditalic) LabelBase._fonts[name] = (_fn_regular, _fn_italic, _fn_bold, _fn_bolditalic)
def get_mod(modname,moddir): mod_str = '' resource_add_path(moddir) modpath = resource_find(modname + '.module') print 'Manjeet: modpath ',modpath if modpath == None: print 'Module not found' , modpath return mod_str with open(modpath,'r') as mf: mod_str += mf.read() print 'Manjeet: module str:\n', mod_str return mod_str
def update_glsl(self, *largs): asp = self.size[0] / float(self.size[1]) proj = Matrix().view_clip(-asp, asp, -1, 1, 1, 100, 1) model = Matrix().look_at(0.0, 0.0, 0.25, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) with self.canvas: self.fbo.shader.source = resource_find('simple.glsl') self.fbo['projection_mat'] = proj self.fbo['modelview_mat'] = model self.rot.angle += -1 self.texture = self.fbo.texture with self.fbo: BindTexture(source='testure.jpg', index=1)
def _trigger_texture_update(self, name=None, source=None, value=None): if source: if name == 'text': self._label.text = value elif name == 'text_size': self._label.usersize = value elif name == 'font_name': rvalue = resource_find(value) self._label.options['font_name'] = rvalue if rvalue else value else: self._label.options[name] = value self._trigger_texture()
def __init__(self, environment, difficulty, policy = 'max'): self.environment = environment self.policy = policy self.Q = '' self.first = None if policy == 'max': with open(resource_find(f"game_logic\\tictactoeAI\\qtables\\{difficulty}.txt"), 'r') as f: for i in f.readlines(): self.Q = i self.Q = eval(self.Q) self.Q = defaultdict(lambda: 0.0, self.Q) self.reset_past()
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 __init__(self, **kwargs): self.canvas = RenderContext(compute_normal_mat=True) #self.scene = ObjFileLoader(resource_find("resource/models/car-kart-white.obj")) self.scene = ObjFileLoader(resource_find("resource/models/car-formula-white.obj")) #self.scene = ObjFileLoader(resource_find("resource/models/car-parsche-sport-white.obj")) #TODO: the following needs work #self.scene = ObjFileLoader(resource_find("resource/models/car-groupc-2-white.obj")) #self.scene = ObjFileLoader(resource_find("resource/models/car-groupc-1-white.obj")) self.canvas.shader.source = resource_find('resource/models/shaders.glsl') super(ImuView, self).__init__(**kwargs) with self.canvas: self.cb = Callback(self.setup_gl_context) PushMatrix() self.setup_scene() PopMatrix() self.cb = Callback(self.reset_gl_context) self.camera_translate = [0, 0, -2.5] self.camera_ax = 0 self.camera_ay = 0 Clock.schedule_once(self.update_glsl, .5 ) self._touches = []
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 __init__(self, **kwargs): super(ServerSettings, self).__init__(**kwargs) config = ConfigParser() config.read('serverconfig.ini') config.setdefaults('main', { 'root': '/sdcard', 'allow_uploads': False, 'port': 11451 }) s = SettingsWithNoMenu() s.add_json_panel('Server', config, resource_find('settings.json')) s.on_config_change = restart_server self.add_widget(s)
def load_wav(self, filename): """Use SDL2 to load wav files cuz it's better, but only on windows""" rfn = resource_find(filename) sound = None if rfn is not None: filename = rfn if platform == 'win': sound = SoundSDL2(source=filename) else: sound = SoundLoader.load(filename) sound.unload( ) # We don't need to keep these loaded all the time... On linux. return sound
def load_fontawesome_unichr(): """ Load FontAwesome icon names and their associated unicode """ fa = FontAwesomeIconDict() with open(resource_find('FontAwesomeUnichr.txt'), 'Ur') as f: for line in f: k, _, v = line.partition(" ") fa[k] = unichr(int(v, 16)) return fa
def test_reload_asyncimage(self): from kivy.resources import resource_find from tempfile import mkdtemp from os import remove from shutil import copyfile, rmtree fn = resource_find('data/logo/kivy-icon-16.png') t = mkdtemp() source = join(t, 'source.png') copyfile(fn, source) image = AsyncImage(source=source) self.render(image, framecount=2) self.assertEqual(image.texture_size, [16, 16]) remove(source) fn = resource_find('data/logo/kivy-icon-32.png') copyfile(fn, source) image.reload() self.render(image, framecount=2) self.assertEqual(image.texture_size, [32, 32]) remove(source) rmtree(t)
def on_source(self, instance, value): if not value: if self._coreimage is not None: self._coreimage.unbind(on_texture=self._on_tex_change) self.texture = None self._coreimage = None else: if not self.is_uri(value): value = resource_find(value) self._coreimage = image = Loader.image(value) image.bind(on_load=self.on_source_load) image.bind(on_texture=self._on_tex_change) self.texture = image.texture
def __init__(self, **kwargs): self.gui = None self.canvas = RenderContext(compute_normal_mat=True) self.canvas.shader.source = resource_find('simple.glsl') self.d3h = D3Helper() self.d3h.loadObj([ [ 'boat', "./3dModels/boat2_3dex_boat.obj", "./3dModels/oiysh_profile2.jpeg" ], ['roseta', './3dModels/3d_roseta.obj', ''], [ 'genoa', "./3dModels/boat2_3dex_sailGenoa_onPower.obj", "./3dModels/3d_texture_genoa.jpg" ], [ 'main', "./3dModels/boat2_3dex_sailMain_sailup_onPower.obj", "./3dModels/IMG_5410.jpg" ], ['boom', "./3dModels/boat2_3dex_boom.obj", ""], ['ruder', "./3dModels/boat2_3dex_ruder.obj", ""], ['tiler', "./3dModels/boat2_3dex_tiler.obj", ""], #['hdr1','./3dModels/hdr1.obj','./3dModels/hdr1.png'], ['xAxis', './3dModels/x-axis.obj', './3dModels/red.png'], ['yAxis', './3dModels/y-axis.obj', './3dModels/green.png'], ['zAxis', './3dModels/z-axis.obj', './3dModels/blue.png'], ['box', './3dModels/3d_box.obj', ''], [ 'waterTile', './3dModels/waterTile.obj', "./3dModels/IMG_5410.jpg" ], [ 'hdr2', './3dModels/hdr2.obj', "./3dModels/PANO_20160311_160253.jpg" ], ['kap2', './3dModels/tile.obj', "./3dModels/kap2.png"] ]) super(d3tex2, self).__init__(**kwargs) with self.canvas: self.cb = Callback(self.setup_gl_context) PushMatrix() self.setup_scene() PopMatrix() self.cb = Callback(self.reset_gl_context) if d3tex2RunAlone: self.on_displayNow()
def __init__(self, *args, **kwargs): super(GraphRenderer, self).__init__(**kwargs) self.render_context.shader.source = resource_find( 'graph_renderer.glsl') self.mesh = Mesh(fmt=[('v_pos', 2, 'float')]) self.mesh.mode = 'lines' # glLineWidth(5.0); self.N = 0 self.render_context.add(self.mesh) self.xmin = 0.0 self.xmax = 1.0 self.updateModelViewMatrix()
def refresh_active_keys_layer(self): self.active_keys_layer.clear() active_keys = self.active_keys layout_geometry = self.layout_geometry background = resource_find(self.key_background_down) texture = Image(background, mipmap=True).texture with self.active_keys_layer: Color(*self.key_background_color) for line_nb, index in active_keys.values(): pos, size = layout_geometry['LINE_%d' % line_nb][index] BorderImage(texture=texture, pos=pos, size=size, border=self.key_border)
def texture_update(self, *largs): if not self.source: self.texture = None else: filename = resource_find(self.source) if filename is None: return mipmap = self.mipmap if self._coreimage is not None: self._coreimage.unbind(on_texture=self._on_tex_change) self._coreimage = ci = CoreImage(filename, mipmap=mipmap, anim_delay=self.anim_delay) ci.bind(on_texture=self._on_tex_change) self.texture = ci.texture
def build(self): self.icon = ICON # how you're supposed to set an icon self.title = f"KaTrain v{VERSION}" self.theme_cls.theme_style = "Dark" self.theme_cls.primary_palette = "Gray" self.theme_cls.primary_hue = "200" kv_file = find_package_resource("katrain/gui.kv") popup_kv_file = find_package_resource("katrain/popups.kv") resource_add_path(PATHS["PACKAGE"] + "/fonts") resource_add_path(PATHS["PACKAGE"] + "/sounds") resource_add_path(PATHS["PACKAGE"] + "/img") resource_add_path(os.path.abspath( os.path.expanduser(DATA_FOLDER))) # prefer resources in .katrain theme_file = resource_find("theme.json") if theme_file: try: with open(theme_file) as f: theme_overrides = json.load(f) for k, v in theme_overrides.items(): setattr(Theme, k, v) print(f"[{theme_file}] Found theme override {k} = {v}") except Exception as e: # noqa E722 print(f"Failed to load theme file {theme_file}: {e}") Theme.DEFAULT_FONT = resource_find(Theme.DEFAULT_FONT) Builder.load_file(kv_file) Window.bind(on_request_close=self.on_request_close) Window.bind(on_dropfile=lambda win, file: self.gui.load_sgf_file( file.decode("utf8"))) self.gui = KaTrainGui() Builder.load_file(popup_kv_file) return self.gui