import sys
import os
sys.path.append(os.getcwd())
from OpenGL.GL import *
import glfw
from glfw.GLFW import *
from glfw import _GLFWwindow as GLFWwindow
import glm
from includes.GLFW.init_glfw import init_glfw
from includes.GL.init_buffers import init_buffers
from includes.GL.GLArcball import GLArcball
from includes.GL.GLRectangle import GLRectangle
global view_state
view_state = {
'eye': glm.vec3( 0, 0, 2000.0 ),
'target': glm.vec3( 0,0,0 ),
'position': glm.vec3( 0,0,0 ),
'up': glm.vec3( 0,1,0 ),
'near': -500000,
'far': 50000,
'window_width': None,
'window_height': None,
'lookAt': glm.mat4(1.0),
}
global input_state
input_state = {
'shift_left': {
'isDown': False
},
'mouse_right': {
'isDown': False
},
'mouse_X_prev': None,
'mouse_Y_prev': None,
'mouse_X_cur': None,
'mouse_Y_cur': None
}
global camera
camera = GLArcball( view_state['eye'], view_state['position'], view_state['up'])
def mouse_callback(window, xpos, ypos):
if (input_state['shift_left']['isDown'] == True and
input_state['mouse_right']['isDown'] == True):
input_state['mouse_X_cur'] = xpos
input_state['mouse_Y_cur'] = ypos
cur_mouse_ndc = camera.mouse_to_ndc(xpos,
ypos,
view_state['window_width'],
view_state['window_height'])
if input_state['mouse_X_prev'] != None:
prev_mouse_ndc = camera.mouse_to_ndc(input_state['mouse_X_prev'],
input_state['mouse_Y_prev'],
view_state['window_width'],
view_state['window_height'])
camera.rotate(prev_mouse_ndc, cur_mouse_ndc)
input_state['mouse_X_prev'] = xpos
input_state['mouse_Y_prev'] = ypos
def mouse_button_callback(window, button, action, mods):
if button == glfw.MOUSE_BUTTON_RIGHT:
if action == glfw.PRESS:
input_state['mouse_right']['isDown'] = True
elif action == glfw.RELEASE:
input_state['mouse_right']['isDown'] = False
input_state['mouse_X_prev'] = None
input_state['mouse_Y_prev'] = None
input_state['mouse_X_cur'] = None
input_state['mouse_Y_cur'] = None
def key_callback(window, key, scancode, action, mods):
if key == glfw.KEY_LEFT_SHIFT:
if action == glfw.PRESS:
input_state['shift_left']['isDown'] = True
elif action == glfw.RELEASE:
input_state['shift_left']['isDown'] = False
def scrollwheel_callback(window, xdelta, ydelta):
scale_factor = 1.0
if(ydelta==1.0):
scale_factor=1.1
else:
scale_factor=0.9
def framebuffer_size_callback(window: GLFWwindow, width: int, height: int) -> None:
glViewport(0, 0, width, height)
def main():
win_width, win_height, window = init_glfw("LearnOpenGL")
global bufs_enum
bufs_enum = init_buffers(50000000, 50000000)
view_state['window_width'] = win_width
view_state['window_height'] = win_height
view_state['lookAt'] = glm.lookAt(view_state['eye'], glm.vec3(0, 0, 0), glm.vec3(0, 1, 0))
view_state['ortho'] = glm.ortho(-(view_state['window_width'] / 2),
view_state['window_width'] / 2,
-(view_state['window_height'] / 2),
view_state['window_height'] / 2,
view_state['near'],
view_state['far'])
glfwSetScrollCallback(window, scrollwheel_callback)
glfwSetWindowAspectRatio(window, int(win_width), int(win_height))
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback)
glfwSetKeyCallback(window, key_callback)
glfwSetMouseButtonCallback(window, mouse_button_callback)
glfwSetCursorPosCallback(window, mouse_callback)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glViewport(0, 0, win_width, win_height)
init_objects(bufs_enum)
while not glfwWindowShouldClose(window):
render(window)
glfwTerminate()
print('done...')
def init_objects(bufs_enum):
global vbo_start
vbo_start = 0
global ebo_start
ebo_start = 0
global rectangle1
rectangle1 = GLRectangle(-25, 25, 25, 25, 0, (1.0, 0.0, 0.0, 1.0), (0.0, 1.0, 0.0, 1.0), vbo_start, ebo_start)
rectangle1.setup_buffers(bufs_enum)
vbo_start = rectangle1.vbo_end
ebo_start = rectangle1.ebo_end
print('vbo_start:', vbo_start)
print('ebo_start', ebo_start )
global rectangle2
rectangle2 = GLRectangle(-25, 25, 25, 25, 0, (1.0, 0.0, 0.0, 1.0), (0.0, 1.0, 0.0, 1.0), vbo_start, ebo_start)
rectangle2.setup_buffers(bufs_enum)
rectangle2.model = glm.translate( rectangle2.model, glm.vec3( 5.0, 5.0, 0.0 ) )
print('vbo_start:', rectangle2.vbo_start)
print('ebo_start', rectangle2.ebo_start )
def render(window):
while not glfwWindowShouldClose(window):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
rectangle1.draw(bufs_enum, camera.transform(), view_state['ortho'])
rectangle2.draw(bufs_enum, camera.transform(), view_state['ortho'])
glfwSwapBuffers(window)
glfwPollEvents()
glClearColor(0.2, 0.3, 0.3, 1.0)
if __name__ == "__main__":
main()
import numpy as np
from OpenGL.GL import *
import glm
from includes.GL.utils import bytes_to_item
from includes.GL.shader_funcs import create_shader_program
class GLRectangle:
def __init__(self, x1, y1, x2, y2, z, color, fill_color, vbo_start, ebo_start, isShaderActive=True):
self.vbo_start = vbo_start
self.ebo_start = ebo_start
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
self.model = glm.mat4(1.0)
self.color = color
self.fill_color = fill_color
self.vertices = np.array([
(self.x1, self.y1, z),
(self.x2, self.y1, z),
(self.x2, self.y2, z),
(self.x1, self.y2, z)
], dtype=np.float32)
self.gl_indices = np.array([0, 1, 2, 2, 3, 0], dtype=np.uint32)
self.gl_vertices = self.setup_gl_vertices()
self.EBW=40
self.triangle_fill_vs = self.triangle_fill_vs()
self.triangle_fill_fs = self.triangle_fill_fs()
self.isShaderActive = isShaderActive
if(self.isShaderActive):
pass
self.shader_program = create_shader_program(self.triangle_fill_vs, self.triangle_fill_fs)
self.vbo_end = self.vbo_start + self.gl_vertices.nbytes
self.ebo_end = self.ebo_start + self.gl_indices.nbytes
def setup_gl_vertices(self):
gl_vertices=[]
for vertex in self.vertices:
vertex = [vertex[0], vertex[1], vertex[2], 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
gl_vertices.append(vertex)
return np.array(gl_vertices, dtype=np.float32)
def setup_buffers(self, bufs_enum):
glBindVertexArray(bufs_enum['VAO'])
glBindBuffer(GL_ARRAY_BUFFER, bufs_enum['VBO'])
glBufferSubData(GL_ARRAY_BUFFER, self.vbo_start, self.gl_vertices.nbytes, ctypes.c_void_p(self.gl_vertices.ctypes.data))
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufs_enum['EBO'])
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, self.ebo_start, self.gl_indices.nbytes, ctypes.c_void_p(self.gl_indices.ctypes.data))
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(0)
def drawPoints(self, bufs_enum, point_size, view, projection):
glUseProgram(self.shader_program)
model = glGetUniformLocation(self.shader_program, "model")
view_loc = glGetUniformLocation(self.shader_program, "view")
projection_loc = glGetUniformLocation(self.shader_program, "projection")
glUniformMatrix4fv(model, 1, GL_FALSE, glm.value_ptr(self.model))
glUniformMatrix4fv(view_loc, 1, GL_FALSE, glm.value_ptr(view))
glUniformMatrix4fv(projection_loc, 1, GL_FALSE, glm.value_ptr(projection))
glBindVertexArray(bufs_enum['VAO'])
glBindBuffer(GL_ARRAY_BUFFER, bufs_enum['VBO'])
draw_start = bytes_to_item(self.vbo_start, self.EBW)
draw_count = len(self.vertices)
glPointSize(point_size)
##print(self.vbo_start)
glDrawArrays(GL_POINTS, draw_start, draw_count)
def draw(self, bufs_enum, view, projection):
glDisable(GL_CULL_FACE)
glUseProgram(self.shader_program)
model = glGetUniformLocation(self.shader_program, "model")
view_loc = glGetUniformLocation(self.shader_program, "view")
projection_loc = glGetUniformLocation(self.shader_program, "projection")
glUniformMatrix4fv(model, 1, GL_FALSE, glm.value_ptr(self.model))
glUniformMatrix4fv(view_loc, 1, GL_FALSE, glm.value_ptr(view))
glUniformMatrix4fv(projection_loc, 1, GL_FALSE, glm.value_ptr(projection))
glBindVertexArray(bufs_enum['VAO'])
glBindBuffer(GL_ARRAY_BUFFER, bufs_enum['VBO'])
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufs_enum['EBO'])
# Draw elements
glDrawElements(GL_TRIANGLES, len(self.gl_indices), GL_UNSIGNED_INT, ctypes.c_void_p(self.ebo_start))
# Check for OpenGL errors
error_code = glGetError()
if error_code != GL_NO_ERROR:
print(f"OpenGL error: {error_code}")
def triangle_fill_vs(self):
shdr_str = """
#version 460 core
layout (location = 0) in vec4 aPos;
layout (location = 1) in vec4 aColor;
layout (location = 2) in vec2 aTexCoord;
out vec4 ourColor;
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
void main()
{
gl_Position = projection * view * model * aPos;
ourColor = aColor;
}
"""
return shdr_str
def triangle_fill_fs(self):
shdr_str = """
#version 460 core
out vec4 FragColor;
in vec4 ourColor;
void main()
{
FragColor = ourColor;
}
"""
return shdr_str
It appears that if the second rectangle, rectangle2 is removed from code that the first rectangle, rectangle1, does draw into the client area of the window. If the code for second rectangle, rectangle2 is in code however neither rectangle1 or rectangle2 will draw and the window opens to a mostly blank window, except for the clear color. Why is this happening? How to get both of the rectangles drawing?
I tried many different ways of using GL error checking as implemented in Python and there was no error to report so far the way that I had used those tools.
New contributor
Francesco Amatto is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.