From BlenderWiki
0 %[edit] Script in Python
Blender ha una caratteristica molto potente ma spesso trascurata. Dispone di un interprete Python interno pienamente equipaggiato. Questo permette agli utenti di aggiungere funzionalità scrivendo script in Python. Python è un linguaggio di programmazione interpretato, interattivo e orientato agli oggetti. Comprende moduli, eccezioni, gestione dinamica dei tipi, tipi dinamici di alto livello e classi. Python combina una notevole potenza con una sintassi molto chiara. È stato espressamente progettato per essere usato come linguaggio di estensione per applicazioni che richiedono un'interfaccia programmabile, e per questo Blender ne fa uso.
Dei due modi di estendere Blender, l'altro usa plugin binari. Gli script Python sono più potenti, versatili e più facili da capire oltre che robusti. È generalmente preferibile usare gli script Python anziché scrivere un plugin.
Attualmente la programmazione Python ha avuto delle funzionalità limitate fino a Blender 2.25, l'ultimo rilascio della NaN. Quando Blender è diventato Open Source molti dei nuovi sviluppatori si sono radunati attorno alla Fondazione decidendo di lavorarci e, con la modifica alla UI (Interfaccia Utente), l'API di Python è probabilmente la sola parte di Blender che ha usufruito dello sviluppo maggiore. È stato riorganizzato tutto l'esistente e vi sono stati aggiunti molti moduli nuovi.
Tale evoluzione continua e ci si deve aspettare una migliore integrazione nelle prossime versioni di Blender.
Tra i vari tipi di finestre, Blender ha una Finestra Testo accessibile tramite il pulsante 
del Menù dei Tipi di Finestra o tramite SHIFT-F11.
La finestra Testo appena aperta è grigia e vuota, con una barra degli strumenti molto semplice (Text Toolbar.). Da sinistra a destra ci sono il pulsante standard di selezione del Tipo di Finestra ed il menù Finestra. Il pulsante per ingrandirla a tutto schermo, seguiti da un pulsante che mostra/nasconde i numeri di riga per il testo e il normale pulsante Menù.
Il pulsante menu (
) permette di selezionare quale buffer di testo visualizzare, oltre a permettere di creare un nuovo buffer o caricare un file di testo.
Se si sceglie di caricare un file la Finestra Testo diventa temporaneamente una Finestra per la Selezione di File, con le solite funzioni. Una volta che un buffer di testo è in una finestra testo, questa si comporta come un editor molto semplice. Scrivendo sulla tastiera si genera un testo nel buffer. Come al solito premendo LMB trascinando e rilasciando LMB si seleziona il testo. Sono disponibili i seguenti comandi da tastiera:
- ALT-C o CTRL-C - Copia il testo selezionato in un raccoglitore di testo;
- ALT-X o CTRL-X - Taglia il testo selezionato in un raccoglitore di testo;
- ALT-V o CTRL-V - Incolla il testo dal raccoglitore alla posizione del cursore nella Finestra di Testo;
- ALT-S - Salva il testo come un file di testo, appare una Finestra di Selezione File;
- ALT-O - Carica un testo, appare una Finestra di Selezione File;
- ALT-F - Fa comparire la toolbox per la Ricerca [Find];
- SHIFT-ALT-F o RMB - Fa comparire il menù File per la Finestra Testo;
- ALT-J - Fa comparire un Pulsante Numerico in cui specificare il numero di linea a cui far saltare il cursore;
- ALT-P - Esegue il testo come script Python;
- ALT-U - Undo (Annulla);
- ALT-R - Redo (Ripeti);
- CTRL-R - Riapre (ricarica) il buffer corrente;
- ALT-M - Converte il contenuto della finestra di testo in un testo 3D (massimo 100 caratteri);
Il raccoglitore di taglia/copia/incolla di Blender è separato dal raccoglitore [clipboard] di Window. Quindi normalmente non si può tagliare/copiare/incollare da/verso Blender. Per accedere alla clipboard di Windows si usa SHIFT-CTRL-C SHIFT-CTRL-V Per cancellare un buffer di testo semplicemente premere il pulsante 'X' vicino al nome del buffer, proprio come si fa per i materiali ecc.
La combinazione di tasti più importante è ALT-P che fa interpretare il contenuto del buffer dall'interprete Python incluso in Blender. La prossima sezione presenterà un esempio di script in Python. Prima di proseguire occorre notare che Blender è fornito solo del semplice interprete Python incorporato, e di alcuni moduli specifici di Blender, quelli descritti in Python Reference .
Altri usi della finestra Testo
La finestra testo è comoda anche quando si vuol condividere i propri file .blend con la comunità o con amici. Una finestra Testo può essere usata per scriverci un README (Leggimi) che spieghi il contenuto del file Blender. Molto più pratico che avere un'applicazione separata aperta. Ci si assicuri di averla visibile durante il salvataggio!
Se si condivide il file con la comunità e lo si vuol condividere con qualche licenza si può scrivere la licenza in una finestra testo.
|
Per accedere ai moduli standard di Python occorre un'installazione completa e funzionante di Python. La si può scaricare da python.org
[edit] Impostazione della variabile d'ambiente PYTHONPATH
Accertarsi di verificare su http://www.blender.org qual è la esatta versione di Python incorporata in Blender per evitare problemi di compatibilità. Blender deve anche sapere dove è stato completamente installato Python. Questo si ottiene definendo una variabile d'ambiente chiamata PYTHONPATH.
[edit] Impostazione di PYTHONPATH su Win95,98,Me
Dopo aver installato Python in, ad esempio, C:\PYTHON22 occorre aprire il file C:\AUTOEXEC.BAT con un editor di testo ed aggiungere una linea:
SET PYTHONPATH=C:\PYTHON22;C:\PYTHON22\DLLS;C:\PYTHON22\LIB;C:\PYTHON22\LIB\LIB-TK
e riavviare il sistema.
[edit] Impostazione di PYTHONPATH su WinNT,2000,XP
Dopo aver installato Python in, ad esempio, C:\PYTHON22 andare sull'icona "Risorse del computer" ["My Computer"] sul desktop, RMB e selezionate Proprietà. Selezionare il tab Avanzate e cliccare sul pulsante Variabili d'Ambiente. Sotto alla casella Variabili di sistema (la seconda casella), cliccare su Nuovo. Se non si è un amministratore si potrebbe non avere il permesso di farlo. In quel caso cliccare su Nuovo nella casella in alto. Ora, nella casella Nome variabile, inserire PYTHONPATH, nella casella Valore variabile inserire:
C:\PYTHON22;C:\PYTHON22\DLLS;C:\PYTHON22\LIB;C:\PYTHON22\LIB\LIB-TK
Cliccare ripetutamente su OK per uscire da tutte le finestre. Può essere necessario riavviare il sistema, dipende dal Sistema Operativo.
[edit] Impostazione di PYTHONPATH su Linux e altri UNIX
Normalmente Python dovrebbe essere già installato. Se no, occorre installarlo. Occorre scoprire dove si trova. È semplice, basta avviare una console di Python aprendo una shell e scrivendo python. Inserire i seguenti comandi:
>>> import sys >>> print sys.path
e annotare l'output, dovrebbe assomigliare a
['', '/usr/local/lib/python2.2', '/usr/local/lib/python2.2 /plat-linux2', '/usr/local/lib/python2.0/lib-tk', '/usr/local/lib/python2.0/lib-dynload', '/usr/local/lib/python2.0/site-packages']
Aggiungere questa al proprio file rc preferito come impostazione di variabile d'ambiente. Ad esempio, aggiungere nel proprio .bashrc la linea
export PYTHONPATH=/usr/local/lib/python2.2:/usr/local/lib/python2.2/plat-linux2:/usr/local/lib/python2.2/lib-tk:/usr/local/lib/python2.2/lib-dynload:/usr/local/lib/python2.0/site-packages
tutto su una sola riga. Aprire una nuova shell di login, oppure effettuare il logoff e di nuovo il login.
[edit] Un esempio di Python in funzione
Ora che abbiamo visto che Blender si può estendere con Python e che abbiamo le basi per maneggiare gli script e per eseguirli, e prima di arrovellarsi il cervello con la guida di riferimento sull'API Python contenuta nella prossima lezione, diamo un'occhiata a un veloce esempio funzionante.
Presenteremo un piccolo script per generare poligoni. Questo duplica in qualche modo l'opzione della toolbox SPACEAdd>>Mesh>>Circle, ma creerà poligoni 'pieni', non solo il contorno.
Per rendere lo script semplice ma completo conterrà un'Interfaccia Utente Grafica (GUI) interamente scritta con le API di Blender.
[edit] Intestazioni, importazione di moduli e variabili globali
Le prime 32 linee di codice sono riportate di seguito
Intestazione dello script
001 ###################################################### 002 # 003 # Demo Script for Blender 2.3 Guide 004 # 005 ###################################################S68 006 # Questo script genera poligoni. Esso è abbastanza 007 # inutile dal momento che potete creare poligoni con 008 # ADD->Mesh->Circle ma è un esempio di script carino 009 # e completo ed i poligoni sono 'pieni' 010 ###################################################### 011 012 ###################################################### 013 # Importing modules 014 ###################################################### 015 016 import Blender 017 from Blender import NMesh 018 from Blender.BGL import * 019 from Blender.Draw import * 020 021 import math 022 from math import * 023 024 # Polygon Parameters 025 T_NumberOfSides = Create(3) 026 T_Radius = Create(1.0) 027 028 # Events 029 EVENT_NOEVENT = 1 030 EVENT_DRAW = 2 031 EVENT_EXIT = 3 032
Dopo i necessari commenti con la descrizione di cosa fa lo script (linee 016-022) ci sono le importazioni dei moduli Python.
Blender è il modulo principale dell'API Python di Blender. NMesh è il modulo che fornisce l'accesso alle mesh di Blender, mentre BGL e Draw danno accesso rispettivamente alle costanti e funzioni di OpenGL e all'interfaccia a finestre di Blender. Il modulo math è il modulo matematico di Python, ma dato che sia il modulo 'math' che il modulo 'os' sono incorporati in Blender non è necessario una completa installazione di Python per questo!
I poligoni sono definiti dal numero di lati che hanno e dal loro raggio. Questi parametri hanno valori che devono essere definiti dall'utente tramite la GUI per questo le linee (025-026) creano due oggetti 'pulsante generico', con i loro valori iniziali di default.
Infine, gli oggetti della GUI lavorano con eventi e generano eventi. Gli identificatori di evento sono interi definiti dal programmatore. Normalmente è buona abitudine definire nomi facili da ricordare, come è stato fatto nelle linee (029-031).
[edit] Disegno della GUI
Il codice responsabile del disegno della GUI deve risiedere in una funzione draw draw (Disegno della GUI).
Disegno della GUI
033 ######################################################
034 # Disegno della GUI
035 ######################################################
036 def draw():
037 global T_NumberOfSides
038 global T_Radius
039 global EVENT_NOEVENT,EVENT_DRAW,EVENT_EXIT
040
041 ########## Titoli
042 glClear(GL_COLOR_BUFFER_BIT)
043 glRasterPos2d(8, 103)
044 Text("Demo Polygon Script")
045
046 ######### Pulsanti Parameters della GUI
047 glRasterPos2d(8, 83)
048 Text("Parameters:")
049 T_NumberOfSides = Number("No. of sides: ", EVENT_NOEVENT, 10, 55, 210, 18,
050 T_NumberOfSides.val, 3, 20, "Number of sides of out polygon");
051 T_Radius = Slider("Radius: ", EVENT_NOEVENT, 10, 35, 210, 18,
052 T_Radius.val, 0.001, 20.0, 1, "Radius of the polygon");
053
054 ######### Pulsanti Draw ed Exit
055 Button("Draw",EVENT_DRAW , 10, 10, 80, 18)
056 Button("Exit",EVENT_EXIT , 140, 10, 80, 18)
057
Le linee (037-039) semplicemente garantiscono l'accesso ai dati globali. La cosa veramente interessante inizia dalle linee (042-044). La finestra OpenGL è inizializzata e la posizione corrente è impostata a x=8, y=103. L'origine di riferimento è l'angolo in basso a sinistra della finestra di testi. Poi è stampato il titolo Demo Polygon Script.
Viene scritta un'ulteriore stringa (linee 047-048), poi sono creati i pulsanti di input per i parametri. Il primo (linee 049-050) è un Pulsante Numerico, esattamente uguale a quelli delle varie finestre pulsanti di Blender. Per il significato dei tutti i parametri vedere la guida di riferimento dell'API. Brevemente ci sono l'etichetta del pulsante, l'evento generato, la posizione (x, y) e le dimensioni (larghezza, altezza), il valore, i valori minimo e massimo permessi e una stringa di testo che appare come aiuto quando si passa col mouse sopra il pulsante.
Le linee (051-052) definiscono uno slider, con una sintassi molto simile. Le linee (055-056) infine creano un pulsante Draw (Disegna) che genererà il poligono e un pulsante Exit.
[edit] Gestione degli eventi
La GUI non sarà disegnata, e non funzionerà, finché non sarà scritto e registrato un opportuno gestore di eventi (Gestione degli eventi).
Gestione degli eventi
058 def event(evt, val): 059 if (evt == QKEY and not val): 060 Exit() 061 062 def bevent(evt): 063 global T_NumberOfSides 064 global T_Radius 065 global EVENT_NOEVENT,EVENT_DRAW,EVENT_EXIT 066 067 ######### Gestisce gli eventi della GUI 068 if (evt == EVENT_EXIT): 069 Exit() 070 elif (evt== EVENT_DRAW): 071 Polygon(T_NumberOfSides.val, T_Radius.val) 072 Blender.Redraw() 073 074 Register(draw, event, bevent) 075
Le linee (058-060) definiscono il gestore degli eventi da tastiera, in questo caso risponde al tasto Q con una semplice chiamata a Exit().
Più interessanti sono le linee (062-072), incaricate di gestire gli eventi della GUI. Ogni volta che si usa un pulsante della GUI questa funzione viene chiamata, con il numero di evento definito per il pulsante passato come parametro. Il nucleo di questa funzione è quindi una struttura "select" che esegue codice differente a seconda del numero dell'evento.
Alla fine viene chiamata la funzione Register. Questa effettivamente disegna la GUI ed avvia il ciclo di cattura degli eventi.
[edit] Gestione delle Mesh
Infine, Intestazione dello script mostra la funzione principale, quella che crea il poligono. È un editing di mesh abbastanza semplice, ma illustra molti punti importanti della struttura dati interna di Blender.
Intestazione dello script
076 ###################################################### 077 # Corpo principale 078 ###################################################### 079 def Polygon(NumberOfSides,Radius): 080 081 ######### Crea una nuova mesh 082 poly = NMesh.GetRaw() 083 084 ######### La popola con i vertici 085 for i in range(0,NumberOfSides): 086 phi = 3.141592653589 * 2 * i / NumberOfSides 087 x = Radius * cos(phi) 088 y = Radius * sin(phi) 089 z = 0 090 091 v = NMesh.Vert(x,y,z) 092 poly.verts.append(v) 093 094 ######### Aggiunge un nuovo vertice al centro 095 v = NMesh.Vert(0.,0.,0.) 096 poly.verts.append(v) 097 098 ######### Connette i vertici per formare le facce 099 for i in range(0,NumberOfSides): 100 f = NMesh.Face() 101 f.v.append(poly.verts[i]) 102 f.v.append(poly.verts[(i+1)%NumberOfSides]) 103 f.v.append(poly.verts[NumberOfSides]) 104 poly.faces.append(f) 105 106 ######### Crea un nuovo Oggetto con la nuova Mesh 107 polyObj = NMesh.PutRaw(poly) 108 109 Blender.Redraw()
La prima linea importante è la (082). Qui è creato un nuovo oggetto mesh, poly. L'oggetto mesh è costituito da una lista di vertici e una lista di facce, più alcune altre cose interessanti. Per i nostri scopi sono sufficienti la lista di vertici e quella delle facce.
Ovviamente la nuova mesh creata è vuota. Il primo ciclo (linee 085-092) calcola le posizioni x, y, z dei NumberOfSides vertici necessari per definire il poligono. Essendo una figura piatta z=0 per tutti.
La linea (091) chiama il metodo Vert di NMesh per creare un nuovo oggetto vertice di coordinate (x,y,z). Tale oggetto viene poi aggiunto (linea 096) nella lista verts della Mesh poly.
Infine (linee 095-096) un ultimo vertice viene aggiunto nel centro.
Le linee (099-104) ora connettono questi vertici per creare le facce. Non è necessario creare prima tutti i vertici e poi le facce. Si può tranquillamente creare una nuova faccia non appena tutti i suoi vertici sono disponibili.
La linea (100) crea un nuovo oggetto faccia. Un oggetto faccia ha la sua lista di vertici v (fino a 4) che lo definiscono. Le linee (101-103) aggiungono tre vertici alla lista inizialmente vuota f.v I vertici sono due vertici consecutivi del poligono e il vertice centrale. Questi vertici devono essere presi dalla lista verts della Mesh. Infine la linea (104) aggiunge la faccia appena creata alla lista faces della nostra mesh poly.
[edit] Conclusioni
Se si crea un file polygon.py contenente il codice sopra descritto, lo si carica in una finestra testo di Blender come abbiamo imparato nella sezione precedente e si preme ALT-P in quella finestra per eseguirlo, si vedrà che lo script scompare e la finestra diventa grigia. Nell'angolo in basso a sinistra sarà disegnata la GUI (La GUI del nostro esempio.).
Selezionando, per esempio, 5 vertici e un raggio di 0.5, e premendo il pulsante Draw apparirà un pentagono nel piano xy della finestra 3D (Il risultato del nostro script di esempio.).
[edit] Python Reference
La completa Interfaccia di programmazione per applicazioni [API, Application Programmer Interface] in Python di Blender ha una documentazione di riferimento che è essa stessa un libro. Per ragioni di spazio non è stata inclusa qui. E' qui :)
[edit] Scripts in Python
Ci sono più di un centinaio di scripts per Blender su internet. Come i plugins, gli scripts sono molto dinamici, cambiano interfaccia, funzionalità e indirizzo web molto rapidamente, per cui per una lista aggiornata e per dei link attivi fate riferimento a uno dei siti principali su Blender, www.blender.org o www.elysiun.com.
[edit] Subpages
![[]](/skins/blender/open.png)
