Initial version

game/play.py

@@ -0,0 +1,95 @@
+import arcade, arcade.gui, pyglet, json
+
+from PIL import Image
+
+from game.shader import create_mandelbrot_shader
+from utils.constants import menu_background_color, button_style, initial_real_min, initial_real_max, initial_imag_min, initial_imag_max
+from utils.preload import button_texture, button_hovered_texture
+
+class Game(arcade.gui.UIView):
+    def __init__(self, pypresence_client):
+        super().__init__()
+
+        self.pypresence_client = pypresence_client
+        self.real_min = initial_real_min
+        self.real_max = initial_real_max
+        self.imag_min = initial_imag_min
+        self.imag_max = initial_imag_max
+
+        with open("settings.json", "r") as file:
+            self.settings_dict = json.load(file)
+
+        self.max_iter = self.settings_dict.get("max_iter", 200)
+        self.zoom = 1.0
+
+    def on_show_view(self):
+        super().on_show_view()
+
+        self.shader_program, self.mandelbrot_image = create_mandelbrot_shader(self.window.width, self.window.height, self.settings_dict.get("precision", "Single").lower())
+
+        self.mandelbrot_sprite = pyglet.sprite.Sprite(img=self.mandelbrot_image)
+
+        self.create_image()
+
+        self.pypresence_client.update(state='Viewing Mandelbrot', details=f'Zoom: {self.zoom}\nMax Iterations: {self.max_iter}', start=self.pypresence_client.start_time)
+
+        self.setup_ui()
+
+    def main_exit(self):
+        from menus.main import Main
+        self.window.show_view(Main(self.pypresence_client))
+
+    def setup_ui(self):
+        self.anchor = self.add_widget(arcade.gui.UIAnchorLayout(size_hint=(1, 1)))
+
+        self.info_box = self.anchor.add(arcade.gui.UIBoxLayout(space_between=10, vertical=False), anchor_x="center", anchor_y="top")
+        self.zoom_label = self.info_box.add(arcade.gui.UILabel(text=f"Zoom: {self.zoom}", font_name="Protest Strike", font_size=16))
+        self.max_iter_label = self.info_box.add(arcade.gui.UILabel(text=f"Max Iterations: {self.max_iter}", font_name="Protest Strike", font_size=16))
+
+        self.back_button = arcade.gui.UITextureButton(texture=button_texture, texture_hovered=button_hovered_texture, text='<--', style=button_style, width=100, height=50)
+        self.back_button.on_click = lambda event: self.main_exit()
+        self.anchor.add(self.back_button, anchor_x="left", anchor_y="top", align_x=5, align_y=-5)
+
+    def zoom_at(self, center_x, center_y, zoom_factor):
+        center_real = self.real_min + (center_x / self.width) * (self.real_max - self.real_min)
+        center_imag = self.imag_min + (center_y / self.height) * (self.imag_max - self.imag_min)
+
+        new_real_range = (self.real_max - self.real_min) / zoom_factor
+        new_imag_range = (self.imag_max - self.imag_min) / zoom_factor
+
+        self.real_min = center_real - new_real_range / 2
+        self.real_max = center_real + new_real_range / 2
+        self.imag_min = center_imag - new_imag_range / 2
+        self.imag_max = center_imag + new_imag_range / 2
+
+    def create_image(self):
+        with self.shader_program:
+            self.shader_program['u_maxIter'] = self.max_iter
+            self.shader_program['u_resolution'] = (self.window.width, self.window.height)
+            self.shader_program['u_real_range'] = (self.real_min, self.real_max)
+            self.shader_program['u_imag_range'] = (self.imag_min, self.imag_max)
+            self.shader_program.dispatch(self.mandelbrot_image.width, self.mandelbrot_image.height, 1, barrier=pyglet.gl.GL_ALL_BARRIER_BITS)
+
+    def on_mouse_press(self, x: int, y: int, button: int, modifiers: int) -> bool | None:
+        super().on_mouse_press(x, y, button, modifiers)
+
+        if button == arcade.MOUSE_BUTTON_LEFT:
+            zoom = self.settings_dict.get("zoom_increase", 2)
+        elif button == arcade.MOUSE_BUTTON_RIGHT:
+            zoom = 1 / self.settings_dict.get("zoom_increase", 2)
+        else:
+            return
+
+        self.zoom *= zoom
+
+        self.zoom_label.text = f"Zoom: {self.zoom}"
+
+        self.zoom_at(self.window.mouse.data["x"], self.window.mouse.data["y"], zoom)
+        self.create_image()
+
+        self.pypresence_client.update(state='Viewing Mandelbrot', details=f'Zoom: {self.zoom}\nMax Iterations: {self.max_iter}', start=self.pypresence_client.start_time)
+
+    def on_draw(self):
+        self.window.clear()
+        self.mandelbrot_sprite.draw()
+        self.ui.draw()

game/shader.py

@@ -0,0 +1,70 @@
+import pyglet
+mandelbrot_compute_source = """#version 430 core
+
+uniform int u_maxIter;
+uniform vec2 u_resolution;
+uniform vec2 u_real_range;
+uniform vec2 u_imag_range;
+
+layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+layout(location = 0, rgba32f) uniform image2D img_output;
+
+int mandelbrot({vec2type} c, int maxIter) {
+    {vec2type} z = {vec2type}(0.0, 0.0);
+    for (int n = 0; n < maxIter; n++) {
+        if (dot(z, z) > 4.0) {
+            return n;
+        }
+        z = {vec2type}(
+            z.x * z.x - z.y * z.y + c.x,
+            2.0 * z.x * z.y + c.y
+        );
+    }
+    return maxIter;
+}
+
+{vec2type} map_pixel({floattype} x, {floattype} y, {vec2type} resolution, {vec2type} real_range, {vec2type} imag_range) {
+    {floattype} real = real_range.x + (x / resolution.x) * (real_range.y - real_range.x);
+    {floattype} imag = imag_range.x + (y / resolution.y) * (imag_range.y - imag_range.x);
+    return {vec2type}(real, imag);
+}
+
+void main() {
+    ivec2 texel_coord = ivec2(gl_GlobalInvocationID.xy);
+    {vec2type} c = map_pixel({floattype}(texel_coord.x), {floattype}(texel_coord.y), u_resolution, u_real_range, u_imag_range);
+    int iters = mandelbrot(c, u_maxIter);
+
+    vec4 value = vec4(0.0, 0.0, 0.0, 1.0);
+
+    if (iters != u_maxIter) {
+        float t = float(iters) / float(u_maxIter);
+        float pow_amount = 0.7;
+        t = pow(t, pow_amount);
+
+        value.r = 9.0 * (1.0 - t) * t * t * t;
+        value.g = 15.0 * (1.0 - t) * (1.0 - t) * t * t;
+        value.b = 8.5 * (1.0 - t) * (1.0 - t) * (1.0 - t) * t;
+    }
+
+    imageStore(img_output, texel_coord, value);
+}
+"""
+
+def create_mandelbrot_shader(width, height, precision="single"):
+    shader_source = mandelbrot_compute_source
+
+    if precision == "single":
+        shader_source = shader_source.replace("{vec2type}", "vec2").replace("{floattype}", "float")
+    elif precision == "double":
+        shader_source = shader_source.replace("{vec2type}", "dvec2").replace("{floattype}", "double")
+    else:
+        raise TypeError("Invalid Precision")
+
+    shader_program = pyglet.graphics.shader.ComputeShaderProgram(shader_source)
+
+    mandelbrot_image = pyglet.image.Texture.create(width, height, internalformat=pyglet.gl.GL_RGBA32F)
+
+    uniform_location = shader_program['img_output']
+    mandelbrot_image.bind_image_texture(unit=uniform_location)
+
+    return shader_program, mandelbrot_image