Tìm hiểu OpenGL Python

Lượt xem bài viết. 22.216

Phát triển kiến ​​thức vượt trội về kết xuất phần cứng vertex shader của đồ họa 3D

Tìm hiểu OpenGL với Python

Bạn sẽ học được gì

• Hiểu các khái niệm cơ bản cần thiết để hiển thị cảnh bằng OpenGL

• Viết mã vertex shader để hiển thị các điểm, khung dây, vật thể rắn được chiếu sáng và lưới có kết cấu

• Xác định các bước trong quy trình kết xuất OpenGL và thảo luận về mục đích của từng bước

• Hoàn thành quá trình phát triển công cụ đồ họa 3D tổng quát bằng Python

Yêu cầu

• Kiến thức làm việc về ngôn ngữ thủ tục hoặc hướng đối tượng

• Một sự tôn trọng lành mạnh đối với vectơ và lượng giác

Sự miêu tả

Tại sao bạn nên học OpenGL? . (b) Kiến thức về OpenGL sẽ tiết lộ cho bạn những gì diễn ra trong nền tảng của các công cụ đồ họa và trò chơi khác, giúp bạn có kỹ năng xử lý sự cố và giải quyết vấn đề vượt trội trong các ứng dụng khác (c) Nó sẽ nâng cao hiểu biết của bạn về toán học 3D và

Được thiết kế cho sinh viên trình độ TRUNG CẤP có kiến ​​thức lập trình làm việc, nội dung trong khóa học này sẽ hướng dẫn bạn từng bước thiết lập Python, Pygame và PyOpenG cũng như phát triển công cụ đồ họa 3D tổng quát được thiết kế nhanh chóng (như

Bạn sẽ tìm hiểu về

• Môi trường phát triển Pycharm
• API Pygame, một giao diện cho OpenGL
• PyOpenGL, trình bao bọc python cho API OpenGL
• Các hệ tọa độ trực giao, phối cảnh, không gian màn hình và không gian camera
• Di chuyển máy ảnh ảo
• Xây dựng đồ họa 3D bằng cách sử dụng trình tạo bóng đỉnh
• tô màu đỉnh
• Chiếu sáng – Tìm hiểu OpenGL với Python
• Toán học cần thiết để làm việc với không gian 3D và định vị các đỉnh với nhiều ma trận xem 4×4
• Làm việc với các tệp mô hình 3D OBJ
• Ánh xạ UV và kết cấu của mắt lưới

Mọi người đang nói gì về các khóa học của Penny

• Một lần nữa Penny mang đến một khóa học mạnh mẽ, rõ ràng và xứng đáng. Tôi tin rằng tài liệu này sẽ rất hữu ích trong việc hiểu các hoạt động cơ bản của nhiều công cụ trò chơi. Nó cũng có một chút khác biệt sẽ cho phép tôi rèn luyện các kỹ năng trăn của mình để có một số niềm vui bằng cách tạo ra các trò chơi. Cô ấy hướng dẫn rất rõ ràng, rất hiểu biết và tất nhiên cung cấp thông tin dễ theo dõi và hiểu mà bạn có thể dễ dàng tiếp thu và học hỏi
• Cho phép tôi nói điều này cực kỳ quan trọng như thế nào đối với một người quan tâm đến một số loại thiết kế trò chơi. Tạo trò chơi nơi bạn có thể tạo các hành vi AI hỗ trợ các tình huống khẩn cấp
• Tôi thực sự yêu thích phương pháp giảng dạy của Holistic và tôi chưa bao giờ học được nhiều điều như vậy trong vòng vài giờ về cách viết mã hiệu quả với những lời giải thích chi tiết như vậy

Khóa học này tập trung vào việc cung cấp cho sinh viên trải nghiệm thực hành mã hóa một công cụ đồ họa 3D chung bằng PyOpenGL, đồng thời cung cấp phần giới thiệu dễ dàng về Python cho lập trình viên trung cấp

Khóa học này dành cho ai

• Lập trình viên trò chơi trung cấp quan tâm đến việc học OpenGL
• Các lập trình viên Python quan tâm đến việc mở rộng bộ kỹ năng của họ để vẽ đồ họa 3D

Được tạo bởi Penny de Byl, Penny @Holistic3D. com

Cập nhật lần cuối 04/2022

Tiếng Anh

Tiếng Anh [Tự động]

Kích thước. 6. 72GB

TẢI HƯỚNG DẪN

https. //www. demy. com/course/learning-opengl-with-python-for-graphics-and-games/

Gần đây, chúng tôi đã nhận được doanh thu rất thấp. Chủ yếu là do nhấp chuột không hợp lệ (Những người nhấp vào quảng cáo của chúng tôi nhưng không tương tác với các trang quảng cáo. Google biết điều này và sau đó cắt giảm doanh thu của chúng tôi). Chúng tôi cũng nhận được nhiều phản hồi về việc "quá nhiều quảng cáo" nhưng mong các bạn thông cảm rằng bạn càng tương tác với trang web và quảng cáo nhiều thì chúng tôi càng có thể phục vụ các bạn tốt hơn. Cảm ơn bạn đã phản hồi của bạn tho

Đồ họa đã là một phần quan trọng của máy tính trong nhiều thập kỷ nay. Mọi thứ chúng tôi sử dụng trong máy tính và hầu hết mọi ứng dụng chúng tôi sử dụng đều sử dụng đồ họa. Python cũng là ngôn ngữ lập trình cho phép tạo các chương trình liên quan đến đồ họa. Một trong những thư viện quan trọng nhất mà Python sử dụng để phát triển các chương trình liên quan đến đồ họa là PyOpenGL

Nó sử dụng khái niệm OpenGL để hỗ trợ nhiều nền tảng như Linux, Windows và macOS. Trong bài viết này, bạn sẽ tìm hiểu về cách sử dụng thư viện OpenGL như PyOpenGL để triển khai đồ họa trong chương trình Python

OpenGL là gì?

OpenGL là viết tắt của Open Graphics Library, là thư viện lập trình đồ họa đa nền tảng. Nó được hỗ trợ bởi nhiều ngôn ngữ lập trình và giao diện lập trình ứng dụng (API) của nó giúp hiển thị đồ họa vector 2D và 3D. Thư viện đồ họa này tương tác trực tiếp với bộ xử lý đồ họa (GPU) để hiển thị đồ họa vectơ và đồ họa tăng tốc phần cứng. OpenGL đơn giản hơn nhiều so với các thư viện đồ họa khác. Không có gì khó chịu, bây giờ chúng ta hãy bắt đầu triển khai thư viện từ một ví dụ cơ bản

Cài đặt thư viện OpenGL

Để cài đặt OpenGL lần đầu tiên trong chương trình Python của bạn, bạn phải sử dụng pip (gói)

Lệnh cài đặt thư viện PyOpenGL

pip install PyOpenGL PyOpenGL_accelerate
pip install pyopengl
pip install pygame

Khi lệnh này cài đặt thư viện PyOpenGL cho bạn, bạn sẽ nhận được một thông báo

Successfully installed PyOpenGL-3.1.0 PyOpenGL-accelerate-3.1.0

Bây giờ chúng ta hãy viết chương trình để kiểm tra xem các thành phần OpenGL có hoạt động tốt hay không

import OpenGL.GL
import OpenGL.GLUT
import OpenGL.GLU
print("Imports successful!")

PyOpenGL hoạt động như thế nào?

PyOpenGL hoạt động như một thư viện ràng buộc cho chương trình Python. Nó liên kết các giá trị của nó với thư viện GLUT và cho phép nó chạy trên nhiều hệ điều hành như Windows, Linux và Mac OS X. Nó tương tác với Bộ xử lý đồ họa (GPU) để hiển thị hình ảnh vectơ cung cấp cho chúng tôi hình ảnh hoặc hình rõ ràng

Các thành phần của PyOpenGL và các chức năng của nó

Điều đầu tiên, chúng ta cần làm là tạo một cửa sổ với các thuộc tính sau

• Chiều cao. 900px , Chiều rộng. 700px
• Màu nền. RGB (255, 0, 0), trong đó 255 có nghĩa là các màu đối lập với chữ cái tồn tại và 0 có nghĩa là các màu đối lập với chữ cái không tồn tại
• Vị trí cửa sổ. (200, 100)
• Màu đối tượng. RGB (0. 2, 0. 5, 0. 4)
• Chức vụ. 'Cung cấp tiêu đề của mã'

Tạo hai điểm với tọa độ đã cho làm tham số

• P1 (100,100)
• P2 (300, 200)
• Kích thước điểm. 10px, trong đó px là viết tắt của pixel
• Điểm khởi đầu;

Sử dụng PyOpenGlut để vẽ hình tam giác

Chương trình

import numpy as np
from OpenGL.GL import *
import glfw

glfw.init()
# creating a window size having 900 as width and 700 as height
window = glfw.create_window(900, 700, "PyOpenGL Triangle", None,None)
glfw.set_window_pos(window, 500, 300)
glfw.make_context_current(window)

vertices = [-0.5, -0.5,0.0,
             0.5, -0.5,0.0,
             0.0, 0.5,0.0]

v = np.array(vertices, dtype = np.float32)

# this will draw a colorless triangle
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointer(3, GL_FLOAT,0,v)

# this will set a color for your background
glClearColor(255, 180, 0, 0)

while not glfw.window_should_close(window):
    glfw.poll_events()
    glClear(GL_COLOR_BUFFER_BIT)
    glDrawArrays(GL_TRIANGLES,0,3)
    glfw.swap_buffers(window)

glfw.terminate()

đầu ra

Giải trình

Trước tiên, bạn sẽ phải nhập ba thư viện khác nhau bằng cách sử dụng từ khóa nhập. Đây là glfw, NumPy và OpenGL. GL. Biểu tượng * trong câu lệnh nhập xác định mọi thứ. Một điều quan trọng khác mà bạn sẽ nhận thấy là chúng tôi đã nhập thư viện NumPy

Điều này là do chúng tôi phải làm việc, chúng tôi NumPy trong PyOpenGL vì PyopenGL không thể hoạt động với các danh sách Python đơn giản. Theo cách mà mọi họa sĩ yêu cầu một khung vẽ để vẽ bất kỳ bản phác thảo nào, chương trình Python của bạn cũng yêu cầu tạo một cửa sổ trong đó bạn sẽ vẽ đồ họa 2D hoặc 3D. Bạn sẽ phải sử dụng glfw. init() để khởi tạo. Không khởi tạo, lập trình viên sẽ không thể truy cập các chức năng của nó

Tiếp đến là glfw. hàm tạo_window(). Nó giúp tạo ra một cửa sổ. Nó sẽ lấy nhiều đối số (chiều rộng, chiều cao và tên của cửa sổ) làm đầu vào và trả về đầu ra tương ứng. gfw. set_window_pos() giúp thiết lập vị trí cụ thể của cửa sổ trong luồng đầu ra (màn hình) của bạn. Phương pháp này sẽ chấp nhận 3 đối số

Đây là trục x, trục y và tên cửa sổ. Hàm gfw. make_context_current() sẽ chấp nhận phần mở rộng cửa sổ liên quan đến ngữ cảnh hiện tại. Giá trị đỉnh sẽ có ba điểm dưới dạng danh sách đại diện cho vị trí x (đỉnh bên trái), y (đỉnh bên phải) và z (đỉnh trên cùng) trên một mặt phẳng

Tiếp theo, bạn phải sử dụng chức năng glEnableClientState() để kích hoạt các năng lực phía máy khách. Sau đó, hàm glClearColor(0,0,0,0) sẽ giúp thiết lập màu nền lấy R (đỏ), G (xanh lục), B (xanh dương), A (alpha) làm 4 đối số khác nhau. Cuối cùng, bạn sẽ phải tạo một vòng lặp sẽ thực thi cho đến khi quá trình tạo cửa sổ kết thúc. Ở đây, chúng ta đã làm điều này bằng cách sử dụng hàm while(). Bên trong vòng lặp, chúng tôi sẽ sử dụng glfw. poll_events() sẽ kiểm tra các sự kiện được kích hoạt đối với hệ thống cửa sổ

Hàm tiếp theo glClear() sẽ chịu trách nhiệm dọn dẹp màn hình mỗi khi vòng lặp thực thi. Điều này sẽ đảm bảo rằng không có gì trên màn hình trước khi kết xuất đồ họa bằng chương trình Python này. Cuối cùng, hàm glDrawArrays() sẽ đặt đồ họa được vector hóa thành các pixel liên tiếp. Ngoài ra, điều quan trọng là phải kết thúc vòng lặp và tạo đồ họa véc tơ bằng glfw. chấm dứt()

Tạo Tam giác hoạt hình với Độ dốc màu

Chương trình

import numpy as np
from OpenGL.GL import *
import glfw

glfw.init()
window = glfw.create_window(900, 700, "PyOpenGL Triangle", None,None)
glfw.set_window_pos(window, 600, 300)
glfw.make_context_current(window)

vertices = [-0.2, -0.2, 0.0,
             0.2, -0.2,0.0,
             0.0, 0.2, 0.0]

# list the color code here
colors = [0.5, 0.5, 0,
          0, 0.8, 0.9,
          0, 0.2, 1.0 ]

v = np.array (vertices, dtype = np.float32)
c = np.array (colors, dtype = np.float32)
# this will create a color-less triangle
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointer(3, GL_FLOAT, 0, v)
glEnableClientState(GL_COLOR_ARRAY)
glColorPointer(3, GL_FLOAT, 0, c)
# Now we will pour color for the animation's background
glClearColor(0.6, 0.8, 0.2,0.2)

while not glfw.window_should_close(window):
# this while loop will keep iterating all the functions below until the window is not closed
    glfw.poll_events()
    glClear(GL_COLOR_BUFFER_BIT)
# creating rotation animated motion
    glRotatef(0.1, 1, 0 ,0)
    glDrawArrays(GL_TRIANGLES, 0, 3)
    glfw.swap_buffers(window)
glfw.terminate()

đầu ra

Giải trình

Trong chương trình này, chúng tôi cũng áp dụng cách tiếp cận tương tự. Nhưng lần này chúng tôi đã thay đổi kích thước đỉnh. Giá trị đỉnh sẽ có ba điểm dưới dạng danh sách đại diện cho vị trí x (đỉnh bên trái), y (đỉnh bên phải) và z (đỉnh trên cùng) trên một mặt phẳng. 0. 2, -0. 2, 0. 0,   0. 2, -0. 2,0. 0,     0. 0, 0. 2, 0. 0.
Sau đó, chúng tôi có một danh sách mã màu mà chúng tôi phải chuyển đổi thành mảng NumPy bằng 2 dòng này v = np. mảng (đỉnh, dtype = np. float32), c = np. mảng (màu sắc, dtype = np. phao32). Tiếp theo, chúng tôi đã kích hoạt phía máy khách với sự trợ giúp của hàm glEnableClientState().

Sau đó, chúng ta sẽ sử dụng vòng lặp while. Bên trong vòng lặp, chúng tôi sẽ sử dụng glfw. poll_events() phương thức sẽ kiểm tra các sự kiện được kích hoạt cho hệ thống windows. Hàm tiếp theo glClear() sẽ chịu trách nhiệm dọn dẹp màn hình mỗi khi vòng lặp thực thi

Điều này sẽ đảm bảo rằng không có gì trên màn hình trước khi kết xuất đồ họa bằng chương trình Python này. Trong vòng lặp while đó, chúng ta phải sử dụng thêm hàm glrotatef() để thực hiện hoạt ảnh xoay. Cuối cùng, hàm glDrawArrays() sẽ đặt đồ họa được vector hóa thành các pixel liên tiếp

Sử dụng PyOpenGL cùng với mô-đun pygame

Các lập trình viên có thể sử dụng PyOpenGL như một thư viện có thể tương tác với một số lượng lớn các thư viện GUI (bên ngoài) khác của Python. Trong phần này, bạn sẽ sử dụng mô-đun pygame sẽ giúp chúng tôi tạo một khối hoạt hình với sự trợ giúp của thư viện PyOpenGL

Chương trình

from OpenGL.GL import *
from OpenGL.GLU import *
import pygame
from pygame.locals import *

verti = (
    (1, -1, -1),
    (1, 1, -1),
    (-1, 1, -1),
    (-1, -1, -1),
    (1, -1, 1),
    (1, 1, 1),
    (-1, -1, 1),
    (-1, 1, 1)
    )

edgez = (
    (0,1),
    (0,3),
    (0,4),
    (2,1),
    (2,3),
    (2,7),
    (6,3),
    (6,4),
    (6,7),
    (5,1),
    (5,4),
    (5,7)
    )
def Cube():
    glBegin(GL_LINES)
    for edge in edgez:
        for vertex in edge:
            glVertex3fv(verti[vertex])
    glEnd()

def main():
    pygame.init()
    display = (900, 700)
    pygame.display.set_mode(display, DOUBLEBUF | OPENGL)
    gluPerspective(35, (display[0] / display[1]), 0.1, 50.0)
    glTranslatef(0.0, 0.0, -5)
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        glRotatef(3, 1, 1, 1)
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        Cube()
        pygame.display.flip()
        pygame.time.wait(15)

main()

đầu ra

Giải trình

Đầu tiên, chúng tôi đã nhập OpenGL. GL và OpenGL. GLU theo sau là thư viện pygame. Vì đây là hình lập phương ba chiều nên ta phải đặt 8 cạnh khác nhau của nó. Đối với điều này, chúng tôi đã chỉ định tất cả 8 đỉnh trong một danh sách và đặt tên cho danh sách đó là "verti". Khi chúng ta xác định các đỉnh, biến "edgez" sẽ lưu trữ cạnh được vẽ giữa các đỉnh đó

Chúng tôi bắt đầu với 0, vì đó là cách Python và các ngôn ngữ lập trình khác hiểu hoặc biểu thị các cạnh. Sau đó, chúng ta tạo một hàm Cube(). Bên trong nó, chúng ta phải gọi hàm glBegin(GL_LINES)

Nó sẽ thông báo cho OpenGL rằng chúng tôi hiện sẽ ném một số mã vào nó. Sau đó, GL_LINES sẽ hướng dẫn OpenGL cách mã sẽ được xử lý để biểu diễn đường. Điều đó có nghĩa là chúng ta có thể coi mã này là mã vẽ đường. Điều này sẽ thực hiện vòng lặp lồng nhau để tạo và kết nối các đỉnh với các cạnh

Bây giờ, chúng ta sẽ định nghĩa hàm main(). Ở đây, trước tiên chúng tôi khởi tạo pygame bằng phương thức init(). Sau đó, chúng ta phải đặt vùng hiển thị (ở đây, 900 x 700). Sau đó, chúng tôi sẽ sử dụng pygame. trưng bày. phương thức set_mode(). Các tham số được sử dụng bên trong thực sự là hằng số.
Chúng giúp xác định PyGame rằng chúng tôi đang tương tác với mã OpenGL của nó. DOUBLEBUF, viết tắt của bộ đệm đôi, xác định một loại bộ đệm trong đó có hai bộ đệm đang được áp dụng với tốc độ làm mới của màn hình. Sau đó, chúng ta có đường ống (". ") toán tử phân tách cả hai hằng số. gluPerspective(), như tên gợi ý, là một chức năng xác định phối cảnh.

glTranslatef() giúp nhân ma trận hiện tại với ma trận dịch. Bây giờ, chúng tôi sẽ sử dụng mô-đun pygame để thực hiện sự kiện cho đến khi chúng tôi thoát bằng cách sử dụng thoát(). Tiếp theo chúng ta có glRotatef(). Hàm glRotatef() sẽ nhân ma trận hiện tại để biến nó thành ma trận xoay và do đó hoạt ảnh xoay sẽ diễn ra. Nó chấp nhận góc, x, y và z làm tham số

Cuối cùng, chúng ta có glClear(), giống như bất kỳ chức năng xóa nào khác để xóa vùng đệm và độ sâu của màn hình. Ở đây chúng ta phải chỉ định các hằng số sẽ yêu cầu OpenGL xóa bộ đệm và độ sâu của màn hình. Sau đó, chúng tôi sẽ gọi pygame. trưng bày. flip() chức năng sẽ cập nhật màn hình của chúng tôi. Cuối cùng, chúng tôi sẽ sử dụng pygame. thời gian. wait() để hiển thị thời gian chờ ngắn và cuối cùng gọi hàm main() để chạy toàn bộ chương trình

Phần kết luận

Hy vọng, bạn đã hiểu cách chúng ta có thể làm việc với OpenGL từ chương trình Python. Bài viết này đã hướng dẫn bạn tạo hình cũng như chuyển đổi hoạt hình 2D và 3D để giúp bạn hiểu các chức năng khác nhau mà PyOpenGL hỗ trợ trong thư viện của nó

Python có tốt cho OpenGL không?

Cách tốt nhất để học OpenGL là gì?

Tại sao nên sử dụng OpenGL trong Python?

Các tài nguyên tốt nhất để tìm hiểu OpenGL là gì?