private Ponto4D gerarPonto(Ponto4D A, Ponto4D B, double t)
{
var xR = A.X + (B.X - A.X) * t;
var yR = A.Y + (B.Y - A.Y) * t;
return(new Ponto4D(xR, yR));
}
public void Desenhar()
{
GL.PointSize(10);
Ponto4D ultimoPonto = null;
for (var i = 0; i < this.pontos.Count; i++)
{
Ponto4D ponto = this.pontos[i];
GL.Begin(PrimitiveType.Points);
GL.Color3(i == this.pontoSelecionado ? Color.Red : Color.Black);
GL.Vertex2(ponto.X, ponto.Y);
GL.End();
if (ultimoPonto != null)
{
segReta = new SegReta($"{i}", new Ponto4D(ultimoPonto.X, ultimoPonto.Y), new Ponto4D(ponto.X, ponto.Y), Color.Cyan, 3);
segReta.Desenhar();
}
ultimoPonto = ponto;
}
this.DesenharSpline();
}
public void MoverPontoDeControle(Key key)
{
double deslocamentoX = 0;
double deslocamentoY = 0;
if (Key.C.Equals(key))
{
deslocamentoY = 1;
}
if (Key.B.Equals(key))
{
deslocamentoY = -1;
}
if (Key.E.Equals(key))
{
deslocamentoX = -1;
}
if (Key.D.Equals(key))
{
deslocamentoX = 1;
}
Ponto4D ponto = this.ObterPontoSelecionado();
ponto.X = ponto.X + deslocamentoX;
ponto.Y = ponto.Y + deslocamentoY;
this.pontosSpline = ObterSpline();
}
public Retangulo(string rotulo, Ponto4D ptoInfEsq, Ponto4D ptoSupDir) : base(rotulo)
{
this.ptoInfEsq = ptoInfEsq;
this.ptoSupDir = ptoSupDir;
GerarPtosRetangulo();
base.PontosAdicionar(ptoInfEsq);
base.PontosAdicionar(new Ponto4D(ptoSupDir.X, ptoInfEsq.Y));
}
private void DesenharSegReta(Ponto4D ponto1, Ponto4D ponto2, Color cor)
{
SegReta segReta1 = new SegReta("SR", null, ponto1, ponto2);
segReta1.PrimitivaTamanho = 5;
segReta1.ObjetoCor.CorR = cor.R; segReta1.ObjetoCor.CorG = cor.G; segReta1.ObjetoCor.CorB = cor.B;
objetosLista.Add(segReta1);
}
private void DesenharCirculo(Ponto4D pontoCentral, int raio, Color cor, int tamanho, int pontos = 72, PrimitiveType primitivo = PrimitiveType.Points)
{
Circulo circulo = new Circulo("C", null, pontoCentral, raio, pontos, primitivo);
circulo.ObjetoCor.CorR = cor.R; circulo.ObjetoCor.CorG = cor.G; circulo.ObjetoCor.CorB = cor.B;
circulo.PrimitivaTamanho = tamanho;
objetosLista.Add(circulo);
}
public SegReta(string rotulo, Ponto4D ponto, Ponto4D ponto2, Color cor, float primitivaTamanho, int angulo = 0) : base(rotulo, cor, primitivaTamanho)
{
matematica = new Matematica();
base.PontosAdicionar(ponto);
base.PontosAdicionar(ponto2);
this._angulo = angulo;
this._raio = 100;
}
private void SetaValoresIniciais()
{
qtdPontos = 5;
ponto = pontos.A;
A = new Ponto4D(x: -100, y: -100);
B = new Ponto4D(x: -100, y: 100);
C = new Ponto4D(x: 100, y: 100);
D = new Ponto4D(x: 100, y: -100);
}
public SegReta(string rotulo, Ponto4D ponto, Color cor, float primitivaTamanho, int angulo = 0) : base(rotulo, cor, primitivaTamanho)
{
this.ponto = ponto;
this._angulo = angulo;
this._raio = 100;
matematica = new Matematica();
ponto2 = matematica.GerarPtosCirculo(angulo, _raio, ponto);
base.PontosAdicionar(ponto);
base.PontosAdicionar(ponto2);
}
public void CameraTerra()
{
Ponto4D centro = terra.GetBBox().obterCentro;
Transformacao4D t = terra.GetMatriz();
centro = t.MultiplicarPonto(centro);
Vector3 v = new Vector3((float)centro.X, 0, (float)centro.Z);
camera.Eye = v;
}
private void DesenharSrPalito()
{
Ponto4D pontoCentral = new Ponto4D(0, 0, 0);
Ponto4D pontoFinal = PontoFinalBaseadoNoAngulo(pontoCentral, AnguloSrPalito, RaioSrPalito);
SrPalito = new SegReta("A", null, pontoCentral, pontoFinal);
SrPalito.ObjetoCor.CorR = 0; SrPalito.ObjetoCor.CorG = 0; SrPalito.ObjetoCor.CorB = 0;
SrPalito.PrimitivaTamanho = 5;
objetosLista.Add(SrPalito);
}
protected override void atualizarBbox()
{
this.bBox = new BBox();
Ponto4D primeiroPonto = this.pontosLista[0];
this.bBox.Atribuir(primeiroPonto);
foreach (Ponto4D ponto in this.pontosLista)
{
this.bBox.Atualizar(ponto);
}
}
private void AumentarAnguloSrPalito()
{
if (SrPalito == null)
{
return;
}
AnguloSrPalito++;
Ponto4D pontoFinal = PontoFinalBaseadoNoAngulo(SrPalito.Ponto1, AnguloSrPalito, RaioSrPalito);
SrPalito.Ponto2.X = pontoFinal.X;
SrPalito.Ponto2.Y = pontoFinal.Y;
}
private void DiminuirSrPalito()
{
if (SrPalito == null)
{
return;
}
RaioSrPalito--;
Ponto4D pontoFinal = PontoFinalBaseadoNoAngulo(SrPalito.Ponto1, AnguloSrPalito, RaioSrPalito);
SrPalito.Ponto2.X = pontoFinal.X;
SrPalito.Ponto2.Y = pontoFinal.Y;
}
public void PontosAdicionar(Ponto4D pto)
{
pontosLista.Add(pto);
if (pontosLista.Count.Equals(1))
{
base.BBox.Atribuir(pto);
}
else
{
base.BBox.Atualizar(pto);
}
base.BBox.ProcessarCentro();
}
private void DesenharTrianguloECirculos()
{
Ponto4D ponto1 = new Ponto4D(0, 100, 0);
Ponto4D ponto2 = new Ponto4D(-100, -100, 0);
Ponto4D ponto3 = new Ponto4D(100, -100, 0);
DesenharSegReta(ponto1, ponto2, Color.Cyan);
DesenharSegReta(ponto2, ponto3, Color.Cyan);
DesenharSegReta(ponto3, ponto1, Color.Cyan);
DesenharCirculo(ponto1, 100, Color.Black, 5);
DesenharCirculo(ponto2, 100, Color.Black, 5);
DesenharCirculo(ponto3, 100, Color.Black, 5);
}
protected override void atualizarBbox()
{
this.bBox = new BBox();
Vector4 v = pontosEsfera[0]._position;
Ponto4D primeiroPonto = new Ponto4D(v.X, v.Y, v.Z);
this.bBox.Atribuir(primeiroPonto);
foreach (TexturedVertex ponto in pontosEsfera)
{
v = ponto._position;
Ponto4D p = new Ponto4D(v.X, v.Y, v.Z);
this.bBox.Atualizar(p);
}
}
private void DesenharSpline()
{
Ponto4D ultimoPontoSpline = null;
foreach (Ponto4D pontoSpline in this.pontosSpline)
{
if (ultimoPontoSpline != null)
{
segReta = new SegReta("Spline", new Ponto4D(ultimoPontoSpline.X, ultimoPontoSpline.Y), new Ponto4D(pontoSpline.X, pontoSpline.Y), Color.Yellow, 3);
segReta.Desenhar();
}
ultimoPontoSpline = pontoSpline;
}
}
public void Restaurar()
{
Ponto4D deslocamento = new Ponto4D(_deslocamentoX, _deslocamentoY, 0);
double angulo = 0;
pontoQuadrado1.X = _deslocamentoX;
pontoQuadrado1.Y = _deslocamentoY - 3;
pontoQuadrado2.X = _deslocamentoX;
pontoQuadrado2.Y = _deslocamentoY + 3;
foreach (Ponto4D ponto in pontos)
{
var pontoNovo = matematica.GerarPtosCirculo(angulo, _raio, deslocamento);
ponto.X = pontoNovo.X;
ponto.Y = pontoNovo.Y;
angulo += _angulo;
}
}
private string TratarColisao(Ponto4D pontoQuadrado, Ponto4D pontoCirculoMaior, double raioCirculoMaior)
{
var boundBox = base.bBox;
if (pontoQuadrado.X > boundBox.obterMenorX || pontoQuadrado.X < boundBox.obterMaiorX || pontoQuadrado.Y > boundBox.obterMenorY || pontoQuadrado.Y < boundBox.obterMaiorY)
{
double x1 = pontoCirculoMaior.X, x2 = pontoQuadrado.X, y1 = pontoCirculoMaior.Y, y2 = pontoQuadrado.Y;
if (Math.Sqrt(Math.Pow(((x2 - x1)), 2) + Math.Pow(((y2 - y1)), 2)) > raioCirculoMaior)
{
return("Fora Completo");
}
return("Fora");
}
else
{
return("Dentro");
}
}
/// <summary>
/// Cria um círculo na cena
/// </summary>
/// <param name="raio">Raio</param>
/// <param name="cor">Cor dos pontos do círculo</param>
/// <param name="deslocamentoX">Caso necessário deslocar no eixo X utilziar um inteiro</param>
/// <param name="deslocamentoY">Caso necessário deslocar no eixo Y utilziar um inteiro</param>
/// <param name="primitivaTamanho">Tamanho dos pontos</param>
public Circulo(string rotulo, double raio, Color cor, int quantidadePontos = 72, int deslocamentoX = 0, int deslocamentoY = 0, int primitivaTamanho = 4, int angulo = 5)
: base(rotulo, cor, primitivaTamanho, PrimitiveType.Points)
{
_raio = raio;
_deslocamentoX = deslocamentoX;
_deslocamentoY = deslocamentoY;
_quantidadePontos = quantidadePontos;
_angulo = angulo;
pontoQuadrado1 = new Ponto4D(deslocamentoX, deslocamentoY - 3);
pontoQuadrado2 = new Ponto4D(deslocamentoX, deslocamentoY + 3);
segReta = new SegReta("Q", pontoQuadrado1, pontoQuadrado2, Color.Blue, 3);
pontoQuadrado1 = new Ponto4D(deslocamentoX, deslocamentoY - 3);
pontoQuadrado2 = new Ponto4D(deslocamentoX, deslocamentoY + 3);
segReta = new SegReta("Q", pontoQuadrado1, pontoQuadrado2, Color.Blue, 3);
GerarCirculo();
}
private void GerarCirculo()
{
double angulo = 0;
Ponto4D deslocamento = new Ponto4D(_deslocamentoX, _deslocamentoY, 0);
for (int i = 0; i < _quantidadePontos; i = i + 1)
{
var ponto = matematica.GerarPtosCirculo(angulo, _raio, deslocamento);
if (_angulosDesejados != null && _angulosDesejados.Count != 0 && (_angulosDesejados.FirstOrDefault(valor => valor == angulo) != 0))
{
var anguloD = _angulosDesejados.FirstOrDefault(valor => valor == angulo);
pontosDosAngulos.Add(ponto);
}
pontos.Add(ponto);
angulo += _angulo;
}
base.PontosAdicionar(pontos);
GL.End();
}
private void DesenharSpline()
{
Ponto4D ponto1 = new Ponto4D(-200, -200);
Ponto4D ponto2 = new Ponto4D(-200, 200);
Ponto4D ponto3 = new Ponto4D(200, 200);
Ponto4D ponto4 = new Ponto4D(200, -200);
pontoSpline1 = new Ponto("D", null, ponto1);
pontoSpline2 = new Ponto("E", null, ponto2);
pontoSpline3 = new Ponto("F", null, ponto3);
pontoSpline4 = new Ponto("G", null, ponto4);
objetosLista.Add(pontoSpline1);
objetosLista.Add(pontoSpline2);
objetosLista.Add(pontoSpline3);
objetosLista.Add(pontoSpline4);
SegReta segReta1 = new SegReta("A", null, ponto1, ponto2);
segReta1.PrimitivaTamanho = 5;
segReta1.DefinirCorPonto(0, Color.Black);
segReta1.ObjetoCor.CorR = 224; segReta1.ObjetoCor.CorG = 255; segReta1.ObjetoCor.CorB = 255;
objetosLista.Add(segReta1);
SegReta segReta2 = new SegReta("B", null, ponto2, ponto3);
segReta2.PrimitivaTamanho = 5;
segReta2.ObjetoCor.CorR = 224; segReta2.ObjetoCor.CorG = 255; segReta2.ObjetoCor.CorB = 255;
objetosLista.Add(segReta2);
SegReta segReta3 = new SegReta("C", null, ponto3, ponto4);
segReta3.PrimitivaTamanho = 5;
segReta3.ObjetoCor.CorR = 224; segReta3.ObjetoCor.CorG = 255; segReta3.ObjetoCor.CorB = 255;
objetosLista.Add(segReta3);
spline = new Spline("D", null, ponto1, ponto2, ponto3, ponto4, 10);
spline.PrimitivaTamanho = 5;
spline.ObjetoCor.CorR = 255; spline.ObjetoCor.CorG = 255; spline.ObjetoCor.CorB = 0;
objetosLista.Add(spline);
}
protected override void OnRenderFrame(FrameEventArgs e)
{
base.OnRenderFrame(e);
GL.Clear(ClearBufferMask.ColorBufferBit);
GL.MatrixMode(MatrixMode.Modelview);
GL.Color3(Color.Green);
GL.LineWidth(10);
GL.Begin(PrimitiveType.Lines);
GL.Vertex2(-250, 0);
GL.Vertex2(-250, -300);
GL.Color3(Color.Brown);
GL.Vertex2(0, -250);
GL.Vertex2(-300, -250);
GL.End();
Ponto4D pto = new Ponto4D(0, 0, 0, 1);
var bb = new BBox();
bb.Atribuir(pto);
bb.Desenhar();
this.SwapBuffers();
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
var segmentoRetaA = new SegReta("A", new Ponto4D(0, 20, 0), new Ponto4D(200, 20, 0), Color.Red, 3);
var segmentoRetaB = new SegReta("B", new Ponto4D(20, 0, 0), new Ponto4D(20, 200, 0), Color.Green, 3);
var angulosDesejados = new List <double>()
{
45, 135, 225, 315
};
circuloMaior = new Circulo("C", raioCirculoMaior, Color.Black, angulosDesejados, 360, 200, 200, 1, 1);
circuloMenor = new Circulo("C", 70, Color.Black, 360, 200, 200, 1, 1);
objetosLista.Add(circuloMenor.segReta);
Ponto4D ponto1 = circuloMaior.pontosDosAngulos[0];
Ponto4D ponto2 = circuloMaior.pontosDosAngulos[1];
Ponto4D ponto3 = circuloMaior.pontosDosAngulos[2];
Ponto4D ponto4 = circuloMaior.pontosDosAngulos[3];
corQuadrado = Color.Pink;
segmentoRetaQuadradoCima = new SegReta("p", ponto1, ponto2, corQuadrado, 1);
segmentoRetaQuadradoEsquerda = new SegReta("p", ponto2, ponto3, corQuadrado, 1);
segmentoRetaQuadradoBaixo = new SegReta("p", ponto3, ponto4, corQuadrado, 1);
segmentoRetaQuadradoDireita = new SegReta("p", ponto4, ponto1, corQuadrado, 1);
circuloMenor.DefinirBoundBox(ponto1, ponto3);
objetosLista.Add(segmentoRetaQuadradoCima);
objetosLista.Add(segmentoRetaQuadradoDireita);
objetosLista.Add(segmentoRetaQuadradoBaixo);
objetosLista.Add(segmentoRetaQuadradoEsquerda);
objetosLista.Add(segmentoRetaA);
objetosLista.Add(segmentoRetaB);
objetosLista.Add(circuloMenor);
objetosLista.Add(circuloMaior);
GL.ClearColor(Color.Gray);
}
public void DesenhaEsfera(double radius, int slices, int stacks, int textu)
{
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, textu);
GL.Color3(Color.White);
GL.Begin(PrimitiveType.Quads);
double stack = (2 * Math.PI) / stacks;
double slice = (2 * Math.PI) / slices;
for (double theta = 0; theta < 2 * Math.PI; theta += stack)
{
for (double phi = 0; phi < 2 * Math.PI; phi += slice)
{
Ponto4D p1 = getPoints(phi, theta, radius);
Ponto4D p2 = getPoints(phi + slice, theta, radius);
Ponto4D p3 = getPoints(phi + slice, theta + stack, radius);
Ponto4D p4 = getPoints(phi, theta + stack, radius);
double s0 = theta / (2 * Math.PI);
double s1 = (theta + stack) / (2 * Math.PI);
double t0 = phi / (2 * Math.PI);
double t1 = (phi + slice) / (2 * Math.PI);
GL.TexCoord2(s0, t0);
GL.Vertex3(p1.X, p1.Y, p1.Z);
GL.TexCoord2(s1, t0);
GL.Vertex3(p2.X, p2.Y, p2.Z);
GL.TexCoord2(s1, t1);
GL.Vertex3(p3.X, p3.Y, p3.Z);
GL.TexCoord2(s0, t1);
GL.Vertex3(p4.X, p4.Y, p4.Z);
}
}
GL.End();
GL.Disable(EnableCap.Texture2D);
}
public string Mover(Ponto4D distancia, Ponto4D pontoCirculoMaior, double raioCirculoMaior)
{
double angulo = 0;
var localizacao = TratarColisao(distancia, pontoCirculoMaior, raioCirculoMaior);
if (localizacao != "Fora Completo")
{
pontoQuadrado1.X = distancia.X;
pontoQuadrado1.Y = distancia.Y - 3;
pontoQuadrado2.X = distancia.X;
pontoQuadrado2.Y = distancia.Y + 3;
foreach (Ponto4D ponto in pontos)
{
var pontoNovo = matematica.GerarPtosCirculo(angulo, _raio, distancia);
ponto.X = pontoNovo.X;
ponto.Y = pontoNovo.Y;
angulo += _angulo;
}
}
return(localizacao);
}
public void DefinirBoundBox(Ponto4D pontoMin, Ponto4D pontoMax)
{
base.bBox.Atribuir(pontoMin, pontoMax);
}
protected override void OnKeyDown(OpenTK.Input.KeyboardKeyEventArgs e)
{
if (PontoSelecionado == null)
{
PontoSelecionado = A;
}
if (e.Key == Key.Escape)
{
Exit();
}
//Reinicia
if (e.Key == Key.R)
{
SetaValoresIniciais();
}
//Aumenta a quantidade de ponto da Spline
if (e.Key == Key.Plus || e.Key == Key.KeypadPlus)
{
qtdPontos++;
}
//Diminui a quantidade de ponto da Spline
if (e.Key == Key.Minus || e.Key == Key.KeypadMinus)
{
if (qtdPontos > 0)
{
qtdPontos--;
}
}
//Muda pontos
if (e.Key == Key.Number1 || e.Key == Key.Keypad1)
{
PontoSelecionado = A;
ponto = pontos.A;
}
if (e.Key == Key.Number2 || e.Key == Key.Keypad2)
{
PontoSelecionado = B;
ponto = pontos.B;
}
if (e.Key == Key.Number3 || e.Key == Key.Keypad3)
{
PontoSelecionado = C;
ponto = pontos.C;
}
if (e.Key == Key.Number4 || e.Key == Key.Keypad4)
{
PontoSelecionado = D;
ponto = pontos.D;
}
//Cima
if (e.Key == Key.C)
{
PontoSelecionado.Y++;
}
//Baixo
if (e.Key == Key.B)
{
PontoSelecionado.Y--;
}
//Direita
if (e.Key == Key.D)
{
PontoSelecionado.X++;
}
//Esquerda
if (e.Key == Key.E)
{
PontoSelecionado.X--;
}
}
public Ponto4D(Ponto4D pto)
{
this.x = pto.x;
this.y = pto.y;
this.z = pto.z;
}
