`8d13407`

Add GPU-accelerated text rendering with FreeType atlas

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: 8d13407d9b9eb1a270bc24162dc6abe2b2f7699d
Parents: d016cd4
Tree: 592e12b

9 changed files

Status	File	+	-
M	`CMakeLists.txt`	3	0
M	`c_src/gl_loader.c`	192	0
A	`shaders/text.frag`	13	0
A	`shaders/text.vert`	16	0
M	`src/fortty.f90`	44	1
M	`src/gl/gl_bindings.f90`	290	9
A	`src/gl/shader.f90`	133	0
A	`src/text/atlas.f90`	161	0
A	`src/text/renderer.f90`	331	0

CMakeLists.txtmodified

      src/core/types.f90
      src/gl/gl_bindings.f90
      src/text/glyph.f90
 +    src/gl/shader.f90
      src/text/font.f90
 +    src/text/atlas.f90
 +    src/text/renderer.f90
      src/window/glfw_bindings.f90
      src/window/window.f90
      src/fortty.f90

c_src/gl_loader.cmodified

  void fortty_glClearColor(float red, float green, float blue, float alpha) {
      glClearColor(red, green, blue, alpha);
+ }
++
 +/* ============ Texture functions ============ */
++
 +void fortty_glGenTextures(int n, unsigned int *textures) {
 +    glGenTextures(n, textures);
 +}
++
 +void fortty_glDeleteTextures(int n, unsigned int *textures) {
 +    glDeleteTextures(n, textures);
 +}
++
 +void fortty_glBindTexture(unsigned int target, unsigned int texture) {
 +    glBindTexture(target, texture);
 +}
++
 +void fortty_glTexImage2D(unsigned int target, int level, int internalformat,
 +                         int width, int height, int border,
 +                         unsigned int format, unsigned int type, const void *data) {
 +    glTexImage2D(target, level, internalformat, width, height, border, format, type, data);
 +}
++
 +void fortty_glTexSubImage2D(unsigned int target, int level,
 +                            int xoffset, int yoffset, int width, int height,
 +                            unsigned int format, unsigned int type, const void *data) {
 +    glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
 +}
++
 +void fortty_glTexParameteri(unsigned int target, unsigned int pname, int param) {
 +    glTexParameteri(target, pname, param);
 +}
++
 +void fortty_glPixelStorei(unsigned int pname, int param) {
 +    glPixelStorei(pname, param);
 +}
++
 +void fortty_glActiveTexture(unsigned int texture) {
 +    glActiveTexture(texture);
 +}
++
 +/* ============ Shader functions ============ */
++
 +unsigned int fortty_glCreateShader(unsigned int type) {
 +    return glCreateShader(type);
 +}
++
 +void fortty_glDeleteShader(unsigned int shader) {
 +    glDeleteShader(shader);
 +}
++
 +void fortty_glShaderSource(unsigned int shader, const char *source) {
 +    const char *sources[1] = { source };
 +    glShaderSource(shader, 1, sources, NULL);
 +}
++
 +void fortty_glCompileShader(unsigned int shader) {
 +    glCompileShader(shader);
 +}
++
 +int fortty_glGetShaderCompileStatus(unsigned int shader) {
 +    int success;
 +    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
 +    return success;
 +}
++
 +void fortty_glGetShaderInfoLog(unsigned int shader, char *log, int maxlen) {
 +    glGetShaderInfoLog(shader, maxlen, NULL, log);
 +}
++
 +unsigned int fortty_glCreateProgram(void) {
 +    return glCreateProgram();
 +}
++
 +void fortty_glDeleteProgram(unsigned int program) {
 +    glDeleteProgram(program);
 +}
++
 +void fortty_glAttachShader(unsigned int program, unsigned int shader) {
 +    glAttachShader(program, shader);
 +}
++
 +void fortty_glLinkProgram(unsigned int program) {
 +    glLinkProgram(program);
 +}
++
 +int fortty_glGetProgramLinkStatus(unsigned int program) {
 +    int success;
 +    glGetProgramiv(program, GL_LINK_STATUS, &success);
 +    return success;
 +}
++
 +void fortty_glGetProgramInfoLog(unsigned int program, char *log, int maxlen) {
 +    glGetProgramInfoLog(program, maxlen, NULL, log);
 +}
++
 +void fortty_glUseProgram(unsigned int program) {
 +    glUseProgram(program);
 +}
++
 +int fortty_glGetUniformLocation(unsigned int program, const char *name) {
 +    return glGetUniformLocation(program, name);
 +}
++
 +void fortty_glUniform1i(int location, int value) {
 +    glUniform1i(location, value);
 +}
++
 +void fortty_glUniform1f(int location, float value) {
 +    glUniform1f(location, value);
 +}
++
 +void fortty_glUniform3f(int location, float v0, float v1, float v2) {
 +    glUniform3f(location, v0, v1, v2);
 +}
++
 +void fortty_glUniform4f(int location, float v0, float v1, float v2, float v3) {
 +    glUniform4f(location, v0, v1, v2, v3);
 +}
++
 +void fortty_glUniformMatrix4fv(int location, int count, int transpose, const float *value) {
 +    glUniformMatrix4fv(location, count, transpose, value);
 +}
++
 +/* ============ VAO/VBO functions ============ */
++
 +void fortty_glGenVertexArrays(int n, unsigned int *arrays) {
 +    glGenVertexArrays(n, arrays);
 +}
++
 +void fortty_glDeleteVertexArrays(int n, unsigned int *arrays) {
 +    glDeleteVertexArrays(n, arrays);
 +}
++
 +void fortty_glBindVertexArray(unsigned int array) {
 +    glBindVertexArray(array);
 +}
++
 +void fortty_glGenBuffers(int n, unsigned int *buffers) {
 +    glGenBuffers(n, buffers);
 +}
++
 +void fortty_glDeleteBuffers(int n, unsigned int *buffers) {
 +    glDeleteBuffers(n, buffers);
 +}
++
 +void fortty_glBindBuffer(unsigned int target, unsigned int buffer) {
 +    glBindBuffer(target, buffer);
 +}
++
 +void fortty_glBufferData(unsigned int target, size_t size, const void *data, unsigned int usage) {
 +    glBufferData(target, size, data, usage);
 +}
++
 +void fortty_glBufferSubData(unsigned int target, size_t offset, size_t size, const void *data) {
 +    glBufferSubData(target, offset, size, data);
 +}
++
 +void fortty_glBufferSubData_floats(unsigned int target, size_t offset, size_t size, const float *data) {
 +    glBufferSubData(target, offset, size, data);
 +}
++
 +void fortty_glVertexAttribPointer(unsigned int index, int size, unsigned int type,
 +                                   int normalized, int stride, size_t offset) {
 +    glVertexAttribPointer(index, size, type, normalized, stride, (void*)offset);
 +}
++
 +void fortty_glEnableVertexAttribArray(unsigned int index) {
 +    glEnableVertexAttribArray(index);
 +}
++
 +void fortty_glDisableVertexAttribArray(unsigned int index) {
 +    glDisableVertexAttribArray(index);
 +}
++
 +/* ============ Drawing functions ============ */
++
 +void fortty_glDrawArrays(unsigned int mode, int first, int count) {
 +    glDrawArrays(mode, first, count);
 +}
++
 +/* ============ State functions ============ */
++
 +void fortty_glEnable(unsigned int cap) {
 +    glEnable(cap);
 +}
++
 +void fortty_glDisable(unsigned int cap) {
 +    glDisable(cap);
 +}
++
 +void fortty_glBlendFunc(unsigned int sfactor, unsigned int dfactor) {
 +    glBlendFunc(sfactor, dfactor);
 +}

shaders/text.fragadded

 +#version 330 core
++
 +in vec2 v_texcoord;
 +in vec4 v_color;
++
 +uniform sampler2D u_atlas;
++
 +out vec4 frag_color;
++
 +void main() {
 +    float alpha = texture(u_atlas, v_texcoord).r;
 +    frag_color = vec4(v_color.rgb, v_color.a * alpha);
 +}

shaders/text.vertadded

 +#version 330 core
++
 +layout(location = 0) in vec2 a_position;
 +layout(location = 1) in vec2 a_texcoord;
 +layout(location = 2) in vec4 a_color;
++
 +uniform mat4 u_projection;
++
 +out vec2 v_texcoord;
 +out vec4 v_color;
++
 +void main() {
 +    gl_Position = u_projection * vec4(a_position, 0.0, 1.0);
 +    v_texcoord = a_texcoord;
 +    v_color = a_color;
 +}

src/fortty.f90modified

  program fortty
    use window_mod
    use gl_bindings
 +  use renderer_mod
    implicit none
    type(window_t) :: win
 +  type(renderer_t) :: ren
 +  integer :: win_width, win_height
 +  character(len=256) :: font_path
++
 +  ! Window dimensions
 +  win_width = 800
 +  win_height = 600
    ! Create window with OpenGL context
 -  win = window_create(800, 600, "fortty")
 +  win = window_create(win_width, win_height, "fortty")
++
 +  ! Font path - try common system locations
 +  font_path = "/usr/share/fonts/TTF/DejaVuSansMono.ttf"
++
 +  ! Create renderer with font
 +  ren = renderer_create(trim(font_path), 24)
 +  if (.not. ren%initialized) then
 +    print *, "Warning: Could not load font, trying alternate path..."
 +    font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf"
 +    ren = renderer_create(trim(font_path), 24)
 +  end if
++
 +  if (.not. ren%initialized) then
 +    print *, "Error: Could not initialize renderer"
 +    print *, "Please ensure DejaVu Sans Mono font is installed"
 +    call window_destroy(win)
 +    stop 1
 +  end if
++
 +  ! Set up projection matrix
 +  call renderer_set_projection(ren, win_width, win_height)
    ! Main event loop
    do while (.not. window_should_close(win))
      call glClearColor(0.1, 0.1, 0.12, 1.0)
      call glClear(GL_COLOR_BUFFER_BIT)
 +    ! Begin new frame
 +    call renderer_begin(ren)
++
 +    ! Draw test text
 +    call renderer_draw_string(ren, 50.0, 100.0, "Hello, Fortran!", &
 +                              1.0, 1.0, 1.0, 1.0)
++
 +    call renderer_draw_string(ren, 50.0, 150.0, "Terminal emulator in progress...", &
 +                              0.7, 0.7, 0.7, 1.0)
++
 +    ! Flush to GPU
 +    call renderer_flush(ren)
++
      ! Swap buffers and poll events
      call window_swap_buffers(win)
      call window_poll_events()
    end do
    ! Cleanup
 +  call renderer_destroy(ren)
    call window_destroy(win)
  end program fortty

src/gl/gl_bindings.f90modified

    ! OpenGL constants
    integer(c_int), parameter :: GL_COLOR_BUFFER_BIT = int(Z'00004000', c_int)
 +  integer(c_int), parameter :: GL_DEPTH_BUFFER_BIT = int(Z'00000100', c_int)
 -  ! OpenGL type aliases
 -  integer, parameter :: GLint = c_int
 -  integer, parameter :: GLsizei = c_int
 -  integer, parameter :: GLfloat = c_float
 -  integer, parameter :: GLbitfield = c_int
 +  ! Texture constants
 +  integer(c_int), parameter :: GL_TEXTURE_2D = int(Z'0DE1', c_int)
 +  integer(c_int), parameter :: GL_TEXTURE0 = int(Z'84C0', c_int)
 +  integer(c_int), parameter :: GL_TEXTURE_MIN_FILTER = int(Z'2801', c_int)
 +  integer(c_int), parameter :: GL_TEXTURE_MAG_FILTER = int(Z'2800', c_int)
 +  integer(c_int), parameter :: GL_TEXTURE_WRAP_S = int(Z'2802', c_int)
 +  integer(c_int), parameter :: GL_TEXTURE_WRAP_T = int(Z'2803', c_int)
 +  integer(c_int), parameter :: GL_LINEAR = int(Z'2601', c_int)
 +  integer(c_int), parameter :: GL_NEAREST = int(Z'2600', c_int)
 +  integer(c_int), parameter :: GL_CLAMP_TO_EDGE = int(Z'812F', c_int)
 +  integer(c_int), parameter :: GL_RED = int(Z'1903', c_int)
 +  integer(c_int), parameter :: GL_UNSIGNED_BYTE = int(Z'1401', c_int)
 +  integer(c_int), parameter :: GL_UNPACK_ALIGNMENT = int(Z'0CF5', c_int)
++
 +  ! Shader constants
 +  integer(c_int), parameter :: GL_VERTEX_SHADER = int(Z'8B31', c_int)
 +  integer(c_int), parameter :: GL_FRAGMENT_SHADER = int(Z'8B30', c_int)
++
 +  ! Buffer constants
 +  integer(c_int), parameter :: GL_ARRAY_BUFFER = int(Z'8892', c_int)
 +  integer(c_int), parameter :: GL_STATIC_DRAW = int(Z'88E4', c_int)
 +  integer(c_int), parameter :: GL_DYNAMIC_DRAW = int(Z'88E8', c_int)
 +  integer(c_int), parameter :: GL_STREAM_DRAW = int(Z'88E0', c_int)
++
 +  ! Drawing constants
 +  integer(c_int), parameter :: GL_TRIANGLES = int(Z'0004', c_int)
 +  integer(c_int), parameter :: GL_FLOAT = int(Z'1406', c_int)
 +  integer(c_int), parameter :: GL_FALSE = 0
 +  integer(c_int), parameter :: GL_TRUE = 1
++
 +  ! Blending constants
 +  integer(c_int), parameter :: GL_BLEND = int(Z'0BE2', c_int)
 +  integer(c_int), parameter :: GL_SRC_ALPHA = int(Z'0302', c_int)
 +  integer(c_int), parameter :: GL_ONE_MINUS_SRC_ALPHA = int(Z'0303', c_int)
    ! Interface to C wrapper functions (in gl_loader.c)
 -  ! These wrap the GLAD-loaded OpenGL functions
    interface
 -    ! void fortty_glViewport(int x, int y, int width, int height)
 +    ! ============ Basic functions ============
      subroutine glViewport(x, y, width, height) bind(C, name="fortty_glViewport")
        import :: c_int
        integer(c_int), value :: x, y, width, height
      end subroutine glViewport
 -    ! void fortty_glClear(unsigned int mask)
      subroutine glClear(mask) bind(C, name="fortty_glClear")
        import :: c_int
        integer(c_int), value :: mask
      end subroutine glClear
 -    ! void fortty_glClearColor(float red, float green, float blue, float alpha)
      subroutine glClearColor(red, green, blue, alpha) bind(C, name="fortty_glClearColor")
        import :: c_float
        real(c_float), value :: red, green, blue, alpha
      end subroutine glClearColor
++
 +    ! ============ Texture functions ============
 +    subroutine glGenTextures(n, textures) bind(C, name="fortty_glGenTextures")
 +      import :: c_int
 +      integer(c_int), value :: n
 +      integer(c_int), intent(out) :: textures(*)
 +    end subroutine glGenTextures
++
 +    subroutine glDeleteTextures(n, textures) bind(C, name="fortty_glDeleteTextures")
 +      import :: c_int
 +      integer(c_int), value :: n
 +      integer(c_int), intent(in) :: textures(*)
 +    end subroutine glDeleteTextures
++
 +    subroutine glBindTexture(target, texture) bind(C, name="fortty_glBindTexture")
 +      import :: c_int
 +      integer(c_int), value :: target, texture
 +    end subroutine glBindTexture
++
 +    subroutine glTexImage2D(target, level, internalformat, width, height, &
 +                            border, format, textype, data) bind(C, name="fortty_glTexImage2D")
 +      import :: c_int, c_ptr
 +      integer(c_int), value :: target, level, internalformat
 +      integer(c_int), value :: width, height, border
 +      integer(c_int), value :: format, textype
 +      type(c_ptr), value :: data
 +    end subroutine glTexImage2D
++
 +    subroutine glTexSubImage2D(target, level, xoffset, yoffset, width, height, &
 +                               format, textype, data) bind(C, name="fortty_glTexSubImage2D")
 +      import :: c_int, c_ptr
 +      integer(c_int), value :: target, level, xoffset, yoffset
 +      integer(c_int), value :: width, height, format, textype
 +      type(c_ptr), value :: data
 +    end subroutine glTexSubImage2D
++
 +    subroutine glTexParameteri(target, pname, param) bind(C, name="fortty_glTexParameteri")
 +      import :: c_int
 +      integer(c_int), value :: target, pname, param
 +    end subroutine glTexParameteri
++
 +    subroutine glPixelStorei(pname, param) bind(C, name="fortty_glPixelStorei")
 +      import :: c_int
 +      integer(c_int), value :: pname, param
 +    end subroutine glPixelStorei
++
 +    subroutine glActiveTexture(texture) bind(C, name="fortty_glActiveTexture")
 +      import :: c_int
 +      integer(c_int), value :: texture
 +    end subroutine glActiveTexture
++
 +    ! ============ Shader functions ============
 +    integer(c_int) function glCreateShader(shadertype) bind(C, name="fortty_glCreateShader")
 +      import :: c_int
 +      integer(c_int), value :: shadertype
 +    end function glCreateShader
++
 +    subroutine glDeleteShader(shader) bind(C, name="fortty_glDeleteShader")
 +      import :: c_int
 +      integer(c_int), value :: shader
 +    end subroutine glDeleteShader
++
 +    subroutine glShaderSource(shader, source) bind(C, name="fortty_glShaderSource")
 +      import :: c_int, c_char
 +      integer(c_int), value :: shader
 +      character(kind=c_char), intent(in) :: source(*)
 +    end subroutine glShaderSource
++
 +    subroutine glCompileShader(shader) bind(C, name="fortty_glCompileShader")
 +      import :: c_int
 +      integer(c_int), value :: shader
 +    end subroutine glCompileShader
++
 +    integer(c_int) function glGetShaderCompileStatus(shader) &
 +        bind(C, name="fortty_glGetShaderCompileStatus")
 +      import :: c_int
 +      integer(c_int), value :: shader
 +    end function glGetShaderCompileStatus
++
 +    subroutine glGetShaderInfoLog(shader, log, maxlen) bind(C, name="fortty_glGetShaderInfoLog")
 +      import :: c_int, c_char
 +      integer(c_int), value :: shader, maxlen
 +      character(kind=c_char), intent(out) :: log(*)
 +    end subroutine glGetShaderInfoLog
++
 +    integer(c_int) function glCreateProgram() bind(C, name="fortty_glCreateProgram")
 +      import :: c_int
 +    end function glCreateProgram
++
 +    subroutine glDeleteProgram(program) bind(C, name="fortty_glDeleteProgram")
 +      import :: c_int
 +      integer(c_int), value :: program
 +    end subroutine glDeleteProgram
++
 +    subroutine glAttachShader(program, shader) bind(C, name="fortty_glAttachShader")
 +      import :: c_int
 +      integer(c_int), value :: program, shader
 +    end subroutine glAttachShader
++
 +    subroutine glLinkProgram(program) bind(C, name="fortty_glLinkProgram")
 +      import :: c_int
 +      integer(c_int), value :: program
 +    end subroutine glLinkProgram
++
 +    integer(c_int) function glGetProgramLinkStatus(program) &
 +        bind(C, name="fortty_glGetProgramLinkStatus")
 +      import :: c_int
 +      integer(c_int), value :: program
 +    end function glGetProgramLinkStatus
++
 +    subroutine glGetProgramInfoLog(program, log, maxlen) bind(C, name="fortty_glGetProgramInfoLog")
 +      import :: c_int, c_char
 +      integer(c_int), value :: program, maxlen
 +      character(kind=c_char), intent(out) :: log(*)
 +    end subroutine glGetProgramInfoLog
++
 +    subroutine glUseProgram(program) bind(C, name="fortty_glUseProgram")
 +      import :: c_int
 +      integer(c_int), value :: program
 +    end subroutine glUseProgram
++
 +    integer(c_int) function glGetUniformLocation(program, name) &
 +        bind(C, name="fortty_glGetUniformLocation")
 +      import :: c_int, c_char
 +      integer(c_int), value :: program
 +      character(kind=c_char), intent(in) :: name(*)
 +    end function glGetUniformLocation
++
 +    subroutine glUniform1i(location, value) bind(C, name="fortty_glUniform1i")
 +      import :: c_int
 +      integer(c_int), value :: location, value
 +    end subroutine glUniform1i
++
 +    subroutine glUniform1f(location, value) bind(C, name="fortty_glUniform1f")
 +      import :: c_int, c_float
 +      integer(c_int), value :: location
 +      real(c_float), value :: value
 +    end subroutine glUniform1f
++
 +    subroutine glUniform3f(location, v0, v1, v2) bind(C, name="fortty_glUniform3f")
 +      import :: c_int, c_float
 +      integer(c_int), value :: location
 +      real(c_float), value :: v0, v1, v2
 +    end subroutine glUniform3f
++
 +    subroutine glUniform4f(location, v0, v1, v2, v3) bind(C, name="fortty_glUniform4f")
 +      import :: c_int, c_float
 +      integer(c_int), value :: location
 +      real(c_float), value :: v0, v1, v2, v3
 +    end subroutine glUniform4f
++
 +    subroutine glUniformMatrix4fv(location, count, transpose, value) &
 +        bind(C, name="fortty_glUniformMatrix4fv")
 +      import :: c_int, c_float
 +      integer(c_int), value :: location, count, transpose
 +      real(c_float), intent(in) :: value(*)
 +    end subroutine glUniformMatrix4fv
++
 +    ! ============ VAO/VBO functions ============
 +    subroutine glGenVertexArrays(n, arrays) bind(C, name="fortty_glGenVertexArrays")
 +      import :: c_int
 +      integer(c_int), value :: n
 +      integer(c_int), intent(out) :: arrays(*)
 +    end subroutine glGenVertexArrays
++
 +    subroutine glDeleteVertexArrays(n, arrays) bind(C, name="fortty_glDeleteVertexArrays")
 +      import :: c_int
 +      integer(c_int), value :: n
 +      integer(c_int), intent(in) :: arrays(*)
 +    end subroutine glDeleteVertexArrays
++
 +    subroutine glBindVertexArray(array) bind(C, name="fortty_glBindVertexArray")
 +      import :: c_int
 +      integer(c_int), value :: array
 +    end subroutine glBindVertexArray
++
 +    subroutine glGenBuffers(n, buffers) bind(C, name="fortty_glGenBuffers")
 +      import :: c_int
 +      integer(c_int), value :: n
 +      integer(c_int), intent(out) :: buffers(*)
 +    end subroutine glGenBuffers
++
 +    subroutine glDeleteBuffers(n, buffers) bind(C, name="fortty_glDeleteBuffers")
 +      import :: c_int
 +      integer(c_int), value :: n
 +      integer(c_int), intent(in) :: buffers(*)
 +    end subroutine glDeleteBuffers
++
 +    subroutine glBindBuffer(target, buffer) bind(C, name="fortty_glBindBuffer")
 +      import :: c_int
 +      integer(c_int), value :: target, buffer
 +    end subroutine glBindBuffer
++
 +    subroutine glBufferData(target, datasize, data, usage) bind(C, name="fortty_glBufferData")
 +      import :: c_int, c_size_t, c_ptr
 +      integer(c_int), value :: target
 +      integer(c_size_t), value :: datasize
 +      type(c_ptr), value :: data
 +      integer(c_int), value :: usage
 +    end subroutine glBufferData
++
 +    subroutine glBufferSubData(target, offset, datasize, data) bind(C, name="fortty_glBufferSubData")
 +      import :: c_int, c_size_t, c_ptr
 +      integer(c_int), value :: target
 +      integer(c_size_t), value :: offset, datasize
 +      type(c_ptr), value :: data
 +    end subroutine glBufferSubData
++
 +    subroutine glBufferSubData_floats(target, offset, datasize, data) &
 +        bind(C, name="fortty_glBufferSubData_floats")
 +      import :: c_int, c_size_t, c_float
 +      integer(c_int), value :: target
 +      integer(c_size_t), value :: offset, datasize
 +      real(c_float), intent(in) :: data(*)
 +    end subroutine glBufferSubData_floats
++
 +    subroutine glVertexAttribPointer(index, vsize, vtype, normalized, stride, offset) &
 +        bind(C, name="fortty_glVertexAttribPointer")
 +      import :: c_int, c_size_t
 +      integer(c_int), value :: index, vsize, vtype, normalized, stride
 +      integer(c_size_t), value :: offset
 +    end subroutine glVertexAttribPointer
++
 +    subroutine glEnableVertexAttribArray(index) bind(C, name="fortty_glEnableVertexAttribArray")
 +      import :: c_int
 +      integer(c_int), value :: index
 +    end subroutine glEnableVertexAttribArray
++
 +    subroutine glDisableVertexAttribArray(index) bind(C, name="fortty_glDisableVertexAttribArray")
 +      import :: c_int
 +      integer(c_int), value :: index
 +    end subroutine glDisableVertexAttribArray
++
 +    ! ============ Drawing functions ============
 +    subroutine glDrawArrays(mode, first, count) bind(C, name="fortty_glDrawArrays")
 +      import :: c_int
 +      integer(c_int), value :: mode, first, count
 +    end subroutine glDrawArrays
++
 +    ! ============ State functions ============
 +    subroutine glEnable(cap) bind(C, name="fortty_glEnable")
 +      import :: c_int
 +      integer(c_int), value :: cap
 +    end subroutine glEnable
++
 +    subroutine glDisable(cap) bind(C, name="fortty_glDisable")
 +      import :: c_int
 +      integer(c_int), value :: cap
 +    end subroutine glDisable
++
 +    subroutine glBlendFunc(sfactor, dfactor) bind(C, name="fortty_glBlendFunc")
 +      import :: c_int
 +      integer(c_int), value :: sfactor, dfactor
 +    end subroutine glBlendFunc
    end interface
  end module gl_bindings

src/gl/shader.f90added

 +module shader_mod
 +  use, intrinsic :: iso_c_binding
 +  use gl_bindings
 +  implicit none
 +  private
++
 +  public :: shader_t
 +  public :: shader_create, shader_destroy, shader_use
 +  public :: shader_set_projection, shader_set_int
++
 +  type :: shader_t
 +    integer :: program_id = 0
 +    integer :: projection_loc = -1
 +    integer :: atlas_loc = -1
 +    logical :: valid = .false.
 +  end type shader_t
++
 +contains
++
 +  ! Create a shader program from vertex and fragment source
 +  function shader_create(vert_source, frag_source) result(shader)
 +    character(len=*), intent(in) :: vert_source, frag_source
 +    type(shader_t) :: shader
 +    integer :: vert_id, frag_id
 +    integer :: success
 +    character(len=512) :: log_buffer
++
 +    ! Compile vertex shader
 +    vert_id = glCreateShader(GL_VERTEX_SHADER)
 +    call glShaderSource(vert_id, vert_source // c_null_char)
 +    call glCompileShader(vert_id)
++
 +    success = glGetShaderCompileStatus(vert_id)
 +    if (success == 0) then
 +      call glGetShaderInfoLog(vert_id, log_buffer, 512)
 +      print *, "Error: Vertex shader compilation failed:"
 +      print *, trim(log_buffer)
 +      call glDeleteShader(vert_id)
 +      return
 +    end if
++
 +    ! Compile fragment shader
 +    frag_id = glCreateShader(GL_FRAGMENT_SHADER)
 +    call glShaderSource(frag_id, frag_source // c_null_char)
 +    call glCompileShader(frag_id)
++
 +    success = glGetShaderCompileStatus(frag_id)
 +    if (success == 0) then
 +      call glGetShaderInfoLog(frag_id, log_buffer, 512)
 +      print *, "Error: Fragment shader compilation failed:"
 +      print *, trim(log_buffer)
 +      call glDeleteShader(vert_id)
 +      call glDeleteShader(frag_id)
 +      return
 +    end if
++
 +    ! Link program
 +    shader%program_id = glCreateProgram()
 +    call glAttachShader(shader%program_id, vert_id)
 +    call glAttachShader(shader%program_id, frag_id)
 +    call glLinkProgram(shader%program_id)
++
 +    success = glGetProgramLinkStatus(shader%program_id)
 +    if (success == 0) then
 +      call glGetProgramInfoLog(shader%program_id, log_buffer, 512)
 +      print *, "Error: Shader program linking failed:"
 +      print *, trim(log_buffer)
 +      call glDeleteShader(vert_id)
 +      call glDeleteShader(frag_id)
 +      call glDeleteProgram(shader%program_id)
 +      shader%program_id = 0
 +      return
 +    end if
++
 +    ! Clean up shaders (they're linked into the program now)
 +    call glDeleteShader(vert_id)
 +    call glDeleteShader(frag_id)
++
 +    ! Get uniform locations
 +    shader%projection_loc = glGetUniformLocation(shader%program_id, &
 +                                                  "u_projection" // c_null_char)
 +    shader%atlas_loc = glGetUniformLocation(shader%program_id, &
 +                                             "u_atlas" // c_null_char)
++
 +    shader%valid = .true.
++
 +  end function shader_create
++
 +  ! Use this shader program
 +  subroutine shader_use(shader)
 +    type(shader_t), intent(in) :: shader
 +    if (shader%valid) then
 +      call glUseProgram(shader%program_id)
 +    end if
 +  end subroutine shader_use
++
 +  ! Set the projection matrix uniform
 +  subroutine shader_set_projection(shader, matrix)
 +    type(shader_t), intent(in) :: shader
 +    real(c_float), intent(in) :: matrix(4,4)
++
 +    if (shader%valid .and. shader%projection_loc >= 0) then
 +      call glUniformMatrix4fv(shader%projection_loc, 1, GL_FALSE, matrix)
 +    end if
 +  end subroutine shader_set_projection
++
 +  ! Set an integer uniform
 +  subroutine shader_set_int(shader, name, value)
 +    type(shader_t), intent(in) :: shader
 +    character(len=*), intent(in) :: name
 +    integer, intent(in) :: value
 +    integer :: loc
++
 +    if (shader%valid) then
 +      loc = glGetUniformLocation(shader%program_id, name // c_null_char)
 +      if (loc >= 0) then
 +        call glUniform1i(loc, value)
 +      end if
 +    end if
 +  end subroutine shader_set_int
++
 +  ! Destroy shader program
 +  subroutine shader_destroy(shader)
 +    type(shader_t), intent(inout) :: shader
++
 +    if (shader%program_id > 0) then
 +      call glDeleteProgram(shader%program_id)
 +      shader%program_id = 0
 +    end if
 +    shader%valid = .false.
 +  end subroutine shader_destroy
++
 +end module shader_mod

src/text/atlas.f90added

 +module atlas_mod
 +  use, intrinsic :: iso_c_binding
 +  use glyph_mod
 +  use font_mod
 +  use gl_bindings
 +  implicit none
 +  private
++
 +  public :: atlas_t
 +  public :: atlas_create, atlas_destroy, atlas_get_glyph
++
 +  integer, parameter :: ATLAS_SIZE = 512
 +  integer, parameter :: ASCII_START = 32
 +  integer, parameter :: ASCII_END = 126
++
 +  type :: atlas_t
 +    integer :: texture_id = 0
 +    integer :: width = ATLAS_SIZE
 +    integer :: height = ATLAS_SIZE
 +    integer :: cursor_x = 0
 +    integer :: cursor_y = 0
 +    integer :: row_height = 0
 +    type(glyph_t) :: glyphs(0:127)
 +    logical :: initialized = .false.
 +  end type atlas_t
++
 +contains
++
 +  ! Create a texture atlas from a font, pre-rendering ASCII characters
 +  function atlas_create(font) result(atlas)
 +    type(font_t), intent(inout) :: font
 +    type(atlas_t) :: atlas
 +    integer :: tex(1)
 +    integer :: cp
 +    type(glyph_t) :: g
 +    type(c_ptr) :: bitmap_ptr
++
 +    if (.not. font%loaded) then
 +      print *, "Error: Cannot create atlas from unloaded font"
 +      return
 +    end if
++
 +    ! Create OpenGL texture
 +    call glGenTextures(1, tex)
 +    atlas%texture_id = tex(1)
 +    call glBindTexture(GL_TEXTURE_2D, atlas%texture_id)
++
 +    ! Set texture parameters
 +    call glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
 +    call glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
 +    call glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
 +    call glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
++
 +    ! Disable byte-alignment restriction for grayscale textures
 +    call glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
++
 +    ! Allocate empty texture
 +    call glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, &
 +                      atlas%width, atlas%height, 0, &
 +                      GL_RED, GL_UNSIGNED_BYTE, c_null_ptr)
++
 +    ! Initialize glyph array
 +    do cp = 0, 127
 +      call glyph_init(atlas%glyphs(cp))
 +    end do
++
 +    ! Pre-render ASCII printable characters (32-126)
 +    atlas%cursor_x = 1
 +    atlas%cursor_y = 1
 +    atlas%row_height = 0
++
 +    do cp = ASCII_START, ASCII_END
 +      g = font_render_glyph(font, cp, bitmap_ptr)
 +      if (g%valid) then
 +        call atlas_add_glyph(atlas, g, bitmap_ptr)
 +        atlas%glyphs(cp) = g
 +      end if
 +    end do
++
 +    ! Unbind texture
 +    call glBindTexture(GL_TEXTURE_2D, 0)
++
 +    atlas%initialized = .true.
++
 +  end function atlas_create
++
 +  ! Add a rendered glyph to the atlas
 +  subroutine atlas_add_glyph(atlas, g, bitmap_ptr)
 +    type(atlas_t), intent(inout) :: atlas
 +    type(glyph_t), intent(inout) :: g
 +    type(c_ptr), intent(in) :: bitmap_ptr
 +    integer :: padding
++
 +    padding = 1  ! 1 pixel padding between glyphs
++
 +    ! Check if glyph fits in current row
 +    if (atlas%cursor_x + g%width + padding > atlas%width) then
 +      ! Move to next row
 +      atlas%cursor_x = 1
 +      atlas%cursor_y = atlas%cursor_y + atlas%row_height + padding
 +      atlas%row_height = 0
 +    end if
++
 +    ! Check if glyph fits vertically
 +    if (atlas%cursor_y + g%height + padding > atlas%height) then
 +      print *, "Warning: Atlas texture is full, cannot add glyph"
 +      return
 +    end if
++
 +    ! Store position in atlas
 +    g%tex_x = atlas%cursor_x
 +    g%tex_y = atlas%cursor_y
++
 +    ! Copy bitmap to texture
 +    if (g%width > 0 .and. g%height > 0 .and. c_associated(bitmap_ptr)) then
 +      call glTexSubImage2D(GL_TEXTURE_2D, 0, &
 +                           g%tex_x, g%tex_y, g%width, g%height, &
 +                           GL_RED, GL_UNSIGNED_BYTE, bitmap_ptr)
 +    end if
++
 +    ! Calculate UV coordinates (normalized 0-1)
 +    g%u0 = real(g%tex_x, c_float) / real(atlas%width, c_float)
 +    g%v0 = real(g%tex_y, c_float) / real(atlas%height, c_float)
 +    g%u1 = real(g%tex_x + g%width, c_float) / real(atlas%width, c_float)
 +    g%v1 = real(g%tex_y + g%height, c_float) / real(atlas%height, c_float)
++
 +    ! Update cursor position
 +    atlas%cursor_x = atlas%cursor_x + g%width + padding
 +    atlas%row_height = max(atlas%row_height, g%height)
++
 +  end subroutine atlas_add_glyph
++
 +  ! Get glyph information for a codepoint
 +  function atlas_get_glyph(atlas, codepoint) result(g)
 +    type(atlas_t), intent(in) :: atlas
 +    integer, intent(in) :: codepoint
 +    type(glyph_t) :: g
++
 +    if (codepoint >= 0 .and. codepoint <= 127) then
 +      g = atlas%glyphs(codepoint)
 +    else
 +      ! Return invalid glyph for unsupported characters
 +      call glyph_init(g)
 +    end if
 +  end function atlas_get_glyph
++
 +  ! Destroy atlas and free texture
 +  subroutine atlas_destroy(atlas)
 +    type(atlas_t), intent(inout) :: atlas
 +    integer :: tex(1)
++
 +    if (atlas%texture_id > 0) then
 +      tex(1) = atlas%texture_id
 +      call glDeleteTextures(1, tex)
 +      atlas%texture_id = 0
 +    end if
++
 +    atlas%initialized = .false.
 +  end subroutine atlas_destroy
++
 +end module atlas_mod

src/text/renderer.f90added

 +module renderer_mod
 +  use, intrinsic :: iso_c_binding
 +  use gl_bindings
 +  use glyph_mod
 +  use font_mod
 +  use atlas_mod
 +  use shader_mod
 +  implicit none
 +  private
++
 +  public :: renderer_t
 +  public :: renderer_create, renderer_destroy
 +  public :: renderer_begin, renderer_draw_char, renderer_draw_string, renderer_flush
 +  public :: renderer_set_projection
++
 +  ! Vertex format: position(2) + texcoord(2) + color(4) = 8 floats per vertex
 +  integer, parameter :: FLOATS_PER_VERTEX = 8
 +  integer, parameter :: VERTICES_PER_QUAD = 6
 +  integer, parameter :: FLOATS_PER_QUAD = FLOATS_PER_VERTEX * VERTICES_PER_QUAD
 +  integer, parameter :: MAX_QUADS = 4096
 +  integer, parameter :: MAX_VERTICES = MAX_QUADS * VERTICES_PER_QUAD
 +  integer, parameter :: BUFFER_SIZE = MAX_VERTICES * FLOATS_PER_VERTEX
++
 +  type :: renderer_t
 +    integer :: vao = 0
 +    integer :: vbo = 0
 +    real(c_float), allocatable :: vertices(:)
 +    integer :: vertex_count = 0
 +    type(shader_t) :: shader
 +    type(atlas_t) :: atlas
 +    type(font_t) :: font
 +    real(c_float) :: projection(4,4)
 +    logical :: initialized = .false.
 +  end type renderer_t
++
 +  ! Embedded shader sources
 +  character(len=*), parameter :: VERT_SHADER = &
 +    "#version 330 core" // c_new_line // &
 +    "layout(location = 0) in vec2 a_position;" // c_new_line // &
 +    "layout(location = 1) in vec2 a_texcoord;" // c_new_line // &
 +    "layout(location = 2) in vec4 a_color;" // c_new_line // &
 +    "uniform mat4 u_projection;" // c_new_line // &
 +    "out vec2 v_texcoord;" // c_new_line // &
 +    "out vec4 v_color;" // c_new_line // &
 +    "void main() {" // c_new_line // &
 +    "    gl_Position = u_projection * vec4(a_position, 0.0, 1.0);" // c_new_line // &
 +    "    v_texcoord = a_texcoord;" // c_new_line // &
 +    "    v_color = a_color;" // c_new_line // &
 +    "}"
++
 +  character(len=*), parameter :: FRAG_SHADER = &
 +    "#version 330 core" // c_new_line // &
 +    "in vec2 v_texcoord;" // c_new_line // &
 +    "in vec4 v_color;" // c_new_line // &
 +    "uniform sampler2D u_atlas;" // c_new_line // &
 +    "out vec4 frag_color;" // c_new_line // &
 +    "void main() {" // c_new_line // &
 +    "    float alpha = texture(u_atlas, v_texcoord).r;" // c_new_line // &
 +    "    frag_color = vec4(v_color.rgb, v_color.a * alpha);" // c_new_line // &
 +    "}"
++
 +contains
++
 +  ! Create renderer with font
 +  function renderer_create(font_path, font_size) result(r)
 +    character(len=*), intent(in) :: font_path
 +    integer, intent(in) :: font_size
 +    type(renderer_t) :: r
 +    integer :: vao(1), vbo(1)
 +    integer(c_size_t) :: stride, offset
++
 +    ! Load font
 +    r%font = font_load(font_path, font_size)
 +    if (.not. r%font%loaded) then
 +      print *, "Error: Failed to load font"
 +      return
 +    end if
++
 +    ! Create atlas from font
 +    r%atlas = atlas_create(r%font)
 +    if (.not. r%atlas%initialized) then
 +      print *, "Error: Failed to create atlas"
 +      call font_destroy(r%font)
 +      return
 +    end if
++
 +    ! Create shader
 +    r%shader = shader_create(VERT_SHADER, FRAG_SHADER)
 +    if (.not. r%shader%valid) then
 +      print *, "Error: Failed to create shader"
 +      call atlas_destroy(r%atlas)
 +      call font_destroy(r%font)
 +      return
 +    end if
++
 +    ! Create VAO and VBO
 +    call glGenVertexArrays(1, vao)
 +    call glGenBuffers(1, vbo)
 +    r%vao = vao(1)
 +    r%vbo = vbo(1)
++
 +    call glBindVertexArray(r%vao)
 +    call glBindBuffer(GL_ARRAY_BUFFER, r%vbo)
++
 +    ! Allocate buffer (empty for now)
 +    call glBufferData(GL_ARRAY_BUFFER, &
 +                      int(BUFFER_SIZE * c_sizeof(1.0_c_float), c_size_t), &
 +                      c_null_ptr, GL_DYNAMIC_DRAW)
++
 +    ! Set up vertex attributes
 +    stride = int(FLOATS_PER_VERTEX * c_sizeof(1.0_c_float), c_size_t)
++
 +    ! Position: location 0, 2 floats, offset 0
 +    offset = 0_c_size_t
 +    call glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, int(stride, c_int), offset)
 +    call glEnableVertexAttribArray(0)
++
 +    ! Texcoord: location 1, 2 floats, offset 8 bytes
 +    offset = int(2 * c_sizeof(1.0_c_float), c_size_t)
 +    call glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, int(stride, c_int), offset)
 +    call glEnableVertexAttribArray(1)
++
 +    ! Color: location 2, 4 floats, offset 16 bytes
 +    offset = int(4 * c_sizeof(1.0_c_float), c_size_t)
 +    call glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, int(stride, c_int), offset)
 +    call glEnableVertexAttribArray(2)
++
 +    call glBindVertexArray(0)
++
 +    ! Allocate vertex buffer
 +    allocate(r%vertices(BUFFER_SIZE))
 +    r%vertices = 0.0_c_float
 +    r%vertex_count = 0
++
 +    ! Initialize projection to identity
 +    r%projection = 0.0_c_float
 +    r%projection(1,1) = 1.0_c_float
 +    r%projection(2,2) = 1.0_c_float
 +    r%projection(3,3) = 1.0_c_float
 +    r%projection(4,4) = 1.0_c_float
++
 +    r%initialized = .true.
++
 +  end function renderer_create
++
 +  ! Destroy renderer
 +  subroutine renderer_destroy(r)
 +    type(renderer_t), intent(inout) :: r
 +    integer :: arr(1)
++
 +    if (r%vbo > 0) then
 +      arr(1) = r%vbo
 +      call glDeleteBuffers(1, arr)
 +      r%vbo = 0
 +    end if
++
 +    if (r%vao > 0) then
 +      arr(1) = r%vao
 +      call glDeleteVertexArrays(1, arr)
 +      r%vao = 0
 +    end if
++
 +    call shader_destroy(r%shader)
 +    call atlas_destroy(r%atlas)
 +    call font_destroy(r%font)
++
 +    if (allocated(r%vertices)) deallocate(r%vertices)
 +    r%initialized = .false.
 +  end subroutine renderer_destroy
++
 +  ! Begin a new frame (reset vertex buffer)
 +  subroutine renderer_begin(r)
 +    type(renderer_t), intent(inout) :: r
 +    r%vertex_count = 0
 +  end subroutine renderer_begin
++
 +  ! Set orthographic projection matrix
 +  subroutine renderer_set_projection(r, width, height)
 +    type(renderer_t), intent(inout) :: r
 +    integer, intent(in) :: width, height
++
 +    ! Orthographic projection: (0,0) top-left, (width, height) bottom-right
 +    r%projection = 0.0_c_float
 +    r%projection(1,1) = 2.0_c_float / real(width, c_float)
 +    r%projection(2,2) = -2.0_c_float / real(height, c_float)  ! Flip Y
 +    r%projection(3,3) = -1.0_c_float
 +    r%projection(4,4) = 1.0_c_float
 +    r%projection(1,4) = -1.0_c_float
 +    r%projection(2,4) = 1.0_c_float
 +  end subroutine renderer_set_projection
++
 +  ! Draw a single character at position (x, y)
 +  subroutine renderer_draw_char(r, x, y, codepoint, red, green, blue, alpha)
 +    type(renderer_t), intent(inout) :: r
 +    real, intent(in) :: x, y
 +    integer, intent(in) :: codepoint
 +    real, intent(in) :: red, green, blue, alpha
 +    type(glyph_t) :: g
 +    real(c_float) :: x0, y0, x1, y1
 +    real(c_float) :: u0, v0, u1, v1
 +    integer :: base
++
 +    if (.not. r%initialized) return
++
 +    g = atlas_get_glyph(r%atlas, codepoint)
 +    if (.not. g%valid) return
++
 +    ! Check if buffer is full
 +    if (r%vertex_count + VERTICES_PER_QUAD > MAX_VERTICES) then
 +      call renderer_flush(r)
 +    end if
++
 +    ! Calculate quad positions
 +    ! x, y is the cursor position (baseline)
 +    x0 = real(x, c_float) + real(g%bearing_x, c_float)
 +    y0 = real(y, c_float) - real(g%bearing_y, c_float)
 +    x1 = x0 + real(g%width, c_float)
 +    y1 = y0 + real(g%height, c_float)
++
 +    u0 = g%u0
 +    v0 = g%v0
 +    u1 = g%u1
 +    v1 = g%v1
++
 +    ! Add 6 vertices (2 triangles) for the quad
 +    base = r%vertex_count * FLOATS_PER_VERTEX + 1
++
 +    ! Triangle 1: top-left, bottom-left, bottom-right
 +    ! Vertex 1: top-left
 +    r%vertices(base:base+7) = [x0, y0, u0, v0, &
 +                               real(red,c_float), real(green,c_float), &
 +                               real(blue,c_float), real(alpha,c_float)]
 +    base = base + 8
++
 +    ! Vertex 2: bottom-left
 +    r%vertices(base:base+7) = [x0, y1, u0, v1, &
 +                               real(red,c_float), real(green,c_float), &
 +                               real(blue,c_float), real(alpha,c_float)]
 +    base = base + 8
++
 +    ! Vertex 3: bottom-right
 +    r%vertices(base:base+7) = [x1, y1, u1, v1, &
 +                               real(red,c_float), real(green,c_float), &
 +                               real(blue,c_float), real(alpha,c_float)]
 +    base = base + 8
++
 +    ! Triangle 2: top-left, bottom-right, top-right
 +    ! Vertex 4: top-left
 +    r%vertices(base:base+7) = [x0, y0, u0, v0, &
 +                               real(red,c_float), real(green,c_float), &
 +                               real(blue,c_float), real(alpha,c_float)]
 +    base = base + 8
++
 +    ! Vertex 5: bottom-right
 +    r%vertices(base:base+7) = [x1, y1, u1, v1, &
 +                               real(red,c_float), real(green,c_float), &
 +                               real(blue,c_float), real(alpha,c_float)]
 +    base = base + 8
++
 +    ! Vertex 6: top-right
 +    r%vertices(base:base+7) = [x1, y0, u1, v0, &
 +                               real(red,c_float), real(green,c_float), &
 +                               real(blue,c_float), real(alpha,c_float)]
++
 +    r%vertex_count = r%vertex_count + VERTICES_PER_QUAD
++
 +  end subroutine renderer_draw_char
++
 +  ! Draw a string at position (x, y)
 +  subroutine renderer_draw_string(r, x, y, text, red, green, blue, alpha)
 +    type(renderer_t), intent(inout) :: r
 +    real, intent(in) :: x, y
 +    character(len=*), intent(in) :: text
 +    real, intent(in) :: red, green, blue, alpha
 +    integer :: i, cp
 +    real :: cursor_x
 +    type(glyph_t) :: g
++
 +    cursor_x = x
 +    do i = 1, len_trim(text)
 +      cp = ichar(text(i:i))
 +      call renderer_draw_char(r, cursor_x, y, cp, red, green, blue, alpha)
++
 +      ! Advance cursor
 +      g = atlas_get_glyph(r%atlas, cp)
 +      if (g%valid) then
 +        cursor_x = cursor_x + real(g%advance)
 +      end if
 +    end do
 +  end subroutine renderer_draw_string
++
 +  ! Flush the vertex buffer to GPU and draw
 +  subroutine renderer_flush(r)
 +    type(renderer_t), intent(inout) :: r
 +    integer(c_size_t) :: data_size
++
 +    if (r%vertex_count == 0) return
++
 +    ! Enable blending for text
 +    call glEnable(GL_BLEND)
 +    call glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
++
 +    ! Bind shader and set uniforms
 +    call shader_use(r%shader)
 +    call shader_set_projection(r%shader, r%projection)
++
 +    ! Bind texture
 +    call glActiveTexture(GL_TEXTURE0)
 +    call glBindTexture(GL_TEXTURE_2D, r%atlas%texture_id)
 +    call glUniform1i(r%shader%atlas_loc, 0)
++
 +    ! Upload vertex data
 +    call glBindVertexArray(r%vao)
 +    call glBindBuffer(GL_ARRAY_BUFFER, r%vbo)
++
 +    data_size = int(r%vertex_count * FLOATS_PER_VERTEX * c_sizeof(1.0_c_float), c_size_t)
 +    call glBufferSubData_floats(GL_ARRAY_BUFFER, 0_c_size_t, data_size, r%vertices)
++
 +    ! Draw
 +    call glDrawArrays(GL_TRIANGLES, 0, r%vertex_count)
++
 +    ! Unbind
 +    call glBindVertexArray(0)
 +    call glBindTexture(GL_TEXTURE_2D, 0)
++
 +    ! Reset vertex count
 +    r%vertex_count = 0
++
 +  end subroutine renderer_flush
++
 +end module renderer_mod