Blender pour le jeu vidéo

La scène doit être installée comme dans un rendu classique. Lorsque l'effet d'éclairage désiré est obtenu, le baking se réalise en ajoutant une carte UV dédiée et assignée à une nouvelle texture.

Ajoutons la texture dans son matériau (fenêtre nodes matériau) pour le baking.

Sélectionnons notre objet puis dans la fenêtre des nodes de son matériau, sélectionnons la texture qui doit être remplie.

Dans l'onglet Rendu, section Baking, enclenchons le bouton Bake. Il faut être patient, car le rendu n'est pas visible et peut prendre un certain temps. Une fois terminée, la texture prend les couleurs de l'éclairage complexe. Enregistrons-la pour ne pas la perdre.

Repassons en mode Game Engine et modifions le matériau dans la fenêtre node, en lui ajoutant un input matériau, ainsi qu'un node output.

Enfin, relions la texture du baking à l'entrée couleur de la texture. Le résultat est maintenant visible dans le BGE.

Il est également possible de baker des textures procédurales non supportées par le Game Engine.

Dans le node editor, une texture générée par association de différents patterns grâce aux nodes mais non supportée dans le Game Engine est transformée en image bitmap utilisée dans le processus de baking.

Un autre usage est de simplifier la géométrie d'un objet en faisantle baking des reliefs dans une normal map qui sera utilisée sur un modèle de moindre détail. La surface aura l'air d'être détaillée alors qu'elle ne comporte que peu de faces. Ceci est très utile pour les personnages par exemple.

Un hook est une fonction Python que nous devons écrire et dans laquelle nous mettrons du code OpenGL, soit directement grâce au module bgl de Blender qui exporte la plupart des fonctions, soit indirectement via notre API Python préférée pour générer du graphisme OpenGL.

Nous devons enregistrer cette fonction auprès de la scène courante :

• Fonctions à exécuter avant le rendu des objets.

scene.pre_draw.append(my_function)

• Fonctions à exécuter après le rendu des objets.

scene.post_draw.append(my_function)

Les attributs pre_draw et post_draw sont des listes pour permettre à différentes parties du code d'enregistrer leurs fonctions. Pour supprimer une fonction hook existante, il suffit d'utiliser la méthode remove : scene.post_draw.remove(my_function)

Une fois enregistrée auprès de la scène, la fonction sera appelée par le moteur graphique à chaque frame avec les modalités suivantes.

• Pas d'argument.
  La fonction est appelée sans argument. Cependant, comme elle est appelée dans le cadre de la scène où elle a été enregistrée, elle a accès à la scène de manière habituelle (via la fonction logic.getCurrentScene()) et si nécessaire à tous les objets qu'elle contient.
• Fonctions pre_draw : matrice chargée, frame buffer vide.
  Le contexte OpenGL est prêt pour des commandes d'affichage, le frame buffer est vide et les matrices OpenGL actives sont telles que les vertices que nous enverrons à OpenGL devront être en coordonnées world. Nous avons bien sûr la possibilité de charger de nouvelles matrices, mais nous devrons impérativement rétablir l'état OpenGL avant le return. Tout ce que nous mettrons dans le frame buffer sera combiné avec le rendu des objets.
• Fonctions post_draw: matrice indéterminée, frame buffer rempli.
  Les fonctions post_draw héritent d'un frame buffer contenant le rendu de tous les objets de la scène plus le résultat des éventuels filtres 2D. Elles ne peuvent compter que sur des valeurs particulières de matrices OpenGL, elles devront donc positionner les matrices selon leurs besoins sans nécessité de rétablir l'état OpenGL avant le return.

• En cas deviewport
  Les fonctions hook sont compatibles avec les viewports dans les limites suivantes :

  • Les fonctions pre_draw sont exécutées pour chaque viewport. Elles héritent du contexte OpenGL du viewport courant. Cela permet d'agir dans chaque viewport. Cependant, une fonction qui ne devrait écrire que dans un viewport devrait d'abord tester le viewport avec la fonction OpenGL appropriée (il n'existe aucun moyen de connaître le viewport courant avec l'API du BGE).
  • Les fonctions post_draw ne sont exécutées qu'une seule fois par frame à la fin du rendu de tous les viewports. Elles héritent de la totalité de la fenêtre OpenGL.

XXXVI-A-1. Exemple : dessiner un rectangle en OpenGL.▲

from bge import logic, render 
import bgl 
def init():
    scene = logic.getCurrentScene()
    scene.post_draw = [write] 
def write():
    """ Write on screen """
    scene = logic.getCurrentScene()
    width = render.getWindowWidth()
    height = render.getWindowHeight() 
    # OpenGL setup 
    bgl.glMatrixMode(bgl.GL_PROJECTION) 
    bgl.glLoadIdentity() 
    bgl.gluOrtho2D(0, width, 0, height) 
    bgl.glMatrixMode(bgl.GL_MODELVIEW) 
    bgl.glLoadIdentity() 
    # Draw a 2D rectangle to make the fonts stand out 
    bgl.glEnable(bgl.GL_BLEND)# Enable alpha blending 
    bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA) 
    view_buf = bgl.Buffer(bgl.GL_INT, 4) 
    bgl.glGetIntegerv(bgl.GL_VIEWPORT, view_buf) 
    view = view_buf 
    bgl.glMatrixMode(bgl.GL_PROJECTION) 
    bgl.glLoadIdentity() 
    bgl.gluOrtho2D(0, view[2], 0, view[3]) 
    bgl.glMatrixMode(bgl.GL_MODELVIEW) 
    bgl.glLoadIdentity() 
    bgl.glBegin(bgl.GL_QUADS) 
    bgl.glColor4f(.4, 0, 0, 0.4) 
    bgl.glVertex2f(5, (height/2)) 
    bgl.glVertex2f(width -5, (height/2)) 
    bgl.glVertex2f(width - 5, (height/2) + 21) 
    bgl.glVertex2f(5, int(height/2) + 21) 
    bgl.glEnd() 
def main(cont):
    own = cont.owner
    if not "init" in own:
        own["init"] = True
        init()