lines not rendering after switching to freeglut

Question

I had a project that i was using glut in - however i went to free glut in order to be able to use

glutBitmapCharacter

However when I did that what I was using to draw a grid no longer works

//This creates the grid 
    for(float f = -1;f<1; f+=0.05){
    glBegin(GL_LINE_STRIP);
        glVertex2f(f,-1);
        glVertex2f(f,1);
        glEnd();
        glBegin(GL_LINE_STRIP);
        glVertex2f(-1,f);
        glVertex2f(1,f);
        glEnd();
    }

Full class:

   #include<stdlib.h>
    #include<windows.h>
    #include<GL/glut.h>
    #include<GL/freeglut.h>
    #include<iostream>
    #include <vector>
    #include "include/Block.h"
    #include <string>


    using namespace std;

    void drawBitmapText(char *string, float x, float y, float z);
    void reshape(int w, int h);
    void render(void);
    void keyboard(unsigned char c,int x,int y);
    void mouse(int button,int state, int x, int y);


    vector <Block> blockList;
    int screenXSize=800;
    int screenYSize=800;
    int selectedBlockType = 0;
    int main(int argc, char ** argv){


    blockList.push_back(*new Block(0,1,1));

    Block Test = blockList.at(0);
    string s = Test.getName();



    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowPosition(100,100);
    glutInitWindowSize(screenXSize,screenYSize);
    glutCreateWindow("TITLE");
    glutDisplayFunc(render);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);
    glutMouseFunc(mouse);
    glutMainLoop();








    }
    void mouse(int button,int state, int x, int y){
        if(button==GLUT_RIGHT_BUTTON){


        }
         if(button==GLUT_LEFT_BUTTON){


        }

    }
    void keyboard(unsigned char c,int x,int y){
        if (c==27){
            exit(0);
        }

    }
void reshape(int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h); 
   glMatrixMode (GL_PROJECTION); 
   glLoadIdentity (); ...

   gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h);
}
void drawBitmapText(char *string, float x, float y, float z)
{
    char *c;
    glRasterPos3f(x, y, z);

    for (c=string; *c != '\0'; c++)
    {
        glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, *c);
    }
}
    void render(void){

    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);


    drawBitmapText("CAN YOU READ ME?",200,200,0);




    //This creates the grid 
    for(float f = -1;f<1; f+=0.05){
    glBegin(GL_LINE_STRIP);
        glVertex3f(f,-1);
        glVertex3f(f,1);
        glEnd();
        glBegin(GL_LINE_STRIP);
        glVertex2f(-1,f);
        glVertex2f(1,f);
        glEnd();
    }

Any help is much appreciated

    glutSwapBuffers();

    glFlush();
    }

However I am able to run the sample project

/*
 * GLUT Shapes Demo
 *
 * Written by Nigel Stewart November 2003
 *
 * This program is test harness for the sphere, cone
 * and torus shapes in GLUT.
 *
 * Spinning wireframe and smooth shaded shapes are
 * displayed until the ESC or q key is pressed.  The
 * number of geometry stacks and slices can be adjusted
 * using the + and - keys.
 */

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

#include <stdlib.h>

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

/* GLUT callback Handlers */

static void resize(int width, int height)
{
    const float ar = (float) width / (float) height;

    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity() ;
}

static void display(void)
{
    const double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
    const double a = t*90.0;

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3d(1,0,0);

    glPushMatrix();
        glTranslated(-2.4,1.2,-6);
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutSolidSphere(1,slices,stacks);
    glPopMatrix();

    glPushMatrix();
        glTranslated(0,1.2,-6);
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutSolidCone(1,1,slices,stacks);
    glPopMatrix();

    glPushMatrix();
        glTranslated(2.4,1.2,-6);
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutSolidTorus(0.2,0.8,slices,stacks);
    glPopMatrix();

    glPushMatrix();
        glTranslated(-2.4,-1.2,-6);
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutWireSphere(1,slices,stacks);
    glPopMatrix();

    glPushMatrix();
        glTranslated(0,-1.2,-6);
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutWireCone(1,1,slices,stacks);
    glPopMatrix();

    glPushMatrix();
        glTranslated(2.4,-1.2,-6);
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutWireTorus(0.2,0.8,slices,stacks);
    glPopMatrix();

    glutSwapBuffers();
}


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

        case '+':
            slices++;
            stacks++;
            break;

        case '-':
            if (slices>3 && stacks>3)
            {
                slices--;
                stacks--;
            }
            break;
    }

    glutPostRedisplay();
}

static void idle(void)
{
    glutPostRedisplay();
}

const GLfloat light_ambient[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat light_diffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_position[] = { 2.0f, 5.0f, 5.0f, 0.0f };

const GLfloat mat_ambient[]    = { 0.7f, 0.7f, 0.7f, 1.0f };
const GLfloat mat_diffuse[]    = { 0.8f, 0.8f, 0.8f, 1.0f };
const GLfloat mat_specular[]   = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat high_shininess[] = { 100.0f };

/* 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("GLUT Shapes");

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

    glClearColor(1,1,1,1);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);

    glEnable(GL_LIGHT0);
    glEnable(GL_NORMALIZE);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_LIGHTING);

    glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);

    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, high_shininess);

    glutMainLoop();

    return EXIT_SUCCESS;
}

Answer 1

The problem is that your grid is being clipped (discarded) by OpenGL because it's outside of the viewing frustum.

In your reshape function, you set the region for objects to be (0, width) in the x direction, and (0, height) in the y direction with the call to gluOrtho2D. That in itself isn't an issue, but the coordinates you use for your grid is (-1,1). If you look closely at your window, you'll see the pixel in the lower-left corner lit up.

The fundamental thing you need to do is figure out which space you want to draw into. With the gluOrtho2D you have, you're effectively rendering in window coordinates, and so if you update your grid to render from [0, width] as compared to [-1,1], your grid will appear as well as the text. Conversely, if you want to use the coordinate space of your grid, update the gluOrtho2D function to gluOrtho2D( -1, 1, -1, 1 ), and update the position you render your text at to be within that square.

One other minor point, there's a primitive type named GL_LINES, which will draw a line segment between every two vertices. In your grid rendering loop, you can be more efficient by writing the loop as

glBegin( GL_LINES );
for ( float f = -1; f < 1; f += 0.05 ) {
    glVertex2f( f, -1 );
    glVertex2f( f , 1 );
    glVertex2f( -1, f );
    glVertex2f(  1, f );
}
glEnd();

(oh, and in your example, you mix glVertex2f, and glVertex3f [which is perfectly legal OpenGL], except that in your use of glVertex3f, you only provide two parameters causing a syntax error)