public void translacaoXYZ(double tx, double ty, double tz)
{
Transformacao4D matrizTranslate = new Transformacao4D();
matrizTranslate.atribuirTranslacao(tx, ty, tz);
matriz = matrizTranslate.transformMatrix(matriz);
}
public void escalaXYZ(double Sx, double Sy)
{
Transformacao4D matrizScale = new Transformacao4D();
matrizScale.atribuirEscala(Sx, Sy, 1.0);
matriz = matrizScale.transformMatrix(matriz);
}
private void pushMove(float x, float y, float z, int qt)
{
Transformacao4D tr = new Transformacao4D();
tr.AtribuirTranslacao(x / 3, y / 3, z / 3);
this.movimentos.Add(tr);
this.qtMovimentos.Add(qt * 3);
}
/// <summary>
/// efetua a translação do poligono e atualiza a bbox
/// </summary>
/// <param name="translX"></param>
/// <param name="translY"></param>
public void Translation(double translX, double translY)
{
var transl = new Transformacao4D();
transl.atribuirTranslacao(translX, translY, 0);
this.transformacao = transl.transformMatrix(this.transformacao);
this.UpdateBBox();
}
public Transformacao4D transformMatrix(Transformacao4D t)
{
Transformacao4D result = new Transformacao4D();
for (int i = 0; i < 16; ++i)
{
result.matriz[i] =
matriz[i % 4] * t.matriz[i / 4 * 4] + matriz[(i % 4) + 4] * t.matriz[i / 4 * 4 + 1]
+ matriz[(i % 4) + 8] * t.matriz[i / 4 * 4 + 2] + matriz[(i % 4) + 12] * t.matriz[i / 4 * 4 + 3];
}
return(result);
}
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();
}
private void EyeRotate(float n)
{
Transformacao4D matA = new Transformacao4D();
matA.AtribuirTranslacao(camera.At.X, camera.At.Y, camera.At.Z);
Transformacao4D matB = new Transformacao4D();
matB.AtribuirRotacaoY(n * Math.PI / 120);
matA = matA.MultiplicarMatriz(matB);
matB.AtribuirTranslacao(-1 * camera.At.X, -1 * camera.At.Y, -1 * camera.At.Z);
matA = matA.MultiplicarMatriz(matB);
this.camera.Eye = PontoToVector(matA.MultiplicarPonto(VectorToPonto(this.camera.Eye)));
}
public void rotacaoZPtoFixo(double angulo, Ponto4D ptoFixo)
{
matrizGlobal.atribuirIdentidade();
matrizTmpTranslacao.atribuirTranslacao(ptoFixo.X, ptoFixo.Y, ptoFixo.Z);
matrizGlobal = matrizTmpTranslacao.transformMatrix(matrizGlobal);
matrizTmpRotacao.atribuirRotacaoZ(Transformacao4D.DEG_TO_RAD * angulo);
matrizGlobal = matrizTmpRotacao.transformMatrix(matrizGlobal);
ptoFixo.inverterSinal();
matrizTmpTranslacaoInversa.atribuirTranslacao(ptoFixo.X, ptoFixo.Y, ptoFixo.Z);
matrizGlobal = matrizTmpTranslacaoInversa.transformMatrix(matrizGlobal);
matriz = matriz.transformMatrix(matrizGlobal);
}
public void escalaXYZPtoFixo(double escala, Ponto4D ptoFixo)
{
matrizGlobal.atribuirIdentidade();
matrizTmpTranslacao.atribuirTranslacao(ptoFixo.X, ptoFixo.Y, ptoFixo.Z);
matrizGlobal = matrizTmpTranslacao.transformMatrix(matrizGlobal);
matrizTmpEscala.atribuirEscala(escala, escala, 1.0);
matrizGlobal = matrizTmpEscala.transformMatrix(matrizGlobal);
ptoFixo.inverterSinal();
matrizTmpTranslacaoInversa.atribuirTranslacao(ptoFixo.X, ptoFixo.Y, ptoFixo.Z);
matrizGlobal = matrizTmpTranslacaoInversa.transformMatrix(matrizGlobal);
matriz = matriz.transformMatrix(matrizGlobal);
}
/// <summary>
/// Rotaciona o poligono ++
/// </summary>
/// <param name="degreeFactor"></param>
public void Rotate(double degreeFactor)
{
var translX = this.Bbox.centerX;
var translY = this.Bbox.centerY;
var originTrans = new Transformacao4D();
originTrans.atribuirTranslacao(translX, translY, 0);
var rotationTrans = new Transformacao4D();
rotationTrans.atribuirRotacaoZ(Transformacao4D.DEG_TO_RAD * degreeFactor);
var initialPositionTrans = new Transformacao4D();
initialPositionTrans.atribuirTranslacao(-translX, -translY, 0);
var result = originTrans.transformMatrix(rotationTrans);
result = result.transformMatrix(initialPositionTrans);
this.transformacao = result.transformMatrix(this.transformacao);
this.UpdateBBox();
}
/// <summary>
/// Altera a escala do poligono ++
/// </summary>
/// <param name="scale"></param>
public void Scale(double scale)
{
var translX = this.Bbox.centerX;
var translY = this.Bbox.centerY;
var originTrans = new Transformacao4D();
originTrans.atribuirTranslacao(translX, translY, 0);
var scaleTrans = new Transformacao4D();
scaleTrans.atribuirEscala(scale, scale, 1);
var initialPositionTrans = new Transformacao4D();
initialPositionTrans.atribuirTranslacao(-translX, -translY, 0);
var result = originTrans.transformMatrix(scaleTrans);
result = result.transformMatrix(initialPositionTrans);
this.transformacao = result.transformMatrix(this.transformacao);
this.UpdateBBox();
}
public void rotacaoZ(double angulo)
{
matrizTmpRotacao.atribuirRotacaoZ(Transformacao4D.DEG_TO_RAD * angulo);
matriz = matrizTmpRotacao.transformMatrix(matriz);
}
protected override void OnLoad(EventArgs e)
{
this.pushMove(1, 0, 0, 3);
Transformacao4D tr = new Transformacao4D();
Transformacao4D trAux = new Transformacao4D();
trAux.AtribuirTranslacao(0, 0.3, 0);
tr.AtribuirRotacaoX(Math.PI / 33);
this.movimentos.Add(trAux.MultiplicarMatriz(tr));
this.qtMovimentos.Add(33);
this.pushMove(1, 0, 0, 4);
this.movimentos.Add(trAux.MultiplicarMatriz(tr));
this.qtMovimentos.Add(33);
this.pushMove(1, 0, 0, 3);
this.pushMove(0, 0, 1, 10);
this.pushMove(0, 1, 0, 10);
this.pushMove(0, 0, -1, 10);
this.pushMove(-1, 0, 0, 10);
this.pushMove(0, -1, 0, 5);
tr = new Transformacao4D();
trAux = new Transformacao4D();
trAux.AtribuirTranslacao(0.3, 0, 0);
tr.AtribuirRotacaoY(Math.PI / 33);
this.movimentos.Add(trAux.MultiplicarMatriz(tr));
this.qtMovimentos.Add(33);
this.pushMove(0, 0, 1, 10);
this.pushMove(0, -1, 0, 5);
this.pushMove(1, 0, 0, 10);
this.pushMove(0, 0, -1, 10);
this.movimentos.Add(trAux.MultiplicarMatriz(tr));
this.qtMovimentos.Add(33);
this.pushMove(1, 0, 0, 10);
base.OnLoad(e);
Console.WriteLine(" --- Ajuda / Teclas: ");
Console.WriteLine(" [ H ] mostra teclas usadas. ");
// obj_Retangulo = new Retangulo("A", null, new Ponto4D(50, 50, 0), new Ponto4D(150, 150, 0));
// objetosLista.Add(obj_Retangulo);
// objetoSelecionado = obj_Retangulo;
// obj_Cilindro = new Cilindro("D", null);
// objetosLista.Add(obj_Cilindro);
// obj_Cilindro.EscalaXYZ(50, 50, 50);
// obj_Cilindro.TranslacaoXYZ(150, 0, 0);
// obj_Esfera = new Esfera("E", null);
// objetosLista.Add(obj_Esfera);
// obj_Esfera.EscalaXYZ(50, 50, 50);
// obj_Esfera.TranslacaoXYZ(200, 0, 0);
// obj_Cone = new Cone("F", null);
// objetosLista.Add(obj_Cone);
// obj_Cone.EscalaXYZ(50, 50, 50);
// obj_Cone.TranslacaoXYZ(250,0,0);
// obj_Cubo = new Cubo("G", null);
// objetosLista.Add(obj_Cubo);
// obj_Cubo.EscalaXYZ(50, 50, 50);
obj_Cubo = new Cubo("G", null);
objetosLista.Add(obj_Cubo);
obj_Cubo.EscalaXYZ(50, 50, 50);
objetoSelecionado = obj_Cubo;
camera.At = new Vector3(0, 0, 0);
camera.Eye = new Vector3(1000, 1000, 1000);
// camera.Eye = new Vector3(0, 0, 1000);
camera.Near = 100.0f;
camera.Far = 4000.0f;
GL.ClearColor(127, 127, 127, 255);
GL.Enable(EnableCap.DepthTest);
// GL.Enable(EnableCap.CullFace);
GL.Disable(EnableCap.CullFace);
}
protected override void OnKeyDown(OpenTK.Input.KeyboardKeyEventArgs e)
{
if (e.Key == Key.H)
{
Utilitario.AjudaTeclado();
}
else if (e.Key == Key.Escape)
{
Exit();
}
else if (e.Key == Key.E)
{
Console.WriteLine("--- Objetos / Pontos: ");
for (var i = 0; i < objetosLista.Count; i++)
{
Console.WriteLine(objetosLista[i]);
}
}
else if (e.Key == Key.O)
{
bBoxDesenhar = !bBoxDesenhar;
}
else if (e.Key == Key.Enter)
{
if (objetoNovo != null)
{
objetoNovo.PontosRemoverUltimo(); // N3-Exe6: "truque" para deixar o rastro
objetoSelecionado = objetoNovo;
objetoNovo = null;
}
}
else if (e.Key == Key.Space)
{
if (objetoNovo == null)
{
objetoNovo = new Poligono(objetoId + 1, null);
objetosLista.Add(objetoNovo);
objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY)); // N3-Exe6: "troque" para deixar o rastro
}
else
{
objetoNovo.PontosAdicionar(new Ponto4D(mouseX, mouseY));
}
}
else if (e.Key == Key.R)
{
if (!poligonoQualquer)
{
this.poligonoQualquer = true;
objetoNovo = new Poligono(objetoId + 1, null);
objetoNovo.setAberto(true);
objetoNovo.PontosAdicionar(new Ponto4D(this.mouseX, this.mouseY));
objetoNovo.PontosAdicionar(new Ponto4D(this.mouseX, this.mouseY));
this.objetosLista.Add(objetoNovo);
objetoSelecionado = objetoNovo;
}
else
{
this.poligonoQualquer = false;
objetoSelecionado = null;
objetoNovo.PontosRemoverUltimo();
objetoNovo = null;
}
}
else if (e.Key == Key.L)
{
//Pegar o último vertice e editar
if (this.objetoSelecionado != null && this.verticeMaisProximo == null)
{
Poligono poligonoSelecionado = (Poligono)this.objetoSelecionado;
List <Ponto4D> ponto4DsPoligono = poligonoSelecionado.getPontosPoligono();
int diferencaXSelecionado = 0;
int diferencaYSelecionado = 0;
foreach (Ponto4D pontoPoligono in ponto4DsPoligono)
{
int diferencaXCalculado = Math.Abs(Math.Abs(this.mouseX) - Math.Abs((int)pontoPoligono.X));
int diferencaYCalculado = Math.Abs(Math.Abs(this.mouseY) - Math.Abs((int)pontoPoligono.Y));
if (this.verticeMaisProximo == null || (diferencaXCalculado < diferencaXSelecionado && diferencaYCalculado < diferencaYSelecionado))
{
this.verticeMaisProximo = pontoPoligono;
diferencaXSelecionado = diferencaXCalculado;
diferencaYSelecionado = diferencaYCalculado;
}
}
}
else
{
this.objetoSelecionado = null;
this.verticeMaisProximo = null;
}
}
else if (e.Key == Key.T)
{
//Translação
Poligono poligono = (Poligono)this.objetoSelecionado;
Transformacao4D transformacao4D = poligono.Matriz;
double[] teste = transformacao4D.ObterDados();
this.translacaoX++;
this.translacaoY++;
teste[11] = this.translacaoX;
teste[12] = this.translacaoY;
teste[13] = this.translacaoY;
Console.Write("");
}
else if (e.Key == Key.Q)
{
//Encerrar
objetoNovo.PontosRemoverUltimo();
this.createDynamicPolygon = false;
objetoNovo = null;
objetoSelecionado = null;
}
else if (e.Key == Key.N)
{
if (!this.createDynamicPolygon)
{
this.createDynamicPolygon = true;
objetoSelecionado = null;
objetoNovo = new Poligono(objetoId + 1, null);
this.objetosLista.Add(objetoNovo);
objetoNovo.PontosAdicionar(new Ponto4D(this.mouseX, this.mouseY));
objetoNovo.PontosAdicionar(new Ponto4D(this.mouseX, this.mouseY));
objetoSelecionado = objetoNovo;
}
else
{
objetoNovo.PontosUltimo().X = mouseX;
objetoNovo.PontosUltimo().Y = mouseY;
objetoNovo.PontosAdicionar(new Ponto4D(this.mouseX, this.mouseY));
}
}
else if (objetoSelecionado != null)
{
if (e.Key == Key.M)
{
Console.WriteLine(objetoSelecionado.Matriz);
}
else if (e.Key == Key.P)
{
Console.WriteLine(objetoSelecionado);
}
else if (e.Key == Key.I)
{
objetoSelecionado.AtribuirIdentidade();
}
//TODO: não está atualizando a BBox com as transformações geométricas
else if (e.Key == Key.Left)
{
objetoSelecionado.TranslacaoXYZ(-10, 0, 0);
}
else if (e.Key == Key.Right)
{
objetoSelecionado.TranslacaoXYZ(10, 0, 0);
}
else if (e.Key == Key.Up)
{
objetoSelecionado.TranslacaoXYZ(0, 10, 0);
}
else if (e.Key == Key.Down)
{
objetoSelecionado.TranslacaoXYZ(0, -10, 0);
}
else if (e.Key == Key.PageUp)
{
objetoSelecionado.EscalaXYZ(2, 2, 2);
}
else if (e.Key == Key.PageDown)
{
objetoSelecionado.EscalaXYZ(0.5, 0.5, 0.5);
}
else if (e.Key == Key.Home)
{
objetoSelecionado.EscalaXYZBBox(0.5, 0.5, 0.5);
}
else if (e.Key == Key.B)
{
if (!TRE)
{
TRE = true;
}
else
{
TRE = false;
}
}
else if (e.Key == Key.C)
{
if (!scale)
{
scale = true;
}
else
{
scale = false;
}
}
else if (e.Key == Key.X)
{
if (!this.rotatate)
{
this.rotatate = true;
}
else
{
this.rotatate = false;
}
}
else if (e.Key == Key.End)
{
objetoSelecionado.EscalaXYZBBox(2, 2, 2);
}
else if (e.Key == Key.Number1)
{
objetoSelecionado.Rotacao(10);
}
else if (e.Key == Key.Number2)
{
objetoSelecionado.Rotacao(-10);
}
else if (e.Key == Key.Number3)
{
objetoSelecionado.RotacaoZBBox(10);
}
else if (e.Key == Key.Number4)
{
objetoSelecionado.RotacaoZBBox(-10);
}
else if (e.Key == Key.Number9)
{
objetoSelecionado = null;
}
else if (e.Key == Key.Number5)
{
Poligono poligonoSelecionado = (Poligono)objetoSelecionado;
poligonoSelecionado.PrimitivaCor = OpenTK.Color.Red;
}
else if (e.Key == Key.Number6)
{
Poligono poligonoSelecionado = (Poligono)objetoSelecionado;
poligonoSelecionado.PrimitivaCor = OpenTK.Color.Green;
}
else if (e.Key == Key.Number7)
{
Poligono poligonoSelecionado = (Poligono)objetoSelecionado;
poligonoSelecionado.PrimitivaCor = OpenTK.Color.Blue;
}
else
{
Console.WriteLine(" __ Tecla não implementada.");
}
}
else
{
Console.WriteLine(" __ Tecla não implementada.");
}
}
