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)