Basic rendering of comet Wild 2 shape data using OpenGL

Question

I want to learn OpenGL, and decided to start with a very simple example - rendering the shape of comet Wild 2 as inferred from measurements from the Stardust spacecraft (details about the data in: http://nssdc.gsfc.nasa.gov/nmc/masterCatalog.do?ds=PSSB-00133). Please keep in mind that I know absolutely NOTHING about OpenGL. Some Google-fu helped me get as far as the code presented below. Despite my best efforts, my comet sucks:

I would like for it to look prettier, and I have no idea how to proceed (besides reading the Red book, or similar). For example:

• How can I make a very basic "wireframe" rendering of the shape?
• Suppose the Sun is along the "bottom" direction (i.e., along -Y), how can I add the light and see the shadow on the other side?
• How can I add "mouse events" so that I can rotate my view by, and zoom in/out?

How can I make this monster look prettier? Any references to on-line tutorials, or code examples?

I placed the source code, data, and makefile (for OS X) in bitbucket:

hg clone https://arrieta@bitbucket.org/arrieta/learning-opengl

The data consists of 8,761 triplets (the vertices, in a body-fixed frame) and 17,518 triangles (each triangle is a triplet of integers referring to one of the 8,761 vertex triplets).

#include<stdio.h>
#include<stdlib.h>

#include<OpenGL/gl.h>
#include<OpenGL/glu.h> 
// I added this in case you want to "copy/paste" the program into a
// non-Mac computer
#ifdef __APPLE__
#  include <GLUT/glut.h>
#else
#  include <GL/glut.h>
#endif

/* I hardcoded the data and use globals. I know it sucks, but I was in
   a hurry. */
#define NF 17518
#define NV 8761
unsigned int fs[3 * NF];
float vs[3 * NV];
float angle = 0.0f;

/* callback when the window changes size (copied from Internet example) */
void changeSize(int w, int h) {
  if (h == 0) h = 1;  
  float ratio =  w * 1.0 / h;
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glViewport(0, 0, w, h);
  gluPerspective(45.0f, ratio, 0.2f, 50000.0f); /*  45 degrees fov in Y direction; 50km z-clipping*/
  glMatrixMode(GL_MODELVIEW);
}

/* this renders and updates the scene (mostly copied from Internet examples) */
void renderScene() {
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  
  glLoadIdentity();
  gluLookAt(0.0f, 0.0f,  10000.0f, /* eye is looking down along the Z-direction at 10km */
            0.0f, 0.0f,  0.0f,     /* center at (0, 0, 0) */
            0.0f, 1.0f,  0.0f);    /* y direction along natural y-axis */

  /* just add a simple rotation */
  glRotatef(angle, 0.0f, 0.0f, 1.0f);    
  /* use the facets and vertices to insert triangles in the buffer */
  glBegin(GL_TRIANGLES);
  unsigned int counter;
  for(counter=0; counter<3 * NF; ++counter) {
    glVertex3fv(vs + 3 * fs[counter]); /* here is where I'm loading
                                          the data - why do I need to
                                          load it every time? */
  }
  glEnd();  
  angle += 0.1f;                /* update the rotation angle */
  glutSwapBuffers();  
}


int main(int argc, char* argv[]) {
  FILE *fp;
  unsigned int counter;


  /* load vertices */
  fp = fopen("wild2.vs", "r");
  counter = 0;
  while(fscanf(fp, "%f", &vs[counter++]) > 0);
  fclose(fp);

  /* load facets */
  fp = fopen("wild2.fs", "r");
  counter = 0;
  while(fscanf(fp, "%d", &fs[counter++]) > 0);
  fclose(fp);

  /* this initialization and "configuration" is mostly copied from Internet */
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
  glutInitWindowPosition(0, 0);
  glutInitWindowSize(1024, 1024);
  glutCreateWindow("Wild-2 Shape");

  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glEnable(GL_DEPTH_TEST);

  GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  GLfloat mat_shininess[] = { 30.0 };
  GLfloat light_position[] = {3000.0, 3000.0, 3000.0, 0.0 };
  glClearColor (0.0, 0.0, 0.0, 0.0);
  glShadeModel (GL_SMOOTH);
  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);

  glutDisplayFunc(renderScene);
  glutReshapeFunc(changeSize);
  glutIdleFunc(renderScene);

  glutMainLoop();
  return 0;  
}

EDIT

It is starting to look better, and I have now plenty of resources to look into for the time being. It still sucks, but my questions have been answered!

I added the normals, and can switch back and forth between the "texture" and the wireframe:

PS. The repository shows the changes made as per SeedmanJ's suggestions.

Answer 1

It's really easy to change to a wireframe rendering in OpenGL, you'll have to use

glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

and to switch back to a fill rendering,

glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

About the lights, OpenGL allows you to use at most 8 different lights, generating your final rendering thanks to the normals, and materials. You can activate a lighting mode with:

glEnable(GL_LIGHTING);

and then activate each of your lights with either:

 glEnable(GL_LIGHT0);
 glEnable(GL_LIGHT1);

to change a light property like its position, please look at http://linux.die.net/man/3/gllightfv

You'll have to set up your normals for each vertices you define, if your using the glBegin() method. In VBO rendering it's the same but normals are also contained in the vram. In the glBegin() method, you can use

glNormal3f(x, y, z); for example

for each vertex you define.

And for more information about what you can do, the redbook is a good way to begin.

Moving your "scene" is one more thing OpenGL indirectly allows you to do. As it all works with matrix,

you can either use

glTranslate3f(x, y, z);
glRotate3f(num, x, y, z);
....

Managing key events and mouse events has (i'm almost sure about that) nothing to do with OpenGL, it depends on the lib your using, for example glut/SDL/... so you'll have to refer to their own documentations.

Finaly, for more further information about some of the functions you can use, http://www.opengl.org/sdk/docs/man/, and there's also a tutorial part, leading you to different interesting websites.

Hope this helps!

Answer 2

How can I make a very basic "wireframe" rendering of the shape?

glPolygonMode( GL_FRONT, GL_LINE );

Suppose the Sun is along the "bottom" direction (i.e., along -Y), how can I add the light and see the shadow on the other side?

Good shadows are hard, especially with the fixed-function pipeline.

But before that you need normals to go with your vertices. You can calculate per-face normals pretty easily.

How can I add "mouse events" so that I can rotate my view by, and zoom in/out?

Try the mouse handlers I did here.

Answer 3

Though I some like to say "Start with something simpler", I think, sometimes you need to "dive in" to get a good understanding, on a small time span! Well done!

Also if you would like an example, please ask... I have written a WELL DOCUMENTED, and efficient, but readable pure Win32 (No .NET, or MFC) OpenGL FPS!

Though it appears other people answered most of you questions... I can help you if you would like, maybe make a cool texture (if you don't have one)...

To answer this question:

    glBegin(GL_TRIANGLES);
    unsigned int counter;
    for(counter=0; counter<3 * NF; ++counter) {
    glVertex3fv(vs + 3 * fs[counter]); /*   here is where I'm loading
                                            the data - why do I need to
                                            load it every time? */
}
glEnd();

That is rendering the vertices of the 3D Model (in the case the view has changed) and using the DC (Device Context), BitBlt's it- onto the Window! It has to be done repeatedly (in case something has caused the window to clear)...