def renderGL(self):
"""opengl render method"""
# get the time in seconds
t = glfwGetTime()
# clear first
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# use the shader program
glUseProgram(self.__shaderProgram)
# calculate ViewProjection matrix
projection = glm.perspective(90.0, 4.0 / 3.0, .1, 100.0)
projection = np.array(projection, dtype=np.float32)
# translate the world/view position
view = glm.translate(glm.mat4(1.0), glm.vec3(0.0, 0.0, -50.0))
# make the camera rotate around the origin
view = glm.rotate(view, 30.0 * math.sin(t * 0.1), glm.vec3(1.0, 0.0, 0.0))
view = glm.rotate(view, -22.5 * t, glm.vec3(0.0, 1.0, 0.0))
view = np.array(view, dtype=np.float32)
# set the uniform
glUniformMatrix4fv(self.__viewLocation, 1, GL_FALSE, view)
glUniformMatrix4fv(self.__projLocation, 1, GL_FALSE, projection)
# bind the vao
glBindVertexArray(self.__vao)
# draw
glDrawArrays(GL_POINTS, 0, self.__particles)
glBindVertexArray(0)
glUseProgram(0)
def renderGL(self):
"""opengl render method"""
# get the time in seconds
t = glfwGetTime()
# clear first
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# use the shader program
glUseProgram(self.__shaderProgram)
# calculate ViewProjection matrix
projection = glm.perspective(90.0, 4.0 / 3.0, .1, 100.0)
# translate the world/view position
view = glm.translate(glm.mat4(1.0), glm.vec3(0.0, 0.0, -5.0))
# make the camera rotate around the origin
view = glm.rotate(view, 90.0 * t, glm.vec3(1.0, 1.0, 1.0))
viewProjection = np.array(projection * view, dtype=np.float32)
# set the uniform
glUniformMatrix4fv(self.__vpLocation, 1, GL_FALSE, viewProjection)
# bind the vao
glBindVertexArray(self.__vao)
# draw
# the additional parameter indicates how many instances to render
glDrawElementsInstanced(GL_TRIANGLES, 6 * 6, GL_UNSIGNED_INT, None, 8)
glBindVertexArray(0)
glUseProgram(0)
def _generate_nodeview_matrix2(
rsm_version: int, node: AbstractNode) -> Tuple[glm.mat4, glm.mat4]:
# Transformations which are inherited by children
local_transform_matrix = glm.mat4()
rsm_node = node.impl
# Scaling
if len(rsm_node.scale_key_frames) > 0:
local_transform_matrix = glm.scale(
local_transform_matrix,
glm.vec3(rsm_node.scale_key_frames[0].scale))
# Rotation
if len(rsm_node.rot_key_frames) > 0:
# Animated model
key_frame = rsm_node.rot_key_frames[0]
quaternion = glm.quat(key_frame.quaternion[3], key_frame.quaternion[0],
key_frame.quaternion[1], key_frame.quaternion[2])
local_transform_matrix *= glm.mat4_cast(quaternion)
else:
# Static model
local_transform_matrix = rag_mat4_mul(
local_transform_matrix, mat3tomat4(rsm_node.info.offset_matrix))
if node.parent:
parent_offset_matrix = mat3tomat4(
node.parent.impl.info.offset_matrix)
local_transform_matrix = rag_mat4_mul(
local_transform_matrix, glm.inverse(parent_offset_matrix))
# Translation
if rsm_version >= 0x203 and len(rsm_node.pos_key_frames) > 0:
key_frame = rsm_node.pos_key_frames[0]
position = glm.vec3(key_frame.position)
elif node.parent:
position = glm.vec3(rsm_node.info.offset_vector) - \
glm.vec3(node.parent.impl.info.offset_vector)
parent_offset_matrix = mat3tomat4(node.parent.impl.info.offset_matrix)
position = glm.vec3(
glm.inverse(parent_offset_matrix) * glm.vec4(position, 1.0))
else:
position = glm.vec3(rsm_node.info.offset_vector)
# Transformations which are applied only to this node
final_transform_matrix = copy.copy(local_transform_matrix)
# Reset translation transformation to `position`
final_transform_matrix[3] = glm.vec4(position, 1.0)
# Inherit transformations from ancestors
parent = node.parent
while parent:
final_transform_matrix = rag_mat4_mul(final_transform_matrix,
parent.local_transform_matrix)
parent = parent.parent
if node.parent:
parent_translation = glm.vec3(node.parent.final_transform_matrix[3])
final_transform_matrix[3] += glm.vec4(parent_translation, 0.0)
return (local_transform_matrix, final_transform_matrix)
def get_tx_point(self, offset):
body_pos = self.body.position
angle = self.body.angle
tx = glm.mat4()
tx = glm.rotate(tx, angle, glm.vec3(0, 0, 1))
rel_pos = tx * glm.vec4(offset[0], offset[1], 0, 1)
pos = rel_pos + glm.vec4(body_pos[0], body_pos[1], 0, 1)
return (pos[0], pos[1])
def __init__(self, mat:Optional[glm.Mat4]=None) -> None:
if mat is None:
self.mat = glm.mat4()
pass
else:
self.mat = mat
pass
pass
def transformation_matrix(self) -> glm.mat4:
if not self.has_physics:
trans = glm.translate(glm.mat4(1), self._location)
trans *= glm.rotate(glm.mat4(1), self._rotation / 180 * glm.pi(), glm.vec3(0, 0, 1))
return trans
pos, quat = pybullet.getBasePositionAndOrientation(
bodyUniqueId=self._body_id,
physicsClientId=self._physics_client_id,
)
mat3 = pybullet.getMatrixFromQuaternion(quat)
return glm.rotate(glm.mat4(
mat3[0], mat3[3], mat3[6], 0,
mat3[1], mat3[4], mat3[7], 0,
mat3[2], mat3[5], mat3[8], 0,
pos[0], pos[1], pos[2], 1,
), math.pi/2., [1, 0, 0])
def model(angle, r_x, r_y, r_z, t_x, t_y, t_z, s_x, s_y, s_z):
angle = math.radians(angle)
matrix_transform = glm.mat4(1.0)
matrix_transform = glm.rotate(matrix_transform, angle, glm.vec3(r_x, r_y, r_z))
matrix_transform = glm.translate(matrix_transform, glm.vec3(t_x, t_y, t_z))
matrix_transform = glm.scale(matrix_transform, glm.vec3(s_x, s_y, s_z))
matrix_transform = np.array(matrix_transform).T
return matrix_transform
def getViewMatrix(self):
i = glm.mat4(1)
camTranslate = glm.translate(i, self.camPosition)
camPitch = glm.rotate(i, glm.radians( self.camRotation.x ), glm.vec3(1,0,0))
camYaw = glm.rotate(i, glm.radians( self.camRotation.y ), glm.vec3(0,1,0))
camRoll = glm.rotate(i, glm.radians( self.camRotation.z ), glm.vec3(0,0,1))
camRotate = camPitch * camYaw * camRoll
return glm.inverse( camTranslate * camRotate )
def render_side_view(camera_intrinsic,
camera_extrinsic,
width,
height,
stereo_index,
hand_color=glm.vec4(0.8, 0.8, 0.8, 0)):
##
# draw grid
##
shader_program.use()
shader_program.set_matrix(
"projection", build_projection_matrix(camera_intrinsic, width, height))
shader_program.set_matrix(
"view", build_model_view_matrix(camera_extrinsic[stereo_index]))
m = glm.mat4(1.0)
m = glm.scale(m, glm.vec3(70))
shader_program.set_matrix("model", glm.value_ptr(m))
shader_program.un_use()
grid_model.draw(shader_program, draw_type=GL_LINES)
##
# draw cube
##
cube_shader_program.use()
cube_shader_program.set_matrix(
"projection", build_projection_matrix(camera_intrinsic, width, height))
cube_shader_program.set_matrix(
"view", build_model_view_matrix(camera_extrinsic[stereo_index]))
m = glm.mat4(1.0)
m = glm.translate(m, model_position[2])
m = glm.rotate(m, glm.radians(model_position[1][0][0]),
model_position[1][0][1])
m = glm.rotate(m, glm.radians(model_position[1][1][0]),
model_position[1][1][1])
m = glm.rotate(m, glm.radians(model_position[1][2][0]),
model_position[1][2][1])
m = glm.scale(m, model_position[0])
cube_shader_program.set_matrix("model", glm.value_ptr(m))
cube_shader_program.set_uniform_3f("handColor", hand_color)
cube_shader_program.set_uniform_3f("lightColor", light_color)
cube_shader_program.set_uniform_3f("lightPos", light_position)
cube_shader_program.un_use()
hand_model.draw(cube_shader_program, draw_type=GL_TRIANGLES)
def move(self):
# x_increase = math.cos(math.radians(self.camera.x_angle + 90)) * self.speed
# z_increase = math.sin(math.radians(self.camera.x_angle + 90)) * self.speed
pre_pos = glm.vec3(glm.column(glm.translate(glm.mat4(self.model.matrix4), glm.vec3(0, 0, 5)), 3))
if pre_pos[0] <= 0.49 and pre_pos[0] >= -0.49 \
and pre_pos[1] <= 0.49 and pre_pos[1] >= 0 \
and pre_pos[2] <= 0.49 and pre_pos[2] >= -0.49:
self.model.translate(0, 0, 5)
def update0():
global camera_matrix, move_matrix
camera_matrix = glm.translate(
mat4(
make_camera_orientation_matrix(rotation_ypr.x, rotation_ypr.y,
rotation_ypr.z)), -position)
move_matrix = glm.transpose(
make_camera_orientation_matrix(rotation_ypr.x, 0.0, 0.0))
def updateViewMatrix(self):
rotM = glm.mat4(1.0)
rotM = glm.rotate(rotM, glm.radians(self.rotation.x),
glm.vec3(1.0, 0.0, 0.0))
rotM = glm.rotate(rotM, glm.radians(self.rotation.y),
glm.vec3(0.0, 1.0, 0.0))
rotM = glm.rotate(rotM, glm.radians(self.rotation.z),
glm.vec3(0.0, 0.0, 1.0))
transM = glm.translate(glm.mat4(1.0), self.position)
if self.typecam == CameraType.firstperson:
self.matrices['view'] = rotM * transM
else:
self.matrices['view'] = transM * rotM
self.updated = True
def __init__(self, pos: glm.vec3, size: glm.vec3, rotation: glm.vec3): self._pos = pos self._size = size self._rot = glm.mod(rotation, 360.0) self._rotHint = rotation self.__posChanged = True self.__sizeChanged = True self.__rotChanged = True self.matrix = glm.mat4(1.0) self._transMat = glm.mat4(1.0) self._scaleMat = glm.mat4(1.0) self._rotQuat = glm.quat(self._rot) self.RecalculateMatrices()
def aniInit(width, height):
settings = aniSettings()
settings.projection = glm.mat4(1)
settings.world = glm.mat4(1)
pg.init()
pg.display.set_mode(size=(0, 0), flags=FULLSCREEN | DOUBLEBUF | OPENGL, display=1)
settings.resolution = pg.display.get_window_size()
settings.render_res = 400
# glEnableClientState(GL_VERTEX_ARRAY)
# glEnableClientState(GL_TEXTURE_COORD_ARRAY)
settings.vao = glGenVertexArrays(1)
initRenderBuffers(settings)
glEnable(GL_CULL_FACE)
glEnable(GL_DEPTH_TEST)
glPointSize(5.0)
glLineWidth(0.5)
return settings
def twist(xi):
M = glm.mat4(0.0, xi[2], -xi[1], 0.0,
-xi[2], 0.0, xi[0], 0.0,
xi[1], -xi[0], 0.0, 0.0,
xi[3], xi[4], xi[5], 0.0)
return M
def getWorldMat(self):
ret = glm.mat4()
if self.parent:
ret = self.parent.getWorldMatForChild()
if self.clone:
ret = self.clone.getWorldMat()
return ret * self.worldMat * self.predefinedMat
def getModelMat(self):
mat = glm.mat4(1.0)
mat = glm.rotate(mat, glm.radians(self.__z), (0.0, 0.0, 1.0))
mat = glm.rotate(mat, glm.radians(self.__y), (0.0, 1.0, 0.0))
mat = glm.rotate(mat, glm.radians(self.__x), (1.0, 0.0, 0.0))
return mat
def update_sphere_positions(self):
for idx, sphere in enumerate(self.spheres):
if idx % 2 == 0:
new_sphere_position = glm.vec3(
glm.rotate(glm.mat4(1.0), 0.00090, glm.vec3(0.0, 1.0, 0.5))
* glm.vec4(sphere.get_position(), 1.0))
elif idx % 3 == 0:
new_sphere_position = glm.vec3(
glm.rotate(glm.mat4(1.0), 0.00110, glm.vec3(0.5, 1.0, 1.0))
* glm.vec4(sphere.get_position(), 1.0))
else:
new_sphere_position = glm.vec3(
glm.rotate(glm.mat4(1.0), -0.00250, glm.vec3(
1.0, 1.0, 0.0)) * glm.vec4(sphere.get_position(), 1.0))
sphere.set_position(new_sphere_position)
sphere.set_radius(sphere.get_radius() * 1.0 +
((random.random() - 0.5) / 50.0))
def CreateTransform3D(pos: glm.vec3, size: glm.vec3,
rot: glm.vec3) -> glm.mat4:
transform = glm.translate(glm.mat4(1.0), pos)
transform = glm.scale(transform, size)
transform = glm.rotate(transform, rot.x, glm.vec3(1.0, 0.0, 0.0))
transform = glm.rotate(transform, rot.y, glm.vec3(0.0, 1.0, 0.0))
return glm.rotate(transform, rot.z, glm.vec3(0.0, 0.0, 1.0))
def __init__(self, shape, voxel):
self.__shape = shape
self.__voxel = voxel
self.__cube_model = glm.scale(glm.translate(glm.mat4(1), glm.vec3(-1)),
glm.vec3(2))
self.__invalid = True
self.__current_mark = None
self.__current_add = None
def __init__(self, position, rotation, fov, draw_distance, aspect_ratio):
Entity.__init__(self, position, rotation)
self.fov = fov
self.draw_distance = draw_distance
self.aspect_ratio = aspect_ratio
self.cam_speed = 30
self.rot_speed = 10
self.view_matrix = glm.mat4()
self.proj_matrix = glm.mat4()
self.target = None
self.update(0)
self.update_projection()
def __init__(self):
self.imgFilename = None
self.imgSize = None
self.image = None
self.camera = None
self.matrixStack = [glm.mat4(1.0)]
self.currentMatrix = glm.mat4(1.0)
self.lights = []
self.group = Group()
self.ambient = None
self.currentMaterial = Material()
self.backgroundColor = glm.vec3(0.7, 0.7, 0.7)
def getView(self):
m = glm.mat4(1.0)
m = glm.translate(m, self.offset)
m = glm.rotate(m, glm.radians(self.pitch), (1, 0, 0))
m = glm.rotate(m, glm.radians(self.yaw), (0, 1, 0))
m = glm.translate(m, self.pos)
return m
def on_draw(self, event):
# Read about depth testing and changing stated in vispy here http://vispy.org/gloo.html?highlight=set_state
gloo.clear(color=[0.2, 0.3, 0.3, 1.0], depth=True)
self.view = glm.mat4(1.0)
self.view = glm.translate(self.view, glm.vec3(0.0, 0.0, -3.0))
# to rotate camera along 45 degree or unit vector's direction
# self.view = glm.rotate(self.view, (time() - self.startTime)* glm.radians(50), glm.vec3(1, 1, 1))
self.projection = glm.mat4(1.0)
self.projection = glm.perspective(glm.radians(45.0),
builtins.width / builtins.height,
0.1, 100.0)
# vispy takes numpy array in m * n matrix form
self.view = (np.array(self.view.to_list()).astype(np.float32))
self.projection = (np.array(self.projection.to_list()).astype(
np.float32))
# reshaping to (m, n) to (1, m*n) to support data input in vispy
self.view = self.view.reshape(
(1, self.view.shape[0] * self.view.shape[1]))
self.projection = self.projection.reshape(
(1, self.projection.shape[0] * self.projection.shape[1]))
self.program['view'] = self.view
self.program['projection'] = self.projection
i = 0
for cubePosition in self.cubePositions:
i += 1
self.model = glm.mat4(1.0)
self.model = glm.translate(self.model, cubePosition)
self.model = glm.rotate(
self.model,
glm.radians(
(time() - self.startTime) * glm.radians(2000) * i / 2),
glm.vec3(1.0, 0.3, 0.5))
self.model = (np.array(self.model.to_list()).astype(np.float32))
self.model = self.model.reshape(
(1, self.model.shape[0] * self.model.shape[1]))
self.program['model'] = self.model
self.program.draw('triangles')
self.update()
def refresh_MVP(self):
self.P = glm.perspective(np.radians(self.view_angle), self.width/self.height, 1, 3)
self.MV = glm.translate(glm.mat4(), glm.vec3(self.position_x, self.position_y, -2))
self.MV = glm.rotate(self.MV, np.radians(self.angle_x), glm.vec3(1,0,0))
self.MV = glm.rotate(self.MV, np.radians(self.angle_y), glm.vec3(0,1,0))
self.MVP = np.array(self.P * self.MV)
self.MV = np.array(self.MV)
def update(dt):
nonlocal t
m = glm.mat4(1)
m = glm.rotate(m, t, (0, 0, 1))
shader.uniforms.model = m
shader.uniforms.view = view
shader.uniforms.proj = proj
t += dt
def compute_plane_minmax(position, far_screen, split):
pm = glm.mat4(position, position, position, position)
s0 = (far_screen - pm) * split + pm
min0 = glm.min(s0[0], s0[1], s0[2], s0[3])
max0 = glm.max(s0[0], s0[1], s0[2], s0[3])
return min0, max0
def update_mesh(self, mesh: MeshObject, time: float, dt: float):
t = self._walk_time
amount = self._walking
head = glm.translate(glm.mat4(), glm.vec3(0, 0, 3))
head = glm.rotate(head, self._head_rotation / 180. * math.pi,
glm.vec3(0, 0, 1))
mesh.part_transforms[0] = head
d = -1
for i in range(2):
rest_pos = glm.vec3(.4 * d, 0.1, 0)
walk_pos = glm.vec3(.4 * d, .3 * math.sin(t + d * 1.57), 0)
foot = glm.translate(glm.mat4(), glm.mix(rest_pos, walk_pos,
amount))
foot = glm.scale(foot, glm.vec3(.3, .5, .3))
mesh.part_transforms[i + 1] = foot
d = 1
def transform(vertex):
vertex = glm.vec3(*vertex)
i = glm.mat4(1)
model = glm.translate(i, glm.vec3(0, -1300, 500)) * glm.rotate(
i, glm.radians(0), glm.vec3(0, 0, 1)) * glm.scale(
i, glm.vec3(200, 200, 200))
view = glm.lookAt(glm.vec3(0, 0, 200), glm.vec3(0, 0, 0),
glm.vec3(0, 1, 0))
proyeccion = glm.mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -0.00069, 0, 0, 0,
1)
viewport = glm.mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1000, 1000, 1000,
1)
vertex = glm.vec4(vertex, 1)
vertex = viewport * proyeccion * view * model * vertex
vertex = glm.vec3(vertex / vertex.w)
return vertex
def project_transform(self, event, **kwargs):
#return glm.mat4(1)
#self.store_id('project', proj, shader_id)
# w, h = self.window_size
# proj = glm.perspective(glm.radians(45), w / h, 1, 100)
proj = glm.mat4(1)
return proj
def __init__(self, path):
self.meshes = []
if not os.path.exists(path):
raise RuntimeError(f'Model source file {path} does not exists.')
self.path = path
self.model = glm.mat4()
data = self.__loadAndGetData()
for meshData in data['meshes']:
self.meshes.append(Mesh(meshData))
def getMatrix(self):
i = glm.mat4(1)
translate = glm.translate(i, self.position)
pitch = glm.rotate(i, glm.radians(self.rotation.x), glm.vec3(1, 0, 0))
yaw = glm.rotate(i, glm.radians(self.rotation.y), glm.vec3(0, 1, 0))
roll = glm.rotate(i, glm.radians(self.rotation.z), glm.vec3(0, 0, 1))
rotate = pitch * yaw * roll
scale = glm.scale(i, self.scale)
return translate * rotate * scale
def renderGL(self):
"""opengl render method"""
# get the time in seconds
t = glfwGetTime()
# use the transform shader program
glUseProgram(self.__tshaderProgram)
# set the uniforms
glUniform3fv(self.__centerLocation, 3, self.__center)
glUniform1fv(self.__radiusLocation, 3, self.__radius)
glUniform3fv(self.__gLocation, 1, self.__g)
glUniform1f(self.__dtLocation, self.__dt)
glUniform1f(self.__bounceLocation, self.__bounce)
glUniform1i(self.__seedLocation, randint(0, 0x7fff))
# bind the current vao
glBindVertexArray(self.__vao[(self.__currentBuffer + 1) % self.__bufferCount])
# bind transform feedback target
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, self.__vbo[self.__currentBuffer])
glEnable(GL_RASTERIZER_DISCARD)
# perform transform feedback
glBeginTransformFeedback(GL_POINTS)
glDrawArrays(GL_POINTS, 0, self.__particles)
glEndTransformFeedback()
glDisable(GL_RASTERIZER_DISCARD)
# clear first
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# use the shader program
glUseProgram(self.__shaderProgram)
# calculate ViewProjection matrix
projection = glm.perspective(90.0, 4.0 / 3.0, .1, 100.0)
projection = np.array(projection, dtype=np.float32)
# translate the world/view position
view = glm.translate(glm.mat4(1.0), glm.vec3(0.0, 0.0, -30.0))
# make the camera rotate around the origin
view = glm.rotate(view, 30.0, glm.vec3(1.0, 0.0, 0.0))
view = glm.rotate(view, -22.5 * t, glm.vec3(0.0, 1.0, 0.0))
view = np.array(view, dtype=np.float32)
# set the uniform
glUniformMatrix4fv(self.__viewLocation, 1, GL_FALSE, view)
glUniformMatrix4fv(self.__projLocation, 1, GL_FALSE, projection)
# bind the vao
glBindVertexArray(self.__vao[self.__currentBuffer])
# draw
glDrawArrays(GL_POINTS, 0, self.__particles)
glBindVertexArray(0)
glUseProgram(0)
# advance buffer index
self.__currentBuffer = (self.__currentBuffer + 1) % self.__bufferCount
def initGL(self):
"""opengl initialization"""
# load shaders
vertexShader = self.shaderFromFile(GL_VERTEX_SHADER, self.__vertexShader)
fragmentShader = self.shaderFromFile(GL_FRAGMENT_SHADER, self.__fragmentShader)
self.__shaderProgram = shaders.compileProgram(vertexShader, fragmentShader)
if not self.__shaderProgram:
self.close()
self.__ubIndex = glGetUniformBlockIndex(self.__shaderProgram, 'Matrices')
# assign the block binding
glUniformBlockBinding(self.__shaderProgram, self.__ubIndex, self.__matricesBinding)
# create uniform buffer
self.__ubo = glGenBuffers(1)
glBindBuffer(GL_UNIFORM_BUFFER, self.__ubo)
glBufferData(GL_UNIFORM_BUFFER, 9 * 4 * 4 * 4, None, GL_DYNAMIC_DRAW)
# fill the Model matrix array
modelMatrices = []
modelMatrices.append(glm.translate(glm.mat4(1.0), glm.vec3( 2.0, 2.0, 2.0)))
modelMatrices.append(glm.translate(glm.mat4(1.0), glm.vec3( 2.0, 2.0, -2.0)))
modelMatrices.append(glm.translate(glm.mat4(1.0), glm.vec3( 2.0, -2.0, 2.0)))
modelMatrices.append(glm.translate(glm.mat4(1.0), glm.vec3( 2.0, -2.0, -2.0)))
modelMatrices.append(glm.translate(glm.mat4(1.0), glm.vec3(-2.0, 2.0, 2.0)))
modelMatrices.append(glm.translate(glm.mat4(1.0), glm.vec3(-2.0, 2.0, -2.0)))
modelMatrices.append(glm.translate(glm.mat4(1.0), glm.vec3(-2.0, -2.0, 2.0)))
modelMatrices.append(glm.translate(glm.mat4(1.0), glm.vec3(-2.0, -2.0, -2.0)))
modelMatrices = np.array(modelMatrices, dtype=np.float32)
glBufferSubData(GL_UNIFORM_BUFFER, 4 * 4 * 4, modelMatrices.nbytes, modelMatrices)
# generate and bind the vao
self.__vao = glGenVertexArrays(1)
glBindVertexArray(self.__vao)
# generate and bind the buffer object
vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
# data for a fullscreen quad
vertexData = np.array([
# x y z U V
# face 0:
1.0, 1.0, 1.0, 1.0, 0.0, 0.0, # vertex 0
-1.0, 1.0, 1.0, 1.0, 0.0, 0.0, # vertex 1
1.0,-1.0, 1.0, 1.0, 0.0, 0.0, # vertex 2
-1.0,-1.0, 1.0, 1.0, 0.0, 0.0, # vertex 3
# face 1:
1.0, 1.0, 1.0, 0.0, 1.0, 0.0, # vertex 0
1.0,-1.0, 1.0, 0.0, 1.0, 0.0, # vertex 1
1.0, 1.0,-1.0, 0.0, 1.0, 0.0, # vertex 2
1.0,-1.0,-1.0, 0.0, 1.0, 0.0, # vertex 3
# face 2:
1.0, 1.0, 1.0, 0.0, 0.0, 1.0, # vertex 0
1.0, 1.0,-1.0, 0.0, 0.0, 1.0, # vertex 1
-1.0, 1.0, 1.0, 0.0, 0.0, 1.0, # vertex 2
-1.0, 1.0,-1.0, 0.0, 0.0, 1.0, # vertex 3
# face 3:
1.0, 1.0,-1.0, 1.0, 1.0, 0.0, # vertex 0
1.0,-1.0,-1.0, 1.0, 1.0, 0.0, # vertex 1
-1.0, 1.0,-1.0, 1.0, 1.0, 0.0, # vertex 2
-1.0,-1.0,-1.0, 1.0, 1.0, 0.0, # vertex 3
# face 4:
-1.0, 1.0, 1.0, 0.0, 1.0, 1.0, # vertex 0
-1.0, 1.0,-1.0, 0.0, 1.0, 1.0, # vertex 1
-1.0,-1.0, 1.0, 0.0, 1.0, 1.0, # vertex 2
-1.0,-1.0,-1.0, 0.0, 1.0, 1.0, # vertex 3
# face 5:
1.0,-1.0, 1.0, 1.0, 0.0, 1.0, # vertex 0
-1.0,-1.0, 1.0, 1.0, 0.0, 1.0, # vertex 1
1.0,-1.0,-1.0, 1.0, 0.0, 1.0, # vertex 2
-1.0,-1.0,-1.0, 1.0, 0.0, 1.0, # vertex 3
], dtype=np.float32)
# fill with data
glBufferData(GL_ARRAY_BUFFER, vertexData.nbytes, vertexData, GL_STATIC_DRAW)
# set up generic attrib pointers
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * 4, None)
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * 4, ctypes.c_void_p(3 * 4))
ibo = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo)
indexData = np.array([
# face 0:
0, 1, 2, # first triangle
2, 1, 3, # second triangle
# face 1:
4, 5, 6, # first triangle
6, 5, 7, # second triangle
# face 2:
8, 9, 10, # first triangle
10, 9, 11, # second triangle
# face 3:
12, 13, 14, # first triangle
14, 13, 15, # second triangle
# face 4:
16, 17, 18, # first triangle
18, 17, 19, # second triangle
# face 5:
20, 21, 22, # first triangle
22, 21, 23, # second triangle
], dtype=np.uint)
# fill with data
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexData.nbytes, indexData, GL_STATIC_DRAW)
glBindVertexArray(0)
# we are drawing 3d objects so we want depth testing
glEnable(GL_DEPTH_TEST)
