opengl: csgl y the tao framework en csharp

Reflexion con respecto al eje X, Y y al centro

Escrito por opengl 17-03-2009 en General. Comentarios (1)
Lo primero que debemos hacer es descargar la bibliteca de clases de csgl para despues crear una aplicacion de windows forms.
teniendo la biblioteca, hacemos referencia hacia ella y agregamos los espacios de nombre:
Imports CsGL.OpenGL
Imports CsGL.Util
y tambien crearemos otra clase pero esta debe derivar de OpenGLControl
ejemplo:
Public Class pintar
    Inherits CsGL.OpenGL.OpenGLControl
'tambien debemos sobreescribir el metodo
       Public Overrides Sub glDraw()
''aqui van los dibujos
       End Sub
End Class
El ejemplo completo se los dejo [HTML]http://www.bienpagado.com/bux/register.php?r=jesusamigable[/HTML] aqui , revisen el codigo.
El programa corriendo queda asi:


hasta luego



Tutoriales opengl

Escrito por opengl 27-02-2009 en General. Comentarios (1)
Tutoriales de opengl(en ingles)

aqui

opengl dibujar circulo

Escrito por opengl 26-02-2009 en General. Comentarios (0)
Creamos un nuevo proyecto de consola en c# y agregamos las refrencias de Tao.FreeGlut y Tao.OpenGl, en el main escribir el siguiente codigo:
 Console.WriteLine("introduzca x");
            xc = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca y");
            yc = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("introduzca r");
            r = Convert.ToDouble(Console.ReadLine());
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
            Glut.glutInitWindowSize(500, 500);
            Glut.glutCreateWindow("**************Circulo**************");
            Glut.glutDisplayFunc(circulo);

            Glut.glutMainLoop();
Creamos el metodo circulo:
 public static void circulo()
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
            Gl.glColor3f(0.6F, 0.6F, 0.6F);
            Gl.glLoadIdentity();
            Gl.glPointSize(5f);
           
            Gl.glBegin(Gl.GL_POINTS);
           
            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;
            }
//mandar los puntos
            circuloAlgoritmo(xc, yc,r);
            Gl.glEnd();
        }
Creamos el metodo circuloAlgoritmo:
public static void circuloAlgoritmo(double xc, double yc, double r)
        {
           
            double x = 0;
            double y = r;
            double p = 0.1f - r;
            pintar(xc, yc, x, y);
            while (x < y)
            {
                x+=.1f;
                if (p < 0)
                    p += .2f * x + .1f;
                else
                {
                    y-=.1f;
                    p += .2f * (x - y) + .1f;
                }
                pintar(xc, yc, x, y);
            }
        }
Creamos el metodo pintar:
public static void pintar(double xc, double yc, double x, double y)
        {
            Gl.glColor3f(1f, .6f, 1f);
            Gl.glVertex2d(xc + x, yc + y);
            Gl.glVertex2d(xc - x, yc + y);
            Gl.glVertex2d(xc + x, yc - y);
            Gl.glVertex2d(xc - x, yc - y);
            Gl.glColor3d(0f, .6f, 1f);
            Gl.glVertex2d(xc + y, yc + x);
            Gl.glVertex2d(xc - y, yc + x);
            Gl.glVertex2d(xc + y, yc - x);
            Gl.glVertex2d(xc - y, yc - x);

          
        }

si corremos el programa nos mostrará algo asi:



el ejemplo de pueden descargar desde aqui

nota:vean el post del algoritmo DDA para la biblioteca

contacto:



Mono y The Tao Framework

Escrito por opengl 23-02-2009 en General. Comentarios (1)
Para quien le guste desarrollar programas en linux, aqui les dejo un pequeño tutorial para que puedan empezar a programar ahi.



Descargar



Nota:Los programas que involucran The Tao Framework hechos en c# tambien pueden correrse en mono.
si no sirven los links de descarga por favor notificarme

algoritmo de Bresenham con opengl y c#

Escrito por opengl 22-02-2009 en General. Comentarios (0)
Crear un proyecto en c# en consola y agregar las referencias de Tao.opengl.dll y tao.Freeglut.dll , declarar variables globales:
static double x1, y1, x2, y2;
en el metodo main escribir el siguiente codigo:

 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());

            //inicializar todo esto para tao opengl
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);
            Glut.glutInitWindowSize(640, 480);
            Glut.glutCreateWindow("**************Bresenham**************");
            //termina inicializacion de componentes tao opengl
            Glut.glutDisplayFunc(Bresen);
           
            Glut.glutMainLoop();
Creamos un metodo llamado Bresen y le agregamos el siguiente codigo:
 public static void Bresen()
        {
            //componentes necesarios
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
            Gl.glColor3f(0.6F, 0.6F, 0.6F);
            Gl.glLoadIdentity();

            Gl.glBegin(Gl.GL_POINTS);
            //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();
            Gl.glPointSize(5.0f);
            Gl.glColor3f(1.0f, 0.111f, 1.0f);
            BresenDibujar(x1, y1, x2, y2);
        }
Creamos otro metod llamado Bresendibujar donde se va a desarrollar el algoritmo de Bresenham

        public static void BresenDibujar(double x1,double y1,double x2,double y2)
        {
            double xinicial = x1, yinicial = y1, xfinal = x2, yfinal= y2, x=0, y=0;
            double deltax, deltay, constanteP,ultimo;
            deltax = Math.Abs( xfinal - xinicial);
            deltay =Math.Abs( yfinal - yinicial);
            constanteP = 2 * deltay - deltax;
            if (xinicial > xfinal)
            {
                x = xfinal;
                y = yfinal;
                ultimo = xinicial;
            }
            else
            {
                x = xinicial;
                y = yinicial;
                ultimo = xfinal;
            }
            Gl.glBegin(Gl.GL_POINTS);
            //Gl.glColor3f(1f, 1.0f, .5f);
            Gl.glVertex2d(x, y);
            while (x < ultimo)
            {
                x +=  .1;
                if (constanteP < 0)
                    constanteP +=2 * deltay;
                else
                {
                    y += .1;
                    constanteP += 2 * (deltay - deltax);
                }
                Gl.glVertex2d(x, y);
            }
            Gl.glEnd();
        }
presionamos F5 y veremos algo parecido a esto:



si desea ver el codigo fuente descarguelo aqui
es aconsejable leer el otro post de DDA para agregar y bajar librerias
si desean contactarme: