`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
++  ! Texture constants
--  integer, parameter :: GLint = c_int
++  integer(c_int), parameter :: GL_TEXTURE_2D = int(Z'0DE1', c_int)
--  integer, parameter :: GLsizei = c_int
++  integer(c_int), parameter :: GL_TEXTURE0 = int(Z'84C0', c_int)
--  integer, parameter :: GLfloat = c_float
++  integer(c_int), parameter :: GL_TEXTURE_MIN_FILTER = int(Z'2801', c_int)
--  integer, parameter :: GLbitfield = 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