def init(): global VAOs glGenVertexArrays(1, VAOs) glBindVertexArray(VAOs) vertices = [ [-0.90, -0.90], [0.85, -0.90], [-0.90, 0.85], [0.90, -0.85], [0.90, 0.90], [-0.85, 0.90], ] vertices = np.array(vertices, dtype="f") buffers = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, buffers) glBufferData(GL_ARRAY_BUFFER, vertices, GL_STATIC_DRAW) shaders = [ (GL_VERTEX_SHADER, "triangles.vert"), (GL_FRAGMENT_SHADER, "triangles.frag"), ] program = LoadShaders(shaders) glUseProgram(program) glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, None) glEnableVertexAttribArray(0)
def compile_program():
program = glCreateProgram()
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
tcs = glCreateShader(GL_TESS_CONTROL_SHADER)
glShaderSource(tcs, tcs_source)
glCompileShader(tcs)
tes = glCreateShader(GL_TESS_EVALUATION_SHADER)
glShaderSource(tes, tes_source)
glCompileShader(tes)
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
glAttachShader(program, vs)
glAttachShader(program, tcs)
glAttachShader(program, tes)
glAttachShader(program, fs)
glLinkProgram(program)
vao = GLuint(0)
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
return program
def __init__(self, width, height):
global tex_src
global tex_lut
self.width = width
self.height = height
# // Load texture from file
tex_src = ktxobject.ktx_load("treelights_2k.ktx")
# // Now bind it to the context using the GL_TEXTURE_2D binding point
glBindTexture(GL_TEXTURE_2D, tex_src)
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
load_shaders()
exposureLUT = [ 11.0, 6.0, 3.2, 2.8, 2.2, 1.90, 1.80, 1.80, 1.70, 1.70, 1.60, 1.60, 1.50, 1.50, 1.40, 1.40, 1.30, 1.20, 1.10, 1.00 ]
tex_lut = glGenTextures(1)
glBindTexture(GL_TEXTURE_1D, tex_lut)
glTexStorage1D(GL_TEXTURE_1D, 1, GL_R32F, 20)
glTexSubImage1D(GL_TEXTURE_1D, 0, 0, 20, GL_RED, GL_FLOAT, exposureLUT)
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
def compile_program(vertex_source, fragment_source):
texture = glGenTextures(1)
#// Generate a name for the texture
glGenTextures(1, texture);
#// Now bind it to the context using the GL_TEXTURE_2D binding point
glBindTexture(GL_TEXTURE_2D, texture);
#// Specify the amount of storage we want to use for the texture
glTexStorage2D(GL_TEXTURE_2D, #// 2D texture
8, #// 8 mipmap levels
GL_RGBA32F, #// 32-bit floating-point RGBA data
256, 256); #// 256 x 256 texels
#// Define some data to upload into the texture
data = np.zeros(256 * 256 * 4);
#// generate_texture() is a function that fills memory with image data
generate_texture(data, 256, 256);
#// Assume the texture is already bound to the GL_TEXTURE_2D target
glTexSubImage2D(GL_TEXTURE_2D, #// 2D texture
0, #// Level 0
0, 0, #// Offset 0, 0
256, 256, #// 256 x 256 texels, replace entire image
GL_RGBA, #// Four channel data
GL_FLOAT, #// Floating point data
data); #// Pointer to data
#// Free the memory we allocated before - \GL now has our data
#delete data;
program = glCreateProgram();
fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, fragment_source);
glCompileShader(fs);
#print_shader_log(fs);
vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, vertex_source);
glCompileShader(vs);
#print_shader_log(vs);
glAttachShader(program, vs);
glAttachShader(program, fs);
glLinkProgram(program);
vao = GLuint(0)
glGenVertexArrays(1, vao);
glBindVertexArray(vao);
return program
def constructCylinderMesh(self, slices, radius, length, direction):
self.slices = slices
self.radius = radius
self.vertex_array_type = GL_TRIANGLES
vertex_list, tris = construct_triangle_cylinder(slices, radius, length)
self.numVertices = len(vertex_list)
self.numIndices = len(tris) * 3
# Create the Vertex Array Object
self.vertexArrayObject = GLuint(0)
glGenVertexArrays(1, self.vertexArrayObject)
glBindVertexArray(self.vertexArrayObject)
indices = np.array(
tris, dtype='uint32') # np.array(tris).reshape(1,numIndices)[0]
self.indices = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER)
self.vertices = vbo.VBO(np.array(vertex_list, 'f'))
def __init__(self, width, height):
global overlay
global texture
global program
global vao
self.width = width
self.height = height
overlay.init(80, 50)
#// Generate a name for the texture
glGenTextures(1, texture)
#// Load texture from file
texture = ktxobject.ktx_load("treelights_2k.ktx")
#// Now bind it to the context using the GL_TEXTURE_2D binding point
glBindTexture(GL_TEXTURE_2D, texture)
program = glCreateProgram()
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
if not glGetShaderiv(fs, GL_COMPILE_STATUS):
print('compile error:')
print(glGetShaderInfoLog(fs))
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
if not glGetShaderiv(vs, GL_COMPILE_STATUS):
print('compile error:')
print(glGetShaderInfoLog(vs))
glAttachShader(program, vs)
glAttachShader(program, fs)
glLinkProgram(program)
if not glGetProgramiv(program, GL_LINK_STATUS):
print('link error:')
print(glGetProgramInfoLog(program))
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
def __init__(self, width, height):
global depth_fbo
global objects
global depth_tex
global depth_debug_tex
global quad_vao
load_shaders()
object_names = ["dragon.sbm", "sphere.sbm", "cube.sbm", "torus.sbm"]
for i in range(0, OBJECT_COUNT):
objects[i].obj.load(object_names[i])
glGenFramebuffers(1, depth_fbo)
glBindFramebuffer(GL_FRAMEBUFFER, depth_fbo)
depth_tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, depth_tex)
glTexStorage2D(GL_TEXTURE_2D, 11, GL_DEPTH_COMPONENT32F,
DEPTH_TEXTURE_SIZE, DEPTH_TEXTURE_SIZE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE,
GL_COMPARE_REF_TO_TEXTURE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL)
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_tex, 0)
depth_debug_tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, depth_debug_tex)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_R32F, DEPTH_TEXTURE_SIZE,
DEPTH_TEXTURE_SIZE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
depth_debug_tex, 0)
glBindTexture(GL_TEXTURE_2D, 0)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glEnable(GL_DEPTH_TEST)
glGenVertexArrays(1, quad_vao)
glBindVertexArray(quad_vao)
def constructSphereMesh(self, slices, stacks, radius):
self.slices = slices
self.stacks = stacks
self.radius = radius
self.vertex_array_type = GL_TRIANGLES
vertexList, tris = construct_triangle_sphere(slices, stacks,
radius * 2)
self.numVertices = (slices + 1) * (stacks + 1)
self.numIndices = len(tris) * 3
#Create the Vertex Array Object
self.vertexArrayObject = GLuint(0)
glGenVertexArrays(1, self.vertexArrayObject)
glBindVertexArray(self.vertexArrayObject)
indices = np.array(
tris, dtype='uint32') #np.array(tris).reshape(1,numIndices)[0]
self.indices = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER)
self.vertices = vbo.VBO(np.array(vertexList, 'f'))
def compile_program():
program = glCreateProgram()
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
tcs = glCreateShader(GL_TESS_CONTROL_SHADER)
glShaderSource(tcs, tcs_source)
glCompileShader(tcs)
tes = glCreateShader(GL_TESS_EVALUATION_SHADER)
glShaderSource(tes, tes_source)
glCompileShader(tes)
gs = glCreateShader(GL_GEOMETRY_SHADER)
glShaderSource(gs, gs_source)
glCompileShader(gs)
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
glAttachShader(program, vs)
glAttachShader(program, tcs)
glAttachShader(program, tes)
glAttachShader(program, gs)
glAttachShader(program, fs)
glLinkProgram(program)
glDeleteShader(vs)
glDeleteShader(tcs)
glDeleteShader(tes)
glDeleteShader(gs)
glDeleteShader(fs)
vao = GLuint(0)
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
return program
def __init__(self, width, height):
global objects
global quad_vao
self.width = width
self.height = height
self.flags.fullscreen = 0
self.flags.stereo = 1
load_shaders()
object_names = ["cube.sbm", "sphere.sbm", "dragon.sbm", "torus.sbm"]
for i in range(0, OBJECT_COUNT):
objects[i].obj.load(object_names[i])
glEnable(GL_DEPTH_TEST)
glGenVertexArrays(1, quad_vao)
glBindVertexArray(quad_vao)
def __init__(self, width, height):
global patch_vao
global patch_buffer
global cage_indices
load_shaders()
glGenVertexArrays(1, patch_vao)
glBindVertexArray(patch_vao)
glGenBuffers(1, patch_buffer)
glBindBuffer(GL_ARRAY_BUFFER, patch_buffer)
glBufferData(GL_ARRAY_BUFFER, ctypes.sizeof(ctypes.c_float)*3*16, None, GL_DYNAMIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
indices = [
0, 1, 1, 2, 2, 3,
4, 5, 5, 6, 6, 7,
8, 9, 9, 10, 10, 11,
12, 13, 13, 14, 14, 15,
0, 4, 4, 8, 8, 12,
1, 5, 5, 9, 9, 13,
2, 6, 6, 10, 10, 14,
3, 7, 7, 11, 11, 15
]
ar = np.array(indices, dtype=np.uint16)
glGenBuffers(1, cage_indices)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cage_indices)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ctypes.sizeof(ctypes.c_ushort)*len(indices), ar, GL_STATIC_DRAW)
overlay.init(80, 50)
overlay.clear()
overlay.drawText("W: Toggle wireframe", 0, 0)
overlay.drawText("C: Toggle control cage", 0, 1)
overlay.drawText("X: Toggle control points", 0, 2)
overlay.drawText("P: Pause", 0, 3)
def __init__(self, width, height):
global myobject
global tex_envmap
global skybox_vao
envmaps[0] = ktxobject.ktx_load("mountaincube.ktx")
tex_envmap = envmaps[envmap_index]
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS)
myobject.load("dragon.sbm")
load_shaders()
glGenVertexArrays(1, skybox_vao)
glBindVertexArray(skybox_vao)
glDepthFunc(GL_LEQUAL)
def __init__(self, width, height):
global ktxobject
global dummy_vao
global images
self.width = width
self.height = height
#glGenTextures(3, images)
images = [glGenTextures(1) for _ in range(3)]
images[0] = ktxobject.ktx_load("salad-gray.ktx")
for i in range(1, 3):
glBindTexture(GL_TEXTURE_2D, images[i])
glTexStorage2D(GL_TEXTURE_2D, 1, GL_R32F, NUM_ELEMENTS,
NUM_ELEMENTS)
glGenVertexArrays(1, dummy_vao)
glBindVertexArray(dummy_vao)
load_shaders()
def __init__(self, width, height):
global uniforms_buffer
global fragment_buffer
global atomic_counter_buffer
global head_pointer_image
global dummy_vao
global myobject
self.width = width
self.height = height
load_shaders()
glGenBuffers(1, uniforms_buffer)
glBindBuffer(GL_UNIFORM_BUFFER, uniforms_buffer)
glBufferData(GL_UNIFORM_BUFFER, sizeof(GLfloat * 16 * 3), None,
GL_DYNAMIC_DRAW)
myobject.load("dragon.sbm")
glGenBuffers(1, fragment_buffer)
glBindBuffer(GL_SHADER_STORAGE_BUFFER, fragment_buffer)
glBufferData(GL_SHADER_STORAGE_BUFFER, 1024 * 1024 * 16, None,
GL_DYNAMIC_COPY)
glGenBuffers(1, atomic_counter_buffer)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomic_counter_buffer)
glBufferData(GL_ATOMIC_COUNTER_BUFFER, 4, None, GL_DYNAMIC_COPY)
head_pointer_image = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, head_pointer_image)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_R32UI, 1024, 1024)
glGenVertexArrays(1, dummy_vao)
glBindVertexArray(dummy_vao)
def __init__(self, locations):
self.locations = locations
self.VBOs = []
self.vptr_args = []
# VAO index or 'name' in OpenGL
self._index = GLuint(0)
glGenVertexArrays(1, self._index)
# Plan: Store the arguments for a glVertex call,
# then, when a buffer is added, activate the VBO
# and call glVertexAttribPointer with stored arguments.
offset = 0
count = 0
stride = 0
for loc, attribs in self.locations.items():
if 'vec' in attribs.type:
size = int(attribs.type[3])
elif 'mat' in attribs.type:
size = int(attribs.type[3])**2
elif 'float' in attribs.type:
size = 1
else:
raise TypeError("Unsupported type for VAO: " + attribs.type)
self.vptr_args.append([
loc,
size,
GL_FLOAT,
GL_FALSE,
0, # mulitply by stride later
ctypes.c_void_p(offset)
])
offset += size * sizeof(ctypes.c_float)
stride += size
for arg in self.vptr_args:
arg[4] = stride * sizeof(ctypes.c_float)
def __init__(self, width, height):
global render_prog
global render_vao
self.width = width
self.height = height
fs_source = '''
#version 410 core
layout (location = 0) out vec4 color;
flat in int shape;
void main(void)
{
color = vec4(1.0);
vec2 p = gl_PointCoord * 2.0 - vec2(1.0);
if (shape == 0)
{
if (dot(p, p) > 1.0)
discard;
}
else if (shape == 1)
{
if (dot(p, p) > sin(atan(p.y, p.x) * 5.0))
discard;
}
else if (shape == 2)
{
if (abs(0.8 - dot(p, p)) > 0.2)
discard;
}
else if (shape == 3)
{
if (abs(p.x) < abs(p.y))
discard;
}
}
'''
vs_source = '''
#version 410 core
flat out int shape;
void main(void)
{
const vec4[4] position = vec4[4](vec4(-0.4, -0.4, 0.5, 1.0),
vec4( 0.4, -0.4, 0.5, 1.0),
vec4(-0.4, 0.4, 0.5, 1.0),
vec4( 0.4, 0.4, 0.5, 1.0));
gl_Position = position[gl_VertexID];
shape = gl_VertexID;
}
'''
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
render_prog = glCreateProgram()
glAttachShader(render_prog, vs)
glAttachShader(render_prog, fs)
glLinkProgram(render_prog)
glDeleteShader(vs)
glDeleteShader(fs)
glGenVertexArrays(1, render_vao)
glBindVertexArray(render_vao)
def __init__(self, width, height):
global render_prog
global render_vao
global uniform
global tex_wall, tex_ceiling, tex_floor
self.width = width
self.height = height
vs = GLuint(0)
fs = GLuint(0)
vs_source = '''
#version 420 core
out VS_OUT
{
vec2 tc;
} vs_out;
uniform mat4 mvp;
uniform float offset;
void main(void)
{
const vec2[4] position = vec2[4](vec2(-0.5, -0.5),
vec2( 0.5, -0.5),
vec2(-0.5, 0.5),
vec2( 0.5, 0.5));
vs_out.tc = (position[gl_VertexID].xy + vec2(offset, 0.5)) * vec2(30.0, 1.0);
gl_Position = mvp * vec4(position[gl_VertexID], 0.0, 1.0);
}
'''
fs_source = '''
#version 420 core
layout (location = 0) out vec4 color;
in VS_OUT
{
vec2 tc;
} fs_in;
layout (binding = 0) uniform sampler2D tex;
void main(void)
{
color = texture(tex, fs_in.tc);
}
'''
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
glGetShaderInfoLog(vs)
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
glGetShaderInfoLog(vs)
render_prog = glCreateProgram()
glAttachShader(render_prog, vs)
glAttachShader(render_prog, fs)
glLinkProgram(render_prog)
glDeleteShader(vs)
glDeleteShader(fs)
glGetProgramInfoLog(render_prog)
uniform.mvp = glGetUniformLocation(render_prog, "mvp")
uniform.offset = glGetUniformLocation(render_prog, "offset")
glGenVertexArrays(1, render_vao)
glBindVertexArray(render_vao)
ktxobj = KTXObject()
tex_wall = ktxobj.ktx_load("brick.ktx")
tex_ceiling = ktxobj.ktx_load("ceiling.ktx")
tex_floor = ktxobj.ktx_load("floor.ktx")
textures = [tex_floor, tex_wall, tex_ceiling]
for i in range(0, 3):
glBindTexture(GL_TEXTURE_2D, textures[i])
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glBindVertexArray(render_vao)
def run():
pygame.init()
screen = pygame.display.set_mode((800,600), pygame.OPENGL)
#Create the Vertex Array Object
vertexArrayObject = GLuint(0)
glGenVertexArrays(1, vertexArrayObject)
glBindVertexArray(vertexArrayObject)
#Create the VBO
vertices = np.array([[0,1,0],[-1,-1,0],[1,-1,0]], dtype='f')
vertexPositions = vbo.VBO(vertices)
#Create the index buffer object
indices = np.array([0,1,2], dtype='uint16')
indexPositions = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER)
indexPositions.bind()
vertexPositions.bind()
glEnableVertexAttribArray(0) # from 'location = 0' in shader
glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, None)
glBindVertexArray(0)
vertexPositions.unbind()
indexPositions.unbind()
#Now create the shaders
VERTEX_SHADER = shaders.compileShader("""
#version 330
layout(location = 0) in vec4 position;
void main()
{
gl_Position = position;
}
""", GL_VERTEX_SHADER)
FRAGMENT_SHADER = shaders.compileShader("""
#version 330
out vec4 outputColor;
void main()
{
outputColor = vec4(0.0f, 1.0f, 0.0f, 1.0f);
}
""", GL_FRAGMENT_SHADER)
shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)
#The draw loop
while True:
glUseProgram(shader)
glBindVertexArray(vertexArrayObject)
#glDrawArrays(GL_TRIANGLES, 0, 3) #This line works
glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0) #This line does not
glBindVertexArray(0)
glUseProgram(0)
# Show the screen
pygame.display.flip()
def __init__(self, width, height):
global program
global vao
global overlay
vs_source = '''
#version 420 core
void main(void)
{
const vec4 vertices[] = vec4[](vec4( 0.4, -0.4, 0.5, 1.0),
vec4(-0.4, -0.4, 0.5, 1.0),
vec4( 0.4, 0.4, 0.5, 1.0),
vec4(-0.4, 0.4, 0.5, 1.0));
gl_Position = vertices[gl_VertexID];
}
'''
tcs_source_triangles = '''
#version 420 core
layout (vertices = 3) out;
void main(void)
{
if (gl_InvocationID == 0)
{
gl_TessLevelInner[0] = 5.0;
gl_TessLevelOuter[0] = 8.0;
gl_TessLevelOuter[1] = 8.0;
gl_TessLevelOuter[2] = 8.0;
}
gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;
}
'''
tes_source_triangles = '''
#version 420 core
layout (triangles) in;
void main(void)
{
gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position) +
(gl_TessCoord.y * gl_in[1].gl_Position) +
(gl_TessCoord.z * gl_in[2].gl_Position);
}
'''
tes_source_triangles_as_points = '''
#version 420 core
layout (triangles, point_mode) in;
void main(void)
{
gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position) +
(gl_TessCoord.y * gl_in[1].gl_Position) +
(gl_TessCoord.z * gl_in[2].gl_Position);
}
'''
tcs_source_quads = '''
#version 420 core
layout (vertices = 4) out;
void main(void)
{
if (gl_InvocationID == 0)
{
gl_TessLevelInner[0] = 9.0;
gl_TessLevelInner[1] = 7.0;
gl_TessLevelOuter[0] = 3.0;
gl_TessLevelOuter[1] = 5.0;
gl_TessLevelOuter[2] = 3.0;
gl_TessLevelOuter[3] = 5.0;
}
gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;
}
'''
tes_source_quads = '''
#version 420 core
layout (quads) in;
void main(void)
{
vec4 p1 = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x);
vec4 p2 = mix(gl_in[2].gl_Position, gl_in[3].gl_Position, gl_TessCoord.x);
gl_Position = mix(p1, p2, gl_TessCoord.y);
}
'''
tcs_source_isolines = '''
#version 420 core
layout (vertices = 4) out;
void main(void)
{
if (gl_InvocationID == 0)
{
gl_TessLevelOuter[0] = 5.0;
gl_TessLevelOuter[1] = 5.0;
}
gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;
}
'''
tes_source_isolines = '''
#version 420 core
layout (isolines) in;
void main(void)
{
float r = (gl_TessCoord.y + gl_TessCoord.x / gl_TessLevelOuter[0]);
float t = gl_TessCoord.x * 2.0 * 3.14159;
gl_Position = vec4(sin(t) * r, cos(t) * r, 0.5, 1.0);
}
'''
fs_source = '''
#version 420 core
out vec4 color;
void main(void)
{
color = vec4(1.0);
}
'''
i = 0
vs_sources = [vs_source, vs_source, vs_source, vs_source]
tcs_sources = [
tcs_source_quads, tcs_source_triangles, tcs_source_triangles,
tcs_source_isolines
]
tes_sources = [
tes_source_quads, tes_source_triangles,
tes_source_triangles_as_points, tes_source_isolines
]
fs_sources = [fs_source, fs_source, fs_source, fs_source]
overlay.init(80, 50)
for i in range(0, 4):
program[i] = glCreateProgram()
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_sources[i])
glCompileShader(vs)
tcs = glCreateShader(GL_TESS_CONTROL_SHADER)
glShaderSource(tcs, tcs_sources[i])
glCompileShader(tcs)
tes = glCreateShader(GL_TESS_EVALUATION_SHADER)
glShaderSource(tes, tes_sources[i])
glCompileShader(tes)
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_sources[i])
glCompileShader(fs)
glAttachShader(program[i], vs)
glAttachShader(program[i], tcs)
glAttachShader(program[i], tes)
glAttachShader(program[i], fs)
glLinkProgram(program[i])
glDeleteShader(vs)
glDeleteShader(tcs)
glDeleteShader(tes)
glDeleteShader(fs)
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
glPatchParameteri(GL_PATCH_VERTICES, 4)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
def __init__(self, width, height):
global grass_buffer
global grass_vao
global grass_program
global tex_grass_color
global tex_grass_length
global tex_grass_orientation
global tex_grass_bend
global uniform
self.width = width
self.height = height
grass_vs = GLuint(0)
grass_fs = GLuint(0)
grass_vs_source = '''
#version 420 core
// Incoming per vertex position
in vec4 vVertex;
// Output varyings
out vec4 color;
uniform mat4 mvpMatrix;
layout (binding = 0) uniform sampler1D grasspalette_texture;
layout (binding = 1) uniform sampler2D length_texture;
layout (binding = 2) uniform sampler2D orientation_texture;
layout (binding = 3) uniform sampler2D grasscolor_texture;
layout (binding = 4) uniform sampler2D bend_texture;
int random(int seed, int iterations)
{
int value = seed;
int n;
for (n = 0; n < iterations; n++) {
value = ((value >> 7) ^ (value << 9)) * 15485863;
}
return value;
}
vec4 random_vector(int seed)
{
int r = random(gl_InstanceID, 4);
int g = random(r, 2);
int b = random(g, 2);
int a = random(b, 2);
return vec4(float(r & 0x3FF) / 1024.0,
float(g & 0x3FF) / 1024.0,
float(b & 0x3FF) / 1024.0,
float(a & 0x3FF) / 1024.0);
}
mat4 construct_rotation_matrix(float angle)
{
float st = sin(angle);
float ct = cos(angle);
return mat4(vec4(ct, 0.0, st, 0.0),
vec4(0.0, 1.0, 0.0, 0.0),
vec4(-st, 0.0, ct, 0.0),
vec4(0.0, 0.0, 0.0, 1.0));
}
void main(void)
{
vec4 offset = vec4(float(gl_InstanceID >> 10) - 512.0,
0.0f,
float(gl_InstanceID & 0x3FF) - 512.0,
0.0f);
int number1 = random(gl_InstanceID, 3);
int number2 = random(number1, 2);
offset += vec4(float(number1 & 0xFF) / 256.0,
0.0f,
float(number2 & 0xFF) / 256.0,
0.0f);
// float angle = float(random(number2, 2) & 0x3FF) / 1024.0;
vec2 texcoord = offset.xz / 1024.0 + vec2(0.5);
// float bend_factor = float(random(number2, 7) & 0x3FF) / 1024.0;
float bend_factor = texture(bend_texture, texcoord).r * 2.0;
float bend_amount = cos(vVertex.y);
float angle = texture(orientation_texture, texcoord).r * 2.0 * 3.141592;
mat4 rot = construct_rotation_matrix(angle);
vec4 position = (rot * (vVertex + vec4(0.0, 0.0, bend_amount * bend_factor, 0.0))) + offset;
position *= vec4(1.0, texture(length_texture, texcoord).r * 0.9 + 0.3, 1.0, 1.0);
gl_Position = mvpMatrix * position; // (rot * position);
// color = vec4(random_vector(gl_InstanceID).xyz * vec3(0.1, 0.5, 0.1) + vec3(0.1, 0.4, 0.1), 1.0);
// color = texture(orientation_texture, texcoord);
color = texture(grasspalette_texture, texture(grasscolor_texture, texcoord).r) +
vec4(random_vector(gl_InstanceID).xyz * vec3(0.1, 0.5, 0.1), 1.0);
}
'''
grass_fs_source = '''
#version 420 core
in vec4 color;
out vec4 output_color;
void main(void)
{
output_color = color;
}
'''
grass_blade = [
-0.3, 0.0, 0.3, 0.0, -0.20, 1.0, 0.1, 1.3, -0.05, 2.3, 0.0, 3.3
]
glGenBuffers(1, grass_buffer)
glBindBuffer(GL_ARRAY_BUFFER, grass_buffer)
ar = array("f", grass_blade)
glBufferData(GL_ARRAY_BUFFER, ar.tostring(), GL_STATIC_DRAW)
glGenVertexArrays(1, grass_vao)
glBindVertexArray(grass_vao)
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
grass_program = glCreateProgram()
grass_vs = glCreateShader(GL_VERTEX_SHADER)
grass_fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(grass_vs, grass_vs_source)
glShaderSource(grass_fs, grass_fs_source)
glCompileShader(grass_vs)
glCompileShader(grass_fs)
glAttachShader(grass_program, grass_vs)
glAttachShader(grass_program, grass_fs)
glLinkProgram(grass_program)
glDeleteShader(grass_fs)
glDeleteShader(grass_vs)
uniform.mvpMatrix = glGetUniformLocation(grass_program, "mvpMatrix")
ktx = KTXObject()
glActiveTexture(GL_TEXTURE1)
tex_grass_length = ktx.ktx_load("grass_length.ktx")
glActiveTexture(GL_TEXTURE2)
tex_grass_orientation = ktx.ktx_load("grass_orientation.ktx")
glActiveTexture(GL_TEXTURE3)
tex_grass_color = ktx.ktx_load("grass_color.ktx")
glActiveTexture(GL_TEXTURE4)
tex_grass_bend = ktx.ktx_load("grass_bend.ktx")
def __init__(self, width, height):
global m_vao
global m_vbo
i = 0
j = 0
load_shaders()
initial_positions = [glm.vec4() for _ in range(POINTS_TOTAL)]
initial_velocities = [glm.vec3() for _ in range(POINTS_TOTAL)]
connection_vectors = [glm.ivec3() for _ in range(POINTS_TOTAL)]
n = 0
for j in range(0, POINTS_Y):
fj = float(j) / float(POINTS_Y)
for i in range(0, POINTS_X):
fi = float(i) / float(POINTS_X)
initial_positions[n] = glm.vec4((fi - 0.5) * float(POINTS_X),
(fj - 0.5) * float(POINTS_Y),
0.6 * sin(fi) * cos(fj), 1.0)
initial_velocities[n] = glm.vec3(0.0)
connection_vectors[n] = glm.ivec4(-1)
if (j != (POINTS_Y - 1)):
if (i != 0):
connection_vectors[n][0] = n - 1
if (j != 0):
connection_vectors[n][1] = n - POINTS_X
if (i != (POINTS_X - 1)):
connection_vectors[n][2] = n + 1
if (j != (POINTS_Y - 1)):
connection_vectors[n][3] = n + POINTS_X
n += 1
for i in range(0, 2):
glGenVertexArrays(1, m_vao[i])
for i in range(0, 5):
glGenBuffers(i + 1, m_vbo[i])
for i in range(0, 2):
glBindVertexArray(m_vao[i])
glBindBuffer(GL_ARRAY_BUFFER, m_vbo[POSITION_A + i])
# POSITION_A
glBindBuffer(GL_ARRAY_BUFFER, m_vbo[POSITION_A + i])
ar_position = np.empty([POINTS_TOTAL, 4], dtype='float32')
for j, e in enumerate(initial_positions):
ar_position[j] = e
glBufferData(GL_ARRAY_BUFFER,
POINTS_TOTAL * glm.sizeof(glm.vec4()), ar_position,
GL_DYNAMIC_COPY)
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
# VELOCITY_A
glBindBuffer(GL_ARRAY_BUFFER, m_vbo[VELOCITY_A + i])
ar_velocities = np.empty([POINTS_TOTAL, 3], dtype='float32')
for j, e in enumerate(initial_velocities):
ar_velocities[j] = e
glBufferData(GL_ARRAY_BUFFER,
POINTS_TOTAL * glm.sizeof(glm.vec3()), ar_velocities,
GL_DYNAMIC_COPY)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(1)
# CONNECTION
glBindBuffer(GL_ARRAY_BUFFER, m_vbo[CONNECTION])
ar_connection = np.empty([POINTS_TOTAL, 4], dtype='uint32')
for j, e in enumerate(connection_vectors):
ar_connection[j] = e
glBufferData(GL_ARRAY_BUFFER,
POINTS_TOTAL * glm.sizeof(glm.ivec4()), ar_connection,
GL_STATIC_DRAW)
glVertexAttribIPointer(2, 4, GL_INT, 0, None)
glEnableVertexAttribArray(2)
glGenTextures(2, m_pos_tbo)
glBindTexture(GL_TEXTURE_BUFFER, m_pos_tbo[0])
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_vbo[POSITION_A])
glBindTexture(GL_TEXTURE_BUFFER, m_pos_tbo[1])
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_vbo[POSITION_B])
lines = (POINTS_X - 1) * POINTS_Y + (POINTS_Y - 1) * POINTS_X
glGenBuffers(1, m_index_buffer)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
lines * 2 * ctypes.sizeof(ctypes.c_int), None,
GL_STATIC_DRAW)
e = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0,
lines * 2 * ctypes.sizeof(ctypes.c_int),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT)
int_array = (ctypes.c_int * (4 * lines * 2)).from_address(e)
n = 0
for j in range(0, POINTS_Y):
for i in range(0, POINTS_X - 1):
int_array[n] = i + j * POINTS_X
n += 1
int_array[n] = 1 + i + j * POINTS_X
n += 1
for i in range(0, POINTS_X):
for j in range(0, POINTS_Y - 1):
int_array[n] = i + j * POINTS_X
n += 1
int_array[n] = POINTS_X + i + j * POINTS_X
n += 1
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER)
def __init__(self, width, height):
global program
global vao
global position_buffer
global index_buffer
global mv_location
global proj_location
vs_source = '''
#version 410 core
in vec4 position;
out VS_OUT
{
vec4 color0;
vec4 color1;
} vs_out;
uniform mat4 mv_matrix;
uniform mat4 proj_matrix;
void main(void)
{
gl_Position = proj_matrix * mv_matrix * position;
vs_out.color0 = position * 2.0 + vec4(0.5, 0.5, 0.5, 0.0);
vs_out.color1 = vec4(0.5, 0.5, 0.5, 0.0) - position * 2.0;
}
'''
fs_source = '''
#version 410 core
layout (location = 0, index = 0) out vec4 color0;
layout (location = 0, index = 1) out vec4 color1;
in VS_OUT
{
vec4 color0;
vec4 color1;
} fs_in;
void main(void)
{
color0 = vec4(fs_in.color0.xyz, 1.0);
color1 = vec4(fs_in.color0.xyz, 1.0);
}
'''
program = glCreateProgram()
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
glAttachShader(program, vs)
glAttachShader(program, fs)
glLinkProgram(program)
mv_location = glGetUniformLocation(program, "mv_matrix")
proj_location = glGetUniformLocation(program, "proj_matrix")
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
vertex_indices = np.array([
0, 1, 2, 2, 1, 3, 2, 3, 4, 4, 3, 5, 4, 5, 6, 6, 5, 7, 6, 7, 0, 0,
7, 1, 6, 0, 2, 2, 4, 6, 7, 5, 3, 7, 3, 1
],
dtype=np.uint16) # GLushort
vertex_positions = np.array([
-0.25,
-0.25,
-0.25,
-0.25,
0.25,
-0.25,
0.25,
-0.25,
-0.25,
0.25,
0.25,
-0.25,
0.25,
-0.25,
0.25,
0.25,
0.25,
0.25,
-0.25,
-0.25,
0.25,
-0.25,
0.25,
0.25,
],
dtype=np.float32) # GLfloat
size_vertex_indices = ctypes.sizeof(
ctypes.c_ushort) * len(vertex_indices)
size_vertex_positions = ctypes.sizeof(
ctypes.c_float) * len(vertex_positions)
glGenBuffers(1, position_buffer)
glBindBuffer(GL_ARRAY_BUFFER, position_buffer)
glBufferData(GL_ARRAY_BUFFER, size_vertex_positions, vertex_positions,
GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
glGenBuffers(1, index_buffer)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, size_vertex_indices,
vertex_indices, GL_STATIC_DRAW)
glEnable(GL_CULL_FACE)
def __init__(self, width, height):
global render_prog
global star_vao
global star_buffer
global uniforms
global star_texture
self.width = width
self.height = height
vs = GLuint(0)
fs = GLuint(0)
fs_source = '''
#version 410 core
layout (location = 0) out vec4 color;
uniform sampler2D tex_star;
flat in vec4 starColor;
void main(void)
{
color = starColor * texture(tex_star, gl_PointCoord);
//color.r = 1.0;
}
'''
vs_source = '''
#version 410 core
layout (location = 0) in vec4 position;
layout (location = 1) in vec4 color;
uniform float time;
uniform mat4 proj_matrix;
flat out vec4 starColor;
void main(void)
{
vec4 newVertex = position;
newVertex.z += time;
newVertex.z = fract(newVertex.z);
float size = (20.0 * newVertex.z * newVertex.z);
starColor = smoothstep(1.0, 7.0, size) * color;
newVertex.z = (999.9 * newVertex.z) - 1000.0;
gl_Position = proj_matrix * newVertex;
gl_PointSize = size;
}
'''
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
if not glGetShaderiv(vs, GL_COMPILE_STATUS):
print( 'compile error:' )
print( glGetShaderInfoLog(vs) )
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
if not glGetShaderiv(fs, GL_COMPILE_STATUS):
print( 'compile error:' )
print( glGetShaderInfoLog(fs) )
render_prog = glCreateProgram()
glAttachShader(render_prog, vs)
glAttachShader(render_prog, fs)
glLinkProgram(render_prog)
if not glGetProgramiv(render_prog, GL_LINK_STATUS):
print( 'link error:' )
print( glGetProgramInfoLog(render_prog) )
glDeleteShader(vs)
glDeleteShader(fs)
uniforms.time = glGetUniformLocation(render_prog, "time")
uniforms.proj_matrix = glGetUniformLocation(render_prog, "proj_matrix")
star_texture = ktxobject.ktx_load("star.ktx")
glGenVertexArrays(1, star_vao)
glBindVertexArray(star_vao)
class star_t:
position = glm.vec3
color = glm.vec3
size_star_t = ctypes.sizeof(ctypes.c_float) * 6; # same as glm.sizeof(glm.vec3) * 2
glGenBuffers(1, star_buffer)
glBindBuffer(GL_ARRAY_BUFFER, star_buffer)
glBufferData(GL_ARRAY_BUFFER, NUM_STARS * size_star_t, None, GL_STATIC_DRAW)
star = glMapBufferRange(GL_ARRAY_BUFFER, 0, NUM_STARS * size_star_t, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT)
m = (GLfloat * 6 * NUM_STARS).from_address(star)
for i in range(0, 1000):
m[i][0] = (random_float() * 2.0 - 1.0) * 100.0
m[i][1] = (random_float() * 2.0 - 1.0) * 100.0
m[i][2] = random_float()
m[i][3] = 0.8 + random_float() * 0.2
m[i][4] = 0.8 + random_float() * 0.2
m[i][5] = 0.8 + random_float() * 0.2
glUnmapBuffer(GL_ARRAY_BUFFER)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, size_star_t, None)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, size_star_t, ctypes.c_void_p(glm.sizeof(glm.vec3) ) )
glEnableVertexAttribArray(0)
glEnableVertexAttribArray(1)
def __init__(self, width, height):
global program
global vao
global position_buffer
global index_buffer
global uniform_buffer
vs_source = '''
#version 420 core
in vec4 position;
out VS_OUT
{
vec4 color;
} vs_out;
void main(void)
{
gl_Position = position;
vs_out.color = position * 2.0 + vec4(0.5, 0.5, 0.5, 0.0);
}
'''
gs_source = '''
#version 420 core
layout (triangles, invocations = 4) in;
layout (triangle_strip, max_vertices = 3) out;
layout (std140, binding = 0) uniform transform_block
{
mat4 mvp_matrix[4];
};
in VS_OUT
{
vec4 color;
} gs_in[];
out GS_OUT
{
vec4 color;
} gs_out;
void main(void)
{
for (int i = 0; i < gl_in.length(); i++)
{
gs_out.color = gs_in[i].color;
gl_Position = mvp_matrix[gl_InvocationID] *
gl_in[i].gl_Position;
gl_ViewportIndex = gl_InvocationID;
EmitVertex();
}
EndPrimitive();
}
'''
fs_source = '''
#version 420 core
out vec4 color;
in GS_OUT
{
vec4 color;
} fs_in;
void main(void)
{
color = fs_in.color;
}
'''
program = glCreateProgram()
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
gs = glCreateShader(GL_GEOMETRY_SHADER)
glShaderSource(gs, gs_source)
glCompileShader(gs)
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
glAttachShader(program, vs)
glAttachShader(program, gs)
glAttachShader(program, fs)
glLinkProgram(program)
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
vertex_indices = np.array([
0, 1, 2,
2, 1, 3,
2, 3, 4,
4, 3, 5,
4, 5, 6,
6, 5, 7,
6, 7, 0,
0, 7, 1,
6, 0, 2,
2, 4, 6,
7, 5, 3,
7, 3, 1
], dtype=np.uint16) # GLushort
vertex_positions = np.array([
-0.25, -0.25, -0.25,
-0.25, 0.25, -0.25,
0.25, -0.25, -0.25,
0.25, 0.25, -0.25,
0.25, -0.25, 0.25,
0.25, 0.25, 0.25,
-0.25, -0.25, 0.25,
-0.25, 0.25, 0.25,
], dtype=np.float32) # GLfloat
size_vertex_indices = ctypes.sizeof(ctypes.c_ushort)*len(vertex_indices)
size_vertex_positions = ctypes.sizeof(ctypes.c_float)*len(vertex_positions)
glGenBuffers(1, position_buffer)
glBindBuffer(GL_ARRAY_BUFFER, position_buffer)
glBufferData(GL_ARRAY_BUFFER,
size_vertex_positions,
vertex_positions,
GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
glGenBuffers(1, index_buffer)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
size_vertex_indices,
vertex_indices,
GL_STATIC_DRAW)
glGenBuffers(1, uniform_buffer)
glBindBuffer(GL_UNIFORM_BUFFER, uniform_buffer)
glBufferData(GL_UNIFORM_BUFFER, 4 * glm.sizeof(glm.mat4()), None, GL_DYNAMIC_DRAW)
glEnable(GL_CULL_FACE)
#// glFrontFace(GL_CW)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LEQUAL)
def __init__(self, width, height):
global myobject
global vao
global render_fbo
global tex_scene
global tex_brightpass
global tex_depth
global filter_fbo
global tex_filter
global tex_lut
global ubo_transform
global ubo_material
self.width = width
self.height = height
buffers = [GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1]
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
load_shaders()
exposureLUT = [
11.0, 6.0, 3.2, 2.8, 2.2, 1.90, 1.80, 1.80, 1.70, 1.70, 1.60, 1.60,
1.50, 1.50, 1.40, 1.40, 1.30, 1.20, 1.10, 1.00
]
glGenFramebuffers(1, render_fbo)
glBindFramebuffer(GL_FRAMEBUFFER, render_fbo)
tex_scene = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, tex_scene)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16F, MAX_SCENE_WIDTH,
MAX_SCENE_HEIGHT)
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex_scene,
0)
tex_brightpass = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, tex_brightpass)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16F, MAX_SCENE_WIDTH,
MAX_SCENE_HEIGHT)
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1,
tex_brightpass, 0)
tex_depth = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, tex_depth)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT32F,
MAX_SCENE_WIDTH, MAX_SCENE_HEIGHT)
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, tex_depth, 0)
glDrawBuffers(2, buffers)
#glGenFramebuffers(2, filter_fbo[0])
filter_fbo = [glGenFramebuffers(1) for _ in range(2)]
#glGenTextures(2, tex_filter[0])
tex_filter = [glGenTextures(1) for _ in range(2)]
for i in range(0, 2):
glBindFramebuffer(GL_FRAMEBUFFER, filter_fbo[i])
glBindTexture(GL_TEXTURE_2D, tex_filter[i])
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA16F,
MAX_SCENE_WIDTH if i == 0 else MAX_SCENE_HEIGHT,
MAX_SCENE_HEIGHT if i == 0 else MAX_SCENE_WIDTH)
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
tex_filter[i], 0)
glDrawBuffers(1, buffers)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
tex_lut = glGenTextures(1)
glBindTexture(GL_TEXTURE_1D, tex_lut)
glTexStorage1D(GL_TEXTURE_1D, 1, GL_R32F, 20)
glTexSubImage1D(GL_TEXTURE_1D, 0, 0, 20, GL_RED, GL_FLOAT, exposureLUT)
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
myobject.load("torus.sbm")
glGenBuffers(1, ubo_transform)
glBindBuffer(GL_UNIFORM_BUFFER, ubo_transform)
glBufferData(GL_UNIFORM_BUFFER,
(2 + SPHERE_COUNT) * glm.sizeof(glm.mat4), None,
GL_DYNAMIC_DRAW)
class material:
diffuse_color = glm.vec3
specular_color = glm.vec3
specular_power = GLfloat(0)
ambient_color = glm.vec3
glGenBuffers(1, ubo_material)
glBindBuffer(GL_UNIFORM_BUFFER, ubo_material)
size_material = ctypes.sizeof(ctypes.c_float) * 12
glBufferData(GL_UNIFORM_BUFFER, SPHERE_COUNT * size_material, None,
GL_STATIC_DRAW)
mat = glMapBufferRange(GL_UNIFORM_BUFFER, 0,
SPHERE_COUNT * size_material,
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT)
m = (GLfloat * 12 * SPHERE_COUNT).from_address(mat)
ambient = 0.002
for i in range(SPHERE_COUNT):
fi = 3.14159267 * i / 8.0
m[i][0:3] = (ctypes.c_float * 3)(sin(fi) * 0.5 + 0.5,
sin(fi + 1.345) * 0.5 + 0.5,
sin(fi + 2.567) * 0.5 + 0.5)
m[i][4:7] = (ctypes.c_float * 3)(2.8, 2.8, 2.9)
m[i][7] = 30
m[i][8:11] = (ctypes.c_float * 3)(ambient * 0.025, ambient * 0.025,
ambient * 0.025)
ambient *= 1.5
glUnmapBuffer(GL_UNIFORM_BUFFER)
def compile_program(vertex_source, fragment_source):
global mv_location
global proj_location
vertex_shader = None
fragment_shader = None
if vertex_source:
vertex_shader = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vertex_shader, vertex_source)
glCompileShader(vertex_shader)
if not glGetShaderiv(vertex_shader, GL_COMPILE_STATUS):
raise Exception(
'failed to compile shader "%s":\n%s' %
('vertex_shader', glGetShaderInfoLog(vertex_shader)))
if fragment_source:
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fragment_shader, fragment_source)
glCompileShader(fragment_shader)
if not glGetShaderiv(fragment_shader, GL_COMPILE_STATUS):
raise Exception(
'failed to compile shader "%s":\n%s' %
('fragment_shader', glGetShaderInfoLog(fragment_shader)))
program = glCreateProgram()
glAttachShader(program, vertex_shader)
glAttachShader(program, fragment_shader)
glLinkProgram(program)
mv_location = glGetUniformLocation(program, "mv_matrix")
proj_location = glGetUniformLocation(program, "proj_matrix")
vao = GLuint(0)
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
vertex_positions = [
-0.25, 0.25, -0.25, -0.25, -0.25, -0.25, 0.25, -0.25, -0.25, 0.25,
-0.25, -0.25, 0.25, 0.25, -0.25, -0.25, 0.25, -0.25, 0.25, -0.25,
-0.25, 0.25, -0.25, 0.25, 0.25, 0.25, -0.25, 0.25, -0.25, 0.25, 0.25,
0.25, 0.25, 0.25, 0.25, -0.25, 0.25, -0.25, 0.25, -0.25, -0.25, 0.25,
0.25, 0.25, 0.25, -0.25, -0.25, 0.25, -0.25, 0.25, 0.25, 0.25, 0.25,
0.25, -0.25, -0.25, 0.25, -0.25, -0.25, -0.25, -0.25, 0.25, 0.25,
-0.25, -0.25, -0.25, -0.25, 0.25, -0.25, -0.25, 0.25, 0.25, -0.25,
-0.25, 0.25, 0.25, -0.25, 0.25, 0.25, -0.25, -0.25, 0.25, -0.25, -0.25,
-0.25, -0.25, -0.25, -0.25, -0.25, 0.25, -0.25, 0.25, -0.25, 0.25,
0.25, -0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, -0.25, 0.25, 0.25,
-0.25, 0.25, -0.25
]
buffer = GLuint(0)
glGenBuffers(1, buffer)
glBindBuffer(GL_ARRAY_BUFFER, buffer)
#ar=numpy.array(vertex_positions, dtype='float32')
ar = array("f", vertex_positions)
glBufferData(GL_ARRAY_BUFFER, ar.tostring(), GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(0)
glEnable(GL_CULL_FACE)
glFrontFace(GL_CW)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LEQUAL)
return program
def __init__(self, width, height):
global quad_vao
global temp_tex
global color_tex
global depth_tex
global depth_fbo
global objects
self.width = width
self.height = height
load_shaders()
object_names = [
"dragon.sbm", "sphere.sbm", "cube.sbm", "cube.sbm", "cube.sbm"
]
object_colors = [
[1.0, 0.7, 0.8, 1.0],
[0.7, 0.8, 1.0, 1.0],
[0.3, 0.9, 0.4, 1.0],
[0.6, 0.4, 0.9, 1.0],
[0.8, 0.2, 0.1, 1.0],
]
for i in range(0, OBJECT_COUNT):
objects[i].obj.load(object_names[i])
objects[i].diffuse_albedo = object_colors[i]
glGenFramebuffers(1, depth_fbo)
glBindFramebuffer(GL_FRAMEBUFFER, depth_fbo)
depth_tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, depth_tex)
glTexStorage2D(GL_TEXTURE_2D, 11, GL_DEPTH_COMPONENT32F, FBO_SIZE,
FBO_SIZE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
color_tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, color_tex)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, FBO_SIZE, FBO_SIZE)
temp_tex = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, temp_tex)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, FBO_SIZE, FBO_SIZE)
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_tex, 0)
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, color_tex,
0)
glBindTexture(GL_TEXTURE_2D, 0)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glEnable(GL_DEPTH_TEST)
glGenVertexArrays(1, quad_vao)
glBindVertexArray(quad_vao)
overlay.init(80, 50)
overlay.clear()
overlay.drawText("Q: Increase focal distance", 0, 0)
overlay.drawText("A: Decrease focal distance", 0, 1)
overlay.drawText("W: Increase focal depth", 0, 2)
overlay.drawText("S: Decrease focal depth", 0, 3)
overlay.drawText("P: Pause", 0, 4)
def __init__(self, width, height):
global render_prog
global render_vao
global tex_alien_array
global rain_buffer
global droplet_x_offset, droplet_rot_speed, droplet_fall_speed
self.width = width
self.height = height
vs = GLuint(0)
fs = GLuint(0)
vs_source = '''
#version 410 core
layout (location = 0) in int alien_index;
out VS_OUT
{
flat int alien;
vec2 tc;
} vs_out;
struct droplet_t
{
float x_offset;
float y_offset;
float orientation;
float unused;
};
layout (std140) uniform droplets
{
droplet_t droplet[256];
};
void main(void)
{
const vec2[4] position = vec2[4](vec2(-0.5, -0.5),
vec2( 0.5, -0.5),
vec2(-0.5, 0.5),
vec2( 0.5, 0.5));
vs_out.tc = position[gl_VertexID].xy + vec2(0.5);
float co = cos(droplet[alien_index].orientation);
float so = sin(droplet[alien_index].orientation);
mat2 rot = mat2(vec2(co, so),
vec2(-so, co));
vec2 pos = 0.25 * rot * position[gl_VertexID];
gl_Position = vec4(pos.x + droplet[alien_index].x_offset,
pos.y + droplet[alien_index].y_offset,
0.5, 1.0);
vs_out.alien = alien_index % 64;
}
'''
fs_source = '''
#version 410 core
layout (location = 0) out vec4 color;
in VS_OUT
{
flat int alien;
vec2 tc;
} fs_in;
uniform sampler2DArray tex_aliens;
void main(void)
{
color = texture(tex_aliens, vec3(fs_in.tc, float(fs_in.alien)));
}
'''
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
glGetShaderInfoLog(vs)
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
glGetShaderInfoLog(vs)
render_prog = glCreateProgram()
glAttachShader(render_prog, vs)
glAttachShader(render_prog, fs)
glLinkProgram(render_prog)
glDeleteShader(vs)
glDeleteShader(fs)
glGetProgramInfoLog(render_prog)
glGenVertexArrays(1, render_vao)
glBindVertexArray(render_vao)
ktxobj = KTXObject()
tex_alien_array = ktxobj.ktx_load("aliens.ktx")
glBindTexture(GL_TEXTURE_2D_ARRAY, tex_alien_array)
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR)
glGenBuffers(1, rain_buffer)
glBindBuffer(GL_UNIFORM_BUFFER, rain_buffer)
glBufferData(GL_UNIFORM_BUFFER, 256 * 4 * 4, None, GL_DYNAMIC_DRAW)
for i in range(0, 256):
droplet_x_offset.append(random_float() * 2.0 - 1.0)
droplet_rot_speed.append(
(random_float() + 0.5) * (-3.0 if (i & 1) else 3.0))
droplet_fall_speed.append(random_float() + 0.2)
glBindVertexArray(render_vao)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def init(self, width, height, font=''):
vs = GLuint(0)
fs = GLuint(0)
self.buffer_width = width
self.buffer_height = height
vs = glCreateShader(GL_VERTEX_SHADER)
fs = glCreateShader(GL_FRAGMENT_SHADER)
vs_source = '''
#version 440 core
void main(void)
{
gl_Position = vec4(float((gl_VertexID >> 1) & 1) * 2.0 - 1.0,
float((gl_VertexID & 1)) * 2.0 - 1.0,
0.0, 1.0);
}
'''
fs_source = '''
#version 440 core
layout (origin_upper_left) in vec4 gl_FragCoord;
layout (location = 0) out vec4 o_color;
layout (binding = 0) uniform isampler2D text_buffer;
layout (binding = 1) uniform isampler2DArray font_texture;
void main(void)
{
ivec2 frag_coord = ivec2(gl_FragCoord.xy);
ivec2 char_size = textureSize(font_texture, 0).xy;
ivec2 char_location = frag_coord / char_size;
ivec2 texel_coord = frag_coord % char_size;
int character = texelFetch(text_buffer, char_location, 0).x;
float val = texelFetch(font_texture, ivec3(texel_coord, character), 0).x;
if (val == 0.0)
discard;
o_color = vec4(1.0);
}
'''
glShaderSource(vs, vs_source)
glCompileShader(vs)
glShaderSource(fs, fs_source)
glCompileShader(fs)
self.text_program = glCreateProgram()
glAttachShader(self.text_program, vs)
glAttachShader(self.text_program, fs)
glLinkProgram(self.text_program)
glDeleteShader(fs)
glDeleteShader(vs)
# glCreateVertexArrays(1, &vao);
glGenVertexArrays(1, self.vao)
glBindVertexArray(self.vao)
# glCreateTextures(GL_TEXTURE_2D, 1, &text_buffer);
self.text_buffer = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, self.text_buffer)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8UI, width, height)
if (font == ''):
font = "cp437_9x16.ktx"
self.font_texture = ktxobject.ktx_load(font)
self.screen_buffer = ['\0' for _ in range(width * height)]
def __init__(self, width, height):
global gbuffer_tex
global gbuffer
global fs_quad_vao
global light_ubo
global render_transform_ubo
global myobject
global tex_nm
global tex_diffuse
glGenFramebuffers(1, gbuffer)
glBindFramebuffer(GL_FRAMEBUFFER, gbuffer)
gbuffer_tex = [glGenTextures(1) for _ in range(3)]
glBindTexture(GL_TEXTURE_2D, gbuffer_tex[0])
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32UI, MAX_DISPLAY_WIDTH,
MAX_DISPLAY_HEIGHT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glBindTexture(GL_TEXTURE_2D, gbuffer_tex[1])
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, MAX_DISPLAY_WIDTH,
MAX_DISPLAY_HEIGHT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glBindTexture(GL_TEXTURE_2D, gbuffer_tex[2])
glTexStorage2D(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT32F,
MAX_DISPLAY_WIDTH, MAX_DISPLAY_HEIGHT)
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
gbuffer_tex[0], 0)
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1,
gbuffer_tex[1], 0)
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
gbuffer_tex[2], 0)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glGenVertexArrays(1, fs_quad_vao)
glBindVertexArray(fs_quad_vao)
myobject.load("ladybug.sbm")
tex_nm = ktxobject.ktx_load("ladybug_nm.ktx")
tex_diffuse = ktxobject.ktx_load("ladybug_co.ktx")
load_shaders()
light_ubo = glGenBuffers(1)
glBindBuffer(GL_UNIFORM_BUFFER, light_ubo)
size_light_t = ctypes.sizeof(ctypes.c_float) * 6
glBufferData(GL_UNIFORM_BUFFER, NUM_LIGHTS * size_light_t, None,
GL_DYNAMIC_DRAW)
render_transform_ubo = glGenBuffers(1)
glBindBuffer(GL_UNIFORM_BUFFER, render_transform_ubo)
glBufferData(GL_UNIFORM_BUFFER,
(2 + NUM_INSTANCES) * glm.sizeof(glm.mat4), None,
GL_DYNAMIC_DRAW)
def __init__(self, width, height):
global program
global vao
global tex_checker
global uniforms
vs_source = '''
#version 410 core
out VS_OUT
{
vec2 tc;
noperspective vec2 tc_np;
} vs_out;
uniform mat4 mvp;
void main(void)
{
const vec4 vertices[] = vec4[](vec4(-0.5, -0.5, 0.0, 1.0),
vec4( 0.5, -0.5, 0.0, 1.0),
vec4(-0.5, 0.5, 0.0, 1.0),
vec4( 0.5, 0.5, 0.0, 1.0));
vec2 tc = (vertices[gl_VertexID].xy + vec2(0.5));
vs_out.tc = tc;
vs_out.tc_np = tc;
gl_Position = mvp * vertices[gl_VertexID];
}
'''
fs_source = '''
#version 410 core
out vec4 color;
uniform sampler2D tex_checker;
uniform bool use_perspective = true;
in VS_OUT
{
vec2 tc;
noperspective vec2 tc_np;
} fs_in;
void main(void)
{
vec2 tc = mix(fs_in.tc_np, fs_in.tc, bvec2(use_perspective));
color = texture(tex_checker, tc).rrrr;
}
'''
buffer = ''
program = glCreateProgram()
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
glGetShaderInfoLog(vs)
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
glGetShaderInfoLog(fs)
glAttachShader(program, vs)
glAttachShader(program, fs)
glLinkProgram(program)
uniforms.mvp = glGetUniformLocation(program, "mvp")
uniforms.use_perspective = glGetUniformLocation(
program, "use_perspective")
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
checker_data = np.array([
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
0xFF,
0x00,
],
dtype=np.ubyte) # unsigned char
tex_checker = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, tex_checker)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8, 8, 8)
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 8, 8, GL_RED, GL_UNSIGNED_BYTE,
checker_data)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
def __init__(self, width, height):
global program
global mv_location
global mvp_location
global stretch_location
global vao
global buffer
vs_source = '''
// Vertex Shader
// OpenGL SuperBible
#version 410 core
// Incoming per vertex... position and normal
in vec4 vVertex;
void main(void)
{
gl_Position = vVertex;
}
'''
gs_source = '''
// Geometry Shader
// Graham Sellers
// OpenGL SuperBible
#version 410 core
layout (triangles) in;
layout (triangle_strip, max_vertices = 12) out;
uniform float stretch = 0.7;
flat out vec4 color;
uniform mat4 mvpMatrix;
uniform mat4 mvMatrix;
void make_face(vec3 a, vec3 b, vec3 c)
{
vec3 face_normal = normalize(cross(c - a, c - b));
vec4 face_color = vec4(1.0, 0.4, 0.7, 1.0) * (mat3(mvMatrix) * face_normal).z;
gl_Position = mvpMatrix * vec4(a, 1.0);
color = face_color;
EmitVertex();
gl_Position = mvpMatrix * vec4(b, 1.0);
color = face_color;
EmitVertex();
gl_Position = mvpMatrix * vec4(c, 1.0);
color = face_color;
EmitVertex();
EndPrimitive();
}
void main(void)
{
int n;
vec3 a = gl_in[0].gl_Position.xyz;
vec3 b = gl_in[1].gl_Position.xyz;
vec3 c = gl_in[2].gl_Position.xyz;
vec3 d = (a + b) * stretch;
vec3 e = (b + c) * stretch;
vec3 f = (c + a) * stretch;
a *= (2.0 - stretch);
b *= (2.0 - stretch);
c *= (2.0 - stretch);
make_face(a, d, f);
make_face(d, b, e);
make_face(e, c, f);
make_face(d, e, f);
EndPrimitive();
}
'''
fs_source = '''
// Fragment Shader
// Graham Sellers
// OpenGL SuperBible
#version 410 core
flat in vec4 color;
out vec4 output_color;
void main(void)
{
output_color = color;
}
'''
program = glCreateProgram()
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, vs_source)
glCompileShader(vs)
gs = glCreateShader(GL_GEOMETRY_SHADER)
glShaderSource(gs, gs_source)
glCompileShader(gs)
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, fs_source)
glCompileShader(fs)
glAttachShader(program, vs)
glAttachShader(program, gs)
glAttachShader(program, fs)
glLinkProgram(program)
mv_location = glGetUniformLocation(program, "mvMatrix")
mvp_location = glGetUniformLocation(program, "mvpMatrix")
stretch_location = glGetUniformLocation(program, "stretch")
tetrahedron_verts = np.array([
0.000, 0.000, 1.000, 0.943, 0.000, -0.333, -0.471, 0.816, -0.333,
-0.471, -0.816, -0.333
],
dtype=np.float32)
tetrahedron_indices = np.array([0, 1, 2, 0, 2, 3, 0, 3, 1, 3, 2, 1],
dtype=np.uint16)
size_t_verts = ctypes.sizeof(ctypes.c_float) * len(tetrahedron_verts)
size_t_indices = ctypes.sizeof(
ctypes.c_ushort) * len(tetrahedron_indices)
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
glGenBuffers(1, buffer)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, size_t_verts + size_t_indices,
None, GL_STATIC_DRAW)
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, size_t_indices,
tetrahedron_indices)
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, size_t_indices, size_t_verts,
tetrahedron_verts)
glBindBuffer(GL_ARRAY_BUFFER, buffer)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0,
ctypes.c_void_p(size_t_indices))
glEnableVertexAttribArray(0)
glEnable(GL_CULL_FACE)
#// glDisable(GL_CULL_FACE)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LEQUAL)
def run():
#Start OpenGL and ask it for an OpenGL context
pygame.init()
clock = pygame.time.Clock()
screen = pygame.display.set_mode(SCREEN_SIZE, pygame.HWSURFACE|pygame.OPENGL|pygame.DOUBLEBUF)
#The first thing we do is print some OpenGL details and check that we have a good enough version
print("OpenGL Implementation Details:")
if glGetString(GL_VENDOR):
print("\tGL_VENDOR: {}".format(glGetString(GL_VENDOR).decode()))
if glGetString(GL_RENDERER):
print("\tGL_RENDERER: {}".format(glGetString(GL_RENDERER).decode()))
if glGetString(GL_VERSION):
print("\tGL_VERSION: {}".format(glGetString(GL_VERSION).decode()))
if glGetString(GL_SHADING_LANGUAGE_VERSION):
print("\tGL_SHADING_LANGUAGE_VERSION: {}".format(glGetString(GL_SHADING_LANGUAGE_VERSION).decode()))
major_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[0])
minor_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[1])
if major_version < 3 or (major_version < 3 and minor_version < 0):
print("OpenGL version must be at least 3.0 (found {0})".format(glGetString(GL_VERSION).decode().split()[0]))
#Now onto the OpenGL initialisation
#Set up depth culling
glEnable(GL_CULL_FACE)
glEnable(GL_DEPTH_TEST)
glDepthMask(GL_TRUE)
glDepthFunc(GL_LEQUAL)
glDepthRange(0.0, 1.0)
#We create out shaders which do little more than set a flat colour for each face
VERTEX_SHADER = shaders.compileShader(b"""
#version 130
in vec4 position;
in vec4 normal;
uniform mat4 projectionMatrix;
uniform mat4 viewMatrix;
uniform mat4 modelMatrix;
flat out float theColor;
void main()
{
vec4 temp = modelMatrix * position;
temp = viewMatrix * temp;
gl_Position = projectionMatrix * temp;
theColor = clamp(abs(dot(normalize(normal.xyz), normalize(vec3(0.9,0.1,0.5)))), 0, 1);
}
""", GL_VERTEX_SHADER)
FRAGMENT_SHADER = shaders.compileShader(b"""
#version 130
flat in float theColor;
out vec4 outputColor;
void main()
{
outputColor = vec4(1.0, 0.5, theColor, 1.0);
}
""", GL_FRAGMENT_SHADER)
shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)
#And then grab our attribute locations from it
glBindAttribLocation(shader, 0, b"position")
glBindAttribLocation(shader, 1, b"normal")
#Create the Vertex Array Object to hold our volume mesh
vertexArrayObject = GLuint(0)
glGenVertexArrays(1, vertexArrayObject)
glBindVertexArray(vertexArrayObject)
#Create the index buffer object
indexPositions = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER, usage=GL_STATIC_DRAW)
#Create the VBO
vertexPositions = vbo.VBO(vertices, usage=GL_STATIC_DRAW)
#Bind our VBOs and set up our data layout specifications
with indexPositions, vertexPositions:
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(0*vertices.dtype.itemsize))
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(3*vertices.dtype.itemsize))
glBindVertexArray(0)
glDisableVertexAttribArray(0)
#Now grab out transformation martix locations
modelMatrixUnif = glGetUniformLocation(shader, b"modelMatrix")
viewMatrixUnif = glGetUniformLocation(shader, b"viewMatrix")
projectionMatrixUnif = glGetUniformLocation(shader, b"projectionMatrix")
modelMatrix = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f')
viewMatrix = np.array([[1.0,0.0,0.0,0.0],[0.0,1.0,0.0,0.0],[0.0,0.0,1.0,-50.0],[0.0,0.0,0.0,1.0]], dtype='f')
projectionMatrix = np.array([[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], dtype='f')
#These next few lines just set up our camera frustum
fovDeg = 45.0
frustumScale = 1.0 / tan(radians(fovDeg) / 2.0)
zNear = 1.0
zFar = 1000.0
projectionMatrix[0][0] = frustumScale
projectionMatrix[1][1] = frustumScale
projectionMatrix[2][2] = (zFar + zNear) / (zNear - zFar)
projectionMatrix[2][3] = -1.0
projectionMatrix[3][2] = (2 * zFar * zNear) / (zNear - zFar)
#viewMatrix and projectionMatrix don't change ever so just set them once here
with shader:
glUniformMatrix4fv(projectionMatrixUnif, 1, GL_TRUE, projectionMatrix)
glUniformMatrix4fv(viewMatrixUnif, 1, GL_TRUE, viewMatrix)
#These are used to track the rotation of the volume
LastFrameMousePos = (0,0)
CurrentMousePos = (0,0)
xRotation = 0
yRotation = 0
while True:
clock.tick()
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE:
return
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
CurrentMousePos = event.pos
LastFrameMousePos = CurrentMousePos
if event.type == pygame.MOUSEMOTION and 1 in event.buttons:
CurrentMousePos = event.pos
diff = (CurrentMousePos[0] - LastFrameMousePos[0], CurrentMousePos[1] - LastFrameMousePos[1])
xRotation += event.rel[0]
yRotation += event.rel[1]
LastFrameMousePos = CurrentMousePos
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
#Perform the rotation of the mesh
moveToOrigin = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f')
rotateAroundX = np.array([[1.0,0.0,0.0,0.0],[0.0,cos(radians(yRotation)),-sin(radians(yRotation)),0.0],[0.0,sin(radians(yRotation)),cos(radians(yRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f')
rotateAroundY = np.array([[cos(radians(xRotation)),0.0,sin(radians(xRotation)),0.0],[0.0,1.0,0.0,0.0],[-sin(radians(xRotation)),0.0,cos(radians(xRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f')
modelMatrix = rotateAroundY.dot(rotateAroundX.dot(moveToOrigin))
with shader:
glUniformMatrix4fv(modelMatrixUnif, 1, GL_TRUE, modelMatrix)
glBindVertexArray(vertexArrayObject)
glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None)
glBindVertexArray(0)
# Show the screen
pygame.display.flip()
