OpenGL (gl)

import gl

def main() -> i32:
    print(gl.available(), gl.screen_width(), gl.screen_height())
    return 0

import gl

def main() -> i32:
    window: gl.Window = gl.Window("probe", 320, 200, gl.WINDOW_VISIBLE)
    if not window.is_open():
        print("no context on this host")
        return 1
    window.make_current()
    print(gl.version(), gl.vendor(), gl.renderer())
    window.destroy()
    return 0

from gl.window import Window
from gl.constants import GL_COLOR_BUFFER_BIT

from gl.window import Window
from gl.constants import GL_COLOR_BUFFER_BIT
from gl.state import clear, clear_color

def main() -> i32:
    window: Window = Window("part", 320, 200)
    if not window.is_open():
        return 1
    window.make_current()

    clear_color(0.1, 0.1, 0.12, 1.0)
    clear(GL_COLOR_BUFFER_BIT)
    window.swap()
    window.destroy()
    return 0

import gl

def main() -> i32:
    window: gl.Window = gl.Window("state", 200, 150, gl.WINDOW_VISIBLE)
    if not window.is_open():
        return 1
    window.make_current()

    gl.enable(gl.GL_DEPTH_TEST)
    gl.depth_func(gl.GL_LESS)
    assert gl.is_enabled(gl.GL_DEPTH_TEST)
    gl.disable(gl.GL_DEPTH_TEST)
    assert not gl.is_enabled(gl.GL_DEPTH_TEST)

    assert window.vsync() or not window.vsync()   # both are bools
    window.destroy()
    return 0

import gl

def main() -> i32:
    window: gl.Window = gl.Window("triangle", 640, 360)
    if not window.is_open():
        print("no display available")
        return 1

    window.make_current()
    gl.default_depth_state()

    while window.is_open():
        window.poll()
        if window.should_close() or window.key_pressed(gl.KEY_ESCAPE):
            window.destroy()

        gl.viewport(0, 0, window.framebuffer_width(), window.framebuffer_height())
        gl.clear_color(0.08, 0.09, 0.12, 1.0)
        gl.clear(gl.GL_COLOR_BUFFER_BIT)

        gl.begin(gl.GL_TRIANGLES)
        gl.color3f(1.0, 0.35, 0.3)
        gl.vertex2f(0.0, 0.7)
        gl.color3f(0.3, 1.0, 0.5)
        gl.vertex2f(-0.7, -0.6)
        gl.color3f(0.3, 0.5, 1.0)
        gl.vertex2f(0.7, -0.6)
        gl.end()

        window.swap()

    return 0

window: gl.Window = gl.Window("title", 960, 540)

import gl

def main() -> i32:
    hidden: gl.Window = gl.Window("hidden", 320, 200, gl.WINDOW_RESIZABLE)
    if not hidden.is_open():
        return 1
    hidden.make_current()

    # A hidden window still has a context: render, read, then show it.
    hidden.show()
    print(hidden.visible(), hidden.resizable(), hidden.decorated())
    hidden.destroy()

    # Fullscreen with vsync, and a maximised window with the default flags.
    game: gl.Window = gl.Window("game", 1280, 720, gl.WINDOW_FULLSCREEN + gl.WINDOW_VSYNC)
    print(game.fullscreen(), game.vsync())
    game.destroy()
    return 0

import gl

def main() -> i32:
    window: gl.Window = gl.Window("mouse look", 640, 360)
    if not window.is_open():
        return 1
    window.make_current()
    window.set_cursor_mode(gl.CURSOR_DISABLED)
    print(gl.cursor_mode_name(window.cursor_mode()))

    while window.is_open():
        window.poll()
        if window.should_close():
            window.destroy()
        # Deltas are pixels moved this frame, and keep counting in DISABLED mode.
        yaw: i32 = window.mouse_dx()
        pitch: i32 = window.mouse_dy()
        if yaw != 0 or pitch != 0:
            print(yaw, pitch)
        window.swap()

    return 0

import gl

def main() -> i32:
    window: gl.Window = gl.Window("input", 640, 360)
    if not window.is_open():
        return 1
    window.make_current()

    while window.is_open():
        window.poll()
        if window.should_close() or window.key_pressed(gl.KEY_ESCAPE):
            window.destroy()

        # Held: continuous action, such as camera movement.
        if window.key(gl.KEY_W):
            print("forward")

        # Pressed: one-shot action, such as a jump or a toggle.
        if window.key_pressed(gl.KEY_SPACE):
            print("jump")

        # Modifiers combine, so test each bit separately.
        if window.modifier(gl.MOD_CONTROL) and window.key_pressed(gl.KEY_S):
            print("save")

        if window.mouse_pressed(gl.MOUSE_LEFT):
            print("click at", window.mouse_x(), window.mouse_y())

        typed: i32 = window.typed_char()
        if typed != 0:
            print("char code", typed)

        window.swap()

    return 0

import gl

def main() -> i32:
    window: gl.Window = gl.Window("motion", 640, 360)
    if not window.is_open():
        return 1
    window.make_current()

    speed: f64 = 0.6            # units per second
    x: f64 = 0.0

    while window.is_open():
        window.poll()
        if window.should_close():
            window.destroy()

        delta: f64 = window.dt()
        if delta > 0.1:
            delta = 0.1         # clamp after a stall so nothing teleports
        x = x + speed * delta
        if x > 0.8:
            x = -0.8

        gl.viewport(0, 0, window.framebuffer_width(), window.framebuffer_height())
        gl.clear(gl.GL_COLOR_BUFFER_BIT)
        gl.rect(x, -0.1, 0.2, 0.2)
        window.swap()

    return 0

import gl

def main() -> i32:
    window: gl.Window = gl.Window("clear", 320, 200)
    if not window.is_open():
        return 1
    window.make_current()

    gl.clear_color(0.05, 0.06, 0.09, 1.0)
    gl.clear_depth(1.0)
    gl.clear_stencil(0)
    mask: u32 = gl.GL_COLOR_BUFFER_BIT + gl.GL_DEPTH_BUFFER_BIT + gl.GL_STENCIL_BUFFER_BIT
    gl.clear(mask)

    window.swap()
    window.destroy()
    return 0

import gl

def main() -> i32:
    window: gl.Window = gl.Window("immediate", 480, 320)
    if not window.is_open():
        return 1
    window.make_current()

    while window.is_open():
        window.poll()
        if window.should_close() or window.key_pressed(gl.KEY_ESCAPE):
            window.destroy()

        gl.viewport(0, 0, window.framebuffer_width(), window.framebuffer_height())
        gl.clear_color(0.1, 0.1, 0.14, 1.0)
        gl.clear(gl.GL_COLOR_BUFFER_BIT)

        # A quad, a circle, a line, and a triangle, using the helpers.
        gl.color3f(0.9, 0.4, 0.3)
        gl.rect(-0.9, -0.9, 0.5, 0.5)

        gl.color3f(0.3, 0.8, 0.9)
        gl.circle(0.4, 0.4, 0.35, 64)

        gl.color3f(1.0, 1.0, 1.0)
        gl.line(-0.9, 0.9, 0.9, 0.2)

        gl.triangle(0.0, 0.9, -0.3, 0.4, 0.3, 0.4)

        window.swap()

    return 0

import gl

VERTEX: str = """#version 120
attribute vec2 position;
attribute vec3 colour;
varying vec3 tint;
void main() {
    tint = colour;
    gl_Position = vec4(position, 0.0, 1.0);
}
"""

FRAGMENT: str = """#version 120
varying vec3 tint;
void main() {
    gl_FragColor = vec4(tint, 1.0);
}
"""

def main() -> i32:
    window: gl.Window = gl.Window("shaders", 480, 320)
    if not window.is_open():
        return 1
    window.make_current()

    program: gl.Program = gl.build(VERTEX, FRAGMENT)
    if not program.ok():
        print("shader log:", program.log)
        window.destroy()
        return 1

    while window.is_open():
        window.poll()
        if window.should_close() or window.key_pressed(gl.KEY_ESCAPE):
            window.destroy()

        gl.viewport(0, 0, window.framebuffer_width(), window.framebuffer_height())
        gl.clear(gl.GL_COLOR_BUFFER_BIT)
        program.use()
        program.set_float("time", window.time())
        window.swap()

    program.destroy()
    return 0

import gl

VERTEX: str = """#version 120
attribute vec2 position;
uniform mat4 transform;
void main() {
    gl_Position = transform * vec4(position, 0.0, 1.0);
}
"""

FRAGMENT: str = """#version 120
uniform vec4 tint;
void main() {
    gl_FragColor = tint;
}
"""

def main() -> i32:
    window: gl.Window = gl.Window("uniforms", 480, 320)
    if not window.is_open():
        return 1
    window.make_current()

    program: gl.Program = gl.build(VERTEX, FRAGMENT)
    if not program.ok():
        print(program.log)
        window.destroy()
        return 1
    program.use()

    # Column-major 4x4: three scaled basis axes and no translation. This scalar
    # matrix is symmetric, so the storage order does not change it; for a
    # rotation or a translation use gl.set_matrix4, which transposes.
    transform: list[f64] = [
        2.0, 0.0, 0.0, 0.0,
        0.0, 2.0, 0.0, 0.0,
        0.0, 0.0, 2.0, 0.0,
        0.0, 0.0, 0.0, 1.0]
    program.set_mat4("transform", transform)
    program.set_vec4("tint", 1.0, 0.4, 0.2, 1.0)
    print(program.uniform("nonexistent"))

    window.swap()
    program.destroy()
    window.destroy()
    return 0

program.set_mat4("model", model.data)   # wrong: the shader sees the transpose
gl.set_matrix4(program, "model", model) # right: transposes on the way in

# or, when you want the block yourself:
block: list[f64] = gl.matrix4_data(model)
program.set_mat4("model", block)

import gl
import matrix

def main() -> i32:
    aspect: f64 = gl.aspect_ratio(1280, 720)

    # Degrees for people, radians for the matrix module.
    perspective: matrix.Mat4 = gl.perspective_deg(60.0, aspect, 0.1, 1000.0)
    same: matrix.Mat4 = gl.perspective(gl.to_radians(60.0), aspect, 0.1, 1000.0)

    # Two dimensions, in pixels: the origin is the top-left corner and y grows
    # downward, which is what a sprite or UI layer wants.
    screen: matrix.Mat4 = gl.ortho_2d(1280, 720)

    # Y up, centred on the origin: the shape a 2D game or a plot wants.
    centred: matrix.Mat4 = gl.ortho_centered(16.0, 9.0)

    # An explicit box, for a CAD view or a shadow map pass.
    box: matrix.Mat4 = gl.ortho(-10.0, 10.0, -5.0, 5.0, 0.1, 100.0)

    print(perspective.data[0], same.data[5], screen.data[0], centred.data[5], box.data[0])
    return 0

import gl
import matrix

def main() -> i32:
    # Look at a point from an angle, rather than picking the position by hand.
    camera: gl.Camera = gl.orbit_camera(gl.vec3(0.0, 1.0, 0.0), 35.0, 20.0, 8.0)
    camera.set_fov_degrees(50.0)
    camera.set_clip(0.1, 200.0)
    camera.set_aspect_ratio(16.0 / 9.0)

    print(camera.position.to_list())
    print(camera.forward().to_list(), camera.right().to_list())

    view: matrix.Mat4 = camera.view()
    projection: matrix.Mat4 = camera.projection()
    combined: matrix.Mat4 = camera.view_projection()
    print(view.data[11], projection.data[0], combined.data[0])
    return 0

import gl

def main() -> i32:
    model: gl.Transform = gl.Transform()
    model.position = gl.vec3(2.0, 0.0, 0.0)
    model.rotation = gl.vec3(0.0, 0.0, gl.to_radians(30.0))
    model.scaling = gl.vec3(2.0, 1.0, 1.0)

    # The model matrix, and the normal matrix that goes with an uneven scale.
    print(model.matrix().data[3], model.normal_matrix().data[0])

    # The same thing with the mutating helpers: turn spins by a frame's worth
    # of radians, move slides it along, scale_by multiplies.
    model.turn(0.0, 0.01, 0.0)
    model.move(0.0, 0.0, -0.5)
    model.scale_by(1.0, 1.0, 1.0)
    print(model.position.to_list())

    # A unit quad placed at a pixel rectangle, for ortho_2d drawing.
    quad: gl.Transform = gl.Transform()
    print(gl.sprite_matrix(10.0, 20.0, 30.0, 40.0).transform_point(1.0, 1.0, 0.0))
    return 0

import gl
import matrix

VERTEX: str = """#version 120
attribute vec3 position;
attribute vec3 normal;
uniform mat4 mvp;
uniform mat4 model;
uniform mat3 normal_matrix;
varying vec3 shade;
void main() {
    shade = normalize(normal_matrix * normal);
    gl_Position = mvp * vec4(position, 1.0);
}
"""

FRAGMENT: str = """#version 120
varying vec3 shade;
void main() {
    gl_FragColor = vec4(abs(shade), 1.0);
}
"""

def main() -> i32:
    window: gl.Window = gl.Window("lit", 640, 400)
    if not window.is_open():
        return 1
    window.make_current()

    program: gl.Program = gl.build(VERTEX, FRAGMENT)
    if not program.ok():
        print(program.log)
        window.destroy()
        return 1
    program.bind_attribute(0, "position")
    program.bind_attribute(1, "normal")
    program.link()
    program.use()

    camera: gl.Camera = gl.orbit_camera(gl.vec3(0.0, 0.0, 0.0), 30.0, 20.0, 6.0)
    camera.set_aspect_ratio(gl.aspect_of_window(window))
    camera.upload(program)

    model: gl.Transform = gl.Transform()
    model.uniform_scale(1.5)
    gl.set_matrix4(program, "model", model.matrix())
    gl.set_normal_matrix(program, "normal_matrix", model.matrix())
    camera.upload_mvp(program, "mvp", model.matrix())

    gl.apply_viewport(window)
    gl.clear_color(0.1, 0.1, 0.12, 1.0)
    gl.clear(gl.GL_COLOR_BUFFER_BIT + gl.GL_DEPTH_BUFFER_BIT)
    gl.enable(gl.GL_DEPTH_TEST)
    gl.draw_arrays(gl.GL_TRIANGLES, 0, 36)
    window.swap()

    program.destroy()
    window.destroy()
    return 0

import gl
import math

def ray_sphere(ray: list[f64], cx: f64, cy: f64, cz: f64, radius: f64) -> f64:
    """Return how far along a ray a sphere is hit, or -1.0 for a miss.

    The ray is [ox, oy, oz, dx, dy, dz] with a unit direction, which is exactly
    what Camera.ray returns.
    """
    ox: f64 = ray[0] - cx
    oy: f64 = ray[1] - cy
    oz: f64 = ray[2] - cz
    b: f64 = ox * ray[3] + oy * ray[4] + oz * ray[5]
    c: f64 = ox * ox + oy * oy + oz * oz - radius * radius
    disc: f64 = b * b - c
    if disc < 0.0:
        return -1.0
    return -b - math.sqrt(disc)

def main() -> i32:
    camera: gl.Camera = gl.make_camera(gl.vec3(0.0, 0.0, 5.0), gl.vec3(0.0, 0.0, 0.0))
    camera.set_aspect_ratio(1.0)

    # A click in the middle of the window, aimed at a sphere at the origin.
    ray: list[f64] = camera.ray(320.0, 240.0, 640, 480)
    print("ray:", ray)
    print("hit at:", ray_sphere(ray, 0.0, 0.0, 0.0, 1.0))
    print("misses:", ray_sphere(ray, 3.0, 0.0, 0.0, 1.0))

    # Where a world point lands on screen, for an overlay.
    mvp: matrix.Mat4 = camera.view_projection()
    print(gl.project_to_screen(mvp, gl.vec3(1.0, 1.0, 0.0), 640, 480))
    return 0