Render optimizations / refactor

Sources/GLFWRenderer/GLFWRenderer.swift

@@ -9,6 +9,8 @@ public struct GLFWRenderer: ~Copyable, RendererProtocol, @unchecked Sendable {
     private var rectRenderer:RectRenderer! = nil
     private var textRenderer:TextRenderer? = nil
 
+    private var window:OpaquePointer! = nil
+
     public init() {
         check(glfwInit() == GLFW_TRUE)
 
@@ -21,13 +23,15 @@ public struct GLFWRenderer: ~Copyable, RendererProtocol, @unchecked Sendable {
     }
 }
 
-// MARK: Render
+// MARK: Load
 extension GLFWRenderer {
-    public mutating func render(
+    public mutating func load(
         fontAtlas: consuming FontAtlas,
-        windowSettings: borrowing WindowSettings
+        windowSettings: borrowing WindowSettings,
     ) {
-        let window = glfwCreateWindow(windowSettings.width, windowSettings.height, windowSettings.title, nil, nil)
+        //glfwWindowHint(GLFW_DOUBLEBUFFER, GLFW_FALSE)
+        //glfwSwapInterval(0)
+        window = glfwCreateWindow(windowSettings.width, windowSettings.height, windowSettings.title, nil, nil)
         if window == nil {
             fatalError("Failed to create GLFW window")
         }
@@ -44,11 +48,20 @@ extension GLFWRenderer {
             screenH: Float(windowSettings.height)
         )
 
+        let width = windowSettings.width
+        let height = windowSettings.height
+        CGLFW.glViewport(0, 0, width, height)
+        CGLFW.glClearColor(0.12, 0.12, 0.12, 1.0)
+        CGLFW.glClear(GLbitfield(GL_COLOR_BUFFER_BIT))
+        glfwSwapBuffers(window)
+    }
+}
+
+// MARK: Render
+extension GLFWRenderer {
+    public func render() {
         // Main loop
         while glfwWindowShouldClose(window) == 0 {
-            let width = windowSettings.width
-            let height = windowSettings.height
-            CGLFW.glViewport(0, 0, width, height)
             CGLFW.glClearColor(0.12, 0.12, 0.12, 1.0)
             CGLFW.glClear(GLbitfield(GL_COLOR_BUFFER_BIT))
 
@@ -68,6 +81,23 @@ extension GLFWRenderer {
         glfwDestroyWindow(window)
         glfwTerminate()
     }
+
+    public func newRender() {
+        /*var needsRedraw = true
+        glfwSetKeyCallback(window) { _, _, _, _, _ in
+            needsRedraw = true
+        }
+
+        glfwSetFramebufferSizeCallback(window) { _, _, _ in
+            needsRedraw = true
+        }
+        while glfwWindowShouldClose(window) == 0 {
+            glfwSwapBuffers(window)
+            glfwPollEvents()
+        }
+        glfwDestroyWindow(window)
+        glfwTerminate()*/
+    }
 }
 
 // MARK: Helpers
@@ -84,4 +114,25 @@ extension GLFWRenderer {
     public mutating func push(_ cmd: RenderCommand) {
         queue.append(cmd)
     }
+}
+
+// MARK: Extensions
+extension GLFWRenderer {
+    public func render(
+        _ cmd: RenderRectangle
+    ) {
+        rectRenderer.draw(cmd)
+    }
+
+    public func render<let count: Int>(
+        _ cmd: RenderInlineVertices<count>
+    ) {
+        rectRenderer.draw(cmd)
+    }
+
+    public func render(
+        _ cmd: RenderVertices
+    ) {
+        rectRenderer.draw(cmd)
+    }
 }

Sources/GLFWRenderer/RectRenderer.swift

@@ -59,19 +59,79 @@ extension RectRenderer {
         var screen = [screenW, screenH]
         glUniform2fv(locScreen, 1, &screen)
         let locColor = glGetUniformLocation(program, "uColor")
-        var col = [color.0, color.1, color.2, color.3]
-        glUniform4fv(locColor, 1, &col)
+        withUnsafePointer(to: color) {
+            glUniform4fv(locColor, 1, UnsafePointer<Float>(OpaquePointer($0)))
+        }
+        rect.vertices.span.withUnsafeBytes { buf in
+            glBindVertexArray(vao)
+            glBindBuffer(GL_ARRAY_BUFFER, vbo)
+            glBufferData(GL_ARRAY_BUFFER, buf.count, buf.baseAddress, GL_DYNAMIC_DRAW)
+            glVertexAttribPointer(0, 2, GL_FLOAT, false, 2 * GLsizei(MemoryLayout<Float>.size), nil)
+            glEnableVertexAttribArray(0)
+            glDrawArrays(GL_TRIANGLES, 0, 6)
+        }
+    }
+}
+
+extension RectRenderer {
+    public func draw(
+        _ rect: RenderRectangle
+    ) {
+        glUseProgram(program)
+        let locScreen = glGetUniformLocation(program, "uScreen")
+        var screen = [screenW, screenH]
+        glUniform2fv(locScreen, 1, &screen)
+        let locColor = glGetUniformLocation(program, "uColor")
+        withUnsafePointer(to: rect.color) {
+            glUniform4fv(locColor, 1, UnsafePointer<Float>(OpaquePointer($0)))
+        }
+        rect.frame.vertices.span.withUnsafeBytes { buf in
+            glBindVertexArray(vao)
+            glBindBuffer(GL_ARRAY_BUFFER, vbo)
+            glBufferData(GL_ARRAY_BUFFER, buf.count, buf.baseAddress, GL_DYNAMIC_DRAW)
+            glVertexAttribPointer(0, 2, GL_FLOAT, false, 2 * GLsizei(MemoryLayout<Float>.size), nil)
+            glEnableVertexAttribArray(0)
+            glDrawArrays(GL_TRIANGLES, 0, 6)
+        }
+    }
+}
+
+extension RectRenderer {
+    public func draw(
+        _ rect: RenderVertices
+    ) {
+        glUseProgram(program)
+        let locScreen = glGetUniformLocation(program, "uScreen")
+        var screen = [screenW, screenH]
+        glUniform2fv(locScreen, 1, &screen)
+        let locColor = glGetUniformLocation(program, "uColor")
+        withUnsafePointer(to: rect.color) {
+            glUniform4fv(locColor, 1, UnsafePointer<Float>(OpaquePointer($0)))
+        }
+        rect.vertices.withUnsafeBytes { buf in
+            glBindVertexArray(vao)
+            glBindBuffer(GL_ARRAY_BUFFER, vbo)
+            glBufferData(GL_ARRAY_BUFFER, buf.count, buf.baseAddress, GL_DYNAMIC_DRAW)
+            glVertexAttribPointer(0, 2, GL_FLOAT, false, 2 * GLsizei(MemoryLayout<Float>.size), nil)
+            glEnableVertexAttribArray(0)
+            glDrawArrays(GL_TRIANGLES, 0, 6)
+        }
+    }
+}
 
-        // create vertex data (two triangles)
-        let x0 = rect.x
-        let y0 = rect.y
-        let x1 = rect.x + rect.w
-        let y1 = rect.y + rect.h
-        let verts = [
-            x0, y1,  x1, y1,  x1, y0,
-            x1, y0,  x0, y0,  x0, y1
-        ]
-        verts.withUnsafeBytes { buf in
+extension RectRenderer {
+    public func draw<let count: Int>(
+        _ rect: RenderInlineVertices<count>
+    ) {
+        glUseProgram(program)
+        let locScreen = glGetUniformLocation(program, "uScreen")
+        var screen = [screenW, screenH]
+        glUniform2fv(locScreen, 1, &screen)
+        let locColor = glGetUniformLocation(program, "uColor")
+        withUnsafePointer(to: rect.color) {
+            glUniform4fv(locColor, 1, UnsafePointer<Float>(OpaquePointer($0)))
+        }
+        rect.vertices.span.withUnsafeBytes { buf in
             glBindVertexArray(vao)
             glBindBuffer(GL_ARRAY_BUFFER, vbo)
             glBufferData(GL_ARRAY_BUFFER, buf.count, buf.baseAddress, GL_DYNAMIC_DRAW)

Sources/GLFWRenderer/TextRenderer.swift

@@ -13,6 +13,9 @@ public struct TextRenderer: GLFWRendererProtocol, ~Copyable {
     public var screenW:Float
     public var screenH:Float
 
+    private var stride = GLsizei(MemoryLayout<Float>.size * 4)
+    private var uvOffset = UnsafeRawPointer(bitPattern: MemoryLayout<Float>.size * 2)
+
     public init(
         atlas: consuming FontAtlas,
         screenW: Float,
@@ -92,8 +95,9 @@ extension TextRenderer {
         var screen = [screenW, screenH]
         glUniform2fv(locScreen, 1, &screen)
         let locColor = glGetUniformLocation(program, "uColor")
-        var col = [color.0, color.1, color.2, color.3]
-        glUniform4fv(locColor, 1, &col)
+        withUnsafePointer(to: color) {
+            glUniform4fv(locColor, 1, UnsafePointer<Float>(OpaquePointer($0)))
+        }
         glActiveTexture(GL_TEXTURE0)
         glBindTexture(GL_TEXTURE_2D, texture)
         let uAtlasLoc = glGetUniformLocation(program, "uAtlas")
@@ -136,9 +140,8 @@ extension TextRenderer {
         verts.withUnsafeBytes { buf in
             glBufferData(GL_ARRAY_BUFFER, GLsizeiptr(buf.count), buf.baseAddress, GL_DYNAMIC_DRAW)
         }
-        let stride = GLsizei(MemoryLayout<Float>.size * 4)
+
         glVertexAttribPointer(0, 2, GL_FLOAT, false, stride, nil)
-        let uvOffset = UnsafeRawPointer(bitPattern: MemoryLayout<Float>.size * 2)
         glVertexAttribPointer(1, 2, GL_FLOAT, false, stride, uvOffset)
         glEnableVertexAttribArray(0)
         glEnableVertexAttribArray(1)

Sources/Run/main.swift

@@ -24,13 +24,21 @@ func load() {
         fatalError("failed to load font")
     }
 
-    let cmds = SettingsView.Static_1280x720.renderCommandsWithOffset(offsetX: 0, offsetY: 100)
     var renderer = GLFWRenderer()
-    for i in cmds.indices {
-        renderer.push(cmds[i])
-    }
-    renderer.render(
+    renderer.load(
         fontAtlas: fontAtlas,
         windowSettings: settings
     )
+    for i in SettingsView.Static_1280x720.renderCommands.indices {
+        renderer.push(SettingsView.Static_1280x720.renderCommands[i])
+    }
+    renderer.render()
+
+    /*let finalRenderer = renderer
+    Task.detached {
+        try await Task.sleep(for: .seconds(1))
+        SettingsView.Static_1280x720().render(renderer: finalRenderer)
+    }
+    finalRenderer.render()
+    */
 }

Sources/SDLRenderer/SDLRenderer.swift

@@ -7,17 +7,18 @@ public struct SDL2Renderer: RendererProtocol, @unchecked Sendable {
     private var commands:[RenderCommand] = []
     private var renderer:OpaquePointer? = nil
 
+    private var window:OpaquePointer! = nil
+    private var fpsDelayMS:UInt32 = 25
+
     public init() {
         SDL_Init(SDL_INIT_VIDEO)
     }
 
-    /// - Parameters:
-    ///   - fps: Target frames per second to render the window.
-    public mutating func render(
+    public mutating func load(
         fontAtlas: consuming FontAtlas,
-        windowSettings: borrowing WindowSettings
+        windowSettings: borrowing WindowSettings,
     ) {
-        let window = SDL_CreateWindow(
+        window = SDL_CreateWindow(
             windowSettings.title,
             Int32(SDL_WINDOWPOS_CENTERED_MASK),
             Int32(SDL_WINDOWPOS_CENTERED_MASK),
@@ -26,7 +27,12 @@ public struct SDL2Renderer: RendererProtocol, @unchecked Sendable {
             windowSettings.flagsSDL
         )
         renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED.rawValue | SDL_RENDERER_PRESENTVSYNC.rawValue)
+        fpsDelayMS = windowSettings.fpsDelayMS
+    }
 
+    /// - Parameters:
+    ///   - fps: Target frames per second to render the window.
+    public func render() {
         var running = true
         var event = SDL_Event()
         while running {
@@ -39,7 +45,7 @@ public struct SDL2Renderer: RendererProtocol, @unchecked Sendable {
             SDL_RenderClear(renderer)
             drawRects()
             SDL_RenderPresent(renderer)
-            SDL_Delay(windowSettings.fpsDelayMS)
+            SDL_Delay(fpsDelayMS)
         }
         SDL_DestroyRenderer(renderer)
         SDL_DestroyWindow(window)
@@ -70,6 +76,22 @@ extension SDL2Renderer {
     }
 }
 
+extension SDL2Renderer {
+    public func render(
+        _ cmd: RenderRectangle
+    ) {
+    }
+
+    public func render<let count: Int>(
+        _ cmd: RenderInlineVertices<count>
+    ) {
+    }
+    public func render(
+        _ cmd: RenderVertices
+    ) {
+    }
+}
+
 extension WindowSettings {
     public var flagsSDL: UInt32 {
         SDL_WINDOW_SHOWN.rawValue

Sources/SlayKit/commands/RenderCommandProtocol.swift

@@ -0,0 +1,4 @@
+
+public protocol RenderCommandProtocol: Sendable {
+    func render(renderer: borrowing some RendererProtocol & ~Copyable)
+}

Sources/SlayKit/commands/RenderInlineVertices.swift

@@ -0,0 +1,17 @@
+
+public struct RenderInlineVertices<let count: Int>: RenderCommandProtocol {
+    public let vertices:[count of Float]
+    public let color:(Float, Float, Float, Float)
+
+    public init(
+        vertices: [count of Float],
+        color: (Float, Float, Float, Float)
+    ) {
+        self.vertices = vertices
+        self.color = color
+    }
+
+    public func render(renderer: borrowing some RendererProtocol & ~Copyable) {
+        renderer.render(self)
+    }
+}

Sources/SlayKit/commands/RenderRectangle.swift

@@ -0,0 +1,20 @@
+
+public struct RenderRectangle: RenderCommandProtocol {
+    public let frame:Rect
+    public let radius:Float
+    public let color:(Float, Float, Float, Float)
+
+    public init(
+        frame: Rect,
+        radius: Float,
+        color: (Float, Float, Float, Float)
+    ) {
+        self.frame = frame
+        self.radius = radius
+        self.color = color
+    }
+
+    public func render(renderer: borrowing some RendererProtocol & ~Copyable) {
+        renderer.render(self)
+    }
+}

Sources/SlayKit/commands/RenderText.swift

@@ -0,0 +1,23 @@
+
+public struct RenderText: RenderCommandProtocol {
+    public let text:String
+    public let x:Float
+    public let y:Float
+    public let color:(Float, Float, Float, Float)
+
+    public init(
+        text: String,
+        x: Float,
+        y: Float,
+        color: (Float, Float, Float, Float)
+    ) {
+        self.text = text
+        self.x = x
+        self.y = y
+        self.color = color
+    }
+
+    public func render(renderer: borrowing some RendererProtocol & ~Copyable) {
+        // TODO: fix
+    }
+}