def setAttributes(self, data):
self.data = data
self.dataLen = data.shape[0]
# Make this buffer the default one
gl.glBindVertexArray(self.VAO)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
# Upload data
gl.glBufferData(gl.GL_ARRAY_BUFFER, data.nbytes, data, gl.GL_DYNAMIC_DRAW)
offset = 0
for i, name in enumerate(data.dtype.names):
# import ipdb; ipdb.set_trace()
stride = data[name].strides[0]
if data[name].ndim == 1:
size = 1
else:
size = data[name].shape[1]
loc = gl.glGetAttribLocation(self.program, name)
# remember these properties for later updating of buffer
self.attribute_layout[name] = {'offset':offset}
gl.glVertexAttribPointer(loc, size, gl.GL_FLOAT, False, stride, ctypes.c_void_p(offset))
gl.glEnableVertexAttribArray(loc)
offset += data.dtype[name].itemsize
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glBindVertexArray(0)
# ensure correct mask is rendered:
self.setMask()
def display():
global offsetUniform, theProgram
GL.glClearColor(0.0, 0.0, 0.0, 0.0)
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glUseProgram(theProgram)
GL.glUniform2f(offsetUniform, 0.5, 0.5)
colorData = sizeOfFloat*len(vertexData)/2
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBufferObject)
positionLocation = GL.glGetAttribLocation(theProgram, 'position')
colorLocation = GL.glGetAttribLocation(theProgram, 'color')
GL.glEnableVertexAttribArray(positionLocation)
GL.glVertexAttribPointer(positionLocation,
4,
GL.GL_FLOAT, False, 0, null)
GL.glEnableVertexAttribArray(colorLocation)
GL.glVertexAttribPointer(colorLocation,
4,
GL.GL_FLOAT, False, 0, c_void_p(colorData))
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 36)
GL.glDisableVertexAttribArray(positionLocation)
GL.glDisableVertexAttribArray(colorLocation)
GL.glUseProgram(0)
def init_vertex_buf(self):
self.vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER,self.vbo)
array_type = (GL.GLfloat*len(VERTICES))
GL.glBufferData(GL.GL_ARRAY_BUFFER,len(VERTICES)*SIZE_FLOAT,
array_type(*VERTICES),GL.GL_STATIC_DRAW)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER,0)
def initializeGL(self):
gl.glClearColor(1.0,1.0,1.0,0.0)
# gl.glColor3f(0.0,0.0, 0.0)
# gl.glPointSize(4.0)
# gl.glMatrixMode(gl.GL_PROJECTION)
# gl.glLoadIdentity()
# glu.gluOrtho2D(0.0,640.0,0.0,480.0)
gl.glViewport (0, 0, 800, 600)
gl.glClearColor (0.0, 0.5, 0.5, 1.0)
gl.glEnableClientState (gl.GL_VERTEX_ARRAY)
self._vertices, self._normals = util.load_obj("monkey.obj")
self._vbo = gl.glGenBuffers(1)
gl.glBindBuffer (gl.GL_ARRAY_BUFFER, self._vbo)
gl.glBufferData (gl.GL_ARRAY_BUFFER, self._vertices.size*4,
self._vertices, gl.GL_STATIC_DRAW)
self._normal_vbo = gl.glGenBuffers(1)
gl.glBindBuffer (gl.GL_ARRAY_BUFFER, self._normal_vbo)
gl.glBufferData (gl.GL_ARRAY_BUFFER, self._normals.size*4,
self._normals, gl.GL_STATIC_DRAW)
self._shader_program = shader.LoadShaders("shader8.vs",
"shader8.ps")
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LESS)
def init(self):
self.vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(self.vao)
self.initializeProgram()
self.initializeVertexBuffer()
colorDataOffset = 3*self.float_size*self.numberOfVertices
GL.glBindBuffer(GL.GL_ARRAY_BUFFER,self.vertexBufferObject)
GL.glEnableVertexAttribArray(0)
GL.glEnableVertexAttribArray(1)
GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None)
GL.glVertexAttribPointer(1, 4, GL.GL_FLOAT, GL.GL_FALSE, 0, GL.GLvoidp(colorDataOffset))
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER,self.indexBufferObject)
GL.glBindVertexArray(0)
GL.glEnable(GL.GL_CULL_FACE)
GL.glCullFace(GL.GL_BACK)
GL.glFrontFace(GL.GL_CW)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glDepthMask(GL.GL_TRUE)
GL.glDepthFunc(GL.GL_LESS)
GL.glDepthRange(0.0, 1.0)
def initializeGL(self):
"""
Create the graphic buffers and compile the shaders.
"""
# Create and bind a new VAO (Vertex Array Object).
self.vertex_array_object = gl.glGenVertexArrays(1)
gl.glBindVertexArray(self.vertex_array_object)
# Upload color values (one for each triangle vertex) in RGB format.
colBuf = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, colBuf)
col = np.array([1,0,0,0,1,0,0,0,1], dtype=np.float32)
gl.glBufferData(gl.GL_ARRAY_BUFFER, col, gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
gl.glEnableVertexAttribArray(0)
# Create and bind GPU buffer for vertex data.
self.vertexBuffer = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vertexBuffer)
# Associate the vertex buffer with the "Layout 0" shader variable (look
# for "v_N" variable in vertex shader program).
gl.glVertexAttribPointer(1, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
gl.glEnableVertexAttribArray(1)
# Enable depth-sorting.
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LESS)
# Background color.
gl.glClearColor(0, 0, 0, 0)
# Compile- and install shader programs.
self.shaders = self.linkShaders('blog4.vs', 'blog4.fs')
gl.glUseProgram(self.shaders)
def paintGL(self):
# clear the buffer
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
# Run the compute phase
i = 0
while (i * MAX_WORKGROUPS < self.count):
upper = min(self.count, (i+1) * MAX_WORKGROUPS)
data = self.valueBuffer[i*MAX_WORKGROUPS:upper]
status = self.statusBuffer[i*MAX_WORKGROUPS:upper]
gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 0, self.ssbos['data'])
gl.glBufferData(gl.GL_SHADER_STORAGE_BUFFER,
data.nbytes,
data, gl.GL_DYNAMIC_COPY)
gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 1, self.ssbos['status'])
gl.glBufferData(gl.GL_SHADER_STORAGE_BUFFER,
status.nbytes,
status, gl.GL_DYNAMIC_COPY)
gl.glUseProgram(self.compute_program)
gl.glDispatchCompute(min(MAX_WORKGROUPS, self.count - i * MAX_WORKGROUPS), 1, 1)
gl.glMemoryBarrier(gl.GL_SHADER_STORAGE_BARRIER_BIT)
# Read back the modified data.
gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 0, self.ssbos['data'])
gl.glGetBufferSubData(gl.GL_SHADER_STORAGE_BUFFER,
0,
data.nbytes,
self.valueBuffer[i*MAX_WORKGROUPS])
gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 1, self.ssbos['status'])
gl.glGetBufferSubData(gl.GL_SHADER_STORAGE_BUFFER,
0,
status.nbytes,
self.statusBuffer[i*MAX_WORKGROUPS])
i += 1
self.iterations += ITER_PER_CYCLE
# bind the VBO
self.vbo.bind()
# tell OpenGL that the VBO contains an array of vertices
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
# these vertices contain 2 single precision coordinates
gl.glVertexPointer(2, gl.GL_FLOAT, 0, self.vbo)
# Bind statuses
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.ssbos['status'])
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.statusBuffer.nbytes,
self.statusBuffer, gl.GL_DYNAMIC_COPY)
gl.glVertexAttribIPointer(1, 2, gl.GL_INT, 0, None)
gl.glEnableVertexAttribArray(1);
# Use our pipeline.
gl.glUseProgram(self.render_program)
# draw "count" points from the VBO
gl.glDrawArrays(gl.GL_POINTS, 0, self.count)
# Update the window title.
self.parent().setWindowTitle("Iterations: %d; zoom; %f" % (self.iterations, self.zoom))
def bind(self):
assert threading.current_thread() is threading.main_thread()
if self.length:
self.unbind()
if self.glsl_dtype == "vec4":
size, dtype = 4, gl.GL_FLOAT
elif self.glsl_dtype == "vec3":
size, dtype = 3, gl.GL_FLOAT
elif self.glsl_dtype == "vec2":
size, dtype = 2, gl.GL_FLOAT
elif self.glsl_dtype == "float":
size, dtype = 1, gl.GL_FLOAT
else:
raise TypeError(self.glsl_dtype)
self.verify_dtype()
self.store.bind()
offset = self.store.offset
stride = self.store.strides[0]
buf = self.store.opengl_id
loc = gl.glGetAttribLocation(self.shader_program, self.attribute)
if loc == -1:
print("WARNING: unused attribute '%s'" % self.attribute)
self.enabled = False
else:
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf)
gl.glVertexAttribPointer(loc, size, dtype, False, stride, ctypes.c_void_p(offset))
if self.instanced:
gl.glVertexAttribDivisor(loc,1)
self.enabled = True
self.length = self.store.shape[0]
def __init__(self, vertices, indices, draw_method):
from . import SHORT_SIZE, FLOAT_SIZE
self.draw_method = draw_method
self.indices = indices
self.vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(self.vao)
vertexBufferObject = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBufferObject)
array_type = (GL.GLfloat*len(vertices))
GL.glBufferData(
GL.GL_ARRAY_BUFFER,
len(vertices)*FLOAT_SIZE,
array_type(*vertices),
GL.GL_STATIC_DRAW)
GL.glEnableVertexAttribArray(0)
GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None)
indexBufferObject = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indexBufferObject)
array_type = (GL.GLushort*len(self.indices))
GL.glBufferData(
GL.GL_ELEMENT_ARRAY_BUFFER,
len(self.indices)*SHORT_SIZE,
array_type(*self.indices),
GL.GL_STATIC_DRAW)
GL.glBindVertexArray(0)
def initializeGL(self):
"""Initialize OpenGL, VBOs, upload data on the GPU, etc."""
# background color
gl.glClearColor(0.8, 0.8, 0.8, 0)
# Make initial data array.
# compile the vertex shader
vs = compile_shader(VERTEX, gl.GL_VERTEX_SHADER)
# compile the geometry shader
gs = compile_shader(GEOMETRY, gl.GL_GEOMETRY_SHADER)
# compile the fragment shader
fs = compile_shader(FRAGMENT, gl.GL_FRAGMENT_SHADER)
# Link the programs.
self.render_program = link_shaders(vs, gs, fs)
# Compile the compute shader
cs = compile_shader(COMPUTE, gl.GL_COMPUTE_SHADER)
# Create the compute shader buffers.
self.makeBuffers()
#self.vbo = glvbo.VBO(self.attributes)
self.vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.attributes.nbytes,
self.attributes, gl.GL_DYNAMIC_COPY)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
self.ssbo = gl.glGenBuffers(1)
gl.glBindBufferBase(gl.GL_SHADER_STORAGE_BUFFER, 1, self.ssbo)
gl.glBufferData(gl.GL_SHADER_STORAGE_BUFFER, self.velocities.nbytes,
self.velocities, gl.GL_DYNAMIC_COPY)
self.compute_program = link_shaders(cs)
def build_buffer(program, data, data_usage=gl.GL_STATIC_DRAW, buffer_target=gl.GL_ARRAY_BUFFER):
# with use_program(program):
buffer = gl.glGenBuffers(1)
gl.glBindBuffer(buffer_target, buffer)
gl.glBufferData(buffer_target, data.nbytes, data, data_usage)
gl.glBindBuffer(buffer_target, 0)
return buffer
def bind_attrib(self, attrib_id, size, data, storagetype=gl.GL_STATIC_DRAW, instance_divisor=0, datatype=gl.GL_FLOAT, stride=0, offset=None, normalize=False):
if RenderObject.bound_vao is not self.vao_id:
gl.glBindVertexArray(self.vao_id)
RenderObject.bound_vao = self.vao_id
# Keep track of max instance divisor
self.max_instance_divisor = max(instance_divisor, self.max_instance_divisor)
# If the input is an array create a new GL buffer, otherwise assume the buffer already exists and a buffer ID is passed
if type(data) is np.ndarray:
# Get an index to one new buffer in GPU mem, bind it, and copy the array data to it
buf_id = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf_id)
gl.glBufferData(gl.GL_ARRAY_BUFFER, data.nbytes, data, storagetype)
else:
# Assume that a GLuint is passed which means that the buffer is already in GPU memory
buf_id = data
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buf_id)
# Assign this buffer to one of the attributes in the shader
gl.glEnableVertexAttribArray(attrib_id)
gl.glVertexAttribPointer(attrib_id, size, datatype, normalize, stride, offset)
# For instanced data, indicate per how many instances we move a step in the buffer (1=per instance)
if instance_divisor > 0:
gl.glVertexAttribDivisor(attrib_id, instance_divisor)
# Clean up
gl.glDisableVertexAttribArray(attrib_id)
self.enabled_attributes[attrib_id] = [size, buf_id, instance_divisor, datatype]
return buf_id
def _make_gl_selection_box(self):
""" Creates the Vertex Array Object, Vertex Buffer Objects and fill the
shaders with the data of the corresponding points. Since we will use
two kind of drawing methods, lines and triangles, the index buffer
will set to GL_DYNAMIC_DRAW, so as the coordinates, but not the
colors, which will be set as GL_STATIC_DRAW.
"""
self.vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(self.vao)
ind_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ind_vbo)
GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, self.indexes.itemsize*int(len(self.indexes)), self.indexes, GL.GL_DYNAMIC_DRAW)
coord_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, coord_vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, self.points.itemsize*int(len(self.points)), self.points, GL.GL_DYNAMIC_DRAW)
att_position = GL.glGetAttribLocation(self.selection_box_program, 'vert_coord')
GL.glEnableVertexAttribArray(att_position)
GL.glVertexAttribPointer(att_position, 2, GL.GL_FLOAT, GL.GL_FALSE, 2*self.points.itemsize, ctypes.c_void_p(0))
col_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, col_vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, self.color.itemsize*int(len(self.color)), self.color, GL.GL_STATIC_DRAW)
att_colors = GL.glGetAttribLocation(self.selection_box_program, 'vert_color')
GL.glEnableVertexAttribArray(att_colors)
GL.glVertexAttribPointer(att_colors, 3, GL.GL_FLOAT, GL.GL_FALSE, 3*self.color.itemsize, ctypes.c_void_p(0))
GL.glBindVertexArray(0)
GL.glDisableVertexAttribArray(att_position)
GL.glDisableVertexAttribArray(att_colors)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0)
self.buffers = (ind_vbo, coord_vbo, col_vbo)
def initializeGL(self):
""" Set OpenGL variables """
self.qglClearColor(QtGui.QColor(250,250,250,255))
#GL.glShadeModel(GL.GL_FLAT)
GL.glShadeModel(GL.GL_SMOOTH)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_POINT_SMOOTH )
#GL.glEnable(GL.GL_CULL_FACE)
# Creates the pixel buffer object for the background and loads image data into it
self.pbo = long(GL.glGenBuffers(1))
GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, self.pbo)
if self.str:
GL.glBufferData(GL.GL_PIXEL_UNPACK_BUFFER, self.str.current(), GL.GL_DYNAMIC_DRAW)
# Creates the texture object for the background
self.texid = long(GL.glGenTextures(1))
GL.glBindTexture(GL.GL_TEXTURE_2D, self.texid)
GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST)
GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST)
GL.glPixelStorei(GL.GL_UNPACK_ALIGNMENT,1)
# Loads image data from the PBO to the texture object
if self.str:
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, 3, self.str.width, self.str.height, 0, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, GL.GLvoid)
# Unbinds everything
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, 0)
def setBackground(self, aStreamer=None):
""" Sets an streamer object as the one who provides the background image """
self.str = aStreamer
if self.str:
GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, self.pbo)
GL.glBufferData(GL.GL_PIXEL_UNPACK_BUFFER, self.str.current(), GL.GL_DYNAMIC_DRAW)
GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, 0)
def sync(self):
# Sync the buffer with the graphics hardware if the buffer is dirty
if self.status == 'synced': return
size = self.stride * self.count
gl.glBindBuffer(self.target, self.id)
gl.glBufferData(self.target, size, self.element, self.usage)
self.status = 'synced'
def updateBackground(self):
""" Updates the Background image """
if self.str:
GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, self.pbo)
GL.glBufferSubData( GL.GL_PIXEL_UNPACK_BUFFER , 0 , self.str.current())
GL.glBindBuffer(GL.GL_PIXEL_UNPACK_BUFFER, 0)
self.updateGL()
def change_vbo_colors (col_vbo = None, colors = [], program = None):
""" Function doc """
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, col_vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, colors.itemsize*int(len(colors)), colors, GL.GL_STATIC_DRAW)
att_colors = GL.glGetAttribLocation(program, 'vert_color')
GL.glEnableVertexAttribArray(att_colors)
GL.glVertexAttribPointer(att_colors, 3, GL.GL_FLOAT, GL.GL_FALSE, 3*colors.itemsize, ctypes.c_void_p(0))
def __init__(self, vertices, normals, indices, draw_method):
self.draw_method = draw_method
self.indices = indices
self.vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(self.vao)
vertexBufferObject = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBufferObject)
data = vertices + normals
array_type = (GL.GLfloat*len(data))
GL.glBufferData(
GL.GL_ARRAY_BUFFER,
len(data)*FLOAT_SIZE,
array_type(*data),
GL.GL_STATIC_DRAW)
GL.glEnableVertexAttribArray(0)
GL.glEnableVertexAttribArray(1)
GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None)
GL.glVertexAttribPointer(1, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, GL.GLvoidp(len(vertices)*FLOAT_SIZE))
indexBufferObject = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indexBufferObject)
array_type = (GL.GLuint*len(self.indices))
GL.glBufferData(
GL.GL_ELEMENT_ARRAY_BUFFER,
len(self.indices)*FLOAT_SIZE,
array_type(*self.indices),
GL.GL_STATIC_DRAW)
GL.glBindVertexArray(0)
def draw_grid(self,):
gl.glUseProgram(self.simple_object_shader)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LESS)
gl.glBindVertexArray(self.grid_vao)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.grid_vbo)
vProjection = gl.glGetUniformLocation(self.simple_object_shader, 'vProjection')
vPosisition = gl.glGetAttribLocation(self.simple_object_shader, "vPosisition")
vColor = gl.glGetAttribLocation(self.simple_object_shader, "vColor")
vCamera = gl.glGetUniformLocation(self.simple_object_shader, 'vCamera')
gl.glUniformMatrix4fv(vProjection, 1, gl.GL_FALSE, self.projection_matrix_function())
gl.glUniformMatrix4fv(vCamera, 1, gl.GL_FALSE, self.camera_matrix_function())
gl.glEnableVertexAttribArray(vPosisition)
gl.glEnableVertexAttribArray(vColor)
gl.glVertexAttribPointer(vPosisition, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
gl.glVertexAttribPointer(vColor, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, ctypes.c_void_p(self.grid_size * 4))
gl.glDrawArrays(gl.GL_TRIANGLES, 0, self.grid_size / 4)
def create_object(shader):
# Create a new VAO (Vertex Array Object) and bind it
vertex_array_object = GL.glGenVertexArrays(1)
GL.glBindVertexArray( vertex_array_object )
# Generate buffers to hold our vertices
vertex_buffer = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertex_buffer)
# Get the position of the 'position' in parameter of our shader and bind it.
position = GL.glGetAttribLocation(shader, 'position')
GL.glEnableVertexAttribArray(position)
coord = GL.glGetAttribLocation(shader, 'coord')
GL.glEnableVertexAttribArray(coord)
# Describe the 'position' data layout in the buffer
GL.glVertexAttribPointer(position, 2, GL.GL_FLOAT, False, 16, GL.GLvoidp(0))
GL.glVertexAttribPointer(coord, 2, GL.GL_FLOAT, False, 16, GL.GLvoidp(8))
# Send the data over to the buffer
GL.glBufferData(GL.GL_ARRAY_BUFFER, 96, vertices, GL.GL_STATIC_DRAW)
# Unbind the VAO first (Important)
GL.glBindVertexArray(0)
# Unbind other stuff
GL.glDisableVertexAttribArray(position)
GL.glDisableVertexAttribArray(coord)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
return vertex_array_object
def bind(self): GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vboID) # Select vbo GL.glVertexAttribPointer(0, # Attribute number in this Vertex Array Object (VAO) 3, # This attribute uses 3 elements. I could make this adaptive and probably will. GL.GL_FLOAT, # These values are of type "GL_FLOAT" GL.GL_FALSE, # These values will not be normalized (made to range between 0.0 and 1.0) 8*4, # Bits per row. n*elements * bits/element. verts: 3, norms: 3, uv-coords: 2, floats: 4 bit ct.c_void_p(0)) # Where (in bits) in each row does this attribute start?) GL.glEnableVertexAttribArray(0) # Enable VBO, assign it to VAO at location = 0 GL.glVertexAttribPointer(1, # Attribute number in this Vertex Array Object (VAO) 3, # This attribute uses 3 elements. I could make this adaptive and probably will. GL.GL_FLOAT, # These values are of type "GL_FLOAT" GL.GL_FALSE, # These values will not be normalized (made to range between 0.0 and 1.0) 8*4, # Bits per row. n*elements * bits/element. verts: 3, norms: 3, uv-coords: 2, floats: 4 bit ct.c_void_p(3*4)) # Where (in bits) in each row does this attribute start?) GL.glEnableVertexAttribArray(1) # Enable VBO, assign it to VAO at location = 1 GL.glVertexAttribPointer(2, # Attribute number in this Vertex Array Object (VAO) 2, # This attribute uses 3 elements. I could make this adaptive and probably will. GL.GL_FLOAT, # These values are of type "GL_FLOAT" GL.GL_FALSE, # These values will not be normalized (made to range between 0.0 and 1.0) 8*4, # Bits per row. n*elements * bits/element. verts: 3, norms: 3, uv-coords: 2, floats: 4 bit ct.c_void_p(6*4)) # Where (in bits) in each row does this attribute start?) GL.glEnableVertexAttribArray(2) # Enable VBO, assign it to VAO at location = 2 GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, self.iboID) # Select ibo GL.glDrawElements( GL.GL_TRIANGLES, self.nindices, GL.GL_UNSIGNED_INT, ct.c_void_p(0))
def map(self):
try:
gl.glBindBuffer(gl.GL_UNIFORM_BUFFER, self.ubo)
self.vp = gl.glMapBuffer(gl.GL_UNIFORM_BUFFER, gl.GL_WRITE_ONLY)
except Exception, e:
print "ubo: %s" % str(self.ubo)
raise
def draw(self, **frame_data):
view = frame_data.get('view_matrix', None)
projection = frame_data.get('projection_matrix', None)
if self._before_draw:
self._before_draw(self, frame_data)
if view is not None:
self.world_matrix.dot(view, out=self._modelview)
self._normal[:] = np.linalg.inv(self._modelview[:3,:3].T)
for material, prims in self.primitives.items():
material.use(u_view=view, u_projection=projection, u_modelview=self._modelview,
u_modelview_inverse_transpose=self._normal, u_model=self.world_matrix,
frame_data=frame_data)
technique = material.technique
for prim in prims:
gl.glBindVertexArray(prim.vaos[technique])
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, prim.index_buffer)
gl.glDrawElements(prim.mode, prim.indices.size, DTYPE_COMPONENT_TYPE[prim.indices.dtype],
c_void_p(0))
if CHECK_GL_ERRORS:
err = gl.glGetError()
if err != gl.GL_NO_ERROR:
raise Exception('error drawing primitive elements: %d' % err)
gl.glBindVertexArray(0)
# for location in technique.attribute_locations.values():
# gl.glDisableVertexAttribArray(location)
material.release()
material.technique.release()
if self._after_draw:
self._after_draw(self, frame_data)
super().draw(**frame_data)
def element_buffer(self, value):
if value.dtype.base not in element_buffer_dtypes:
raise ValueError("Invalid dtype for an element buffer")
with self:
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, value.handle)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0)
self._element_buffer = value
def draw_text(self, text, color=(1.0, 1.0, 1.0, 0.0),
view_matrix=None, projection_matrix=None):
gl.glUseProgram(self._program_id)
gl.glActiveTexture(gl.GL_TEXTURE0+0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self._texture_id)
gl.glBindSampler(0, self._sampler_id)
gl.glUniform1i(self._uniform_locations['u_fonttex'], 0)
gl.glUniform4f(self._uniform_locations['u_color'], *color)
if view_matrix is not None:
self._matrix.dot(view_matrix, out=self._modelview_matrix)
gl.glUniformMatrix4fv(self._uniform_locations['u_modelviewMatrix'], 1, False, self._modelview_matrix)
if projection_matrix is not None:
gl.glUniformMatrix4fv(self._uniform_locations['u_projectionMatrix'], 1, False, projection_matrix)
gl.glEnableVertexAttribArray(0)
gl.glEnableVertexAttribArray(1)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
x = 0.0
text = [ord(c) - 32 for c in text]
for i in text:
if i >= 0 and i < 95:
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._buffer_ids[i])
gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, False, 0, c_void_p(0))
gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, False, 0, c_void_p(8*4))
gl.glUniform1f(self._uniform_locations['advance'], x)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
x += self._advance[i]
gl.glDisableVertexAttribArray(0)
gl.glDisableVertexAttribArray(1)
gl.glDisable(gl.GL_BLEND)
def init_gl(self, force=False):
if self._initialized and not force:
return
self._initialized = False
for material, prims in self.primitives.items():
material.init_gl(force=force)
technique = material.technique
for prim in prims:
prim.init_gl(force=force)
if technique in prim.vaos:
continue
vao = gl.glGenVertexArrays(1)
prim.vaos[technique] = vao
gl.glBindVertexArray(vao)
for attribute_name, location in technique.attribute_locations.items():
attribute = prim.attributes[attribute_name]
gl.glEnableVertexAttribArray(location)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, prim.buffers[attribute_name])
gl.glVertexAttribPointer(location, attribute.shape[-1],
DTYPE_COMPONENT_TYPE[attribute.dtype], False,
attribute.dtype.itemsize * attribute.shape[-1],
NULL_PTR)
if attribute_name in technique.attribute_divisors:
gl.glVertexAttribDivisor(location, technique.attribute_divisors[attribute_name])
gl.glBindVertexArray(0)
for location in technique.attribute_locations.values():
gl.glDisableVertexAttribArray(location)
err = gl.glGetError()
if err != gl.GL_NO_ERROR:
raise Exception('failed to init primitive: %s' % err)
_logger.info('%s.init_gl: OK' % self.__class__.__name__)
self._initialized = True
def display():
global phi, theta
gl.glDepthMask(gl.GL_TRUE)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
gl.glUniform4f(gpu["uniform"]["u_color"], 1, 1, 1, 1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["filled"])
gl.glDrawElements(gl.GL_TRIANGLES, len(f_indices), gl.GL_UNSIGNED_INT, None)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
gl.glUniform4f(gpu["uniform"]["u_color"], 0, 0, 0, 0.5)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["outline"])
gl.glDrawElements(gl.GL_LINES, len(o_indices), gl.GL_UNSIGNED_INT, None)
gl.glDepthMask(gl.GL_TRUE)
# Rotate cube
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
rotate(model, theta, 0, 0, 1)
rotate(model, phi, 0, 1, 0)
gl.glUniformMatrix4fv(gpu["uniform"]["u_model"], 1, False, model)
glut.glutSwapBuffers()
def __init__(self, elements, indices):
temp_list = [0]
# noinspection PyCallingNonCallable
self.vbo = (ctypes.c_uint32 * 1)(*temp_list)
# noinspection PyCallingNonCallable
self.ibo = (ctypes.c_uint32 * 1)(*temp_list)
GL.glGenBuffers(1, self.vbo)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbo)
# noinspection PyCallingNonCallable
GL.glBufferData(
GL.GL_ARRAY_BUFFER,
len(elements) * 4,
(ctypes.c_float * len(elements))(*elements),
GL.GL_STATIC_DRAW
)
GL.glGenBuffers(1, self.ibo)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, self.ibo)
# noinspection PyCallingNonCallable
GL.glBufferData(
GL.GL_ELEMENT_ARRAY_BUFFER,
len(indices) * 4,
(ctypes.c_uint32 * len(indices))(*indices),
GL.GL_STATIC_DRAW
)
self.indices_number = ctypes.c_uint32(len(indices))
def setup_buffers(gltf, uri_path):
buffers = gltf['buffers']
data_buffers = {}
for buffer_name, buffer in buffers.items():
uri = buffer['uri']
if uri.startswith('data:application/octet-stream;base64,'):
data_buffers[buffer_name] = base64.b64decode(uri.split(',')[1])
else:
filename = os.path.join(uri_path, buffer['uri'])
if buffer['type'] == 'arraybuffer':
data_buffers[buffer_name] = open(filename, 'rb').read()
elif buffer['type'] == 'text':
raise Exception('TODO')
#data_buffers[buffer_name] = open(filename, 'r').read()
_logger.debug('* loaded buffer "%s" (from %s)', buffer_name, filename)
for bufferView_name, bufferView in gltf['bufferViews'].items():
buffer_id = gl.glGenBuffers(1)
#byteLength = bufferView['byteLength']
byteOffset = bufferView['byteOffset']
gl.glBindBuffer(bufferView['target'], buffer_id)
gl.glBufferData(bufferView['target'], bufferView['byteLength'],
data_buffers[bufferView['buffer']][byteOffset:], gl.GL_STATIC_DRAW)
if gl.glGetError() != gl.GL_NO_ERROR:
raise Exception('failed to create buffer "%s"' % bufferView_name)
bufferView['id'] = buffer_id
gl.glBindBuffer(bufferView['target'], 0)
_logger.debug('* created buffer "%s"' % bufferView_name)
def main():
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(800, 600, "LearnOpenGL", None, None)
if not window:
print("Window Creation failed!")
glfw.terminate()
glfw.make_context_current(window)
glfw.set_window_size_callback(window, on_resize)
shader = Shader(CURDIR / 'shaders/4.1.texture.vs',
CURDIR / 'shaders/4.1.texture.fs')
shader_mix = Shader(CURDIR / 'shaders/4.1.texture.vs',
CURDIR / 'shaders/4.1.texture_mix.fs')
vertices = [
# positions colors tex_coords
0.5,
0.5,
0.0,
1.0,
0.0,
0.0,
1.0,
1.0, # top right
0.5,
-0.5,
0.0,
0.0,
1.0,
0.0,
1.0,
0.0, # bottom right
-0.5,
-0.5,
0.0,
0.0,
0.0,
1.0,
0.0,
0.0, # bottom left
-0.5,
0.5,
0.0,
1.0,
1.0,
0.0,
0.0,
1.0, # top left
]
vertices = (c_float * len(vertices))(*vertices)
indices = [0, 1, 3, 1, 2, 3]
indices = (c_uint * len(indices))(*indices)
vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vao)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices,
gl.GL_STATIC_DRAW)
ebo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ebo)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,
gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE,
8 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT,
gl.GL_FALSE, 8 * sizeof(c_float),
c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
gl.glVertexAttribPointer(2, 2, gl.GL_FLOAT,
gl.GL_FALSE, 8 * sizeof(c_float),
c_void_p(6 * sizeof(c_float)))
gl.glEnableVertexAttribArray(2)
# -- load texture
texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR_MIPMAP_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('container.jpg'))
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
while not glfw.window_should_close(window):
process_input(window)
gl.glClearColor(.2, .3, .3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
shader.use()
# -- uncomment to see mixture of vertex color and texture color
# shader_mix.use()
gl.glBindVertexArray(vao)
gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0))
glfw.poll_events()
glfw.swap_buffers(window)
gl.glDeleteVertexArrays(1, id(vao))
gl.glDeleteBuffers(1, id(vbo))
gl.glDeleteBuffers(1, id(ebo))
glfw.terminate()
def initialize():
global shaderProgram
global VAO
global idxCnt
global texUnitUniform
global sampleTexture
vertexStaticShader = shaders.compileShader(
"""
#version 330 core
layout (location=0) in vec3 position;
layout (location=1) in vec3 aNormal;
uniform mat4 rot;
uniform mat4 translation;
uniform mat4 projection;
uniform mat4 view;
out vec3 theCoords;
out vec3 theNormal;
void main()
{
vec4 world = translation*rot*vec4((1*position), 1);
gl_Position = projection*view*world;
theCoords = 0.5*(vec3(1,1,1)+1*position);
theNormal = aNormal;
}
""", GL.GL_VERTEX_SHADER)
fragmentShader = shaders.compileShader(
"""
#version 330 core
uniform sampler3D texUnit;
in vec3 theCoords;
in vec3 theNormal;
uniform vec3 lightPos;
out vec4 outputColour;
float ambientStrenght;
float diff;
vec3 lightColor;
vec3 ambient;
vec3 norm;
vec3 lightDir;
vec3 diffuse;
void main()
{
// ambient
lightColor = vec3(1, 1, 1);
ambientStrenght = 1.0;
ambient = ambientStrenght * lightColor;
// diffusse
norm = normalize(theNormal);
lightDir = normalize(lightPos - theCoords);
diff = max(dot(norm, lightDir), 0.0);
diffuse = diff * lightColor;
// out
outputColour = vec4(diffuse+ambient, 1.0)*texture(texUnit, theCoords);
}
""", GL.GL_FRAGMENT_SHADER)
vertexData = np.array([
1.0,
-1.0,
-1.0,
0,
-1,
0,
1.0,
-1.0,
1.0,
0,
-1,
0,
-1.0,
-1.0,
1.0,
0,
-1,
0,
-1.0,
-1.0,
-1.0,
0,
-1,
0,
1.0,
1.0,
-1.0,
0,
1,
0,
1.0,
1.0,
1.0,
0,
1,
0,
-1.0,
1.0,
1.0,
0,
1,
0,
-1.0,
1.0,
-1.0,
0,
1,
0,
1.0,
-1.0,
-1.0,
1,
0,
0,
1.0,
-1.0,
1.0,
1,
0,
0,
1.0,
1.0,
-1.0,
1,
0,
0,
1.0,
1.0,
1.0,
1,
0,
0,
1.0,
-1.0,
-1.0,
0,
0,
-1,
-1.0,
-1.0,
-1.0,
0,
0,
-1,
1.0,
1.0,
-1.0,
0,
0,
-1,
-1.0,
1.0,
-1.0,
0,
0,
-1,
-1.0,
-1.0,
1.0,
-1,
0,
0,
-1.0,
-1.0,
-1.0,
-1,
0,
0,
-1.0,
1.0,
1.0,
-1,
0,
0,
-1.0,
1.0,
-1.0,
-1,
0,
0,
1.0,
-1.0,
1.0,
0,
0,
1,
-1.0,
-1.0,
1.0,
0,
0,
1,
1.0,
1.0,
1.0,
0,
0,
1,
-1.0,
1.0,
1.0,
0,
0,
1,
],
dtype=np.float32)
faceData = np.array([
1,
3,
0,
7,
5,
4,
22,
21,
20,
10,
9,
8,
12,
15,
14,
16,
19,
17,
1,
2,
3,
7,
6,
5,
22,
23,
21,
10,
11,
9,
12,
13,
15,
16,
18,
19,
],
dtype=np.uint32)
idxCnt = faceData.shape[0]
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glDepthFunc(GL.GL_LEQUAL)
shaderProgram = shaders.compileProgram(vertexStaticShader, fragmentShader)
GL.glDeleteShader(vertexStaticShader)
GL.glDeleteShader(fragmentShader)
VAO = GL.glGenVertexArrays(1)
GL.glBindVertexArray(VAO)
# Need VBO for triangle vertices coordinates
VBO = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, VBO)
GL.glBufferData(GL.GL_ARRAY_BUFFER, vertexData.nbytes, vertexData,
GL.GL_STATIC_DRAW)
GL.glEnableVertexAttribArray(0)
GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, stride,
vertex_offset)
GL.glVertexAttribPointer(1, 3, GL.GL_FLOAT, GL.GL_FALSE, stride,
normal_offset)
GL.glEnableVertexAttribArray(1)
IBO = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, IBO)
GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, faceData.nbytes, faceData,
GL.GL_STATIC_DRAW)
# Finished
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
GL.glBindVertexArray(0)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
GL.glBindVertexArray(0)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0)
# load texture and assign texture unit for shaders
sampleTexture = loadTexture(texture)
texUnitUniform = GL.glGetUniformLocation(shaderProgram, 'texUnit')
def main():
global delta_time, last_frame
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(SRC_WIDTH, SRC_HEIGHT, "learnOpenGL", None,
None)
if not window:
glfw.terminate()
raise ValueError("Failed to create window")
glfw.make_context_current(window)
glfw.set_framebuffer_size_callback(window, framebuffer_size_callback)
glfw.set_cursor_pos_callback(window, mouse_callback)
glfw.set_scroll_callback(window, scroll_callback)
glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED)
gl.glEnable(gl.GL_DEPTH_TEST)
lamp_shader = Shader(CURDIR / "shaders/1.lamp.vs",
CURDIR / "shaders/1.lamp.fs")
lighting_shader = Shader(CURDIR / "shaders/5.1.light_casters.vs",
CURDIR / "shaders/5.1.light_casters.fs")
vertices = [
# positions normals texture coords
-0.5,
-0.5,
-0.5,
0.0,
0.0,
-1.0,
0.0,
0.0,
0.5,
-0.5,
-0.5,
0.0,
0.0,
-1.0,
1.0,
0.0,
0.5,
0.5,
-0.5,
0.0,
0.0,
-1.0,
1.0,
1.0,
0.5,
0.5,
-0.5,
0.0,
0.0,
-1.0,
1.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
0.0,
-1.0,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
0.0,
-1.0,
0.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
0.0,
0.0,
0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
1.0,
0.0,
0.5,
0.5,
0.5,
0.0,
0.0,
1.0,
1.0,
1.0,
0.5,
0.5,
0.5,
0.0,
0.0,
1.0,
1.0,
1.0,
-0.5,
0.5,
0.5,
0.0,
0.0,
1.0,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
0.0,
0.0,
-0.5,
0.5,
0.5,
-1.0,
0.0,
0.0,
1.0,
0.0,
-0.5,
0.5,
-0.5,
-1.0,
0.0,
0.0,
1.0,
1.0,
-0.5,
-0.5,
-0.5,
-1.0,
0.0,
0.0,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
-1.0,
0.0,
0.0,
0.0,
1.0,
-0.5,
-0.5,
0.5,
-1.0,
0.0,
0.0,
0.0,
0.0,
-0.5,
0.5,
0.5,
-1.0,
0.0,
0.0,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.0,
1.0,
0.0,
0.5,
0.5,
-0.5,
1.0,
0.0,
0.0,
1.0,
1.0,
0.5,
-0.5,
-0.5,
1.0,
0.0,
0.0,
0.0,
1.0,
0.5,
-0.5,
-0.5,
1.0,
0.0,
0.0,
0.0,
1.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
0.0,
0.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.0,
1.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
-1.0,
0.0,
0.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
-1.0,
0.0,
1.0,
1.0,
0.5,
-0.5,
0.5,
0.0,
-1.0,
0.0,
1.0,
0.0,
0.5,
-0.5,
0.5,
0.0,
-1.0,
0.0,
1.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
-1.0,
0.0,
0.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
-1.0,
0.0,
0.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
0.0,
0.0,
1.0,
0.5,
0.5,
-0.5,
0.0,
1.0,
0.0,
1.0,
1.0,
0.5,
0.5,
0.5,
0.0,
1.0,
0.0,
1.0,
0.0,
0.5,
0.5,
0.5,
0.0,
1.0,
0.0,
1.0,
0.0,
-0.5,
0.5,
0.5,
0.0,
1.0,
0.0,
0.0,
0.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
0.0,
0.0,
1.0
]
vertices = (c_float * len(vertices))(*vertices)
cube_positions = [(0.0, 0.0, 0.0), (2.0, 5.0, -15.0), (-1.5, -2.2, -2.5),
(-3.8, -2.0, -12.3), (2.4, -0.4, -3.5),
(-1.7, 3.0, -7.5), (1.3, -2.0, -2.5), (1.5, 2.0, -2.5),
(1.5, 0.2, -1.5), (-1.3, 1.0, -1.5)]
cube_vao = gl.glGenVertexArrays(1)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices,
gl.GL_STATIC_DRAW)
gl.glBindVertexArray(cube_vao)
# -- position attribute
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE,
8 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
# -- normal attribute
gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT,
gl.GL_FALSE, 8 * sizeof(c_float),
c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
# -- texture coordinate
gl.glVertexAttribPointer(2, 2, gl.GL_FLOAT,
gl.GL_FALSE, 8 * sizeof(c_float),
c_void_p(6 * sizeof(c_float)))
gl.glEnableVertexAttribArray(2)
# -- second configure light vao (vbo is the same)
light_vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(light_vao)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE,
8 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
# -- load texture
diffuse_map = load_texture("container2.png")
specular_map = load_texture("container2_specular.png")
# -- shader configuration
lighting_shader.use()
lighting_shader.set_int("material.diffuse", 0)
lighting_shader.set_int("material.specular", 1)
while not glfw.window_should_close(window):
# -- time logic
current_frame = glfw.get_time()
delta_time = current_frame - last_frame
last_frame = current_frame
# -- input
process_input(window)
# -- render
gl.glClearColor(0.1, 0.1, 0.1, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
lighting_shader.use()
lighting_shader.set_vec3("light.direction", Vector3([-0.2, -1.0,
-0.3]))
lighting_shader.set_vec3("viewPos", camera.position)
# -- light properties
lighting_shader.set_vec3("light.ambient", Vector3([0.2, 0.2, 0.2]))
lighting_shader.set_vec3("light.diffuse", Vector3([0.5, 0.5, 0.5]))
lighting_shader.set_vec3("light.specular", Vector3([1.0, 1.0, 1.0]))
# -- material properties
lighting_shader.set_float("material.shininess", 32.0)
# -- view.projection transformations
projection = Matrix44.perspective_projection(camera.zoom,
SRC_WIDTH / SRC_HEIGHT,
0.1, 100.0)
view = camera.get_view_matrix()
lighting_shader.set_mat4("projection", projection)
lighting_shader.set_mat4("view", view)
# -- world transformation
model = Matrix44.identity()
lighting_shader.set_mat4("model", model)
# -- bind diffuse map
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, diffuse_map)
# -- bind specular map
gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindTexture(gl.GL_TEXTURE_2D, specular_map)
# -- render cube
# gl.glBindVertexArray(cube_vao)
# gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
# -- render continers
gl.glBindVertexArray(cube_vao)
for idx, position in enumerate(cube_positions):
angle = 20.0 * idx
rotation = matrix44.create_from_axis_rotation([1.0, 0.3, 0.5],
math.radians(angle))
translation = Matrix44.from_translation(position)
model = translation * rotation
lighting_shader.set_mat4('model', model)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
# a lamp object is weird when we only have a directional light, don't render the light object
# -- draw lamp object
# lamp_shader.use()
# lamp_shader.set_mat4("projection", projection)
# lamp_shader.set_mat4("view", view)
# model = Matrix44.identity()
# model *= Matrix44.from_translation(light_pos)
# model *= Matrix44.from_scale(Vector3([.2, .2, .2]))
# lamp_shader.set_mat4("model", model)
# gl.glBindVertexArray(light_vao)
# gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
glfw.swap_buffers(window)
glfw.poll_events()
gl.glDeleteVertexArrays(1, id(cube_vao))
gl.glDeleteVertexArrays(1, id(light_vao))
gl.glDeleteBuffers(1, id(vbo))
glfw.terminate()
def draw_vbo(self):
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_DIFFUSE)
gl.glEnable(gl.GL_COLOR_MATERIAL)
# bind color buffer
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.buffers[2])
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffers[1])
gl.glColorPointer(3, gl.GL_FLOAT, 0, None)
# bind vertex buffer - cylinder
# stride is one vertex
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.buffers[2])
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffers[0])
gl.glVertexPointer(3, gl.GL_FLOAT, 3 * self.__FLOAT_BYTE_SIZE__, None)
gl.glDrawElements(gl.GL_TRIANGLES, len(self.indices),
gl.GL_UNSIGNED_INT, None)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.buffers[2])
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffers[0])
gl.glVertexPointer(3, gl.GL_FLOAT, 3 * self.__FLOAT_BYTE_SIZE__,
c_void_p(4 * 3))
gl.glDrawElements(gl.GL_TRIANGLES, len(self.indices),
gl.GL_UNSIGNED_INT, None)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
def initialize():
global shaderProgram
global VAO
global VBO
vertexShader = shaders.compileShader(
"""
#version 330
layout (location=0) in vec4 position;
layout (location=1) in vec4 colour;
smooth out vec4 theColour;
void main()
{
gl_Position = position;
theColour = colour;
}
""", GL.GL_VERTEX_SHADER)
fragmentShader = shaders.compileShader(
"""
#version 330
smooth in vec4 theColour;
out vec4 outputColour;
void main()
{
outputColour = theColour;
}
""", GL.GL_FRAGMENT_SHADER)
shaderProgram = shaders.compileProgram(vertexShader, fragmentShader)
vertexData = numpy.array(
[
# Vertex Positions
0.0,
0.5,
0.0,
1.0,
0.5,
-0.366,
0.0,
1.0,
-0.5,
-0.366,
0.0,
1.0,
# Vertex Colours
1.0,
0.0,
0.0,
1.0,
0.0,
1.0,
0.0,
1.0,
0.0,
0.0,
1.0,
1.0,
],
dtype=numpy.float32)
# Core OpenGL requires that at least one OpenGL vertex array be bound
VAO = GL.glGenVertexArrays(1)
GL.glBindVertexArray(VAO)
# Need VBO for triangle vertices and colours
VBO = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, VBO)
GL.glBufferData(GL.GL_ARRAY_BUFFER, vertexData.nbytes, vertexData,
GL.GL_STATIC_DRAW)
# enable array and set up data
GL.glEnableVertexAttribArray(0)
GL.glEnableVertexAttribArray(1)
GL.glVertexAttribPointer(0, 4, GL.GL_FLOAT, GL.GL_FALSE, 0, None)
# the last parameter is a pointer
GL.glVertexAttribPointer(1, 4, GL.GL_FLOAT, GL.GL_FALSE, 0,
ctypes.c_void_p(48))
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
GL.glBindVertexArray(0)
def _deactivate(self):
""" Unbind the current bound buffer """
log("GPU: Deactivating buffer")
gl.glBindBuffer(self._target, 0)
def _activate(self):
""" Bind the buffer to some target """
log("GPU: Activating buffer")
gl.glBindBuffer(self._target, self._handle)
def main():
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(width, height, "LearnOpenGL", None, None)
if not window:
print("Window Creation failed!")
glfw.terminate()
glfw.make_context_current(window)
glfw.set_window_size_callback(window, on_resize)
gl.glEnable(gl.GL_DEPTH_TEST)
shader = Shader(CURDIR / 'shaders/6.1.coordinate_systems.vs',
CURDIR / 'shaders/6.1.coordinate_systems.fs')
vertices = [
# positions tex_coords
-0.5,
-0.5,
-0.5,
0.0,
0.0,
0.5,
-0.5,
-0.5,
1.0,
0.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
1.0,
0.5,
0.5,
0.5,
1.0,
1.0,
-0.5,
0.5,
0.5,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
-0.5,
0.5,
0.5,
1.0,
0.0,
-0.5,
0.5,
-0.5,
1.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
-0.5,
0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
1.0,
0.5,
-0.5,
0.5,
0.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
0.5,
-0.5,
-0.5,
1.0,
1.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
-0.5,
0.5,
0.5,
0.0,
0.0,
-0.5,
0.5,
-0.5,
0.0,
1.0
]
vertices = (c_float * len(vertices))(*vertices)
vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vao)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices,
gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE,
5 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT,
gl.GL_FALSE, 5 * sizeof(c_float),
c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
# -- load texture 1
texture1 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('container.jpg')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
# -- load texture 2
texture2 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('awesomeface.png')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0,
gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
shader.use()
shader.set_int("texture1", 0)
shader.set_int("texture2", 1)
while not glfw.window_should_close(window):
process_input(window)
gl.glClearColor(.2, .3, .3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
shader.use()
model = Matrix44.from_x_rotation(
glfw.get_time() * 0.5) * Matrix44.from_y_rotation(glfw.get_time())
view = Matrix44.from_translation([0, 0, -3])
projection = Matrix44.perspective_projection(45, width / height, 0.1,
100.0)
shader.set_mat4('view', view)
shader.set_mat4('model', model)
shader.set_mat4('projection', projection)
gl.glBindVertexArray(vao)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
glfw.poll_events()
glfw.swap_buffers(window)
gl.glDeleteVertexArrays(1, id(vao))
gl.glDeleteBuffers(1, id(vbo))
glfw.terminate()
def init_target() -> RenderTarget: # pragma: no cover
# Setting up VAO
vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vao)
# Quad vertex buffer
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, QUAD_VERTS.nbytes, QUAD_VERTS,
gl.GL_DYNAMIC_DRAW)
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
# Finish setting up VAO
gl.glBindVertexArray(0)
# Quad index buffer
ebo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ebo)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, QUAD_IDX.nbytes, QUAD_IDX,
gl.GL_STATIC_DRAW)
# Regions data
world_ssbo = gl.glGenBuffers(1)
# Create shaders
vs_src, fs_src = __load_shaders()
vs = shaders.compileShader(vs_src, gl.GL_VERTEX_SHADER)
fs = shaders.compileShader(fs_src, gl.GL_FRAGMENT_SHADER)
program = shaders.compileProgram(vs, fs)
# Create target texture
render_texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, render_texture)
gl.glTexImage2D(
gl.GL_TEXTURE_2D,
0, # level
gl.GL_RGBA, # internalFormat
1, # width
1, # height
0, # border
gl.GL_RGBA, # format
gl.GL_FLOAT, # type
None # data
)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
# Create target framebuffer
# Create target framebuffer
render_fbo = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, render_fbo)
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, render_texture, 0)
_validate_fbo_complete()
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
return RenderTarget(
vao=vao,
vbo=vbo,
ebo=ebo,
world_ssbo=world_ssbo,
vertex_shader=vs,
fragment_shader=fs,
program=program,
indices=np.copy(QUAD_IDX),
render_fbo=render_fbo,
render_texture=render_texture,
)
def initialize(self):
vertices = np.array(
[
0.5,
0.5,
0.0,
1.0,
0.0,
0.0,
0.55,
0.55, # top right
0.5,
-0.5,
0.0,
0.0,
1.0,
0.0,
0.55,
0.45, # bottom right
-0.5,
-0.5,
0.0,
0.0,
0.0,
1.0,
0.45,
0.45, # bottom left
-0.5,
0.5,
0.0,
1.0,
1.0,
0.0,
0.45,
0.55 # top left
],
dtype=np.float32)
indices = np.array([0, 1, 3, 1, 2, 3], dtype=np.uint32)
self._vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(self._vao)
vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, vertices, GL.GL_STATIC_DRAW)
float_size = ctypes.sizeof(ctypes.c_float)
GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE,
8 * float_size, ctypes.c_void_p(0))
GL.glEnableVertexAttribArray(0)
GL.glVertexAttribPointer(1, 3, GL.GL_FLOAT,
GL.GL_FALSE, 8 * float_size,
ctypes.c_void_p(3 * float_size))
GL.glEnableVertexAttribArray(1)
GL.glVertexAttribPointer(2, 2, GL.GL_FLOAT,
GL.GL_FALSE, 8 * float_size,
ctypes.c_void_p(6 * float_size))
GL.glEnableVertexAttribArray(2)
ebo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ebo)
GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, indices, GL.GL_STATIC_DRAW)
GL.glBindVertexArray(0)
self._texture = Texture2D("awesomeface.png",
flip_y=True,
wrap_s=GL.GL_REPEAT,
wrap_t=GL.GL_REPEAT,
min_filter=GL.GL_NEAREST,
mag_filter=GL.GL_NEAREST)
vertex_shader = Shader(GL.GL_VERTEX_SHADER,
"shaders_src/textures_vertex.glsl")
fragment_shader = Shader(GL.GL_FRAGMENT_SHADER,
"shaders_src/textures_frag.glsl")
self._shader_program = ShaderProgram(vertex_shader, fragment_shader)
vertex_shader.delete()
fragment_shader.delete()
def main():
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(800, 600, "LearnOpenGL", None, None)
if not window:
print("Window Creation failed!")
glfw.terminate()
glfw.make_context_current(window)
glfw.set_window_size_callback(window, on_resize)
shader = Shader(CURDIR / 'shaders/5.1.transform.vs', CURDIR / 'shaders/5.1.transform.fs')
vertices = [
# positions tex_coords
0.5, 0.5, 0.0, 1.0, 1.0, # top right
0.5, -0.5, 0.0, 1.0, 0.0, # bottom right
-0.5, -0.5, 0.0, 0.0, 0.0, # bottom left
-0.5, 0.5, 0.0, 0.0, 1.0, # top left
]
vertices = (c_float * len(vertices))(*vertices)
indices = [
0, 1, 3,
1, 2, 3
]
indices = (c_uint * len(indices))(*indices)
vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vao)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices, gl.GL_STATIC_DRAW)
ebo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ebo)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
# -- load texture 1
texture1 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('container.jpg')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
# -- load texture 2
texture2 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('awesomeface.png')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
shader.use()
shader.set_int("texture1", 0)
shader.set_int("texture2", 1)
while not glfw.window_should_close(window):
process_input(window)
gl.glClearColor(.2, .3, .3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
translation = Matrix44.from_translation([0.5, -0.5, 0.0])
rotation = Matrix44.from_z_rotation(glfw.get_time())
transform = translation * rotation
shader.use()
shader.set_mat4('transform', transform)
gl.glBindVertexArray(vao)
gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0))
# -- second container
translation = Matrix44.from_translation([-0.5, 0.5, 0.0])
scale = Matrix44.from_scale([math.sin(glfw.get_time())]*3)
transform = translation * scale
shader.set_mat4('transform', transform)
gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0))
glfw.poll_events()
glfw.swap_buffers(window)
gl.glDeleteVertexArrays(1, id(vao))
gl.glDeleteBuffers(1, id(vbo))
gl.glDeleteBuffers(1, id(ebo))
glfw.terminate()
def __init__(self, vec1:mmath.Vec3, vec2:mmath.Vec3, vec3:mmath.Vec3, vec4:mmath.Vec3,
vec5:mmath.Vec3, vec6:mmath.Vec3, vec7:mmath.Vec3, vec8:mmath.Vec3,
textureId:int, textureVerNum_f:float, textureHorNum_f:float, shininess:float, specularStrength:float,
startPos_l:list):
super().__init__()
self.renderFlag = True
self.vertices_l = [vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8]
self.textureId = textureId
self.textureVerNum_f = float(textureVerNum_f)
self.textureHorNum_f = float(textureHorNum_f)
self.shininess_f = float(shininess)
self.specularStrength_f = float(specularStrength)
self.pos_l = startPos_l
self.selectedTexId = self.textureId
self.textureId2 = None
self.collideModels_l.append( co.AabbActor(vec3, vec5, self) )
#self.collideModels_l.append()
#### ####
self.vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(self.vao)
vertices = np.array([*vec1.getXYZ(),
*vec2.getXYZ(),
*vec3.getXYZ(),
*vec1.getXYZ(),
*vec3.getXYZ(),
*vec4.getXYZ(),
*vec2.getXYZ(),
*vec6.getXYZ(),
*vec7.getXYZ(),
*vec2.getXYZ(),
*vec7.getXYZ(),
*vec3.getXYZ(),
*vec3.getXYZ(),
*vec7.getXYZ(),
*vec8.getXYZ(),
*vec3.getXYZ(),
*vec8.getXYZ(),
*vec4.getXYZ(),
*vec4.getXYZ(),
*vec8.getXYZ(),
*vec5.getXYZ(),
*vec4.getXYZ(),
*vec5.getXYZ(),
*vec1.getXYZ(),
*vec1.getXYZ(),
*vec5.getXYZ(),
*vec6.getXYZ(),
*vec1.getXYZ(),
*vec6.getXYZ(),
*vec2.getXYZ(),
*vec8.getXYZ(),
*vec7.getXYZ(),
*vec6.getXYZ(),
*vec8.getXYZ(),
*vec6.getXYZ(),
*vec5.getXYZ()], dtype=np.float32)
size = vertices.size * vertices.itemsize
self.vertexSize_i = vertices.size
self.verticesBuffer = gl.glGenBuffers(1) # Create a buffer.
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.verticesBuffer) # Bind the buffer.
gl.glBufferData(gl.GL_ARRAY_BUFFER, size, vertices, gl.GL_STATIC_DRAW) # Allocate memory.
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, None) # Defines vertex attributes. What are those?
gl.glEnableVertexAttribArray(0)
#### Texture Coord ####
textureCoords = np.array([0, 1,
0, 0,
1, 0,
0, 1,
1, 0,
1, 1,
0, 1,
0, 0,
1, 0,
0, 1,
1, 0,
1, 1,
0, 1,
0, 0,
1, 0,
0, 1,
1, 0,
1, 1,
0, 1,
0, 0,
1, 0,
0, 1,
1, 0,
1, 1,
0, 1,
0, 0,
1, 0,
0, 1,
1, 0,
1, 1,
0, 1,
0, 0,
1, 0,
0, 1,
1, 0,
1, 1], dtype=np.float32)
size = textureCoords.size * textureCoords.itemsize
self.texCoordBuffer = gl.glGenBuffers(1) # Create a buffer.
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.texCoordBuffer) # Bind the buffer.
gl.glBufferData(gl.GL_ARRAY_BUFFER, size, textureCoords, gl.GL_STATIC_DRAW) # Allocate memory.
gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, None) # Defines vertex attributes. What are those?
gl.glEnableVertexAttribArray(1)
def update_buffer(buf_id, data, offset=0, target=gl.GL_ARRAY_BUFFER):
gl.glBindBuffer(target, buf_id)
gl.glBufferSubData(target, offset, data.nbytes, data)
def _update_region_sub_data(self, region_idx: int, region_data: bytes):
gl.glBindBuffer(gl.GL_SHADER_STORAGE_BUFFER, self.target.world_ssbo)
gl.glBufferSubData(gl.GL_SHADER_STORAGE_BUFFER,
offset=region_idx * REGION_SIZE,
data=region_data)
def unbind_all():
gl.glBindVertexArray(0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
RenderObject.bound_vao = -1
def update(self, offset=0, size=None):
if size is None:
size = self.nbytes
gl.glBindBuffer(gl.GL_UNIFORM_BUFFER, self.ubo)
gl.glBufferSubData(gl.GL_UNIFORM_BUFFER, offset, size, pointer(self.data))
# Get rid of shaders (no more needed) gl.glDetachShader(program, vertex) gl.glDetachShader(program, fragment) # Make program the default program gl.glUseProgram(program) # Build buffer # -------------------------------------- # Request a buffer slot from GPU buffer = gl.glGenBuffers(1) # Make this buffer the default one gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer) # Upload data gl.glBufferData(gl.GL_ARRAY_BUFFER, data.nbytes, data, gl.GL_DYNAMIC_DRAW) # Bind the position attribute # -------------------------------------- stride = data.strides[0] offset = ctypes.c_void_p(0) loc = gl.glGetAttribLocation(program, "position") gl.glEnableVertexAttribArray(loc) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, buffer) gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset) # Upload the uniform color # --------------------------------------
def create_empty_buffer(size, target=gl.GL_ARRAY_BUFFER, usage=gl.GL_STATIC_DRAW):
buf_id = gl.glGenBuffers(1)
gl.glBindBuffer(target, buf_id)
gl.glBufferData(target, size, None, usage)
return buf_id
def _init_buffers(self, vertices, normals, _):
# prepare data for the gpu
gpu_data = np.array(vertices + normals, dtype=np.float32)
# create VBOs
self.vbos = list(GL.glGenBuffers(3))
# init VBO 0 - static mesh data
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbos[0])
loc = self.get_attribute_location("position")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 3, GL.GL_FLOAT, GL.GL_FALSE, 0,
ctypes.c_void_p(0))
loc = self.get_attribute_location("normal")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 3, GL.GL_FLOAT, GL.GL_FALSE, 0,
ctypes.c_void_p(self.size * 12))
GL.glBufferData(GL.GL_ARRAY_BUFFER, 12 * len(gpu_data), gpu_data,
GL.GL_STATIC_DRAW)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
# init VBO 1 - dynamic offset data
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbos[1])
loc = self.get_attribute_location("offset")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 3, GL.GL_FLOAT, GL.GL_FALSE, 0,
ctypes.c_void_p(0))
GL.glVertexAttribDivisor(loc, 1)
GL.glBufferData(GL.GL_ARRAY_BUFFER, 0, np.array([], dtype=np.float32),
GL.GL_DYNAMIC_DRAW)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
# init VBO 2 - dynamic color data
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vbos[2])
loc = self.get_attribute_location("color")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 4, GL.GL_FLOAT, GL.GL_FALSE, 0,
ctypes.c_void_p(0))
GL.glVertexAttribDivisor(loc, 1)
GL.glBufferData(GL.GL_ARRAY_BUFFER, 0, np.array([], dtype=np.float32),
GL.GL_DYNAMIC_DRAW)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
def main():
# declare draw method so it can be reused during resizing
def draw():
gl.glClearColor(0.2, 0.3, 0.3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glUseProgram(shaderProgram)
gl.glBindVertexArray(VAO)
gl.glDrawElements(gl.GL_TRIANGLES, 3 * indices.shape[0],
gl.GL_UNSIGNED_INT, None)
gl.glBindVertexArray(0)
glfw.swap_buffers(window)
# declaring resize callback in main to allow access to variables
def window_size_callback(window, width, height):
gl.glViewport(0, 0, width, height)
# calling draw to allow drawing while resizing
draw()
# glfw: initialize and configure
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE,
glfw.OPENGL_CORE_PROFILE) # No deprecated functions
glfw.window_hint(glfw.RESIZABLE, gl.GL_TRUE)
# checking if run on Mac OS X
if sys.platform == 'darwin':
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
# glfw window creation
window = glfw.create_window(WIDTH, HEIGHT, 'LearnOpenGL', None,
None) # tutorial: (800, 600...
if window is None:
glfw.terminate()
raise Exception("ERROR: Failed to create GLFW window")
glfw.make_context_current(window)
glfw.set_key_callback(window, key_callback)
width, height = glfw.get_framebuffer_size(window)
glfw.set_window_size_callback(window, window_size_callback)
# build and compile shader program
# vertex shader
vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(vertexShader, vertexShaderSource)
gl.glCompileShader(vertexShader)
if not gl.glGetShaderiv(vertexShader, gl.GL_COMPILE_STATUS):
infoLog = gl.glGetShaderInfoLog(vertexShader).decode()
raise Exception("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" +
infoLog)
# fragment shader
fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(fragmentShader, fragmentShaderSource)
gl.glCompileShader(fragmentShader)
if not gl.glGetShaderiv(fragmentShader, gl.GL_COMPILE_STATUS):
infoLog = gl.glGetShaderInfoLog(fragmentShader).decode()
raise Exception("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" +
infoLog)
# link shaders
shaderProgram = gl.glCreateProgram()
gl.glAttachShader(shaderProgram, vertexShader)
gl.glAttachShader(shaderProgram, fragmentShader)
gl.glLinkProgram(shaderProgram)
if not gl.glGetProgramiv(shaderProgram, gl.GL_LINK_STATUS):
infoLog = gl.glGetProgramInfoLog(shaderProgram).decode()
raise Exception("ERROR::SHADER::PROGRAM::LINKING_FAILED\n" + infoLog)
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
# set up vertex data (and buffer(s)) and configure vertex attributes
vertices = np.array(
[
[0.5, 0.5, 0.0], # Left
[0.5, -0.5, 0.0], # Right
[-0.5, -0.5, 0.0],
[-0.5, 0.5, 0.0],
[1.0, -0.5, 0.0]
], # Top
dtype=np.float32)
indices = np.array(
[
[3, 2, 1], # first triangle
[0, 1, 4]
], # second triangle
dtype=np.int32)
VBO, VAO, EBO = gl.GLuint(), gl.GLuint(), gl.GLuint()
gl.glGenVertexArrays(1, VAO) # 1 -> 1 buffer to be generated
gl.glGenBuffers(1, VBO)
gl.glGenBuffers(1, EBO)
# bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s)
gl.glBindVertexArray(VAO)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER,
VBO) # bind = make active/current for subsequent ops
gl.glBufferData(gl.GL_ARRAY_BUFFER, vertices, gl.GL_STATIC_DRAW)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, EBO)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, indices, gl.GL_STATIC_DRAW)
stride = vertices.itemsize * vertices.shape[1]
offset = gl.ctypes.c_void_p(vertices.itemsize * 0)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, stride, offset)
gl.glEnableVertexAttribArray(0) # location = 0
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glBindVertexArray(0)
# to put in wireframe mode
# gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE)
# render loop
while not glfw.window_should_close(window):
glfw.poll_events()
draw()
glfw.terminate()
return 0
def load_gltf(filepath, opt_input_flags: List[str] = ()) -> List[Entity]:
obj = glb_object(filepath)
# if not len(obj.meshes) == 1:
# raise Exception("only 1 mesh")
# if not len(obj.meshes[0].primitives) == 1:
# raise Exception("only 1 primitive")
# initialize gltf stuff
blob = np.frombuffer(obj.binary_blob(), dtype='uint8')
obj.destroy_binary_blob()
buffers = UnboundBufferCollection()
for i in range(len(obj.bufferViews)):
buffer_view = obj.bufferViews[i]
data_slice = blob[buffer_view.byteOffset:buffer_view.byteOffset +
buffer_view.byteLength]
buffers.add_buffer(UnboundBuffer(buffer_view, data_slice, index=i))
def get_texture(index) -> TextureUnit:
tex = obj.textures[index]
img = obj.images[tex.source]
data = buffers[img.bufferView].data
if tex.sampler is not None:
sampler = clean_sampler(obj.samplers[tex.sampler])
else:
sampler = get_default_sampler()
return load_gltf_image(img, data, sampler)
materials = []
for material in obj.materials:
mat = Material.from_gltf_material(material)
if not material.alphaMode == 'OPAQUE':
raise Exception(
"Special case! Discard model, and find the nearest exit.")
color = material.pbrMetallicRoughness.baseColorTexture
normal = material.normalTexture
metallic = material.pbrMetallicRoughness.metallicRoughnessTexture
if color is not None:
mat.set_texture(get_texture(color.index), MaterialTexture.COLOR)
if normal is not None:
mat.set_texture(get_texture(normal.index), MaterialTexture.NORMAL)
if metallic is not None:
mat.set_texture(get_texture(metallic.index),
MaterialTexture.METALLIC)
# add extras just in case
for prop, value in material.extras.items():
if value == 'flag':
mat.add_flag(prop)
else:
mat.set_property(prop, value)
for f in opt_input_flags:
mat.add_flag(f)
if mat.has_flag('reflective'):
mat.add_fbo_texture(fbos.find_fbo_by_type(FBO.REFLECTION),
GL.GL_COLOR_ATTACHMENT0)
materials.append(mat)
# for each primitive in each mesh . . .
entities: List[Entity] = []
for n in obj.nodes:
if n.mesh is None: continue
ent = Entity(n.name)
# do the mesh, using only the first primitive
mesh = Mesh()
mesh.bind_vao()
gltf_mesh = obj.meshes[n.mesh]
primitive = gltf_mesh.primitives[0]
index_acc = obj.accessors[
primitive.indices] if primitive.indices is not None else None
if index_acc is not None:
mesh.element = True
mesh.elementInfo = index_acc
index_buff: UnboundBuffer = buffers[index_acc.bufferView]
index_buff.optional_binder()(GL.GL_ELEMENT_ARRAY_BUFFER)
mesh.elementBufID = index_buff.buffer_id
# do materials # todo: create materials, then apply to meshes
mesh.material = None
materialIdx = gltf_mesh.primitives[0].material
if materialIdx is not None:
mesh.material = copy.deepcopy(materials[materialIdx])
if len(mesh.material.get_all_mat_textures()) == 0 or (
primitive.attributes.TEXCOORD_0 is None
and primitive.attributes.TEXCOORD_1 is None):
if primitive.attributes.COLOR_0 is not None:
mesh.material.add_flag('useVertexColor')
mesh.find_shader('flat_shaded')
print('using a flat shader for material %s' %
mesh.material.name)
else:
mesh.find_shader('default')
# print('using default shader for material %s'%mesh.material.name)
else:
mesh.set_shader(shaders.get_default_program())
mesh.material = mesh.program.create_material()
print('WARNING: you used a default program!')
# do vbos
attrs = 'COLOR_0,JOINTS_0,NORMAL,POSITION,TANGENT,TEXCOORD_0,TEXCOORD_1,WEIGHTS_0'.split(
',')
# attrs = 'COLOR_0,NORMAL,POSITION,TEXCOORD_0'.split(',')
unsupported = 'JOINTS_0,TANGENT,TEXCOORD_1,WEIGHTS_0'.split(
',') # todo: fix this
for att in attrs:
val = getattr(primitive.attributes, att)
if val is None: continue
if att in unsupported:
print(
f'WARNING: {att} in model {gltf_mesh.name} is currently unsupported and may cause problems in rendering.'
)
continue
name = att.lower()
acc = obj.accessors[val]
location = GL.glGetAttribLocation(mesh.gl_program, name)
# compiler can automatically assume that a location might not exist.
# for example, if a mesh has a texcoord_0 defined but no textures, the shader it requested will have the
# #defines set up so that it never actually calls on the attribute texcoord_0, so the compiler pretends it does
# not exist. Hence, this value can be -1 even if you do define everything correctly :/
if location == -1:
print(f'WARNING: location of {name} returned -1')
continue
buff = buffers[acc.bufferView]
byte_stride = buff.buffer_view.byteStride
if byte_stride is None:
vec = accessor_type_dim(acc.type)
byte_size = np.array([1],
dtype=accessor_dtype(
acc.componentType)).itemsize
byte_stride = vec * byte_size
buff.optional_binder()(
GL.GL_ARRAY_BUFFER
) # if not bound already, bind with that target (that target is correct for all these attributes)
GL.glEnableVertexAttribArray(location)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, buff.buffer_id)
GL.glVertexAttribPointer(
location,
type_to_dim[acc.type],
acc.componentType,
acc.normalized,
byte_stride,
ctypes.c_void_p(acc.byteOffset),
)
if name == 'position': # this is ok because gltf specifies position, see attrs
mesh.tri_count = acc.count // 3
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
mesh.unbind_vao()
ent.mesh = mesh
ent.transform.set_translation(n.translation)
ent.transform.set_rotation(n.rotation)
ent.transform.set_scale(n.scale)
entities.append(ent)
return entities
def main():
global delta_time, last_frame
if not glfw.init():
raise ValueError("Failed to initialize glfw")
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(SRC_WIDTH, SRC_HEIGHT, "learnOpenGL", None, None)
if not window:
glfw.terminate()
raise ValueError("Failed to create window")
glfw.make_context_current(window)
glfw.set_framebuffer_size_callback(window, framebuffer_size_callback)
glfw.set_cursor_pos_callback(window, mouse_callback)
glfw.set_scroll_callback(window, scroll_callback)
glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED)
gl.glEnable(gl.GL_DEPTH_TEST)
lamp_shader = Shader(CURDIR / "shaders/1.lamp.vs", CURDIR / "shaders/1.lamp.fs")
lighting_shader = Shader(CURDIR / "shaders/2.1.basic_lighting.vs", CURDIR / "shaders/2.1.basic_lighting.fs")
vertices = [
-0.5, -0.5, -0.5, 0.0, 0.0, -1.0,
0.5, -0.5, -0.5, 0.0, 0.0, -1.0,
0.5, 0.5, -0.5, 0.0, 0.0, -1.0,
0.5, 0.5, -0.5, 0.0, 0.0, -1.0,
-0.5, 0.5, -0.5, 0.0, 0.0, -1.0,
-0.5, -0.5, -0.5, 0.0, 0.0, -1.0,
-0.5, -0.5, 0.5, 0.0, 0.0, 1.0,
0.5, -0.5, 0.5, 0.0, 0.0, 1.0,
0.5, 0.5, 0.5, 0.0, 0.0, 1.0,
0.5, 0.5, 0.5, 0.0, 0.0, 1.0,
-0.5, 0.5, 0.5, 0.0, 0.0, 1.0,
-0.5, -0.5, 0.5, 0.0, 0.0, 1.0,
-0.5, 0.5, 0.5, -1.0, 0.0, 0.0,
-0.5, 0.5, -0.5, -1.0, 0.0, 0.0,
-0.5, -0.5, -0.5, -1.0, 0.0, 0.0,
-0.5, -0.5, -0.5, -1.0, 0.0, 0.0,
-0.5, -0.5, 0.5, -1.0, 0.0, 0.0,
-0.5, 0.5, 0.5, -1.0, 0.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0, 0.0,
0.5, 0.5, -0.5, 1.0, 0.0, 0.0,
0.5, -0.5, -0.5, 1.0, 0.0, 0.0,
0.5, -0.5, -0.5, 1.0, 0.0, 0.0,
0.5, -0.5, 0.5, 1.0, 0.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0, 0.0,
-0.5, -0.5, -0.5, 0.0, -1.0, 0.0,
0.5, -0.5, -0.5, 0.0, -1.0, 0.0,
0.5, -0.5, 0.5, 0.0, -1.0, 0.0,
0.5, -0.5, 0.5, 0.0, -1.0, 0.0,
-0.5, -0.5, 0.5, 0.0, -1.0, 0.0,
-0.5, -0.5, -0.5, 0.0, -1.0, 0.0,
-0.5, 0.5, -0.5, 0.0, 1.0, 0.0,
0.5, 0.5, -0.5, 0.0, 1.0, 0.0,
0.5, 0.5, 0.5, 0.0, 1.0, 0.0,
0.5, 0.5, 0.5, 0.0, 1.0, 0.0,
-0.5, 0.5, 0.5, 0.0, 1.0, 0.0,
-0.5, 0.5, -0.5, 0.0, 1.0, 0.0
]
vertices = (c_float * len(vertices))(*vertices)
cube_vao = gl.glGenVertexArrays(1)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices, gl.GL_STATIC_DRAW)
gl.glBindVertexArray(cube_vao)
# -- position attribute
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 6 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
# -- normal attribute
gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, gl.GL_FALSE, 6 * sizeof(c_float), c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
# -- second configure light vao (vbo is the same)
light_vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(light_vao)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 6 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
while not glfw.window_should_close(window):
# -- time logic
current_frame = glfw.get_time()
delta_time = current_frame - last_frame
last_frame = current_frame
# -- input
process_input(window)
# -- render
gl.glClearColor(0.1, 0.1, 0.1, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
lighting_shader.use()
lighting_shader.set_vec3("objectColor", Vector3([1.0, 0.5, 0.31]))
lighting_shader.set_vec3("lightColor", Vector3([1.0, 1.0, 1.0]))
lighting_shader.set_vec3("lightPos", light_pos)
# -- view.projection transformations
projection = Matrix44.perspective_projection(camera.zoom, SRC_WIDTH/SRC_HEIGHT, 0.1, 100.0)
view = camera.get_view_matrix()
lighting_shader.set_mat4("projection", projection)
lighting_shader.set_mat4("view", view)
# -- world transformation
model = Matrix44.identity()
lighting_shader.set_mat4("model", model)
# -- render cube
gl.glBindVertexArray(cube_vao)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
# -- draw lamp object
lamp_shader.use()
lamp_shader.set_mat4("projection", projection)
lamp_shader.set_mat4("view", view)
model = Matrix44.identity()
model *= Matrix44.from_translation(light_pos)
model *= Matrix44.from_scale(Vector3([.2, .2, .2]))
lamp_shader.set_mat4("model", model)
gl.glBindVertexArray(light_vao)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
glfw.swap_buffers(window)
glfw.poll_events()
gl.glDeleteVertexArrays(1, id(cube_vao))
gl.glDeleteVertexArrays(1, id(light_vao))
gl.glDeleteBuffers(1, id(vbo))
glfw.terminate()
def glize(node):
model = node.transformation.astype(numpy.float32)
gl.glUniformMatrix4fv(
gl.glGetUniformLocation(shader, "model"), 1 , gl.GL_FALSE,
model
)
gl.glUniformMatrix4fv(
gl.glGetUniformLocation(shader, "view"), 1 , gl.GL_FALSE,
glm.value_ptr(view)
)
gl.glUniformMatrix4fv(
gl.glGetUniformLocation(shader, "projection"), 1 , gl.GL_FALSE,
glm.value_ptr(projection)
)
for mesh in node.meshes:
#assert False , texture #prueba para ver el nombre de la textura
texture_surface = pygame.image.load(getTexture(mesh))
texture_data = pygame.image.tostring(texture_surface, "RGB", 1)
width = texture_surface.get_width()
height = texture_surface.get_height()
texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, width, height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, texture_data)
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
vertex_data = numpy.hstack((
numpy.array(mesh.vertices, dtype=numpy.float32),
numpy.array(mesh.normals, dtype=numpy.float32),
numpy.array(mesh.texturecoords[0], dtype=numpy.float32)
))
index_data = numpy.hstack(
numpy.array(mesh.faces, dtype=numpy.int32)
)
vertex_buffer_object = gl.glGenVertexArrays(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_buffer_object)
gl.glBufferData(gl.GL_ARRAY_BUFFER, vertex_data.nbytes, vertex_data, gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, False, 9 * 4, None)
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, False, 9 * 4, ctypes.c_void_p(3 * 4))
gl.glEnableVertexAttribArray(1)
gl.glVertexAttribPointer(2, 3, gl.GL_FLOAT, False, 9 * 4, ctypes.c_void_p(6 * 4))
gl.glEnableVertexAttribArray(2)
element_buffer_object = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, element_buffer_object)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, index_data.nbytes, index_data, gl.GL_STATIC_DRAW)
diffuse = mesh.material.properties["diffuse"]
gl.glUniform4f(
gl.glGetUniformLocation(shader, "color"),
*diffuse,
1
)
gl.glUniform4f(
gl.glGetUniformLocation(shader, "light"),
int(lighting.x), int(lighting.y), int(lighting.z), 1
)
gl.glDrawElements(gl.GL_TRIANGLES, len(index_data), gl.GL_UNSIGNED_INT, None)
for child in node.children:
glize(child)
def run():
if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0:
print(sdl2.SDL_GetError())
return -1
window = sdl2.SDL_CreateWindow(b"OpenGL demo",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, 800, 600,
sdl2.SDL_WINDOW_OPENGL)
if not window:
print(sdl2.SDL_GetError())
return -1
# Force OpenGL 3.3 'core' context.
# Must set *before* creating GL context!
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, 3)
video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK,
video.SDL_GL_CONTEXT_PROFILE_CORE)
context = sdl2.SDL_GL_CreateContext(window)
quad = [-0.5, -0.5, 0.0, 1.0, 0.0, 0.0,
0.5, -0.5, 0.0, 0.0, 1.0, 0.0,
0.5, 0.5, 0.0, 0.0, 0.0, 1.0,
-0.5, 0.5, 0.0, 1.0, 1.0, 1.0]
quad = numpy.array(quad, dtype=numpy.float32)
indices = [0, 1, 2,
2, 3, 0]
indices = numpy.array(indices, dtype=numpy.uint32)
# Setup GL shaders, data, etc.
vertex_shader = shaders.compileShader("""
#version 330
in vec3 position;
in vec3 color;
out vec3 newColor;
void main()
{
gl_Position = vec4(position, 1.0f);
newColor = color;
}
"""
, GL.GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader("""
#version 330
in vec3 newColor;
out vec4 outColor;
void main()
{
outColor = vec4(newColor, 1.0f);
}
"""
, GL.GL_FRAGMENT_SHADER)
shaderProgram = shaders.compileProgram(vertex_shader, fragment_shader)
GL.glUseProgram(shaderProgram)
# Need VBO for triangle vertices and colours
VBO = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, VBO)
GL.glBufferData(GL.GL_ARRAY_BUFFER, 96, quad, GL.GL_STATIC_DRAW)
EBO = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, EBO)
GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, 24, indices, GL.GL_STATIC_DRAW)
position = GL.glGetAttribLocation(shaderProgram, "position")
GL.glVertexAttribPointer(position, 3, GL.GL_FLOAT, GL.GL_FALSE, 24, ctypes.c_void_p(0))
GL.glEnableVertexAttribArray(position)
color = GL.glGetAttribLocation(shaderProgram, "color")
GL.glVertexAttribPointer(color, 3, GL.GL_FLOAT, GL.GL_FALSE, 24, ctypes.c_void_p(12))
GL.glEnableVertexAttribArray(color)
event = sdl2.SDL_Event()
running = True
GL.glClearColor(0, 0, 0, 1)
while running:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
try:
GL.glClear(GL.GL_COLOR_BUFFER_BIT)
GL.glDrawElements(GL.GL_TRIANGLES, 6, GL.GL_UNSIGNED_INT, None)
finally:
GL.glUseProgram(0)
sdl2.SDL_GL_SwapWindow(window)
sdl2.SDL_Delay(10)
sdl2.SDL_GL_DeleteContext(context)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
return 0
def make_gl_cylinder(self, program, bond_list, vao_list, ribbon=True):
""" Function doc
"""
for bond in bond_list:
if ribbon:
vertices, indexes, colors, normals = shapes.get_cylinder(
bond[0].pos,
bond[0].color,
bond[2],
bond[3],
bond[1],
10,
radius=0.2,
level='level_6')
self.ribbon_indexes = len(indexes)
else:
vertices, indexes, colors, normals = shapes.get_cylinder(
bond[0].pos,
bond[0].color,
bond[2],
bond[3],
bond[1],
10,
radius=0.1,
level='level_6')
self.stick_indexes = len(indexes)
vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(vao)
ind_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ind_vbo)
GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER,
indexes.itemsize * len(indexes), indexes,
GL.GL_STATIC_DRAW)
vert_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vert_vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER,
vertices.itemsize * len(vertices), vertices,
GL.GL_STATIC_DRAW)
att_position = GL.glGetAttribLocation(program, 'coordinate')
GL.glEnableVertexAttribArray(att_position)
GL.glVertexAttribPointer(att_position, 3, GL.GL_FLOAT, GL.GL_FALSE,
3 * vertices.itemsize, ctypes.c_void_p(0))
center_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, center_vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER,
normals.itemsize * len(normals), normals,
GL.GL_STATIC_DRAW)
att_center = GL.glGetAttribLocation(program, 'center')
GL.glEnableVertexAttribArray(att_center)
GL.glVertexAttribPointer(att_center, 3, GL.GL_FLOAT, GL.GL_FALSE,
3 * normals.itemsize, ctypes.c_void_p(0))
col_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, col_vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, colors.itemsize * len(colors),
colors, GL.GL_STATIC_DRAW)
att_colors = GL.glGetAttribLocation(program, 'vert_color')
GL.glEnableVertexAttribArray(att_colors)
GL.glVertexAttribPointer(att_colors, 3, GL.GL_FLOAT, GL.GL_FALSE,
3 * colors.itemsize, ctypes.c_void_p(0))
vao_list.append(vao)
GL.glBindVertexArray(0)
GL.glDisableVertexAttribArray(att_position)
GL.glDisableVertexAttribArray(att_colors)
GL.glDisableVertexAttribArray(att_center)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0)
def init_gl_modern(display_size):
"""
Initialise open GL in the 'modern' open GL style for open GL versions
greater than 3.1.
:param display_size: Size of the window/viewport.
"""
# Create shaders
# --------------------------------------
vertex_code = """
#version 150
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
uniform vec4 colour_mul;
uniform vec4 colour_add;
in vec4 vertex_colour; // vertex colour in
in vec3 vertex_position;
out vec4 vertex_color_out; // vertex colour out
void main()
{
vertex_color_out = (colour_mul * vertex_colour) + colour_add;
gl_Position = projection * view * model * vec4(vertex_position, 1.0);
}
"""
fragment_code = """
#version 150
in vec4 vertex_color_out; // vertex colour from vertex shader
out vec4 fragColor;
void main()
{
fragColor = vertex_color_out;
}
"""
program = GL.glCreateProgram()
vertex = GL.glCreateShader(GL.GL_VERTEX_SHADER)
fragment = GL.glCreateShader(GL.GL_FRAGMENT_SHADER)
GL.glShaderSource(vertex, vertex_code)
GL.glCompileShader(vertex)
# this logs issues the shader compiler finds.
log = GL.glGetShaderInfoLog(vertex)
if isinstance(log, bytes):
log = log.decode()
for line in log.split("\n"):
print(line)
GL.glAttachShader(program, vertex)
GL.glShaderSource(fragment, fragment_code)
GL.glCompileShader(fragment)
# this logs issues the shader compiler finds.
log = GL.glGetShaderInfoLog(fragment)
if isinstance(log, bytes):
log = log.decode()
for line in log.split("\n"):
print(line)
GL.glAttachShader(program, fragment)
GL.glValidateProgram(program)
GL.glLinkProgram(program)
GL.glDetachShader(program, vertex)
GL.glDetachShader(program, fragment)
GL.glUseProgram(program)
# Create vertex buffers and shader constants
# ------------------------------------------
# Cube Data
vertices = zeros(8, [("vertex_position", float32, 3),
("vertex_colour", float32, 4)])
vertices["vertex_position"] = [
[1, 1, 1],
[-1, 1, 1],
[-1, -1, 1],
[1, -1, 1],
[1, -1, -1],
[1, 1, -1],
[-1, 1, -1],
[-1, -1, -1],
]
vertices["vertex_colour"] = [
[0, 1, 1, 1],
[0, 0, 1, 1],
[0, 0, 0, 1],
[0, 1, 0, 1],
[1, 1, 0, 1],
[1, 1, 1, 1],
[1, 0, 1, 1],
[1, 0, 0, 1],
]
filled_cube_indices = array(
[
0,
1,
2,
0,
2,
3,
0,
3,
4,
0,
4,
5,
0,
5,
6,
0,
6,
1,
1,
6,
7,
1,
7,
2,
7,
4,
3,
7,
3,
2,
4,
7,
6,
4,
6,
5,
],
dtype=uint32,
)
outline_cube_indices = array(
[
0, 1, 1, 2, 2, 3, 3, 0, 4, 7, 7, 6, 6, 5, 5, 4, 0, 5, 1, 6, 2, 7,
3, 4
],
dtype=uint32,
)
shader_data = {"buffer": {}, "constants": {}}
GL.glBindVertexArray(GL.glGenVertexArrays(1)) # Have to do this first
shader_data["buffer"]["vertices"] = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, shader_data["buffer"]["vertices"])
GL.glBufferData(GL.GL_ARRAY_BUFFER, vertices.nbytes, vertices,
GL.GL_DYNAMIC_DRAW)
stride = vertices.strides[0]
offset = ctypes.c_void_p(0)
loc = GL.glGetAttribLocation(program, "vertex_position")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 3, GL.GL_FLOAT, False, stride, offset)
offset = ctypes.c_void_p(vertices.dtype["vertex_position"].itemsize)
loc = GL.glGetAttribLocation(program, "vertex_colour")
GL.glEnableVertexAttribArray(loc)
GL.glVertexAttribPointer(loc, 4, GL.GL_FLOAT, False, stride, offset)
shader_data["buffer"]["filled"] = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER,
shader_data["buffer"]["filled"])
GL.glBufferData(
GL.GL_ELEMENT_ARRAY_BUFFER,
filled_cube_indices.nbytes,
filled_cube_indices,
GL.GL_STATIC_DRAW,
)
shader_data["buffer"]["outline"] = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER,
shader_data["buffer"]["outline"])
GL.glBufferData(
GL.GL_ELEMENT_ARRAY_BUFFER,
outline_cube_indices.nbytes,
outline_cube_indices,
GL.GL_STATIC_DRAW,
)
shader_data["constants"]["model"] = GL.glGetUniformLocation(
program, "model")
GL.glUniformMatrix4fv(shader_data["constants"]["model"], 1, False, eye(4))
shader_data["constants"]["view"] = GL.glGetUniformLocation(program, "view")
view = translate(eye(4), z=-6)
GL.glUniformMatrix4fv(shader_data["constants"]["view"], 1, False, view)
shader_data["constants"]["projection"] = GL.glGetUniformLocation(
program, "projection")
GL.glUniformMatrix4fv(shader_data["constants"]["projection"], 1, False,
eye(4))
# This colour is multiplied with the base vertex colour in producing
# the final output
shader_data["constants"]["colour_mul"] = GL.glGetUniformLocation(
program, "colour_mul")
GL.glUniform4f(shader_data["constants"]["colour_mul"], 1, 1, 1, 1)
# This colour is added on to the base vertex colour in producing
# the final output
shader_data["constants"]["colour_add"] = GL.glGetUniformLocation(
program, "colour_add")
GL.glUniform4f(shader_data["constants"]["colour_add"], 0, 0, 0, 0)
# Set GL drawing data
# -------------------
GL.glClearColor(0, 0, 0, 0)
GL.glPolygonOffset(1, 1)
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glDepthFunc(GL.GL_LESS)
GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)
GL.glLineWidth(1.0)
projection = perspective(45.0, display_size[0] / float(display_size[1]),
2.0, 100.0)
GL.glUniformMatrix4fv(shader_data["constants"]["projection"], 1, False,
projection)
return shader_data, filled_cube_indices, outline_cube_indices
def add_vert_attrib(self, name, arr, each):
self.vert_attrib[name] = (GL.glGenBuffers(1), each)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vert_attrib[name][0])
GL.glBufferData(GL.GL_ARRAY_BUFFER, arr.nbytes, arr, GL.GL_STATIC_DRAW)
0.5, 0.5, 0, 1, 0, 0, 1, 1,
0.5, -0.5, 0, 0, 1, 0, 1, 0,
-0.5, -0.5, 0, 0, 0, 1, 0, 0,
-0.5, 0.5, 0, 1, 1, 0, 0, 1
], dtype=numpy.float32)
index_data = numpy.array([
0, 1, 3,
1, 2, 3
], dtype=numpy.uint32)
vertex_array_object = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vertex_array_object)
vertex_buffer_object = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_buffer_object)
gl.glBufferData(gl.GL_ARRAY_BUFFER, vertex_data.nbytes, vertex_data, gl.GL_STATIC_DRAW)
element_buffer_object = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, element_buffer_object)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, index_data.nbytes, index_data, gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, False, 8 * 4, ctypes.c_void_p(0))
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT, False, 8 * 4, ctypes.c_void_p(3 * 4))
gl.glEnableVertexAttribArray(1)
gl.glVertexAttribPointer(2, 2, gl.GL_FLOAT, False, 8 * 4, ctypes.c_void_p(6 * 4))
gl.glEnableVertexAttribArray(2)
# glfw requires shaders to be compiled after buffer binding
def __init__(self):
# Load Shader
self.attrib_locs = {
"aPosCoord": -1,
"aTexCoord": -1
}
self.uniform_locs = {
"tsdf": -1,
"tsdf_cnt": -1,
"s2w": -1,
"c": -1,
"vol_dim": -1,
"volStart": -1,
"volEnd": -1,
"random_colors": -1
}
vert_prog = shaders.compileShader(open('tsdf_render.vert').read(), gl.GL_VERTEX_SHADER)
if not gl.glGetShaderiv(vert_prog, gl.GL_COMPILE_STATUS):
sys.stderr.write("Error: Could not compile vertex shader.\n")
exit(2)
frag_prog = shaders.compileShader(open('tsdf_render.frag').read(), gl.GL_FRAGMENT_SHADER)
if not gl.glGetShaderiv(frag_prog, gl.GL_COMPILE_STATUS):
sys.stderr.write("Error: Could not compile fragment shader.\n")
exit(3)
self.program = gl.glCreateProgram()
gl.glAttachShader(self.program, vert_prog)
gl.glAttachShader(self.program, frag_prog)
gl.glLinkProgram(self.program)
if gl.glGetProgramiv(self.program, gl.GL_LINK_STATUS) != gl.GL_TRUE:
sys.stderr.write("Error: {0}\n".format(gl.glGetProgramInfoLog(self.program)))
exit(4)
for name in self.attrib_locs:
self.attrib_locs[name] = gl.glGetAttribLocation(self.program, name)
for name in self.uniform_locs:
self.uniform_locs[name] = gl.glGetUniformLocation(self.program, name)
vertices = np.array([-1, -1, -1, 1, 1, -1, 1, 1], np.float32)
texture_coords = np.array([0, 1, 0, 0, 1, 1, 1, 0], np.float32)
# Load Object
self.vbos = gl.glGenBuffers(2)
self.vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(self.vao)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glEnableVertexAttribArray(self.attrib_locs['aPosCoord'])
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbos[0])
gl.glBufferData(gl.GL_ARRAY_BUFFER, 8 * 4, vertices, gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(self.attrib_locs['aPosCoord'], 2, gl.GL_FLOAT, False, 0, ctypes.c_void_p(0))
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glEnableVertexAttribArray(self.attrib_locs['aTexCoord'])
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbos[1])
gl.glBufferData(gl.GL_ARRAY_BUFFER, 8 * 4, texture_coords, gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(self.attrib_locs['aTexCoord'], 2, gl.GL_FLOAT, False, 0, ctypes.c_void_p(0))
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glBindVertexArray(0)
gl.glUseProgram(self.program)
gl.glUniform1i(self.uniform_locs['tsdf'], 0)
gl.glUniform1i(self.uniform_locs['tsdf_cnt'], 1)
rand_colors = np.random.rand(32, 3)
gl.glUniform3fv(self.uniform_locs['random_colors'], 32, rand_colors.astype(np.float32))
def make_gl_sphere(self, program, atom_list, vao_list, covalent=True):
""" Function doc
"""
for atom in atom_list:
if covalent:
vertices, indexes, colors = shapes.get_sphere(atom.pos,
atom.cov_rad,
atom.color,
level='level_2')
else:
vertices, indexes, colors = shapes.get_sphere(atom.pos,
atom.ball_radius,
atom.color,
level='level_2')
centers = [atom.pos[0], atom.pos[1], atom.pos[2]] * len(indexes)
centers = np.array(centers, dtype=np.float32)
vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(vao)
atom.triangles = len(indexes)
ind_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, ind_vbo)
GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER,
indexes.itemsize * len(indexes), indexes,
GL.GL_STATIC_DRAW)
vert_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vert_vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER,
vertices.itemsize * len(vertices), vertices,
GL.GL_STATIC_DRAW)
att_position = GL.glGetAttribLocation(program, 'coordinate')
GL.glEnableVertexAttribArray(att_position)
GL.glVertexAttribPointer(att_position, 3, GL.GL_FLOAT, GL.GL_FALSE,
3 * vertices.itemsize, ctypes.c_void_p(0))
center_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, center_vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER,
centers.itemsize * len(centers), centers,
GL.GL_STATIC_DRAW)
att_center = GL.glGetAttribLocation(program, 'center')
GL.glEnableVertexAttribArray(att_center)
GL.glVertexAttribPointer(att_center, 3, GL.GL_FLOAT, GL.GL_FALSE,
3 * centers.itemsize, ctypes.c_void_p(0))
col_vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, col_vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, colors.itemsize * len(colors),
colors, GL.GL_STATIC_DRAW)
att_colors = GL.glGetAttribLocation(program, 'vert_color')
GL.glEnableVertexAttribArray(att_colors)
GL.glVertexAttribPointer(att_colors, 3, GL.GL_FLOAT, GL.GL_FALSE,
3 * colors.itemsize, ctypes.c_void_p(0))
vao_list.append(vao)
GL.glBindVertexArray(0)
GL.glDisableVertexAttribArray(att_position)
GL.glDisableVertexAttribArray(att_colors)
GL.glDisableVertexAttribArray(att_center)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0)
