Universidad Tecnológica de los Andes

FACULTAD DE INGENIERÍA
Escuela Profesional de Ingeniería de Sistemas e Informática

COMPUTACIÓN GRÁFICA
Guía de aplicación N° 4

I. FECHA : Noviembre del 2021

II. Tema : Gráfico de circunferencia

III. COMPETENCIAS A CONSEGUIR

• Implementar un programa que muestre como graficar una circunferencia usando
las librerías OpenGL

IV. Fundamento Teórico

Los comandos de la función glVertex se utilizan dentro de los pares glBegin / glEnd para
especificar vértices de punto, línea y polígono. Las coordenadas de color, normal y textura
actuales se asocian con el vértice cuando se llama a glVertex. Cuando solo se especifican xey, z
se establece por defecto en 0.0 y w por defecto en 1.0. Cuando se especifican x, y y z, w toma el
valor predeterminado de 1.0. Invocar glVertex fuera de un par glBegin / glEnd da como resultado
un comportamiento indefinido.
La función Reshape o de remodelación define qué hacer cuando se cambia el tamaño de la
ventana. Debe tener un tipo de retorno vacío y toma dos parámetros int (el nuevo ancho y alto
de la ventana). glViewport define la esquina inferior izquierda y las dimensiones de la ventana
de dibujo:
Display es una lista de visualización, es un grupo de comandos OpenGL que se han almacenado
para su posterior ejecución. Cuando se invoca una lista de visualización, los comandos que
contiene se ejecutan en el orden en que se emitieron. La mayoría de los comandos de OpenGL
pueden almacenarse en una lista de visualización o emitirse en modo inmediato, lo que hace
que se ejecuten inmediatamente. Puede mezclar libremente la programación en modo
inmediato y las listas de visualización en un solo programa.

En esta Guia veremos como dibujar una circunferencia a traves de opengl en Java utilizando
la IDE Netbeans 8.2.

Para poder dibujar una circunferencia hacemos uso de la funcion gl.GL_POLYGON.

Antes que nada es importante saber que para poder utilizar opengl en netbeans se debe tener
instalado el plugin que permite hacer esto.

El dibujo de una circunferencia es muy sencillo y se logra a traves del siguiente codigo:

//Dibuja circunferencia
gl.glBegin(gl.GL_POLYGON);
for(int i=0; i<100; i++){
float x = (float) Math.cos(i*2*Pi/100);
float y = (float) Math.sin(i*2*Pi/100);
gl.glVertex2f(x, y); gl.glColor3f(1.0f, 0.8f, 0.2f);
 Universidad Tecnológica de los Andes
FACULTAD DE INGENIERÍA
Escuela Profesional de Ingeniería de Sistemas e Informática

}
gl.glEnd();
gl.glFlush();
Como se puede observar, se dibuja un poligono de muchisimos lados, lo que da la impresion
que se esta dibujando una circunferencia.

Practica
package paq_circulo;

import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;

//Para usar GLU de OpenGL, colocar librerias

import javax.media.opengl.glu.GLU;
import javax.swing.*;

public class CCirculo extends JFrame{

public CCirculo(){
//Estable el ancho y alto de la ventana
setSize(500,500);
//Establecemos la posicion de la ventana
setLocation(350,120);
//Colocamos el titulo a nuestra ventana
setTitle("Dibujando circulo");
//Creamos una instancia de la clase GraphicListener
GraphicListener listener = new GraphicListener();
//agregamos nuestra area de dibujo a la ventana del frame
GLCanvas canvas = new GLCanvas(new GLCapabilities());
canvas.addGLEventListener(listener);
getContentPane().add(canvas);
}
//Programa Principal
public static void main (String args[]){
/*Dibujos_Linea cuadrado = new Dibujos_Linea();
cuadrado.setVisible(true);
cuadrado.setDefaultCloseOperation(EXIT_ON_CLOSE);*/
//Crear el objeto circulo instanciando
CCirculo circulo = new CCirculo();
circulo.setVisible(true);
circulo.setDefaultCloseOperation(EXIT_ON_CLOSE);
}
//Permiten usar las funciones de opengl
GL gl;
GLU glu;

public class GraphicListener implements GLEventListener{

//Declaramos nuestra variable PI
public static final double Pi = 3.14159265358979323846;
//*************************************************************
//Metodo que prepara la ventana donde se visualizara el objeto
public void reshape(GLAutoDrawable drawable, int x, int y, int
width, int height) {
 Universidad Tecnológica de los Andes
FACULTAD DE INGENIERÍA
Escuela Profesional de Ingeniería de Sistemas e Informática
GL gl = drawable.getGL();
GLU glu = new GLU();

if (height <= 0) { //Evita un error de división por cero

height = 1;
}
final float h = (float) width / (float) height;
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(45.0f, h, 1.0, 20.0);
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glLoadIdentity();
}
//*************************************************************
public void display(GLAutoDrawable drawable) {
GL gl = drawable.getGL();

// Limpiar el área de dibujo

gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
// Restablecer la matriz actual a la "identidad"
gl.glLoadIdentity();
//--------------------------------------------
//Dibuja circunferencia
gl.glTranslatef(0.0f, 0.0f, -4.0f); //Permite enfocar la
esfera

//Dibuja circunferencia grande

gl.glPointSize(6);//dimencion del punto
gl.glColor3f(1.0f, 0.4f, 0.8f);
gl.glBegin(gl.GL_POINTS);
//Dibuja la cantidad de puntos
for(float angul = 0.0f; angul<2*Pi; angul +=0.1){
float x = (float) ((float) 1.5*Math.sin(angul));
float y = (float) ((float) 1.5*Math.cos(angul));
gl.glVertex2f(x,y);//Especifica el punto en el vertice
}
gl.glEnd();
//--------------------------------------------

}
//Metodo para cambio de pantalla
public void displayChanged(GLAutoDrawable arg0, boolean arg1,
boolean arg2) {
}

public void init(GLAutoDrawable arg0) {

//Manejo de primitivas de JOGL
GL gl = arg0.getGL();
gl.glEnable(GL.GL_BLEND);
gl.glBlendFunc(GL.GL_SRC_ALPHA,GL.GL_ONE_MINUS_SRC_ALPHA);
}
}
}
 Universidad Tecnológica de los Andes
FACULTAD DE INGENIERÍA
Escuela Profesional de Ingeniería de Sistemas e Informática

Ejercicio Propuesto:
•