lab7_vertex_arrays.py

import numpy as np
import glfw
from OpenGL.GL import *
from OpenGL.GLUT import *
import pygame
import time

# Параметры окна и масштабирования
window_width = 800
window_height = 800
scale = 0.256

# Параметры вращения и анимации
a = np.pi / 2
l = 0.25
T = (1, 0, 0, 0,
     0, 1, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1)

animation_mode = False
fi = 0
tetha = 0
sides = 6
radius = 1
height = 1
flying_speed = 0
V = np.pi * 10 ** (-5)
acl = 10 ** (-7)

# Переключатели режимов
light_mode = False
filling_mode = True

# Переменные для хранения VAO и VBO
vao = None
vbo = None
ebo = None
indices_count = 0

def generate_texture():
    textureSurface = pygame.image.load('img_2.png')
    textureData = pygame.image.tobytes(textureSurface, "RGBA")
    width = textureSurface.get_width()
    height = textureSurface.get_height()

    glEnable(GL_TEXTURE_2D)
    texid = glGenTextures(1)

    glBindTexture(GL_TEXTURE_2D, texid)

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData)

def create_prism_buffers(cx, cy, cz, r, h, sides):
    global vao, vbo, ebo, indices_count

    vertices = []
    normals = []
    tex_coords = []
    indices = []

    angle_step = 2 * np.pi / sides

    # Верхняя грань
    top_center_index = len(vertices) // 3
    vertices.extend([cx, cy, cz + h / 2])
    normals.extend([0, 0, 1])
    tex_coords.extend([0.5, 0.5])

    for i in range(sides):
        angle = i * angle_step
        x = cx + r * np.cos(angle)
        y = cy + r * np.sin(angle)
        vertices.extend([x, y, cz + h / 2])
        normals.extend([0, 0, 1])
        tex_coords.extend([0.5 + 0.5 * np.cos(angle), 0.5 + 0.5 * np.sin(angle)])
        indices.extend([top_center_index, top_center_index + i + 1, top_center_index + ((i + 1) % sides) + 1])

    # Нижняя грань
    bottom_center_index = len(vertices) // 3
    vertices.extend([cx, cy, cz - h / 2])
    normals.extend([0, 0, -1])
    tex_coords.extend([0.5, 0.5])

    for i in range(sides):
        angle = i * angle_step
        x = cx + r * np.cos(angle)
        y = cy + r * np.sin(angle)
        vertices.extend([x, y, cz - h / 2])
        normals.extend([0, 0, -1])
        tex_coords.extend([0.5 + 0.5 * np.cos(angle), 0.5 + 0.5 * np.sin(angle)])
        indices.extend([bottom_center_index, bottom_center_index + ((i + 1) % sides) + 1, bottom_center_index + i + 1])

    # Боковые грани
    for i in range(sides):
        angle = i * angle_step
        next_angle = ((i + 1) % sides) * angle_step

        x1 = cx + r * np.cos(angle)
        y1 = cy + r * np.sin(angle)
        x2 = cx + r * np.cos(next_angle)
        y2 = cy + r * np.sin(next_angle)

        # Нижняя вершина текущей боковой грани
        vertices.extend([x1, y1, cz - h / 2])
        normals.extend([np.cos(angle), np.sin(angle), 0])
        tex_coords.extend([i / sides, 0])

        # Верхняя вершина текущей боковой грани
        vertices.extend([x1, y1, cz + h / 2])
        normals.extend([np.cos(angle), np.sin(angle), 0])
        tex_coords.extend([i / sides, 1])

        # Нижняя вершина следующей боковой грани
        vertices.extend([x2, y2, cz - h / 2])
        normals.extend([np.cos(next_angle), np.sin(next_angle), 0])
        tex_coords.extend([(i + 1) / sides, 0])

        # Верхняя вершина следующей боковой грани
        vertices.extend([x2, y2, cz + h / 2])
        normals.extend([np.cos(next_angle), np.sin(next_angle), 0])
        tex_coords.extend([(i + 1) / sides, 1])

        # Добавление индексов для текущей боковой грани
        base_index = bottom_center_index + sides + 1 + i * 4
        indices.extend([base_index, base_index + 1, base_index + 2, base_index + 2, base_index + 1, base_index + 3])

    indices_count = len(indices)

    # Преобразование данных в массивы NumPy
    vertices = np.array(vertices, dtype=np.float32)
    normals = np.array(normals, dtype=np.float32)
    tex_coords = np.array(tex_coords, dtype=np.float32)
    indices = np.array(indices, dtype=np.uint32)

    # Создание и настройка VAO
    vao = glGenVertexArrays(1)
    glBindVertexArray(vao)

    # Создание и настройка VBO для вершин
    vbo = glGenBuffers(3)
    glBindBuffer(GL_ARRAY_BUFFER, vbo[0])
    glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL_STATIC_DRAW)
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(0)

    # Создание и настройка VBO для нормалей
    glBindBuffer(GL_ARRAY_BUFFER, vbo[1])
    glBufferData(GL_ARRAY_BUFFER, normals.nbytes, normals, GL_STATIC_DRAW)
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(1)

    # Создание и настройка VBO для текстурных координат
    glBindBuffer(GL_ARRAY_BUFFER, vbo[2])
    glBufferData(GL_ARRAY_BUFFER, tex_coords.nbytes, tex_coords, GL_STATIC_DRAW)
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(2)

    # Создание и настройка EBO для индексов
    ebo = glGenBuffers(1)
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices, GL_STATIC_DRAW)

    # Отвязываем VAO
    glBindVertexArray(0)


def render_prism():
    """Отображает призму с использованием VAO и VBO."""
    glBindVertexArray(vao)
    glDrawElements(GL_TRIANGLES, indices_count, GL_UNSIGNED_INT, None)
    glBindVertexArray(0)


def display(window):
    glEnable(GL_DEPTH_TEST)
    glDepthFunc(GL_LESS)
    glClearColor(0.0, 0.0, 0.0, 0.0)
    glLoadIdentity()
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glMultMatrixd(T)

    if animation_mode:
        move_object()

    glScale(scale, scale, scale)
    glTranslatef(0, flying_speed, 0)
    glRotatef(fi, 1, 0, 0)
    glRotatef(tetha, 0, 1, 0)

    render_prism()

    glfw.swap_buffers(window)
    glfw.poll_events()


def key_callback(window, key, scancode, action, mods):
    global x_angle, y_angle, scale, animation_mode, fi, tetha, sides, radius, height, T, a, l

    if key == glfw.KEY_0:
        a -= np.pi / 12

        T = (1, 0, 0, 0,
             0, 1, 0, 0,
             np.cos(a), np.sin(a), 1, 0,
             0, 0, 0, 1)

    if action == glfw.PRESS and key == glfw.KEY_1:
        if sides > 3:
            sides -= 1
            create_prism_buffers(0, 0, 0, radius, height, sides)
        else:
            print('Sides must be greater than 3')

    if action == glfw.PRESS and key == glfw.KEY_2:
        sides += 1
        create_prism_buffers(0, 0, 0, radius, height, sides)

    if action == glfw.PRESS and key == glfw.KEY_Q:
        if radius > 0.1:
            radius -= 0.1
            create_prism_buffers(0, 0, 0, radius, height, sides)
        else:
            print("Radius must be greater than 0.1")

    if action == glfw.PRESS and key == glfw.KEY_E:
        radius += 0.1
        create_prism_buffers(0, 0, 0, radius, height, sides)

    if action == glfw.PRESS and key == glfw.KEY_R:
        if height > 0.1:
            height -= 0.1
            create_prism_buffers(0, 0, 0, radius, height, sides)
        else:
            print("Height must be greater than 0.1")

    if action == glfw.PRESS and key == glfw.KEY_T:
        height += 0.1
        create_prism_buffers(0, 0,0, radius, height, sides)

    if action == glfw.PRESS and key == glfw.KEY_ENTER:
        mode = glGetIntegerv(GL_POLYGON_MODE)
        if mode[1] == GL_LINE:
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
        else:
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)

    if action == glfw.PRESS or action == glfw.REPEAT:
        if key == glfw.KEY_A:
            fi -= 2
        if key == glfw.KEY_D:
            fi += 2
        if key == glfw.KEY_W:
            tetha -= 2
        if key == glfw.KEY_S:
            tetha += 2
        if key == glfw.KEY_UP:
            scale += 0.05
        if key == glfw.KEY_DOWN:
            scale -= 0.05

        global light_mode

        if key == glfw.KEY_L:
            if glIsEnabled(GL_LIGHTING):
                glDisable(GL_LIGHTING)
            else:
                glEnable(GL_LIGHTING)
            return
        if key == glfw.KEY_M:
            animation_mode = not animation_mode
            return

def mouse_callback(window, button, action, mods):
    global filling_mode
    if action == glfw.PRESS:
        if button == glfw.MOUSE_BUTTON_LEFT:
            filling_mode = not filling_mode
            if filling_mode:
                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
            else:
                glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)

def move_object():
    global V, flying_speed, acl
    flying_speed -= V
    V += acl
    if flying_speed < -2.2 or flying_speed > 2.2:
        V = -V

def light():
    glEnable(GL_LIGHTING)
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, [[0.2, 0.2, 0.2, 1]])

    # Light 0
    glLightfv(GL_LIGHT0, GL_AMBIENT, [0, 0, 0, 1])  # фоновое излучение
    glLightfv(GL_LIGHT0, GL_DIFFUSE, [0.5, 0.5, 0.5, 1])  # рассеяное излучение
    glLightfv(GL_LIGHT0, GL_SPECULAR, [0.5, 0.5, 0.5, 1])  # зеркальное излучение
    glLightfv(GL_LIGHT0, GL_POSITION, [1, 1, -1, 1])  # местоположение источника света
    glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0)  # постоянный коэффициент
    glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.2)  # линейный коэффициент
    glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.05)  # квадратичный коэффициент

    # Light 1
    glLightfv(GL_LIGHT1, GL_AMBIENT, [0, 0, 0, 1])
    glLightfv(GL_LIGHT1, GL_DIFFUSE, [0.6, 0.6, 0.6, 1])
    glLightfv(GL_LIGHT1, GL_SPECULAR, [0.5, 0.5, 0.5, 1])
    glLightfv(GL_LIGHT1, GL_POSITION, [-1, 1, 1, 1])
    glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.0)
    glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.2)
    glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.1)

    # Light 2
    glLightfv(GL_LIGHT2, GL_AMBIENT, [0, 0, 0, 1])
    glLightfv(GL_LIGHT2, GL_DIFFUSE, [0.8, 0.8, 0.8, 1])
    glLightfv(GL_LIGHT2, GL_SPECULAR, [0.5, 0.5, 0.5, 1])
    glLightfv(GL_LIGHT2, GL_POSITION, [0, -1, 0, 1])
    glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, 1.0)
    glLightf(GL_LIGHT2, GL_LINEAR_ATTENUATION, 0.2)
    glLightf(GL_LIGHT2, GL_QUADRATIC_ATTENUATION, 0.1)

    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, [1, 1, 1, 1])
    glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, 50.0)
    glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, [0, 0, 0, 1])

    glEnable(GL_LIGHT0)
    glEnable(GL_LIGHT1)
    glEnable(GL_LIGHT2)


def main():
    if not glfw.init():
        return

    window = glfw.create_window(window_width, window_height, "Prism with Vertex Arrays", None, None)

    if not window:
        glfw.terminate()
        return

    glfw.make_context_current(window)
    glfw.set_key_callback(window, key_callback)
    glfw.set_mouse_button_callback(window, mouse_callback)
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
    generate_texture()
    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()
    light()

    # Создаем буферы для призмы
    create_prism_buffers(0, 0, 0, radius, height, sides)

    # while not glfw.window_should_close(window):
    #     display(window)
    for _ in range(300):
        display(window)

    glfw.destroy_window(window)
    glfw.terminate()


if __name__ == '__main__':
    start = time.monotonic()
    main()
    stop = time.monotonic()
    print('time:', stop - start) # time: 0.5940000000409782