Exemplo n.º 1
0
 void Rectangulo::imprimeEsq()
 {
 cout << "Para la esquina superior izquierda.\n";
 cout << "x = " << superiorIzq.obtenerX() << " y = " << superiorIzq.obtenerY() << endl;
 cout << "Para la esquina inferior derecha.\n";
 cout << "x = " << inferiorDer.obtenerX() << " y = " << inferiorDer.obtenerY() << endl;
 }
Exemplo n.º 2
0
	void move(Coordenada passo) {
		double xFactor = largura * passo.getX() / 100.0;
		double yFactor = altura * passo.getY() / 100.0;

		_centro += Coordenada(xFactor, yFactor);

	}
Exemplo n.º 3
0
void Clipping::clippingPoligonoFechado(Poligono* poligono) {
	list<Coordenada*> *poligonoVertices = getPoligonoLista(poligono);
	if(poligonoVertices->size() > poligono->getCPPCoordenadas()->size()){
		list<Coordenada*> *windowVertices = getWindowLista(poligonoVertices);
		list<Coordenada*> *novosVertices = new list<Coordenada*>();
		list<Coordenada*>::iterator it = poligonoVertices->begin();
		Coordenada* first = NULL;
		while (true) {
			Coordenada *atual = (*it);
			if(atual == first)
				return;
			it = ListUtils::incrementIteratorCircular(poligonoVertices, it);
			if (!atual->isVisitado() && atual->isInterseccao() && CoordenadaUtils::isDentroWindow(*it, window)) {
				if(!first)
					first = atual;
				atual->setVisitado(true);
				novosVertices->push_back(atual);
				percorrerLista(poligonoVertices, windowVertices, novosVertices, ListUtils::getIteratorInObject(poligonoVertices, atual));

				Poligono *poligonoNovo = poligono->clone();
				poligonoNovo->setCPPCoordenadas(novosVertices);
				window->addWindowObjeto(poligonoNovo);
				novosVertices = new list<Coordenada* >();
			}
		}
		delete novosVertices;
		ListUtils::destroyListByCondition(windowVertices, CoordenadaUtils::notVisitado);
	}else
		window->addWindowObjeto(poligono->clone());
	ListUtils::destroyListByCondition(poligonoVertices, CoordenadaUtils::notVisitado);
}
Exemplo n.º 4
0
	vector<vector<double> > getTransformadaMundo(Coordenada wCentro, Window * window){
		Coordenada tr(-1*wCentro.getX(),-1*wCentro.getY(),1);
		vector<vector<double> > m = manipulaMtr->getTranslacao(tr);
		m = manipulaMtr->multiplicaMatriz(m, manipulaMtr->getRotacao(-1*angulo));
		Coordenada tr2(2/window->getLargura(),2/window->getAltura(),1);
		m = manipulaMtr->multiplicaMatriz(m, manipulaMtr->getEscalonamento(tr2));
		return m;
	}
Exemplo n.º 5
0
	void escalona(Objeto* obj, Coordenada c){
		Coordenada centro = obj->getCentro();
		Coordenada a(-1*centro.getX(),-1*centro.getY(),1);
		vector<vector<double> > m = manipulador->getTranslacao(a);
		m = manipulador->multiplicaMatriz(m, manipulador->getEscalonamento(c));
		m = manipulador->multiplicaMatriz(m, manipulador->getTranslacao(centro));
		transformaObjeto(obj, m);
	}
Exemplo n.º 6
0
	bool gambs_pontoPertence(ListaEnc<Coordenada> pontos, Coordenada obj){
		Elemento<Coordenada>* it = pontos.getHead();
		for(int i =0; i<pontos.getSize(); i++){
			if(igual(it->info->getX(),obj.getX()) && igual(it->info->getY(),obj.getY()))
				return true;
			it = it->_next;
		}
		return false;
	}
Exemplo n.º 7
0
	void transformaObjeto(Objeto* b, vector<vector<double> >transformada){
		ListaEnc<Coordenada>* coordenadas = b->pontos();
		for(int i=0; i<coordenadas->getSize(); i++){
			Coordenada antiga = coordenadas->retiraDoInicio();
			vector<vector<double> > nova = manipulador->multiplicaMatriz(antiga.getVector(), transformada);
			Coordenada nova_c(nova[0][0],nova[1][0],nova[2][0]);
			coordenadas->adiciona(nova_c);
		}
	}
Exemplo n.º 8
0
	void escalona(Window* window, Coordenada c){
		window->setTamanho(c);
		Coordenada centro = window->getwCentro();
		vector<vector<double> > m = manipulaMtr->getTranslacao(centro.negative());
		m = manipulaMtr->multiplicaMatriz(m, manipulaMtr->getEscalonamento(c));
		m = manipulaMtr->multiplicaMatriz(m, manipulaMtr->getTranslacao(centro));
		transformaWindow(window, m);
		manipulaWrld->fuckMundo(window->getDisplay(), window->getDisplay_virtual(), getTransformadaMundo(centro, window));
	}
Exemplo n.º 9
0
	//Obs: não consegui passar parâmetro null para fazer uma única funćão
	void insereNoObjeto(ListaEnc<Coordenada>* pontosObjeto, Coordenada ref, Coordenada pontoA){
		int pos = 0;
		Elemento<Coordenada> *it_lista = pontosObjeto->getHead();
		while(!igual(it_lista->info->getX(),ref.getX()) || !igual(it_lista->info->getY(),ref.getY())){//busca como referência o ponto A
			it_lista = it_lista->_next;
			pos++;
		}
		pos++;
		pontosObjeto->adicionaNaPosicao(pontoA, pos);
	}
Exemplo n.º 10
0
	void rotaciona(Window* window, double angulo){
		this->angulo+=angulo;
		Coordenada centro = window->getwCentro();
		Coordenada a(-1*centro.getX(),-1*centro.getY(),1);
		vector<vector<double> > m = manipulaMtr->getTranslacao(a);
		m = manipulaMtr->multiplicaMatriz(m, manipulaMtr->getRotacao(angulo));
		m = manipulaMtr->multiplicaMatriz(m, manipulaMtr->getTranslacao(centro));
		transformaWindow(window, m);
		manipulaWrld->fuckMundo(window->getDisplay(), window->getDisplay_virtual(), getTransformadaMundo(centro, window));
	}
Exemplo n.º 11
0
	int classificaPonto(Coordenada c){
		if(c.getX()==-1)
			return 1;//borda Oeste
		if(c.getY()==1)
			return 2;//borda Norte
		if(c.getX()==1)
			return 3;//borda Leste
		if(c.getY()==-1)
			return 4;//borda Sul
		return 0; //centro
	}
Exemplo n.º 12
0
	void rotaciona(Objeto* obj, Coordenada coord, double angulo){
		/* (0,0,1): rotaciona no centro do mundo
		 * getCentro: rotaciona no centro do objeto
		 * (x, y, 1): rotaciona no  ponto
		 */
		Coordenada a(-1*coord.getX(),-1*coord.getY(),1);
		vector<vector<double> > m = manipulador->getTranslacao(a);
		m = manipulador->multiplicaMatriz(m, manipulador->getRotacao(angulo));
		m = manipulador->multiplicaMatriz(m, manipulador->getTranslacao(coord));
		transformaObjeto(obj, m);
	}
Exemplo n.º 13
0
Matriz::Matriz(Coordenada coord) {
	mat.resize(1);
	mat[0].resize(4);

	mat[0][0] = coord.getX();
	mat[0][1] = coord.getY();
	mat[0][2] = coord.getZ();
	mat[0][3] = coord.getW();

	linhas = 1;
	colunas = 4;
}
Exemplo n.º 14
0
	int rcCode(Coordenada ponto){
		int code =0;
		if (ponto.getX() < -1)
			code |= 1;
		else if (ponto.getX() > 1)
			code |= 2;
		if (ponto.getY() < -1)
			code |= 4;
		else if (ponto.getY() > 1)
			code |= 8;
		return code;
	}
Exemplo n.º 15
0
std::vector<Coordenada> Personaje::coordenadas(Coordenada centro){
	std::vector<Coordenada> s_coord;
	Coordenada coord_aux(0,0);
	for (size_t i = 0; i <= alto/2; i++){
		for (size_t j = 0; j <= ancho/2; j++){
			coord_aux = centro.arriba(i).izquierda(j);
			if (std::find(s_coord.begin(), s_coord.end(), coord_aux) == s_coord.end()){
				s_coord.push_back(centro.arriba(i).izquierda(j));
			}
			coord_aux = centro.arriba(i).derecha(j);
			if (std::find(s_coord.begin(), s_coord.end(), coord_aux) == s_coord.end()){
				s_coord.push_back(centro.arriba(i).derecha(j));
			}
			coord_aux = centro.abajo(i).izquierda(j);
			if (std::find(s_coord.begin(), s_coord.end(), coord_aux) == s_coord.end()){
				s_coord.push_back(centro.abajo(i).izquierda(j));
			}
			coord_aux = centro.abajo(i).derecha(j);
			if (std::find(s_coord.begin(), s_coord.end(), coord_aux) == s_coord.end()){
				s_coord.push_back(centro.abajo(i).derecha(j));
			}

		}
	}
	return s_coord;
}
Exemplo n.º 16
0
bool Personaje::colisiona(Bala *bala, Coordenada c){
	if (!this->recibe_danio(bala)){
		return false;
	}
	size_t x = c.obtener_abscisa();
	size_t y = c.obtener_ordenada();
	size_t ancho_max = coordenada.derecha(ancho/2).obtener_abscisa();
	size_t ancho_min = coordenada.izquierda(ancho/2).obtener_abscisa();
	size_t alto_max = coordenada.arriba(alto/2).obtener_ordenada();
	size_t alto_min = coordenada.abajo(alto/2).obtener_ordenada();
	if ( (x >= ancho_min) && (x <= ancho_max) && (y <= alto_min) && (y >= alto_max) ){
		return true;
	}
	return false;
}
bool CampoMinas::descubreCasilla(const Coordenada &c){
	bool res;
	if ((c.getCoordX()>dimx)||(c.getCoordY()>dimy)||(c.getCoordX()<1)||(c.getCoordY()<1)){
		res=false;
	}
	else{
		if (getCasilla(c).getDescubierta()){
			res=false;
		}
		else{
			getCasilla(c).setDescubierta();
			res=true;
		}
	}
return(res);
}
Exemplo n.º 18
0
list<Coordenada*>* Clipping::getPoligonoLista(Poligono* poligono){
	list<Coordenada*>* poligonoVertices = new list<Coordenada*>();
	list<Coordenada*>::iterator it = poligono->getCPPCoordenadas()->begin();
	poligono->getCPPCoordenadas()->push_back(poligono->getCPPCoordenadas()->front());
	poligonoVertices->push_back((*it)->clone());
	for (; it._M_node != poligono->getCPPCoordenadas()->end()._M_node->_M_prev; it++) {
		Coordenada* currentClone = (*it)->clone();
		Coordenada* next = ListUtils::getDataForwardIterator(it, 1)->clone();
		Coordenada* nextClone = next->clone();
		if (clippingLine(currentClone, nextClone)) {
			if (!(*it)->equal(currentClone)) {
				currentClone->setInterseccao(true);
				poligonoVertices->push_back(currentClone);
			}else
				delete currentClone;
			if (!next->equal(nextClone)) {
				nextClone->setInterseccao(true);
				poligonoVertices->push_back(nextClone);
			}else
				delete nextClone;
		}
		poligonoVertices->push_back(next);
	}
	poligono->getCPPCoordenadas()->pop_back();
	poligonoVertices->pop_back();
	return poligonoVertices;
}
int CampoMinas::calculaPuntos(){
	int puntos=0,i,j;
	Coordenada coord;
	for(i=0;i<getDimX();i++){
		for(j=0;j<getDimY();j++){
			coord.setCoordX(i+1);
			coord.setCoordY(j+1);
			if(getCasilla(coord).getMarcada()){
				if(hasMina(coord)){
					puntos=puntos+(getCasilla(coord).getMina()->getPuntos());
				}
				else{
					puntos--;
				}
			}
		}
	}
	if(puntos<0) puntos=0;
return(puntos);
}
bool CampoMinas::marcaCasilla(const Coordenada &c){
	bool res;
	if ((c.getCoordX()>getDimX())||(c.getCoordY()>getDimY())||(c.getCoordX()<1)||(c.getCoordY()<1)){
		res=false;
	}
	else{
		if (getCasilla(c).getDescubierta()){
			res=false;
		}
		else{
			if (getCasilla(c).getMarcada()){
				res=false;
			}
			else{
				getCasilla(c).setMarcada();
				res=true;
			}
		}
	}
return(res);
}
Exemplo n.º 21
0
	DisplayFile transformadaViewport(Window w) {
		DisplayFile novoDisplay;
		DisplayFile originalDisplay = *w.getDisplay_virtual();
		//constantes da transformacao
		double divX, divY, multX, multY;
		//		divX = (w.getwMax() - w.getwMin()).getX();
		//		divY = (w.getwMax() - w.getwMin()).getY();
		//Alterado para 2 devido ao processo de normalizacao das coordenadas do mundo: window=(-1,-1), (1,1)
		divX = 2;
		divY = 2;
		multX = (vMax - vMin).getX();
		multY = (vMax - vMin).getY();
		// iterando lista de objetos
		Elemento<Objeto*>* it_originalDisplay = originalDisplay.getHead();
		for (int i = 0; i < originalDisplay.getSize(); i++) {
			Objeto *novoObj = new Objeto((it_originalDisplay->getInfo())->nome(), it_originalDisplay->getInfo()->getTipo(), it_originalDisplay->getInfo()->isPreenchido());
			ListaEnc<Coordenada>* coordenadas_obj = (it_originalDisplay->getInfo())->pontos();
			Elemento<Coordenada>* it_coordenada = coordenadas_obj->getHead();
			//iterando as coordenadas do objeto
			for (int j = 0; j < coordenadas_obj->getSize(); j++) {
				Coordenada atual = it_coordenada->getInfo();
				//Transformacao
				double newX, newY, newZ;
				//				newX = ((atual.getX() - w.getwMin().getX()) / divX) * multX;
				//				newY = (1 - (atual.getY() - w.getwMin().getY()) / divY) * multY;
				//Alterado para 2 devido ao processo de normalizacao das coordenadas do mundo: window=(-1,-1), (1,1)
				newX = ((atual.getX() +1) / divX) * multX + vMin.getX();
				newY = (1 - (atual.getY() +1) / divY) * multY + vMin.getY();
				newZ = 1;
				//criando novo ponto
				Coordenada* novoPonto = new Coordenada(newX, newY, newZ);
				novoObj->adiciona(*novoPonto);
				it_coordenada = it_coordenada->getProximo();
			}
			novoDisplay.adicionaNoInicio(novoObj);
			it_originalDisplay = it_originalDisplay->getProximo();
		}
		return novoDisplay;
	}
Exemplo n.º 22
0
list<Coordenada*>* Clipping::getWindowLista(list<Coordenada*>* poligonoVertices) {
	list<Coordenada*>* windowVertices = new list<Coordenada*>();
	Coordenada *A = this->window->CPPstart->clone();
	Coordenada *C = this->window->CPPend->clone();
	Coordenada *B = new Coordenada(A->getX(), C->getY(), 0);
	Coordenada *D = new Coordenada(C->getX(), A->getY(), 0);
	windowVertices->push_back(A);
	windowVertices->push_back(B);
	windowVertices->push_back(C);
	windowVertices->push_back(D);
	this->addListToList(poligonoVertices, windowVertices, A, CoordenadaUtils::compareEqualXAndIsInterseccao, CoordenadaUtils::compareMenorY);
	this->addListToList(poligonoVertices, windowVertices, B, CoordenadaUtils::compareEqualYAndIsInterseccao, CoordenadaUtils::compareMenorX);
	this->addListToList(poligonoVertices, windowVertices, C, CoordenadaUtils::compareEqualXAndIsInterseccao, CoordenadaUtils::compareMaiorY);
	this->addListToList(poligonoVertices, windowVertices, D, CoordenadaUtils::compareEqualYAndIsInterseccao, CoordenadaUtils::compareMaiorX);
	return windowVertices;
}
Exemplo n.º 23
0
void GameProyecto:: update()
{
	int asteroidePeque;
	int asteroideGrande;
	for(int  i=0; i < asteroides.size(); i++) {
		Coordenada centro = asteroides[i].obtenCentro();
		if((centro.obtenerX()>650 || centro.obtenerX() <-50) || (centro.obtenerY()>850 || centro.obtenerY() <-50))
		{
			centro = Coordenada(((double)600+rand()%50),(double)800+ rand()%50);
			if(((int)(centro.obtenerX()))%2==0) centro = Coordenada(-centro.obtenerX()+600,centro.obtenerY());
			if(((int)(centro.obtenerY()))%2==0) centro = Coordenada(centro.obtenerX(),-centro.obtenerY()+800);
			asteroides[i].desplazamiento = Vector2D((float)rand(),(float)rand());
			if(((int)asteroides[i].desplazamiento.getX())%3==0)	asteroides[i].desplazamiento.setX(-asteroides[i].desplazamiento.getX());
			if(((int)asteroides[i].desplazamiento.getY())%3==0)	asteroides[i].desplazamiento.setY(-asteroides[i].desplazamiento.getY());
			asteroides[i].desplazamiento.normaliza();
		}
		asteroides[i].posicionaCentro(Coordenada(centro.obtenerX()+ 1000/asteroides[i].calcArea()*asteroides[i].desplazamiento.getX(), centro.obtenerY() + 1000/asteroides[i].calcArea()*asteroides[i].desplazamiento.getY()));
		asteroides[i].rota(1000/asteroides[i].calcArea());
		for(int j = 0 ; j<i ; j++)
		{
			centro = asteroides[j].obtenCentro();
			if((centro.obtenerX()>600 || centro.obtenerX() <0) || (centro.obtenerY()>800 || centro.obtenerY() <0))
				continue;	
			if(asteroides[i].choca(&asteroides[j]))
			{
				if(asteroides[j].calcArea()>asteroides[i].calcArea())
				{
					asteroidePeque = i;
					asteroideGrande = j;
				}	
				else 
				{
					asteroidePeque = j;
					asteroideGrande = i;
				}						
				asteroides[asteroideGrande].desplazamiento = Vector2D(asteroides[asteroideGrande].desplazamiento.getX() + asteroides[asteroidePeque].desplazamiento.getX()*2, asteroides[asteroideGrande].desplazamiento.getY()+ asteroides[asteroidePeque].desplazamiento.getY()*2);
				asteroides[asteroideGrande].desplazamiento.normaliza();
				centro = Coordenada(((double)600+rand()%50),(double)800+ rand()%50);
				if(((int)(centro.obtenerX()))%2==0) centro = Coordenada(-centro.obtenerX()+600,centro.obtenerY());
				if(((int)(centro.obtenerY()))%2==0) centro = Coordenada(centro.obtenerX(),-centro.obtenerY()+800);				
				asteroides[asteroidePeque].desplazamiento = Vector2D((float)rand(),(float)rand());
				if(((int)asteroides[asteroidePeque].desplazamiento.getX())%3==0)	asteroides[asteroidePeque].desplazamiento.setX(-asteroides[asteroidePeque].desplazamiento.getX());
				if(((int)asteroides[asteroidePeque].desplazamiento.getY())%3==0)	asteroides[asteroidePeque].desplazamiento.setY(-asteroides[asteroidePeque].desplazamiento.getY());
				asteroides[asteroidePeque].desplazamiento.normaliza();
				asteroides[asteroidePeque].posicionaCentro(Coordenada(centro.obtenerX()+ 1000/asteroides[asteroidePeque].calcArea()*asteroides[asteroidePeque].desplazamiento.getX(), centro.obtenerY() + 1000/asteroides[asteroidePeque].calcArea()*asteroides[asteroidePeque].desplazamiento.getY()));
			}
		}
	}
}
void CampoMinas::setNumMinasAlrededorCasilla(Coordenada &c){
	int x=c.getCoordX(), y=c.getCoordY(),minas=0;
	if ((x-1)<1){
		if((y+1)>getDimY()){
			if((casilla[x][y-1]).getMina()!=NULL) minas++;
			if((casilla[x][y-2]).getMina()!=NULL) minas++;
			if((casilla[x-1][y-2]).getMina()!=NULL) minas++;
		}
		else{
			if((y-1)<1){
				if((casilla[x-1][y]).getMina()!=NULL) minas++;
				if((casilla[x][y]).getMina()!=NULL) minas++;
				if((casilla[x][y-1]).getMina()!=NULL) minas++;
			}
			else{
				if((casilla[x][y-1]).getMina()!=NULL) minas++;
				if((casilla[x][y-2]).getMina()!=NULL) minas++;
				if((casilla[x-1][y-2]).getMina()!=NULL) minas++;
				if((casilla[x-1][y]).getMina()!=NULL) minas++;
				if((casilla[x][y]).getMina()!=NULL) minas++;
			}
		}
	}
	else{
		if ((x+1)>getDimX()){
			if((y+1)>getDimY()){
				if((casilla[x-2][y-1]).getMina()!=NULL) minas++;
				if((casilla[x-2][y-2]).getMina()!=NULL) minas++;
				if((casilla[x-1][y-2]).getMina()!=NULL) minas++;
			}
			else{
				if((y-1)<1){
					if((casilla[x-1][y]).getMina()!=NULL) minas++;
					if((casilla[x-2][y]).getMina()!=NULL) minas++;
					if((casilla[x-2][y-1]).getMina()!=NULL) minas++;
				}
				else{
					if((casilla[x-2][y-1]).getMina()!=NULL) minas++;
					if((casilla[x-2][y-2]).getMina()!=NULL) minas++;
					if((casilla[x-1][y-2]).getMina()!=NULL) minas++;
					if((casilla[x-1][y]).getMina()!=NULL) minas++;
					if((casilla[x-2][y]).getMina()!=NULL) minas++;
				}
			}
		}
		else{
			if((y+1)>getDimY()){
				if((casilla[x-2][y-1]).getMina()!=NULL) minas++;
				if((casilla[x-2][y-2]).getMina()!=NULL) minas++;
				if((casilla[x-1][y-2]).getMina()!=NULL) minas++;
				if((casilla[x][y-1]).getMina()!=NULL) minas++;
				if((casilla[x][y-2]).getMina()!=NULL) minas++;
			}
			else{
				if((y-1)<1){
					if((casilla[x-1][y]).getMina()!=NULL) minas++;
					if((casilla[x-2][y]).getMina()!=NULL) minas++;
					if((casilla[x-2][y-1]).getMina()!=NULL) minas++;
					if((casilla[x][y]).getMina()!=NULL) minas++;
					if((casilla[x][y-1]).getMina()!=NULL) minas++;
				}
				else{
					if((casilla[x-2][y-1]).getMina()!=NULL) minas++;
					if((casilla[x-2][y-2]).getMina()!=NULL) minas++;
					if((casilla[x-1][y-2]).getMina()!=NULL) minas++;
					if((casilla[x][y-1]).getMina()!=NULL) minas++;
					if((casilla[x][y-2]).getMina()!=NULL) minas++;
					if((casilla[x-1][y]).getMina()!=NULL) minas++;
					if((casilla[x-2][y]).getMina()!=NULL) minas++;
					if((casilla[x][y]).getMina()!=NULL) minas++;
				}
			}
		}
	}
casilla[x-1][y-1].setNumMinasAlrededor(minas);
}
Exemplo n.º 25
0
	void clip_Poligono(Objeto obj, DisplayFile* virt_clip){
		//CHANCE DE DAR MERDA EM TUDO POR COMPARAR IGUALDADE ENTRE DOUBLES
		//Inicializando as 3 listas
		ListaEnc<Coordenada> pontos_obj;
		ListaEnc<Coordenada> pontos_obj_ori;//usado para percorrer os pontos do objeto. pontos_obj será modificado.
		ListaEnc<Coordenada> pontos_window;
		ListaEnc<Coordenada> pontos_window_ori;
		ListaEnc<Coordenada> entrantes;

		ListaEnc<Coordenada>* pontos_obj_ = obj.pontos();
		for(int i =0; i<pontos_obj_->getSize();i++){
			pontos_obj.adiciona(*pontos_obj_->posicaoMem(i));
			pontos_obj_ori.adiciona(*pontos_obj_->posicaoMem(i));
		}
		pontos_window.adiciona(Coordenada(-1,-1,1));
		pontos_window.adiciona(Coordenada(-1,1,1));
		pontos_window.adiciona(Coordenada(1,1,1));
		pontos_window.adiciona(Coordenada(1,-1,1));

		pontos_window_ori.adiciona(Coordenada(-1,-1,1));
		pontos_window_ori.adiciona(Coordenada(-1,1,1));
		pontos_window_ori.adiciona(Coordenada(1,1,1));
		pontos_window_ori.adiciona(Coordenada(1,-1,1));

		bool gambiarraTudoDentro = true;

		//percorrendo os segmentos de reta do polígono e montando as 3 listas
		Elemento<Coordenada>* it_objeto = pontos_obj_ori.getHead();
		for(int i =0; i<pontos_obj_ori.getSize();i++){
			Coordenada pontoA = *pontos_obj_ori.posicaoMem(i);
			Coordenada pontoB = *pontos_obj_ori.posicaoMem((i+1) % (pontos_obj_ori.getSize()));
			it_objeto = it_objeto->_next;

			if(rcCode(pontoA)==0){ // A dentro;
				if(rcCode(pontoB)!=0){ //pontoB fora;

					//caso dentro-fora
					Objeto reta(" ", Reta, false);
					reta.adiciona(pontoA);
					reta.adiciona(pontoB);
					Objeto *nova_reta = reta_clippada(reta);
					ListaEnc<Coordenada>* pontos_reta = nova_reta->pontos();
					Coordenada novoB = *pontos_reta->posicaoMem(1);//pode dar problema de índice;
					insereNaWindow(&pontos_window, novoB);
					insereNoObjeto(&pontos_obj, pontoA, novoB);

					gambiarraTudoDentro = false;

				}else{
//					cout << "dentro dentro" << endl;
				}
			}
			else{
				gambiarraTudoDentro = false;
				Objeto reta(" ", Reta, false);
				reta.adiciona(pontoA);
				reta.adiciona(pontoB);
				Objeto *nova_reta = reta_clippada(reta);

				if(rcCode(pontoB)==0){ //pontoB dentro;
					//caso fora-dentro;
					ListaEnc<Coordenada>* pontos_reta = nova_reta->pontos();
					Coordenada novoA = *pontos_reta->posicaoMem(0);//pode dar problema de índice;
					insereNaWindow(&pontos_window, novoA);
					insereNoObjeto(&pontos_obj, pontoA, novoA);
					entrantes.adiciona(novoA);
				}
				else{
					//caso fora-fora
					if(nova_reta==0){
						continue;
					}
					//cortando 2 pontos da window:
					ListaEnc<Coordenada>* pontos_reta = nova_reta->pontos();
					Coordenada novoA = *pontos_reta->posicaoMem(0);//pode dar problema de índice;
					Coordenada novoB = *pontos_reta->posicaoMem(1);//pode dar problema de índice;
					insereNaWindow(&pontos_window, novoA);
					insereNaWindow(&pontos_window, novoB);
					insereNoObjeto(&pontos_obj, pontoA, novoA, novoB);
					entrantes.adiciona(novoA);
				}
			}
		}

		while(!entrantes.listaVazia()){
			Objeto* novo = new Objeto(obj.nome(), obj.getTipo(), obj.isPreenchido());
			Coordenada inicial = entrantes.retiraDoInicio();
			Coordenada atual = inicial;

			novo->adiciona(atual);
			Coordenada* it_pontos_obj = pontos_obj.posicaoMem(0);
			Coordenada* it_pontos_window = pontos_window.posicaoMem(0);

			//ajustando iteradores para as posićões corretas.
			bool varreWindow =false;
			int fuck1=0, fuck2=0;
			do{
				if(varreWindow){

					while(!igual(it_pontos_window->getX(), atual.getX()) || !igual(it_pontos_window->getY(),atual.getY())){
						it_pontos_window = pontos_window.posicaoMem(fuck1);
						fuck1 = (fuck1+1) % pontos_window.getSize();
					}

					it_pontos_window = pontos_window.posicaoMem(fuck1);
					fuck1 = (fuck1+1) % pontos_window.getSize();
					atual = *it_pontos_window;
//					cout << "adicionou" << endl;
					cout<< atual.getX() << ", " << atual.getY() << endl;
					novo->adiciona(atual);


					if(gambs_pontoPertence(pontos_window_ori, atual)){
						continue;
					}
					varreWindow = false;
				}
				else{

					while(!igual(it_pontos_obj->getX(), atual.getX()) || !igual(it_pontos_obj->getY(),atual.getY())){
						it_pontos_obj = pontos_obj.posicaoMem(fuck2);
						fuck2 = (fuck2+1) % pontos_obj.getSize();

					}


					it_pontos_obj = pontos_obj.posicaoMem(fuck2);
					fuck2 = (fuck2+1) % pontos_obj.getSize();
					atual = *it_pontos_obj;
					novo->adiciona(atual);

					if(gambs_pontoPertence(pontos_window, atual)){
						varreWindow = true;
						continue;
					}
					if(gambs_pontoPertence(pontos_obj_ori, atual)){

						continue;
					}
					varreWindow = true;
				}
			}while(!igual(atual.getX(), inicial.getX()) || !igual(atual.getY(), inicial.getY()));//atual!=inicial
			virt_clip->adiciona(novo);
		}
		if(gambiarraTudoDentro){
			ListaEnc<Coordenada>* pontos_obj_ = obj.pontos();
			Objeto* novo = new Objeto(obj.nome(), obj.getTipo(), obj.isPreenchido());
			for(int i =0; i<pontos_obj_->getSize();i++){
				novo->adiciona(*pontos_obj_->posicaoMem(i));
			}
			virt_clip->adiciona(novo);
		}
	}
Exemplo n.º 26
0
void ViewPort::calculeCoordenadaVP(Coordenada* pontoObjeto){
	Coordenada* startWindow = window->CPPstart;
	Coordenada* endWindow = window->CPPend;
	pontoObjeto->setX((((pontoObjeto->getX() - startWindow->getX()) / (endWindow->getX() - startWindow->getX())) * (end->getX() - start->getX())) + 10);
	pontoObjeto->setY((((1 - ((pontoObjeto->getY() - startWindow->getY()) / (endWindow->getY() - startWindow->getY()))) * (end->getX() - start->getX()))) + 10);
}
Exemplo n.º 27
0
	void insereNaWindow(ListaEnc<Coordenada>* pontosWindow, Coordenada ponto){
		//Código monstruoso comecando em 9, 8, 7, ...
		/* B---2---C
		 * |	   |
		 * 1   0   3
		 * |       |
		 * A---4---D
		 */
		//1 e 2 contam em ordem crescente, considerando Y e X, respectivamente;
		//3 e 4 contam em ordem decrescente, considerando Y e X, respectivamente;
		int lado = classificaPonto(ponto);
		int pos = 0;
		//!!!!!!!!!!!PODE DAR MERDA NOS INDICES!!!!!!!!!!!!!
		Elemento<Coordenada> *it_lista = pontosWindow->getHead();
		switch(lado){
		case(1):{
			while(!igual(it_lista->info->getX(),-1) || !igual(it_lista->info->getY(),-1)){//busca como referência o ponto A
				it_lista = it_lista->_next;
				pos++;
			}
			while(igual(it_lista->info->getX(),-1) && igual(it_lista->info->getY(),-1)){//para caso hajam pontos A além da referência
				it_lista = it_lista->_next;
				pos++;
			}
			while(it_lista->info->getY()<ponto.getY()){//busca em ordem crescente
				it_lista = it_lista->_next;
				pos++;
			}
			pontosWindow->adicionaNaPosicao(ponto, pos);
			return;
		}
		case(2):{
			while(!igual(it_lista->info->getX(),-1) || !igual(it_lista->info->getY(),1)){//busca como referência o ponto B
				it_lista = it_lista->_next;
				pos++;
			}
			while(igual(it_lista->info->getX(),-1) && igual(it_lista->info->getY(),1)){//busca como referência o ponto B
				it_lista = it_lista->_next;
				pos++;
			}
			while(it_lista->info->getX()<ponto.getX()){//busca em ordem crescente
				it_lista = it_lista->_next;
				pos++;
			}
			pontosWindow->adicionaNaPosicao(ponto, pos);
			return;
		}
		case(3):{
			while(!igual(it_lista->info->getX(),1) || !igual(it_lista->info->getY(),1)){//busca como referência o ponto C
				it_lista = it_lista->_next;
				pos++;
			}
			while(igual(it_lista->info->getX(),1) && igual(it_lista->info->getY(),1)){//busca como referência o ponto C
				it_lista = it_lista->_next;
				pos++;
			}
			while(it_lista->info->getY()>ponto.getY()){//busca em ordem crescente
				it_lista = it_lista->_next;
				pos++;
			}
			pontosWindow->adicionaNaPosicao(ponto, pos);
			return;
		}
		case(4):{
			while(!igual(it_lista->info->getX(),1) || !igual(it_lista->info->getY(),-1)){//busca como referência o ponto D
				it_lista = it_lista->_next;
				pos++;
			}
			while(igual(it_lista->info->getX(),1) && igual(it_lista->info->getY(),-1)){//busca como referência o ponto D
				pos++;
				if(pos==pontosWindow->getSize()){
					pontosWindow->adiciona(ponto);
					return;
				}
				it_lista = it_lista->_next;
			}
			while(it_lista->info->getX()>ponto.getX()){//busca em ordem crescente
				it_lista = it_lista->_next;
				pos++;
				if(pos==pontosWindow->getSize()){
					pontosWindow->adiciona(ponto);
					return;
				}
			}
			pontosWindow->adicionaNaPosicao(ponto, pos);
			return;
		}
		}
	}