I have this code:
#include <iostream>
#include <GL/glut.h>
using namespace std;
bool* Keys = new bool[256];
void keyboardDown(unsigned char key, int x, int y)
{
Keys[key] = true;
}
void keyboardUp(unsigned char key, int x, int y)
{
Keys[key] = false;
}
void reshape(int width, int height)
{
GLfloat fieldOfView = 90.0f;
glViewport(0, 0, (GLsizei)width, (GLsizei)height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(fieldOfView, (GLfloat)width / (GLfloat)height, 0.1, 500.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void draw()
{
if (Keys['e'])
cout << "e" << endl;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glBegin(GL_QUADS);
glColor3f(0.1, 0.1, 0.1); glVertex3f(1.0, 1.0, -1.0);
glColor3f(0.1, 0.9, 0.1); glVertex3f(1.0, -1.0, -1.0);
glColor3f(0.9, 0.1, 0.1); glVertex3f(-1.0, -1.0, -1.0);
glColor3f(0.1, 0.1, 0.9); glVertex3f(-1.0, 1.0, -1.0);
glEnd();
glFlush();
glutSwapBuffers();
}
void initGL(int width, int height)
{
reshape(width, height);
glClearColor(0.1f, 0.5f, 0.7f, 1.0f);
glClearDepth(1.0f);
glOrtho(0, 1, 0, 1, 1, 10);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
}
/* initialize GLUT settings, register callbacks, enter main loop */
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(800, 800);
glutInitWindowPosition(100, 100);
glutCreateWindow("Perspective's GLUT Template");
glutKeyboardFunc(keyboardDown);
glutKeyboardUpFunc(keyboardUp);
glutSpecialFunc(keyboardSpecialDown);
glutSpecialUpFunc(keyboardSpecialUp);
glutReshapeFunc(reshape);
glutDisplayFunc(draw);
glutIgnoreKeyRepeat(true); // ignore keys held down
initGL(800, 600);
glutMainLoop();
return 0;
}
When I start the program, it writes 'e' only when I press on the mouse. I can't find the problem. Why does it only work when the mouse is held down?
You dont have mouse functions in your code, thats why it is not working. Insert from here : http://www.zeuscmd.com/tutorials/glut/03-MouseInput.php
#include <iostream>
#include <gl/glut.h>
using namespace std;
bool lbuttonDown = false;
bool init()
{
return true;
}
void display()
{
}
void mouse(int button, int state, int x, int y)
{
if (button == GLUT_RIGHT_BUTTON)
{
if (state == GLUT_DOWN)
cout << "Right button pressed"
<< endl;
else
cout << "Right button lifted "
<< "at (" << x << "," << y
<< ")" << endl;
}
else if (button == GLUT_LEFT_BUTTON)
{
if (state == GLUT_DOWN)
lbuttonDown = true;
else
lbuttonDown = false;
}
}
void motion(int x, int y)
{
if (lbuttonDown)
cout << "Mouse dragged with left button at "
<< "(" << x << "," << y << ")" << endl;
}
void motionPassive(int x, int y)
{
cout << "Mouse moved at "
<< "(" << x << "," << y << ")" << endl;
}
void entry(int state)
{
if (state == GLUT_ENTERED)
cout << "Mouse Entered" << endl;
else
cout << "Mouse Left" << endl;
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitWindowPosition(200, 200);
glutInitWindowSize(200, 200);
glutCreateWindow("03 - Mouse Input");
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutPassiveMotionFunc(motionPassive);
glutEntryFunc(entry);
if (!init())
return 1;
glutMainLoop();
return 0;
}
I had the same problem [using freeglut] and calling 'draw()' [or whatever display callback you use] right after glutPostRedisplay() in the key callback function forced it to do the redraw. I actually don't know why it behaves like this. After data is changed by keyboard input and the key callback returned, a redraw is expected but not executed.
Related
I need help in understanding how to scale my coordinates. The instruction says, modify the code to move the triangle to the mouse click position. Can someone explain how this is done?
Here is the source code I'm working with:
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <stddef.h>
#include <iostream>
// values controlled by fast keys
float g_angle = 0.0f;
float g_xoffset = 0.0f;
float g_yoffset = 0.0f;
int x;
int y;
// increments
const float g_angle_step = 32.0f; // degrees
const float g_offset_step = 32.0f; // world coord units
// last cursor click
int g_cursor_x = 0;
int g_cursor_y = 0;
void draw_triangle()
{
// in model cooridnates centred at (0,0)
static float vertex[3][2] =
{
{-1.0f, -1.0f},
{1.0f, -1.0f},
{0.0f, 1.0f}
};
glBegin(GL_LINE_LOOP);
for (size_t i=0;i<3;i++)
glVertex2fv(vertex[i]);
glEnd();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0f, 1.0f, 1.0f);
glLineWidth(2.0f);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(500.0f+g_xoffset, 500.0f+g_yoffset, 0.0f);
glScalef(100.0f, 100.0f, 1.0f);
glRotatef(g_angle, 0.0f, 0.0f, 1.0f);
draw_triangle();
glPopMatrix(); // done with stack
glutSwapBuffers();
}
// handles mouse click events
// button will say which button is presed, e.g. GLUT_LEFT_BUTTON, GLUT_RIGHT_BUTTON
// state will say if the button is GLUT_UP or GLUT_DOWN
// x and y are the poitner position
void mouse_click(int button, int state, int x, int y)
{
if (button==GLUT_LEFT_BUTTON)
{
std::cerr << "\t left mouse button pressed!" << std::endl;
if (state==GLUT_UP)
{
std::cerr << "\t button released...click finished" << std::endl;
g_cursor_x = x;
g_cursor_y = y;
std::cerr << "\t cursor at (" << g_cursor_x << ", " <<
g_cursor_y << ")" << std::endl;
}
}
else
if (button==GLUT_RIGHT_BUTTON)
{
std::cerr << "\t right mouse button pressed!" << std::endl;
}
// Here is my attempt:
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
float x_min = (-x+500)/512;
float x_max = (x-500)/512;
float y_min = (-y+500)/512;
float y_max = (y-500)/512;
gluOrtho2D(x_min, x_max, y_min, y_max);
//glTranslatef(x/512, 1-y/512, 0.0f);
std::cerr << x << ", " << y << std::endl;
}
glutPostRedisplay();
}
void mouse_motion(int x, int y)
{
std::cerr << "\t mouse is at (" << x << ", " << y << ")" << std::endl;
glutPostRedisplay();
}
// will get which key was pressed and x and y positions if required
void keyboard(unsigned char key, int, int)
{
std::cerr << "\t you pressed the " << key << " key" << std::endl;
switch (key)
{
case 'q': exit(1); // quit!
// clockwise rotate
case 'r': g_angle += g_angle_step; break;
}
glutPostRedisplay(); // force a redraw
}
// any special key pressed like arrow keys
void special(int key, int, int)
{
// handle special keys
switch (key)
{
case GLUT_KEY_LEFT: g_xoffset -= g_offset_step; break;
case GLUT_KEY_RIGHT: g_xoffset += g_offset_step; break;
case GLUT_KEY_UP: g_yoffset += g_offset_step; break;
case GLUT_KEY_DOWN: g_yoffset -= g_offset_step; break;
}
glutPostRedisplay(); // force a redraw
}
void init()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, 1000, 0, 1000);
glClearColor(0.0f, 0.0f, 1.0f, 0.0f);
g_cursor_x = g_cursor_y = 500; // middle of window
}
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
glutInitWindowSize(512, 512);
glutInitWindowPosition(50, 50);
glutCreateWindow("Mouse Test");
glutDisplayFunc(display);
// handlers for keyboard input
glutKeyboardFunc(keyboard);
glutSpecialFunc(special);
// mouse event handlers
glutMouseFunc(mouse_click);
glutPassiveMotionFunc(mouse_motion);
init();
glutMainLoop();
return 0;
}
This should solve your issue.replace your code(your attempt) with the code below.
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
g_xoffset = x;
g_yoffset = 1000-y;
} glutPostRedisplay();
I tried to convert the mouse coords in click to opengl coords. Actually it seems to work, but when I uncomment a cout-line that I just wrote for testing it sets my vars to not a number -nan.
How does it happen? How can I fix it?
//global:
GLdouble mouseOgl[3] = {0.0,0.0,0.0};
//handle click events of the mouse
void myMouse(int button, int state, int x, int y)
{
//mouse coords to gl coords
switch (button)
{
case GLUT_LEFT_BUTTON:
if(state == GLUT_UP){ //on release left mouse button
std::cout << x << " * "<< y << std::endl;
GetOGLPos(x, y);
std::cout
<< mouseOgl[0] << " # "
<< mouseOgl[1] << " # "
<< mouseOgl[2] << " # "
<< std::endl;
glutPostRedisplay();
}
break;
}
}
whole code here:
#include <iostream>
#include <stdlib.h>
#include <string>
#include <fstream>
#include <math.h>
#include <time.h>
#include <GL/glut.h>
const GLint nNumPoints = 5;
GLfloat ctrlpoints[5][3] = {
{ -4.0, -4.0, 0.0}, { -2.0, 4.0, 0.0},
{2.0, -4.0, 0.0}, {4.0, 4.0, 0.0}, {6.0, 2.0, 0.0}};
GLdouble mouseOgl[3] = {0.0,0.0,0.0};
void GetOGLPos(int x, int y);
void init(void)
{
glClearColor(1.0, 1.0, 1.0, 0.0);
glShadeModel(GL_FLAT);
glMap1f(GL_MAP1_VERTEX_3, // Type of data generated
0.0f, // Lower u range
1.0f, // Upper u range
3, // Distance between points in the data
nNumPoints, // number of control points
&ctrlpoints[0][0]); // array of control points
// Enable the evaluator
glEnable(GL_MAP1_VERTEX_3);
glEnable(GL_DEPTH);
}
void display(void)
{
int i;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0, 0.0, 1.0);
glBegin(GL_LINE_STRIP);
for (i = 0; i <= 30; i++)
glEvalCoord1f((GLfloat) i/30.0);
glEnd();
//Kontrollpunkte:
glPointSize(5.0);
glColor3f(1.0, 0.0, 0.0);
glBegin(GL_POINTS);
for (i = 0; i < nNumPoints; i++)
glVertex3fv(&ctrlpoints[i][0]);
glEnd();
glColor3f(0.0, 1.0, 0.0);
glBegin(GL_LINE_STRIP);
for (i = 0; i < nNumPoints; i++)
glVertex3fv(&ctrlpoints[i][0]);
glEnd();
glFlush();
}
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
//keep aspect ratio:
if (w <= h)
glOrtho(-10.0, 10.0, -10.0*(GLfloat)h/(GLfloat)w,
10.0*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
else
glOrtho(-10.0*(GLfloat)w/(GLfloat)h,
10.0*(GLfloat)w/(GLfloat)h, -10.0, 10.0, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
//handle click events of the mouse
void myMouse(int button, int state, int x, int y)
{
//mouse coords to gl coords
switch (button)
{
case GLUT_LEFT_BUTTON:
if(state == GLUT_UP){ //on release left mouse button
std::cout << x << " * "<< y << std::endl;
GetOGLPos(x, y);
std::cout
<< mouseOgl[0] << " # "
<< mouseOgl[1] << " # "
<< mouseOgl[2] << " # "
<< std::endl;
glutPostRedisplay();
}
break;
}
}
// detailed information:
// http://nehe.gamedev.net/article/using_gluunproject/16013/
void GetOGLPos(int x, int y)
{
//init vars:
GLint viewport[4];
GLdouble modelview[16];
GLdouble projection[16];
GLfloat winX, winY, winZ;
GLdouble posX, posY, posZ;
//get gl specs
glGetDoublev( GL_MODELVIEW_MATRIX, modelview ); //get Modelmatrix
glGetDoublev( GL_PROJECTION_MATRIX, projection ); //get projection matrix
glGetIntegerv( GL_VIEWPORT, viewport ); //get viewport values
//calculate the gl mouseposition
winX = (float)x;
winY = (float)viewport[3] - (float)y;
glReadPixels( x, int(winY), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ );
gluUnProject( winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ);
/*
following line needed to run the program propper?!?!
*/
std::cout << "positions:" << posX << " | " << posY << " | " << posZ << std::endl;
mouseOgl[0] = posX;
mouseOgl[1] = posY;
mouseOgl[2] = posZ;
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (600, 600);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(myMouse);
glutMainLoop();
return 0;
}
mouse callback can be called any time, so you are not sure what is the proper state of your rendering code when you are in that callback...
I think You should mark that the mouse was pressed (save it to some variable wasMousePressed = true;) in this callback and then check mouse hits in your OnRender function. That way it will be synchronized with the opengl. Then check if your cout code works properly.
onMouse() {
if (...)
mousePressed = true;
else
mousePressed = false;
}
onRender() {
clearBuffer();
setupCameraAndProjection();
if (mousePressed)
checkOGLState();
render...
}
I have written a color picker in C++ using OpenGL but I cannot figure out how to color a polygon (or anything else for that matter) with the colors I have stored. Do I need to put the draw function in some kind of loop or is there a better way to do this?
#ifdef __APPLE__
# include <OpenGL/gl.h>
# include <OpenGL/glu.h>
# include <GLUT/glut.h>
#else
# include <GL/gl.h>
# include <GL/glu.h>
# include <GL/glut.h>
#endif
#include <iostream>
#include <cmath>
using namespace std;
#define WIDTH 750
#define HEIGHT 750
int i=0,mousex, mousey;
float pick[3];
bool mouseleftdown = false;
void hex(void){
glBegin(GL_POLYGON);
glColor3f(1,0,0); //red
glVertex2f(0, 2); //top
glColor3f(1,.38,.01); //orange
glVertex2f(2, 1); //top right
glColor3f(1,1,0); //yellow
glVertex2f(2, -1); //bottom right
glColor3f(0,1,0); //green
glVertex2f(0, -2); //bottom
glColor3f(0,0,1); //blue
glVertex2f(-2, -1); //bottom left
glColor3f(.8,0,.8); //purple
glVertex2f(-2, 1); //top left
glEnd();
glEnd();
}
void square(void){
glBegin(GL_POLYGON);
glVertex2i(1, -1);
glVertex2i(1, 1);
glVertex2i(-1, 1);
glVertex2i(-1, -1);
glEnd();
}
void mouse(int button, int state, int x, int y){
// Save the left button state
/*if (button == GLUT_LEFT_BUTTON)
{
if (state == GLUT_DOWN)
glutPostRedisplay(); // Left button has changed; redisplay!
}*/
// Save the mouse position
mousex = x;
mousey = y;
glReadPixels(mousex , mousey , 1 , 1 , GL_RGB , GL_FLOAT , &pick);
cout << pick[0] <<"pick";
cout << " mouse x " << mousex << "\n";
cout << " mouse y " << mousey << "\n";
fflush(stdout);
cout << "pick R: " << pick[1] << "\n";
cout << "pick G: " << pick[0] << "\n";
cout << "pick B: " << pick[2] << "\n";
}
void draw(void){
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glScalef(20,20,1);
hex();
glPopMatrix();
glPushMatrix();
glTranslatef(100,100,0);
glColor3f(pick[1],pick[0],pick[2]);
glScalef(20,20,1);
square();
glPopMatrix();
glFlush();
}
void my_init(void){
//glClearColor(0, 0, 0, 1); //sets clear color
glLineWidth(4);
gluOrtho2D(-100, 100, -100, 100); //sets origin
}
int main(int argc, char* argv[ ]){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(WIDTH, HEIGHT);
glutCreateWindow("Color Picker");
glutDisplayFunc(draw);
glutMouseFunc(mouse);
my_init();
glClearColor(1, 1, 1, 0);
glutMainLoop(); //listens for events
return 0;
}
You have to simply add the line:
glutPostRedisplay();
at the end of your mouse callback function.
This is because you always have to explicitly tell glut when to refresh the window.
#include "std_lib_facilities.h"
#include <GL/glut.h>
static float dx=0.0;
static float dz=10;
static float points[2];
static float cx=0.0;
static float cy=0.0;
static float cz=0.0;
static float spin=0.0;
static float rotation=1.0;
int readObject()
{
ifstream inputFile("spikeBall.ogl");
if(!inputFile)
{
cerr << "cannot open file spikeBall.ogl" << endl;
return -1;
}
int count = 0;
float x,y,z;
do{
inputFile >> count;
glBegin(GL_POLYGON);
for(int i=0;i<count;i++)
{
inputFile >> x >> y >> z;
glVertex3f(((x/5)+cx),((y/5)+cy),((z/5)+cz));
}
glEnd();
}while(count!=0);
inputFile.close();
}
void init(void)
{
glClearColor(0.0,0.0,0.0,0.0);
}
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glLoadIdentity();
gluLookAt (0,0,20, 0.0,0.0,0.0, 0.0,1.0,0.0);
glPushMatrix();
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLfloat aMaterial[]={0.1745,0.01175,0.01175,1.0};
GLfloat bMaterial[]={0.61424,0.04136,0.04136,1.0};
GLfloat cMaterial[]={0.727811,0.626959,0.626959,1.0};
GLfloat dMaterial=40;
glMaterialfv(GL_FRONT,GL_AMBIENT,aMaterial);
glMaterialfv(GL_FRONT,GL_DIFFUSE,bMaterial);
glMaterialfv(GL_FRONT,GL_SPECULAR,cMaterial);
glMaterialf(GL_FRONT,GL_SHININESS,dMaterial);
readObject();
glRotatef(spin,0.0,1.0,0.0);
glPopMatrix();
glFlush();
}
void idleFunc(void)
{
spin+=rotation;
if(spin>360.0)
{
spin-=360.0;
}
cz+=0.1;
if(cz==20)
{
srand((unsigned int) time(NULL));
for(int i=0;i<2;i++)
{
points[i] = (rand()%20)-10;
}
cx = points[0];
cy = points[1];
cz = 0;
GLfloat lightPos[] = {cx,cy,(cz+2),1.0};
glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
std::cout << "cx:" << cx;
std::cout << "cy:" << cy;
std::cout << "cz:" << cz;
}
else
{
}
glutPostRedisplay();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0,20.0);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(300,300);
glutInitWindowPosition(0,0);
glutCreateWindow("3ds Max loader");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
init();
glutIdleFunc(idleFunc);
glutMainLoop();
return(0);
}
iat the moment it's just moving forward, i want it to spin too, but everywhere i put it, it's either not spinning or it makes the sphere look like it just blew up ( like when i put it after glEnd())
I would create an update loop where you could call all of your logic functions, and create a new seperate Rotate() function then call it there. The general format for games programming I usually follow is:
main()
{
init();
while(gameOn)
{
update();
draw();
}
}
init()
{
//create textures, etc.
}
update()
{
//do logic
}
draw()
{
//display on screen after update
}
I am having trouble setting a orthographical projection matrix of dimensions 4x2 with (0,0) being in the center, (-2, -1) being at the bottom left corner, and (2, 1) being at the top right corner.
I use glutInitWindowSize(600, 300); to initialize the window size.
In my reshape function, I use glViewport(0, 0, w, h); to set the viewport.
Also in my reshape function, I use gluOrtho2D(-(float)w/h, (float)w/h, -2.0, 2.0); to set the ortho.
However, when I move my mouse around to see the world coordinates, the bottom left corner is (-1, -1) and the top right corner is (1, 1). Is there something I am doing wrong here? I am assuming since I am setting bottom and top to -2 and 2 respectively in the gluOrtho2D call, it should give me the right coordinates.
Please help me out if you see anything that might be wrong.
Here is my code so far, please ignore the arm variables and drawing functions.
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <iostream>
#if 0 /*unix*/
#include <GL/glut.h>
#endif
#if 1 /*apple */
#include <GLUT/glut.h>
#include <OPENGL/gl.h>
#include <OPENGL/glext.h>
#endif
#if 0 /*windows*/
#include <io.h>
#include <fcntl.h>
#include <glut.h>
#endif
int GW, GH;
bool animfore, animupper;
float foreangle, upperangle;
using namespace std;
void drawShoulder();
void drawUpper();
void drawFore();
void display() {
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
//draw shoulder
glPushMatrix();
drawShoulder();
//draw upper arm
glPushMatrix();
drawUpper();
//draw forearm
glPushMatrix();
drawFore();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glutPostRedisplay();
glutSwapBuffers();
}
void drawShoulder() {
//cout << "Enters" << endl;
glBegin(GL_POLYGON);
glColor3f((float)30/255, (float)0/255, (float)30/255);
glVertex2f(-2.0, -0.4);
glVertex2f(-2.0, -1.0);
glVertex2f(-1.0, -1.0);
glVertex2f(-1.0, -0.4);
glEnd();
}
void drawUpper() {
}
void drawFore() {
}
void reshape(GLsizei w, GLsizei h) {
GW = w;
GW = h;
glViewport(0, 0, w, h);
glLoadIdentity();
gluOrtho2D(-(float)w/h, (float)w/h, -1.0, 1.0);
cout << "Enters" << endl;
}
void keyboard(unsigned char key, int x, int y) {
switch(key) {
case 'q' : case 'Q' :
exit(EXIT_SUCCESS);
break;
}
}
//control arm animations
void idle() {
if(animupper) {
}
if(animfore) {
}
}
float p2w_x(int gx) {
return (float)2.*GW/(GW*GH-GH)*gx-(float)GW/GH;
}
float p2w_y(int gy) {
int py = GH-1-gy;
return (float)2./(GH-1.)*py-1;
}
void mouseMove(int x, int y) {
cout << "(" << p2w_x(x) << "," << p2w_y(y) << ")" << endl;
}
int main(int argc, char **argv) {
// global variable intializations
GW = 600;
GH = 300;
animfore, animupper = true;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE);
// initialization
glutInitWindowSize(600, 300);
glutInitWindowPosition(100, 100);
glutCreateWindow("Robot Arm");
glClearColor(1.0, 1.0, 1.0, 1.0);
// callback functions
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutMotionFunc(mouseMove);
glutMainLoop();
}
Try setting glMatrixMode( GL_PROJECTION ) before you make your ortho call and then set it back to GL_MODELVIEW when you do your transformations.