DESCARGA DE PLUGIN PARA NETBEANS
PASO 1:
Descargar el plugin oficial de Java3D para Netbeans en la versión INSTALLER
PASO 2:
Ejecute el instalador: lee el acuerdo de licencia y haz clic en aceptar (accept)
PASO 3:
Espera que finalice y tendrás lista la librería dar clic en Terminar (Finish)
OPCION 2: AGREGAR ARCHIVOS JAR
PASO 1: Descarga el plugin oficial de Java3D para Netbeans en la versión ZIP y descomprime el
contenido.
PASO2 Elige el proyecto en Netbeans, haz clic derecho sobre la carpeta bibliotecas y elige Agregar
JAR/Carpeta…
PASO3 Navega hasta la carpeta donde descomprimiste el archivo ZIP, en la carpeta\j3d-re\ext y
selecciona todos los archivos, y haz clic en abrir, como se muestra a continuación
PASO 4: comprueba los resultados dando clic derecho sobre bibliotecas y deben aparecer los .jar
display()
Defino las caracteristicas del material que voy a usar :
GLfloat
GLfloat
GLfloat
GLfloat
mat_ambient[] = { 0.7f, 0.7f, 0.7f, 1.0f };
mat_diffuse[] = { 0.1f, 0.5f, 0.8f, 1.0f };
mat_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
mat_shininess[] = { 100.0f };
La función glClear nos permite borrar tanto buffer de color, como el de profundidad.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Selecciono la matriz de modelado :
glMatrixMode (GL_MODELVIEW);
y la "limpio" con la matriz identidad :
glLoadIdentity ();
Roto el objeto 25 grados en torno al eje x.
glRotated(25.0, 1.0, 0.0, 0.0);
Lo vuelvo a rotar pero esta ves -30 grados en torno al eje y.
glRotated(-30.0, 0.0, 1.0, 0.0);
Aplico el material al objeto
glMaterialfv(GL_FRONT,
glMaterialfv(GL_FRONT,
glMaterialfv(GL_FRONT,
glMaterialfv(GL_FRONT,
GL_AMBIENT, mat_ambient);
GL_DIFFUSE, mat_diffuse);
GL_SPECULAR, mat_specular);
GL_SHININESS, mat_shininess);
Dibujo una "Tetera" de dimensiones 125.0, este objeto esta definido en GLUT.
glutSolidTeapot(125.0);
Fuerzo a dibujar el objeto.
glFlush();
reshape()
Definimos primero un viewport es un área rectangular de la ventana de visualización. Por defecto es la
ventana entera pero podemos variarlo a gusto. Se utiliza la funció :
void glViewport(GLint x, GLint y, GLsizei w, GLsizei h)
dónde (x,y) es la esquina inferior izquierda del rectangulo o viewport. Esta coordenada debe especificarse con
relación a la esquina inferior izquierda de la ventana. Claro está que w, h son la anchura y altura de nuestro
viewport dentro de la ventana. Todos los valores son enteros ya que se tratan de pixels.
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
En primer lugar tenemos decirle a OpenGL como debe proyectar nuestros gráficos en pantalla. Por ello y para
empezar le decimos que active la matriz de proyección :
glMatrixMode (GL_PROJECTION);
Procedemos a "limpiarla" para que no contenga ningún valor que pueda falsear los cálculos y por tanto nos
haga obtener resultados inexactos. Para ello cargamos a la matriz activa (proyeccion) con la matriz identidad :
glLoadIdentity ();
Tengo la matriz de proyección limpia, pero ahora tengo que decirle a OpenGL de que manera quiero que
proyecte mis gráficos en la ventana que he creado. Usaremos la función glOrtho(...). Así creo el volumen de
visualización. Todo lo que esté dentro de este volumen será proyectado de la forma más simple, eliminando
su coordenada Z, o de profundidad. Es la llamada proyección ortográfica y no permite que se distinga la
distancia de los objetos a la cámara :
glOrtho (-200, 200, -200, 200, -200, 200);
glOrtho()
Se utiliza para especificar una proyección
ortográfica. Este tipo de proyección define un
volumen de vista rectangular, concretamente
define un paralelepípedo de tamaño infinito, este
hecho nos lleva a definir una serie de planos de
corte para detallar con exactitud el volumen de
vista. OpenGL define la sentencia como:
glOrtho(xmin, xmax, ymin, ymax, cerca,
lejos);
Estos seis argumentos definen la ventana de
visualización y los planos de corte tanto cercano
como lejano. Para definir la ventana de
visualización es suficiente definir las
coordenadas de dos esquinas de la ventana, con
estos dos valores queda totalmente definida. Los
valores de cerca y lejos representan el plano
cercano y el plano lejano. Hay que tener en
cuenta que el objeto a visualizar debe
encontrarse dentro de ambos planos, si
sobrepasan estos dos planos el objeto se
recortará automáticamente.
Ya hemos terminado con la matriz de proyección. El sistema ya sabe como debe proyectar en pantalla. Ahora
pasemos a la matriz de modelado/visionado, o sea, la matriz que rota/escala/traslada....Dado que queremos
operar sobre ella la seleccionamos con :
glMatrixMode (GL_MODELVIEW);
Procedemos a "limpiarla" con la matriz identidad.
glLoadIdentity();
keyboard()
Esta funcion termina la aplicacion si es presionada la tecla Esc
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 27: exit(0);
break;
}
}
Código Fuente del ejemplo
Codigo fuente (ejemplo1.zip 4kb)
/* Este programa utiliza proyeccion ortografica para
* visualizar una "Tetera", este objeto esta definido
* en GLUT, se crea una fuente de luz, y un material */
//Incluimos las librerias
#include <GL/glut.h>
#include <stdlib.h>
void init(void)
{
// Ubicamos la fuente de luz en el punto (1.0, 1.0, 1.0)
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
// Activamos la fuente de luz
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
// Queremos que se dibujen las caras frontales
// y con un color solido de relleno.
glPolygonMode(GL_FRONT, GL_FILL);
}
void reshape(int w, int h)
{
if (!h)
return;
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
// Activamos la matriz de proyeccion.
glMatrixMode(GL_PROJECTION);
// "limpiamos" esta con la matriz identidad.
glLoadIdentity();
// Usamos proyeccion ortogonal
glOrtho(-200, 200, -200, 200, -200, 200);
// Activamos la matriz de modelado/visionado.
glMatrixMode(GL_MODELVIEW);
// "Limpiamos" la matriz
glLoadIdentity();
}
// Aqui ponemos lo que queremos dibujar.
void display(void)
{
// Propiedades del material
GLfloat mat_ambient[] = { 0.7f, 0.7f, 0.7f, 1.0f };
GLfloat mat_diffuse[] = { 0.1f, 0.5f, 0.8f, 1.0f };
GLfloat mat_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat mat_shininess[] = { 100.0f };
// "Limpiamos" el frame buffer con el color de "Clear", en este
// caso negro.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode( GL_MODELVIEW_MATRIX );
glLoadIdentity();
// Rotacion de 30 grados en torno al eje x
glRotated(25.0, 1.0, 0.0, 0.0);
// Rotacion de -30 grados en torno al eje y
glRotated(-30.0, 0.0, 1.0, 0.0);
// Dibujamos una "Tetera" y le aplico el material
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glutSolidTeapot(125.0);
glFlush();
}
// Termina la ejecucion del programa cuando se presiona ESC
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 27: exit(0);
break;
}
}
// Main del programa.
int main(int argc, char **argv)
{
// Inicializo OpenGL
glutInit(&argc, argv);
// Activamos buffer simple y colores del tipo RGB
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
// Definimos una ventana de medidas 300 x 300 como ventana
// de visualizacion en pixels
glutInitWindowSize (300, 300);
// Posicionamos la ventana en la esquina superior izquierda de
// la pantalla.
glutInitWindowPosition (0, 0);
// Creamos literalmente la ventana y le adjudicamos el nombre que se
// observara en su barra de titulo.
glutCreateWindow ("Teapot");
// Inicializamos el sistema
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
// ANSI C requiere que main retorne un valor entero.
return 0;
}
