public SegmentoReta(char rotulo, Objeto paiRef, Ponto4D a, Ponto4D b) : base(rotulo, paiRef)
{
pOriginal1 = new Ponto4D(a);
pOriginal2 = new Ponto4D(b);
base.PontosAdicionar(a);
base.PontosAdicionar(b);
}
//TODO: não está considerando o NDC
protected override void OnMouseMove(MouseMoveEventArgs e)
{
mouseX = e.Position.X; mouseY = 600 - e.Position.Y; // Inversao eixo Y
if (mouseMoverPto && (objetoSelecionado != null))
{
int xPointClick = mouseX >= 300 ? mouseX - 300 : (300 - mouseX) * -1;
int yPointClick = mouseY >= 300 ? mouseY - 300 : (300 - mouseY) * -1;
double distancePoitsClick = (Math.Sqrt(Math.Abs((xPointClick * xPointClick) + (yPointClick * yPointClick)))) / 2;
if (distancePoitsClick <= this.circuloMaior.Radius)
{
this.centerCirculoMenor = new Ponto4D(xPointClick / 2, yPointClick / 2);
}
if ((Math.Abs(xPointClick / 2) > Math.Abs(this.retangulo.PtoInfEsq.Y) || Math.Abs(yPointClick / 2) > Math.Abs(this.retangulo.PtoInfEsq.Y)) && distancePoitsClick < this.circuloMaior.Radius)
{
this.colorRetangulo = Color.Blue;
}
else if (Math.Abs(distancePoitsClick) >= this.circuloMaior.Radius)
{
this.colorRetangulo = Color.Yellow;
}
else
{
this.colorRetangulo = Color.Red;
}
}
}
protected override void DesenharObjeto()
{
Ponto4D ponto1 = pontosLista[0];
Ponto4D ponto2 = pontosLista[1];
Ponto4D ponto3 = pontosLista[2];
Ponto4D ponto4 = pontosLista[3];
GL.Begin(PrimitivaTipo);
GL.Vertex2(ponto1.X, ponto1.Y);
for (double i = 0; i < quantidadePontos; i++)
{
double t = i / quantidadePontos;
Ponto4D p0 = FuncaoSpline(ponto1, ponto2, t);
Ponto4D p1 = FuncaoSpline(ponto2, ponto3, t);
Ponto4D p2 = FuncaoSpline(ponto3, ponto4, t);
Ponto4D p01 = FuncaoSpline(p0, p1, t);
Ponto4D p12 = FuncaoSpline(p1, p2, t);
Ponto4D resultado = FuncaoSpline(p01, p12, t);
GL.Vertex2(resultado.X, resultado.Y);
}
GL.Vertex2(ponto4.X, ponto4.Y);
GL.End();
}
protected override void DesenharObjeto()
{
this.Panterior = pontosLista[0];
Ponto4D P1P2;
Ponto4D P2P3;
Ponto4D P3P4;
Ponto4D P1P2P3;
Ponto4D P2P3P4;
Ponto4D P1P2P3P4;
for (var i = 0; i < this.quantidadePontos; i++)
{
P1P2 = Inter(pontosLista[0], pontosLista[1], i, 1);
P2P3 = Inter(pontosLista[1], pontosLista[2], i, 1);
P3P4 = Inter(pontosLista[2], pontosLista[3], i, 1);
P1P2P3 = Inter(P1P2, P2P3, i, 1);
P2P3P4 = Inter(P2P3, P3P4, i, 1);
P1P2P3P4 = Inter(P1P2P3, P2P3P4, i, 0);
GL.LineWidth(this.lineWidth);
GL.Begin(BeginMode.Lines);
GL.Color3(Color.Blue);
GL.Vertex2(this.Panterior.X, this.Panterior.Y);
GL.Vertex2(P1P2P3P4.X, P1P2P3P4.Y);
GL.End();
this.Panterior = P1P2P3P4;
}
}
private Ponto4D FuncaoSpline(Ponto4D pontoA, Ponto4D pontoB, double t)
{
double pontoX = pontoA.X + (pontoB.X - pontoA.X) * t;
double pontoY = pontoA.Y + (pontoB.Y - pontoA.Y) * t;
return(new Ponto4D(pontoX, pontoY));
}
/// <summary>
/// Atribui os valores xMax, xMin, yMax e yMin com o valores X e Y do ponto passado
/// </summary>
/// <param name="ponto">Ponto de referencia</param>
public void Atribuir(Ponto4D ponto)
{
this.xMax = ponto.X;
this.xMin = ponto.X;
this.yMax = ponto.Y;
this.yMin = ponto.Y;
}
/// <summary>
/// Atualiza se necessário os valores xMax, xMin, yMax e yMin com o valores X e Y do ponto passado
/// </summary>
/// <param name="ponto">Ponto de referencia</param>
public void Atualizar(Ponto4D ponto)
{
this.xMax = this.xMax < ponto.X ? ponto.X : this.xMax;
this.xMin = this.xMin > ponto.X ? ponto.X : this.xMin;
this.yMax = this.yMax < ponto.Y ? ponto.Y : this.yMax;
this.yMin = this.yMin > ponto.Y ? ponto.Y : this.yMin;
}
private void selecionarObjeto(double mouseX, double mouseY)
{
var ponto = new Ponto4D(mouseX, mouseY);
var dentroDaBBox = this.objetoSelecionado != null && this.objetoSelecionado.BBox.DentroDaArea(ponto);
if (this.objetoSelecionado != null && this.objetoSelecionado is Poligono && !this.movendoVertice && dentroDaBBox)
{
this.movendoVertice = true;
((Poligono)this.objetoSelecionado).SelecionarVertice(ponto);
return;
}
else if (this.objetoSelecionado != null && this.objetoSelecionado is Poligono && this.movendoVertice && dentroDaBBox)
{
this.movendoVertice = false;
((Poligono)this.objetoSelecionado).SetVerticeSelecionado(null);
return;
}
this.objetoSelecionado = null;
foreach (Objeto objeto in this.objetosLista)
{
if (objeto is Poligono)
{
var aux = ((Poligono)objeto).GetObjetoSelecao(ponto);
if (aux != null)
{
this.objetoSelecionado = aux;
break;
}
}
}
}
public Retangulo(string rotulo, Objeto paiRef, Ponto4D ptoInfEsq, Ponto4D ptoSupDir) : base(rotulo, paiRef)
{
base.PontosAdicionar(ptoInfEsq);
base.PontosAdicionar(new Ponto4D(ptoSupDir.X, ptoInfEsq.Y));
base.PontosAdicionar(ptoSupDir);
base.PontosAdicionar(new Ponto4D(ptoInfEsq.X, ptoSupDir.Y));
}
/// <summary>
/// Método que calcula a distância entre o vértice atual e o novo vértice.
/// </summary>
/// <param name="pontoAtual"></param>
/// <param name="pontoNovo"></param>
/// <returns> Retorna a distância entre os dois pontos.</returns>
private double CalcularDistancia(Ponto4D pontoAtual, Ponto4D pontoNovo)
{
double a = (pontoNovo.X - pontoAtual.X);
double b = (pontoNovo.Y - pontoAtual.Y);
double disctancia = Math.Sqrt(Math.Pow(a, 2) + Math.Pow(b, 2));
return(disctancia);
}
public Ponto(string rotulo, Objeto paiRef, Ponto4D ponto, int tamanho = 15) : base(rotulo, paiRef)
{
PrimitivaTamanho = tamanho;
base.PrimitivaTipo = PrimitiveType.Points;
base.PontosAdicionar(ponto);
this.ponto = ponto;
cor = Color.Black;
}
public Circulo(string rotulo, Objeto paiRef, Ponto4D pontoCentral, int raioCirculo, int qtdPontos = 72, PrimitiveType primitivo = PrimitiveType.Points) : base(rotulo, paiRef)
{
base.PrimitivaTipo = primitivo;
PontoCentral = pontoCentral;
RaioCirculo = raioCirculo;
Pontos = qtdPontos;
GerarPontos(pontoCentral, raioCirculo, qtdPontos);
}
/// <summary>
/// Retorna o deslocamento ++
/// </summary>
/// <param name="sourcePoint"></param>
/// <param name="targetPoint"></param>
/// <returns></returns>
private Ponto4D GetDesloc(Ponto4D sourcePoint, Ponto4D targetPoint)
{
var transformedPoint = this.transformacao.transformPoint(sourcePoint);
var result = new Ponto4D();
result.X = sourcePoint.X + targetPoint.X - transformedPoint.X;
result.Y = sourcePoint.Y + targetPoint.Y - transformedPoint.Y;
return(result);
}
public SegReta(string rotulo, Objeto paiRef, Ponto4D ponto1, Ponto4D ponto2) : base(rotulo, paiRef)
{
base.PrimitivaTipo = PrimitiveType.Lines;
base.PontosAdicionar(ponto1);
base.PontosAdicionar(ponto2);
Ponto1 = ponto1;
Ponto2 = ponto2;
}
public Ponto4D transformPoint(Ponto4D pto)
{
Ponto4D pointResult = new Ponto4D(
matriz[0] * pto.X + matriz[4] * pto.Y + matriz[8] * pto.Z + matriz[12] * pto.W,
matriz[1] * pto.X + matriz[5] * pto.Y + matriz[9] * pto.Z + matriz[13] * pto.W,
matriz[2] * pto.X + matriz[6] * pto.Y + matriz[10] * pto.Z + matriz[14] * pto.W,
matriz[3] * pto.X + matriz[7] * pto.Y + matriz[11] * pto.Z + matriz[15] * pto.W);
return(pointResult);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
Console.WriteLine(" --- Ajuda / Teclas: ");
Console.WriteLine(" [ H ] mostra teclas usadas. ");
GL.ClearColor(Color.Gray);
centerCirculoMenor = new Ponto4D(0, 0);
this.circuloMaior = new Circulo(null, null, Color.Black, 3, 1, 100, new Ponto4D(0, 0), BeginMode.LineLoop);
colorRetangulo = Color.Red;
}
public Retangulo(string rotulo, Objeto paiRef, Ponto4D ptoInfEsq, Ponto4D ptoSupDir, Color color, int lineWidth) : base(rotulo, paiRef, BeginMode.LineLoop)
{
this.ptoInfEsq = ptoInfEsq;
this.ptoSupDir = ptoSupDir;
this.lineWidth = lineWidth;
this.color = color;
base.PontosAdicionar(ptoInfEsq);
base.PontosAdicionar(new Ponto4D(ptoSupDir.X, ptoInfEsq.Y));
base.PontosAdicionar(ptoSupDir);
base.PontosAdicionar(new Ponto4D(ptoInfEsq.X, ptoSupDir.Y));
}
public static void dynamicLine(Ponto4D ponto4DBase, Color color, int size, int rotationGrados)
{
GL.Color3(color);
GL.Begin(PrimitiveType.Lines);
GL.Vertex2(ponto4DBase.X, ponto4DBase.Y);
double degInRad = rotationGrados * 3.1416 / 180;
GL.Vertex2(Math.Cos(degInRad) * size + ponto4DBase.X, Math.Sin(degInRad) * size + ponto4DBase.Y);
GL.End();
}
public Ponto4D getVertice(Ponto4D ponto)
{
foreach (Ponto4D pontoPoligono in base.pontosLista)
{
if (pontoPoligono.X == ponto.X && pontoPoligono.Y == ponto.Y)
{
return(pontoPoligono);
}
}
return(null);
}
public Spline(string rotulo, Objeto paiRef, Ponto4D ponto1, Ponto4D ponto2, Ponto4D ponto3, Ponto4D ponto4, int quantidadePontos) : base(rotulo, paiRef)
{
PrimitivaTipo = PrimitiveType.LineStrip;
base.PontosAdicionar(ponto1);
base.PontosAdicionar(ponto2);
base.PontosAdicionar(ponto3);
base.PontosAdicionar(ponto4);
this.quantidadePontos = quantidadePontos;
}
private void GerarPontos(Ponto4D pontoCentral, int raioCirculo, int qtdPontos)
{
base.PontosRemoverTodos();
for (int i = 0; i < qtdPontos; i++)
{
var angulo = (qtdPontos == 72 ? i * 5 : i / 2);
Ponto4D pontoCirculo = Matematica.GerarPtosCirculo(angulo, raioCirculo);
Ponto4D pontoFinal = new Ponto4D(pontoCirculo.X + pontoCentral.X, pontoCirculo.Y + pontoCentral.Y, 0);
base.PontosAdicionar(pontoFinal);
}
}
public Circulo(string rotulo, Objeto paiRef, Color color, int lineWith, int lineStrip, int radius, Ponto4D center, BeginMode beginMode) : base(rotulo, paiRef, beginMode)
{
this.center = center;
this.radius = radius;
this.lineWith = lineWith;
this.color = color;
for (int i = 0; i < 360; i = i + lineStrip)
{
double degInRad = i * 3.1416 / 180;
base.PontosAdicionar(new Ponto4D(Math.Cos(degInRad) * radius + center.X, Math.Sin(degInRad) * radius + center.Y));
}
}
protected override void OnRenderFrame(FrameEventArgs e)
{
base.OnRenderFrame(e);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
Matrix4 modelview = Matrix4.LookAt(camera.Eye, camera.At, camera.Up);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref modelview);
#if CG_Gizmo
Sru3D();
#endif
for (var i = 0; i < objetosLista.Count; i++)
{
objetosLista[i].Desenhar();
}
if (bBoxDesenhar && (objetoSelecionado != null))
{
objetoSelecionado.BBox.Desenhar();
}
Transformacao4D tr = new Transformacao4D();
tr.AtribuirEscala(50, 50, 50);
Ponto4D pt = new Ponto4D(0, 0, 0);
GL.LineWidth(5);
GL.Color3(0, 0, 0);
GL.Begin(PrimitiveType.LineLoop);
for (var i = 0; i < movimentos.Count; i++)
{
for (var j = 0; j < qtMovimentos[i]; j++)
{
Ponto4D pt2 = tr.MultiplicarPonto(pt);
GL.Vertex3(pt2.X, pt2.Y, pt2.Z);
tr = tr.MultiplicarMatriz(movimentos[i]);
}
}
GL.End();
objetoSelecionado.Matriz = objetoSelecionado.Matriz.MultiplicarMatriz(this.movimentos[i]);
j++;
if (j >= this.qtMovimentos[i])
{
i++;
j = 0;
if (i >= this.movimentos.Count)
{
i = 0;
}
}
this.SwapBuffers();
}
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();
}
/// <summary>
/// Encontra o vertice mais proximo em relação ao ponto passado
/// </summary>
/// <param name="ponto">Ponto de referencia</param>
/// <returns>
/// O vertice mais proximo encontrado
/// </returns>
private Ponto4D GetVerticeMaisProximo(Ponto4D ponto)
{
Ponto4D maisProximo = null;
foreach (Ponto4D vertice in base.pontosLista)
{
if (maisProximo == null || this.GetDistancia(maisProximo, ponto) > this.GetDistancia(vertice, ponto))
{
maisProximo = vertice;
}
}
return(maisProximo);
}
public Spline(char rotulo, Objeto paiRef, int quantidadePontos, Ponto4D a, Ponto4D b, Ponto4D c, Ponto4D d) : base(rotulo, paiRef)
{
qtdPontosOriginal = quantidadePontos;
qtdPontos = quantidadePontos;
pOriginal1 = new Ponto4D(a);
pOriginal2 = new Ponto4D(b);
pOriginal3 = new Ponto4D(c);
pOriginal4 = new Ponto4D(d);
base.PontosAdicionar(a);
base.PontosAdicionar(b);
base.PontosAdicionar(c);
base.PontosAdicionar(d);
}
/// <summary>
/// Método que permite remover o vértice selecionado.
/// </summary>
private void RemoverPontoSelecionado()
{
if (objetoSelecionado != null && pontoSelecionado != null)
{
objetoSelecionado.RemoverPonto(pontoSelecionado);
if (objetoSelecionado.QuantidadePontos() == 1)
{
objetosLista.Remove(objetoSelecionado);
objetoSelecionado = null;
pontoSelecionado = null;
bBoxDesenhar = false;
}
}
}
