GL gl = drawable.

getGL();

gl.glClear(GL.GL_COLOR_BUFFER_BIT);

double yi, yf, xi, xf;

double xpi, xpf, ypi, ypf;

double xpc, ypc, dx, dy;

double xp1, yp1, xp2, yp2;

List<TPunto3D> puntos3D = new ArrayList<TPunto3D>();

TPunto3D punto;

List<TPunto2D> puntos2D = new ArrayList<TPunto2D>();

TPunto2D trazo;

double fx, fy, LC, phi;

int i, n, pi, pf;

// Medidas en pantalla

xpf = 640; // Punto final en pantalla en x

xpi = 0; // Punto inicial en pantalla en x

ypf = 480; // Punto final en pantalla en y

ypi = 0; // Punto inicial en pantalla en y

xpc = (xpi + xpf)/2; // Parte central de la ventana en x

ypc = (ypi + ypf)/2; // Parte central de la ventana en y

gl.glColor3f(1, 1, 0); // Color a usar: amarillo;

// Medidas del plano cartesiano a proyectar 2D

// debe ser simétrico para un escalamiento correcto.

xi = -10;

xf = 10;

yi = -10;

yf = 10;
// Escalamiento de pantalla del punto real al punto de pantalla

// Escalamiento de pantalla en x

dx = (Math.abs(xpi) + Math.abs(xpf))/(Math.abs(xi) + Math.abs(xf));

// dx = xpc/xf; // Es lo mismo que la linea anterior

// Escalamiento de pantalla en y

dy = (Math.abs(ypi) + Math.abs(ypf))/(Math.abs(yi) + Math.abs(yf));

// dy = ypc/yf; // Es lo mismo que la linea anterior

/* Forma de graficar en 3D a pantalla de 2D

* Z Y

* | |

* |______ Y => _____|_____ X

* / |

* / |

* X

* Método de caballera (Proyección paralela oblicua)

*/

// Colocamos las coordenadas de los puntos en el espacio cartesiano XYZ

puntos3D.add(new TPunto3D(3, -3, 0)); // punto 0

puntos3D.add(new TPunto3D(3, 3, 0)); // punto 1

puntos3D.add(new TPunto3D(-3, 3, 0)); // punto 2

puntos3D.add(new TPunto3D(-3, -3, 0)); // punto 3

puntos3D.add(new TPunto3D(0, 0, 5)); // punto 4

// Colocamos la secuencia de graficación de los puntos

puntos2D.add(new TPunto2D(0, 1)); // Segmento de los puntos 0 al 1

puntos2D.add(new TPunto2D(1, 2)); // Segmento de los puntos 1 al 2

puntos2D.add(new TPunto2D(2, 3)); // Segmento de los puntos 2 al 3

puntos2D.add(new TPunto2D(3, 0)); // Segmento de los puntos 3 al 0

puntos2D.add(new TPunto2D(0, 4)); // Segmento de los puntos 0 al 4

puntos2D.add(new TPunto2D(1, 4)); // Segmento de los puntos 1 al 4

puntos2D.add(new TPunto2D(2, 4)); // Segmento de los puntos 2 al 4

puntos2D.add(new TPunto2D(3, 4)); // Segmento de los puntos 3 al 4

LC = 1.0/3.0; // escalamiento de longitud del segmento de profundidad

phi = 30; // número en grados de la rotación de la figura

fx = LC * Math.cos(Math.PI*phi/180); // Escalamiento para X 3D para dibujar en X 2D

fy = LC * Math.sin(Math.PI*phi/180); // Escalamiento para Y 3D para dibujar en Y 2D

n = puntos2D.size(); // número de puntos a graficar

gl.glBegin(gl.GL_LINES);

for (i=0; i<n; i++){

trazo = puntos2D.get(i); // Obtiene la secuencia del trazo

pi = trazo.DevuelveP(); // punto inicial del trazo de la línea

pf = trazo.DevuelveQ(); // punto final del trazo de la línea

punto = puntos3D.get(pi); // Obtiene el punto inicial del trazo

xp1 = punto.DevuelveY() - punto.DevuelveX()* fx; // Traslado de

yp1 = punto.DevuelveZ() - punto.DevuelveX()* fy; // (xp1, yp1)

punto = puntos3D.get(pf); // Obtiene el punto final del trazo

xp2 = punto.DevuelveY() - punto.DevuelveX()* fx; // Traslado de

yp2 = punto.DevuelveZ() - punto.DevuelveX()* fy; // (xp2, yp2)

xp1 = xpc + xp1 * dx; // Traslado al centro y escalamiento

yp1 = ypc + yp1 * dy; // en pantalla para el punto1

 xp2 = xpc + xp2 * dx; // Traslado al centro y escalamiento

yp2 = ypc + yp2 * dy; // en pantalla para el punto 2

gl.glVertex2d(xp1, yp1); // Dibuja la linea del punto 1 al 2

gl.glVertex2d(xp2, yp2); // es decir el segmento P-Q

gl.glEnd();

gl.glFlush();