def __init__(self, title, width, height):
settings.WINDOW['class'] = 'moderngl_window.context.glfw.Window'
settings.WINDOW['gl_version'] = (4, 6)
settings.WINDOW['size'] = (width, height)
settings.WINDOW['aspect_ratio'] = width / height
settings.WINDOW['title'] = title
settings.WINDOW['resizable'] = True
settings.WINDOW['vsync'] = True
path = os.path.abspath(__file__)
dirPath = os.path.dirname(os.path.dirname(path))
resources.register_dir(os.path.normpath(dirPath))
self.wnd = moderngl_window.create_window_from_settings()
self.ctx = self.wnd.ctx
self.wnd.key_event_func = self.key_event
self.wnd.mouse_press_event_func = self.mouse_press_event
self.wnd.mouse_release_event_func = self.mouse_release_event
self.wnd.position = (1640 - self.wnd.size[0]) // 2, (
1140 - self.wnd.size[1]) // 2
self.height = height
self.width = width
self.frames = 0
self.oldTime = 0
self.wnd.set_icon('resources/icon.png')
self.camera = camera.Camera(self.wnd.keys)
def __init__(self,
ctx: moderngl.Context = None,
wnd: BaseWindow = None,
timer: BaseTimer = None,
**kwargs):
"""Initialize the window config
Keyword Args:
ctx (moderngl.Context): The moderngl context
wnd: The window instance
timer: The timer instance
"""
self.ctx = ctx
self.wnd = wnd
self.timer = timer
if self.resource_dir:
resources.register_dir(Path(self.resource_dir).resolve())
if not self.ctx or not isinstance(self.ctx, moderngl.Context):
raise ValueError(
"WindowConfig requires a moderngl context. ctx={}".format(
self.ctx))
if not self.wnd or not isinstance(self.wnd, BaseWindow):
raise ValueError("WindowConfig requires a window. wnd={}".format(
self.wnd))
def test_reister_path_duplicates(self):
"""Ensure search path only occur once if registered multipel times"""
with settings_context(self.settings):
resources.register_dir(self.absolute_path)
resources.register_dir(self.absolute_path)
resources.register_dir(self.absolute_path)
self.assertEqual(len(settings.DATA_DIRS), 1)
from pyrr import matrix44
from pathlib import Path
import moderngl
from moderngl_window.opengl.vao import VAO
from moderngl_window import resources
from moderngl_window.meta import (
DataDescription,
TextureDescription,
ProgramDescription,
)
from .base import BaseText, FontMeta
resources.register_dir(Path(__file__).parent.resolve())
class TextWriter2D(BaseText):
"""Simple monspaced bitmapped text renderer"""
def __init__(self):
super().__init__()
meta = FontMeta(
resources.data.load(
DataDescription(path="bitmapped/text/meta.json")))
self._texture = resources.textures.load(
TextureDescription(
path="bitmapped/textures/VeraMono.png",
kind="array",
mipmap=True,
from pathlib import Path
import moderngl
from headless import HeadlessTestCase
from moderngl_window import resources
from moderngl_window.meta import TextureDescription
from moderngl_window.exceptions import ImproperlyConfigured
resources.register_dir(
(Path(__file__).parent / 'fixtures' / 'resources').resolve())
class TextureLoadersTestCase(HeadlessTestCase):
window_size = (16, 16)
aspect_ratio = 1.0
def test_texture_2d(self):
"""Load standard 2d texture"""
texture = resources.textures.load(
TextureDescription(path='textures/crate.png'))
self.assertEqual(texture.size, (192, 192))
self.assertIsInstance(texture.extra.get('meta'), TextureDescription)
def test_texture_2d_8bit(self):
"""Test loading 8 bit texture with palette"""
texture = resources.textures.load(
TextureDescription(path='textures/8bit.png'))
self.assertIsInstance(texture, moderngl.Texture)
def test_texture_not_found(self):
"""Ensure ImproperlyConfigured is raised if texture is not found"""
def test_register_file(self):
"""Attempt to register a file as a search path"""
with settings_context(self.settings):
with self.assertRaises(ImproperlyConfigured):
resources.register_dir(self.file_path)
def test_non_dir(self):
"""Register nonexistent path"""
with settings_context(self.settings):
with self.assertRaises(ImproperlyConfigured):
resources.register_dir(self.nonexist_path)
def test_relative_path(self):
"""Raise error if relative path is passed"""
with settings_context(self.settings):
with self.assertRaises(ImproperlyConfigured):
resources.register_dir(self.relative_path)
import math
from pathlib import Path
from pyrr import matrix44
from moderngl_window import resources
from moderngl_window.meta import ProgramDescription
from track import EventType
RESOURCE_DIR = Path(__file__).parent.resolve() / 'resources'
resources.register_dir(RESOURCE_DIR)
class BSScene:
def __init__(self, scene, camera, track):
self.scene = scene
self.track = track
self.camera = camera
static_color = 0.01, 0.01, 0.01, 1.0
# light/laser shaders
self.light_static_prog = resources.programs.load(
ProgramDescription(path='programs/light_static.glsl'))
self.laser_prog = resources.programs.load(
ProgramDescription(path='programs/laser.glsl'))
self.highway = self.scene.find_node('Highway')
self.highway.mesh.material.color = static_color
# Inner rings
self.inner_ring_prog = resources.programs.load(
def __init__(self,
lines=None,
line_colors=None,
lw=1,
points=None,
point_colors=None,
point_r=1):
self.point_r = point_r
# Configure to use pyglet window
window_str = 'moderngl_window.context.pyglet.Window'
window_cls = moderngl_window.get_window_cls(window_str)
window = window_cls(
title="My Window",
gl_version=(3, 3),
# aspect_ratio=1.0,
# resizable=False,
# size=(1600, 800),
)
self.wnd = window
moderngl_window.activate_context(ctx=window.ctx)
# self.wnd.gl_version = (3, 3)
resources.register_dir(Path(__file__).parent.absolute())
self.ctx = self.wnd.ctx
# register event methods
self.wnd.resize_func = self.resize
# self.wnd.iconify_func = self.iconify
# self.wnd.key_event_func = self.key_event
# self.wnd.mouse_position_event_func = self.mouse_position_event
# self.wnd.mouse_drag_event_func = self.mouse_drag_event
# self.wnd.mouse_scroll_event_func = self.mouse_scroll_event
# self.wnd.mouse_press_event_func = self.mouse_press_event
# self.wnd.mouse_release_event_func = self.mouse_release_event
# self.wnd.unicode_char_entered_func = self.unicode_char_entered
self.line_prog = programs.load(
ProgramDescription(path="rich_lines.glsl"))
self.point_prog = programs.load(ProgramDescription(path="points.glsl"))
bbox = drawing_bbox(lines + points)
bbox = drawing_bbox(lines + points, padding=0.05 * bbox[2])
self.bbox = bbox
self.drawing_W = bbox[2]
self.drawing_H = bbox[3]
if len(lines) > 0:
vertex, index, colors = build_buffers(lines, line_colors)
vbo = self.ctx.buffer(vertex)
ibo = self.ctx.buffer(index)
cbo = self.ctx.buffer(colors)
self.line_vao = self.ctx.vertex_array(self.line_prog, [
(vbo, "2f", "in_position"),
(cbo, "4f", "in_color"),
],
index_buffer=ibo)
else:
self.line_vao = None
if len(points) > 0:
point_vertex, point_color = build_point_buffers(
points, point_colors)
vbo = self.ctx.buffer(point_vertex)
cbo = self.ctx.buffer(point_color)
self.point_vao = self.ctx.vertex_array(self.point_prog, [
(vbo, "2f", "in_position"),
(cbo, "4f", "in_color"),
])
else:
self.point_vao = None
# Set the desired properties for the lines.
# Note:
# - round cap/ends are used if miter_limit < 0
# - antialias value is in model space and should probably be scaled to be ~1.5px in
# screen space
self.line_prog["linewidth"].value = lw
self.line_prog["antialias"].value = 1.5
self.line_prog["miter_limit"].value = -1
# self.line_prog["color"].value = 0, 0, 0, 1
self.update_projection()
from moderngl_window import resources
from pathlib import Path
from typing import Any, Tuple
import datetime
import moderngl_window as mglw
import numpy as np
resources.register_dir((Path(__file__).parent / "resources").resolve())
class FakeUniform:
def __init__(self, value: Any) -> None:
self.value = value
class NPS(mglw.WindowConfig):
title: str = "Nano Pixel Shader"
gl_version: Tuple[int, int] = (3, 3)
window_size: Tuple[int, int] = (1280, 720)
aspect_ratio: float = 16 / 9
vsync: bool = False
resizable: bool = False
samples: int = 8
def __init__(self, program: str, *args, **kwargs) -> None:
super(NPS, self).__init__(*args, **kwargs)
program = self.load_program(program)
faces = np.array([0, 1, 2, 1, 2, 3], dtype=np.int32)
verts = np.array(
def mode(self, window_class, msaa=1, vsync=True, strict=False, icon=None):
debug_prefix = "[MMVShaderMGLWindowHandlers.mode]"
logging.info(
f"{debug_prefix} \"i\" Set window mode [window_class={window_class}] [msaa={msaa}] [vsync={vsync}] [strict={strict}] [icon={icon}]"
)
# Get function arguments
self.headless = window_class == "headless"
self.strict = strict
self.vsync = vsync
self.msaa = msaa
# Headless we disable vsync because we're rendering only..?
# And also force aspect ratio just in case (strict option)
if self.headless:
self.strict = True
self.vsync = False
# Assign the function arguments
settings.WINDOW[
"class"] = f"moderngl_window.context.{window_class}.Window"
settings.WINDOW[
"aspect_ratio"] = self.mmv_shader_mgl.width / self.mmv_shader_mgl.height
settings.WINDOW["vsync"] = self.vsync
settings.WINDOW["title"] = "MMVShaderMGL Real Time Window"
settings.WINDOW["size"] = (self.mmv_shader_mgl.width,
self.mmv_shader_mgl.height)
# Create the window
self.window = moderngl_window.create_window_from_settings()
# Make sure we render strictly into the resolution we asked
if strict:
self.window.fbo.viewport = (0, 0, self.mmv_shader_mgl.width,
self.mmv_shader_mgl.height)
# self.window.set_default_viewport()
# Set the icon
if icon is not None:
# Absolute path
icon = Path(icon).resolve()
resources.register_dir(icon.parent)
self.window.set_icon(icon_path=icon.name)
# The context we'll use is the one from the window
self.gl_context = self.window.ctx
self.mmv_shader_mgl.gl_context = self.gl_context
self.window_should_close = False
# Functions of the window if not headless
if not self.headless:
self.window.resize_func = self.window_resize
self.window.key_event_func = self.key_event
self.window.mouse_position_event_func = self.mouse_position_event
self.window.mouse_drag_event_func = self.mouse_drag_event
self.window.mouse_scroll_event_func = self.mouse_scroll_event
self.window.mouse_press_event_func = self.mouse_press_event
self.window.mouse_release_event_func = self.mouse_release_event
self.window.unicode_char_entered_func = self.unicode_char_entered
self.window.close_func = self.close
imgui.create_context()
self.imgui = ModernglWindowRenderer(self.window)
from pathlib import Path
import moderngl_window
from moderngl_window.resources import programs
from moderngl_window import geometry
from moderngl_window import resources
from moderngl_window.finders.program import FilesystemFinder
# Register system resource directory in this package
resources.register_dir(Path(__file__).parent / 'resources')
class ShaderToyWindow(moderngl_window.WindowConfig):
title = "Python Shadertoy"
resource_dir = Path(__file__).parent
# Don't enforce a specific aspect ratio
aspect_ratio = None
main_program = None
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._main_program_mtime = 0
self._main_program_path = FilesystemFinder().find(
Path(self.main_program))
self._main_program = None
self.load_main_program()
self._quad_fs = geometry.quad_fs()
self._fallback_program = self.load_program(
'shadertoy/programs/fallback.glsl')
