Vetor Vetor::m_escalar(const Vetor& vetor, const float escalar)
{
Vetor ret = vetor;
ret.m_escalar(escalar);
return ret;
}
void GLWidget::mouseReleaseEvent(QMouseEvent *event)
{
QGLWidget::mouseReleaseEvent(event);
if (!this->passaroEmMovimento)
{
return;
}
// Define que o pássaro parou de se movimentar por função do jogador
this->passaroEmMovimento = false;
// Define o uso do vetorFinal
Vetor vetorFinal = Vetor(event->x(), event->y());
// Calcula a magnitude entre os dois vetores
this->magnitudeLancamento = Vetor::magnitudeEntreVetores(
this->particulas[this->indicePassaro].getPosicaoInicial(), vetorFinal);
// Define a direção do lançamento
this->direcaoLancamento =
vetorFinal.getY() > this->particulas[this->indicePassaro].getPosicaoInicial().getY() ? 'C' : 'S';
// Calcula o ângulo
this->angulo = Vetor::anguloEntreVetores(this->particulas[this->indicePassaro].getPosicaoInicial(), vetorFinal,
this->magnitudeLancamento);
// A velocidade do lançamento vai ser 0.0005% da magniute
this->velocidadeLancamento = this->magnitudeLancamento * 0.00005;
this->atirado = true;
}
Vetor Vetor::normalizar(const Vetor& vetor)
{
Vetor ret = vetor;
ret.normalizar();
return ret;
}
void JogadorIA::tomaDecisao() {
float px, py;
Vetor i(1, 0);
Vetor j(0, 1);
Vetor d = (partida->getDisco()->getPos() - this->pos).versor() * maxvel;
Vetor dx = d.prodEscalar(i) * i;
Vetor dy = d.prodEscalar(j) * j;
Vetor b = partida->getDisco()->getVel();
Vetor by = b.prodEscalar(j) * j;
if (!area.bContem(partida->getDisco()->getPos())) {
px = 1.0;
py = -0.35;
}
else {
px = 1.0;
py = 0.4;
}
// se o disco estiver na frente
if (frente.prodEscalar(partida->getDisco()->getPos() - this->getPos()) > 0)
this->setVel(dx * px + dy * py); // antes era by * py
else // se o disco estiver atras
this->setVel(-dx * px + dy * py); // antes era by * py
// this->setVel((partida->getDisco()->getPos() - this->pos) * maxvel);
}
Vetor Vetor::operator%(const Vetor& b){
Vetor r = *this;
Vetor a = b;
Vetor prod = r.ProdutoVetorial( a );
return prod;
}
void viewOperations::assembleViewSystem(Vetor &v, Vetor &n, double d, double hx, double hy) {
Vetor Vortho = n.orthogonalize(v);
Vortho.normalize();
n.normalize();
Vetor U = n%Vortho;
double coords[4][4] = {{U.x_, U.y_, U.z_, 0.0},
{Vortho.x_, Vortho.y_, Vortho.z_, 0.0},
{n.x_, n.y_, n.z_, 0.0},
{0.0, 0.0, 0.0, 1.0}
};
this->camCoords_ = Matriz(coords);
this->d = d;
this->hx = hx;
this->hy = hy;
}
// Projeção desse vetor em B
//Proj = (U.V) . vetor V
// |V|²
Vetor Vetor::project(const Vetor b)
{
Vetor proj;
float dp = dot(b);
proj.x = (dp/b.dot(b)) * b.x;
proj.y = (dp/b.dot(b)) * b.y;
return proj;
}
std::vector<Vetor> screenOperations::normaisF(std::vector<Ponto> &pontosView, std::vector<int> &faces) {
std::vector<Vetor> normaisFace;
for (int i = 0; i < (int)faces.size(); i += 3) {
Ponto a = pontosView[faces[i]];
Ponto b = pontosView[faces[i+1]];
Ponto c = pontosView[faces[i+2]];
Ponto arr[3];
arr[0] = a;
arr[1] = b;
arr[2] = c;
//std::sort(arr, arr+3, cmpByY);
Vetor ba = arr[1] - arr[0];
ba.normalize();
Vetor ca = arr[2] - arr[0];
ca.normalize();
Vetor normal = ca%ba;
//std::cout << normal.x_ << " " << normal.y_ << " " << normal.z_ << std::endl;
normaisFace.push_back(normal);
}
return normaisFace;
}
double Vetor::distanciaPontoAReta(Vetor a, Vetor b) {
double dx = a.getX() - b.getX();
double dy = a.getY() - b.getY();
double t = ((x * dx + y * dy) - (b.getX() * dx + b.getY() * dy)) / (dx*dx + dy*dy);
Vetor g, q;
if(t < 0.0)t = 0.0; // para segmento
if(t > 1.0)t = 1.0; // para segmento
g.setX(dx * t + b.getX());
g.setY(dy * t + b.getY());
q.setX(g.getX() - x);
q.setY(g.getY() - y);
return q.getNorma();
}
std::vector<Vetor> screenOperations::normaisV(std::vector<Ponto> &pontosView, std::vector<int> &faces, int tam) {
std::vector<Vetor> normaisV;
std::vector< std::vector<int> > listaAdj = this->lista(pontosView, faces, tam);
std::vector<Vetor> normaisFace = this->normaisF(pontosView, faces);
std::cout << (int)normaisFace.size() << std::endl;
//std::cout << "oi" << std::endl;
//std::cout << listaAdj[0][0] << std::endl;
for (int i=0; i < (int)listaAdj.size(); ++i) {
//if((int)listaAdj[i].size()==0) std::cout << listaAdj[i].size() << std::endl;
Vetor normal = Vetor(0.0, 0.0, 0.0);
int aux = 0;
for (int j=0; j < (int)listaAdj.at(i).size(); ++j) {
//std::cout << "jota: " << j << "size: " << (int)listaAdj[i][j] << std::endl;
normal = normal + normaisFace.at(listaAdj[i][j]);
++aux;
}
//if(aux==0) std::cout << "AEUEAHUEAHUAEHAE" << std::endl;
normal = normal * (1.0/aux);
normal.normalize();
normaisV.push_back(normal);
}
std::cout << "saiu porra" << std::endl;
return normaisV;
}
Vetor screenOperations::phongShading(Vetor& normal,Ponto& objCoord) {
normal.normalize();
Vetor L = lightSourceView_ - objCoord;
L.normalize();
Vetor V = (objCoord - cameraCoordView_) * -1.0;
V.normalize();
double dotNL = normal*L;
double dotVN = V*normal;
Vetor R = ((normal*(2.0*(dotNL)))- L);
R.normalize();
double dotVR = V*R;
Vetor ambiental = Vetor(0.0, 0.0, 0.0);
Vetor difusa = Vetor(0.0, 0.0, 0.0);
Vetor especular = Vetor(0.0, 0.0, 0.0);
//calculo da componente ambiental
ambiental = Ia_ * ka_;
//se primeiro parametro for menor que segundo retorna 1
//se for igual retorna 0
//se for maior retorna 1
if(cmp(dotVN) == -1) normal = normal * -1;
if(cmp(dotNL) == 0 || cmp(dotNL) == 1) {
Vetor kronecker = Vetor(0.0,0.0,0.0);
kronecker.x_ = Od_.x_ * Il_.x_;
kronecker.y_ = Od_.y_ * Il_.y_;
kronecker.z_ = Od_.z_ * Il_.z_;
difusa = kronecker * (kd_ * dotNL);
if(cmp(dotVR) == 0 || cmp(dotVR) == 1) {
especular = Il_ * ks_ * pow(dotVR,alpha_);
}
}
Vetor corFinal = ambiental + difusa + especular;
return corFinal;
}
//interface
//_--_-__-_--_---__---_-___--__-_-_---__-__--__--__--____-_--___--_--__-_-
void observer_look(){
switch(modo_observacao){
case FREE_CAMERA:{
double cosphi = cos(phi_free);
double abscosphi = cosphi<0?-cosphi:cosphi;
gluLookAt(posicao_observador.x,posicao_observador.y,posicao_observador.z,
posicao_observador.x+abscosphi*cos(theta_free), posicao_observador.y+sin(phi_free), posicao_observador.z+abscosphi*sin(theta_free),
cos(phi_free+PI/2)*cos(theta_free),cos(phi_free),cos(phi_free+PI/2)*sin(theta_free) );
}break;
case FIRST:
case THIRD_SIDE:
case THIRD_UP:{
Vetor centro = planeta->get_coordenadas();
Vetor up;
posicao_observador = last_boid->get_coordenadas();
posicao_observador.rotacionar_em_y(-planeta->get_rotation());
posicao_observador.rotacionar_em_x(planeta->INCLINACAO_ROT);
if(modo_observacao == THIRD_SIDE){
posicao_observador.normalizar();
posicao_observador += produto_vetorial(posicao_observador, Vetor(0,cos(planeta->INCLINACAO_ROT),sin(planeta->INCLINACAO_ROT)));
up = last_boid->get_coordenadas();
up.rotacionar_em_y(-planeta->get_rotation());
up.rotacionar_em_x(planeta->INCLINACAO_ROT);
posicao_observador *= distancia_terceira_pessoa;
posicao_observador += centro;
centro += up;
} else if(modo_observacao == THIRD_UP){
posicao_observador.normalizar();
up = produto_vetorial(posicao_observador, Vetor(0,cos(planeta->INCLINACAO_ROT),sin(planeta->INCLINACAO_ROT)));
posicao_observador *= distancia_terceira_pessoa;
posicao_observador += centro;
} else {
up = posicao_observador;
Vetor velocidade = last_boid->get_velocidade();
velocidade.rotacionar_em_y(-planeta->get_rotation());
velocidade.rotacionar_em_x(planeta->INCLINACAO_ROT);
centro += posicao_observador + velocidade;
posicao_observador = centro - velocidade;
}
gluLookAt(posicao_observador.x,posicao_observador.y,posicao_observador.z,
centro.x,centro.y,centro.z,
up.x,up.y,up.z);
}break;
case GEO_ESTACIONARIA:{
double rotacao = planeta->get_rotation();
posicao_observador = Vetor(distancia_terceira_pessoa + planeta->RAIO,0,0);
posicao_observador.rotacionar_em_y(-rotacao + theta_geoestacionaria);
posicao_observador.rotacionar_em_x(planeta->INCLINACAO_ROT);
Vetor centro = planeta->get_coordenadas();
posicao_observador += centro;
gluLookAt(posicao_observador.x,posicao_observador.y,posicao_observador.z,
centro.x,centro.y,centro.z,
0,cos(planeta->INCLINACAO_ROT),sin(planeta->INCLINACAO_ROT));
}break;
}
//setando as strings do HUD
//os numeros são a quantidade de caracteres necessários definidos empiricamente
static char aux_xyz[3][12], aux_observado[21], aux_lider[17], aux_n_boids[11];
memset(aux_observado,0,21);
memset(aux_lider,0,17);
memset(aux_xyz,0,36);
memset(aux_n_boids,0,11);
sprintf(aux_n_boids, "%d Boids", planeta->boid_container.get_n_boids());
sprintf(aux_observado, "boid observado: %d", id_observado);
sprintf(aux_lider, "Lider: %d", lider_atual);
sprintf(aux_xyz[2],"X: %i",(int)posicao_observador.x);
sprintf(aux_xyz[1],"Y: %i",(int)posicao_observador.y);
sprintf(aux_xyz[0],"Z: %i",(int)posicao_observador.z);
_hud->set_string(string_n_boids, aux_n_boids);
_hud->set_string(string_lider, aux_lider);
_hud->set_string(string_boid_observado, aux_observado);
_hud->set_string(string_coordenadas, aux_xyz[0]);
_hud->set_string(string_coordenadas+1, aux_xyz[1]);
_hud->set_string(string_coordenadas+2, aux_xyz[2]);
}
void JogadorIA::setVel(const Vetor &v) {
if (v.norma() > maxvel)
vel = v.versor() * maxvel;
else
vel = v;
}
int main(){
//Cria Objeto
Vetor vet;
Vetor vet2(2, 40);
int menu = 0;
int elemento;
int nRepeticoes;
int posicao;
int recuperado;
while (menu != 6){
cout << endl << "Escolha uma das opcoes abaixo:" << endl;
cout << "1 - Para inserir um elemento no vetor." << endl;
cout << "2 - Para remover um elemento no vetor." << endl;
cout << "3 - Para recuperar um elemento no vetor." << endl;
cout << "4 - Para preencher o vetor com um determinado elemento." << endl;
cout << "5 - Para imprimir os elementos do vetor." << endl;
cout << "6 - Para Sair." << endl;
cin >> menu;
switch (menu) {
case 1:{
cout << "Digite o elemento que deseja inserir" << endl;
cin >> elemento;
if (vet.inserir(elemento))
cout << "Elemento " << elemento << ", inserido com sucesso!" << endl;
else
cout << "Nao foi possivel inserir o elemento, verifique se o vetor nao esta cheio" << endl;
break;
}
case 2:{
cout << "Digite o elemento que deseja remover" << endl;
cin >> elemento;
if (vet.remover(elemento))
cout << "Elemento " << elemento << ", removido com sucesso!" << endl;
else
cout << "Nao foi possivel encontrar o elemento ou vetor esta vazio!" << endl;
break;
}
case 3:{
cout << "Digite a posicao do elemento que deseja recuperar" << endl;
cin >> posicao;
recuperado = vet.recuperarElemento(posicao);
if (recuperado != -1)
cout << "Elemento recuperado foi o numero " << recuperado << "." << endl;
else
cout << "Nao foi possivel encontrar o elemento!" << endl;
break;
}
case 4:{
cout << "Digite o numero com o qual voce deseja preencher o vetor" << endl;
cin >> elemento;
cout << "Quantas repeticoes do elemento voce deseja?" << endl;
cin >> nRepeticoes;
vet.preencher(elemento, nRepeticoes);
break;
}
case 5:{
cout << "vet" << endl;
vet.imprimir();
break;
}
case 6:{
cout << "Bye!" << endl;
break;
}
default: {
cout << "Digite um numero valido" << endl;
break;
}
}// fim switch
}
return 0;
}
int Colisao::colisaoJogadorDisco(int j)
{
static bool antcol[2]; // estado anterior da colisao (true/false)
// Seja P o jogador e Q o disco.
// Seja P1 a posicao anterior e P2 a posicao atual (o mesmo vale para Q)
Vetor P1(jog[j]->getOldPos()), P2(jog[j]->getPos());
Vetor Q1(disco->getOldPos()), Q2(disco->getPos());
// Calcularemos agora as velocidades
Vetor VP = P2 - P1;
Vetor VQ = Q2 - Q1;
// Definindo variaveis para otimizar o calculo
Vetor A = P1 - Q1;
Vetor B = VP - VQ;
float A2 = A.prodEscalar(A);
float B2 = B.prodEscalar(B);
float AB = A.prodEscalar(B);
float AB2 = AB * AB;
// quadrado da distancia entre os centros
float d2 = pow(jog[j]->getRaio() + disco->getRaio(), 2);
float t; // tempo
// se ainda nao esta colidindo
if ((jog[j]->getPos() - disco->getPos()).norma() > jog[j]->getRaio() + disco->getRaio()) {
//LD fixes
float zero = 0.0f;
// Teste para verificar a nao-colisao
if (B == zero) // movimento relativo == 0
{ antcol[j] = false; return 0; } // nao houve colisao
// Teste para verificar a nao-colisao
if (A2 - AB2 / B2 > d2)
{ antcol[j] = false; return 0; } // nao houve colisao
// Teste para verificar a nao colisao
float raiz = AB2 - B2 * (A2 - d2);
if (raiz < 0)
{ antcol[j] = false; return 0; } // nao houve colisao
// tempo da colisao
t = (-(AB) - sqrt(raiz)) / B2;
// Teste para verificar a nao-colisao
if (!(t > 0 && t <= 1))
{ antcol[j] = false; return 0; } // nao houve colisao
// Verifica se ja houve colisao no instante anterior
if (antcol[j])
return 0;
// Atualiza posicoes para o instante de colisao
jog[j]->setPos(P1 + t * VP);
disco->setPos(Q1 + t * VQ);
}
else {
// Atualiza a posicao do disco (para ficar _fora_ do jog[j]->
Vetor normal = (disco->getPos() - jog[j]->getPos()).versor() * (disco->getRaio() + jog[j]->getRaio());
disco->setPos(jog[j]->getPos() + normal);
}
// normal (do disco para o jogador)
Vetor normal(jog[j]->getPos() - disco->getPos());
normal = (disco->getVel().prodEscalar(normal) / normal.prodEscalar(normal)) * normal; // projecao
// vetor tangente
Vetor tangente = disco->getVel() - normal;
// velocidade resultante (da disco)
disco->setVel(tangente - normal);
// afasta um pouco o disco do jogador
disco->setPos(disco->getPos() + disco->getVel().versor() * 3);
// Aumenta velocidade do disco (armengue)
Vetor v = disco->getVel().versor();
if (v.norma() == 0)
v = jog[j]->getVel().versor() * 10.0;
disco->setVel(disco->getVel() + v * 2.0);
antcol[j] = true;
return 1;
}
Vetor projecao_ortogonal(Vetor v, Vetor w){
return (produto_escalar(v,w)/w.norma()/w.norma())*w;
}
void Vetor::operator =(Vetor v) {
this->x = v.getX();
this->y = v.getY();
}
