Beispiel #1
0
 def draw(self, reset, modelview):
     """Binds the shaders and things to draw the lamp itself.
     Takes a reference to the 'matrix reset' function, and a modelview matrix to draw by."""
     glUseProgram(shaderl)
     reset(shaderl)
     glUniformMatrix4fv(glGetUniformLocation(shaderl, 'modelmatrix'), 1, False, modelview)
     self.model.draw()
Beispiel #2
0
def level5_init(level, program):
    # 1.59 - approximate position of the eyes of a person who is 1.69 meters tall
    level.position = array([0, 0, 1.59, 1], dtype='float32')
    # looking forward in Y-axis positive direction
    level.orientation = array([0, 1, 0, 0], dtype='float32')

    level.time_start = time()
    level.time_checkpoint = level.time_start

    # get position for view matrix
    level.view_pos = glGetUniformLocation(program, 'view')

    # get position for rotating model matrix
    level.rotating_model_pos = glGetUniformLocation(program, 'rotating_model')

    # sun
    level.sun_color = array([1.0, 1.0, 1.0], dtype='float32')
    level.sun_color_pos = glGetUniformLocation(program, 'sunColor')
    glUniform3fv(level.sun_color_pos, 1, level.sun_color)

    level.sun_direction_pos = glGetUniformLocation(program, 'sunDirection')
    glUniform3fv(level.sun_direction_pos, 1, level.sun_direction)

    level.ambient_intensity = 0.2
    level.ambient_intensity_pos = glGetUniformLocation(program, 'ambientIntensity')
    glUniform1f(level.ambient_intensity_pos, level.ambient_intensity)

    # initialize projection matrix once
    level.projection = perspective(pi / 3.5, level.screen_w / level.screen_h, 0.005, 1000000.0)
    level.projection_pos = glGetUniformLocation(program, 'projection')
    glUniformMatrix4fv(level.projection_pos, 1, GL_FALSE, level.projection)
Beispiel #3
0
def level4_render(level):
    left = glfwGetKey(level.window, GLFW_KEY_LEFT) == GLFW_PRESS or \
        glfwGetKey(level.window, GLFW_KEY_A) == GLFW_PRESS
    right = glfwGetKey(level.window, GLFW_KEY_RIGHT) == GLFW_PRESS or \
        glfwGetKey(level.window, GLFW_KEY_D) == GLFW_PRESS
    backward = glfwGetKey(level.window, GLFW_KEY_DOWN) == GLFW_PRESS or \
        glfwGetKey(level.window, GLFW_KEY_S) == GLFW_PRESS
    forward = glfwGetKey(level.window, GLFW_KEY_UP) == GLFW_PRESS or \
        glfwGetKey(level.window, GLFW_KEY_W) == GLFW_PRESS
    up = glfwGetKey(level.window, GLFW_KEY_PAGE_UP) == GLFW_PRESS
    down = glfwGetKey(level.window, GLFW_KEY_PAGE_DOWN) == GLFW_PRESS

    current_time = time()
    speed = (current_time - level.time_checkpoint)*3

    if glfwGetKey(level.window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS:
        speed *= 2
    if glfwGetKey(level.window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS:
        speed /= 2

    if (left or right) and (backward or forward) and (up or down):
        speed /= sqrt(3.0)
    elif ((left or right) and (backward or forward)) or \
            ((left or right) and (up or down)) or \
            ((backward or forward) and (up or down)):
        speed /= sqrt(2.0)
    if left:
        v = vector_norm(array([level.orientation[0], level.orientation[1], 0, 0], dtype='float32'))
        v = rotate(pi/2).dot(v)
        try_to_move(lvl, level, -v[0]*speed, -v[1]*speed, start_x, start_y)
    if right:
        v = vector_norm(array([level.orientation[0], level.orientation[1], 0, 0], dtype='float32'))
        v = rotate(-pi/2).dot(v)
        try_to_move(lvl, level, -v[0]*speed, -v[1]*speed, start_x, start_y)
    if backward:
        v = vector_norm(array([level.orientation[0], level.orientation[1], 0, 0], dtype='float32'))
        v = rotate(pi).dot(v)
        try_to_move(lvl, level, v[0]*speed, v[1]*speed, start_x, start_y)
    if forward:
        v = vector_norm(array([level.orientation[0], level.orientation[1], 0, 0], dtype='float32'))
        try_to_move(lvl, level, v[0]*speed, v[1]*speed, start_x, start_y)
    if up:
        level.position[2] += speed
    if down:
        level.position[2] -= speed

    level.time_checkpoint = current_time

    # update view matrix (according to position and orientation)
    level.view = look_at(level.position[:3], add(level.position, level.orientation)[:3])
    glUniformMatrix4fv(level.view_pos, 1, GL_FALSE, level.view)

    # update rotating model
    level.angle = -(level.time_start - time()) / 3
    level.rotating_model = array([cos(level.angle), -sin(level.angle), 0, 0,
                                  sin(level.angle), cos(level.angle), 0, 0,
                                  0, 0, 1, 0,
                                  0, 0, 0, 1], dtype='float32').reshape(4, 4)
    glUniformMatrix4fv(level.rotating_model_pos, 1, GL_FALSE, level.rotating_model)
Beispiel #4
0
def render_with_context(context):
    glUseProgram(context["shader"])

    # need true because our matrices are row-major and opengl wants column major by default.
    modelview = context["modelview"]
    projection = context["projection"]

    glUniformMatrix4fv(modelview["location"], 1, True, modelview["matrix"])
    glUniformMatrix4fv(projection["location"], 1, True, projection["matrix"])
    position_location = context["position_location"]
    normal_location = context["normal_location"]
    color_location = context["color_location"]

    stack = [modelview["matrix"]]
    try:
        render_thing(context["thing"], position_location, normal_location, color_location, modelview["location"], stack)
    finally:
        shaders.glUseProgram( 0 )
 def uniform(self, name, value):
     with self:
         if type(value) == int or type(value) == long:
             glUniform1i(self.uniformLocation(name), value)
         elif type(value) == float or type(value) == numpy.float32:
             glUniform1f(self.uniformLocation(name), value)
         elif len(value) == 4:
             value = numpy.array(value, dtype=numpy.float32)
             glUniform4f(self.uniformLocation(name), *value)
         elif len(value) == 16:
             glUniformMatrix4fv(self.uniformLocation(name), 1, GL_FALSE, value)
         elif len(value) == 9:
             glUniformMatrix3fv(self.uniformLocation(name), 1, GL_FALSE, value)
         elif len(value) == 2:
             value = numpy.array(value, dtype=numpy.float32)
             glUniform2f(self.uniformLocation(name), *value)
         else:
             print(len(value))
             raise Exception('not implemented')
Beispiel #6
0
	def setup(self, actor):
		'''
		Setup the shader uniforms / attributes.
		Assumes actor.vbo is already bound
		'''
		# Bind the shader
		shaders.glUseProgram(self.program)

		# Enable vertex attribute arrays
		glEnableVertexAttribArray(self.attrib_position)
			
		# Set the Attribute pointers			
		glVertexAttribPointer(self.attrib_position, 4, GL_FLOAT, False, 0, actor.vbo)

		# Apply uniforms
		glUniformMatrix4fv(self.uniform_modelCamera, 1, GL_TRUE, actor.modelCamera_matrix)
		glUniformMatrix4fv(self.uniform_projection, 1, GL_TRUE, actor.projection_matrix)
		glUniform1f(self.uniform_alpha, actor.alpha)
		
		# Bind to the correct texture
		glBindTexture(GL_TEXTURE_2D, actor.texid)
Beispiel #7
0
    def render(self) -> None:
        """Render proxy objects to canvas with a diffuse shader."""
        if not self.init():
            return

        proj = self.parent.projection_matrix
        view = self.parent.modelview_matrix

        glUseProgram(self.parent.shaders['diffuse'])
        glUniformMatrix4fv(0, 1, GL_FALSE, glm.value_ptr(proj))
        glUniformMatrix4fv(1, 1, GL_FALSE, glm.value_ptr(view))

        for mesh in self._meshes:
            glBindVertexArray(mesh.vao)
            glUniform4fv(2, 1, glm.value_ptr(mesh.color))
            glUniform1i(3, int(mesh.selected))
            glDrawElements(GL_TRIANGLES, mesh.count, GL_UNSIGNED_INT,
                           ctypes.c_void_p(0))

        glBindVertexArray(0)
        glUseProgram(0)
Beispiel #8
0
    def render(self, model, view_matrix, projection_matrix):
        glUseProgram(self.program)

        glEnableVertexAttribArray(self.vertices)

        glUniformMatrix4fv(self.model_view_matrix, 1, GL_TRUE,
                           np.dot(view_matrix, model.matrix))
        glUniformMatrix4fv(self.projection_matrix, 1, GL_TRUE,
                           projection_matrix)

        glVertexAttribPointer(self.vertices, 3, GL_FLOAT, GL_FALSE, 0,
                              model.vertex_buffer)

        glUniform1f(self.color_uniform, 0)
        glDrawElements(GL_LINES, model.line_buffer.size, GL_UNSIGNED_BYTE,
                       model.line_buffer)

        glUniform1f(self.color_uniform, 0.5)
        glDrawElements(GL_TRIANGLES, model.index_buffer.size, GL_UNSIGNED_BYTE,
                       model.index_buffer)

        glDisableVertexAttribArray(self.vertices)
    def render_for_picking(self) -> None:
        """Render ViewCube for picking pass."""
        if not self.init():
            return

        glViewport(*self.viewport)

        proj = glm.ortho(-2.3, 2.3, -2.3, 2.3, -2.3, 2.3)
        mat = glm.lookAt(
            vec3(0.0, -1.0, 0.0),  # position
            vec3(0.0, 0.0, 0.0),  # target
            vec3(0.0, 0.0, 1.0))  # up
        modelview = mat * glm.mat4_cast(self.parent.rot_quat)

        glUseProgram(self.parent.shaders['default'])
        glUniformMatrix4fv(0, 1, GL_FALSE, glm.value_ptr(proj))
        glUniformMatrix4fv(1, 1, GL_FALSE, glm.value_ptr(modelview))
        glBindVertexArray(self._vao_picking)
        glDrawArrays(GL_QUADS, 0, 24)

        glBindVertexArray(0)
        glUseProgram(0)
Beispiel #10
0
	def setup(self, actor):
		'''
		Setup the shader uniforms / attributes.
		Assumes actor.vbo is already bound
		'''
		# Bind the shader
		shaders.glUseProgram(self.program)

		# Enable vertex attribute arrays
		glEnableVertexAttribArray(self.attrib_position)
		glEnableVertexAttribArray(self.attrib_color)
			
		# colorOffset is sizeof float (4) * floats per point (4) * num of points (vbo/2)
		colorOffset = 4 * 4 * (len(actor.vbo) / 2) 

		# Set the Attribute pointers			
		glVertexAttribPointer(self.attrib_position, 4, GL_FLOAT, False, 0, actor.vbo)
		glVertexAttribPointer(self.attrib_color,    4, GL_FLOAT, False, 0, actor.vbo + colorOffset)

		# Apply uniforms
		glUniformMatrix4fv(self.uniform_modelCamera, 1, GL_TRUE, actor.modelCamera_matrix)
		glUniformMatrix4fv(self.uniform_projection, 1, GL_TRUE, actor.projection_matrix)
		glUniform1f(self.uniform_alpha, actor.alpha)
Beispiel #11
0
    def render_for_picking(self) -> None:
        """Render action "pickables" for picking pass."""
        if not self.init():
            return

        proj = self.parent.projection_matrix
        view = self.parent.modelview_matrix

        glUseProgram(self.parent.shaders['instanced_picking'])
        glUniformMatrix4fv(0, 1, GL_FALSE, glm.value_ptr(proj))
        glUniformMatrix4fv(1, 1, GL_FALSE, glm.value_ptr(view))

        # render cameras for picking
        glBindVertexArray(self._vaos['camera'])
        glDrawArraysInstanced(GL_QUADS, 0, 24, self._num_devices)

        # render points for picking
        if self._num_points > 0:
            glBindVertexArray(self._vaos['box'])
            glDrawArraysInstanced(GL_QUADS, 0, 24, self._num_points)

        glBindVertexArray(0)
        glUseProgram(0)
Beispiel #12
0
    def render_for_picking(self) -> None:
        """Render proxy objects for picking pass."""
        if not self.init():
            return

        proj = self.parent.projection_matrix
        view = self.parent.modelview_matrix

        glUseProgram(self.parent.shaders['solid'])
        glUniformMatrix4fv(0, 1, GL_FALSE, glm.value_ptr(proj))
        glUniformMatrix4fv(1, 1, GL_FALSE, glm.value_ptr(view))

        for mesh in self._meshes:
            glBindVertexArray(mesh.vao)
            glUniform1i(2, MAX_ID - mesh.object_id)
            glDrawElements(GL_TRIANGLES, mesh.count, GL_UNSIGNED_INT,
                           ctypes.c_void_p(0))

        glBindVertexArray(0)
        glUseProgram(0)

        glBindVertexArray(0)
        glUseProgram(0)
Beispiel #13
0
    def render(self, model, view_matrix, projection_matrix):
        glUseProgram(self.program)

        glEnableVertexAttribArray(self.texcoords)
        glEnableVertexAttribArray(self.vertices)
        glEnableVertexAttribArray(self.bone_ids)
        glEnableVertexAttribArray(self.bone_weights)

        glUniformMatrix4fv(
            self.model_view_matrix, 1, GL_TRUE,
            np.dot(view_matrix, model.matrix)
        )
        glUniformMatrix4fv(
            self.projection_matrix, 1, GL_TRUE, projection_matrix
        )
        glUniformMatrix4fv(
            self.bone_matrices, len(model.bones), GL_TRUE, model.bone_matrices
        )

        for group in model.groups:
            glBindTexture(GL_TEXTURE_2D, group.material.texture)
            glUniform1i(self.texture, 0)

            glVertexAttribPointer(
                self.bone_ids, 4, GL_SHORT, GL_FALSE, 0, group.bone_id_buffer
            )
            glVertexAttribPointer(
                self.bone_weights, 4, GL_FLOAT, GL_FALSE, 0,
                group.bone_weight_buffer
            )
            glVertexAttribPointer(
                self.vertices, 3, GL_FLOAT, GL_FALSE, 0, group.vertex_buffer
            )
            glVertexAttribPointer(
                self.texcoords, 2, GL_FLOAT, GL_FALSE, 0, group.texcoord_buffer
            )

            glDrawArrays(GL_TRIANGLES, 0, len(group.vertex_buffer))

        glDisableVertexAttribArray(self.bone_weights)
        glDisableVertexAttribArray(self.bone_ids)
        glDisableVertexAttribArray(self.vertices)
        glDisableVertexAttribArray(self.texcoords)
Beispiel #14
0
 def bind(self, uniform_location):
     count = 1
     transpose = False
     glUniformMatrix4fv(uniform_location, count, transpose, self._data)
Beispiel #15
0
    def render(self) -> None:
        """Render actions to canvas."""
        if not self.init():
            return

        proj = self.parent.projection_matrix
        view = self.parent.modelview_matrix
        model = mat4()

        # --- render cameras ---

        glUseProgram(self.parent.shaders['instanced_model_color'])
        glUniformMatrix4fv(0, 1, GL_FALSE, glm.value_ptr(proj))
        glUniformMatrix4fv(1, 1, GL_FALSE, glm.value_ptr(view))
        glBindVertexArray(self._vaos['camera'])
        glDrawArraysInstanced(GL_QUADS, 0, 24, self._num_devices)

        # --- render path lines ---

        glUseProgram(self.parent.shaders['single_color'])
        glUniformMatrix4fv(0, 1, GL_FALSE, glm.value_ptr(proj))
        glUniformMatrix4fv(1, 1, GL_FALSE, glm.value_ptr(view))
        glUniformMatrix4fv(2, 1, GL_FALSE, glm.value_ptr(model))

        for key, value in self._vaos['line'].items():
            color = self.colors[key % len(self.colors)]
            glUniform4fv(3, 1, glm.value_ptr(color))
            glBindVertexArray(value)
            glDrawArrays(GL_LINE_STRIP, 0, len(self._items['line'][key]))

        # --- render points ---

        if self._num_points > 0:
            glUseProgram(self.parent.shaders['instanced_model_color'])
            glUniformMatrix4fv(0, 1, GL_FALSE, glm.value_ptr(proj))
            glUniformMatrix4fv(1, 1, GL_FALSE, glm.value_ptr(view))
            glBindVertexArray(self._vaos['box'])
            glDrawArraysInstanced(GL_QUADS, 0, 24, self._num_points)

        glBindVertexArray(0)
        glUseProgram(0)
def run():
    #Start OpenGL and ask it for an OpenGL context
    pygame.init()
    clock = pygame.time.Clock()
    screen = pygame.display.set_mode(
        SCREEN_SIZE, pygame.HWSURFACE | pygame.OPENGL | pygame.DOUBLEBUF)

    #The first thing we do is print some OpenGL details and check that we have a good enough version
    print("OpenGL Implementation Details:")
    if glGetString(GL_VENDOR):
        print("\tGL_VENDOR: {}".format(glGetString(GL_VENDOR).decode()))
    if glGetString(GL_RENDERER):
        print("\tGL_RENDERER: {}".format(glGetString(GL_RENDERER).decode()))
    if glGetString(GL_VERSION):
        print("\tGL_VERSION: {}".format(glGetString(GL_VERSION).decode()))
    if glGetString(GL_SHADING_LANGUAGE_VERSION):
        print("\tGL_SHADING_LANGUAGE_VERSION: {}".format(
            glGetString(GL_SHADING_LANGUAGE_VERSION).decode()))

    major_version = int(
        glGetString(GL_VERSION).decode().split()[0].split('.')[0])
    minor_version = int(
        glGetString(GL_VERSION).decode().split()[0].split('.')[1])
    if major_version < 3 or (major_version < 3 and minor_version < 0):
        print("OpenGL version must be at least 3.0 (found {0})".format(
            glGetString(GL_VERSION).decode().split()[0]))

    #Now onto the OpenGL initialisation

    #Set up depth culling
    glEnable(GL_CULL_FACE)
    glEnable(GL_DEPTH_TEST)
    glDepthMask(GL_TRUE)
    glDepthFunc(GL_LEQUAL)
    glDepthRange(0.0, 1.0)

    #We create out shaders which do little more than set a flat colour for each face

    VERTEX_SHADER = shaders.compileShader(
        b"""
	#version 130
	
	in vec4 position;
	in vec4 normal;
	
	uniform mat4 projectionMatrix;
	uniform mat4 viewMatrix;
	uniform mat4 modelMatrix;
	
	flat out float theColor;
	
	void main()
	{
		vec4 temp = modelMatrix * position;
		temp = viewMatrix * temp;
		gl_Position = projectionMatrix * temp;
		
		theColor = clamp(abs(dot(normalize(normal.xyz), normalize(vec3(0.9,0.1,0.5)))), 0, 1);
	}
	""", GL_VERTEX_SHADER)

    FRAGMENT_SHADER = shaders.compileShader(
        b"""
	#version 130
	
	flat in float theColor;
	
	out vec4 outputColor;
	void main()
	{
		outputColor = vec4(1.0, 0.5, theColor, 1.0);
	}
	""", GL_FRAGMENT_SHADER)

    shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)

    #And then grab our attribute locations from it
    glBindAttribLocation(shader, 0, b"position")
    glBindAttribLocation(shader, 1, b"normal")

    #Create the Vertex Array Object to hold our volume mesh
    vertexArrayObject = GLuint(0)
    glGenVertexArrays(1, vertexArrayObject)
    glBindVertexArray(vertexArrayObject)

    #Create the index buffer object
    indexPositions = vbo.VBO(indices,
                             target=GL_ELEMENT_ARRAY_BUFFER,
                             usage=GL_STATIC_DRAW)
    #Create the VBO
    vertexPositions = vbo.VBO(vertices, usage=GL_STATIC_DRAW)

    #Bind our VBOs and set up our data layout specifications
    with indexPositions, vertexPositions:
        glEnableVertexAttribArray(0)
        glVertexAttribPointer(0, 3, GL_FLOAT, False,
                              6 * vertices.dtype.itemsize,
                              vertexPositions + (0 * vertices.dtype.itemsize))
        glEnableVertexAttribArray(1)
        glVertexAttribPointer(1, 3, GL_FLOAT, False,
                              6 * vertices.dtype.itemsize,
                              vertexPositions + (3 * vertices.dtype.itemsize))

        glBindVertexArray(0)
        glDisableVertexAttribArray(0)

    #Now grab out transformation martix locations
    modelMatrixUnif = glGetUniformLocation(shader, b"modelMatrix")
    viewMatrixUnif = glGetUniformLocation(shader, b"viewMatrix")
    projectionMatrixUnif = glGetUniformLocation(shader, b"projectionMatrix")

    modelMatrix = np.array([[1.0, 0.0, 0.0, -32.0], [0.0, 1.0, 0.0, -32.0],
                            [0.0, 0.0, 1.0, -32.0], [0.0, 0.0, 0.0, 1.0]],
                           dtype='f')
    viewMatrix = np.array([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0],
                           [0.0, 0.0, 1.0, -50.0], [0.0, 0.0, 0.0, 1.0]],
                          dtype='f')
    projectionMatrix = np.array([[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0],
                                 [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]],
                                dtype='f')

    #These next few lines just set up our camera frustum
    fovDeg = 45.0
    frustumScale = 1.0 / tan(radians(fovDeg) / 2.0)

    zNear = 1.0
    zFar = 1000.0

    projectionMatrix[0][0] = frustumScale
    projectionMatrix[1][1] = frustumScale
    projectionMatrix[2][2] = (zFar + zNear) / (zNear - zFar)
    projectionMatrix[2][3] = -1.0
    projectionMatrix[3][2] = (2 * zFar * zNear) / (zNear - zFar)

    #viewMatrix and projectionMatrix don't change ever so just set them once here
    with shader:
        glUniformMatrix4fv(projectionMatrixUnif, 1, GL_TRUE, projectionMatrix)
        glUniformMatrix4fv(viewMatrixUnif, 1, GL_TRUE, viewMatrix)

    #These are used to track the rotation of the volume
    LastFrameMousePos = (0, 0)
    CurrentMousePos = (0, 0)
    xRotation = 0
    yRotation = 0

    while True:
        clock.tick()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return
            if event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE:
                return
            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
                CurrentMousePos = event.pos
                LastFrameMousePos = CurrentMousePos
            if event.type == pygame.MOUSEMOTION and 1 in event.buttons:
                CurrentMousePos = event.pos
                diff = (CurrentMousePos[0] - LastFrameMousePos[0],
                        CurrentMousePos[1] - LastFrameMousePos[1])
                xRotation += event.rel[0]
                yRotation += event.rel[1]
                LastFrameMousePos = CurrentMousePos

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        #Perform the rotation of the mesh
        moveToOrigin = np.array(
            [[1.0, 0.0, 0.0, -32.0], [0.0, 1.0, 0.0, -32.0],
             [0.0, 0.0, 1.0, -32.0], [0.0, 0.0, 0.0, 1.0]],
            dtype='f')
        rotateAroundX = np.array(
            [[1.0, 0.0, 0.0, 0.0],
             [0.0, cos(radians(yRotation)), -sin(radians(yRotation)), 0.0],
             [0.0, sin(radians(yRotation)),
              cos(radians(yRotation)), 0.0], [0.0, 0.0, 0.0, 1.0]],
            dtype='f')
        rotateAroundY = np.array(
            [[cos(radians(xRotation)), 0.0,
              sin(radians(xRotation)), 0.0], [0.0, 1.0, 0.0, 0.0],
             [-sin(radians(xRotation)), 0.0,
              cos(radians(xRotation)), 0.0], [0.0, 0.0, 0.0, 1.0]],
            dtype='f')

        modelMatrix = rotateAroundY.dot(rotateAroundX.dot(moveToOrigin))

        with shader:
            glUniformMatrix4fv(modelMatrixUnif, 1, GL_TRUE, modelMatrix)
            glBindVertexArray(vertexArrayObject)

            glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None)

            glBindVertexArray(0)

        # Show the screen
        pygame.display.flip()
Beispiel #17
0
 def setMat4(self, name, value):
     location = glGetUniformLocation(self.program, name)
     glUniformMatrix4fv(location, 1, GL_FALSE, value.data())
Beispiel #18
0
def main():
    global width
    global height
    global camera

    width = 1024
    height = 1024

    delta_time = 0.0
    last_frame = 0.0

    if not glfw.init():
        return

    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)
    glfw.window_hint(glfw.RESIZABLE, GL_FALSE)
    window = glfw.create_window(width, height, "opengl_lab1", None, None)

    glfw.set_key_callback(window, key_callback)
    glfw.set_cursor_pos_callback(window, mousemove_callback)
    glfw.set_mouse_button_callback(window, mouseclick_callback)

    if not window:
        glfw.terminate()
        return

    glfw.make_context_current(window)

    fun1 = lambda x, z: math.sin(x+z)
    fun2 = lambda x, z: math.exp(-x*x - z*z)
    fun3 = lambda x, z: (x**2 + z**2) / (x*z)
    contour_plot = lambda x, z: 0.0
    heightmap_dummy_fun = lambda x, z: 0.0

    surface_size = 50

    (fun_vao1, ind_fun1) = create_surface(100, 100, surface_size, fun1, False)
    (fun_vao2, ind_fun2) = create_surface(100, 100, surface_size, fun2, False)
    (fun_vao3, ind_fun3) = create_surface(100, 100, surface_size, fun3, False)
    (grad_vao, grad_point_count) = create_grad(100, 100, surface_size)
    (contour_plot_vao, ind_con, vec_lines, vector_line_indexes) = create_surface(100, 100, surface_size, 0, False, True)
    (heightmap_vao, ind_hm) = create_surface(100,100, surface_size, heightmap_dummy_fun, True)
    (sphere_vao, sphere_ind, normals_for_glyph) = uv_sphere(22, 11)
    (torus_vao, torus_ind) = uv_torus(5, 10, 100, 100)
    (cm_vao, ind_cm) = create_surface(100, 100, surface_size, heightmap_dummy_fun, True)
    (cloud_vao, points_count) = read_ply()
    (perlin_vao, ind_perlin) = create_surface(100, 100, surface_size, heightmap_dummy_fun, False)
    (div_vao, ind_div) = create_surface(100, 100, surface_size, heightmap_dummy_fun, False)
    (traj_vao, ind_traj) = simple_cube()

    fun_shader_sources = [(GL_VERTEX_SHADER, "shaders/functions.vert"), (GL_FRAGMENT_SHADER, "shaders/functions.frag")]

    fun_program = ShaderProgram(fun_shader_sources)

    hm_shader_sources = [(GL_VERTEX_SHADER, "shaders/heightmap.vert"), (GL_FRAGMENT_SHADER, "shaders/heightmap.frag")]

    hm_program = ShaderProgram(hm_shader_sources)

    hm_texture = read_texture("1.jpg")

    contour_plot_shader_sources = [(GL_VERTEX_SHADER, "shaders/contourplot.vert"), (GL_FRAGMENT_SHADER, "shaders/contourplot.frag")]

    contour_plot_program = ShaderProgram(contour_plot_shader_sources)

    sphere_shader_sources = [(GL_VERTEX_SHADER, "shaders/sphere.vert"), (GL_FRAGMENT_SHADER, "shaders/sphere.frag")]
    sphere_program = ShaderProgram(sphere_shader_sources)

    glyph_shader_sources = [(GL_VERTEX_SHADER, "shaders/glyph.vert"), (GL_GEOMETRY_SHADER, "shaders/glyph.geom"), (GL_FRAGMENT_SHADER, "shaders/glyph.frag")]
    glyph_program = ShaderProgram(glyph_shader_sources)

    grad_shader_sources = [(GL_VERTEX_SHADER, "shaders/grad.vert"), (GL_GEOMETRY_SHADER, "shaders/grad.geom"), (GL_FRAGMENT_SHADER, "shaders/grad.frag")]
    grad_program = ShaderProgram(grad_shader_sources)

    cm_shader_sources = [(GL_VERTEX_SHADER, "shaders/colormap.vert"), (GL_FRAGMENT_SHADER, "shaders/colormap.frag")]
    cm_program = ShaderProgram( cm_shader_sources )

    perlin_shader_sources = [(GL_VERTEX_SHADER, "shaders/perlin.vert"), (GL_FRAGMENT_SHADER, "shaders/perlin.frag")]
    perlin_program = ShaderProgram(perlin_shader_sources)

    cloud_shader_sources = [(GL_VERTEX_SHADER, "shaders/ply.vert"), (GL_FRAGMENT_SHADER, "shaders/ply.frag")]
    cloud_program = ShaderProgram(cloud_shader_sources)

    vf_shader_sources = [(GL_VERTEX_SHADER, "shaders/vector_field.vert"), (GL_FRAGMENT_SHADER, "shaders/vector_field.frag")]
    vf_program = ShaderProgram(vf_shader_sources)

    traj_shader_sources = [(GL_VERTEX_SHADER, "shaders/trajectory.vert"),
                         (GL_FRAGMENT_SHADER, "shaders/trajectory.frag")]

    traj_program = ShaderProgram(traj_shader_sources)



    check_gl_errors()

    projection = projectionMatrixTransposed(60.0, float(width) / float(height), 1, 1000.0)

    HDR_TEXTURES_AMOUNT = 33

    cm_textures = read_cm_textures(HDR_TEXTURES_AMOUNT)

    cm_texture_num = 0

    cm_change_counter = 0

    hdr_textures_speed = 6

    perlin_time = 0.0
    perlin_time_step = 0.03



    cube_multiplier = 1.0
    cube_center = [0.0, 0.0, 0.0]
    traj_points_list = [ cube_center ]
    cube_edge_length = 2.0 * cube_multiplier

    offset = cube_edge_length / 10
    left_cube_pos = -25 * cube_edge_length
    cube_steps = -left_cube_pos / offset - 10
    traj_points_count = int(cube_steps)


    for i in range(traj_points_count):
        traj_points_list.append( [0.5*cube_edge_length * i, 0.0, 0.0] )

    traj_part_index = 0



    while not glfw.window_should_close(window):
        current_frame = glfw.get_time()
        delta_time = current_frame - last_frame
        last_frame = current_frame
        glfw.poll_events()

        doCameraMovement(camera, delta_time)

        model = translateM4x4(np.array([0.0, 0.0, 0.0]))
        view = camera.get_view_matrix()

        glClearColor(0.5, 0.5, 0.5, 1.0)
        glViewport(0, 0, width, height)
        glEnable(GL_DEPTH_TEST)
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        fun_program.bindProgram()

        glUniform3fv(fun_program.uniformLocation("col"), 1 , [1.0, 0, 0] )

        glUniformMatrix4fv(fun_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniformMatrix4fv(fun_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(fun_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())

        glBindVertexArray(fun_vao1)
        glDrawElements(GL_TRIANGLE_STRIP, ind_fun1, GL_UNSIGNED_INT, None)

        model = translateM4x4(np.array([-1.5*surface_size,0.0 ,0.0 ]))
        glUniform3fv(fun_program.uniformLocation("col"), 1, [0.0, 1.0, 0])
        glUniformMatrix4fv(fun_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glBindVertexArray(fun_vao2)
        glDrawElements(GL_TRIANGLE_STRIP, ind_fun2, GL_UNSIGNED_INT, None)

        model = translateM4x4(np.array([1.5 * surface_size, 0.0, 0.0]))
        glUniform3fv(fun_program.uniformLocation("col"), 1, [0.0, 0.0, 1.0])
        glUniformMatrix4fv(fun_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glBindVertexArray(fun_vao3)
        glDrawElements(GL_TRIANGLE_STRIP, ind_fun3, GL_UNSIGNED_INT, None)

        cloud_program.bindProgram()

        translate_cloud = translateM4x4(np.array([-2.5*surface_size,0.0 ,0.0 ]))
        # rotate_cloud = rotateYM4x4(math.radians(180))
        model = translate_cloud
        # glUniform3fv(fun_program.uniformLocation("col"), 1, [0.0, 1.0, 0])
        glUniformMatrix4fv(cloud_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniformMatrix4fv(cloud_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(cloud_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
        glBindVertexArray(cloud_vao)
        glDrawArrays(GL_POINTS, 0, points_count)

        sphere_program.bindProgram()

        sph_scale = scaleM4x4(np.array([sphere_radius, sphere_radius, sphere_radius]))
        sph_translate = translateM4x4(np.array([0.0, 0.0, 2.0 * surface_size]))

        glUniformMatrix4fv(sphere_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(sph_translate + sph_scale).flatten())
        glUniformMatrix4fv(sphere_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(sphere_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
        glBindVertexArray(sphere_vao)
        glDrawElements(GL_TRIANGLES, sphere_ind, GL_UNSIGNED_INT, None)

        torus_translate = translateM4x4(np.array([0.0, 0.0, 3.0 * surface_size]))
        glUniformMatrix4fv(sphere_program.uniformLocation("model"), 1, GL_FALSE,
                           np.transpose(torus_translate + sph_scale).flatten())
        glBindVertexArray(torus_vao)
        glDrawElements(GL_TRIANGLES, torus_ind, GL_UNSIGNED_INT, None)

        glyph_program.bindProgram()
        sph_scale = scaleM4x4(np.array([sphere_radius, sphere_radius, sphere_radius]))
        sph_translate = translateM4x4(np.array([0.0, 0.0, 2.0 * surface_size]))

        glUniformMatrix4fv(glyph_program.uniformLocation("model"), 1, GL_FALSE,
                           np.transpose(sph_translate + sph_scale).flatten())
        glUniformMatrix4fv(glyph_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(glyph_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())

        vao = glGenVertexArrays(1)
        glBindVertexArray(vao)
        vbo = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, vbo)
        glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(normals_for_glyph), normals_for_glyph.flatten(),
                     GL_STATIC_DRAW)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
        glEnableVertexAttribArray(0)
        glDrawArrays(GL_POINTS, 0, 10000)
        glBindVertexArray(0)

        contour_plot_program.bindProgram()

        model = translateM4x4(np.array([-1.5 * surface_size, 0.0, -1.5 * surface_size]))

        glUniformMatrix4fv(contour_plot_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniformMatrix4fv(contour_plot_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(contour_plot_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
        glBindVertexArray(contour_plot_vao)
        glDrawElements(GL_TRIANGLE_STRIP, ind_con, GL_UNSIGNED_INT, None)

        fun_program.bindProgram()
        lines_vao = glGenVertexArrays(1)
        glBindVertexArray(lines_vao)
        vbo_lines = glGenBuffers(1)
        vbo_indices = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, vbo_lines)
        glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(vec_lines), vec_lines.flatten(),
                     GL_STATIC_DRAW)  #
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
        glEnableVertexAttribArray(0)
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_indices)
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(vector_line_indexes), vector_line_indexes.flatten(),
                     GL_STATIC_DRAW)

        glUniformMatrix4fv(fun_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniformMatrix4fv(fun_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(fun_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
        glBindVertexArray(lines_vao)
        glDrawElements(GL_LINES, vector_line_indexes.size, GL_UNSIGNED_INT, None)

        hm_program.bindProgram()

        model = translateM4x4(np.array([0.0, 0.0, -1.5 * surface_size]))

        bindTexture(0, hm_texture)

        glUniform1i(hm_program.uniformLocation("tex"), 0)
        glUniformMatrix4fv(hm_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniformMatrix4fv(hm_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(hm_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
        glBindVertexArray(heightmap_vao)
        glDrawElements(GL_TRIANGLE_STRIP, ind_hm, GL_UNSIGNED_INT, None)

        cm_program.bindProgram()

        model = translateM4x4(np.array([1.5 * surface_size, 0.0, -1.5 * surface_size]))

        cur_cm_texture = cm_textures[cm_texture_num % HDR_TEXTURES_AMOUNT]

        bindTexture(1, cur_cm_texture)

        if cm_change_counter % hdr_textures_speed == 0:
            cm_texture_num += 1

        cm_change_counter += 1

        glUniform1i(cm_program.uniformLocation("cm_switch"), False)

        glUniform1i(cm_program.uniformLocation("tex"), 1)
        glUniformMatrix4fv(cm_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniformMatrix4fv(cm_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(cm_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
        glBindVertexArray(cm_vao)
        glDrawElements(GL_TRIANGLE_STRIP, ind_cm, GL_UNSIGNED_INT, None)

        # draw second animated hdr on the same shader
        model = translateM4x4(np.array([2.5 * surface_size, 0.0, -2.5 * surface_size]))
        glUniformMatrix4fv(cm_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniform1i(cm_program.uniformLocation("cm_switch"), True)
        glDrawElements(GL_TRIANGLE_STRIP, ind_cm, GL_UNSIGNED_INT, None)

        perlin_program.bindProgram()
        model = translateM4x4(np.array([0.0, 0.0, -3.5 * surface_size]))
        glUniformMatrix4fv(perlin_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniformMatrix4fv(perlin_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(perlin_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
        glUniform1f(perlin_program.uniformLocation("time"), perlin_time)
        perlin_time += perlin_time_step

        glBindVertexArray(perlin_vao)
        glDrawElements(GL_TRIANGLE_STRIP, ind_perlin, GL_UNSIGNED_INT, None)

        grad_program.bindProgram()
        model = translateM4x4(np.array([-25.0, 0.0, -7.0 * surface_size]))
        glUniformMatrix4fv(grad_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniformMatrix4fv(grad_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(grad_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
        glBindVertexArray(grad_vao)
        glDrawArrays(GL_LINES, 0, grad_point_count)

        vf_program.bindProgram()
        model = translateM4x4(np.array([0.0, 0.0, -5.5 * surface_size]))
        glUniformMatrix4fv(vf_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glUniformMatrix4fv(vf_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(vf_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())
        glUniform1i(vf_program.uniformLocation("cm_switch"), True)
        glBindVertexArray(div_vao)
        glDrawElements(GL_TRIANGLE_STRIP, ind_div, GL_UNSIGNED_INT, None)

        glUniform1i(vf_program.uniformLocation("cm_switch"), False)
        model = translateM4x4(np.array([1.0 * surface_size, 0.0, -6.5 * surface_size]))
        glUniformMatrix4fv(vf_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(model).flatten())
        glDrawElements(GL_TRIANGLE_STRIP, ind_div, GL_UNSIGNED_INT, None)


        traj_program.bindProgram()

        l_traj_part =[]
        r_traj_part =[]

        if offset > 0:
            traj_part_index = int(traj_points_count - cm_change_counter % cube_steps)
            r_traj_part = traj_points_list[0:traj_part_index]
            for traj_coords in r_traj_part:
                l_traj_part.append( [-x for x in traj_coords] )
        else:
            traj_part_index = int(traj_points_count - cm_change_counter % cube_steps)
            # traj_part_index = int(cm_change_counter % cube_steps)
            l_traj_part = traj_points_list[0:traj_part_index]
            for traj_coords in l_traj_part:
                r_traj_part.append([-x for x in traj_coords])

        l_traj_vec = np.array(l_traj_part, dtype=np.float32)
        r_traj_vec = np.array(r_traj_part, dtype=np.float32)

        indices_list = [i for i in range(len(r_traj_part))]
        indices_vec = np.array(indices_list, dtype=np.uint32)

        left_traj_vao = glGenVertexArrays(1)
        right_traj_vao = glGenVertexArrays(1)
        left_traj_vertices = glGenBuffers(1)
        left_traj_indices = glGenBuffers(1)
        right_traj_vertices = glGenBuffers(1)
        right_traj_indices = glGenBuffers(1)

        glBindVertexArray(left_traj_vao)
        glPointSize( 3.0 )

        glBindBuffer(GL_ARRAY_BUFFER, left_traj_vertices)
        glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(l_traj_vec), l_traj_vec.flatten(),
                     GL_STATIC_DRAW)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
        glEnableVertexAttribArray(0)

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, left_traj_indices)

        glBufferData(GL_ELEMENT_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(indices_vec), indices_vec.flatten(),
                     GL_STATIC_DRAW)


        glBindVertexArray(right_traj_vao)

        glBindBuffer(GL_ARRAY_BUFFER, right_traj_vertices)
        glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(r_traj_vec), r_traj_vec.flatten(),
                     GL_STATIC_DRAW)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
        glEnableVertexAttribArray(0)

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, right_traj_indices)

        glBufferData(GL_ELEMENT_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(indices_vec), indices_vec.flatten(),
                     GL_STATIC_DRAW)

        glBindVertexArray(0)




        cube_scale_ = scaleM4x4(np.array([1.0, 1.0, 1.0]))

        left_cube_pos += offset

        left_translation = translateM4x4(np.array([left_cube_pos, 0.0, -7.5 * surface_size]))
        glUniformMatrix4fv(traj_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(left_translation).flatten())
        glUniformMatrix4fv(traj_program.uniformLocation("view"), 1, GL_FALSE, np.transpose(view).flatten())
        glUniformMatrix4fv(traj_program.uniformLocation("projection"), 1, GL_FALSE, projection.flatten())

        glBindVertexArray(left_traj_vao)
        glDrawElements(GL_LINE_STRIP, indices_vec.size, GL_UNSIGNED_INT, None)

        glBindVertexArray(traj_vao)
        glDrawElements(GL_TRIANGLE_STRIP, ind_traj, GL_UNSIGNED_INT, None)

        right_translation = translateM4x4(np.array([-left_cube_pos, 0.0, -8.5 * surface_size]))
        glUniformMatrix4fv(traj_program.uniformLocation("model"), 1, GL_FALSE, np.transpose(right_translation).flatten())
        glDrawElements(GL_TRIANGLE_STRIP, ind_traj, GL_UNSIGNED_INT, None)


        glBindVertexArray(right_traj_vao)
        glDrawElements(GL_LINE_STRIP, indices_vec.size, GL_UNSIGNED_INT, None)







        if not cm_change_counter % cube_steps:
            # left_cube_pos = left_cube_pos + offset * (cube_steps-1)
            offset *= -1
            # r_traj_part, l_traj_part = l_traj_part, r_traj_part


        traj_program.unbindProgram()

        glfw.swap_buffers(window)

    glfw.terminate()
Beispiel #19
0
 def SetUniformMat4f(self, name, value):
     glUniformMatrix4fv(self.GetUniformLocation(name), 1, GL_FALSE, value)        
Beispiel #20
0
    def update(self):
        for camera in self.__active_camera:
            self.__vertices = camera.vertices
            self.__indices = camera.indices
            self.__data_for_render = camera.get_data_for_render()
            glBindBuffer(GL_ARRAY_BUFFER, self.__VBO)
            glBufferData(GL_ARRAY_BUFFER, self.__vertices.nbytes,
                         self.__vertices, GL_STATIC_DRAW)
            camera.bind_frame_buffer()
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
            for material, data in self.__data_for_render.items():
                material.use_program()
                num_of_items = sum(
                    TYPE_TO_LENGTH[type_]
                    for attrib, type_ in material.attributes_types.items()
                    if attrib not in material.instanced_attribs)
                pointer = 0
                glBindBuffer(GL_ARRAY_BUFFER, self.__VBO)
                for attrib, index in sorted(material.attributes.items(),
                                            key=lambda x: x[1]):
                    if attrib not in material.instanced_attribs:
                        length = TYPE_TO_LENGTH[
                            material.attributes_types[attrib]]
                        glEnableVertexAttribArray(index)
                        glVertexAttribPointer(
                            index, length, GL_FLOAT, GL_FALSE,
                            self.__vertices.itemsize * num_of_items,
                            ctypes.c_void_p(pointer * 4))
                        pointer += length
                if material.view_matrix_name in material.uniforms:
                    glUniformMatrix4fv(
                        material.uniforms[material.view_matrix_name], 1,
                        GL_FALSE, camera.obj.inverse_matrix)
                if material.projection_matrix_name in material.uniforms:
                    glUniformMatrix4fv(
                        material.uniforms[material.projection_matrix_name], 1,
                        GL_FALSE, camera.projection)
                for dat in data:
                    sampler_id = 0
                    for uniform, index in material.uniforms.items():
                        if material.uniforms_types[uniform] == GL_SAMPLER_2D:
                            if uniform in dat['object'].components[
                                    'Mesh'].uniform_data:
                                unif_dat = dat['object'].components[
                                    'Mesh'].uniform_data[uniform]
                                if callable(unif_dat):
                                    unif_dat = unif_dat()
                                    glUniform1i(index, sampler_id)
                                    glActiveTexture(GL_TEXTURE0 + sampler_id)
                                    unif_dat.bind_texture()

                                    unif_dat.load_settings()
                                    if unif_dat.default_texture == unif_dat.texture:
                                        unif_dat.send_texture()
                                    # if type(unif_dat) == int:
                                    #     glUniform1i(index, sampler_id)
                                    # glActiveTexture(GL_TEXTURE0 + sampler_id)
                                    # glBindTexture(GL_TEXTURE_2D, unif_dat)
                                else:
                                    glUniform1i(index, sampler_id)
                                    glActiveTexture(GL_TEXTURE0 + sampler_id)
                                    unif_dat.bind_texture()

                                    unif_dat.load_settings()
                                    if unif_dat.default_texture == unif_dat.texture:
                                        unif_dat.send_texture()
                                    # glUniform1i(index, sampler_id)
                                    # glActiveTexture(GL_TEXTURE0 + sampler_id)
                                    # glBindTexture(GL_TEXTURE_2D, unif_dat)
                            elif 'Texture' in dat['object'].components:
                                # location = material.uniforms[uniform]
                                texture = dat['object'].components['Texture']
                                glUniform1i(index, sampler_id)
                                glActiveTexture(GL_TEXTURE0 + sampler_id)
                                texture.bind_texture()

                                texture.load_settings()
                                if texture.default_texture == texture.texture:
                                    texture.send_texture()
                                # texture.bind_default_texture()
                            sampler_id += 1
                        elif material.model_matrix_name == uniform:
                            glUniformMatrix4fv(
                                index, 1, GL_FALSE,
                                dat['object'].transformation_matrix)
                        elif material.view_matrix_name == uniform:
                            pass
                        elif material.projection_matrix_name == uniform:
                            pass
                        elif uniform in dat['object'].components[
                                'Mesh'].uniform_data:
                            uniform_data = dat['object'].components[
                                'Mesh'].uniform_data[uniform]
                            if callable(uniform_data):
                                uniform_data = uniform_data()
                                if type(uniform_data) == int or float:
                                    glUniform1f(index, float(uniform_data))
                            elif type(uniform_data) == int or float:
                                glUniform1f(index, float(uniform_data))

                    # glDrawElements(GL_TRIANGLES, dat['length'], GL_UNSIGNED_INT, ctypes.c_void_p(dat['pointer'] * 0))
                    flatten_indices = dat['indices']
                    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.__EBO)
                    glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                                 flatten_indices.nbytes, flatten_indices,
                                 GL_STATIC_DRAW)
                    # glDrawElements(GL_TRIANGLES, len(flatten_indices), GL_UNSIGNED_INT, None)
                    mesh = dat['object'].components['Mesh']
                    if len(mesh.instanced_point_data):
                        instance_data = mesh.get_instanced_data_positioned_to_material(
                            material, flattened=False)
                        instance_cnt = len(instance_data)
                        instance_data = instance_data.flatten()
                        glBindBuffer(GL_ARRAY_BUFFER, self.__instanceVBO)
                        glBufferData(GL_ARRAY_BUFFER, instance_data.nbytes,
                                     instance_data, GL_STATIC_DRAW)
                        num_of_items = sum(
                            TYPE_TO_LENGTH[material.attributes_types[attrib]]
                            for attrib in material.instanced_attribs)
                        ptr = 0
                        for attrib, index in sorted(
                                material.attributes.items(),
                                key=lambda x: x[1]):
                            if attrib in material.instanced_attribs:
                                length = TYPE_TO_LENGTH[
                                    material.attributes_types[attrib]]
                                glEnableVertexAttribArray(index)
                                glVertexAttribPointer(
                                    index, length, GL_FLOAT, GL_FALSE,
                                    instance_data.itemsize * num_of_items,
                                    ctypes.c_void_p(ptr * 4))
                                glVertexAttribDivisor(index, 1)
                                ptr += length

                        glDrawElementsInstanced(GL_TRIANGLES,
                                                len(flatten_indices),
                                                GL_UNSIGNED_INT, None,
                                                instance_cnt)
                    else:
                        glDrawRangeElements(GL_TRIANGLES, dat['pointer'],
                                            dat['pointer'] + dat['length'],
                                            len(flatten_indices),
                                            GL_UNSIGNED_INT, None)
Beispiel #21
0
 def bind_uniform_matrix(self, data, name):
     """Bind uniform matrix parameter."""
     location = glGetUniformLocation(self.__program, name)
     assert location >= 0
     glUniformMatrix4fv(location, 1, GL_FALSE, data.flatten())
Beispiel #22
0
shaders.glUseProgram(shaderProg)

points = vbo.VBO(data=imgnp,
                 usage="GL_DYNAMIC_DRAW",
                 target='GL_ARRAY_BUFFER',
                 size=None)
points.bind()

modelmat = glGetUniformLocation(shaderProg, 'model')
viewmat = glGetUniformLocation(shaderProg, 'view')
projectionmat = glGetUniformLocation(shaderProg, 'projection')

glPushMatrix()
glRotatef(-90, 0, 0, 1)

scal = 0.01
glTranslatef(-0.5, -0.5, 0)
glScalef(1 / imgnp.shape[0], 1 / imgnp.shape[1], 1)
model2 = glGetDoublev(GL_MODELVIEW_MATRIX)
glPopMatrix()
# print(model2)

glUniformMatrix4fv(modelmat, 1, GL_FALSE, model2)

glutDisplayFunc(draw_points)

# glutInitWindowPosition(600, 100)
# wind2 = glutCreateWindow("OpenGL Window2")
# glutMouseFunc(moveMouse)
glutMainLoop()
Beispiel #23
0
def render_thing(thing, position_location, normal_location, color_location, modelview_location, context_matrix):
    try:
        translate = np.array(matrix_translate(thing["position"]), 'f')
    except:
        print "render_thing can't translate thing: ", thing
        exit()
    #print "render_thing type: ", thing["type"], thing["position"]
    context_matrix = np.dot(context_matrix, translate)

    rotates = thing["rotates"]
    if len(rotates) == 2:
        rotate0 = np.array(matrix_rotate_ortho(rotates[0]["angle"], rotates[0]["axis"]), 'f')
        tmp_matrix = np.dot(context_matrix, rotate0)
        rotate1 = np.array(matrix_rotate_ortho(rotates[1]["angle"], rotates[1]["axis"]), 'f')
        context_matrix = np.dot(tmp_matrix, rotate1)
    #print "render_thing:\n {}\n{}\n{}".format(translate, rotate0, rotate1)
    #print "context_matrix:\n", context_matrix
    glUniformMatrix4fv(modelview_location, 1, True, context_matrix)
    geometry = thing["geometry"]

    if geometry != None:
        if geometry["static"]:
            key = int(float(geometry["id"]))
            #print "thing type: {}, key: {}".format(thing["type"], key)
            if not key in vbos:
                vertices = geometry["vertices"]
                #print "adding geometry:\n{}".format(vertices[0])
                #vbos[key] = (vbo.VBO(np.array(vertices, 'f')), len(vertices))
                vbos[key] = (vbo.VBO(vertices), len(vertices))
            buffer_object, buffer_size = vbos[key]
        else:
            vertices = geometry["vertices"]
            buffer_object = vbo.VBO(vertices)
            buffer_size = len(vertices)
        #print "rendering type: {}, size: {}".format(buffer_object, buffer_size)
        #pdb.set_trace()
        buffer_object.bind()
        try:
            glEnableVertexAttribArray( position_location )
            glEnableVertexAttribArray( normal_location )
            glEnableVertexAttribArray( color_location )
            stride = 10*4
            glVertexAttribPointer(
                position_location,
                3, GL_FLOAT,False, stride, buffer_object
            )
            glVertexAttribPointer(
                normal_location,
                3, GL_FLOAT,False, stride, buffer_object+12
            )
            glVertexAttribPointer(
                color_location,
                4, GL_FLOAT,False, stride, buffer_object+24
            )
            glDrawArrays(GL_TRIANGLES, 0, buffer_size)
            #print 'buffer size: ', buffer_size

        finally:
            buffer_object.unbind()
            glDisableVertexAttribArray( position_location )
            glDisableVertexAttribArray( color_location )
    else:
        for child in thing["children"]:
            render_thing(child, position_location, normal_location, color_location, modelview_location, context_matrix)
Beispiel #24
0
def run():
	#Start OpenGL and ask it for an OpenGL context
	pygame.init()
	clock = pygame.time.Clock()
	screen = pygame.display.set_mode(SCREEN_SIZE, pygame.HWSURFACE|pygame.OPENGL|pygame.DOUBLEBUF)
	
	#The first thing we do is print some OpenGL details and check that we have a good enough version
	print("OpenGL Implementation Details:")
	if glGetString(GL_VENDOR):
		print("\tGL_VENDOR: {}".format(glGetString(GL_VENDOR).decode()))
	if glGetString(GL_RENDERER):
		print("\tGL_RENDERER: {}".format(glGetString(GL_RENDERER).decode()))
	if glGetString(GL_VERSION):
		print("\tGL_VERSION: {}".format(glGetString(GL_VERSION).decode()))
	if glGetString(GL_SHADING_LANGUAGE_VERSION):
		print("\tGL_SHADING_LANGUAGE_VERSION: {}".format(glGetString(GL_SHADING_LANGUAGE_VERSION).decode()))
	
	major_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[0])
	minor_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[1])
	if major_version < 3 or (major_version < 3 and minor_version < 0):
		print("OpenGL version must be at least 3.0 (found {0})".format(glGetString(GL_VERSION).decode().split()[0]))
	
	#Now onto the OpenGL initialisation
	
	#Set up depth culling
	glEnable(GL_CULL_FACE)
	glEnable(GL_DEPTH_TEST)
	glDepthMask(GL_TRUE)
	glDepthFunc(GL_LEQUAL)
	glDepthRange(0.0, 1.0)
	
	#We create out shaders which do little more than set a flat colour for each face
	
	VERTEX_SHADER = shaders.compileShader(b"""
	#version 130
	
	in vec4 position;
	in vec4 normal;
	
	uniform mat4 projectionMatrix;
	uniform mat4 viewMatrix;
	uniform mat4 modelMatrix;
	
	flat out float theColor;
	
	void main()
	{
		vec4 temp = modelMatrix * position;
		temp = viewMatrix * temp;
		gl_Position = projectionMatrix * temp;
		
		theColor = clamp(abs(dot(normalize(normal.xyz), normalize(vec3(0.9,0.1,0.5)))), 0, 1);
	}
	""", GL_VERTEX_SHADER)
	
	
	FRAGMENT_SHADER = shaders.compileShader(b"""
	#version 130
	
	flat in float theColor;
	
	out vec4 outputColor;
	void main()
	{
		outputColor = vec4(1.0, 0.5, theColor, 1.0);
	}
	""", GL_FRAGMENT_SHADER)
	
	shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)
	
	#And then grab our attribute locations from it
	glBindAttribLocation(shader, 0, b"position")
	glBindAttribLocation(shader, 1, b"normal")
	
	#Create the Vertex Array Object to hold our volume mesh
	vertexArrayObject = GLuint(0)
	glGenVertexArrays(1, vertexArrayObject)
	glBindVertexArray(vertexArrayObject)
	
	#Create the index buffer object
	indexPositions = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER, usage=GL_STATIC_DRAW)
	#Create the VBO
	vertexPositions = vbo.VBO(vertices, usage=GL_STATIC_DRAW)
	
	#Bind our VBOs and set up our data layout specifications
	with indexPositions, vertexPositions:
		glEnableVertexAttribArray(0)
		glVertexAttribPointer(0, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(0*vertices.dtype.itemsize))
		glEnableVertexAttribArray(1)
		glVertexAttribPointer(1, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(3*vertices.dtype.itemsize))
		
		glBindVertexArray(0)
		glDisableVertexAttribArray(0)
	
	#Now grab out transformation martix locations
	modelMatrixUnif = glGetUniformLocation(shader, b"modelMatrix")
	viewMatrixUnif = glGetUniformLocation(shader, b"viewMatrix")
	projectionMatrixUnif = glGetUniformLocation(shader, b"projectionMatrix")
	
	modelMatrix = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f')
	viewMatrix = np.array([[1.0,0.0,0.0,0.0],[0.0,1.0,0.0,0.0],[0.0,0.0,1.0,-50.0],[0.0,0.0,0.0,1.0]], dtype='f')
	projectionMatrix = np.array([[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], dtype='f')
	
	#These next few lines just set up our camera frustum
	fovDeg = 45.0
	frustumScale = 1.0 / tan(radians(fovDeg) / 2.0)
	
	zNear = 1.0
	zFar = 1000.0
	
	projectionMatrix[0][0] = frustumScale
	projectionMatrix[1][1] = frustumScale
	projectionMatrix[2][2] = (zFar + zNear) / (zNear - zFar)
	projectionMatrix[2][3] = -1.0
	projectionMatrix[3][2] = (2 * zFar * zNear) / (zNear - zFar)
	
	#viewMatrix and projectionMatrix don't change ever so just set them once here
	with shader:
		glUniformMatrix4fv(projectionMatrixUnif, 1, GL_TRUE, projectionMatrix)
		glUniformMatrix4fv(viewMatrixUnif, 1, GL_TRUE, viewMatrix)
	
	#These are used to track the rotation of the volume
	LastFrameMousePos = (0,0)
	CurrentMousePos = (0,0)
	xRotation = 0
	yRotation = 0
	
	while True:
		clock.tick()
		
		for event in pygame.event.get():
			if event.type == pygame.QUIT:
				return
			if event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE:
				return
			if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
				CurrentMousePos = event.pos
				LastFrameMousePos = CurrentMousePos
			if event.type == pygame.MOUSEMOTION and 1 in event.buttons:
				CurrentMousePos = event.pos
				diff = (CurrentMousePos[0] - LastFrameMousePos[0], CurrentMousePos[1] - LastFrameMousePos[1])
				xRotation += event.rel[0]
				yRotation += event.rel[1]
				LastFrameMousePos = CurrentMousePos
		
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
		
		#Perform the rotation of the mesh
		moveToOrigin = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f')
		rotateAroundX = np.array([[1.0,0.0,0.0,0.0],[0.0,cos(radians(yRotation)),-sin(radians(yRotation)),0.0],[0.0,sin(radians(yRotation)),cos(radians(yRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f')
		rotateAroundY = np.array([[cos(radians(xRotation)),0.0,sin(radians(xRotation)),0.0],[0.0,1.0,0.0,0.0],[-sin(radians(xRotation)),0.0,cos(radians(xRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f')
		
		modelMatrix = rotateAroundY.dot(rotateAroundX.dot(moveToOrigin))
		
		with shader:
			glUniformMatrix4fv(modelMatrixUnif, 1, GL_TRUE, modelMatrix)
			glBindVertexArray(vertexArrayObject)
			
			glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None)
			
			glBindVertexArray(0)
		
		# Show the screen
		pygame.display.flip()
Beispiel #25
0
 def bind(self, uniform_location):
     count = 1
     transpose = False
     glUniformMatrix4fv(uniform_location, count, transpose, self._data)
 def _load_matrix(location: int, matrix: np.ndarray) -> None:
     glUniformMatrix4fv(location, 1, True, matrix)
Beispiel #27
0
 def bind_uniform_matrix(self, data, name):
     """Bind uniform matrix parameter."""
     location = glGetUniformLocation(self.__program, name)
     assert location >= 0
     glUniformMatrix4fv(location, 1, GL_FALSE, data.flatten())
Beispiel #28
0
 def setMat4(self, name, mat):
     glUniformMatrix4fv(self.getUniformLocation(name), 1, GL_FALSE,
                        glm.value_ptr(mat))
Beispiel #29
0
 GL_FLOAT_VEC2: (GLfloat, 2, glUniform2fv),
 GL_FLOAT_VEC3: (GLfloat, 3, glUniform3fv),
 GL_FLOAT_VEC4: (GLfloat, 4, glUniform4fv),
 GL_INT: (GLint, 1, glUniform1iv),
 GL_INT_VEC2: (GLint, 2, glUniform2iv),
 GL_INT_VEC3: (GLint, 3, glUniform3iv),
 GL_INT_VEC4: (GLint, 4, glUniform4iv),
 GL_FLOAT_MAT2:
 (GLfloat, 4, lambda x, y, z: glUniformMatrix2fv(x, y, TRANSPOSE_MATRIX, z),
  (2, 2)),
 GL_FLOAT_MAT3:
 (GLfloat, 9, lambda x, y, z: glUniformMatrix3fv(x, y, TRANSPOSE_MATRIX, z),
  (3, 3)),
 GL_FLOAT_MAT4:
 (GLfloat, 16,
  lambda x, y, z: glUniformMatrix4fv(x, y, TRANSPOSE_MATRIX, z), (4, 4)),
 GL_FLOAT_MAT2x3:
 (GLfloat, 6,
  lambda x, y, z: glUniformMatrix2x3fv(x, y, TRANSPOSE_MATRIX, z), (2, 3)),
 GL_FLOAT_MAT2x4:
 (GLfloat, 8,
  lambda x, y, z: glUniformMatrix2x4fv(x, y, TRANSPOSE_MATRIX, z), (2, 4)),
 GL_FLOAT_MAT3x2:
 (GLfloat, 6,
  lambda x, y, z: glUniformMatrix3x2fv(x, y, TRANSPOSE_MATRIX, z), (3, 2)),
 GL_FLOAT_MAT3x4:
 (GLfloat, 12,
  lambda x, y, z: glUniformMatrix3x4fv(x, y, TRANSPOSE_MATRIX, z), (3, 4)),
 GL_FLOAT_MAT4x2:
 (GLfloat, 8,
  lambda x, y, z: glUniformMatrix4x2fv(x, y, TRANSPOSE_MATRIX, z), (4, 2)),