BoghdadyJR/codesearch_python · Datasets at Hugging Face

text stringlengths 75 104k
def swap_buffers(self): """ Swaps buffers, incement the framecounter and pull events. """ self.frames += 1 glfw.swap_buffers(self.window) self.poll_events()
def resize(self, width, height): """ Sets the new size and buffer size internally """ self.width = width self.height = height self.buffer_width, self.buffer_height = glfw.get_framebuffer_size(self.window) self.set_default_viewport()
def check_glfw_version(self): """ Ensure glfw library version is compatible """ print("glfw version: {} (python wrapper version {})".format(glfw.get_version(), glfw.__version__)) if glfw.get_version() < self.min_glfw_version: raise ValueError("Please update glfw binaries to version {} or later".format(self.min_glfw_version))
def key_event_callback(self, window, key, scancode, action, mods): """ Key event callback for glfw. Translates and forwards keyboard event to :py:func:`keyboard_event` :param window: Window event origin :param key: The key that was pressed or released. :param scancode: The system-specific scancode of the key. :param action: GLFW_PRESS, GLFW_RELEASE or GLFW_REPEAT :param mods: Bit field describing which modifier keys were held down. """ self.keyboard_event(key, action, mods)
def ctx() -> moderngl.Context: """ModernGL context""" win = window() if not win.ctx: raise RuntimeError("Attempting to get context before creation") return win.ctx
def quad_2d(width, height, xpos=0.0, ypos=0.0) -> VAO: """ Creates a 2D quad VAO using 2 triangles with normals and texture coordinates. Args: width (float): Width of the quad height (float): Height of the quad Keyword Args: xpos (float): Center position x ypos (float): Center position y Returns: A :py:class:`demosys.opengl.vao.VAO` instance. """ pos = numpy.array([ xpos - width / 2.0, ypos + height / 2.0, 0.0, xpos - width / 2.0, ypos - height / 2.0, 0.0, xpos + width / 2.0, ypos - height / 2.0, 0.0, xpos - width / 2.0, ypos + height / 2.0, 0.0, xpos + width / 2.0, ypos - height / 2.0, 0.0, xpos + width / 2.0, ypos + height / 2.0, 0.0, ], dtype=numpy.float32) normals = numpy.array([ 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, ], dtype=numpy.float32) uvs = numpy.array([ 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, ], dtype=numpy.float32) vao = VAO("geometry:quad", mode=moderngl.TRIANGLES) vao.buffer(pos, '3f', ["in_position"]) vao.buffer(normals, '3f', ["in_normal"]) vao.buffer(uvs, '2f', ["in_uv"]) return vao
def translate_buffer_format(vertex_format): """Translate the buffer format""" buffer_format = [] attributes = [] mesh_attributes = [] if "T2F" in vertex_format: buffer_format.append("2f") attributes.append("in_uv") mesh_attributes.append(("TEXCOORD_0", "in_uv", 2)) if "C3F" in vertex_format: buffer_format.append("3f") attributes.append("in_color") mesh_attributes.append(("NORMAL", "in_color", 3)) if "N3F" in vertex_format: buffer_format.append("3f") attributes.append("in_normal") mesh_attributes.append(("NORMAL", "in_normal", 3)) buffer_format.append("3f") attributes.append("in_position") mesh_attributes.append(("POSITION", "in_position", 3)) return " ".join(buffer_format), attributes, mesh_attributes
def load(self): """Deferred loading""" path = self.find_scene(self.meta.path) if not path: raise ValueError("Scene '{}' not found".format(self.meta.path)) if path.suffix == '.bin': path = path.parent / path.stem data = pywavefront.Wavefront(str(path), create_materials=True, cache=True) scene = Scene(self.meta.resolved_path) texture_cache = {} for _, mat in data.materials.items(): mesh = Mesh(mat.name) # Traditional loader if mat.vertices: buffer_format, attributes, mesh_attributes = translate_buffer_format(mat.vertex_format) vbo = numpy.array(mat.vertices, dtype='f4') vao = VAO(mat.name, mode=moderngl.TRIANGLES) vao.buffer(vbo, buffer_format, attributes) mesh.vao = vao for attrs in mesh_attributes: mesh.add_attribute(attrs) # Binary cache loader elif hasattr(mat, 'vao'): mesh = Mesh(mat.name) mesh.vao = mat.vao for attrs in mat.mesh_attributes: mesh.add_attribute(attrs) else: # Empty continue scene.meshes.append(mesh) mesh.material = Material(mat.name) scene.materials.append(mesh.material) mesh.material.color = mat.diffuse if mat.texture: # A texture can be referenced multiple times, so we need to cache loaded ones texture = texture_cache.get(mat.texture.path) if not texture: print("Loading:", mat.texture.path) texture = textures.load(TextureDescription( label=mat.texture.path, path=mat.texture.path, mipmap=True, )) texture_cache[mat.texture.path] = texture mesh.material.mat_texture = MaterialTexture( texture=texture, sampler=None, ) node = Node(mesh=mesh) scene.root_nodes.append(node) # Not supported yet for obj # self.calc_scene_bbox() scene.prepare() return scene
def start(self): """ Start the timer by recoding the current ``time.time()`` preparing to report the number of seconds since this timestamp. """ if self.start_time is None: self.start_time = time.time() # Play after pause else: # Add the duration of the paused interval to the total offset pause_duration = time.time() - self.pause_time self.offset += pause_duration # print("pause duration", pause_duration, "offset", self.offset) # Exit the paused state self.pause_time = None
def stop(self) -> float: """ Stop the timer Returns: The time the timer was stopped """ self.stop_time = time.time() return self.stop_time - self.start_time - self.offset
def get_time(self) -> float: """ Get the current time in seconds Returns: The current time in seconds """ if self.pause_time is not None: curr_time = self.pause_time - self.offset - self.start_time return curr_time curr_time = time.time() return curr_time - self.start_time - self.offset
def set_time(self, value: float): """ Set the current time. This can be used to jump in the timeline. Args: value (float): The new time """ if value < 0: value = 0 self.offset += self.get_time() - value
def resolve_loader(self, meta: SceneDescription): """ Resolve scene loader based on file extension """ for loader_cls in self._loaders: if loader_cls.supports_file(meta): meta.loader_cls = loader_cls break else: raise ImproperlyConfigured( "Scene {} has no loader class registered. Check settings.SCENE_LOADERS".format(meta.path))
def on_key_press(self, symbol, modifiers): """ Pyglet specific key press callback. Forwards and translates the events to :py:func:`keyboard_event` """ self.keyboard_event(symbol, self.keys.ACTION_PRESS, modifiers)
def on_key_release(self, symbol, modifiers): """ Pyglet specific key release callback. Forwards and translates the events to :py:func:`keyboard_event` """ self.keyboard_event(symbol, self.keys.ACTION_RELEASE, modifiers)
def on_mouse_motion(self, x, y, dx, dy): """ Pyglet specific mouse motion callback. Forwards and traslates the event to :py:func:`cursor_event` """ # screen coordinates relative to the lower-left corner self.cursor_event(x, self.buffer_height - y, dx, dy)
def on_resize(self, width, height): """ Pyglet specific callback for window resize events. """ self.width, self.height = width, height self.buffer_width, self.buffer_height = width, height self.resize(width, height)
def swap_buffers(self): """ Swap buffers, increment frame counter and pull events """ if not self.window.context: return self.frames += 1 self.window.flip() self.window.dispatch_events()
def sphere(radius=0.5, sectors=32, rings=16) -> VAO: """ Creates a sphere. Keyword Args: radius (float): Radius or the sphere rings (int): number or horizontal rings sectors (int): number of vertical segments Returns: A :py:class:`demosys.opengl.vao.VAO` instance """ R = 1.0 / (rings - 1) S = 1.0 / (sectors - 1) vertices = [0] * (rings * sectors * 3) normals = [0] * (rings * sectors * 3) uvs = [0] * (rings * sectors * 2) v, n, t = 0, 0, 0 for r in range(rings): for s in range(sectors): y = math.sin(-math.pi / 2 + math.pi * r * R) x = math.cos(2 * math.pi * s * S) * math.sin(math.pi * r * R) z = math.sin(2 * math.pi * s * S) * math.sin(math.pi * r * R) uvs[t] = s * S uvs[t + 1] = r * R vertices[v] = x * radius vertices[v + 1] = y * radius vertices[v + 2] = z * radius normals[n] = x normals[n + 1] = y normals[n + 2] = z t += 2 v += 3 n += 3 indices = [0] * rings * sectors * 6 i = 0 for r in range(rings - 1): for s in range(sectors - 1): indices[i] = r * sectors + s indices[i + 1] = (r + 1) * sectors + (s + 1) indices[i + 2] = r * sectors + (s + 1) indices[i + 3] = r * sectors + s indices[i + 4] = (r + 1) * sectors + s indices[i + 5] = (r + 1) * sectors + (s + 1) i += 6 vbo_vertices = numpy.array(vertices, dtype=numpy.float32) vbo_normals = numpy.array(normals, dtype=numpy.float32) vbo_uvs = numpy.array(uvs, dtype=numpy.float32) vbo_elements = numpy.array(indices, dtype=numpy.uint32) vao = VAO("sphere", mode=mlg.TRIANGLES) # VBOs vao.buffer(vbo_vertices, '3f', ['in_position']) vao.buffer(vbo_normals, '3f', ['in_normal']) vao.buffer(vbo_uvs, '2f', ['in_uv']) vao.index_buffer(vbo_elements, index_element_size=4) return vao
def draw(self, current_time, frame_time): """ Calls the superclass ``draw()`` methods and checks ``HEADLESS_FRAMES``/``HEADLESS_DURATION`` """ super().draw(current_time, frame_time) if self.headless_duration and current_time >= self.headless_duration: self.close()
def swap_buffers(self): """ Headless window currently don't support double buffering. We only increment the frame counter here. """ self.frames += 1 if self.headless_frames and self.frames >= self.headless_frames: self.close()
def load(self, meta: ResourceDescription) -> Any: """ Loads a resource or return existing one :param meta: The resource description """ self._check_meta(meta) self.resolve_loader(meta) return meta.loader_cls(meta).load()
def add(self, meta): """ Add a resource to this pool. The resource is loaded and returned when ``load_pool()`` is called. :param meta: The resource description """ self._check_meta(meta) self.resolve_loader(meta) self._resources.append(meta)
def load_pool(self): """ Loads all the data files using the configured finders. """ for meta in self._resources: resource = self.load(meta) yield meta, resource self._resources = []
def resolve_loader(self, meta: ResourceDescription): """ Attempts to assign a loader class to a resource description :param meta: The resource description instance """ meta.loader_cls = self.get_loader(meta, raise_on_error=True)
def get_loader(self, meta: ResourceDescription, raise_on_error=False) -> BaseLoader: """ Attempts to get a loader :param meta: The resource description instance :param raise_on_error: Raise ImproperlyConfigured if the loader cannot be resolved :returns: The requested loader class """ for loader in self._loaders: if loader.name == meta.loader: return loader if raise_on_error: raise ImproperlyConfigured( "Resource has invalid loader '{}': {}\nAvailiable loaders: {}".format( meta.loader, meta, [loader.name for loader in self._loaders]))
def keyPressEvent(self, event): """ Pyqt specific key press callback function. Translates and forwards events to :py:func:`keyboard_event`. """ self.keyboard_event(event.key(), self.keys.ACTION_PRESS, 0)
def keyReleaseEvent(self, event): """ Pyqt specific key release callback function. Translates and forwards events to :py:func:`keyboard_event`. """ self.keyboard_event(event.key(), self.keys.ACTION_RELEASE, 0)
def resize(self, width, height): """ Pyqt specific resize callback. """ if not self.fbo: return # pyqt reports sizes in actual buffer size self.width = width // self.widget.devicePixelRatio() self.height = height // self.widget.devicePixelRatio() self.buffer_width = width self.buffer_height = height super().resize(width, height)
def draw(self, texture, pos=(0.0, 0.0), scale=(1.0, 1.0)): """ Draw texture using a fullscreen quad. By default this will conver the entire screen. :param pos: (tuple) offset x, y :param scale: (tuple) scale x, y """ if not self.initialized: self.init() self._texture2d_shader["offset"].value = (pos[0] - 1.0, pos[1] - 1.0) self._texture2d_shader["scale"].value = (scale[0], scale[1]) texture.use(location=0) self._texture2d_sampler.use(location=0) self._texture2d_shader["texture0"].value = 0 self._quad.render(self._texture2d_shader) self._texture2d_sampler.clear(location=0)
def draw_depth(self, texture, near, far, pos=(0.0, 0.0), scale=(1.0, 1.0)): """ Draw depth buffer linearized. By default this will draw the texture as a full screen quad. A sampler will be used to ensure the right conditions to draw the depth buffer. :param near: Near plane in projection :param far: Far plane in projection :param pos: (tuple) offset x, y :param scale: (tuple) scale x, y """ if not self.initialized: self.init() self._depth_shader["offset"].value = (pos[0] - 1.0, pos[1] - 1.0) self._depth_shader["scale"].value = (scale[0], scale[1]) self._depth_shader["near"].value = near self._depth_shader["far"].value = far self._depth_sampler.use(location=0) texture.use(location=0) self._depth_shader["texture0"].value = 0 self._quad.render(self._depth_shader) self._depth_sampler.clear(location=0)
def _init_texture2d_draw(self): """Initialize geometry and shader for drawing FBO layers""" if not TextureHelper._quad: TextureHelper._quad = geometry.quad_fs() # Shader for drawing color layers TextureHelper._texture2d_shader = context.ctx().program( vertex_shader=""" #version 330 in vec3 in_position; in vec2 in_uv; out vec2 uv; uniform vec2 offset; uniform vec2 scale; void main() { uv = in_uv; gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0); } """, fragment_shader=""" #version 330 out vec4 out_color; in vec2 uv; uniform sampler2D texture0; void main() { out_color = texture(texture0, uv); } """ ) TextureHelper._texture2d_sampler = self.ctx.sampler( filter=(moderngl.LINEAR, moderngl.LINEAR), )
def _init_depth_texture_draw(self): """Initialize geometry and shader for drawing FBO layers""" from demosys import geometry if not TextureHelper._quad: TextureHelper._quad = geometry.quad_fs() # Shader for drawing depth layers TextureHelper._depth_shader = context.ctx().program( vertex_shader=""" #version 330 in vec3 in_position; in vec2 in_uv; out vec2 uv; uniform vec2 offset; uniform vec2 scale; void main() { uv = in_uv; gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0); } """, fragment_shader=""" #version 330 out vec4 out_color; in vec2 uv; uniform sampler2D texture0; uniform float near; uniform float far; void main() { float z = texture(texture0, uv).r; float d = (2.0 * near) / (far + near - z * (far - near)); out_color = vec4(d); } """ ) TextureHelper._depth_sampler = self.ctx.sampler( filter=(moderngl.LINEAR, moderngl.LINEAR), compare_func='', )
def draw(self, current_time, frame_time): """ Draws a frame. Internally it calls the configured timeline's draw method. Args: current_time (float): The current time (preferrably always from the configured timer class) frame_time (float): The duration of the previous frame in seconds """ self.set_default_viewport() self.timeline.draw(current_time, frame_time, self.fbo)
def clear(self): """ Clear the window buffer """ self.ctx.fbo.clear( red=self.clear_color[0], green=self.clear_color[1], blue=self.clear_color[2], alpha=self.clear_color[3], depth=self.clear_depth, )
def clear_values(self, red=0.0, green=0.0, blue=0.0, alpha=0.0, depth=1.0): """ Sets the clear values for the window buffer. Args: red (float): red compoent green (float): green compoent blue (float): blue compoent alpha (float): alpha compoent depth (float): depth value """ self.clear_color = (red, green, blue, alpha) self.clear_depth = depth
def keyboard_event(self, key, action, modifier): """ Handles the standard keyboard events such as camera movements, taking a screenshot, closing the window etc. Can be overriden add new keyboard events. Ensure this method is also called if you want to keep the standard features. Arguments: key: The key that was pressed or released action: The key action. Can be `ACTION_PRESS` or `ACTION_RELEASE` modifier: Modifiers such as holding shift or ctrl """ # The well-known standard key for quick exit if key == self.keys.ESCAPE: self.close() return # Toggle pause time if key == self.keys.SPACE and action == self.keys.ACTION_PRESS: self.timer.toggle_pause() # Camera movement # Right if key == self.keys.D: if action == self.keys.ACTION_PRESS: self.sys_camera.move_right(True) elif action == self.keys.ACTION_RELEASE: self.sys_camera.move_right(False) # Left elif key == self.keys.A: if action == self.keys.ACTION_PRESS: self.sys_camera.move_left(True) elif action == self.keys.ACTION_RELEASE: self.sys_camera.move_left(False) # Forward elif key == self.keys.W: if action == self.keys.ACTION_PRESS: self.sys_camera.move_forward(True) if action == self.keys.ACTION_RELEASE: self.sys_camera.move_forward(False) # Backwards elif key == self.keys.S: if action == self.keys.ACTION_PRESS: self.sys_camera.move_backward(True) if action == self.keys.ACTION_RELEASE: self.sys_camera.move_backward(False) # UP elif key == self.keys.Q: if action == self.keys.ACTION_PRESS: self.sys_camera.move_down(True) if action == self.keys.ACTION_RELEASE: self.sys_camera.move_down(False) # Down elif key == self.keys.E: if action == self.keys.ACTION_PRESS: self.sys_camera.move_up(True) if action == self.keys.ACTION_RELEASE: self.sys_camera.move_up(False) # Screenshots if key == self.keys.X and action == self.keys.ACTION_PRESS: screenshot.create() if key == self.keys.R and action == self.keys.ACTION_PRESS: project.instance.reload_programs() if key == self.keys.RIGHT and action == self.keys.ACTION_PRESS: self.timer.set_time(self.timer.get_time() + 10.0) if key == self.keys.LEFT and action == self.keys.ACTION_PRESS: self.timer.set_time(self.timer.get_time() - 10.0) # Forward the event to the timeline self.timeline.key_event(key, action, modifier)
def cursor_event(self, x, y, dx, dy): """ The standard mouse movement event method. Can be overriden to add new functionality. By default this feeds the system camera with new values. Args: x: The current mouse x position y: The current mouse y position dx: Delta x postion (x position difference from the previous event) dy: Delta y postion (y position difference from the previous event) """ self.sys_camera.rot_state(x, y)
def set_default_viewport(self): """ Calculates the viewport based on the configured aspect ratio in settings. Will add black borders if the window do not match the viewport. """ # The expected height with the current viewport width expected_height = int(self.buffer_width / self.aspect_ratio) # How much positive or negative y padding blank_space = self.buffer_height - expected_height self.fbo.viewport = (0, blank_space // 2, self.buffer_width, expected_height)
def start(self): """Start the timer""" self.music.start() if not self.start_paused: self.rocket.start()
def toggle_pause(self): """Toggle pause mode""" self.controller.playing = not self.controller.playing self.music.toggle_pause()
def supports_file(cls, meta): """Check if the loader has a supported file extension""" path = Path(meta.path) for ext in cls.file_extensions: if path.suffixes[:len(ext)] == ext: return True return False
def get(self, name) -> Track: """ Get or create a Track object. :param name: Name of the track :return: Track object """ name = name.lower() track = self.track_map.get(name) if not track: track = Track(name) self.tacks.append(track) self.track_map[name] = track return track
def find_commands(command_dir: str) -> List[str]: """ Get all command names in the a folder :return: List of commands names """ if not command_dir: return [] return [name for _, name, is_pkg in pkgutil.iter_modules([command_dir]) if not is_pkg and not name.startswith('_')]
def execute_from_command_line(argv=None): """ Currently the only entrypoint (manage.py, demosys-admin) """ if not argv: argv = sys.argv # prog_name = argv[0] system_commands = find_commands(system_command_dir()) project_commands = find_commands(project_command_dir()) project_package = project_package_name() command = argv[1] if len(argv) > 1 else None # Are we running a core command? if command in system_commands: cmd = load_command_class('demosys', command) cmd.run_from_argv(argv) elif command in project_commands: cmd = load_command_class(project_package, command) cmd.run_from_argv(argv) else: print("Available commands:") for name in system_commands: print(" - {}".format(name)) for name in project_commands: print(" - {}".format(name))
def update(self, **kwargs): """Override settings values""" for name, value in kwargs.items(): setattr(self, name, value)
def add_program_dir(self, directory): """Hack in program directory""" dirs = list(self.PROGRAM_DIRS) dirs.append(directory) self.PROGRAM_DIRS = dirs
def add_texture_dir(self, directory): """Hack in texture directory""" dirs = list(self.TEXTURE_DIRS) dirs.append(directory) self.TEXTURE_DIRS = dirs
def add_data_dir(self, directory): """Hack in a data directory""" dirs = list(self.DATA_DIRS) dirs.append(directory) self.DATA_DIRS = dirs
def content(self, attributes: List[str]): """Build content tuple for the buffer""" formats = [] attrs = [] for attrib_format, attrib in zip(self.attrib_formats, self.attributes): if attrib not in attributes: formats.append(attrib_format.pad_str()) continue formats.append(attrib_format.format) attrs.append(attrib) attributes.remove(attrib) if not attrs: return None return ( self.buffer, "{}{}".format(" ".join(formats), '/i' if self.per_instance else ''), *attrs )
def render(self, program: moderngl.Program, mode=None, vertices=-1, first=0, instances=1): """ Render the VAO. Args: program: The ``moderngl.Program`` Keyword Args: mode: Override the draw mode (``TRIANGLES`` etc) vertices (int): The number of vertices to transform first (int): The index of the first vertex to start with instances (int): The number of instances """ vao = self.instance(program) if mode is None: mode = self.mode vao.render(mode, vertices=vertices, first=first, instances=instances)
def render_indirect(self, program: moderngl.Program, buffer, mode=None, count=-1, *, first=0): """ The render primitive (mode) must be the same as the input primitive of the GeometryShader. The draw commands are 5 integers: (count, instanceCount, firstIndex, baseVertex, baseInstance). Args: program: The ``moderngl.Program`` buffer: The ``moderngl.Buffer`` containing indirect draw commands Keyword Args: mode (int): By default :py:data:`TRIANGLES` will be used. count (int): The number of draws. first (int): The index of the first indirect draw command. """ vao = self.instance(program) if mode is None: mode = self.mode vao.render_indirect(buffer, mode=mode, count=count, first=first)
def transform(self, program: moderngl.Program, buffer: moderngl.Buffer, mode=None, vertices=-1, first=0, instances=1): """ Transform vertices. Stores the output in a single buffer. Args: program: The ``moderngl.Program`` buffer: The ``moderngl.buffer`` to store the output Keyword Args: mode: Draw mode (for example ``moderngl.POINTS``) vertices (int): The number of vertices to transform first (int): The index of the first vertex to start with instances (int): The number of instances """ vao = self.instance(program) if mode is None: mode = self.mode vao.transform(buffer, mode=mode, vertices=vertices, first=first, instances=instances)
def buffer(self, buffer, buffer_format: str, attribute_names, per_instance=False): """ Register a buffer/vbo for the VAO. This can be called multiple times. adding multiple buffers (interleaved or not) Args: buffer: The buffer data. Can be ``numpy.array``, ``moderngl.Buffer`` or ``bytes``. buffer_format (str): The format of the buffer. (eg. ``3f 3f`` for interleaved positions and normals). attribute_names: A list of attribute names this buffer should map to. Keyword Args: per_instance (bool): Is this buffer per instance data for instanced rendering? Returns: The ``moderngl.Buffer`` instance object. This is handy when providing ``bytes`` and ``numpy.array``. """ if not isinstance(attribute_names, list): attribute_names = [attribute_names, ] if not type(buffer) in [moderngl.Buffer, numpy.ndarray, bytes]: raise VAOError( ( "buffer parameter must be a moderngl.Buffer, numpy.ndarray or bytes instance" "(not {})".format(type(buffer)) ) ) if isinstance(buffer, numpy.ndarray): buffer = self.ctx.buffer(buffer.tobytes()) if isinstance(buffer, bytes): buffer = self.ctx.buffer(data=buffer) formats = buffer_format.split() if len(formats) != len(attribute_names): raise VAOError("Format '{}' does not describe attributes {}".format(buffer_format, attribute_names)) self.buffers.append(BufferInfo(buffer, buffer_format, attribute_names, per_instance=per_instance)) self.vertex_count = self.buffers[-1].vertices return buffer
def index_buffer(self, buffer, index_element_size=4): """ Set the index buffer for this VAO Args: buffer: ``moderngl.Buffer``, ``numpy.array`` or ``bytes`` Keyword Args: index_element_size (int): Byte size of each element. 1, 2 or 4 """ if not type(buffer) in [moderngl.Buffer, numpy.ndarray, bytes]: raise VAOError("buffer parameter must be a moderngl.Buffer, numpy.ndarray or bytes instance") if isinstance(buffer, numpy.ndarray): buffer = self.ctx.buffer(buffer.tobytes()) if isinstance(buffer, bytes): buffer = self.ctx.buffer(data=buffer) self._index_buffer = buffer self._index_element_size = index_element_size
def instance(self, program: moderngl.Program) -> moderngl.VertexArray: """ Obtain the ``moderngl.VertexArray`` instance for the program. The instance is only created once and cached internally. Returns: ``moderngl.VertexArray`` instance """ vao = self.vaos.get(program.glo) if vao: return vao program_attributes = [name for name, attr in program._members.items() if isinstance(attr, moderngl.Attribute)] # Make sure all attributes are covered for attrib_name in program_attributes: # Ignore built in attributes for now if attrib_name.startswith('gl_'): continue # Do we have a buffer mapping to this attribute? if not sum(buffer.has_attribute(attrib_name) for buffer in self.buffers): raise VAOError("VAO {} doesn't have attribute {} for program {}".format( self.name, attrib_name, program.name)) vao_content = [] # Pick out the attributes we can actually map for buffer in self.buffers: content = buffer.content(program_attributes) if content: vao_content.append(content) # Any attribute left is not accounted for if program_attributes: for attrib_name in program_attributes: if attrib_name.startswith('gl_'): continue raise VAOError("Did not find a buffer mapping for {}".format([n for n in program_attributes])) # Create the vao if self._index_buffer: vao = context.ctx().vertex_array(program, vao_content, self._index_buffer, self._index_element_size) else: vao = context.ctx().vertex_array(program, vao_content) self.vaos[program.glo] = vao return vao
def release(self, buffer=True): """ Destroy the vao object Keyword Args: buffers (bool): also release buffers """ for key, vao in self.vaos: vao.release() if buffer: for buff in self.buffers: buff.buffer.release() if self._index_buffer: self._index_buffer.release()
def cube(width, height, depth, center=(0.0, 0.0, 0.0), normals=True, uvs=True) -> VAO: """ Creates a cube VAO with normals and texture coordinates Args: width (float): Width of the cube height (float): Height of the cube depth (float): Depth of the cube Keyword Args: center: center of the cube as a 3-component tuple normals: (bool) Include normals uvs: (bool) include uv coordinates Returns: A :py:class:`demosys.opengl.vao.VAO` instance """ width, height, depth = width / 2.0, height / 2.0, depth / 2.0 pos = numpy.array([ center[0] + width, center[1] - height, center[2] + depth, center[0] + width, center[1] + height, center[2] + depth, center[0] - width, center[1] - height, center[2] + depth, center[0] + width, center[1] + height, center[2] + depth, center[0] - width, center[1] + height, center[2] + depth, center[0] - width, center[1] - height, center[2] + depth, center[0] + width, center[1] - height, center[2] - depth, center[0] + width, center[1] + height, center[2] - depth, center[0] + width, center[1] - height, center[2] + depth, center[0] + width, center[1] + height, center[2] - depth, center[0] + width, center[1] + height, center[2] + depth, center[0] + width, center[1] - height, center[2] + depth, center[0] + width, center[1] - height, center[2] - depth, center[0] + width, center[1] - height, center[2] + depth, center[0] - width, center[1] - height, center[2] + depth, center[0] + width, center[1] - height, center[2] - depth, center[0] - width, center[1] - height, center[2] + depth, center[0] - width, center[1] - height, center[2] - depth, center[0] - width, center[1] - height, center[2] + depth, center[0] - width, center[1] + height, center[2] + depth, center[0] - width, center[1] + height, center[2] - depth, center[0] - width, center[1] - height, center[2] + depth, center[0] - width, center[1] + height, center[2] - depth, center[0] - width, center[1] - height, center[2] - depth, center[0] + width, center[1] + height, center[2] - depth, center[0] + width, center[1] - height, center[2] - depth, center[0] - width, center[1] - height, center[2] - depth, center[0] + width, center[1] + height, center[2] - depth, center[0] - width, center[1] - height, center[2] - depth, center[0] - width, center[1] + height, center[2] - depth, center[0] + width, center[1] + height, center[2] - depth, center[0] - width, center[1] + height, center[2] - depth, center[0] + width, center[1] + height, center[2] + depth, center[0] - width, center[1] + height, center[2] - depth, center[0] - width, center[1] + height, center[2] + depth, center[0] + width, center[1] + height, center[2] + depth, ], dtype=numpy.float32) if normals: normal_data = numpy.array([ -0, 0, 1, -0, 0, 1, -0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, -0, 0, -1, -0, 0, -1, -0, 0, -1, -0, 0, -1, -0, 0, -1, -0, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, ], dtype=numpy.float32) if uvs: uvs_data = numpy.array([ 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0 ], dtype=numpy.float32) vao = VAO("geometry:cube") # Add buffers vao.buffer(pos, '3f', ['in_position']) if normals: vao.buffer(normal_data, '3f', ['in_normal']) if uvs: vao.buffer(uvs_data, '2f', ['in_uv']) return vao
def draw(self, mesh, projection_matrix=None, view_matrix=None, camera_matrix=None, time=0): """ Draw code for the mesh. Should be overriden. :param projection_matrix: projection_matrix (bytes) :param view_matrix: view_matrix (bytes) :param camera_matrix: camera_matrix (bytes) :param time: The current time """ self.program["m_proj"].write(projection_matrix) self.program["m_mv"].write(view_matrix) mesh.vao.render(self.program)
def pause(self): """Pause the music""" self.pause_time = self.get_time() self.paused = True self.player.pause()
def get_time(self) -> float: """ Get the current time in seconds Returns: The current time in seconds """ if self.paused: return self.pause_time return self.player.get_time() / 1000.0
def parse_package_string(path): """ Parse the effect package string. Can contain the package python path or path to effect class in an effect package. Examples:: # Path to effect pacakge examples.cubes # Path to effect class examples.cubes.Cubes Args: path: python path to effect package. May also include effect class name. Returns: tuple: (package_path, effect_class) """ parts = path.split('.') # Is the last entry in the path capitalized? if parts[-1][0].isupper(): return ".".join(parts[:-1]), parts[-1] return path, ""
def get_dirs(self) -> List[str]: """ Get all effect directories for registered effects. """ for package in self.packages: yield os.path.join(package.path, 'resources')
def get_effect_resources(self) -> List[Any]: """ Get all resources registed in effect packages. These are typically located in ``resources.py`` """ resources = [] for package in self.packages: resources.extend(package.resources) return resources
def add_package(self, name): """ Registers a single package :param name: (str) The effect package to add """ name, cls_name = parse_package_string(name) if name in self.package_map: return package = EffectPackage(name) package.load() self.packages.append(package) self.package_map[package.name] = package # Load effect package dependencies self.polulate(package.effect_packages)
def get_package(self, name) -> 'EffectPackage': """ Get a package by python path. Can also contain path to an effect. Args: name (str): Path to effect package or effect Returns: The requested EffectPackage Raises: EffectError when no package is found """ name, cls_name = parse_package_string(name) try: return self.package_map[name] except KeyError: raise EffectError("No package '{}' registered".format(name))
def find_effect_class(self, path) -> Type[Effect]: """ Find an effect class by class name or full python path to class Args: path (str): effect class name or full python path to effect class Returns: Effect class Raises: EffectError if no class is found """ package_name, class_name = parse_package_string(path) if package_name: package = self.get_package(package_name) return package.find_effect_class(class_name, raise_for_error=True) for package in self.packages: effect_cls = package.find_effect_class(class_name) if effect_cls: return effect_cls raise EffectError("No effect class '{}' found in any packages".format(class_name))
def runnable_effects(self) -> List[Type[Effect]]: """Returns the runnable effect in the package""" return [cls for cls in self.effect_classes if cls.runnable]
def load_package(self): """FInd the effect package""" try: self.package = importlib.import_module(self.name) except ModuleNotFoundError: raise ModuleNotFoundError("Effect package '{}' not found.".format(self.name))
def load_effects_classes(self): """Iterate the module attributes picking out effects""" self.effect_classes = [] for _, cls in inspect.getmembers(self.effect_module): if inspect.isclass(cls): if cls == Effect: continue if issubclass(cls, Effect): self.effect_classes.append(cls) self.effect_class_map[cls.__name__] = cls cls._name = "{}.{}".format(self.effect_module_name, cls.__name__)
def load_resource_module(self): """Fetch the resource list""" # Attempt to load the dependencies module try: name = '{}.{}'.format(self.name, 'dependencies') self.dependencies_module = importlib.import_module(name) except ModuleNotFoundError as err: raise EffectError( ( "Effect package '{}' has no 'dependencies' module or the module has errors. " "Forwarded error from importlib: {}" ).format(self.name, err)) # Fetch the resource descriptions try: self.resources = getattr(self.dependencies_module, 'resources') except AttributeError: raise EffectError("Effect dependencies module '{}' has no 'resources' attribute".format(name)) if not isinstance(self.resources, list): raise EffectError( "Effect dependencies module '{}': 'resources' is of type {} instead of a list".format( name, type(self.resources))) # Fetch the effect class list try: self.effect_packages = getattr(self.dependencies_module, 'effect_packages') except AttributeError: raise EffectError("Effect dependencies module '{}' has 'effect_packages' attribute".format(name)) if not isinstance(self.effect_packages, list): raise EffectError( "Effect dependencies module '{}': 'effect_packages' is of type {} instead of a list".format( name, type(self.effects)))
def create(file_format='png', name=None): """ Create a screenshot :param file_format: formats supported by PIL (png, jpeg etc) """ dest = "" if settings.SCREENSHOT_PATH: if not os.path.exists(settings.SCREENSHOT_PATH): print("SCREENSHOT_PATH does not exist. creating: {}".format(settings.SCREENSHOT_PATH)) os.makedirs(settings.SCREENSHOT_PATH) dest = settings.SCREENSHOT_PATH else: print("SCREENSHOT_PATH not defined in settings. Using cwd as fallback.") if not Config.target: Config.target = context.window().fbo image = Image.frombytes( "RGB", (Config.target.viewport[2], Config.target.viewport[3]), Config.target.read(viewport=Config.target.viewport, alignment=Config.alignment), ) image = image.transpose(Image.FLIP_TOP_BOTTOM) if not name: name = "{}.{}".format(datetime.now().strftime("%Y-%m-%d-%H-%M-%S-%f"), file_format) dest = os.path.join(dest, name) print("Creating screenshot:", dest) image.save(dest, format=file_format)
def draw(self, time, frametime, target): """ Fetch track value for every runnable effect. If the value is > 0.5 we draw it. """ for effect in self.effects: value = effect.rocket_timeline_track.time_value(time) if value > 0.5: effect.draw(time, frametime, target)
def load(self): """Load a 2d texture""" self._open_image() components, data = image_data(self.image) texture = self.ctx.texture( self.image.size, components, data, ) texture.extra = {'meta': self.meta} if self.meta.mipmap: texture.build_mipmaps() self._close_image() return texture
def from_single(cls, meta: ProgramDescription, source: str): """Initialize a single glsl string containing all shaders""" instance = cls(meta) instance.vertex_source = ShaderSource( VERTEX_SHADER, meta.path or meta.vertex_shader, source ) if GEOMETRY_SHADER in source: instance.geometry_source = ShaderSource( GEOMETRY_SHADER, meta.path or meta.geometry_shader, source, ) if FRAGMENT_SHADER in source: instance.fragment_source = ShaderSource( FRAGMENT_SHADER, meta.path or meta.fragment_shader, source, ) if TESS_CONTROL_SHADER in source: instance.tess_control_source = ShaderSource( TESS_CONTROL_SHADER, meta.path or meta.tess_control_shader, source, ) if TESS_EVALUATION_SHADER in source: instance.tess_evaluation_source = ShaderSource( TESS_EVALUATION_SHADER, meta.path or meta.tess_evaluation_shader, source, ) return instance
def from_separate(cls, meta: ProgramDescription, vertex_source, geometry_source=None, fragment_source=None, tess_control_source=None, tess_evaluation_source=None): """Initialize multiple shader strings""" instance = cls(meta) instance.vertex_source = ShaderSource( VERTEX_SHADER, meta.path or meta.vertex_shader, vertex_source, ) if geometry_source: instance.geometry_source = ShaderSource( GEOMETRY_SHADER, meta.path or meta.geometry_shader, geometry_source, ) if fragment_source: instance.fragment_source = ShaderSource( FRAGMENT_SHADER, meta.path or meta.fragment_shader, fragment_source, ) if tess_control_source: instance.tess_control_source = ShaderSource( TESS_CONTROL_SHADER, meta.path or meta.tess_control_shader, tess_control_source, ) if tess_evaluation_source: instance.tess_evaluation_source = ShaderSource( TESS_EVALUATION_SHADER, meta.path or meta.tess_control_shader, tess_evaluation_source, ) return instance
def create(self): """ Creates a shader program. Returns: ModernGL Program instance """ # Get out varyings out_attribs = [] # If no fragment shader is present we are doing transform feedback if not self.fragment_source: # Out attributes is present in geometry shader if present if self.geometry_source: out_attribs = self.geometry_source.find_out_attribs() # Otherwise they are specified in vertex shader else: out_attribs = self.vertex_source.find_out_attribs() program = self.ctx.program( vertex_shader=self.vertex_source.source, geometry_shader=self.geometry_source.source if self.geometry_source else None, fragment_shader=self.fragment_source.source if self.fragment_source else None, tess_control_shader=self.tess_control_source.source if self.tess_control_source else None, tess_evaluation_shader=self.tess_evaluation_source.source if self.tess_evaluation_source else None, varyings=out_attribs, ) program.extra = {'meta': self.meta} return program
def find_out_attribs(self): """ Get all out attributes in the shader source. :return: List of attribute names """ names = [] for line in self.lines: if line.strip().startswith("out "): names.append(line.split()[2].replace(';', '')) return names
def print(self): """Print the shader lines""" print("---[ START {} ]---".format(self.name)) for i, line in enumerate(self.lines): print("{}: {}".format(str(i).zfill(3), line)) print("---[ END {} ]---".format(self.name))
def create_effect(self, label: str, name: str, args, kwargs) -> Effect: """ Create an effect instance adding it to the internal effects dictionary using the label as key. Args: label (str): The unique label for the effect instance name (str): Name or full python path to the effect class we want to instantiate args: Positional arguments to the effect initializer kwargs: Keyword arguments to the effect initializer Returns: The newly created Effect instance """ effect_cls = effects.find_effect_class(name) effect = effect_cls(args, **kwargs) effect._label = label if label in self._effects: raise ValueError("An effect with label '{}' already exists".format(label)) self._effects[label] = effect return effect
def load(self): """ Loads this project instance """ self.create_effect_classes() self._add_resource_descriptions_to_pools(self.create_external_resources()) self._add_resource_descriptions_to_pools(self.create_resources()) for meta, resource in resources.textures.load_pool(): self._textures[meta.label] = resource for meta, resource in resources.programs.load_pool(): self._programs[meta.label] = resource for meta, resource in resources.scenes.load_pool(): self._scenes[meta.label] = resource for meta, resource in resources.data.load_pool(): self._data[meta.label] = resource self.create_effect_instances() self.post_load()
def _add_resource_descriptions_to_pools(self, meta_list): """ Takes a list of resource descriptions adding them to the resource pool they belong to scheduling them for loading. """ if not meta_list: return for meta in meta_list: getattr(resources, meta.resource_type).add(meta)
def reload_programs(self): """ Reload all shader programs with the reloadable flag set """ print("Reloading programs:") for name, program in self._programs.items(): if getattr(program, 'program', None): print(" - {}".format(program.meta.label)) program.program = resources.programs.load(program.meta)
def get_effect(self, label: str) -> Effect: """ Get an effect instance by label Args: label (str): The label for the effect instance Returns: Effect class instance """ return self._get_resource(label, self._effects, "effect")
def get_effect_class(self, class_name, package_name=None) -> Type[Effect]: """ Get an effect class from the effect registry. Args: class_name (str): The exact class name of the effect Keyword Args: package_name (str): The python path to the effect package the effect name is located. This is optional and can be used to avoid issue with class name collisions. Returns: Effect class """ if package_name: return effects.find_effect_class("{}.{}".format(package_name, class_name)) return effects.find_effect_class(class_name)
def get_scene(self, label: str) -> Scene: """ Gets a scene by label Args: label (str): The label for the scene to fetch Returns: Scene instance """ return self._get_resource(label, self._scenes, "scene")
def get_texture(self, label: str) -> Union[moderngl.Texture, moderngl.TextureArray, moderngl.Texture3D, moderngl.TextureCube]: """ Get a texture by label Args: label (str): The label for the texture to fetch Returns: Texture instance """ return self._get_resource(label, self._textures, "texture")
def get_data(self, label: str) -> Any: """ Get a data resource by label Args: label (str): The labvel for the data resource to fetch Returns: The requeted data object """ return self._get_resource(label, self._data, "data")
def _get_resource(self, label: str, source: dict, resource_type: str): """ Generic resoure fetcher handling errors. Args: label (str): The label to fetch source (dict): The dictionary to look up the label resource_type str: The display name of the resource type (used in errors) """ try: return source[label] except KeyError: raise ValueError("Cannot find {0} with label '{1}'.\nExisting {0} labels: {2}".format( resource_type, label, list(source.keys())))
def get_runnable_effects(self) -> List[Effect]: """ Returns all runnable effects in the project. :return: List of all runnable effects """ return [effect for name, effect in self._effects.items() if effect.runnable]
def image_data(image): """Get components and bytes for an image""" # NOTE: We might want to check the actual image.mode # and convert to an acceptable format. # At the moment we load the data as is. data = image.tobytes() components = len(data) // (image.size[0] * image.size[1]) return components, data
def run_from_argv(self, argv): """ Called by the system when executing the command from the command line. This should not be overridden. :param argv: Arguments from command line """ parser = self.create_parser(argv[0], argv[1]) options = parser.parse_args(argv[2:]) cmd_options = vars(options) args = cmd_options.pop('args', ()) self.handle(args, *cmd_options)
def create_parser(self, prog_name, subcommand): """ Create argument parser and deal with ``add_arguments``. This method should not be overriden. :param prog_name: Name of the command (argv[0]) :return: ArgumentParser """ parser = argparse.ArgumentParser(prog_name, subcommand) # Add generic arguments here self.add_arguments(parser) return parser
def validate_name(self, name): """ Can the name be used as a python module or package? Raises ``ValueError`` if the name is invalid. :param name: the name to check """ if not name: raise ValueError("Name cannot be empty") # Can the name be used as an identifier in python (module or package name) if not name.isidentifier(): raise ValueError("{} is not a valid identifier".format(name))
def bbox(width=1.0, height=1.0, depth=1.0): """ Generates a bounding box with (0.0, 0.0, 0.0) as the center. This is simply a box with ``LINE_STRIP`` as draw mode. Keyword Args: width (float): Width of the box height (float): Height of the box depth (float): Depth of the box Returns: A :py:class:`demosys.opengl.vao.VAO` instance """ width, height, depth = width / 2.0, height / 2.0, depth / 2.0 pos = numpy.array([ width, -height, depth, width, height, depth, -width, -height, depth, width, height, depth, -width, height, depth, -width, -height, depth, width, -height, -depth, width, height, -depth, width, -height, depth, width, height, -depth, width, height, depth, width, -height, depth, width, -height, -depth, width, -height, depth, -width, -height, depth, width, -height, -depth, -width, -height, depth, -width, -height, -depth, -width, -height, depth, -width, height, depth, -width, height, -depth, -width, -height, depth, -width, height, -depth, -width, -height, -depth, width, height, -depth, width, -height, -depth, -width, -height, -depth, width, height, -depth, -width, -height, -depth, -width, height, -depth, width, height, -depth, -width, height, -depth, width, height, depth, -width, height, -depth, -width, height, depth, width, height, depth, ], dtype=numpy.float32) vao = VAO("geometry:cube", mode=moderngl.LINE_STRIP) vao.buffer(pos, '3f', ["in_position"]) return vao
def _find_last_of(self, path, finders): """Find the last occurance of the file in finders""" found_path = None for finder in finders: result = finder.find(path) if result: found_path = result return found_path
def initial_sanity_check(self): """Checks if we can create the project""" # Check for python module collision self.try_import(self.project_name) # Is the name a valid identifier? self.validate_name(self.project_name) # Make sure we don't mess with existing directories if os.path.exists(self.project_name): print("Directory {} already exist. Aborting.".format(self.project_name)) return False if os.path.exists('manage.py'): print("A manage.py file already exist in the current directory. Aborting.") return False return True
def create_entrypoint(self): """Write manage.py in the current directory""" with open(os.path.join(self.template_dir, 'manage.py'), 'r') as fd: data = fd.read().format(project_name=self.project_name) with open('manage.py', 'w') as fd: fd.write(data) os.chmod('manage.py', 0o777)
def get_template_dir(self): """Returns the absolute path to template directory""" directory = os.path.dirname(os.path.abspath(__file__)) directory = os.path.dirname(os.path.dirname(directory)) directory = os.path.join(directory, 'project_template') return directory
def resolve_loader(self, meta: ProgramDescription): """ Resolve program loader """ if not meta.loader: meta.loader = 'single' if meta.path else 'separate' for loader_cls in self._loaders: if loader_cls.name == meta.loader: meta.loader_cls = loader_cls break else: raise ImproperlyConfigured( ( "Program {} has no loader class registered." "Check PROGRAM_LOADERS or PROGRAM_DIRS" ).format(meta.path) )

def swap_buffers(self): """ Swaps buffers, incement the framecounter and pull events. """ self.frames += 1 glfw.swap_buffers(self.window) self.poll_events()

def resize(self, width, height): """ Sets the new size and buffer size internally """ self.width = width self.height = height self.buffer_width, self.buffer_height = glfw.get_framebuffer_size(self.window) self.set_default_viewport()

def check_glfw_version(self): """ Ensure glfw library version is compatible """ print("glfw version: {} (python wrapper version {})".format(glfw.get_version(), glfw.__version__)) if glfw.get_version() < self.min_glfw_version: raise ValueError("Please update glfw binaries to version {} or later".format(self.min_glfw_version))

def key_event_callback(self, window, key, scancode, action, mods): """ Key event callback for glfw. Translates and forwards keyboard event to :py:func:`keyboard_event` :param window: Window event origin :param key: The key that was pressed or released. :param scancode: The system-specific scancode of the key. :param action: GLFW_PRESS, GLFW_RELEASE or GLFW_REPEAT :param mods: Bit field describing which modifier keys were held down. """ self.keyboard_event(key, action, mods)

def ctx() -> moderngl.Context: """ModernGL context""" win = window() if not win.ctx: raise RuntimeError("Attempting to get context before creation") return win.ctx

def quad_2d(width, height, xpos=0.0, ypos=0.0) -> VAO: """ Creates a 2D quad VAO using 2 triangles with normals and texture coordinates. Args: width (float): Width of the quad height (float): Height of the quad Keyword Args: xpos (float): Center position x ypos (float): Center position y Returns: A :py:class:`demosys.opengl.vao.VAO` instance. """ pos = numpy.array([ xpos - width / 2.0, ypos + height / 2.0, 0.0, xpos - width / 2.0, ypos - height / 2.0, 0.0, xpos + width / 2.0, ypos - height / 2.0, 0.0, xpos - width / 2.0, ypos + height / 2.0, 0.0, xpos + width / 2.0, ypos - height / 2.0, 0.0, xpos + width / 2.0, ypos + height / 2.0, 0.0, ], dtype=numpy.float32) normals = numpy.array([ 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, ], dtype=numpy.float32) uvs = numpy.array([ 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, ], dtype=numpy.float32) vao = VAO("geometry:quad", mode=moderngl.TRIANGLES) vao.buffer(pos, '3f', ["in_position"]) vao.buffer(normals, '3f', ["in_normal"]) vao.buffer(uvs, '2f', ["in_uv"]) return vao

def translate_buffer_format(vertex_format): """Translate the buffer format""" buffer_format = [] attributes = [] mesh_attributes = [] if "T2F" in vertex_format: buffer_format.append("2f") attributes.append("in_uv") mesh_attributes.append(("TEXCOORD_0", "in_uv", 2)) if "C3F" in vertex_format: buffer_format.append("3f") attributes.append("in_color") mesh_attributes.append(("NORMAL", "in_color", 3)) if "N3F" in vertex_format: buffer_format.append("3f") attributes.append("in_normal") mesh_attributes.append(("NORMAL", "in_normal", 3)) buffer_format.append("3f") attributes.append("in_position") mesh_attributes.append(("POSITION", "in_position", 3)) return " ".join(buffer_format), attributes, mesh_attributes

def load(self): """Deferred loading""" path = self.find_scene(self.meta.path) if not path: raise ValueError("Scene '{}' not found".format(self.meta.path)) if path.suffix == '.bin': path = path.parent / path.stem data = pywavefront.Wavefront(str(path), create_materials=True, cache=True) scene = Scene(self.meta.resolved_path) texture_cache = {} for _, mat in data.materials.items(): mesh = Mesh(mat.name) # Traditional loader if mat.vertices: buffer_format, attributes, mesh_attributes = translate_buffer_format(mat.vertex_format) vbo = numpy.array(mat.vertices, dtype='f4') vao = VAO(mat.name, mode=moderngl.TRIANGLES) vao.buffer(vbo, buffer_format, attributes) mesh.vao = vao for attrs in mesh_attributes: mesh.add_attribute(*attrs) # Binary cache loader elif hasattr(mat, 'vao'): mesh = Mesh(mat.name) mesh.vao = mat.vao for attrs in mat.mesh_attributes: mesh.add_attribute(*attrs) else: # Empty continue scene.meshes.append(mesh) mesh.material = Material(mat.name) scene.materials.append(mesh.material) mesh.material.color = mat.diffuse if mat.texture: # A texture can be referenced multiple times, so we need to cache loaded ones texture = texture_cache.get(mat.texture.path) if not texture: print("Loading:", mat.texture.path) texture = textures.load(TextureDescription( label=mat.texture.path, path=mat.texture.path, mipmap=True, )) texture_cache[mat.texture.path] = texture mesh.material.mat_texture = MaterialTexture( texture=texture, sampler=None, ) node = Node(mesh=mesh) scene.root_nodes.append(node) # Not supported yet for obj # self.calc_scene_bbox() scene.prepare() return scene

def start(self): """ Start the timer by recoding the current ``time.time()`` preparing to report the number of seconds since this timestamp. """ if self.start_time is None: self.start_time = time.time() # Play after pause else: # Add the duration of the paused interval to the total offset pause_duration = time.time() - self.pause_time self.offset += pause_duration # print("pause duration", pause_duration, "offset", self.offset) # Exit the paused state self.pause_time = None

def stop(self) -> float: """ Stop the timer Returns: The time the timer was stopped """ self.stop_time = time.time() return self.stop_time - self.start_time - self.offset

def get_time(self) -> float: """ Get the current time in seconds Returns: The current time in seconds """ if self.pause_time is not None: curr_time = self.pause_time - self.offset - self.start_time return curr_time curr_time = time.time() return curr_time - self.start_time - self.offset

def set_time(self, value: float): """ Set the current time. This can be used to jump in the timeline. Args: value (float): The new time """ if value < 0: value = 0 self.offset += self.get_time() - value

def resolve_loader(self, meta: SceneDescription): """ Resolve scene loader based on file extension """ for loader_cls in self._loaders: if loader_cls.supports_file(meta): meta.loader_cls = loader_cls break else: raise ImproperlyConfigured( "Scene {} has no loader class registered. Check settings.SCENE_LOADERS".format(meta.path))

def on_key_press(self, symbol, modifiers): """ Pyglet specific key press callback. Forwards and translates the events to :py:func:`keyboard_event` """ self.keyboard_event(symbol, self.keys.ACTION_PRESS, modifiers)

def on_key_release(self, symbol, modifiers): """ Pyglet specific key release callback. Forwards and translates the events to :py:func:`keyboard_event` """ self.keyboard_event(symbol, self.keys.ACTION_RELEASE, modifiers)

def on_mouse_motion(self, x, y, dx, dy): """ Pyglet specific mouse motion callback. Forwards and traslates the event to :py:func:`cursor_event` """ # screen coordinates relative to the lower-left corner self.cursor_event(x, self.buffer_height - y, dx, dy)

def on_resize(self, width, height): """ Pyglet specific callback for window resize events. """ self.width, self.height = width, height self.buffer_width, self.buffer_height = width, height self.resize(width, height)

def swap_buffers(self): """ Swap buffers, increment frame counter and pull events """ if not self.window.context: return self.frames += 1 self.window.flip() self.window.dispatch_events()

def sphere(radius=0.5, sectors=32, rings=16) -> VAO: """ Creates a sphere. Keyword Args: radius (float): Radius or the sphere rings (int): number or horizontal rings sectors (int): number of vertical segments Returns: A :py:class:`demosys.opengl.vao.VAO` instance """ R = 1.0 / (rings - 1) S = 1.0 / (sectors - 1) vertices = [0] * (rings * sectors * 3) normals = [0] * (rings * sectors * 3) uvs = [0] * (rings * sectors * 2) v, n, t = 0, 0, 0 for r in range(rings): for s in range(sectors): y = math.sin(-math.pi / 2 + math.pi * r * R) x = math.cos(2 * math.pi * s * S) * math.sin(math.pi * r * R) z = math.sin(2 * math.pi * s * S) * math.sin(math.pi * r * R) uvs[t] = s * S uvs[t + 1] = r * R vertices[v] = x * radius vertices[v + 1] = y * radius vertices[v + 2] = z * radius normals[n] = x normals[n + 1] = y normals[n + 2] = z t += 2 v += 3 n += 3 indices = [0] * rings * sectors * 6 i = 0 for r in range(rings - 1): for s in range(sectors - 1): indices[i] = r * sectors + s indices[i + 1] = (r + 1) * sectors + (s + 1) indices[i + 2] = r * sectors + (s + 1) indices[i + 3] = r * sectors + s indices[i + 4] = (r + 1) * sectors + s indices[i + 5] = (r + 1) * sectors + (s + 1) i += 6 vbo_vertices = numpy.array(vertices, dtype=numpy.float32) vbo_normals = numpy.array(normals, dtype=numpy.float32) vbo_uvs = numpy.array(uvs, dtype=numpy.float32) vbo_elements = numpy.array(indices, dtype=numpy.uint32) vao = VAO("sphere", mode=mlg.TRIANGLES) # VBOs vao.buffer(vbo_vertices, '3f', ['in_position']) vao.buffer(vbo_normals, '3f', ['in_normal']) vao.buffer(vbo_uvs, '2f', ['in_uv']) vao.index_buffer(vbo_elements, index_element_size=4) return vao

def draw(self, current_time, frame_time): """ Calls the superclass ``draw()`` methods and checks ``HEADLESS_FRAMES``/``HEADLESS_DURATION`` """ super().draw(current_time, frame_time) if self.headless_duration and current_time >= self.headless_duration: self.close()

def swap_buffers(self): """ Headless window currently don't support double buffering. We only increment the frame counter here. """ self.frames += 1 if self.headless_frames and self.frames >= self.headless_frames: self.close()

def load(self, meta: ResourceDescription) -> Any: """ Loads a resource or return existing one :param meta: The resource description """ self._check_meta(meta) self.resolve_loader(meta) return meta.loader_cls(meta).load()

def add(self, meta): """ Add a resource to this pool. The resource is loaded and returned when ``load_pool()`` is called. :param meta: The resource description """ self._check_meta(meta) self.resolve_loader(meta) self._resources.append(meta)

def load_pool(self): """ Loads all the data files using the configured finders. """ for meta in self._resources: resource = self.load(meta) yield meta, resource self._resources = []

def resolve_loader(self, meta: ResourceDescription): """ Attempts to assign a loader class to a resource description :param meta: The resource description instance """ meta.loader_cls = self.get_loader(meta, raise_on_error=True)

def get_loader(self, meta: ResourceDescription, raise_on_error=False) -> BaseLoader: """ Attempts to get a loader :param meta: The resource description instance :param raise_on_error: Raise ImproperlyConfigured if the loader cannot be resolved :returns: The requested loader class """ for loader in self._loaders: if loader.name == meta.loader: return loader if raise_on_error: raise ImproperlyConfigured( "Resource has invalid loader '{}': {}\nAvailiable loaders: {}".format( meta.loader, meta, [loader.name for loader in self._loaders]))

def keyPressEvent(self, event): """ Pyqt specific key press callback function. Translates and forwards events to :py:func:`keyboard_event`. """ self.keyboard_event(event.key(), self.keys.ACTION_PRESS, 0)

def keyReleaseEvent(self, event): """ Pyqt specific key release callback function. Translates and forwards events to :py:func:`keyboard_event`. """ self.keyboard_event(event.key(), self.keys.ACTION_RELEASE, 0)

def resize(self, width, height): """ Pyqt specific resize callback. """ if not self.fbo: return # pyqt reports sizes in actual buffer size self.width = width // self.widget.devicePixelRatio() self.height = height // self.widget.devicePixelRatio() self.buffer_width = width self.buffer_height = height super().resize(width, height)

def draw(self, texture, pos=(0.0, 0.0), scale=(1.0, 1.0)): """ Draw texture using a fullscreen quad. By default this will conver the entire screen. :param pos: (tuple) offset x, y :param scale: (tuple) scale x, y """ if not self.initialized: self.init() self._texture2d_shader["offset"].value = (pos[0] - 1.0, pos[1] - 1.0) self._texture2d_shader["scale"].value = (scale[0], scale[1]) texture.use(location=0) self._texture2d_sampler.use(location=0) self._texture2d_shader["texture0"].value = 0 self._quad.render(self._texture2d_shader) self._texture2d_sampler.clear(location=0)

def draw_depth(self, texture, near, far, pos=(0.0, 0.0), scale=(1.0, 1.0)): """ Draw depth buffer linearized. By default this will draw the texture as a full screen quad. A sampler will be used to ensure the right conditions to draw the depth buffer. :param near: Near plane in projection :param far: Far plane in projection :param pos: (tuple) offset x, y :param scale: (tuple) scale x, y """ if not self.initialized: self.init() self._depth_shader["offset"].value = (pos[0] - 1.0, pos[1] - 1.0) self._depth_shader["scale"].value = (scale[0], scale[1]) self._depth_shader["near"].value = near self._depth_shader["far"].value = far self._depth_sampler.use(location=0) texture.use(location=0) self._depth_shader["texture0"].value = 0 self._quad.render(self._depth_shader) self._depth_sampler.clear(location=0)

def _init_texture2d_draw(self): """Initialize geometry and shader for drawing FBO layers""" if not TextureHelper._quad: TextureHelper._quad = geometry.quad_fs() # Shader for drawing color layers TextureHelper._texture2d_shader = context.ctx().program( vertex_shader=""" #version 330 in vec3 in_position; in vec2 in_uv; out vec2 uv; uniform vec2 offset; uniform vec2 scale; void main() { uv = in_uv; gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0); } """, fragment_shader=""" #version 330 out vec4 out_color; in vec2 uv; uniform sampler2D texture0; void main() { out_color = texture(texture0, uv); } """ ) TextureHelper._texture2d_sampler = self.ctx.sampler( filter=(moderngl.LINEAR, moderngl.LINEAR), )

def _init_depth_texture_draw(self): """Initialize geometry and shader for drawing FBO layers""" from demosys import geometry if not TextureHelper._quad: TextureHelper._quad = geometry.quad_fs() # Shader for drawing depth layers TextureHelper._depth_shader = context.ctx().program( vertex_shader=""" #version 330 in vec3 in_position; in vec2 in_uv; out vec2 uv; uniform vec2 offset; uniform vec2 scale; void main() { uv = in_uv; gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0); } """, fragment_shader=""" #version 330 out vec4 out_color; in vec2 uv; uniform sampler2D texture0; uniform float near; uniform float far; void main() { float z = texture(texture0, uv).r; float d = (2.0 * near) / (far + near - z * (far - near)); out_color = vec4(d); } """ ) TextureHelper._depth_sampler = self.ctx.sampler( filter=(moderngl.LINEAR, moderngl.LINEAR), compare_func='', )

def draw(self, current_time, frame_time): """ Draws a frame. Internally it calls the configured timeline's draw method. Args: current_time (float): The current time (preferrably always from the configured timer class) frame_time (float): The duration of the previous frame in seconds """ self.set_default_viewport() self.timeline.draw(current_time, frame_time, self.fbo)

def clear(self): """ Clear the window buffer """ self.ctx.fbo.clear( red=self.clear_color[0], green=self.clear_color[1], blue=self.clear_color[2], alpha=self.clear_color[3], depth=self.clear_depth, )

def clear_values(self, red=0.0, green=0.0, blue=0.0, alpha=0.0, depth=1.0): """ Sets the clear values for the window buffer. Args: red (float): red compoent green (float): green compoent blue (float): blue compoent alpha (float): alpha compoent depth (float): depth value """ self.clear_color = (red, green, blue, alpha) self.clear_depth = depth

def keyboard_event(self, key, action, modifier): """ Handles the standard keyboard events such as camera movements, taking a screenshot, closing the window etc. Can be overriden add new keyboard events. Ensure this method is also called if you want to keep the standard features. Arguments: key: The key that was pressed or released action: The key action. Can be `ACTION_PRESS` or `ACTION_RELEASE` modifier: Modifiers such as holding shift or ctrl """ # The well-known standard key for quick exit if key == self.keys.ESCAPE: self.close() return # Toggle pause time if key == self.keys.SPACE and action == self.keys.ACTION_PRESS: self.timer.toggle_pause() # Camera movement # Right if key == self.keys.D: if action == self.keys.ACTION_PRESS: self.sys_camera.move_right(True) elif action == self.keys.ACTION_RELEASE: self.sys_camera.move_right(False) # Left elif key == self.keys.A: if action == self.keys.ACTION_PRESS: self.sys_camera.move_left(True) elif action == self.keys.ACTION_RELEASE: self.sys_camera.move_left(False) # Forward elif key == self.keys.W: if action == self.keys.ACTION_PRESS: self.sys_camera.move_forward(True) if action == self.keys.ACTION_RELEASE: self.sys_camera.move_forward(False) # Backwards elif key == self.keys.S: if action == self.keys.ACTION_PRESS: self.sys_camera.move_backward(True) if action == self.keys.ACTION_RELEASE: self.sys_camera.move_backward(False) # UP elif key == self.keys.Q: if action == self.keys.ACTION_PRESS: self.sys_camera.move_down(True) if action == self.keys.ACTION_RELEASE: self.sys_camera.move_down(False) # Down elif key == self.keys.E: if action == self.keys.ACTION_PRESS: self.sys_camera.move_up(True) if action == self.keys.ACTION_RELEASE: self.sys_camera.move_up(False) # Screenshots if key == self.keys.X and action == self.keys.ACTION_PRESS: screenshot.create() if key == self.keys.R and action == self.keys.ACTION_PRESS: project.instance.reload_programs() if key == self.keys.RIGHT and action == self.keys.ACTION_PRESS: self.timer.set_time(self.timer.get_time() + 10.0) if key == self.keys.LEFT and action == self.keys.ACTION_PRESS: self.timer.set_time(self.timer.get_time() - 10.0) # Forward the event to the timeline self.timeline.key_event(key, action, modifier)

def cursor_event(self, x, y, dx, dy): """ The standard mouse movement event method. Can be overriden to add new functionality. By default this feeds the system camera with new values. Args: x: The current mouse x position y: The current mouse y position dx: Delta x postion (x position difference from the previous event) dy: Delta y postion (y position difference from the previous event) """ self.sys_camera.rot_state(x, y)

def set_default_viewport(self): """ Calculates the viewport based on the configured aspect ratio in settings. Will add black borders if the window do not match the viewport. """ # The expected height with the current viewport width expected_height = int(self.buffer_width / self.aspect_ratio) # How much positive or negative y padding blank_space = self.buffer_height - expected_height self.fbo.viewport = (0, blank_space // 2, self.buffer_width, expected_height)

def start(self): """Start the timer""" self.music.start() if not self.start_paused: self.rocket.start()

def toggle_pause(self): """Toggle pause mode""" self.controller.playing = not self.controller.playing self.music.toggle_pause()

def supports_file(cls, meta): """Check if the loader has a supported file extension""" path = Path(meta.path) for ext in cls.file_extensions: if path.suffixes[:len(ext)] == ext: return True return False

def get(self, name) -> Track: """ Get or create a Track object. :param name: Name of the track :return: Track object """ name = name.lower() track = self.track_map.get(name) if not track: track = Track(name) self.tacks.append(track) self.track_map[name] = track return track

def find_commands(command_dir: str) -> List[str]: """ Get all command names in the a folder :return: List of commands names """ if not command_dir: return [] return [name for _, name, is_pkg in pkgutil.iter_modules([command_dir]) if not is_pkg and not name.startswith('_')]

def execute_from_command_line(argv=None): """ Currently the only entrypoint (manage.py, demosys-admin) """ if not argv: argv = sys.argv # prog_name = argv[0] system_commands = find_commands(system_command_dir()) project_commands = find_commands(project_command_dir()) project_package = project_package_name() command = argv[1] if len(argv) > 1 else None # Are we running a core command? if command in system_commands: cmd = load_command_class('demosys', command) cmd.run_from_argv(argv) elif command in project_commands: cmd = load_command_class(project_package, command) cmd.run_from_argv(argv) else: print("Available commands:") for name in system_commands: print(" - {}".format(name)) for name in project_commands: print(" - {}".format(name))

def update(self, **kwargs): """Override settings values""" for name, value in kwargs.items(): setattr(self, name, value)

def add_program_dir(self, directory): """Hack in program directory""" dirs = list(self.PROGRAM_DIRS) dirs.append(directory) self.PROGRAM_DIRS = dirs

def add_texture_dir(self, directory): """Hack in texture directory""" dirs = list(self.TEXTURE_DIRS) dirs.append(directory) self.TEXTURE_DIRS = dirs

def add_data_dir(self, directory): """Hack in a data directory""" dirs = list(self.DATA_DIRS) dirs.append(directory) self.DATA_DIRS = dirs

def content(self, attributes: List[str]): """Build content tuple for the buffer""" formats = [] attrs = [] for attrib_format, attrib in zip(self.attrib_formats, self.attributes): if attrib not in attributes: formats.append(attrib_format.pad_str()) continue formats.append(attrib_format.format) attrs.append(attrib) attributes.remove(attrib) if not attrs: return None return ( self.buffer, "{}{}".format(" ".join(formats), '/i' if self.per_instance else ''), *attrs )

def render(self, program: moderngl.Program, mode=None, vertices=-1, first=0, instances=1): """ Render the VAO. Args: program: The ``moderngl.Program`` Keyword Args: mode: Override the draw mode (``TRIANGLES`` etc) vertices (int): The number of vertices to transform first (int): The index of the first vertex to start with instances (int): The number of instances """ vao = self.instance(program) if mode is None: mode = self.mode vao.render(mode, vertices=vertices, first=first, instances=instances)

def render_indirect(self, program: moderngl.Program, buffer, mode=None, count=-1, *, first=0): """ The render primitive (mode) must be the same as the input primitive of the GeometryShader. The draw commands are 5 integers: (count, instanceCount, firstIndex, baseVertex, baseInstance). Args: program: The ``moderngl.Program`` buffer: The ``moderngl.Buffer`` containing indirect draw commands Keyword Args: mode (int): By default :py:data:`TRIANGLES` will be used. count (int): The number of draws. first (int): The index of the first indirect draw command. """ vao = self.instance(program) if mode is None: mode = self.mode vao.render_indirect(buffer, mode=mode, count=count, first=first)

def transform(self, program: moderngl.Program, buffer: moderngl.Buffer, mode=None, vertices=-1, first=0, instances=1): """ Transform vertices. Stores the output in a single buffer. Args: program: The ``moderngl.Program`` buffer: The ``moderngl.buffer`` to store the output Keyword Args: mode: Draw mode (for example ``moderngl.POINTS``) vertices (int): The number of vertices to transform first (int): The index of the first vertex to start with instances (int): The number of instances """ vao = self.instance(program) if mode is None: mode = self.mode vao.transform(buffer, mode=mode, vertices=vertices, first=first, instances=instances)

def buffer(self, buffer, buffer_format: str, attribute_names, per_instance=False): """ Register a buffer/vbo for the VAO. This can be called multiple times. adding multiple buffers (interleaved or not) Args: buffer: The buffer data. Can be ``numpy.array``, ``moderngl.Buffer`` or ``bytes``. buffer_format (str): The format of the buffer. (eg. ``3f 3f`` for interleaved positions and normals). attribute_names: A list of attribute names this buffer should map to. Keyword Args: per_instance (bool): Is this buffer per instance data for instanced rendering? Returns: The ``moderngl.Buffer`` instance object. This is handy when providing ``bytes`` and ``numpy.array``. """ if not isinstance(attribute_names, list): attribute_names = [attribute_names, ] if not type(buffer) in [moderngl.Buffer, numpy.ndarray, bytes]: raise VAOError( ( "buffer parameter must be a moderngl.Buffer, numpy.ndarray or bytes instance" "(not {})".format(type(buffer)) ) ) if isinstance(buffer, numpy.ndarray): buffer = self.ctx.buffer(buffer.tobytes()) if isinstance(buffer, bytes): buffer = self.ctx.buffer(data=buffer) formats = buffer_format.split() if len(formats) != len(attribute_names): raise VAOError("Format '{}' does not describe attributes {}".format(buffer_format, attribute_names)) self.buffers.append(BufferInfo(buffer, buffer_format, attribute_names, per_instance=per_instance)) self.vertex_count = self.buffers[-1].vertices return buffer

def index_buffer(self, buffer, index_element_size=4): """ Set the index buffer for this VAO Args: buffer: ``moderngl.Buffer``, ``numpy.array`` or ``bytes`` Keyword Args: index_element_size (int): Byte size of each element. 1, 2 or 4 """ if not type(buffer) in [moderngl.Buffer, numpy.ndarray, bytes]: raise VAOError("buffer parameter must be a moderngl.Buffer, numpy.ndarray or bytes instance") if isinstance(buffer, numpy.ndarray): buffer = self.ctx.buffer(buffer.tobytes()) if isinstance(buffer, bytes): buffer = self.ctx.buffer(data=buffer) self._index_buffer = buffer self._index_element_size = index_element_size

def instance(self, program: moderngl.Program) -> moderngl.VertexArray: """ Obtain the ``moderngl.VertexArray`` instance for the program. The instance is only created once and cached internally. Returns: ``moderngl.VertexArray`` instance """ vao = self.vaos.get(program.glo) if vao: return vao program_attributes = [name for name, attr in program._members.items() if isinstance(attr, moderngl.Attribute)] # Make sure all attributes are covered for attrib_name in program_attributes: # Ignore built in attributes for now if attrib_name.startswith('gl_'): continue # Do we have a buffer mapping to this attribute? if not sum(buffer.has_attribute(attrib_name) for buffer in self.buffers): raise VAOError("VAO {} doesn't have attribute {} for program {}".format( self.name, attrib_name, program.name)) vao_content = [] # Pick out the attributes we can actually map for buffer in self.buffers: content = buffer.content(program_attributes) if content: vao_content.append(content) # Any attribute left is not accounted for if program_attributes: for attrib_name in program_attributes: if attrib_name.startswith('gl_'): continue raise VAOError("Did not find a buffer mapping for {}".format([n for n in program_attributes])) # Create the vao if self._index_buffer: vao = context.ctx().vertex_array(program, vao_content, self._index_buffer, self._index_element_size) else: vao = context.ctx().vertex_array(program, vao_content) self.vaos[program.glo] = vao return vao

def release(self, buffer=True): """ Destroy the vao object Keyword Args: buffers (bool): also release buffers """ for key, vao in self.vaos: vao.release() if buffer: for buff in self.buffers: buff.buffer.release() if self._index_buffer: self._index_buffer.release()

def cube(width, height, depth, center=(0.0, 0.0, 0.0), normals=True, uvs=True) -> VAO: """ Creates a cube VAO with normals and texture coordinates Args: width (float): Width of the cube height (float): Height of the cube depth (float): Depth of the cube Keyword Args: center: center of the cube as a 3-component tuple normals: (bool) Include normals uvs: (bool) include uv coordinates Returns: A :py:class:`demosys.opengl.vao.VAO` instance """ width, height, depth = width / 2.0, height / 2.0, depth / 2.0 pos = numpy.array([ center[0] + width, center[1] - height, center[2] + depth, center[0] + width, center[1] + height, center[2] + depth, center[0] - width, center[1] - height, center[2] + depth, center[0] + width, center[1] + height, center[2] + depth, center[0] - width, center[1] + height, center[2] + depth, center[0] - width, center[1] - height, center[2] + depth, center[0] + width, center[1] - height, center[2] - depth, center[0] + width, center[1] + height, center[2] - depth, center[0] + width, center[1] - height, center[2] + depth, center[0] + width, center[1] + height, center[2] - depth, center[0] + width, center[1] + height, center[2] + depth, center[0] + width, center[1] - height, center[2] + depth, center[0] + width, center[1] - height, center[2] - depth, center[0] + width, center[1] - height, center[2] + depth, center[0] - width, center[1] - height, center[2] + depth, center[0] + width, center[1] - height, center[2] - depth, center[0] - width, center[1] - height, center[2] + depth, center[0] - width, center[1] - height, center[2] - depth, center[0] - width, center[1] - height, center[2] + depth, center[0] - width, center[1] + height, center[2] + depth, center[0] - width, center[1] + height, center[2] - depth, center[0] - width, center[1] - height, center[2] + depth, center[0] - width, center[1] + height, center[2] - depth, center[0] - width, center[1] - height, center[2] - depth, center[0] + width, center[1] + height, center[2] - depth, center[0] + width, center[1] - height, center[2] - depth, center[0] - width, center[1] - height, center[2] - depth, center[0] + width, center[1] + height, center[2] - depth, center[0] - width, center[1] - height, center[2] - depth, center[0] - width, center[1] + height, center[2] - depth, center[0] + width, center[1] + height, center[2] - depth, center[0] - width, center[1] + height, center[2] - depth, center[0] + width, center[1] + height, center[2] + depth, center[0] - width, center[1] + height, center[2] - depth, center[0] - width, center[1] + height, center[2] + depth, center[0] + width, center[1] + height, center[2] + depth, ], dtype=numpy.float32) if normals: normal_data = numpy.array([ -0, 0, 1, -0, 0, 1, -0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, -0, 0, -1, -0, 0, -1, -0, 0, -1, -0, 0, -1, -0, 0, -1, -0, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, ], dtype=numpy.float32) if uvs: uvs_data = numpy.array([ 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0 ], dtype=numpy.float32) vao = VAO("geometry:cube") # Add buffers vao.buffer(pos, '3f', ['in_position']) if normals: vao.buffer(normal_data, '3f', ['in_normal']) if uvs: vao.buffer(uvs_data, '2f', ['in_uv']) return vao

def draw(self, mesh, projection_matrix=None, view_matrix=None, camera_matrix=None, time=0): """ Draw code for the mesh. Should be overriden. :param projection_matrix: projection_matrix (bytes) :param view_matrix: view_matrix (bytes) :param camera_matrix: camera_matrix (bytes) :param time: The current time """ self.program["m_proj"].write(projection_matrix) self.program["m_mv"].write(view_matrix) mesh.vao.render(self.program)

def pause(self): """Pause the music""" self.pause_time = self.get_time() self.paused = True self.player.pause()

def get_time(self) -> float: """ Get the current time in seconds Returns: The current time in seconds """ if self.paused: return self.pause_time return self.player.get_time() / 1000.0

def parse_package_string(path): """ Parse the effect package string. Can contain the package python path or path to effect class in an effect package. Examples:: # Path to effect pacakge examples.cubes # Path to effect class examples.cubes.Cubes Args: path: python path to effect package. May also include effect class name. Returns: tuple: (package_path, effect_class) """ parts = path.split('.') # Is the last entry in the path capitalized? if parts[-1][0].isupper(): return ".".join(parts[:-1]), parts[-1] return path, ""

def get_dirs(self) -> List[str]: """ Get all effect directories for registered effects. """ for package in self.packages: yield os.path.join(package.path, 'resources')

def get_effect_resources(self) -> List[Any]: """ Get all resources registed in effect packages. These are typically located in ``resources.py`` """ resources = [] for package in self.packages: resources.extend(package.resources) return resources

def add_package(self, name): """ Registers a single package :param name: (str) The effect package to add """ name, cls_name = parse_package_string(name) if name in self.package_map: return package = EffectPackage(name) package.load() self.packages.append(package) self.package_map[package.name] = package # Load effect package dependencies self.polulate(package.effect_packages)

def get_package(self, name) -> 'EffectPackage': """ Get a package by python path. Can also contain path to an effect. Args: name (str): Path to effect package or effect Returns: The requested EffectPackage Raises: EffectError when no package is found """ name, cls_name = parse_package_string(name) try: return self.package_map[name] except KeyError: raise EffectError("No package '{}' registered".format(name))

def find_effect_class(self, path) -> Type[Effect]: """ Find an effect class by class name or full python path to class Args: path (str): effect class name or full python path to effect class Returns: Effect class Raises: EffectError if no class is found """ package_name, class_name = parse_package_string(path) if package_name: package = self.get_package(package_name) return package.find_effect_class(class_name, raise_for_error=True) for package in self.packages: effect_cls = package.find_effect_class(class_name) if effect_cls: return effect_cls raise EffectError("No effect class '{}' found in any packages".format(class_name))

def runnable_effects(self) -> List[Type[Effect]]: """Returns the runnable effect in the package""" return [cls for cls in self.effect_classes if cls.runnable]

def load_package(self): """FInd the effect package""" try: self.package = importlib.import_module(self.name) except ModuleNotFoundError: raise ModuleNotFoundError("Effect package '{}' not found.".format(self.name))

def load_effects_classes(self): """Iterate the module attributes picking out effects""" self.effect_classes = [] for _, cls in inspect.getmembers(self.effect_module): if inspect.isclass(cls): if cls == Effect: continue if issubclass(cls, Effect): self.effect_classes.append(cls) self.effect_class_map[cls.__name__] = cls cls._name = "{}.{}".format(self.effect_module_name, cls.__name__)

def load_resource_module(self): """Fetch the resource list""" # Attempt to load the dependencies module try: name = '{}.{}'.format(self.name, 'dependencies') self.dependencies_module = importlib.import_module(name) except ModuleNotFoundError as err: raise EffectError( ( "Effect package '{}' has no 'dependencies' module or the module has errors. " "Forwarded error from importlib: {}" ).format(self.name, err)) # Fetch the resource descriptions try: self.resources = getattr(self.dependencies_module, 'resources') except AttributeError: raise EffectError("Effect dependencies module '{}' has no 'resources' attribute".format(name)) if not isinstance(self.resources, list): raise EffectError( "Effect dependencies module '{}': 'resources' is of type {} instead of a list".format( name, type(self.resources))) # Fetch the effect class list try: self.effect_packages = getattr(self.dependencies_module, 'effect_packages') except AttributeError: raise EffectError("Effect dependencies module '{}' has 'effect_packages' attribute".format(name)) if not isinstance(self.effect_packages, list): raise EffectError( "Effect dependencies module '{}': 'effect_packages' is of type {} instead of a list".format( name, type(self.effects)))

def create(file_format='png', name=None): """ Create a screenshot :param file_format: formats supported by PIL (png, jpeg etc) """ dest = "" if settings.SCREENSHOT_PATH: if not os.path.exists(settings.SCREENSHOT_PATH): print("SCREENSHOT_PATH does not exist. creating: {}".format(settings.SCREENSHOT_PATH)) os.makedirs(settings.SCREENSHOT_PATH) dest = settings.SCREENSHOT_PATH else: print("SCREENSHOT_PATH not defined in settings. Using cwd as fallback.") if not Config.target: Config.target = context.window().fbo image = Image.frombytes( "RGB", (Config.target.viewport[2], Config.target.viewport[3]), Config.target.read(viewport=Config.target.viewport, alignment=Config.alignment), ) image = image.transpose(Image.FLIP_TOP_BOTTOM) if not name: name = "{}.{}".format(datetime.now().strftime("%Y-%m-%d-%H-%M-%S-%f"), file_format) dest = os.path.join(dest, name) print("Creating screenshot:", dest) image.save(dest, format=file_format)

def draw(self, time, frametime, target): """ Fetch track value for every runnable effect. If the value is > 0.5 we draw it. """ for effect in self.effects: value = effect.rocket_timeline_track.time_value(time) if value > 0.5: effect.draw(time, frametime, target)

def load(self): """Load a 2d texture""" self._open_image() components, data = image_data(self.image) texture = self.ctx.texture( self.image.size, components, data, ) texture.extra = {'meta': self.meta} if self.meta.mipmap: texture.build_mipmaps() self._close_image() return texture

def from_single(cls, meta: ProgramDescription, source: str): """Initialize a single glsl string containing all shaders""" instance = cls(meta) instance.vertex_source = ShaderSource( VERTEX_SHADER, meta.path or meta.vertex_shader, source ) if GEOMETRY_SHADER in source: instance.geometry_source = ShaderSource( GEOMETRY_SHADER, meta.path or meta.geometry_shader, source, ) if FRAGMENT_SHADER in source: instance.fragment_source = ShaderSource( FRAGMENT_SHADER, meta.path or meta.fragment_shader, source, ) if TESS_CONTROL_SHADER in source: instance.tess_control_source = ShaderSource( TESS_CONTROL_SHADER, meta.path or meta.tess_control_shader, source, ) if TESS_EVALUATION_SHADER in source: instance.tess_evaluation_source = ShaderSource( TESS_EVALUATION_SHADER, meta.path or meta.tess_evaluation_shader, source, ) return instance

def from_separate(cls, meta: ProgramDescription, vertex_source, geometry_source=None, fragment_source=None, tess_control_source=None, tess_evaluation_source=None): """Initialize multiple shader strings""" instance = cls(meta) instance.vertex_source = ShaderSource( VERTEX_SHADER, meta.path or meta.vertex_shader, vertex_source, ) if geometry_source: instance.geometry_source = ShaderSource( GEOMETRY_SHADER, meta.path or meta.geometry_shader, geometry_source, ) if fragment_source: instance.fragment_source = ShaderSource( FRAGMENT_SHADER, meta.path or meta.fragment_shader, fragment_source, ) if tess_control_source: instance.tess_control_source = ShaderSource( TESS_CONTROL_SHADER, meta.path or meta.tess_control_shader, tess_control_source, ) if tess_evaluation_source: instance.tess_evaluation_source = ShaderSource( TESS_EVALUATION_SHADER, meta.path or meta.tess_control_shader, tess_evaluation_source, ) return instance

def create(self): """ Creates a shader program. Returns: ModernGL Program instance """ # Get out varyings out_attribs = [] # If no fragment shader is present we are doing transform feedback if not self.fragment_source: # Out attributes is present in geometry shader if present if self.geometry_source: out_attribs = self.geometry_source.find_out_attribs() # Otherwise they are specified in vertex shader else: out_attribs = self.vertex_source.find_out_attribs() program = self.ctx.program( vertex_shader=self.vertex_source.source, geometry_shader=self.geometry_source.source if self.geometry_source else None, fragment_shader=self.fragment_source.source if self.fragment_source else None, tess_control_shader=self.tess_control_source.source if self.tess_control_source else None, tess_evaluation_shader=self.tess_evaluation_source.source if self.tess_evaluation_source else None, varyings=out_attribs, ) program.extra = {'meta': self.meta} return program

def find_out_attribs(self): """ Get all out attributes in the shader source. :return: List of attribute names """ names = [] for line in self.lines: if line.strip().startswith("out "): names.append(line.split()[2].replace(';', '')) return names

def print(self): """Print the shader lines""" print("---[ START {} ]---".format(self.name)) for i, line in enumerate(self.lines): print("{}: {}".format(str(i).zfill(3), line)) print("---[ END {} ]---".format(self.name))

def create_effect(self, label: str, name: str, *args, **kwargs) -> Effect: """ Create an effect instance adding it to the internal effects dictionary using the label as key. Args: label (str): The unique label for the effect instance name (str): Name or full python path to the effect class we want to instantiate args: Positional arguments to the effect initializer kwargs: Keyword arguments to the effect initializer Returns: The newly created Effect instance """ effect_cls = effects.find_effect_class(name) effect = effect_cls(*args, **kwargs) effect._label = label if label in self._effects: raise ValueError("An effect with label '{}' already exists".format(label)) self._effects[label] = effect return effect

def load(self): """ Loads this project instance """ self.create_effect_classes() self._add_resource_descriptions_to_pools(self.create_external_resources()) self._add_resource_descriptions_to_pools(self.create_resources()) for meta, resource in resources.textures.load_pool(): self._textures[meta.label] = resource for meta, resource in resources.programs.load_pool(): self._programs[meta.label] = resource for meta, resource in resources.scenes.load_pool(): self._scenes[meta.label] = resource for meta, resource in resources.data.load_pool(): self._data[meta.label] = resource self.create_effect_instances() self.post_load()

def _add_resource_descriptions_to_pools(self, meta_list): """ Takes a list of resource descriptions adding them to the resource pool they belong to scheduling them for loading. """ if not meta_list: return for meta in meta_list: getattr(resources, meta.resource_type).add(meta)

def reload_programs(self): """ Reload all shader programs with the reloadable flag set """ print("Reloading programs:") for name, program in self._programs.items(): if getattr(program, 'program', None): print(" - {}".format(program.meta.label)) program.program = resources.programs.load(program.meta)

def get_effect(self, label: str) -> Effect: """ Get an effect instance by label Args: label (str): The label for the effect instance Returns: Effect class instance """ return self._get_resource(label, self._effects, "effect")

def get_effect_class(self, class_name, package_name=None) -> Type[Effect]: """ Get an effect class from the effect registry. Args: class_name (str): The exact class name of the effect Keyword Args: package_name (str): The python path to the effect package the effect name is located. This is optional and can be used to avoid issue with class name collisions. Returns: Effect class """ if package_name: return effects.find_effect_class("{}.{}".format(package_name, class_name)) return effects.find_effect_class(class_name)

def get_scene(self, label: str) -> Scene: """ Gets a scene by label Args: label (str): The label for the scene to fetch Returns: Scene instance """ return self._get_resource(label, self._scenes, "scene")

def get_texture(self, label: str) -> Union[moderngl.Texture, moderngl.TextureArray, moderngl.Texture3D, moderngl.TextureCube]: """ Get a texture by label Args: label (str): The label for the texture to fetch Returns: Texture instance """ return self._get_resource(label, self._textures, "texture")

def get_data(self, label: str) -> Any: """ Get a data resource by label Args: label (str): The labvel for the data resource to fetch Returns: The requeted data object """ return self._get_resource(label, self._data, "data")

def _get_resource(self, label: str, source: dict, resource_type: str): """ Generic resoure fetcher handling errors. Args: label (str): The label to fetch source (dict): The dictionary to look up the label resource_type str: The display name of the resource type (used in errors) """ try: return source[label] except KeyError: raise ValueError("Cannot find {0} with label '{1}'.\nExisting {0} labels: {2}".format( resource_type, label, list(source.keys())))

def get_runnable_effects(self) -> List[Effect]: """ Returns all runnable effects in the project. :return: List of all runnable effects """ return [effect for name, effect in self._effects.items() if effect.runnable]

def image_data(image): """Get components and bytes for an image""" # NOTE: We might want to check the actual image.mode # and convert to an acceptable format. # At the moment we load the data as is. data = image.tobytes() components = len(data) // (image.size[0] * image.size[1]) return components, data

def run_from_argv(self, argv): """ Called by the system when executing the command from the command line. This should not be overridden. :param argv: Arguments from command line """ parser = self.create_parser(argv[0], argv[1]) options = parser.parse_args(argv[2:]) cmd_options = vars(options) args = cmd_options.pop('args', ()) self.handle(*args, **cmd_options)

def create_parser(self, prog_name, subcommand): """ Create argument parser and deal with ``add_arguments``. This method should not be overriden. :param prog_name: Name of the command (argv[0]) :return: ArgumentParser """ parser = argparse.ArgumentParser(prog_name, subcommand) # Add generic arguments here self.add_arguments(parser) return parser

def validate_name(self, name): """ Can the name be used as a python module or package? Raises ``ValueError`` if the name is invalid. :param name: the name to check """ if not name: raise ValueError("Name cannot be empty") # Can the name be used as an identifier in python (module or package name) if not name.isidentifier(): raise ValueError("{} is not a valid identifier".format(name))

def bbox(width=1.0, height=1.0, depth=1.0): """ Generates a bounding box with (0.0, 0.0, 0.0) as the center. This is simply a box with ``LINE_STRIP`` as draw mode. Keyword Args: width (float): Width of the box height (float): Height of the box depth (float): Depth of the box Returns: A :py:class:`demosys.opengl.vao.VAO` instance """ width, height, depth = width / 2.0, height / 2.0, depth / 2.0 pos = numpy.array([ width, -height, depth, width, height, depth, -width, -height, depth, width, height, depth, -width, height, depth, -width, -height, depth, width, -height, -depth, width, height, -depth, width, -height, depth, width, height, -depth, width, height, depth, width, -height, depth, width, -height, -depth, width, -height, depth, -width, -height, depth, width, -height, -depth, -width, -height, depth, -width, -height, -depth, -width, -height, depth, -width, height, depth, -width, height, -depth, -width, -height, depth, -width, height, -depth, -width, -height, -depth, width, height, -depth, width, -height, -depth, -width, -height, -depth, width, height, -depth, -width, -height, -depth, -width, height, -depth, width, height, -depth, -width, height, -depth, width, height, depth, -width, height, -depth, -width, height, depth, width, height, depth, ], dtype=numpy.float32) vao = VAO("geometry:cube", mode=moderngl.LINE_STRIP) vao.buffer(pos, '3f', ["in_position"]) return vao

def _find_last_of(self, path, finders): """Find the last occurance of the file in finders""" found_path = None for finder in finders: result = finder.find(path) if result: found_path = result return found_path

def initial_sanity_check(self): """Checks if we can create the project""" # Check for python module collision self.try_import(self.project_name) # Is the name a valid identifier? self.validate_name(self.project_name) # Make sure we don't mess with existing directories if os.path.exists(self.project_name): print("Directory {} already exist. Aborting.".format(self.project_name)) return False if os.path.exists('manage.py'): print("A manage.py file already exist in the current directory. Aborting.") return False return True

def create_entrypoint(self): """Write manage.py in the current directory""" with open(os.path.join(self.template_dir, 'manage.py'), 'r') as fd: data = fd.read().format(project_name=self.project_name) with open('manage.py', 'w') as fd: fd.write(data) os.chmod('manage.py', 0o777)

def get_template_dir(self): """Returns the absolute path to template directory""" directory = os.path.dirname(os.path.abspath(__file__)) directory = os.path.dirname(os.path.dirname(directory)) directory = os.path.join(directory, 'project_template') return directory

def resolve_loader(self, meta: ProgramDescription): """ Resolve program loader """ if not meta.loader: meta.loader = 'single' if meta.path else 'separate' for loader_cls in self._loaders: if loader_cls.name == meta.loader: meta.loader_cls = loader_cls break else: raise ImproperlyConfigured( ( "Program {} has no loader class registered." "Check PROGRAM_LOADERS or PROGRAM_DIRS" ).format(meta.path) )