#CUBO CON PYTHON by INGOENIUS
#grazie a kino, S68, Manuel, Jody ,JSalvo

import Blender 
from Blender import NMesh 
from Blender.BGL import *
from Blender.Draw import *

# Parametri del CUBO
D_X = Create(1.0)
D_Y = Create(1.0)
D_Z = Create(1.0)

# Eventi
EVENT_NOEVENT = 1
EVENT_DRAW    = 2
EVENT_EXIT    = 3


######################################################
# disegno della GUI
######################################################
def draw():
     global D_X
     global D_Y
     global D_Z
     
     global EVENT_NOEVENT,EVENT_X,EVENT_Y,EVENT_Z,EVENT_DRAW,EVENT_EXIT

     ########## Titoli
     glClear(GL_COLOR_BUFFER_BIT)
     glRasterPos2d(8, 123)
     Text("1 CUBETTO?")# intestazione

     ######### Pulsanti GUI per i parametri
     glRasterPos2d(8, 100)
     Text("Parametri:")
     
     
     D_X		 = Slider("Dim X: ", EVENT_NOEVENT, 10, 35, 210, 18,
     #D_X é il valore da passare tramite lo slider alla def CUBO linea 74
                     D_X.val, 0.001, 20.0, 1, "Dimensioni in X");
 
     D_Y		 = Slider("Dim Y: ", EVENT_NOEVENT, 10, 55, 210, 18,
                     D_Y.val, 0.001, 20.0, 1, "Dimensioni in Y");
 
     D_Z		 = Slider("Dim Z: ", EVENT_NOEVENT, 10, 75, 210, 18,
                     D_Z.val, 0.001, 20.0, 1, "Dimensioni in Z");
 
                                             
     ######### Pulsanti Crea ed Esci
     Button("Crea",EVENT_DRAW , 10, 10, 80, 18)
     Button("Esci",EVENT_EXIT , 140, 10, 80, 18)
 
def event(evt, val):
     if (evt == QKEY and not val):
             Exit()

def bevent(evt):
     global D_X
     global D_Y
     global D_Z
     global EVENT_NOEVENT,EVENT_X,EVENT_Y,EVENT_Z,EVENT_DRAW,EVENT_EXIT

     ######### Gestisce gli eventi della GUI
     if (evt == EVENT_EXIT):
             Exit()
     elif (evt== EVENT_DRAW):
             CUBO(D_X.val, D_Y.val, D_Z.val)
             #D_X.val vuol dire il valore preso nello slider
             Blender.Redraw()

Register(draw, event, bevent)

#Definizione del cubo

def CUBO(X, Y, Z):
             
	me=NMesh.GetRaw() #crea la mesh vuota 


#creazione degli 8 vertici usando i valodi degli slider 
#e relativo append alla mesh creata prima 

	
	v=NMesh.Vert(0.0,0.0,0.0)#Vertice 0 
	me.verts.append(v) 
	v=NMesh.Vert(D_X.val,0.0,0.0) #Vertice 1 
	#prende il valore di D_X quindi D_X.val
	me.verts.append(v) 
	v=NMesh.Vert(D_X.val,D_Y.val,0.0) #Vertice 2
	me.verts.append(v) 
	v=NMesh.Vert(0.0,D_Y.val,0.0) #Vertice 3
	me.verts.append(v) 
	v=NMesh.Vert(0.0,D_Y.val,D_Z.val) #Vertice 4
	me.verts.append(v) 
	v=NMesh.Vert(0.0,0.0,D_Z.val) #Vertice 5
	me.verts.append(v) 
	v=NMesh.Vert(D_X.val,0.0,D_Z.val) #Vertice 6
	me.verts.append(v) 
	v=NMesh.Vert(D_X.val,D_Y.val,D_Z.val) #Vertice 7
	me.verts.append(v) 

# creazione delle facce ATT vanno selezionati i vertici in senso antiorario 
# att i vertici vanno da 0 a 7 e non da 1 a 8 

# Qui memorizzo gli indici dei vertici. Puoi vederla come una matrice, 
# oppure come una lista di liste (e' uguale)
 
	faccie = [ [0,1,2,3], [1,2,7,6], [3,2,7,4], [0,3,4,5], [0,1,6,5], [4,5,6,7] ] 

	for i in range(0, len(faccie)):
 
# range(0, len(faccie)) crea una lista chiamata "faccie" che contiene gli elementi 
# da 0 a len(faccie) 
# len(faccie) e' chiaramente la lunghezza di faccie, faccie contiene 6 liste di indici 
# qundi ha lunghezza 6. Quindi range(0, len(faccie)) = [0,1,2,3,4,5] (l'estremo 
# superiore del range e' escluso). Ora, l'istruzione "for", ripete le 
# istruzioni del suo corpo, facendo assumere ad "i", i valori della lista 
# [0,1,2,3,4,5] (in sostanza il for ripete le istruzioni presenti nel suo 
# corpo 6 volte, la prima facendo assumere ad "i" il valore 0, la seconda 
# il valore "1" e cosi' via). 
	
		f=NMesh.Face() 

# faccie[i], e' la lista i-esima presente in faccie. Questa volta, j assume i valori 
# della lista faccie[i]. L'istruzione presente nel suo corpo viene eseguita 
# len(faccie[i]) volte, cioe' 4 volte. 

		for j in faccie[i]: 
			f.v.append(me.verts[j]) 
		me.faces.append(f) 

#fine della creazione facce e creazione finale della mesh 
	NMesh.PutRaw(me,"Cube",1) 
	Blender.Redraw()