ansaurus

Question

opengl: how to keep objects in window when it's resized

Answer 1

+3 A:

Don't think of it as "keeping them drawn". Think instead in terms of events and "when do I need to redraw my objects".

For this you will need to handle the resize event and rerun your drawing code. I'm also guessing that your objects might not redraw themselves after another application is moved over them, or if it is moved off screen a little and then brought back. If this is the case you'll need to figure out what events to handle that will cause a redraw as well.

Paul Sasik 2010-10-15 02:58:03

how can I rerun the drawing code? Shall I keep a stack with the operations I have done? If so, could you supply an example?

omgzor 2010-10-15 03:43:18

@omgzor: My answer is very high-level and conceptual. Check BugKiller and VJo's answers for the detailed specifics. And one more conceptual idea: don't think of it as a stack of operations. Think of a collection (array) of primitives (drawing objects) that need to be redrawn frequently.

Paul Sasik 2010-10-15 12:31:11

Answer 2

+3 A:

First of all , you need to arrange the code. You must have one and only one display function, that clears the buffer,calls the other draw-functions and flushes them to the screen ( or swaps the buffer if you are using a double buffer).

On resizing the window,GLUT will call the Display Function which is renderPoint() as you know :

glutDisplayFunc (renderPoint);

renderPoint clears the buffer before redrawing the "points" , for example :

void renderPoint(void) /*REVISAR ESTO*/
{
    glClear (GL_COLOR_BUFFER_BIT);
    glBegin (GL_POINTS);
        glVertex2f  (-0.98, 0.98);
    glEnd ();
    glFlush ();
}

Since the buffer has been cleared , all the points that are drawn outside the function renderPoint ( the points of circles, the points of lines .. ) has no meaning , because you did not call them from the "main display function which is renderPoint.

How to keep the points on the screen ?

You must store the points ( any point you want to draw ) in a buffer such as an array , a dynamic array, std::vector or anything else. in the display function , write a loop statement to visit each point and extract the x and y .. then draw them.

for example , instead of the above function , replace it with :

class MyPoint {
    public:
    float x;
    float y;
    MyPoint(float x, float y)
    {
        this->x = x;
        this->y = y;
    } };

#include <vector> 
std::vector<MyPoint> testPoints;

void renderPoint(void) /*REVISAR ESTO*/ {
    testPoints.push_back(MyPoint(-0.58,0.58));
    testPoints.push_back(MyPoint(0.58,0.58));
    testPoints.push_back(MyPoint(0.58,-0.58));

    glClear (GL_COLOR_BUFFER_BIT);
    glPointSize(2);

    glBegin (GL_POINTS);
        for(int i=0;i<testPoints.size();i++)
        {
          glVertex2f  (testPoints[i].x, testPoints[i].y);
        }
    glEnd ();

    glFlush (); 
}

as you can see , by using a dynamic array such as (std::vector) to store the points and by using a for loop statement , we able to keep the three points visible.

what else ?

do the same method with other shapes , so that for each "mouse click " event , you may add or push_back two points represents a line end points in an array or std::vector called lineArray . in the display function , make a for loop statement to draw each line after extracting the two line points.
you should use glutReshapeFunc and glViewport to make sure that the viewport has the same dimenstions as the window after the resizing event. and I think that gluOrtho2d is more elegant than trying to mapping from Windows coordinates space to OpenGL coordinates space
arrange your code , so that you just use one display function.

Your program could be Something like this:

void drawTestPoints()
{
  for(int i=0;i<length;i++)
  {
      renderPoint(pointsArray[i].x,pointsArray[i].y);// vector of points/(MyPoint)

  }

}

void drawLines()
{
  for(int i=0;i<length;)
  {

      MyPoint startPoint = linesArray[i];
      MyPoint endPoint = linesArray[i+1];
      bresenham1(startPoint.x,endPoint.x,startPoint.y,endPoint.y);
      i+=2;
  }

}

void drawAll()
{
  glClear (GL_COLOR_BUFFER_BIT);

    drawTestPoints();
    drawLines();
    drawOtherShapes();

  glFlush();
}

.
.
.

// in the main func:
glutDisplayFunc (drawAll);

==

BugKiller 2010-10-15 04:49:40

Thanks, very detailed, though I don't know how to arrange this code to use just one display function. What's wrong with the current approach I'm using?

omgzor 2010-10-16 00:49:09

For any GLUT apps , there is only one display function that will be called after (resizing/repainting events occur ). so the buffer will be cleared and OpenGL will redraw the points on the buffer. In your way, the points would be removed if the repainting event occured, so use the display function as a main display function which call other functions that draw other shapes, those functions have a for loop statements to draw the points that is stored in an array.

BugKiller 2010-10-16 00:55:40

I've added an example in last paragraph of the answer ( to clear what I meant by arrangement).

BugKiller 2010-10-16 01:20:32

Answer 3

+2 A:

Here is a quick example for windows : http://www.falloutsoftware.com/tutorials/gl/gl2.htm

VJo 2010-10-15 10:17:52

ansaurus

tags:

views:

answers:

opengl: how to keep objects in window when it's resized

related questions