Open GL - Transformación de coordenadas

Hola,
mi problema es el siguiente:

Quiero transformar un punto expresado en coordenadas de pantalla (obtenidas con el ratón) a coordenadas de mi mundo virtual.

He estado leyendo en el foro acerca de ello y he visto un mensaje en el que se habla del Picking. He estado consultando el siguiente tutorial:

http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=32

pero creo que este no es exactamente mi problema, ya que yo no quiero seleccionar ningún objeto con el ratón sino sólo obtener las coordenas para luego poder dibujar ese punto.

He probado a implementar una función que calcula manualmente la transformación de coordenadas mediante las siguientes fórmulas:

Xu = (Xm-X1) / (X2-X1)
Yu = (Ym-Y1) / (Y2 -Y1)

Xp = W * Xu
Yp = H * (1 - Yu)

pero no consigo que funcione correctamente ya que al dibujar luego los puntos, estos no aparecen en la pantalla, pero no en el lugar deseado.

Por otro lado también lo he intentado con la función gluUnProject pero elija el punto me devuelve unas coordenas que, aunque están dentro del mundo virtual, son, en todos los casos, muy similares, por no decir iguales, con lo que, tampoco consigo que funcione correctamente.

Estaría muy agradecida con cualquier tipo de ayuda recibida.

Saludos.
Begoña.

yo tengo el mismo problema!!... alguien ayude por favor!!

Tenemos que tener claro que:

1 - Vas a trabajar con nubes de puntos en 2D, luego nuestra representación y proyección será 2D
2 - ¿Qué recorrido tendrán nuestro puntos? ,O sea, el maximo y minimo en coordenadas (x,y) de nuestros puntos, de modo que todos ellos queden representados dentro y no fuera de la ventana
Para empezar, suponiendo que usas glut (de no ser asi, este código debes introducirlo en tu funcion de redimensionado de la pantalla)

void Resize(int ancho, int alto)
{
float ratio;

// No debemos dividir por cero al calcular el ratio
if(alto == 0) alto = 1;

// Establezco mi view port
glViewport(0, 0, ancho, alto);

// Inicializo la matriz de proyeccion
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

// Calculo el ratio
ratio = (float)ancho / (float)alto;
if (ancho <= alto)
glOrtho (- 3.0, 3.0, -3 / ratio, 3.0 / ratio, 1.0, -1.0);
else
glOrtho (-3.0 * ratio, 3.0 * ratio, -3.0, 3.0, 1.0, -1.0);
}

ratio es cociente entre el ancho y alto de la pantalla. Con glOrtho tomo una parte del espacio y la proyecto en mi ventana, pero si mi ventana es mas ancha que alta, por logica, y para no distorsionar el espacio, nuestra sección tomada del espacio debe ser también más ancha que alta. Más aún, las proporciones ancho-alto de la pantalla deben ser iguales a las proporciones ancho-alto del espacio.

glOrtho toma una proyeccion paralela, (los objetos alejados no se ven empequeñecidos), muy apropiada para trabajar con 2D. Esta es su estructura

glOrtho (minX, maxX, minY, maxY, cerca, lejos)

te recomiendo que: cerca = 1, y lejos = -1, así, cuando dibujes en z=0 ó, directamente, obvies z, no tendras problemas. En este caso, nuestra ventana tendrá un rango minimo de -3 a 3 tanto para las coordenadas x, como las y. Segun los puntos, tendras que modificar esto. Divido o multiplico estos valores por ratio para hacer el espacio proporcional a la ventana.

Ya tenemos la función resize, solo queda obtener la relación entre las coordenadas del raton (pixeles) y las del espacio. Te recomiendo que ratio lo declares como global, para asi poder usar ratio desde la función del raton.

En la función raton, mete este codigo:

if (ratio<1)
{
ancho_total_seccion_espacio = 3 - (-3); // Coord X
alto_total_seccion_espacio = 3/ratio - (-3/ratio); // Coord Y
}else{
ancho_total_seccion_espacio = 3*ratio - (-3*ratio);// Coord X
alto_total_seccion_espacio = 3 - (-3); // Coord Y
}

Asi, en ancho_total_seccion_espacio y en alto_total_seccion_espacio tenemos el ancho y alto de nuestra sección de espacio representada. Hay que buscar una relación entre esto y la ventana.

relacionX = ancho_total_seccion_espacio/ancho_ventana
relacionY = alto_total_seccion_espacio/alto_ventana

Ya tengo la cantidad de unidades del espacio en ancho y en alto que vale un pixel.

Asi, para el punto (en pixeles del raton) (a,b)
Las coordenadas espaciales son (a*relacionX, b*relacionY)

De forma analoga, para el punto(en el espacio) (c,d)
Las coordenadas de ventana son (c/relacionX, d/relacionY)

Listo. Recuerda mirar el recorrido de los puntos y cambiar esos 3's que van por ahi.

Saludos, Angel

PD: No se si te he ayudado o si te he liado más, si tienes dudas o algo, me lo dices y te mando un codigo fuente hecho para que lo veas. Saludos

Hola Angel,
Muchas gracias por la respuesta pero sigo perdida. Te envie un correo electrónico contándote el problema con más detalle.
Saludos.
Begoña.

Bueno, ya tengo la solucion hecha. Esta un poco cutre por las prisas, pero aun asi, os servirá. El programa (codigo c++, usando GLUT) muestra una pantalla en negro, sin nada, pero, cuando mueves el raton cambia el titulo de la ventana.

Te muestra:

Coordenadas de ventana (x,y)
Coordenadas de espacio (x,y)

He supuesto unos limites de espacio minimo de -3 a 3 tanto en la X como en la Y (explicado en el post anterior). Podeis cambiarlos.

Todos los calculos vienen en la funcion raton(x,y) con x,y valores del raton en pixeles de pantalla, en mi caso (640, 480), y los convierto en valor de espacio.

Ojo,

la ventana va de 0 a 640 en X y de 0 a 480 en Y
el espacion va de -4 a 4 en X (despues de multiplicar por ratio) y de -3 a 3 en Y

Luego, la ventana no esta centrada!!! , por ello, hago una operacion

espX = (x-ancho_ventana_pixeles/2)*relacionX

al x en pixeles le resto la mitad de la ventana, asi, el espacio queda centrado. SI no me explico claro, decidmelo.

Dejo el fichero cpp integro a continuacion, en el siguiente post. Suerte

Hola,
estuve probando el código pero no me funciona, ...
he estado intentando seguir el razonamiento con lápiz y papel y hay algo que me falla ...
Voy a intentar explicarme ...
en la función del ratón, se calculan las relaciones en alto y en ancho entre las coordenadas de pantalla y las coordenadas del "mundo virtual" y luego, a partir de las coordenadas de pantalla y estas relaciones, se calculan las correspondientes coordenas del mundo virtual.
Sin embargo ... lo que se me escapa es en qué parte del proceso se tienen en cuenta las coordenadas "absolutas" (no sé si esa sería la palabra, en realidad no sé cómo llamarlo) del mundo virtual, es decir, aquellas que marcarían sus límites.
Me explico, ... estamos teniendo en cuenta la anchura y altura de nuestro mundo pero creo que no tenemos en cuenta dónde empieza y dónde acaba realmente, es decir, no sólo su volumen (su área) si no sus límites, es decir ... creo que a la hora de transformar las coordenadas de pantalla a nuestro mundo, no sería lo mismo que este mundo empiece (por ejemplo, en la coordenada X) en 3 y acabe en 5, a que empiece en 30000 y acabe en 30002, aunque, en ambos casos, el ancho sería el mismo.
Gracias por todo.
Saludos.
Begoña.

Hola Begoña.

Te entendi perfectamente. Tienes razon. El codigo que he mandado solo funciona correctamente si la porcion tomada del espacio va de (-x a x) y de (-y a y), o sea, el punto (0,0) del espacio esta en el centro de nuestra pantalla. Si lo deseas, puedes mejorar el codigo para que cualquier coordenada sea valida. Te muestro, al final del hilo de este post, una implementacion

#include <GL/glut.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>

static int slices = 16;
static int stacks = 16;

/* GLUT callback Handlers */

float alto_ventana = 480.0;
float ancho_ventana = 640.0;
float ratio;

void resize(int ancho, int alto)
{


// No debemos dividir por cero al calcular el ratio
if(alto == 0) alto = 1;

// Establezco mi view port
glViewport(0, 0, ancho, alto);

// Inicializo la matriz de proyeccion
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

// Calculo el ratio
ratio = (float)ancho / (float)alto;
if (ancho <= alto)
glOrtho (- 3.0, 3.0, -3 / ratio, 3.0 / ratio, 1.0, -1.0);
else
glOrtho (-3.0 * ratio, 3.0 * ratio, -3.0, 3.0, 1.0, -1.0);
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glutSwapBuffers();
}

void key(unsigned char key, int x, int y)
{
switch (key)
{
case 27 :
case 'q':
exit(0);
break;

}

glutPostRedisplay();
}

void raton(int x, int y)
{
float ancho_total_seccion_espacio;
float alto_total_seccion_espacio;
float relacionX, relacionY;

if (ratio<1)
{
ancho_total_seccion_espacio = 3 - (-3); // Coord X
alto_total_seccion_espacio = 3/ratio - (-3/ratio); // Coord Y
}else{
ancho_total_seccion_espacio = 3*ratio - (-3*ratio);// Coord X
alto_total_seccion_espacio = 3 - (-3); // Coord Y
}

relacionX = ancho_total_seccion_espacio/ancho_ventana;
relacionY = alto_total_seccion_espacio/alto_ventana;

float espX, espY;
espX = (x-ancho_ventana/2) * relacionX;
espY = (y-alto_ventana/2) * relacionY;

char cadena [50];
sprintf (cadena, "Pantalla: %d, %d --- Espacio: %f, %f",x,y,espX,espY);
glutSetWindowTitle(cadena);

}

void idle(void)
{
glutPostRedisplay();
}

/* Program entry point */

int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitWindowPosition(10,10);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

glutCreateWindow("Ejemplo");

glutReshapeFunc(resize);
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutIdleFunc(idle);
glutPassiveMotionFunc(raton);

glutMainLoop();

return EXIT_SUCCESS;
}

Una cosa mas, algunas cosas sobran, como las "slices" y los stacks", es que... es modificado el fichero y estoy de una pereza terrible. No me di cuenta. Espero vuestros resultados.

xao!!!

Muchas gracias, Angel.
Lo pruebo y te comento.
Saludos.

Hola de nuevo, os dejo aqui el codigo.

--------------------------
Codigo C++
Hecho con DevCpp
Usa GLUT
--------------------------

#include <GL/glut.h>
#include <stdio.h>
#include <stdlib.h>

float alto_ventana = 480.0;
float ancho_ventana = 640.0;
float ratio;

const float ymin0 = -1.0;
const float ymax0 = 3.0;
const float xmin0 = 5.0;
const float xmax0 = 12.0;

float dist_x,dist_y;
float xmin;
float xmax;
float ymin;
float ymax;

void ajuste()
{
float t;
float delta;

xmin = xmin0;
xmax = xmax0;
ymin = ymin0;
ymax = ymax0;

if (ymin>ymax)
{
t = ymin;
ymin = ymax;
ymax = t;
}
if (xmin>xmax)
{
t = xmin;
xmin = xmax;
xmax = t;
}

if (ymin==ymax)
ymax = ymin + 1.0;
if (xmin==xmax)
xmax = xmin + 1.0;

dist_x = (xmax-xmin);
dist_y = (ymax-ymin);

if (dist_y*ratio > dist_x)
{
delta = (dist_y*ratio - dist_x)/2.0;
xmin = xmin - delta;
xmax = xmax + delta;
}else{
delta = dist_x/(2.0*ratio) - dist_y/2.0;
ymin = ymin - delta;
ymax = ymax + delta;
}
}

void resize(int ancho, int alto)
{
// No debemos dividir por cero al calcular el ratio
if(alto == 0) alto = 1;

// Establezco mi view port
glViewport(0, 0, ancho, alto);

// Inicializo la matriz de proyeccion
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

// Calculo el ratio
ratio = (float)ancho / (float)alto;

// Ajusta la dimension del espacio
ajuste();

// Tomo la seccion del espacio
glOrtho (xmin,xmax,ymin,ymax, 1.0, -1.0);
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutSwapBuffers();
}

void key(unsigned char key, int x, int y)
{
switch (key)
{
case 27 :
case 'q':
exit(0);
break;

}
glutPostRedisplay();
}

void raton(int x, int y)
{
float ancho_total_seccion_espacio;
float alto_total_seccion_espacio;
float relacionX, relacionY;

ancho_total_seccion_espacio = xmax - xmin;
alto_total_seccion_espacio = ymax - ymin;

relacionX = ancho_total_seccion_espacio/ancho_ventana;
relacionY = alto_total_seccion_espacio/alto_ventana;

float espX, espY;
espX = x * relacionX + xmin;
espY = (alto_ventana-y) * relacionY + ymin;

char cadena [50];
sprintf (cadena, "Pantalla: %d, %d --- Espacio: %f, %f",x,y,espX,espY);
glutSetWindowTitle(cadena);

}

void idle(void)
{
glutPostRedisplay();
}

int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitWindowPosition(10,10);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

glutCreateWindow("Ejemplo");

glutReshapeFunc(resize);
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutIdleFunc(idle);
glutPassiveMotionFunc(raton);

glutMainLoop();

return EXIT_SUCCESS;
}

Hola, a ver, os cuento:

En el main no he hecho nada nuevo, ni en idle, ni en las teclas ni el el display

Solo toco esto:

1- FUNCION ajuste

con las constantes ymin0, ymax0, xmin0 y xmax0 elijo la porcion del espacio que se va a ver. Pero... ¿Y si la porcion del espacio no es proporcional a la pantalla? Si mi pantalla es mas ancha que alta, y mi espacio es mas alto que ancho, el dibujo en pantalla sale distorsionado. Hay dos soluciones:

-->A: Cambiar el tamaño de la ventana (muy cutre)
-->B: Cambiar el tamaño del espacio (mejor). De esto se encarga la funcion fijar. Compara el ancho y el alto del espacio con el ratio de la ventana. Si no coincide, dejo fijo la coordenada que sobrepasa la ventana, y aumento la otra coordenada. Asi, en un caso peor, mostraremos mas espacio del solicitado, pero nunca menos, no se si me explico...

2. FUNCION resize

Aqui lo que hago es muy basico. Despues de calcular el ratio de ventana, llamo a ajuste(), hay que tener en cuenta que ajuste necesita dicho ratio. Luego, tomo con glOrtho la seccion del espacio que quiero.

3. FUNCION raton

esp_X y esp_Y contienen las variables espacioles, mientras que x e y contienen los valores de ventana. Todos son mostrados.

-----------------------------------------------------
Asi que... para tomar un espacio, modificar las constantes del inicio del programa. Si teneis dudas de como funcionan los calculos, comentadmelo. Si encontrais algun fallo, bug... me lo decis y lo apaño.

Saludos.

Hola Angel,
Muchas gracias de nuevo.
Lo pruebo y te cuento, espero que esta vez ya funcione todo bien para no seguir dando la lata.
Saludos.
Begoña.

Hola Begoña.... desde el inicio de tu pregunta hasta aca parecira que se ha torcido toda la conversación... lamentablemente no tengo la respuesta a tu pregunta, pero si no entendi mal.. creo que preguntaste como hacer que un punto de la pantalla expresado con el mouse, te de las coordenadas de tu mundo virtual que esta en 3D o sea... de (X, Y) que obtenes del Mouse... queres saber (X, Y, Z) ... de tu mundo virtual.. si es asi y lo has podido resolver, porfavor enviame la solucion a mi correo ... estoy empezando con OpenGL y me gustaria intercambiar ideas... si te parece... bye bye

Hola,
sí, esa es exactamente la cuestión. Respecto a lo de resolverlo, ... todavía estoy en ello. El problema es que yo no estoy usando GLUT, entonces mi código está estructurado de otra forma y tengo que adaptar lo de Angel al mío.
Ya os contaré.
Gracias.
Saludos.

Hola Angel!
No entiendo que haces exactamente en la función ajuste cuando calculas delta y operas con ella. ¿Me podrías dar una explicación un poco más detallada de ella?
La función del ratón sí que la entiendo y estoy de acuerdo con ella.
El problema es que no uso GLUT y estoy un poco desorientada a la hora de integrar este código con el mío, pero estoy en ello ...
Muchas gracias.
Lo siento por dar tanto la lata.
Saludos.

Hola Begoña, trankila, no das la lata. Estamos para ayudar. Te explico lo que hace paso a paso la funcion. Así, en general, lo que hace es crear un espacio proporcional a la pantalla para que el dibujo no se distorsione.

ancho_pantalla/alto_pantalla debe ser igual a ancho_espacio/alto_espacio

Para ello, lo que hacemos es modificar los valores de las variables float xmin; float xmax; float ymin; float ymax;

1. El usuario introduce el espacio que quiere mostrar en unas constantes.

2. Copiamos el valor de las constantes en unas variables, para asi no perder el valor inicial, ya que estas variables si seran modificadas.

xmin = xmin0;
xmax = xmax0;
ymin = ymin0;
ymax = ymax0;

3. Me aseguro que los valores maximos tanto de y como de x son mayores a los valores minimos, si no es asi, los intercambio.

if (ymin>ymax)
{
t = ymin;
ymin = ymax;
ymax = t;
}
if (xmin>xmax)
{
t = xmin;
xmin = xmax;
xmax = t;
}

4. Me aseguro que los valores minimos no son iguales a los maximos.

if (ymin==ymax)
ymax = ymin + 1.0;
if (xmin==xmax)
xmax = xmin + 1.0;

5. Calculo el ancho y el alto del espacio que quiero representar

dist_x = (xmax-xmin);
dist_y = (ymax-ymin);

6. La variable ratio es el ancho/alto de la pantalla. Por ello, dist_x/dist_y deberia valer ratio. Pero... eso no suele ser.

7 Si me excedo en el alto...

if (dist_y*ratio > dist_x) es lo mismo que if (ratio_ventana>ratio_espacio) . Entro aqui si mis proporciones, en alto, son demasiado grandes para el ancho que he introducido. Por ello, amplio el ancho introducido, para asi mostrar todo el ancho y todo el alto pedido. Ademas, se mostrara un poco mas de ancho.

8 Ensancho la seccion tomada del espacio. Aumento xmax y disminuyo xmin en la misma medida.

(xmax + delta) - (xmin-delta) = nuevo ancho espacio, no conozco delta

nuevo_ancho = alto_espacio*ratio

->> asi, ancho_espacio/alto_espacio = ratio, siendo de las mismas proporciones de la ventana.

Despejo delta

delta = (dist_y*ratio - dist_x)/2.0;

Ensancho el espacio

xmin = xmin - delta;
xmax = xmax + delta;

9. En este caso, el ancho introducido es muy grande para el alto. Lo que hago es aumentar el alto. en la misma medida.

(ymax + delta) - (ymin-delta) = nuevo alto espacio, no conozco delta

nuevo_alto = ancho_espacio / ratio

despejo delta

delta = dist_x/(2.0*ratio) - dist_y/2.0;

10. Actializo el alto

ymin = ymin - delta;
ymax = ymax + delta;

y listo

--------------------------------
Si tienes problemas, comunicamelo ok? a mi me funciona correctamente, asi que en principio, debe estar bien. Te recomiendo que bajes DevCpp de softonic. Instalalo y cierralo. A continuacion, descargate esto

http://www.nigels.com/glt/devpak/glut.3.7.6+.DevPak

y una vez descargado, ejecutalo. Esto configurara el compilador. Archivo->Nuevo Proyecto, Selecciona Multimedia y luego GLUT

Sustituye el main por el codigo que mande al foro. Luego, guarda y pulsa F9.

Saludos!!

¡Hola Angel!

Estuve probando el codigo. Ahora me funciona bastante bien, pero el punto que dibujo en la pantalla (primero cojo el punto de la pantalla con la función FormMouseDown, calculo las coordenadas de mi mundo virtual de ese punto y luego lo represento) no se corresponde exactamente con el punto de la pantalla en el que pinche con el ratón.
He observado que, en el centro de la pantalla, hay muy poco desfase entre un punto y otro pero sin embargo, a medida que me voy hacia los extremos de la pantalla, aumenta la diferencia.

Estuve dándole vueltas a esto pero no consigo saber porqué pasa, lo único que se me ocurrió es lo siguiente:

¿Podría ser porque la función que utilizo para coger las coordendas de pantalla pinchando con el ratón considera las coordenadas como un entero (int) en vez de como un float?

¿Tienes idea de cómo se podría solucionar este problema?

Muchas gracias.
Saludos.
Begoña.

Hola, tengo examenes en la universidad y ando algo ocupado. Estudiare como solucionar el problema mañana ¿de acuerdo?, a ver que se me ocurre XD

Disculpame, hasta mañana

Hola,
Muchas gracias, no te preocupes.
¡Mucha suerte con tus exámenes!
Saludos.
Begoña.

Hola de nuevo Begoña.

He hecho una prueba en mi ejemplo de lo que me comentas (el descuadre entre la ventana y el espacio), pero en mi caso, no tengo ningun tipo de problemas en la implementacion. ¿Qué plataforma usas? ¿Lenguaje?...

En mi caso, funciona correctamente usando Windows, el compilador DevCpp y GLUT. Te dejo el codigo fuente que apenas he modificado. Este codigo lo que hace es:

1. Algunas variables locales ahora son globales. Si, lo se, es muy cutre, pero no me quise complicar.

2. Creo la función click, que es llamada ante un click del ratón.

3. Dibujo un cuadrado que tiene como centro la ultima posicion del raton cuando hice click.

------------------------------------------------------------------------------------------------------------------

#include <GL/glut.h>
#include <stdio.h>
#include <stdlib.h>

float alto_ventana = 480.0;
float ancho_ventana = 640.0;
float ratio;

const float ymin0 = -1.0;
const float ymax0 = 3.0;
const float xmin0 = 5.0;
const float xmax0 = 12.0;

float ancho_total_seccion_espacio;
float alto_total_seccion_espacio;
float relacionX, relacionY;
float espX, espY;

float dist_x,dist_y;
float xmin;
float xmax;
float ymin;
float ymax;

float bolaX = 9.0;
float bolaY = 0.0;

void ajuste()
{
float t;
float delta;

xmin = xmin0;
xmax = xmax0;
ymin = ymin0;
ymax = ymax0;

if (ymin>ymax)
{
t = ymin;
ymin = ymax;
ymax = t;
}
if (xmin>xmax)
{
t = xmin;
xmin = xmax;
xmax = t;
}

if (ymin==ymax)
ymax = ymin + 1.0;
if (xmin==xmax)
xmax = xmin + 1.0;

dist_x = (xmax-xmin);
dist_y = (ymax-ymin);

if (dist_y*ratio > dist_x)
{
delta = (dist_y*ratio - dist_x)/2.0;
xmin = xmin - delta;
xmax = xmax + delta;
}else{
delta = dist_x/(2.0*ratio) - dist_y/2.0;
ymin = ymin - delta;
ymax = ymax + delta;
}
}

void resize(int ancho, int alto)
{
// No debemos dividir por cero al calcular el ratio
if(alto == 0) alto = 1;

// Establezco mi view port
glViewport(0, 0, ancho, alto);

// Inicializo la matriz de proyeccion
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

// Calculo el ratio
ratio = (float)ancho / (float)alto;

// Ajusta la dimension del espacio
ajuste();

// Tomo la seccion del espacio
glOrtho (xmin,xmax,ymin,ymax, 1.0, -1.0);
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glBegin(GL_QUADS);
glVertex3f(bolaX+0.05, bolaY + 0.05, 0.0);
glVertex3f(bolaX+0.05, bolaY - 0.05, 0.0);
glVertex3f(bolaX-0.05, bolaY - 0.05, 0.0);
glVertex3f(bolaX-0.05, bolaY + 0.05, 0.0);
glEnd();
glutSwapBuffers();
}

void key(unsigned char key, int x, int y)
{
switch (key)
{
case 27 :
case 'q':
exit(0);
break;

}
glutPostRedisplay();
}

void click(int boton, int estado, int x, int y)
{
bolaX = espX;
bolaY = espY;
}

void raton(int x, int y)
{
ancho_total_seccion_espacio = xmax - xmin;
alto_total_seccion_espacio = ymax - ymin;

relacionX = ancho_total_seccion_espacio/ancho_ventana;
relacionY = alto_total_seccion_espacio/alto_ventana;

espX = x * relacionX + xmin;
espY = (alto_ventana-y) * relacionY + ymin;

char cadena [50];
sprintf (cadena, "Pantalla: %d, %d --- Espacio: %f, %f",x,y,espX,espY);
glutSetWindowTitle(cadena);
}

void idle(void)
{
glutPostRedisplay();
}

int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitWindowPosition(10,10);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

glutCreateWindow("Ejemplo");

glutReshapeFunc(resize);
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutIdleFunc(idle);
glutMouseFunc(click);
glutPassiveMotionFunc(raton);

glutMainLoop();

return EXIT_SUCCESS;
}

Si lo deseas, me lo dices y te mando el ejecutable para que lo compruebes tu misma. Saludos.

Hola Angel,

Muchas gracias de nuevo.
Yo estoy programando en Windows, en C++ con Borland Builder, versión 6 y estoy usando Opengl pero no glut.
No te contesté antes porque estos días estuve de vacaciones y con otras cosas entre manos.
Lo volveré a mirar. Ya que te ofreces, si me envias el ejecutable, compruebo a qué te refieres con que funciona correctamente, de todas formas, no quiero abusar más de tu amabilidad.
Nuevamente, gracias por todo.

Un saludo.
Begoña.

Hola Begoña, feliz año nuevo!!

Yo he estado en mi pueblo, asi que no tenia internet.

Esta misma tarde te envio el ejecutable, el codigo, el compilador si quieres (es gratuito, no hay problemas de licencia..)

Disculpa por la tardanza..., pero es q no tenia conexión. Hasta esta tarde, saludos!!!

Hola,
tranquilo, yo también estuve de vacaciones.
Ya vi tu correo.
Muchas gracias!!

quiero ejercicio y difinicon