Oscar Gabriel Caballero Martínez - Gráficos por computadora usando JOGL

3. final GL2 gl = glad.getGL().getGL2(); // Se genera un objeto de tipo

3.1 // GL2

4. final GLU glu = new GLU(); // Se genera un objeto de tipo GLU

5. gl.glMatrixMode (GL2.GL_PROJECTION); // Se presenta el modo de

6. // Proyección

7. gl.glClearColor (1.0f, 1.0f, 1.0f, 0.0f); // Se coloca el color

7.1 // blanco en el fondo

8. // del canvas para dibujar. RGBA=(1,1,1,0)

9. glu.gluOrtho2D (-10.0,10.0,-10.0,10.0); //Las dimensiones a trabajar

9.1 // son de

10. //-10 a 10 en x y de -10 a 10 en y

11. gl.glMatrixMode(GL2.GL_MODELVIEW); // Se presenta el modo de vista

12. gl.glLoadIdentity(); // Se coloca la matriz identidad para

12.1 // operaciones.

13. }

14. @Override

15. public void display(GLAutoDrawable glad) {

16. final GL2 gl = glad.getGL().getGL2(); // Se genera un objeto de tipo

16.1 // GL2

17. gl.glClear(GL2.GL_COLOR_BUFFER_BIT); // Se limpia el buffer de color

18. gl.glLoadIdentity(); // Se coloca la matriz identidad para operaciones

19. dibuja(glad,0,0,2.5f);//Se invoca a la función dibuja, la “f”

19.1 // significa para java

20. // que el valor es de punto flotante

21. gl.glFlush(); // Se limpian los bufferes

22. }

23. public void dibuja(GLAutoDrawable glad,float x1, float y1, float lado)

24. {

25. final GL2 gl = glad.getGL().getGL2(); // Se genera un objeto GL2

26. gl.glPointSize(12f); // Se fija el tamaño del punto

27. gl.glBegin(GL2.GL_POINTS); // Se comienzan a dibujar puntos

28. gl.glColor3f(1, 0, 0); // Se activa el color rojo R=1

29. gl.glVertex2f(x1-lado,y1-lado); // Se dibuja el punto en la

29.1 // posición

30. gl.glColor3f(0, 0, 1); // Se activa el color azul B=1

31. gl.glVertex2f(x1-lado,y1+lado); // Se dibuja el punto en la

31.1 // posición

32. gl.glColor3f(0, 1, 0); // Se activa el color verde G=1

33. gl.glVertex2f(x1+lado,y1+lado); // Se dibuja el punto en la

33.1 //posición

34. gl.glColor3f(0, 0, 0); // se desactivan todos los colores,

34.1 // negro

35. gl.glVertex2f(x1+lado,y1-lado); // Se dibuja el punto en la

35.1 // posición

36. gl.glEnd(); // Se termina de dibujar.

37. }

Código3.1 Puntos2D.java

Figura 3.2 Salida del programa anterior

Fuente: Elaboración propia.

Hay que observar a los objetos GL2 en las líneas 3, 16 y 25, todos son generados en cada una de las funciones. Se les llaman variables (en el caso, son objetos ) locales, ya que sólo van a ser reconocidas en las funciones que se utilizan. Cuando son generadas en la parte superior de las clases, son reconocidas por todas las funciones de la clase y se les llaman variables (en el caso, objetos) globales.

Del código anterior hay que destacar lo siguiente: en la línea 26 se fija el tamaño del punto de 12 pixeles en la función glPointSize . En las líneas 29, 31, 33 y 35 se utiliza el método glVertex2f [TutorialOpenGL, 2016], cuyos parámetros son dos valores de punto flotante que representan la posición en dos dimensiones. Y en las líneas 28, 30, 32 y 34 el método glColor3f especifica el color para cada uno de los puntos a dibujar; los parámetros son la intensidad de los colores Rojo, Verde y Azul desde 0 a 1. En la línea 34 los parámetros son ceros, lo que significa que no hay intensidades de los tres colores, por lo tanto, hay una ausencia de color, que genera el negro. Cuando los tres valores correspondientes a los colores están a su máxima intensidad (o sea, 1), generan el color blanco.

Se observa que se generan puntos de diferentes colores, pero podemos generar más gráficas primitivas. Por ejemplo, para generar una línea es necesaria la característica GL_LINES y además un par de vértices que indican dónde empieza y dónde termina la línea correspondiente, como se muestra en la figura 3.3 a continuación [Villar, 2009].

Figura 3.3 Primitivas gráficas

Fuente: Apuntes de Villar Patiño.

Práctica

1. Modifique el programa Puntos2D para que presente la siguiente salida.

Genere un nuevo programa para que cuadricule cada unidad del plano cartesiano con las líneas azules y los ejes en negro.

Observe la siguiente tabla de colores

Figura 3.4 Tabla de colores de Windows

Fuente: Elaboración propia

Para trabajar con el color escogido se usa el método glColor3i(15,31,172) , que genera la salida mostrada en la figura 3.5, pero no proporciona el color esperado. Con ello surge la pregunta: ¿Existe un método que nos ayude a generar la salida esperada, utilizando los mismos valores de los colores?

Figura 3.5 Gráfica de la secante.

Fuente: Elaboración propia.

La respuesta es sí con el método glColor3d (15/256.0, 31/256.0, 172/256.0), que se puede observar en la línea 31 del siguiente código. Hay que resaltar los parámetros del método; estos se transcriben, por ejemplo, 15/250.0: se debe a que, si se escribe 35/256, como los dos valores son enteros la división regresaría un entero, el cual es 0. Al escribir 256.0 se le dice a java que el valor es uno de doble precisión y el resultado es un valor de doble precisión.

Figura 3.6 gráfica del seno

Fuente: Elaboración propia.

El siguiente código, en una nueva clase, genera la salida de la figura 3.6, llamado GraficasTrigonometricas .

1. public void init(GLAutoDrawable glad) {

2. final GL2 gl = glad.getGL().getGL2();

3. final GLU glu = new GLU();

4. gl.glMatrixMode (GL2.GL_PROJECTION);

5. gl.glClearColor (1.0f, 1.0f, 1.0f, 0.0f);

6. glu.gluOrtho2D (-10.0, 10.0, -1.2, 1.2);

7. gl.glMatrixMode(GL2.GL_MODELVIEW);

8. gl.glLoadIdentity();

9. }

10. public void display(GLAutoDrawable glad) {

11. final GL2 gl = glad.getGL().getGL2();

12. gl.glClear(GL2.GL_COLOR_BUFFER_BIT);

13. gl.glLoadIdentity();

14. dibujaEjes(gl,-9f,9f,-1f,1f);

15. dibujaSeno(gl);

16. gl.glFlush();

17. }

18. public void dibujaEjes(GL2 gl,float xi,float xf,float yi, float yf){

19. gl.glLineWidth(10f);

20. gl.glColor3f(0.0f, 0.0f, 0.0f);

21. gl.glBegin(GL2.GL_LINES);

22. gl.glVertex2f(xi, 0.0f);

23. gl.glVertex2f(xf, 0.0f);

24. gl.glVertex2f(0.0f, yi);