package puzzle.puzzleClasses;

import java.awt.Color;
import java.awt.Frame;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.util.Random;

import jv.anim.PsAnimation;
import jv.anim.PsTimeEvent;
import jv.anim.PsTimeListenerIf;
import jv.geom.PgElementSet;
import jv.geom.PgTexture;
import jv.number.PuDouble;
import jv.object.PsConfig;
import jv.object.PsDebug;
import jv.objectGui.PsImage;
import jv.project.PjProject;
import jv.project.PvCameraEvent;
import jv.project.PvCameraIf;
import jv.project.PvCameraListenerIf;
import jv.project.PvDisplayIf;
import jv.project.PvPickEvent;
import jv.project.PvPickListenerIf;
import jv.project.PvViewerIf;
import jv.vecmath.PdVector;
import jv.vecmath.PuVectorGeom;

/**
 * 
 * @author agoncalves
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */

public class Puzzle3D extends PjProject implements PvPickListenerIf ,PvCameraListenerIf,PsTimeListenerIf, Runnable{
	private static final long serialVersionUID = 1L;
	protected 	double 			Pi				= Math.PI;
	/**Margem de erro.*/
	protected	double 			eps	= 0.0001;
	/**Cor do applet.*/
	protected	Color			corFundo;

	/*As janelas de visualização*/
		/**A janela que aparece visível, da vista esquerda.*/
		protected	PvDisplayIf		m_dispDef;
		/**A janela que aparece visível, da vista direita.*/
		protected	PvDisplayIf		m_dispDefVD;
	/*............................................................*/
		
	/*Para o plano:*/
		/**As faces do objecto "plano".*/
		protected	PgElementSet[]	facesPlano;
		protected	Color 			corPlano;
		/**Se mostra o plano.*/
		protected	boolean			mostraPlano;
		/**Se mostra as faces do plano.*/
		protected	boolean			mostraFacesPlano;
		/**Se mostra as arestas do plano.*/
		protected	boolean			mostraArestasPlano;
	/*......................................................*/
	
	/*Para o cilindro:*/
		/**As faces do cilindro.*/
		protected	PgElementSet[]	facesCili;
		/**Ponto central na base do cilindro.*/
		protected	PdVector		ptoCilindroB;
		/**Ponto central no topo do cilindro.*/
		protected	PdVector		ptoCilindroT;
		/**Raio do cilindro.*/
		protected	double			raioCilindro;	
		/**Nº de linhas na horizontal do cilindro.*/
		protected	int 			numXLinesCili;
		/**Cor das faces do cilindro.*/
		protected	Color 			corCilindro;
		/**Se mostra o cilindro.*/
		protected	boolean			mostraCili;
		/**Nº de linhas na horizontal do cilindro.*/
		protected	int 			numYLinesCili;
		/**Se mostra as faces do cilindro.*/
		protected	boolean			mostraFacesCili;
		/**Se mostra as arestas.*/
		protected	boolean			mostraArestasCili;
		/**Cor das arestas das partes do cilindro que não estão seleccionadas.*/
		static	Color				corArestas;
		/**Grossura das arestas que não estão seleccionadas.*/
		static	double				sizeArestas;
		/**Cor das arestas das partes do cilindro que estão seleccionadas.*/
		protected	Color			corBordo;
		/**Grossura das arestas que estão seleccionadas.*/
		protected	double			sizeBordo;
		/**A cor da selecção.*/
		protected	Color			corSele;
		/**Grossura da selecção.*/
		protected	double			sizeSele;
		/**Grossura da linha que aparece às vezes nas faces da garrafa de Klein e da tira de Moebius*/
		static	double 			sizeLinhaDiv;
	/*.................................................*/
	
	/*Para o toro:*/
		/**As faces do toro, ie, as peças do puzzle.*/
		protected	PgElementSet[]	facesToro;
		/**Ponto central do toro.*/
		protected	double			distCentroToro;
		/**Raio do toro.*/
		protected	double			raioMenorToro;	
		/**Nº de linhas na horizontal do toro.*/
		protected	int 			numXLinesToro;
		/**Nº de linhas na horizontal do toro.*/
		protected	int 			numYLinesToro;
		/**Cor das faces do toro.*/
		protected	Color 			corToro;
		/**Se mostra o toro.*/
		protected	boolean			mostraToro;
		/**Se mostra as faces do toro.*/
		protected	boolean			mostraFacesToro;
		/**Se mostra as arestas do toro.*/
		protected	boolean			mostraArestasToro;
	/*.................................................*/
	
	/*Para o tira de Moebius:*/
		/**As faces da tira de Moebius.*/
		protected	PgElementSet[]	facesTiraM;
		/**Comprimento da tira de Moebius.*/
		protected	double			comprimentoTiraM;
		/**Largura da tira de Moebius.*/
		protected	double			larguraTiraM;	
		/**Nº de linhas na horizontal da tira de Moebius.*/
		protected	int 			numXLinesTiraM;
		/**Nº de linhas na horizontal da tira de Moebius.*/
		protected	int 			numYLinesTiraM;
		/**Cor das faces da tira de Moebius.*/
		protected	Color 			corTiraM;
		/**Se mostra a tira de Moebius.*/
		protected	boolean			mostraTiraM;
		/**Se mostra as faces da tira de Moebius.*/
		protected	boolean			mostraFacesTiraM;
		/**Se mostra as arestas da tira de Moebius.*/
		protected	boolean			mostraArestasTiraM;
	/*.................................................*/
	
	
	/*Para a garrafa de Klein:*/
		/**As faces da garrafa de Klein.*/
		protected	PgElementSet[]	facesGarrafaK;
		/**Linha divisória na face da garrafa de klein ou na tira de MOebius que dá para virar para os dois lados.*/
		protected	PgElementSet	linha;
		/**Raio maior da garrafa de Klein.*/
		protected	double			rMaiorGarrafaK;
		/**Raio menor da garrafa de Klein.*/
		protected	double			rMenorGarrafaK;
		/**Nº de linhas na horizontal da garrafa de Klein.*/
		protected	int 			numXLinesGarrafaK;
		/**Nº de linhas na horizontal da garrafa de Klein.*/
		protected	int 			numYLinesGarrafaK;
		/**Cor das faces da garrafa de Klein.*/
		protected	Color 			corGarrafaK;
		/**Se mostra a garrafa de Klein.*/
		protected	boolean			mostraGarrafaK;
		/**Se mostra as faces da garrafa de Klein.*/
		protected	boolean			mostraFacesGarrafaK;
		/**Se mostra as arestas da garrafa de Klein.*/
		protected	boolean			mostraArestasGarrafaK;
	/*.................................................*/
	
	/*Para o nº de linhas e de colunas:*/
		/**Valor do nº de colunas, modifica em comprimento (XLines).*/
		protected	static int 			valorM;
		/**Ao mudar o valorM, conserva o valor anterior dele até que todas as peças tenham tenham sido calculadas com o novo valor.*/
		protected	int[] 			valorMAntigo;
		/**Valor do nº de linhas, modifica em largura (YLines).*/
		protected	static int 			valorN;
		/**Ao mudar o valorN, conserva o valor anterior dele até que todas as peças tenham tenham sido calculadas com o novo valor.*/
		protected	int[] 			valorNAntigo;
	/*.......................................*/
	
	/**Pares ordenados que indicam as cores as posições das cores.*/
	static		int[][]				distCores;
	/**Estado das placas quanto às reflexões*/
	protected	boolean[][]			Flip	;
	/**Indica as posições das peças do puzzle após terem sido baralhadas.*/
	protected	Random 				aleatorio;
	/**Se o baralhar é par ou ímpar.*/
	protected	int 				paridade		;
	/**Cria.*/
	protected	boolean 			cria;
	/**Prim*/
	protected	boolean 			prim	;
	/**Posições das placas contíguas à peça que tem o buraco.*/
	protected	int[][]				indPlacasContiguas;
	/**Valor da transparência pra cada placa.*/
	protected	double[][]			transp;
	/**Transparência mínima, para as placas que naquele momento do jogo não podem ser movidas.*/
	static		double				transpMin	= 0.;
	/**Transparência máxima, para as placas que naquele momento do jogo podem ser movidas.*/
	protected	double				transpMax	= 0.2;
	
	/**Nome da figura que está seleccionada.*/
	static		String				nome;
	
	/*Para o objecto que é sensível à acção do rato:*/
		/**Objecto sensível ao pick do rato.*/
		protected	PgElementSet	objPick;
		/**Valor que multiplico ao valorM para ter mais definição no objPick.*/
		protected	int				multM;
		/**Valor que multiplico ao valorM para ter mais definição no objPick.*/
		protected	int				multN;
	/*......................................................*/
	
		
	/*Para as imagens:*/
		/**array das imagens que compõem as placas*/
		protected	BufferedImage[] BImg ;	
		/**As imagens que vão estar em cada peça.*/
		protected	PsImage []		m_image;
	/*...................................*/
	
	/*Para a animação que obtém a melhor posição:*/
		/**A animação da câmera, que consiste na mudança direcção e do "interest" da camera.*/
		protected	PsAnimation 	anim;
		/**O valor de deformação: valor que orienta a animação.*/
		protected	PuDouble		m_a;
		/**Número de passos da animação, isto é nº de posições que a câmera passa desde a sua posição inicial até à posição final.*/
		protected	final double 	nPassos	= 30;
		
		/*Para a das deformações:*/
		/**O valor de deformação das transformações: valor que orienta a animação.*/
		static	PuDouble			m_aDef;
		/**Número de passos da animação das transformações.*/
		protected	final double 	nPassosDef	= 25;
		
		/**Valor acrescentado ao tempo da animação para que tenha a distância final e o Interest final.*/
		protected	int 			dif = 10;	
	/*.....................................................*/
	
	/*Para que haja a rotação da câmera de forma a que a sua direcção permita ver a peça do puzzle vazia:*/
		/**Ponto de vista da câmera.*/
		protected	PdVector intAntigo;
		/**Novo ponto de vista da câmera.*/
		protected	PdVector intActual;
		/**Direcção da câmera.*/
		protected	PdVector dirAntiga;
		/**A nova direcção da câmera.*/
		protected	PdVector dirActual;
		/**Interest ideal para a camêra.*/
		protected	PdVector 		intActualPos = new PdVector(0,0,0);
		/**Interest da camêra antes de ser actualizado.*/
		static		PdVector 		intAntes;
		/**Interest da camêra antes de ser actualizado.*/
		static		PdVector 		intAntesPos;
		protected	double 			distActualPos ;
		protected	double 			distAntes ;
		protected	double 			distActual;
	/*..................................................*/
	
	/**Informa quando já há informação sobre as imagens, após o Puzzle ter sido corrido.*/
	protected	boolean inicio	= false;
	
	/**O conjunto das partes da superfície em qualquer um dos seus estados.*/
	protected	static PgElementSet[] ciliDefs;
	/**O vector normal a cada uma das partes da superfície.*/
	protected	static PdVector[]		normalCiliDefs;
	/**O ângulo entre o vector dado pela posição da camêra e o vector normal à parte da superfície correspondente à posição vazia.*/
	protected	double 			ang;
	/**O "cross" entre o vector dado pela posição da camêra e o vector normal à parte da superfície correspondente à posição vazia.*/
	protected	PdVector 		c;
	/**Nº de linhas para calcular a superfície.*/
	protected	final int numXLinesDef	= 12;
	/**Nº de linhas para calcular a superfície.*/
	protected	final int numYLinesDef	= 12;
	
	static 		boolean update	= false;
		
	public Puzzle3D(){
		super("O puzzle.");
		
		anim = new PsAnimation();// Criaçao da animação (which sends timer events)
		anim.setName("Inversão");	
		anim.addTimeListener(this);
		m_a 		= new PuDouble("Deformação:", this);
		m_aDef 		= new PuDouble("Deformação das transformações.", this);
		
		linha	= new PgElementSet(3);
		objPick			= new PgElementSet(3);
		
		if (getClass() == Puzzle3D.class){
			init();
		}
	}
	

	public void init() {
		//System.out.println("Inicio!!!!");
		update	= false;
		
		anim.setTimeInterval(0, nPassos+dif,1,1);
		anim.setRepeat(0);//A animação faz LOOP (LOOP = 1), outros: para ONE_WAY = 0 ou para BACK_FORTH = 2.
		anim.setSleepInterval(150);anim.update(anim);
		m_a.setDefBounds(0.,nPassos, 1, 1);
		m_a.setDefValue(0.);
		m_a.init();
		m_aDef.setDefBounds(0.,nPassosDef, 1, 1);
		m_aDef.setDefValue(1.);
		m_aDef.init();
		
		
		corFundo			= Metodos.corRGB(196,177,128);
		corArestas			= new Color(1.f,1.f,1.f);
		sizeArestas			= 1.;
		corBordo			= corArestas;
		sizeBordo			= sizeArestas;
		corSele				= Color.YELLOW;
		sizeSele			= 3.;
		sizeLinhaDiv		= 1.5;
		
		multM				= 2; multN				= 2;
		
		
		valorM		= 4; valorN		= 4;
		valorMAntigo	= new int[5]; valorNAntigo	= new int[5];
		for(int i=0;i<5;i++){valorMAntigo[i] = valorM; valorNAntigo[i] = valorN;}
		
		aleatorio	= new Random();
		paridade	= valorM*valorN*4;
		cria		= true;
		prim		= false;
		
		int cont	= 1;
		distCores	= new int[valorM*valorN][2];
		distCores[0][0]	= valorM-1; distCores[0][1]	= valorN-1;
		for(int i=0; i<valorM; i++){
			for(int j=0; j<valorN; j++){
				if(i!=valorM-1||j!=valorN-1){
					distCores[cont][0]=i;	distCores[cont][1]=j;	cont++;
				}
			}		
		}
		Flip = FlipI(valorM,valorN);		
		nome	= "rectângulo"; cor();
			
		mostraPlano			= true;
		mostraCili			= false;
		mostraToro			= false;
		mostraTiraM			= false;
		mostraGarrafaK		= false;
		
		objectoPick();
		plano();	cilindro();		toro(); 	tiraMoebius();	garrafaKlein();
		
		ciliDefs	= new PgElementSet[valorM*valorN];
		normalCiliDefs	= new PdVector[valorM*valorN];
		for(int i=0;i<valorN*valorM;i++){ ciliDefs[i]	= new PgElementSet(3);	}
		defInicial();
	}
	
	public void start() {
		dispDef().addGeometry(objPick); 	dispDefVD().addGeometry(objPick);
		for(int i=0;i<valorM*valorN;i++){	dispDef().addGeometry(ciliDefs[i]); dispDefVD().addGeometry(ciliDefs[i]);	}
		dispDefVD().addGeometry(linha); 	dispDef().addGeometry(linha);
		
		Thread thread = new Thread(this, "JavaView: loading texture images");
		thread.start();
				
		super.start();
	}
	
	/**Acrescenta à janela dada os objectos pretendidos.*/
	public void simFacesDisp(PvDisplayIf disp,PgElementSet[] faces,int numXLines,int numYLines){
		for(int i=0;i<numXLines*numYLines;i++){
			disp.addGeometry(faces[i]);
		}
	}
	
	/**Remove à janela dada os objectos pretendidos.*/
	public void naoFacesDisp(PvDisplayIf disp,PgElementSet[] faces,int numXLines,int numYLines){
		for(int i=0;i<numXLines*numYLines;i++){
			disp.removeGeometry(faces[i]);
		}
	}
	
		
	/*Métodos para animar a câmera:*/
		/**Método reponsável pela animação/deformação*/
		public void animar(){
			if (super.hasAnimation()) {
				//PsAnimation anim = super.getAnimation();
				if(AppletPuzzle.cbEnrolar[AppletPuzzle.menuS].isSelected()){
					if(m_aDef.getValue()==1){anim.setTime(0);m_aDef.setValue(0);}
					else {anim.setTime(Math.floor(m_aDef.getValue()*nPassosDef));}
					AppletPuzzle.camera(); intAntes = m_dispDef.getCamera().getInterest(); distAntes = m_dispDef.getCamera().getDist();
					AppletPuzzle.puzzle[0].repaint();AppletPuzzle.puzzle[1].repaint();mudancaCor();tudoRun();anim.start();
				}else if(AppletPuzzle.animar[AppletPuzzle.menuS].isSelected()||AppletPuzzle.animar[1].isSelected()){
					anim.setTime(anim.getMinTime()); intAntes = m_dispDef.getCamera().getInterest(); distAntes = m_dispDef.getCamera().getDist();
					anim.start();	
				}
			}
		}
		
		
		public void cam(){
			dirAntiga	= Metodos.multiNumVect(-1,Metodos.difVect(m_dispDef.getCamera().getInterest(),m_dispDef.getCamera().getPosition()));
			cameraAbMudaDirDef(dirAntiga);
			dirActual = Metodos.multiNumVect(1,dirActual);
			ang	= PdVector.angle(dirActual,Metodos.multiNumVect(1,dirAntiga))*Pi/180;
			c	= Metodos.multiNumVect(1,Metodos.cross(dirActual,Metodos.multiNumVect(1,dirAntiga)));
			if(Metodos.iguais(c,new PdVector(0,0,0),eps)){
				c	= Metodos.vectOrtogonal(dirActual,1);
			}
			intAntes = m_dispDef.getCamera().getInterest();
		}
		
		/**Animação para mudar a posição da camêra, de forma a melhorar a posição vazia.*/
		public void animacao(PdVector intAntigo,PdVector intActual,PdVector dirAntiga,PdVector dirActual,double time){
			PdVector dir	= Metodos.rotacaoVect(Metodos.multiNumVect(1,dirAntiga),c,time*(ang)/nPassos);
			PdVector ortV	= Metodos.multiVectNum(1,dir);
			cameraAbMudaDirDef(ortV);
		}
		
		/**Animação para mudar a interest e a distância da camêra, de forma a melhorar a posição de toda a superfície após ter sido colada.*/
		public void animacaoInt(PdVector intActual,PdVector intAntigo,double distActual,double distAntigo,double nPass,double time){
			double tempo = ((time-nPass)/dif);
			double dist = distAntigo+tempo*(distActual-distAntigo);
			PdVector intAct = Metodos.somaVect(intAntigo,Metodos.multiNumVect(tempo,Metodos.difVect(intActual,intAntigo)));
			cameraAbMudaIntDef(intAct,dist);
		}
		
		/**Método que diz à animação o que fazer.*/
		public boolean setTime(PsTimeEvent timeEvent) {
			double time = timeEvent.getTime();
			
			if(AppletPuzzle.cbEnrolar[AppletPuzzle.menuS].isSelected()){
				boolean enr = true;
				if(time==nPassosDef){
					m_aDef.setValue(1);
					m_aDef.update(m_aDef);
					enr = true;
				}else if(time<nPassosDef){
					m_aDef.setValue(time/nPassosDef);
					m_aDef.update(m_aDef);
				}else if(time==nPassosDef+dif){
					for(int k=0;k<2;k++){AppletPuzzle.cbEnrolar[k].setSelected(false);AppletPuzzle.menuOpcoes[k].setPopupMenuVisible(false); AppletPuzzle.colagem[k].setPopupMenuVisible(false); AppletPuzzle.cbEnrolar[k].setText(Legendas.enrolarLegenda); AppletPuzzle.cbEnrolar[k].setToolTipText(Legendas.enrolarFuncao);}
					AppletPuzzle.enabled(true,false);animacaoInt(new PdVector(0,0,0),intAntes,distActual,distAntes,nPassosDef,time);
					anim.stop(); enr = false; AppletPuzzle.cameraProp();
				}else {
					animacaoInt(new PdVector(0,0,0),intAntes,distActual,distAntes,nPassosDef,time); enr = false;
				}
				if(enr){
					if(AppletPuzzle.Moeb[AppletPuzzle.menuS].isSelected()){
						def();	run(); objectoPick();
					}else if(AppletPuzzle.Cil[AppletPuzzle.menuS].isSelected()){
						def();	run(); objectoPick();
					}else if(AppletPuzzle.Tor[AppletPuzzle.menuS].isSelected()){
						def();	run(); objectoPick();
					}else if(AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected()){
						def();  run(); objectoPick();
					}
					if(m_aDef.getValue()==1.||m_aDef.getValue()==.5+1/nPassosDef||m_aDef.getValue()==0.){
						AppletPuzzle.execPuzzle();
					}
				}
				
				
			}else if(AppletPuzzle.animar[AppletPuzzle.menuS].isSelected()){
				if(time<=nPassos){
					if(!Metodos.vectIguais(dirAntiga,dirActual,0.1)){
						animacao(intAntigo,intActual,dirAntiga,dirActual,time);
					}else {
						time=nPassos;
					}
				}else {
					if(!Metodos.vectIguais(intAntes,intActualPos,0.1)||!(Math.abs(distAntes-distActual)<.05)){
						animacaoInt(intActualPos,intAntes,distActualPos,distAntes,nPassos,time);
					}else {
						for(int h=0;h<AppletPuzzle.e;h++){AppletPuzzle.animar[h].setSelected(false);}
						AppletPuzzle.enabled(true,true);
						time=nPassos+dif;
					}
				}
				if(time==nPassos){
					m_a.setValue(0);
					m_a.update(m_a);
				}else if(time<nPassos){
					m_a.setValue(time);
					m_a.update(m_a);
				}else if(time==nPassos+dif){
					for(int h=0;h<AppletPuzzle.e;h++){AppletPuzzle.animar[h].setSelected(false);}
					AppletPuzzle.enabled(true,true);
					anim.stop();
				}
			}		
			return super.update(this);// Update info panel of this project
		}
		
		/*Os métodos chamados pela animação:*/
		/**Método que actualiza a direcção e o "interest" da câmera da colagem.*/
		public void cameraDef(PdVector interest,PdVector viewDir,double dist,double roll){
			m_dispDef.getCamera().setViewDir(viewDir);
			m_dispDef.getCamera().setDist(dist);
			m_dispDef.getCamera().setInterest(interest);
			m_dispDef.getCamera().setRoll(roll);
			m_dispDef.getCamera().update(m_dispDef.getCamera());
			m_dispDef.update(m_dispDef.getCamera());
			arranjarCamera();
		}
		
		
		/**Método que só actualiza a posição da câmera.*/
		public void cameraAbMudaDirDef(PdVector viewDir){
			m_dispDef.getCamera().setPosition(Metodos.multiNumVect(1,Metodos.somaVect(viewDir,m_dispDef.getCamera().getInterest())));
			m_dispDef.getCamera().update(m_dispDef.getCamera());
		}
		
		/**Método que só actualiza o Interest da câmera.*/
		public void cameraAbMudaIntDef(PdVector inter,double dist){
			m_dispDef.getCamera().setInterest(inter);
			m_dispDef.getCamera().setDist(dist);
			m_dispDef.getCamera().update(m_dispDef.getCamera());
		}
	/*........................................................................................*/
	
	
	/**Método que chama as imagens e que atribuí a cada peça uma imagem.*/
	public void run() {
		if(inicio){
		if(AppletPuzzle.inicio){						
			m_image	= new PsImage[valorM*valorN];				
			for(int i=1;i<Dados.M*Dados.N;i++){
				m_image[i] = new PsImage((Image)BImg[i],"imgs");
			}
			int oposto = -1;
			int buraco = -1; int opostoT = -1;
			if(AppletPuzzle.Cil[AppletPuzzle.menuS].isSelected()){
				int[][]	cores	= new int[1][2];
				cores[0][0]	= distCores[0][0];
				cores[0][1]	= (valorN-1)-distCores[0][1];
				buraco	= Metodos.parOrdInd(cores[0],valorM,valorN);
				
				if(m_aDef.getValue()<1){
					if((distCores[0][0]>0&&distCores[0][0]<valorM-1)||(distCores[0][1]>0&&distCores[0][1]<valorN-1)){
						oposto = -1;
					}else {
						int[]	coresOp	= {(valorM-1)-cores[0][0],cores[0][1]};
						oposto =  Metodos.parOrdInd(coresOp,valorM,valorN);
					}
				}
			}else if(AppletPuzzle.Tor[AppletPuzzle.menuS].isSelected()){
				if(m_aDef.getValue()<=0.5){
					int[]	coresOp	= {(valorM-1)-distCores[0][0],distCores[0][1]};
					oposto =  Metodos.parOrdInd(coresOp,valorM,valorN);
					int[]	coresOp2	= {distCores[0][0],(valorN-1)-distCores[0][1]};
					opostoT =  Metodos.parOrdInd(coresOp2,valorM,valorN);
					if((distCores[0][0]>0&&distCores[0][0]<valorM-1)||(distCores[0][1]>0&&distCores[0][1]<valorN-1)){
						oposto = -1;opostoT = -1;
					}else if((distCores[0][1]>0&&distCores[0][1]<valorN-1)){
						opostoT = -1;
					}
				}else if(m_aDef.getValue()<1){
					oposto = -1;
					if((distCores[0][1]>0&&distCores[0][1]<valorN-1)){	opostoT = -1; }
					else {
						int[]	coresOp2	= {distCores[0][0],(valorN-1)-distCores[0][1]};
						opostoT =  Metodos.parOrdInd(coresOp2,valorM,valorN);
					}
				}
			}else if(AppletPuzzle.Moeb[AppletPuzzle.menuS].isSelected()){
				int[][]	cores	= new int[1][2];
				cores[0][0]	= distCores[0][0];
				cores[0][1]	= (valorN-1)-distCores[0][1];
				
				buraco	= Metodos.parOrdInd(cores[0],valorM,valorN);
				
				if(m_aDef.getValue()<1){
					int[]	coresOp	= new int[2];
					coresOp[0]	= (valorM-1)-cores[0][0];
					coresOp[1]	= cores[0][1];
					oposto = Metodos.parOrdInd(coresOp,valorM,valorN);
					if((cores[0][0]>0&&cores[0][0]<valorM-1)&&(cores[0][1]>0&&cores[0][1]<valorN-1)){
						oposto = -1;
					}
				}
				
			}else if(AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected()){
				if(m_aDef.getValue()<=0.5){
					int[]	coresOp	= {(valorM-1)-distCores[0][0],(valorN-1)-distCores[0][1]};
					oposto =  Metodos.parOrdInd(coresOp,valorM,valorN);
					int[]	coresOp2	= {distCores[0][0],(valorN-1)-distCores[0][1]};
					opostoT =  Metodos.parOrdInd(coresOp2,valorM,valorN);
					if((distCores[0][0]>0&&distCores[0][0]<valorM-1)&&(distCores[0][1]>0&&distCores[0][1]<valorN-1)){
						oposto = -1;opostoT = -1;
					}else if((distCores[0][1]>0&&distCores[0][1]<valorN-1)){
						opostoT = -1;
					}
				}else if(m_aDef.getValue()<1){
					oposto = -1;
					if((distCores[0][0]>0&&distCores[0][0]<valorM-1)||(distCores[0][1]>0&&distCores[0][1]<valorN-1)){
						opostoT = -1;
					}else {
						int[]	coresOp	= {(valorM-1)-distCores[0][0],distCores[0][1]};
						opostoT =  Metodos.parOrdInd(coresOp,valorM,valorN);
					}					
				}
			}
			for(int i=1;i<Dados.M*Dados.N;i++){
				PgTexture texture = new PgTexture();
				texture.setImage(m_image[i].getImage());
				textura(Metodos.parOrdInd(distCores[i],valorM,valorN),texture,oposto,opostoT);
			}
			if(AppletPuzzle.Cil[AppletPuzzle.menuS].isSelected()){
				facesCili[buraco].showElements(false);
				facesCili[buraco].update(facesCili[buraco]);
				
				if(m_aDef.getValue()<1&&oposto!=-1){
					ciliDefs[oposto].setTransparency(transpMin); ciliDefs[oposto].setGlobalBndColor(corArestas);ciliDefs[oposto].setGlobalBndSize(sizeArestas);
				}
				ciliDefs[buraco].showElements(false); 
				
				
			}else if(AppletPuzzle.Moeb[AppletPuzzle.menuS].isSelected()){
				ciliDefs[buraco].showElements(false); 
				
			}
			for(int i=0;i<valorM*valorN;i++){ ciliDefs[i].update(ciliDefs[i]);	}
		}
		}
		inicio	= true;
	}
	
	/**Método de apoio ao run(), que atribuí a cada peça uma imagem.*/
	public void textura(int i,PgTexture texture,int oposto,int opostoT){
		if(mostraPlano){
			ciliDefs[i].makeQuadrElementTexture(2, 2); ciliDefs[i].setTexture(texture);
			ciliDefs[i].showElementTexture(true);	ciliDefs[i].update(ciliDefs[i]);
		}else if(mostraCili){
			double q	= Math.floor(i/valorN);
			double r	= i%valorN;
			int nInd	= (int)(valorN*q+((valorN-1)-r));
			int ind	= Metodos.parOrdInd(distCores[0],valorM,valorN);
			ciliDefs[nInd].makeQuadrElementTexture(numXLinesDef,numYLinesDef); ciliDefs[nInd].setTexture(texture);
			ciliDefs[nInd].showElementTexture(true);	
			if(AppletPuzzle.luzes[0].isSelected()){
				if(facesCili[nInd].getTransparency()==transpMax){
					facesCili[nInd].setGlobalBndColor(corSele);facesCili[nInd].setGlobalBndSize(sizeSele);
					if(nInd!=oposto||m_aDef.getValue()==1){
						ciliDefs[nInd].setTransparency(transpMax);ciliDefs[nInd].setGlobalBndColor(corSele);ciliDefs[nInd].setGlobalBndSize(sizeSele);		
					}	
				}
			}
			if(ind==nInd){facesCili[nInd].showElements(true); ciliDefs[nInd].showElements(true);}
			facesCili[nInd].update(facesCili[nInd]); 
		}else if(mostraToro){
			ciliDefs[i].makeQuadrElementTexture(numXLinesDef,numYLinesDef); ciliDefs[i].setTexture(texture);
			ciliDefs[i].showElementTexture(true);
			if(AppletPuzzle.luzes[0].isSelected()){
				if(facesToro[i].getTransparency()==transpMax){
					if((i!=oposto&&i!=opostoT)||m_aDef.getValue()==1){
						ciliDefs[i].setTransparency(transpMax);ciliDefs[i].setGlobalBndColor(corSele);ciliDefs[i].setGlobalBndSize(sizeSele);		
					}	
				}
			}
		}else if(mostraTiraM){
			double q	= Math.floor(i/valorN);
			double r	= i%valorN;
			int nInd	= (int)(valorN*q+((valorN-1)-r));
			int ind	= Metodos.parOrdInd(distCores[0],valorM,valorN);
			if(AppletPuzzle.luzes[0].isSelected()){
				if(facesTiraM[i].getTransparency()==transpMax){
					if(i!=oposto||m_aDef.getValue()==1){
						ciliDefs[nInd].setTransparency(transpMax);ciliDefs[nInd].setGlobalBndColor(corSele);ciliDefs[nInd].setGlobalBndSize(sizeSele);		
					}	
				}
			}
			ciliDefs[nInd].makeQuadrElementTexture(numXLinesDef,numYLinesDef); ciliDefs[nInd].setTexture(texture);
			ciliDefs[nInd].showElementTexture(true);
			if(ind==nInd){ciliDefs[nInd].showElements(true);}
		}else if(mostraGarrafaK){
			facesGarrafaK[i].makeQuadrElementTexture(numXLinesGarrafaK, numYLinesGarrafaK); facesGarrafaK[i].setTexture(texture);
			facesGarrafaK[i].showElementTexture(true);	facesGarrafaK[i].update(facesGarrafaK[i]);
			
			ciliDefs[i].makeQuadrElementTexture(numXLinesDef,numYLinesDef); ciliDefs[i].setTexture(texture);
			ciliDefs[i].showElementTexture(true);
			if(AppletPuzzle.luzes[0].isSelected()){
				if(facesGarrafaK[i].getGlobalBndSize()==sizeSele){
					if((i!=oposto&&i!=opostoT)||m_aDef.getValue()==1){
						ciliDefs[i].setTransparency(transpMax);ciliDefs[i].setGlobalBndColor(corSele);ciliDefs[i].setGlobalBndSize(sizeSele);		
					}	
				}
			}
		}
	}
	
	/**Calcular as cores das peças.*/
	public void cor(){
		int ind	= 0;
		transp	= new double[valorM][valorN];
		String n = nome;
		if(m_aDef.getValue()<1){
			n = "rectângulo";
			if(inicio)
			if((AppletPuzzle.Tor[AppletPuzzle.menuS].isSelected()||AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected())&&m_aDef.getValue()>0.5){
				n = "cilindro";
			}
		}
		
		indPlacasContiguas	= Contig(n,distCores[0]);
		for(int i=0;i<valorM;i++){
			for(int j=0;j<valorN;j++){
				transp[distCores[0][0]][distCores[0][1]]	= transpMin;
				if(ind!=0){
					for(int k=0;k<4;k++){
						if(indPlacasContiguas[k][0]==distCores[ind][0]&&indPlacasContiguas[k][1]==distCores[ind][1]){
							transp[distCores[ind][0]][distCores[ind][1]]	= transpMax;
							k = 4;
						}else {
							transp[distCores[ind][0]][distCores[ind][1]]	= transpMin;
						}
					}
				}
				ind++;
			}
		}
	}
	
	/**Calcular as cores das peças.*/
	public void corA(){
		int ind	= 0;
		transp	= new double[valorM][valorN];
		String n = nome;
		if(m_aDef.getValue()<1){
			n = "rectângulo";
			if(inicio)
			if((AppletPuzzle.Tor[AppletPuzzle.menuS].isSelected()||AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected())&&m_aDef.getValue()>0.5){
				n = "cilindro";
			}
		}
		
		indPlacasContiguas	= Contig(n,distCores[0]);
		for(int i=0;i<valorM;i++){
			for(int j=0;j<valorN;j++){
				transp[distCores[0][0]][distCores[0][1]]	= transpMin;
				if(ind!=0){
					for(int k=0;k<4;k++){
						if(indPlacasContiguas[k][0]==distCores[ind][0]&&indPlacasContiguas[k][1]==distCores[ind][1]){
							transp[distCores[ind][0]][distCores[ind][1]]	= transpMax; k = 4;
						}else {
							transp[distCores[ind][0]][distCores[ind][1]]	= transpMin;
						}
					}
				}
				ind++;
			}
		}
	}
	
	/**Renovar as cores das peças após ter sido mudada uma peça.*/
	public void mudancaCor(){
		//distCores	= applet.distCores;
		String n = nome;
		if(m_aDef.getValue()<1){
			n = "rectângulo";
			if(inicio){
				if(AppletPuzzle.Tor[AppletPuzzle.menuS].isSelected()){
					if(m_aDef.getValue()>0.5){
						n = "cilindro";
					}else if(m_aDef.getValue()==1){
						n = "toro";
					}
				}
				if(AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected()&&m_aDef.getValue()>0.5){
					n = "klein";
				}
			}
		}
		
		indPlacasContiguas	= Contig(n,distCores[0]);
		
		int ind	= 0;
		for(int i=0;i<valorM;i++){
			for(int j=0;j<valorN;j++){
				transp[distCores[0][0]][distCores[0][1]]	= transpMin;
				if(ind!=0){
					for(int k=0;k<4;k++){
						if(indPlacasContiguas[k][0]==distCores[ind][0]&&indPlacasContiguas[k][1]==distCores[ind][1]){
							transp[distCores[ind][0]][distCores[ind][1]]	= transpMax; k = 4;
						}else {
							transp[distCores[ind][0]][distCores[ind][1]]	= transpMin;
						}
					}
				}
				ind++;
			}
		}		
	}
	
	public void tudo(){
		//cameraAbMudaDir(new PdVector(1,0,0));
		if(AppletPuzzle.Rect[AppletPuzzle.menuS].isSelected()){mostraTiraM=false;mostraCili=false;mostraToro=false;
			plano();objectoPick(); valorMAntigo[0] = valorM; valorNAntigo[0] = valorN;
			def();
		}
		if(AppletPuzzle.Cil[AppletPuzzle.menuS].isSelected()){
			cilindro();objectoPick(); valorMAntigo[1] = valorM; valorNAntigo[1] = valorN;
			def();
		}
		if(AppletPuzzle.Tor[AppletPuzzle.menuS].isSelected()){mostraTiraM=false;mostraCili=false;
			toro();objectoPick(); valorMAntigo[2] = valorM; valorNAntigo[2] = valorN;
			def();
		}
		if(AppletPuzzle.Moeb[AppletPuzzle.menuS].isSelected()){
			tiraMoebius();objectoPick(); valorMAntigo[3] = valorM; valorNAntigo[3] = valorN;
			def();
		}
		if(AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected()){
			garrafaKlein(); valorMAntigo[4] = valorM; valorNAntigo[4] = valorN;
			def();objectoPick();
		}
		run();		
		dispDef().update(dispDef()); dispDefVD().update(dispDefVD());
	}
	
	public void tudoRun(){
		if(AppletPuzzle.Rect[AppletPuzzle.menuS].isSelected()){
			plano();objectoPick(); valorMAntigo[0] = valorM; valorNAntigo[0] = valorN;
		}
		if(AppletPuzzle.Cil[AppletPuzzle.menuS].isSelected()){
			cilindro();objectoPick(); valorMAntigo[1] = valorM; valorNAntigo[1] = valorN;
		}
		if(AppletPuzzle.Tor[AppletPuzzle.menuS].isSelected()){mostraTiraM=false;mostraCili=false;
			toro();objectoPick(); valorMAntigo[2] = valorM; valorNAntigo[2] = valorN;
		}
		if(AppletPuzzle.Moeb[AppletPuzzle.menuS].isSelected()){
			tiraMoebius();objectoPick(); valorMAntigo[3] = valorM; valorNAntigo[3] = valorN;
		}
		if(AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected()){
			garrafaKlein(); valorMAntigo[4] = valorM; valorNAntigo[4] = valorN;
		}
	}
	
	/**Para haver correspondência no início entre o random do puzzle a 2D com o a 3D.*/
	public void tudoInicioApplet(boolean planoB,boolean cilindroB,boolean toroB,boolean tiraMB,boolean garrafaKB){
		if(planoB){plano();objectoPick();}
		if(cilindroB){cilindro();objectoPick();}
		if(toroB){toro();objectoPick();}
		if(tiraMB){tiraMoebius();objectoPick();}
		if(garrafaKB){garrafaKlein();objectoPick();}
		run();
		dispDef().update(dispDef());
	}
	
	
	public void tudoPick(){
		if(AppletPuzzle.Rect[AppletPuzzle.menuS].isSelected()){
			plano(); valorMAntigo[0] = valorM; valorNAntigo[0] = valorN;
			def();
		}
		if(AppletPuzzle.Cil[AppletPuzzle.menuS].isSelected()){
			cilindro(); valorMAntigo[1] = valorM; valorNAntigo[1] = valorN;
			def();
		}
		if(AppletPuzzle.Tor[AppletPuzzle.menuS].isSelected()){
			toro(); valorMAntigo[2] = valorM; valorNAntigo[2] = valorN;
			def();
		}
		if(AppletPuzzle.Moeb[AppletPuzzle.menuS].isSelected()){
			tiraMoebius(); valorMAntigo[3] = valorM; valorNAntigo[3] = valorN;
			def();
		}
		if(AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected()){
			garrafaKlein();objectoPick(); valorMAntigo[4] = valorM; valorNAntigo[4] = valorN;
			def();
		}
		run();
		dispDef().update(dispDef());
	}
	
	/**Calcular o objecto que será sensível ao "pick" do rato para mexer as peças do jogo.*/
	public void objectoPick(){
		boolean mostraFaces	= false; boolean mostraArestas = false;
		if(nome.equals("rectângulo")){
			Metodos.computePlanoLC(objPick,-valorN,0,0,valorM,valorN+1,valorM+1,Color.white,Color.black,sizeArestas,0.,mostraFaces,mostraArestas,true);
		}else if(nome.equals("cilindro")){
			Metodos.rectCil(objPick,m_aDef.getValue(),0,((double)valorN)/2,valorM/(2*Pi),multM*valorM+1,valorN+1,mostraFaces,mostraArestas);
		}else if(nome.equals("toro")){
			Metodos.rectCilToro(objPick,m_aDef.getValue(),raioMenorToro,distCentroToro,multM*valorM+1,multN*valorN+1,mostraFaces,mostraArestas);
		}else if(nome.equals("moebius")){
			Metodos.rectCil(objPick,m_aDef.getValue(),1,larguraTiraM/2,comprimentoTiraM,multM*valorM+1,multN*valorN+1,mostraFaces,mostraArestas);
			
		}else if(nome.equals("klein")){
			Metodos.rectCilGK(trans,dir,objPick,m_aDef.getValue(),rMenorGarrafaK,rMaiorGarrafaK,multM*valorM+1,multN*valorN+1,mostraFaces,mostraArestas);
		}
		
	}
	
	public void defInicial(){
		Metodos.computeLinha(linha,distCores,valorM/(2*Pi),valorN/2,valorM,valorN,numXLinesDef);
		int ind	= 0;
		for(int i=0;i<valorM;i++){
			for(int j=0;j<valorN;j++){
				ciliDefs[ind].showElements(true);
				if(i==distCores[0][0]&&j==distCores[0][1]){
					Metodos.computePlanoLC(ciliDefs[ind],-j-1,-j,i,i+1,2,2,corPlano,corArestas,sizeArestas,transp[i][j],false,mostraArestasPlano,mostraPlano);
				}else {
					if(AppletPuzzle.luzes[AppletPuzzle.menuS].isSelected()){
						bordo(i,j);
						Metodos.computePlanoLC(ciliDefs[ind],-j-1,-j,i,i+1,2,2,corPlano,corBordo,sizeBordo,transp[i][j],mostraFacesPlano,mostraArestasPlano,mostraPlano);
					}else {
						Metodos.computePlanoLC(ciliDefs[ind],-j-1,-j,i,i+1,2,2,corPlano,corArestas,sizeArestas,transp[i][j],mostraFacesPlano,mostraArestasPlano,mostraPlano);
						ciliDefs[ind].showTransparency(false);ciliDefs[ind].update(ciliDefs[ind]);
					}	
				}
				normalCiliDefs[ind] = new PdVector(+0.2,-1.,0);ind++;
			}
		}
	}
	
	public void def(){
		if(m_aDef.getValue()==1||(m_aDef.getValue()<=(0.5+1/nPassosDef+0.1)&&m_aDef.getValue()>0.5)){mudancaCor();tudoRun();}
		if(AppletPuzzle.Rect[AppletPuzzle.menuS].isSelected()){
			int ind	= 0;
			for(int i=0;i<valorM;i++){
				for(int j=0;j<valorN;j++){
					ciliDefs[ind].showElements(true);
					if(i==distCores[0][0]&&j==distCores[0][1]){
						Metodos.computePlanoLC(ciliDefs[ind],-j-1,-j,i,i+1,2,2,corPlano,corArestas,sizeArestas,transp[i][j],false,mostraArestasPlano,mostraPlano);
					}else {
						if(AppletPuzzle.luzes[AppletPuzzle.menuS].isSelected()){
							bordo(i,j);
							Metodos.computePlanoLC(ciliDefs[ind],-j-1,-j,i,i+1,2,2,corPlano,corBordo,sizeBordo,transp[i][j],mostraFacesPlano,mostraArestasPlano,mostraPlano);
						}else {
							Metodos.computePlanoLC(ciliDefs[ind],-j-1,-j,i,i+1,2,2,corPlano,corArestas,sizeArestas,transp[i][j],mostraFacesPlano,mostraArestasPlano,mostraPlano);
							ciliDefs[ind].showTransparency(false);ciliDefs[ind].update(ciliDefs[ind]);
						}	
					}
					normalCiliDefs[ind] = new PdVector(0.13,1.,-0.2);ind++;
				}
			}
			
		}else if(AppletPuzzle.Cil[AppletPuzzle.menuS].isSelected()){
			Metodos.rectCils(dispDef(),ciliDefs,normalCiliDefs,facesCili,valorM,valorN,m_aDef.getValue(),0,((double)valorN)/2,valorM/(2*Pi),numXLinesDef,numYLinesDef,update);
		}else if(AppletPuzzle.Tor[AppletPuzzle.menuS].isSelected()){
			Metodos.rectCilToros(dispDef(),ciliDefs,normalCiliDefs,facesToro,valorM,valorN,m_aDef.getValue(),raioMenorToro,distCentroToro,numXLinesDef,numYLinesDef,update);
			//met.rectCilToros(ciliDefs,facesToro,valorM,valorN,m_aDef.getValue(),raioMenorToro,distCentroToro,numXLinesDef,numYLinesDef);
		}else if(AppletPuzzle.Moeb[AppletPuzzle.menuS].isSelected()){
			Metodos.rectCils(dispDef(),ciliDefs,normalCiliDefs,facesTiraM,valorM,valorN,m_aDef.getValue(),1,larguraTiraM/2,comprimentoTiraM,numXLinesDef,numYLinesDef,update);
			Metodos.computeLinha(linha,distCores,larguraTiraM/2,comprimentoTiraM,valorM,valorN,numXLinesDef);
			if(m_aDef.getValue()!=1.){
				linha.setVisible(false);linha.update(linha);
			}
		}else if(AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected()){
			double Raio = rMaiorGarrafaK;
			double raio = rMenorGarrafaK;
			PdVector p1 = new PdVector(Raio-6*(-2*Pi),-16*(-2*Pi),-1*4*Pi); PdVector p2 = new PdVector(Raio,0,-1*4*Pi);
			dir = Metodos.difVect(p1,p2);
			PdVector ext1 = Metodos.rotacaoVect(p1,dir,Pi/2);
			PdVector difExt = Metodos.difVect(p1,ext1);
			double dist = PdVector.dist(p1,ext1);
			trans = Metodos.multiNumVect(dist,Metodos.uni(difExt));
			Metodos.rectCilGKs(dispDef(),trans,dir,ciliDefs,normalCiliDefs,facesGarrafaK,valorM,valorN,m_aDef.getValue(),raio,Raio,numXLinesDef,numYLinesDef,update);
			Metodos.computeLinhaGK(linha,distCores,raio,Raio,valorM,valorN,numXLinesDef);
			if(m_aDef.getValue()!=1.){
				linha.setVisible(false);linha.update(linha);
			}
		}
	}
	
	/**Para o cilindro resultante da colagem do rectângulo esteja no mesmo sítio que o cilindro que vai formar a garrafa de klein.*/
	PdVector trans,dir;
	
	/**Se for o plano.*/
	public void plano(){
		corPlano			= Metodos.corRGB(214,180,86);
		mostraFacesPlano	= true;
		mostraArestasPlano	= true;
		
		facesPlano	= new PgElementSet[valorM*valorN];
		
		int ind	= 0;
		for(int i=0;i<valorM;i++){
			for(int j=0;j<valorN;j++){
				facesPlano[ind]	= new PgElementSet(3);
				if(i==distCores[0][0]&&j==distCores[0][1]){
					Metodos.computePlanoLCProp(facesPlano[ind],-j-1,-j,i,i+1,2,2,corPlano,corArestas,sizeArestas,transp[i][j],false,mostraArestasPlano,mostraPlano);
				}else {
					if(AppletPuzzle.luzes[AppletPuzzle.menuS].isSelected()){
						bordo(i,j);
						Metodos.computePlanoLCProp(facesPlano[ind],-j-1,-j,i,i+1,2,2,corPlano,corBordo,sizeBordo,transp[i][j],mostraFacesPlano,mostraArestasPlano,mostraPlano);
					}else {
						Metodos.computePlanoLCProp(facesPlano[ind],-j-1,-j,i,i+1,2,2,corPlano,corArestas,sizeArestas,transp[i][j],mostraFacesPlano,mostraArestasPlano,mostraPlano);
						facesPlano[ind].showTransparency(false);facesPlano[ind].update(facesPlano[ind]);
					}
					
				}
				ind++;
			}
		}
	}
	
	/**Para acyualizar o bordo das peças que podem ser seleccionadas.*/
	public void bordo(int i,int j){
		corBordo	= corArestas;
		sizeBordo	= sizeArestas;
		for(int k=0;k<4;k++){
			if(i==indPlacasContiguas[k][0]&&j==indPlacasContiguas[k][1]){
				corBordo	= corSele;
				sizeBordo	= sizeSele;
			}
		}
	}
	
	/**Para acyualizar o bordo das peças que podem ser seleccionadas.*/
	public void bordoCili(double tr,double trMax,int i,int j){
		if(tr==trMax){
			corBordo	= corSele;
			sizeBordo	= sizeSele;
		}else {
			corBordo	= corArestas;
			sizeBordo	= sizeArestas;
		}
				
			
	}
	
		
	/**Se for o cilindro.*/
	public void cilindro(){
		corCilindro			= Metodos.corRGB(214,180,86);
		ptoCilindroB		= new PdVector(0,0,0);
		ptoCilindroT		= new PdVector(0,0,valorN);
		raioCilindro		= valorM/(2*Pi);
		numXLinesCili		= 10;
		numYLinesCili		= 2;
		mostraFacesCili		= true;
		mostraArestasCili	= true;
		boolean mostraArestasMesmo	= false;
		double sizeArestasMesmo	= .5;
		Color corArestasMesmo	= corFundo;
		
		double[][] t	= new double[valorM][valorN];
		for(int i=0;i<valorM;i++){	for(int j=0;j<valorN;j++){	t[i][j]	= transpMin;}	}
		
		for(int i=0;i<valorM;i++){
			for(int j=0;j<valorN;j++){
				if(transp[i][j]==transpMax){
					t[i][(valorN-1)-j]	= transpMax;	
				}
			}
		}
		facesCili	= new PgElementSet[valorM*valorN];
		int ind	= 0;
		double[] ang	= {0,0};
		double[] compr	= {0,0};
		double pAng		= 2*Pi/valorM;//Passos do ângulo
		double pCompr	= 1/(double)valorN;//Passos do comprimento (que tem como mínimo 0 e máximo 1)
		for(int i=0;i<valorM;i++){
			ang[0] = ang[1]; ang[1] = ang[1]+pAng;
			compr[1] = 0; 
			for(int j=0;j<valorN;j++){
				compr[0] = compr[1]; compr[1] = compr[1]+pCompr;
				facesCili[ind]	= new PgElementSet(3);
				if(i==distCores[0][0]&&j==distCores[0][1]){
					Metodos.computePartesCilindroNumLinesProp(facesCili[ind],ptoCilindroB,ptoCilindroT,raioCilindro,numXLinesCili,numYLinesCili,ang,compr,corCilindro,corArestas,sizeArestas,t[i][j],false,mostraArestasCili,false,corFundo,sizeArestasMesmo,mostraCili);
				}else {
					if(transp[i][j]==transpMax){
						if(AppletPuzzle.luzes[AppletPuzzle.menuS].isSelected()){
							bordoCili(t[i][j],transpMax,i,j);
							Metodos.computePartesCilindroNumLinesProp(facesCili[ind],ptoCilindroB,ptoCilindroT,raioCilindro,numXLinesCili,numYLinesCili,ang,compr,corCilindro,corBordo,sizeBordo,t[i][j],mostraFacesCili,mostraArestasCili,mostraArestasMesmo,corArestasMesmo,sizeArestasMesmo,mostraCili);
						}else {
							mostraArestasMesmo	= false;
							Metodos.computePartesCilindroNumLinesProp(facesCili[ind],ptoCilindroB,ptoCilindroT,raioCilindro,numXLinesCili,numYLinesCili,ang,compr,corCilindro,corArestas,sizeArestas,t[i][j],mostraFacesCili,mostraArestasCili,mostraArestasMesmo,corArestasMesmo,sizeArestasMesmo,mostraCili);
							facesCili[ind].showTransparency(false);facesCili[ind].update(facesCili[ind]);
						}
					}else {
						if(AppletPuzzle.luzes[AppletPuzzle.menuS].isSelected()){
							bordoCili(t[i][j],transpMax,i,j);
							Metodos.computePartesCilindroNumLinesProp(facesCili[ind],ptoCilindroB,ptoCilindroT,raioCilindro,numXLinesCili,numYLinesCili,ang,compr,corCilindro,corBordo,sizeBordo,t[i][j],mostraFacesCili,mostraArestasCili,false,corFundo,sizeArestasMesmo,mostraCili);
						}else {
							Metodos.computePartesCilindroNumLinesProp(facesCili[ind],ptoCilindroB,ptoCilindroT,raioCilindro,numXLinesCili,numYLinesCili,ang,compr,corCilindro,corArestas,sizeArestas,t[i][j],mostraFacesCili,mostraArestasCili,false,corFundo,sizeArestasMesmo,mostraCili);
							facesCili[ind].showTransparency(false);facesCili[ind].update(facesCili[ind]);
						}
					}
				}
				ind++;
			}
		}			
	}
	
	
	/**Se for o toro.*/
	public void toro(){
		corToro				= Metodos.corRGB(214,180,86);
		raioMenorToro		= 1;
		distCentroToro		= 2;
		numXLinesToro		= 10;
		numYLinesToro		= 10;
		mostraFacesToro		= true;
		mostraArestasToro	= true;
		
		facesToro	= new PgElementSet[valorM*valorN];
		int ind	= 0;
		double[] angX	= {0,0};
		double[] angY	= {0,0};
		double pX		= 2*Pi/valorM;//Passos do ângulo nos xx
		double pY		= 2*Pi/valorN;//Passos do ângulo nos yy
		for(int i=0;i<valorM;i++){
			angX[0] = angX[1]; angX[1] = angX[1]+pX;
			angY[1]	= 0;
			for(int j=0;j<valorN;j++){
				angY[0] = angY[1]; angY[1] = angY[1]+pY;
				facesToro[ind]	= new PgElementSet(3);
				if(i==distCores[0][0]&&j==distCores[0][1]){
					Metodos.computePartesToroProp(facesToro[ind],raioMenorToro,distCentroToro,numXLinesToro,numYLinesToro,angX,angY,corToro,corArestas,sizeArestas,transp[i][j],false,mostraArestasToro,mostraToro);
				}else {
					if(AppletPuzzle.luzes[AppletPuzzle.menuS].isSelected()){
						bordo(i,j);
						Metodos.computePartesToroProp(facesToro[ind],raioMenorToro,distCentroToro,numXLinesToro,numYLinesToro,angX,angY,corToro,corBordo,sizeBordo,transp[i][j],mostraFacesToro,mostraArestasToro,mostraToro);
					}else {
						Metodos.computePartesToroProp(facesToro[ind],raioMenorToro,distCentroToro,numXLinesToro,numYLinesToro,angX,angY,corToro,corArestas,sizeArestas,transp[i][j],mostraFacesToro,mostraArestasToro,mostraToro);
						facesToro[ind].showTransparency(false);facesToro[ind].update(facesToro[ind]);
					}	
				}
				ind++;
			}
		}
	}
	
	
	/**Se for a tira de Moebius.*/
	public void tiraMoebius(){
		corBordo	= corArestas;
		sizeBordo	= sizeArestas;
		corTiraM			= Metodos.corRGB(214,180,86);
		comprimentoTiraM	= 3;
		larguraTiraM		= 1;
		if(valorN>6&&valorM>6){
			numXLinesTiraM		= 10;
			numYLinesTiraM		= 5;
		}else {
			numXLinesTiraM		= 10;
			numYLinesTiraM		= 5;
		}
		
		mostraFacesTiraM	= true;
		mostraArestasTiraM	= true;
		
		facesTiraM	= new PgElementSet[valorM*valorN];
		int ind	= 0;
		double[] ang	= {0,0};
		double larg		= 0;
		double pAng		= 2*Pi/valorM;//Passos do ângulo
		double pLarg	= larguraTiraM/(double)valorN;//Passos do comprimento (que tem como mínimo 0 e máximo 1)
		for(int i=0;i<valorM;i++){
			ang[0] = ang[1]; ang[1] = ang[1]+pAng;
			larg = 0; 
			for(int j=0;j<valorN;j++){
				larg = larg+pLarg;
				facesTiraM[ind]	= new PgElementSet(3);
				if(i==distCores[0][0]&&j==distCores[0][1]){
					Metodos.computePartesTiraMoebius(facesTiraM[ind],comprimentoTiraM,pLarg,Pi/2,numXLinesTiraM,numYLinesTiraM,ang,larg,j,valorN,corTiraM,corArestas,sizeArestas,transp[i][j],false,mostraArestasTiraM,mostraTiraM);	
				}else {
					if(AppletPuzzle.luzes[AppletPuzzle.menuS].isSelected()){
						bordo(i,j);
						Metodos.computePartesTiraMoebius(facesTiraM[ind],comprimentoTiraM,pLarg,Pi/2,numXLinesTiraM,numYLinesTiraM,ang,larg,j,valorN,corTiraM,corBordo,sizeBordo,transp[i][j],mostraFacesTiraM,mostraArestasTiraM,mostraTiraM);
					}else {
						Metodos.computePartesTiraMoebius(facesTiraM[ind],comprimentoTiraM,pLarg,Pi/2,numXLinesTiraM,numYLinesTiraM,ang,larg,j,valorN,corTiraM,corArestas,sizeArestas,transp[i][j],mostraFacesTiraM,mostraArestasTiraM,mostraTiraM);	
						facesTiraM[ind].showTransparency(false); facesTiraM[ind].update(facesTiraM[ind]);
					}
				}
				ind++;
			}
		}
	}
	
	/**Se for a garrafa de Klein.*/
	public void garrafaKlein(){
		corGarrafaK				= Metodos.corRGB(214,180,86);
		rMaiorGarrafaK			= 6;
		rMenorGarrafaK			= 2;
		numXLinesGarrafaK		= 10;
		numYLinesGarrafaK		= 5;//Ímpar
		mostraFacesGarrafaK		= true;
		mostraArestasGarrafaK	= true;
		
		facesGarrafaK	= new PgElementSet[valorM*valorN];
		int ind	= 0;
		double[] angX	= {0,0};
		double[] angY	= {0,0};
		double pAngX	= 2*Pi/valorM;//Passos do ângulo em X
		double pAngY	= 2*Pi/valorN;//Passos do ângulo em Y
		for(int i=0;i<valorM;i++){
			angX[0] = angX[1]; angX[1] = angX[1]+pAngX;
			for(int j=0;j<valorN;j++){
				int[] aa = {valorM-1-i,j};ind = Metodos.parOrdInd(aa,valorM,valorN);
				angY[0] = angY[1]; angY[1] = angY[1]+pAngY;
				facesGarrafaK[ind]	= new PgElementSet(3);
				if(valorM-1-i==distCores[0][0]&&j==distCores[0][1]){
					Metodos.computePartesGarrafaKlein(facesGarrafaK[ind],rMaiorGarrafaK,rMenorGarrafaK,numXLinesGarrafaK,numYLinesGarrafaK,angX,angY,corGarrafaK,corArestas,sizeArestas,transp[valorM-1-i][j],false,true,mostraGarrafaK);
				}else {
					if(angX[0]<=1.5*Pi&&angX[1]>=1.1*Pi){
						if(AppletPuzzle.luzes[AppletPuzzle.menuS].isSelected()){
							bordo(valorM-1-i,j);
							Metodos.computePartesGarrafaKlein(facesGarrafaK[ind],rMaiorGarrafaK,rMenorGarrafaK,numXLinesGarrafaK,numYLinesGarrafaK,angX,angY,corGarrafaK,corBordo,sizeBordo,transpMax,mostraFacesGarrafaK,mostraArestasGarrafaK,mostraGarrafaK);
						}else {
							Metodos.computePartesGarrafaKlein(facesGarrafaK[ind],rMaiorGarrafaK,rMenorGarrafaK,numXLinesGarrafaK,numYLinesGarrafaK,angX,angY,corGarrafaK,corArestas,sizeArestas,transpMax,mostraFacesGarrafaK,mostraArestasGarrafaK,mostraGarrafaK);
						}	
					}else {
						if(AppletPuzzle.luzes[AppletPuzzle.menuS].isSelected()){
							bordo(valorM-1-i,j);
							Metodos.computePartesGarrafaKlein(facesGarrafaK[ind],rMaiorGarrafaK,rMenorGarrafaK,numXLinesGarrafaK,numYLinesGarrafaK,angX,angY,corGarrafaK,corBordo,sizeBordo,transpMin,mostraFacesGarrafaK,mostraArestasGarrafaK,mostraGarrafaK);
						}else {
							Metodos.computePartesGarrafaKlein(facesGarrafaK[ind],rMaiorGarrafaK,rMenorGarrafaK,numXLinesGarrafaK,numYLinesGarrafaK,angX,angY,corGarrafaK,corArestas,sizeArestas,transpMin,mostraFacesGarrafaK,mostraArestasGarrafaK,mostraGarrafaK);	
							facesGarrafaK[ind].showTransparency(false);facesGarrafaK[ind].update(facesGarrafaK[ind]);
						}
					}
				}
			}
		}
		
	}
	
	/**Calcular o vector normal a cada face.*/
	public PdVector vNormal(PdVector[] vert,PdVector ptoInterior){
		PdVector normal;
		PdVector u	= Metodos.uv(vert[0],vert[1]);
		PdVector v	= Metodos.uv(vert[1],vert[2]);
		PdVector vectInt	= Metodos.uv(ptoInterior,vert[0]);
		PdVector c	= Metodos.cross(u,v);
		if(Metodos.produtoEscalar(vectInt,c)>=0){
			normal	= Metodos.uni(c);
		}else {
			normal	= Metodos.uni(Metodos.cross(Metodos.uv(vert[2],vert[1]),Metodos.uv(vert[1],vert[0])));
		}	
		
		return normal;
	}
	
	/*Métodos de apoio à mudança das peças:*/
		/**Estado inicial das placas quanto às reflexões*/
		public boolean[][] FlipI(int M,int N){//faz corresponder a cada placa o par (false, false)
			boolean[][] Result = new boolean[M*N][2];
			for(int i=0; i<M*N;i++){				//para as reflexões
				Result[i][1]=false;
				Result[i][0]=false;
			}
			return Result;
		}
	
		/** Retorna os 4 pares de contiguos para cada par mn*/
		public static int[][] Contig(String nome,int[] mn){
			int[][] R=new int[4][2];
							
			if(nome=="cilindro"||nome=="toro"||nome=="moebius"||nome=="klein"){
				R[0][0]=(mn[0]-1+Dados.M)%Dados.M;
			}else{R[0][0]=mn[0]-1;}
			if((nome=="moebius"||nome=="klein")&&(mn[0]==0)){
				R[0][1]=Dados.N-mn[1]-1;
			}else{R[0][1]=mn[1];}
			
			if((nome=="moebius")&&(mn[1]==0)){
				R[2][0]=Dados.M-mn[0]-1;
			}else{R[2][0]=mn[0];}
			if(nome=="toro"||nome=="klein"){
				R[2][1]=(mn[1]-1+Dados.N)%Dados.N;
			}else{R[2][1]=mn[1]-1;}
			
			if(nome=="cilindro"||nome=="toro"||nome=="moebius"||nome=="klein"){
				R[1][0]=(mn[0]+1+Dados.M)%Dados.M;
				if((mn[0]==Dados.M-1)&&AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected()&&m_aDef.getValue()<1&&m_aDef.getValue()>0.5){
					R[1][0]=R[2][0];
				}
			}else{R[1][0]=mn[0]+1;}
			if((nome=="moebius"||nome=="klein")&&(mn[0]==Dados.M-1)){
				R[1][1]=(Dados.N-mn[1]-1);
				if((mn[0]==Dados.M-1)&&nome.equals("klein")&&m_aDef.getValue()<1&&m_aDef.getValue()>0.5){
					R[1][1]=R[2][1];
				}
			}else{	R[1][1]=mn[1]; }
			
			if((nome=="moebius")&&(mn[1]==Dados.N-1)){
				R[3][0]=Dados.M-mn[0]-1;
			}else{R[3][0]=mn[0];}
			if(nome=="toro"||nome=="klein"){
				R[3][1]=(mn[1]+1+Dados.N)%Dados.N;
			}else{R[3][1]=mn[1]+1;}
			
			if((mn[0]==0)&&nome.equals("klein")&&m_aDef.getValue()<1&&m_aDef.getValue()>0.5){
				R[0][0]=R[2][0];R[0][1]=R[2][1];
			}
			
			return R;
		}
				
		/**retorna o numero da placa correspondente posição pos na lista Placas*/
		public static int invPlacas(int[] pos, int[][] Placas){
			int Result=-1;
			for(int i=0; (i<Placas.length)&&(Result==-1);i++){
				if((Placas[i][0]==pos[0])&&(Placas[i][1]==pos[1])){
					Result=i;
				}
			}
			return Result;		
		}
		
		/**Troca de posições dentro de um array de inteiros.*/	
		public static void Permuta(int[][] array, int m, int n){
			int[] mm = array[m];
			int[] nn = array[n];
			if((m<array.length)&&(n<array.length)){
				array[m]=nn;
				array[n]=mm;
			}
		}
	/*.......................................................................................*/
	
	
	
	
			
	
	public void pickInitial(PvPickEvent pos) {
		if (pos==null || pos.getGeometry()==null) {
						if (PsDebug.WARNING) PsDebug.warning("select background grid and pick inside.");
						return;
		}
		double	quoc	= 0;
		int in = pos.getElementInd();
		int indice;
		if(nome.equals("rectângulo")){
			indice	= Metodos.nPlacaInv(in,1,valorM,1,valorN);
		}else if(nome.equals("klein")){
			if(m_aDef.getValue()>0.5){
				quoc	= in/(valorN*valorM*multM*multN);
				if(in<((double)valorN*valorM*multM*multN)/2-1){//dá 0
					if(in<((double) valorN*multN*((double)multM/2))){
						quoc	= 0;
					}else {
						quoc	= 1;
					}
				}else {
					if(in<((double) (valorM*multM*valorN*multN-valorN*multN*((double)multM/2)))){
						quoc	= 0;
					}else {
						quoc	= 1;
					}
				}
				int[] aa = Metodos.indParOrd(in,valorM*multM,valorN*multN);
				aa[1] = valorN*multN-1-aa[1];
				int ini = Metodos.parOrdInd(aa,valorM*multM,valorN*multN);
				indice	= Metodos.nPlaca(ini,multM,valorM,multN,valorN);
			}else {
				indice = Metodos.parOrdInd(Metodos.invConj(Metodos.indParOrd(Metodos.nPlaca(in,multN,valorN,multM,valorM),valorN,valorM)),valorM,valorN);
				
			}
		}else if(nome.equals("moebius")){
			quoc	= in/(valorN*valorM*multM*multN);
			if(in<((double)valorN*valorM*multM*multN)/2-1){//dá 0
				if(in<((double) valorN*multN*((double)multM/2))){
					quoc	= 0;
				}else {	quoc	= 1; }
			}else {
				if(in<((double) (valorM*multM*valorN*multN-valorN*multN*((double)multM/2)))){
					quoc	= 0;
				}else {	quoc	= 1; }
			}
			indice	= Metodos.nPlaca(in,multM,valorM,multN,valorN);
		}else if(nome.equals("toro")){
			if(m_aDef.getValue()<=0.5){	indice	= Metodos.nPlaca(in,multM,valorM,multN,valorN);	}
			else {indice = Metodos.parOrdInd(Metodos.invConj(Metodos.indParOrd(Metodos.nPlaca(in,multN,valorN,multM,valorM),valorN,valorM)),valorM,valorN);	}
		}else if(nome.equals("cilindro")){
			indice	= Metodos.nPlaca(in,multM,valorM,1,valorN);
			double q	= Math.floor(indice/valorN);
			double r	= indice%valorN;
			indice		= (int)(valorN*q+((valorN-1)-r));
			
		}else {
			indice	= Metodos.nPlaca(in,multM,valorM,1,valorN);
		}
		
		if(pos.getGeometry().equals(objPick)){
			for(int i=0;i<4;i++){
				if(indice==Metodos.parOrdInd(indPlacasContiguas[i],valorM,valorN)){
					if(mostraPlano){
						Permuta(distCores,invPlacas(Contig(nome,distCores[0])[i],distCores),0);
						mudancaCor();
						tudoPick();
						for(int j=0;j<valorM*valorN;j++){
							AppletPuzzle.distCores[j][0]	= distCores[j][0];
							AppletPuzzle.distCores[j][1]	= distCores[j][1];
						}
						AppletPuzzle.execPuzzle();
					}else if(AppletPuzzle.Moeb[AppletPuzzle.menuS].isSelected()||AppletPuzzle.Klein[AppletPuzzle.menuS].isSelected()){
						if(valorM==2&&
							valorN%2==1&&Contig(nome,distCores[0])[i][1]==(int)((valorN+1)/2-1)&&distCores[0][1]==(int)((valorN+1)/2-1)){
								if(((quoc==0)&&distCores[0][0]==1)||((quoc==1)&&distCores[0][0]==0)){
									boolean New=!Flip[invPlacas(Contig(nome,distCores[0])[i],distCores)][1];
									Flip[Func.invPlacas(Contig(nome,distCores[0])[i],distCores)][1]=New;
								}
								Permuta(distCores,invPlacas(Contig(nome,distCores[0])[i],distCores),0);
								mudancaCor();
								tudoPick();
								AppletPuzzle.distCores	= distCores; AppletPuzzle.execPuzzle();
								
						}else{
							boolean flag2;
							if(valorM==2){flag2=Func.Contig(distCores[0])[i][1]!=distCores[0][1];
							}else{flag2=true;}
							if((flag2)&&((Func.Contig(distCores[0])[i][0]==0&&distCores[0][0]==Dados.M-1)||
							(Func.Contig(distCores[0])[i][0]==Dados.M-1&&distCores[0][0]==0))){
								boolean New =!Flip[invPlacas(Contig(nome,distCores[0])[i],distCores)][1];
								Flip[invPlacas(Contig(nome,distCores[0])[i],distCores)][1]	= New;
							}
							Permuta(distCores,invPlacas(Contig(nome,distCores[0])[i],distCores),0);
							mudancaCor();
							tudoPick();
							AppletPuzzle.distCores	= distCores; AppletPuzzle.execPuzzle();
						}
					}else {
						Permuta(distCores,invPlacas(Contig(nome,distCores[0])[i],distCores),0);
						mudancaCor();
						tudoPick();
						AppletPuzzle.distCores	= distCores;AppletPuzzle.execPuzzle();
					}
				}
			}				
		}			
	}
		
	public void dragInitial(PvPickEvent pos) { pickInitial(pos);}
	
	public void arranjarCamera(){
		PvCameraIf camera		= m_dispDef.getCamera();
		PdVector interest		= camera.getInterest();
		PdVector upVector		= camera.getUpVector();
		PdVector position		= camera.getPosition();
		double scale			= camera.getScale();

		// Find out which camera has issued the event,
		// and then steer the other
		PvCameraIf	cam			= m_dispDefVD.getCamera();
		double angle= -6.*Math.PI/180.;

		// Adjust the camera in the steered display
		cam.setInterest(interest);
		cam.setUpVector(upVector);
		PdVector pRot = (PdVector)position.clone();
		PuVectorGeom.rotatePointAroundLine(pRot, position, interest, upVector, angle);
		cam.setPosition(pRot);
		cam.setScale(scale);
		// Update the camera in the steered display
		// but block this current method to avoid an infinite loop
		// since the steered camera will also issue a camera event.
		m_bUpdating = true;
		m_dispDefVD.update(cam);
		m_bUpdating = false;
	}
	
	public void pickCamera(PvCameraEvent pos) {
		if (m_bUpdating)
			return;
		// Do nothing if not both display have been created yet
		if (m_dispDef==null || m_dispDefVD==null)
			return;
				
		PdVector interest		= pos.getInterest();
		PdVector upVector		= pos.getUpVector();
		PdVector position		= pos.getPosition();
		double scale			= pos.getScale();

		// Find out which camera has issued the event,
		// and then steer the other
		PvDisplayIf dispSrc		= pos.getSource();
		PvDisplayIf dispSteer	= null;
		PvCameraIf	cam			= null;
		double angle;
		if (dispSrc == m_dispDef) {
			cam			= m_dispDefVD.getCamera();
			dispSteer	= m_dispDefVD;
			angle		= -6.*Math.PI/180.;
		} else {
			cam			= m_dispDef.getCamera();
			dispSteer	= m_dispDef;
			angle		= 6.*Math.PI/180.;
		}
		// Adjust the camera in the steered display
		cam.setInterest(interest);
		cam.setUpVector(upVector);
		PdVector pRot = (PdVector)position.clone();
		PuVectorGeom.rotatePointAroundLine(pRot, position, interest, upVector, angle);
		cam.setPosition(pRot);
		cam.setScale(scale);
		// Update the camera in the steered display
		// but block this current method to avoid an infinite loop
		// since the steered camera will also issue a camera event.
		m_bUpdating = true;
		dispSteer.update(cam);
		m_bUpdating = false;
	}
	boolean m_bUpdating = false;
	/**
	 * Get camera events resulting from dragging the mouse.
	 * This method just calls the method pickCamera which does all the work.
	 */
	public void dragCamera(PvCameraEvent pos) {
		pickCamera(pos);
	}
	
	/**Método invocado quando os "Sliders" são modificados, caso estes existam.*/
	public boolean update(Object event) {
		if (event == this) {
			return true;
		}
		return super.update(this);
	}
		
	/**Declaração das características da janela.*/
	public PvDisplayIf dispDef() {
		if (m_dispDef != null)
			return m_dispDef;
		PvViewerIf viewer = getViewer();
		m_dispDef = viewer.newDisplay("Janela da transformação", PsConfig.isApplication());
		m_dispDef.addPickListener(this);
		m_dispDef.addCameraListener(this);
		m_dispDef.setEnabledZBuffer(true);
		m_dispDef.showDepthcue(false);
		//m_dispDef.setEnabled3DLook(true);
		m_dispDef.setBackgroundColor(corFundo);
		if (PsConfig.isApplication()) {
			Frame frame = m_dispDef.getFrame();
			frame.setTitle("Janela da transformação");
			frame.setBounds(0, 250, 250, 250);
			frame.validate();
			frame.setVisible(true);
		}
		if (m_dispDef != null) {
			m_dispDef.setMajorMode(PvDisplayIf.MODE_INITIAL_PICK);//.MODE_ORBIT);	// force picking of initial point
		}
		return m_dispDef;
	}
	
	/**Declaração das características da janela.*/
	public PvDisplayIf dispDefVD() {
		if (m_dispDefVD != null)
			return m_dispDefVD;
		PvViewerIf viewer = getViewer();
		m_dispDefVD = viewer.newDisplay("Janela da transformação", PsConfig.isApplication());
		m_dispDefVD.addPickListener(this);
		m_dispDefVD.addCameraListener(this);
		m_dispDefVD.setEnabledZBuffer(true);
		m_dispDefVD.showDepthcue(false);
		//m_dispDefVD.setEnabled3DLook(true);
		m_dispDefVD.setBackgroundColor(corFundo);
		if (PsConfig.isApplication()) {
			Frame frame = m_dispDefVD.getFrame();
			frame.setTitle("Janela da transformação");
			frame.setBounds(0, 250, 250, 250);
			frame.validate();
			frame.setVisible(true);
		}
		if (m_dispDefVD != null) {
			m_dispDefVD.setMajorMode(PvDisplayIf.MODE_INITIAL_PICK);//.MODE_ORBIT);	// force picking of initial point
		}
		return m_dispDefVD;
	}


}