Python Pygame/OpenGL optimization - opengl

Question

I wanted to implement shaders in my pygame program. As far as I know this is not possible to apply shaders to pygame, so I tried using PyOpenGL with GLSL shaders. I've already written a working program to use shaders, but it's not really fast.
It should run each tick multiple times for different purposes. Also, I want it to take a pygame surface as input, apply a shader to it, and output a pygame surface to work with later. It accepts variables, that are inputs for the shader.
Running a shader once per tick I get about 100 fps, without the shader I get about 500 fps in a program displaying a single image with pygame. I've never used OpenGL before, so with some tweaking it will probably run faster.
Do you have code optimizations or ideas to make it run faster?
Are there better solutions and alternatives?
Thanks!
main.py
import pygame, sys, pygame.freetype
import shader
pygame.init()
shader.init()
font = pygame.freetype.SysFont(None, 20)
clock = pygame.time.Clock()
loadedImage = pygame.image.load("image.png")
shaderObj = shader.create("vertex.txt", "fragment.txt")
window = pygame.display.set_mode(loadedImage.get_size())
while True:
image = shader.apply(shaderObj, loadedImage)
window.blit(image, (0,0))
font.render_to(window, (5, 5), str(clock.get_fps()), (0, 0, 0), (255, 255, 255))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
shader.quit()
sys.exit()
clock.tick(100)
shader.py
from OpenGL.GL import *
from OpenGL.GL.shaders import *
from pygame.locals import *
import pygame, numpy, sys, glfw
pygame.init()
if not glfw.init():
sys.exit()
def getFileContent(file):
with open(file, 'r') as file:
content = file.read()
return content
def quit():
global glfwwindow
glfw.destroy_window(glfwwindow)
# Create a glfw window
# It's size will be edited later
def init():
global width, height, glfwwindow
width, height = 1, 1
glfw.window_hint(glfw.VISIBLE, False)
glfwwindow = glfw.create_window(width, height, "", None, None)
glfw.make_context_current(glfwwindow)
glViewport(0, 0, width, height)
# Do as much as possible before using the shader
# Ouput an array of data, which will not change over time
def create(vertexShaderPath, fragmentShaderPath):
global timeMessage
vertices = numpy.array((0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0), dtype=numpy.float32)
texcoords = numpy.array((-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0), dtype=numpy.float32)
texcoords = numpy.array((-1.0, -1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0), dtype=numpy.float32)
vertexShader = compileShader(getFileContent(vertexShaderPath), GL_VERTEX_SHADER)
fragmentShader = compileShader(getFileContent(fragmentShaderPath), GL_FRAGMENT_SHADER)
shader = (vertices, texcoords, vertexShader, fragmentShader)
return shader
# You need to create a shader first
# Give optional variables that can be used by the GLSL shader
def apply(shader, image, **variables):
vertices, texcoords, vertexShader, fragmentShader = shader
global glfwwindow, timeMessage
width, height = image.get_size()
glfw.set_window_size(glfwwindow, width, height)
glViewport(0, 0, width, height)
glClear(GL_COLOR_BUFFER_BIT)
textureData = pygame.image.tostring(image, "RGB", 1)
glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, textureData)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
shaderProgram = glCreateProgram()
glAttachShader(shaderProgram, vertexShader)
glAttachShader(shaderProgram, fragmentShader)
glLinkProgram(shaderProgram)
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, texcoords)
glEnableVertexAttribArray(0)
glEnableVertexAttribArray(1)
glFlush()
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
glUseProgram(shaderProgram)
# Send variables to the shader if provided
for variable in variables:
location = glGetUniformLocation(shaderProgram, variable)
glUniform1f(location, variables[variable])
glDrawArrays(GL_QUADS, 0, 4)
# Turn image to pygame surface
data = glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE)
return pygame.transform.flip(pygame.image.frombuffer(data, (width, height), "RGBA"), False, True)
vertex.txt
#version 120
attribute vec2 vPosition;
attribute vec2 vTexcoords;
varying vec2 fTexcoords;
void main()
{
gl_Position = vec4(vPosition.x, vPosition.y, 0.0, 1.0);
fTexcoords = vTexcoords;
}
fragment.txt
#version 120
varying vec2 fTexcoords;
uniform sampler2D textureObj;
void main()
{
gl_FragColor = texture2D(textureObj, fTexcoords);
}

Answer 1

You are running far more per frame than you need to this is the reason why it is not running as fast as you expect.
Your shader.apply() function is compiling the shader and loading the texture to GPU member every frame. This should only be done once at start-up.
Your inner loop should just include the glUseProgram glDrawArrays.
You should also be creating names for objects and binding them, you can get away with it for very simple programs that include one texture and one VAO.