Vous avez toujours voulu créer votre propre interface utilisateur tout en développant des modules complémentaires Blender? Lors de la création d'une interface utilisateur, il est nécessaire d'afficher des images, etc. dans Blender, mais heureusement, l'API Blender expose une API pour accéder à OpenGL. Si vous utilisez cette API avec les événements de souris présentés dans les articles suivants, vous pouvez créer votre propre interface utilisateur sans suivre l'interface utilisateur spécifique à Blender.

[Blender] Comment gérer les événements de souris et de clavier dans les scripts Blender

Cependant, même si des API sont fournies, toutes les fonctions OpenGL ne sont pas fournies. Par conséquent, ce que vous pouvez faire est limité à la gamme d'API fournie par Blender, mais s'il s'agit d'un processus de dessin simple comme l'interface utilisateur supplémentaire, je pense que l'API fournie est suffisante.

Dans cet article, je vais vous montrer un exemple de dessin d'un rectangle dans View3D et vous montrer comment utiliser OpenGL de Blender.

Exemple de code

`opengl_on_blender.py`



import bpy
import bgl    #Nécessaire pour utiliser OpenGL depuis l'intérieur de Blender


bl_info = {
    "name": "Tutorial: OpenGL on Blender",
    "author": "Nutti",
    "version": (1, 0),
    "blender": (2, 74, 0),
    "location": "View3D > Tutorial: OpenGL on Blender",
    "description": "Tutorial: Use Blender's OpenGL API.",
    "warning": "",
    "support": "COMMUNITY",
    "wiki_url": "",
    "tracker_url": "",
    "category": "3D View"
}


class RectRenderer(bpy.types.Operator):
    """Dessinez un carré"""
    
    bl_idname = "view3d.rect_renderer"
    bl_label = "Rect renderer"

    __handle = None    #Fonction de dessin
    
    #Enregistrer la fonction de dessin de la zone "View3D"
    @staticmethod
    def handle_add():
        RectRenderer.__handle = bpy.types.SpaceView3D.draw_handler_add(
            RectRenderer.render_rect,
            (), 'WINDOW', 'POST_PIXEL')

    #Désenregistrer la fonction de dessin dans la zone "View3D"
    @staticmethod
    def handle_remove():
        if RectRenderer.__handle is not None:
            bpy.types.SpaceView3D.draw_handler_remove(
                RectRenderer.__handle, 'WINDOW')
            RectRenderer.__handle = None
    
    #Dessin du corps de la fonction dans la zone "View3D"
    @staticmethod
    def render_rect():
        #Créer une zone de dessin
        positions = [
            [10.0, 10.0],     #En bas à gauche
            [10.0, 600.0],    #en haut à gauche
            [600.0, 600.0],   #En haut à droite
            [600.0, 10.0]     #En bas à droite
            ]

        #Dessiner un carré avec OpenGL
        bgl.glEnable(bgl.GL_BLEND)    #Activer Alpha Blend
        bgl.glBegin(bgl.GL_QUADS)    #Commencez à dessiner un quadrilatère
        bgl.glColor4f(0.7, 0.5, 0.3, 0.6)    #Spécifiez la couleur du carré à dessiner
        for (v1, v2) in positions:
            bgl.glVertex2f(v1, v2)    #Enregistrement des sommets
        bgl.glEnd()    #Terminer le dessin du quadrilatère


#Traitement au moment de l'installation du script
def register():
    bpy.utils.register_module(__name__)
    RectRenderer.handle_add()


#Traitement lors de la désinstallation du script
def unregister():
    bpy.utils.unregister_module(__name__)
    RectRenderer.handle_remove()


if __name__ == "__main__":
    register()

Comment utiliser

Installez le plug-in en vous référant à la page Blender Wiki.
Confirmez que le carré est affiché dans View3D.

Explication de l'exemple de code

L'explication de base du script Blender est présentée dans l'article suivant, nous nous concentrerons donc ici sur l'explication des éléments nouvellement ajoutés. [\ Blender ] Comment créer un plug-in Blender

Importer le module bgl

Pour utiliser l'API OpenGL fournie par Blender, vous devez importer le module bgl```.

import bgl

Enregistrement de la fonction de dessin "View3D"

Lors de l'installation du script, appelez `` RectRenderer.handle_add () '' pour enregistrer la fonction de dessin. Cela permettra au rectangle d'être dessiné après l'installation du script.

#Traitement au moment de l'installation du script
def register():
    bpy.utils.register_module(__name__)
    RectRenderer.handle_add()

`RectRenderer.handle_add()Est implémenté comme une méthode statique.`



#### **`bpy.types.SpaceView3D.draw_handler_add()Est une fonction qui enregistre une fonction de dessin pour la zone "View3D".`**

Spécifiez ** corps de la fonction de dessin ** dans le premier argument et ** paramètres ** à transmettre à l'argument de la fonction de dessin spécifié dans le premier argument du deuxième argument. Enregistrez le ** handler **, qui est la valeur de retour de bpy.types.SpaceView3D.draw_handler_add () `` , dans la variable `__handle``` au cas où vous voudriez libérer la fonction de dessin enregistrée. Je vais.

    #Enregistrer la fonction de dessin de la zone "View3D"
    @staticmethod
    def handle_add():
        RectRenderer.__handle = bpy.types.SpaceView3D.draw_handler_add(
            RectRenderer.render_rect,
            (), 'WINDOW', 'POST_PIXEL')

Désenregistrer la fonction de dessin "View3D"

Lors de la désinstallation du script, appelez `` RectRenderer.handle_remove () '' pour désinscrire la fonction de dessin. Empêche le rectangle d'être dessiné après la désinstallation du script.

#Traitement lors de la désinstallation du script
def unregister():
    bpy.utils.unregister_module(__name__)
    RectRenderer.handle_remove()

`RectRenderer.handle_remove()Est implémenté comme une méthode statique.`



#### **`bpy.types.SpaceView3D.draw_handler_remove()Est une fonction qui annule la fonction de dessin enregistrée pour la zone "View3D".`**

Passez le ** handler **, qui est la valeur de retour de bpy.types.SpaceView3D.draw_handler_add () '', comme premier argument.

    #Désenregistrer la fonction de dessin dans la zone "View3D"
    @staticmethod
    def handle_remove():
        if RectRenderer.__handle is not None:
            bpy.types.SpaceView3D.draw_handler_remove(
                RectRenderer.__handle, 'WINDOW')
            RectRenderer.__handle = None

Corps de la fonction de dessin "View3D"

Le traitement du dessin est ajouté au corps de la fonction de dessin. Comme tous ceux qui ont utilisé OpenGL le sauront immédiatement, il est très similaire à l'utilisation d'OpenGL en langage C. Cependant, notez que bgl. est préfixé à la fonction car il utilise le module `` `` bgl. Il y a beaucoup d'informations sur la façon d'utiliser OpenGL en langage C sur le Web, donc je n'expliquerai pas l'utilisation spécifique d'OpenGL ici. Pour l'exemple montré cette fois, le contenu de traitement spécifique est décrit comme un commentaire dans le code source, veuillez donc le vérifier. L'API OpenGL publiée par Blender peut être confirmée à partir de l'URL suivante. http://www.blender.org/api/blender_python_api_2_60_4/bgl.html

    #Dessin du corps de la fonction dans la zone "View3D"
    @staticmethod
    def render_rect():
        #Créer une zone de dessin
        positions = [
            [10.0, 10.0],     #En bas à gauche
            [10.0, 600.0],    #en haut à gauche
            [600.0, 600.0],   #En haut à droite
            [600.0, 10.0]     #En bas à droite
            ]

        #Dessiner un carré avec OpenGL
        bgl.glEnable(bgl.GL_BLEND)    #Activer Alpha Blend
        bgl.glBegin(bgl.GL_QUADS)    #Commencez à dessiner un quadrilatère
        bgl.glColor4f(0.7, 0.5, 0.3, 0.6)    #Spécifiez la couleur du carré à dessiner
        for (v1, v2) in positions:
            bgl.glVertex2f(v1, v2)    #Enregistrement des sommets
        bgl.glEnd()    #Terminer le dessin du quadrilatère

[Blender] Utilisez OpenGL depuis l'intérieur du script