Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Membre expérimenté
    [Tutoriel pyopengl] La programmation 3D mode d'emploi ?
    Salut les python du forum 3D,

    Suite a de longues semaines d'étude d'un ouvrage sur OpenGL, j'ai acquis pas mal de connaissances sur le sujet.

    Et comme ce forum est désert j'ai décidé de transmettre ce que j'ai put tirer comme connaissance du livre étudié, en écrivant un tutoriel Python qui est plutôt un HOW-TO de la programmation 3D avec OpenGL, afin de repeupler ce forum.

    J'ai beaucoup entendus que la programmation 3D avec OpenGL été compliquer et ajouter au faîte que python est un langage lent en terme de vitesse d'exécution par rapport au langage compilé comme C ou C++ par exemple. Python n'est pas idéal pour la programmation 3D qui demande pas mal de code a exécuter, souvent dans une boucle.

    Le tutoriel est la preuve que l'on peut faire de la programmation 3D avec OpenGL et il est simpliste c.a.d, que les grands théorèmes mathématiques permettant les calcules de coordonnées par matrices ou génération de polyèdres sont a peine effleurer.

    Le tutoriel est construit afin de vous donnez les bases nécessaires a la génération de polyèdres régulier (tétraèdre, cube, octaèdre, dodecaèdre, icosaèdre, etc...) et les outils pour les animés, c.a.d les codes des formules de calcul des coordonnées dans un repère en 3 Dimension (matriciel ou pas).

    J'ai écrit ce tutoriel dans le but de donner a mes amis python la possibilité de créer des programmes 3D, malgré qu'un complément est nécessaire pour user de toute la puissance de OpenGL.

    Pour finir j'ai écrit un module d'aide a la programmation 3D qui reprend pas mal de codes issue du tutoriel, donc si vous (étudiez) lisez le tutoriel vous n'aurai aucun mal a vous servir du module.

    Je serai ravis d'animer la flamme de la programmation 3D en vous et espère que vous irez plus loin en téléchargeant d'autres tutoriel, voir d'acheter un livre sur OpenGL.
    Il n'en existe pas pour l'implémentation python de OpenGL mais dans d'autres langages si et pas beaucoup en français.

    A ce propos une petite anecdote:

    J'ai a un moment commencer le livre, dont les codes sont écrit en C++, puis j'ai lâchement abandonner au bout de quelques dizaines de pages,
    puis quelques temps plus tard, après avoir appris les rouages du langage C, j'ai repris le livre... regarder le tutoriel et vous devinerez ce qu'est devenus la deuxième tentative de lecture du livre.
    La morale est que, en tant que python, apprendre le C est un avantage (La syntaxe du C est proche du C++), mais c'est difficile également.
    Vous trouverez le fichier du tutoriel nommer Introduction a pyopengl dans l'index de mon site sous forme de fichier *.zip contenant des pages *.html composant le tutoriel.

    PS: Il y a eu une correction d'orthographe et de grammaire mais la correctrice étant une littéraire a déchiqueter mes phrases en changeant le sens de celle-ci involontairement, alors j'ai du rectifier en gardant une partie du document non corriger qui est donc enclin a contenir des fautes orthographique et grammaticale, désolé.
    Pour faire tes armes:
    Use du présent pour construire ton futur sinon use de ce que tu as appris auparavant.
    Et sois toujours bien armé avant de te lancer.
    Le hasard ne sourit qu'aux gens préparés...
    Site: Website programmation international (www.open-source-projects.net)
    Site: Website imagerie 3D (www.3dreaming-imaging.net)
    Testez aux moins pendant une semaine l'éditeur avec terminaux intégrées it-edit Vous l'adopterai sûrement !
    FUN is HARD WORK !!!

  2. #2
    Membre éprouvé
    Pas de. zip, il y a un problème de permission pour ma part.

  3. #3
    Membre expérimenté
    Comment ça pas de zip ?
    Tu parle du tutoriel ?

    Explications: le lien n'est pas un lien direct ver le fichier *.zip du tutoriel mais vers une page index de mon site.

    Une page index est une page qui affiche un listing de fichiers sur un serveur web, il suffit de cliquer sur le nom du fichier pour le télécharger (j'ai essayer ca marche très bien).
    C'est comme ta page ou tu host tes fichiers *.zip de tes jeux donné comme source sur pygame.org (Pas la DropBox).

    Le fichier s'appelle: Introduction_a_pyopengl.zip

    Mais si tu parle du programme cube-hunter (le jeu de shoot-them-all ou l'on doit dégommer des cubes que tu m'a permis de présenter sur pygame .org) je n'ai pas encore eu le temps de le tester sous Windows, donc j'ai pas encore fait de fichier *.zip.

    Je suis vraiment désolé du retard pris par la procédure, je le ferai dès que je pourrai.

    Puisque l'on en parle et que c'est le sujet:
    cube-hunter est un petit jeu de shoot-them-all fait avec pyopengl et peu être lu comme exemple de jeu en 3D implémenter avec OpenGL.
    Le jeu n'est que compatible avec Linux et est distribuer sous forme de fichier *.deb.

    Je vous souhaite bonne lecture et attend patiemment vos réactions et vos critiques.
    Pour faire tes armes:
    Use du présent pour construire ton futur sinon use de ce que tu as appris auparavant.
    Et sois toujours bien armé avant de te lancer.
    Le hasard ne sourit qu'aux gens préparés...
    Site: Website programmation international (www.open-source-projects.net)
    Site: Website imagerie 3D (www.3dreaming-imaging.net)
    Testez aux moins pendant une semaine l'éditeur avec terminaux intégrées it-edit Vous l'adopterai sûrement !
    FUN is HARD WORK !!!

  4. #4
    Expert éminent
    ça a l'air très interessant tout ça. Merci beaucoup
    "La connaissance appartient à tout le monde" (Film Antitrust)

    Tout le nécessaire pour Python:
    *News/Accueil *Cours/tutoriels *FAQ
    *Forums *Outils dédiés *Mon espace personnel avec mes Articles, Cours et Tutoriels

  5. #5
    Membre éprouvé
    ok ça marche sur PC, c'est sur tablette que ça coince.

  6. #6
    Responsable 2D/3D/Jeux

    Bonjour,

    J'y ai vu des choses étranges dans votre mode d'emploi. Notamment, on parle de matrices de couleurs dans l'introduction, notion que je ne connais absolument pas. Pouvez-vous l'expliquer ?
    Ce code (seconde partie) :
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    def resizeGL(width,height) :
      fov_angle=60.0                   # Angle of eye view.
      z_near=2.0                       # Distance from the user from the screen.
      z_far=1000.0                     # Distance in depth.
     
      glMatrixMode(GL_PROJECTION)      # Enable Projection matrix configuration.
      glLoadIdentity()
      gluPerspective( fov_angle,
                      float(width)/float(height),
                      z_near,
                      z_far )
     
      glLoadIdentity()
      glOrtho(-30.0,                   # Left coordinates value.   ( x_min )
               30.0,                   # Right coordinates value.  ( x_max )
              -30.0,                   # Bottom coordinates value. ( y_min )
               30.0,                   # Top coordinates value.    ( y_max )
              -30.0,                   # Near coordinates value.   ( z_min )
               30.0)                   # Far coordinates value.    ( z_max )
     
      glMatrixMode(GL_MODELVIEW)       # Enable modelview matrix as current matrix.

    Le glLoadIdentity annule la transformation effectuée par gluPerspective.

    Finalement, vous utilisez OpenGL 1. En soit, ce n'est pas faux, cela fonctionne encore, mais clairement, c'est déprécié. Nous sommes passé à ce que l'on appelle OpenGL Moderne. Minimum, la version 3.0 d'OpenGL. La moitié des fonctions que vous présentez ne sont plus à utiliser.
    De plus, c'est loin d'être un cours de pyOpenGL, mais un cours de 3D. La moitié contient les notions pour faire des formes géométriques et des formules sur la géométrie. Mais bon, cela ne suffit pas spécialement pour faire de la vraie 3D en informatique (surtout que l'on n'utilise pas ou très peu le centre d'une forme 3D).
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  7. #7
    Membre expérimenté
    Merci pour votre intervention LittleWhite

    certaines choses reste a clarifier pour moi:
    La moitié des fonctions que vous présentez ne sont plus à utiliser.
    Parlez vous des fonction internes de (py)OpenGL présentées ou des fonctions implémentées par mes soins dans le tutoriel ?

    Il faut savoir que je n'ai lu qu'un seule ouvrage sur OpenGL pour l'instant, je suis donc un débutant malgré le petit jeu que j'ai pu développer avec les mêmes outils que présentés dans le tutoriel.

    Et les théorèmes mathématiques sur lesquelles reposent les techniques de programmation avec OpenGL ne sont pas forcément a la portée de quelqu'un de mon niveau scolaire, mais une lecture assidus m'a permis de les comprendre en parties, complètement ou pas du tout.

    on parle de matrices de couleurs dans l'introduction, notion que je ne connais absolument pas. Pouvez-vous l'expliquer ?
    Je pensais a la matrice internes de représentation de couleurs pour implémenter les variations de couleurs pour généré des effets de couleurs comme celui-ci:

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
     
    from math import cos,sin,radians
     
    from OpenGL.GL import *
    from OpenGL.GLU import *
     
    class Vertex(object) :
      def __init__(self,x=False,y=False,z=False,vertexv=False) :
        ''' Object from type Vertex representing an vertice '''
        if vertexv :
          # The coordinates component are given in an vector.
          self.wx=vertexv[0]
          self.wy=vertexv[1]
          self.wz=vertexv[2]
        else :
          # The coordinates component are given individually. 
          self.wx=x
          self.wy=y
          self.wz=z
     
      def get_vertex(self) :
        return (self.wx,self.wy,self.wz)    
     
    def generate_polygon_on_xy(edges,radius,center,offset=0) :
      ''' Return an polygon on surface xy:
        
                y 
                | 
            ____|____x
                |
                | 
              
          from edges sides, from radius radius, with offset offset. '''
     
      if not isinstance(center,Vertex) :
        raise TypeError(Vertex)
     
      polygon=[]        # Polygon vertice container.
      scale=360./edges  # Computing of the angle separating 2 points from the polygon.
      i=0
      while i < edges :
     
        polygon.append(Vertex((radius*cos(radians((scale*i)+offset)))+center.wx,(radius*sin(radians((scale*i)+offset)))+center.wy,center.wz))
     
        i += 1
     
      return polygon
     
    try :
      import pygame
      from pygame.locals import *
    except :
      print "pygame required !\nPlease install the pygame module and relaunch the script."
      quit()
     
    from time import sleep  
     
     
     
    def resizeGL(width,height) :
      fov_angle=60.0                   # Angle of eye view.
      z_near=2.0                       # Distance from the user from the screen.
      z_far=1000.0                     # Distance in depth.
     
      glMatrixMode(GL_PROJECTION)      # Enable Projection matrix configuration.  
      #glLoadIdentity()          
      gluPerspective( fov_angle, 
                      float(width)/float(height),
                      z_near, 
                      z_far )
     
      glLoadIdentity()
      glOrtho( -30.0,                   # Left coordinates value.   ( x_min ) 
                30.0,                   # Right coordinates value.  ( x_max ) 
               -30.0,                   # Bottom coordinates value. ( y_min )
                30.0,                   # Top coordinates value.    ( y_max )  
               -30.0,                   # Near coordinates value.   ( z_min ) 
                30.0)                   # Far coordinates value.    ( z_max )  
     
      glMatrixMode(GL_MODELVIEW)       # Enable modelview matrix as current matrix.   
     
    def initGL(width,height) :
     
      glClearColor(0.0, 0.0, 0.0, 0.0) # Define clear color [0.0-1.0]
     
      glEnable(GL_DEPTH_TEST)          # Enable GL depth functions. 
     
      #######################
      glShadeModel(GL_SMOOTH)          # This configuration setting permit the color gradient effect. contrary to the GL_FLAT argument. 
      #######################
     
      resizeGL(width,height)           # Call to the resize function.
     
     
     
    def mainloop() :
      ''' Display function '''
      global red,green,blue,color_high
     
      red=0.0
      green=0.0
      blue=0.0
     
      color_high='gray'
     
      pygame.key.set_repeat(100, 10)
     
      colors=[(255,255,0),(255,0,0),(255,0,0),(255,255,0),(0,255,0),(0,255,0)]
     
      glColor3ubv((255,255,255)) 
      hexagon=generate_polygon_on_xy(6,20.0,Vertex(0.0,0.0,0.0)) 
     
      while True :
        glClearColor(red,green,blue,0.0)
     
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)  
     
        i=0
        glBegin(GL_POLYGON)
        for v in hexagon :
          glColor3ubv(colors[i])
          glVertex3fv(v.get_vertex())
          i += 1
        glEnd()
     
        for event in pygame.event.get() :
          ''' So we can catch user-interaction events in the mainloop. ''' 
     
     
          if event.type == QUIT      :         # The user close the window. 
            quit()
     
          elif event.type == KEYDOWN :         # The user press a keyboard key. 
            # event.unicode 
            # event.key 
            # event.mod
     
            pass
     
        pygame.display.flip()    
        sleep(0.0125)  
     
    def main() :
      global screen,width,height
      width=800.0
      height=600.0
     
      pygame.init()                                                         # We initialise the pygame module. 
     
      screen=pygame.display.set_mode((int(width),int(height)),              # We set the window width and height
                                      HWSURFACE | OPENGL | DOUBLEBUF,       # We set flags.
                                      24)                                   # Indicator colors are coded on 24 bits.
     
     
      initGL(width,height)                                                  # Call to initialise function.
     
      mainloop()                                                            # We call our display function: mainloop. 
     
    if __name__ == "__main__" :
     
      main()


    mais je ne me rappelle plus très bien...

    Mais vous pouvez regarder le programme suivant qui utilise un système de matrice de couleurs fait maison pour appliquer des effets de couleurs sur des images: PyImaging.

    Merci pour votre commentaire, c'est bien que finalement ça intéresse quand même quelqu'un.
    Pour faire tes armes:
    Use du présent pour construire ton futur sinon use de ce que tu as appris auparavant.
    Et sois toujours bien armé avant de te lancer.
    Le hasard ne sourit qu'aux gens préparés...
    Site: Website programmation international (www.open-source-projects.net)
    Site: Website imagerie 3D (www.3dreaming-imaging.net)
    Testez aux moins pendant une semaine l'éditeur avec terminaux intégrées it-edit Vous l'adopterai sûrement !
    FUN is HARD WORK !!!

  8. #8
    Responsable 2D/3D/Jeux

    Votre "matrice de couleurs" semble simplement être une palette de couleur. Chose qui n'est pas liée à la 3D.
    Code python :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    glMatrixMode(GL_PROJECTION)      # Enable Projection matrix configuration.  
      #glLoadIdentity()          
      gluPerspective( fov_angle, 
                      float(width)/float(height),
                      z_near, 
                      z_far )
     
      glLoadIdentity()
      glOrtho( -30.0,                   # Left coordinates value.   ( x_min ) 
                30.0,                   # Right coordinates value.  ( x_max ) 
               -30.0,                   # Bottom coordinates value. ( y_min )
                30.0,                   # Top coordinates value.    ( y_max )  
               -30.0,                   # Near coordinates value.   ( z_min ) 
                30.0)                   # Far coordinates value.    ( z_max )  
     
      glMatrixMode(GL_MODELVIEW)       # Enable modelview matrix as current matrix.

    Comme je le disais avant, ce code est toujours aussi faux. La moitié devient inutile, car le glLoadIdentity remet à zéro la matrice générée par gluPerspective().

    Parlez vous des fonction internes de (py)OpenGL présentées ou des fonctions implémentées par mes soins dans le tutoriel ?
    Je parle bien des fonctions OpenGL, qui viennent de la version 1, comme : glVertex, glColor, ... et qui sont obsolètes.
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  9. #9
    Membre expérimenté
    Vous avez raison.
    Suite a une courte vérification cela est exacte si l'on en croit ce document sur OpenGL 3.2 mais si l'on regarde la documentation de pyopengl 3.1.0, glVertex(..) existe toujours et il n'y a pas d'alternative pour spécifier un vertex unique.

    De toute façon python n'est pas l'idéal pour faire de l'OpenGL, je le reconnaît, malgré qu'une implémentation existe.

    Si vous regardez les timestamps du forum 3D de python vous remarquerez qu'il est pratiquement désert.
    Pour faire tes armes:
    Use du présent pour construire ton futur sinon use de ce que tu as appris auparavant.
    Et sois toujours bien armé avant de te lancer.
    Le hasard ne sourit qu'aux gens préparés...
    Site: Website programmation international (www.open-source-projects.net)
    Site: Website imagerie 3D (www.3dreaming-imaging.net)
    Testez aux moins pendant une semaine l'éditeur avec terminaux intégrées it-edit Vous l'adopterai sûrement !
    FUN is HARD WORK !!!

  10. #10
    Responsable 2D/3D/Jeux

    Pour remplacer les anciens appels glVertex3*, tout est expliqué dans ce tutoriel : http://raptor.developpez.com/tutorial/opengl/vbo/ et pyopengl le supporte (vu qu'ils recouvrent toutes les versions d'OpenGL).
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

###raw>template_hook.ano_emploi###