O controlo a utilizar responde pelo nome de SharpGL.
A versão atual do controlo inclui modelos de aplicações que podem ser instalados diretamente na versão 2010 do Visual C#, incluindo a versão Express.
Depois de instalado o SharpGL basta escolher o tipo de aplicação pretendida: Windows Forms ou WPF.
A partir daqui podemos gravar o projeto criado e abri-lo na versão 2012 do Visual Studio.
De seguida é possível exportar o projeto a partir do Visual Studio 2012 como um Template para que se possam criar mais projetos sem ser necessário voltar ao Visual C# 2010.
Esta opção abre um Wizard que passo a passo permite gerar o Template na Versão 2012 do Visual Studio.
O modelo agora criado apresenta código que permite gerar uma pirâmide 3D a rodar com cores diferentes entre os vertices.
O controlo gera automaticamente três métodos/funções:
- openGLControl_OpenGLDraw
- openGLControl_OpenGLInitialized
- openGLControl_Resized
A função openGLControl_OpenGLInitialized é chamada uma vez quando o controlo é inicializado em conjunto com a janela da aplicação. Aqui devemos colocar o código que necessita de ser executado uma só vez como por exemplo a definição de valores iniciais de objetos a utilizar no programa.
A função openGLControl_Resized é chamada sempre que o controlo é redimensionado, por força da alteração do tamanho da janela ou da alteração da resolução do ecrã.
Por fim a função openGLControl_OpenGLDraw controla o evento de redesenhar o controlo, portanto a cena tridimensional. Será nesta função que vamos colocar o código que faz aparecer os objetos do nosso programa.
OpenGL
Hoje em dia os programas 3D utilizam um método de desenho baseado em Shaders. Neste artigo vamos abordar o chamado método imediato de desenho 3D, sem shaders, por ser mais simples de implementar.
Para começar vamos definir algumas classes que mais tarde vão facilitar o nosso trabalho, especialmente quando estivermos a conceber uma aplicação já com alguma dimensão.
Classe Ponto - esta classe vai permitir definir um ponto no espaço 3D. Define três floats que representam as coordenadas dos três eixos (X,Y,Z).
Classe Objeto - esta classe representa um objeto 3D, nomeadamente as caraterísticas base do objeto, a origem, a rotação, a cor, a largura (para desenhar em wireframe) e a transparência (alpha).
Classe Triangulo - esta classe, tal como o nome indica, representa um triângulo, derivando a partir da classe objeto só temos de definir os vertices do triangulo (três pontos).
Com estas três classes já podemos criar algumas imagens interessantes.
Desenhar
O processo de desenhar com o OpenGL implica diversas operações matemáticas, as principais implicam passar as coordenadas que definem o objeto para as coordenadas que o colocam numa determinada posição no espaço do mundo 3D. Estas operações são realizadas através de cálculos matriciais. Para que os cálculos realizados para colocar um modelo no espaço não influenciem os restantes o estado deve ser guardado antes de iniciar o processo de desenho do objeto. Para isso deve-se guardar a matriz do espaço 3D antes de desenhar e no final do processo tornar a repor a matriz original. As funçãos PushMatrix e PopMatrix são utilizadas para essas operações, devendo ocorrer entre elas as operações de desenho.
gl.PushMatrix();
//desenhar
gl.PopMatrix();
O objeto gl é uma referência para o controlo colocado no formulário, esta referência deve ser passada para todas as funções de desenho das classes referidas.
Assim a função de desenho em wireframe (esqueleto) do triângulo fica assim:
//guardar o estado da matriz
gl.PushMatrix();
//desenhar
gl.Translate(origem.getX(), origem.getY(), origem.getZ());
gl.Rotate(rotacao.getX(), rotacao.getY(), rotacao.getZ());
gl.Color(cor.getX(), cor.getY(), cor.getZ());
gl.LineWidth(largura);
//vertice 1 ao 2
gl.Begin(OpenGL.GL_LINES);
gl.Vertex(p1.getX(), p1.getY(), p1.getZ());
gl.Vertex(p2.getX(), p2.getY(), p2.getZ());
gl.End();
//vertice 2 ao 3
gl.Begin(OpenGL.GL_LINES);
gl.Vertex(p2.getX(), p2.getY(), p2.getZ());
gl.Vertex(p3.getX(), p3.getY(), p3.getZ());
gl.End();
//vertice 3 ao 1
gl.Begin(OpenGL.GL_LINES);
gl.Vertex(p3.getX(), p3.getY(), p3.getZ());
gl.Vertex(p1.getX(), p1.getY(), p1.getZ());
gl.End();
//repor a matriz
gl.PopMatrix();
Primeiro fazemos uma translação, que na prática significa mover o objeto para a sua origem, depois uma rotação, de seguida definimos a cor de desenho e a largura da linha a desenhar.
A função de desenho utilizada no OpenGL necessita de dois pontos, o inicial e final que no caso do nosso triângulo são os vértices.
Para que o código funcione a classe Ponto deve implementar três funções públicas que devolvem as coordenadas de cada eixo (getX, getY, getZ).
O resultado ainda não é espetacular mas é um bom começo:
No próximo artigo vamos passar para a fase em que o triângulo será desenhado com uma textura, para além de uma função para importar objetos 3D desenhados a partir do Blender.
O projeto pode ser picado aqui.
Sem comentários:
Enviar um comentário