Conversion de l'ondulation de l'eau Pygame 2D en pyOpenGL

Sep 04 2020

J'ai un truc de simulation d'eau pygame 2D que j'ai suivi un tutoriel pour faire. J'ai également trouvé la réponse à cette question pour résoudre les problèmes avec le tutoriel: la physique de l'eau Pygame ne fonctionne pas comme prévu

J'ai depuis essayé de convertir ce programme en utilisant pyopengl pour rendre les choses. Cependant, j'ai eu du mal à: A: dessiner le polygone d'eau B: texturer le polygone d'eau avec une texture en mosaïque

Voici ma (plutôt médiocre) tentative de conversion de ce code en pyopengl.

import pygame, random
import math as m

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

pygame.init()

WINDOW_SIZE = (854, 480)
 
screen = pygame.display.set_mode(WINDOW_SIZE,0,32,DOUBLEBUF|OPENGL) # initiate the window

clock = pygame.time.Clock()


def draw_polygon(polygon_points):
    glBegin(GL_POLYGON);
    for i in polygon_points:
        glVertex3fv(i)
    #glEnd()
    
class surface_water_particle():
    
    def __init__(self, x,y):
        self.x_pos = x
        self.y_pos = y
        self.target_y = y
        self.velocity = 0
        self.k = 0.04  
        self.d = 0.08
        self.time = 1

    def update(self):
        x =  self.y_pos - self.target_y
        a = -(self.k * x + self.d * self.velocity)

        if self.y_pos > self.target_y:
            self.y_pos -= 0.1
        if self.y_pos < self.target_y:
            self.y_pos += 0.1
        self.velocity = round(self.velocity)

        self.y_pos += self.velocity
        self.velocity += a

        self.time += 1

class water_tile():
    def __init__(self, x_start, x_end, y_start, y_end, segment_length):
        self.springs = []
        self.x_start = x_start
        self.y_start = y_start
        self.x_end = x_end
        self.y_end = y_end - 10
        for i in range(abs(x_end - x_start) // segment_length):
            self.springs.append(surface_water_particle(i * segment_length + x_start, y_end))

    def update(self, spread):
        passes = 4  # more passes = more splash spreading
        for i in range(len(self.springs)):
            self.springs[i].update() 

        leftDeltas = [0] * len(self.springs)
        rightDeltas = [0] * len(self.springs)
        for p in range(passes):  
            for i in range(0, len(self.springs)):
                if i > 0:  
                    leftDeltas[i] = spread * (self.springs[i].y_pos - self.springs[i - 1].y_pos)
                    self.springs[i - 1].velocity += leftDeltas[i]
                if i < len(self.springs):
                    rightDeltas[i] = spread * (self.springs[i].y_pos - self.springs[(i + 1)%len(self.springs)].y_pos)
                    self.springs[(i + 1)%len(self.springs)].velocity += rightDeltas[i]

            for i in range(0, len(self.springs)):
                if round (leftDeltas[i],12) == 0 or round (rightDeltas[i],12) == 0:
                    self.springs[i - 1].y_pos = self.y_end+10
                if i > 0:
                    self.springs[i - 1].y_pos += leftDeltas[i]  # you were updating velocity here!
                if i < len(self.springs):
                    self.springs[(i + 1)%len(self.springs)].y_pos += rightDeltas[i]
                
    def splash(self, index, speed):
        if index >= 0 and index < len(self.springs):
            self.springs[index].velocity = speed 

    def draw(self):
        water_surface = pygame.Surface((abs(self.x_end-self.x_start), abs(self.y_start - self.y_end)), depth=8).convert_alpha()
        polygon_points = []
        polygon_points.append((self.x_start, self.y_start,0))
        for spring in range(len(self.springs)):
            polygon_points.append((self.springs[spring].x_pos, self.springs[spring].y_pos,0))
        polygon_points.append((self.springs[len(self.springs) - 1].x_pos, self.y_start,0))

        draw_polygon(polygon_points)
        
        return water_surface

class water_object:
    def __init__(self, x_start, x_end, y_start, y_end, segment_length, x_pos, y_pos):
        self.water = water_tile(x_start,x_end,y_start,y_end,segment_length)
        self.image = self.water.draw()
        self.rect = self.image.get_rect()
        self.rect.x = x_pos
        self.rect.y = y_pos

    def update(self):
        self.water.update(0.1)
        self.image = self.water.draw()
        
water_list = [water_object(0,276+16,64,0,16,0,20)]

while True:
    screen.fill((0,0,0))
    for water in water_list:
        gluPerspective(45, (WINDOW_SIZE[0]/WINDOW_SIZE[1]), 0.1, 50.0)
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
        water.update()
        #screen.blit(water.image, (water.rect.x,water.rect.y))
        #water_test.x_start = water_test.x_start + 1
        
        #if random.randint(0,8) == 1:
            #water_test.splash(random.randint(0, len(water_test.springs) - 1),2)
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
            if event.type == MOUSEBUTTONDOWN:
                print (len(water.water.springs))
                water.water.splash(random.randint(0, len(water.water.springs) - 1),50)

    pygame.display.update()

    clock.tick(60)

Cependant, malgré ma tentative, je n'ai rien pu afficher à l'écran du tout. Comment puis-je résoudre ce problème / comment puis-je atteindre les 2 choses avec lesquelles j'ai eu du mal?

Réponses

3 Rabbid76 Sep 04 2020 at 22:37

Vous ne pouvez pas dessiner une primitive OpenGL vers un fichier pygame.Surface. Quoi qu'il en soit, il n'est pas nécessaire de le faire. Pour de meilleures performances, dessinez directement sur le framebuffer par défaut (fenêtre).

Puisque vous voulez tracer une ligne, vous devez utiliser un Line primitivetype. GL_POLYGONdessinerait un polygone convexe déposé. Utilisez le type primitif GL_LINE_STRIP:

def draw_polygon(polygon_points):
    glBegin(GL_LINE_STRIP)
    for pt in polygon_points:
        glVertex2f(*pt)
    glEnd()

Avant de tracer la ligne, serrez la couleur actuelle en glColor:

glColor3f(0, 0, 1)
draw_polygon(polygon_points)

Les coordonnées des sommets du mensonge sont spécifiées dans l'espace fenêtre. Par conséquent, vous devez configurer une projection orthographique plutôt qu'une projection en perspective . Spécifiez la matrice actuelle par [ glMatrixMode] et définissez la matrice de projection par glOrtho. Étant donné que les opérations de matrice ne définissent pas de matrice, mais multiplient la matrice actuelle par la matrice spécifiée, je recommande de charger la matrice d'identité avant ( glLoadIdentity):