Linea DDA en C# Con Open GL

Hola chavos! Me da gusto saludarlos y que me acompañen a realizar más aplicaciones de graficación. El día de hoy vamos a continuar con aplicaciones en C#, vamos a volver a realizar la aplicación del algoritmo DDA para dibujar líneas pero ésta vez lo vamos a hacer utilizando las librerías de Open GL.

Lo primero que tenemos que hacer es descargar la aplicación taoframework (en mi caso estoy usando la versión 2.1.0). Lo instalamos normalmente dando "Next" a cada ventana que nos salga. Ahora creamos una nueva aplicación en consola en C#. Aun no podemos utilizar las librerías de Open GL sino que tenemos que agregar las referencias al nuestro proyecto, lo anterior lo hacemos abriendo el menú "Proyecto", luego "Agregar referencia...", después nos vamos a la pestaña "Examinar" y ahí buscamos la carpeta donde hayamos instalado el taoframework y en alguna de las carpetas buscamos los archivos "Tao.OpenGL.dll" y "Tao.FreeGlut.dll" y le damos clic a "Aceptar". Ahora tenemos que agregar los "using" para poder acceder a las clases de estas librerías, agregamos los siguientes "using" al final de los que están cargados por defecto:

using Tao.FreeGlut;
using Tao.OpenGl;

Ahora declaramos las siguientes variables de manera local:

static double x1, y1, x2, y2;

Ahora dentro del método Main() que es el principal de nuestra aplicación, escribimos el siguiente código:

static void Main(string[] args)
        {
            Console.WriteLine("introduzca el valor de X1");
            x1 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca el valor de Y1");
            y1 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca el valor de X2");
            x2 = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca el valor de Y2");
            y2 = Convert.ToDouble(Console.ReadLine());
            Glut.glutInit();//funciones propias de opengl
            Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
            Glut.glutInitWindowSize(640, 480);//creamos una ventana
            Glut.glutCreateWindow("**************Algoritmo DDA**************");//colocamos titulo a la ventana
            //llamamos a la funcion dda
            Glut.glutDisplayFunc(dda);
            Glut.glutMainLoop();
        }

Después declaramos un método estático llamado dda(), el cual dibujará unas líneas que dividirán la pantalla representando los 4 cuadrantes y llamará al método que dibujará la línea DDA:

public static void dda()
        {
            //componentes necesarios de opengl
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);//limpia el buffer de la pantall
            Gl.glColor3f(0.6F, 0.6F, 0.6F);//poner color a los pixeles
            Gl.glLoadIdentity();//''muy importante;
            Gl.glPointSize(0.5f);//medida de los puntos
            Gl.glBegin(Gl.GL_POINTS);//funcion para dibujar puntos
            //dibujando el plano
            float z = -1, w = 1, c = 0;
            for (int i = 0; i < 200; i++)
            {
                Gl.glColor3f(w, c, z);
                Gl.glVertex2d(z, 0);
                Gl.glVertex2d(0, w);
                z += .01f;
                w -= .01f;
                c += .1f;
            }
            Gl.glEnd();//termina funcion para dibujar puntos
            //pasamos las
            Gl.glPointSize(3.0f);//sirve para el tamaño de los pixeles
            Gl.glColor3f(1.0f, 0.0f, 0.0f);//sirve para el color de los pixeles
            ddaDibujar(x1, y1, x2, y2);
        }

Finalmente escribimos el método que contiene el algoritmo para dibujar la línea DDA en este caso el nombre del método es ddaDibujar() y el código es el siguiente:

public static void ddaDibujar(double x1, double y1, double x2, double y2)
        {
            double xinicial = x1, yinicial = y1, xfinal = x2, yfinal = y2, x, y;
            double deltax, deltay, xincremento, yincremento;
            double pasos;
            deltax = xfinal - xinicial;
            deltay = yfinal - yinicial;
            if (Math.Abs(deltax) > Math.Abs(deltay))
                pasos = Math.Abs(deltax);
            else
                pasos = Math.Abs(deltay);
            xincremento = (deltax / pasos) / 25;//10;
            yincremento = (deltay / pasos) / 25;// 10;
            x = xinicial;
            y = yinicial;
            Gl.glBegin(Gl.GL_POINTS);
            Gl.glVertex2d(x, y);//funcion que pinta un pixel en las coordenadas especificadas
            for (double k = .1; k <= pasos; k += .1)
            {
                x = (x + xincremento);
                y = (y + yincremento);
                Gl.glVertex2d(x, y);
            }
            Gl.glEnd();
            //termina dda
        }

Y eso es todo amigos, si instalaron bien el taoframework y agregaron bien las referencias de las librerías a la aplicación no deberían de tener problemas ya que el resto fue bastante sencillo ahora compilamos y corremos nuestra aplicación y nos saldrá una ventana de consola pidiendo los valores de x1, y1, x2 y y2, que serán las coordenadas iniciales y finales de la línea a dibujar:

Podemos teclear los valore que nosotros deseemos, tanto valores negativos como valores positivos ya que tenemos representados los 4 cuadrantes. En mi caso a manera de ejemplo colocaré las coordenadas de: 0, 0, 1, 1. La línea que me saldrá a mi estará representada en el primer cuadrante debido a que estoy utilizando solo valores positivos, aquí lo tenemos:

Y bien amigos pues eso es todo por esta ocasión, los espero en la próxima para ver más figuras que podemos graficar y las diferentes maneras que tenemos para hacerlo. La próxima semana regresaremos a realizar aplicaciones en C++ Builder que ha sido nuestra principal herramienta de programación a lo largo de este semestre. Hasta la próxima amigos!.