text: 
  /* This source code is based on Direct3D-based code written by Stephen
     Coy of Microsoft.  All credit for the original implementation of the
     idea should go to Stephen.  While I referenced Stephen's code during
     the writing of my code, my code was completely written by me from
     scratch.  The algorithms are basically the same to ease critical
     comparison of the OpenGL and Direct3D versions.  */
  
  /* The image files used by this program are derived from images
     developed by Microsoft. */
  
  #include <GL/glut.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <math.h>
  
  #if !defined(GL_VERSION_1_1)
  /* Assume the texture object extension is supported. */
  #define glBindTexture(A,B)     glBindTextureEXT(A,B)
  #endif
  
  #include "loadlum.h"
  
  GLfloat red[3] = {1.0, 0.0, 0.0};
  GLfloat green[3] = {0.0, 1.0, 0.0};
  GLfloat blue[3] = {0.0, 0.0, 1.0};
  GLfloat from[3] = {0.0, 0.0, 20.0};
  GLfloat at[3] = {0.0, 0.0, 0.0};
  GLfloat near_clip = 1.0;
  int useMipmaps = 0, verbose = 0;
  GLuint logoTex, flareTex[6], shineTex[10];
  
  typedef struct t_flare {
    int type;             /* flare texture index, 0..5 */
    float scale;
    float loc;            /* postion on axis */
    GLfloat color[3];
  } Flare;
  
  Flare
  set_flare(int type, float location, float scale, GLfloat color[3], float colorScale)
  {
    Flare ret;
  
    ret.type = type;
    ret.loc = location;
    ret.scale = scale;
    ret.color[0] = color[0] * colorScale;
    ret.color[1] = color[1] * colorScale;
    ret.color[2] = color[2] * colorScale;
    return ret;
  }
  
  Flare flare[20];
  int num_flares = 0;
  static float tic = 0.0;
  float position[3];
  int shine_tic = 0;
  
  void
  init_flares(void)
  {
    /* Shines */
    flare[0] = set_flare(-1, 1.0, 0.3, blue, 1.0);
    flare[1] = set_flare(-1, 1.0, 0.2, green, 1.0);
    flare[2] = set_flare(-1, 1.0, 0.25, red, 1.0);
  
    /* Flares, ordered to eliminate redundant texture binds */
    flare[3] = set_flare(1, 0.5, 0.2f, red, 0.3);
    flare[4] = set_flare(2, 1.3, 0.04f, red, 0.6);
    flare[5] = set_flare(3, 1.0, 0.1f, red, 0.4);
    flare[6] = set_flare(3, 0.2, 0.05f, red, 0.3);
    flare[7] = set_flare(0, 0.0, 0.04f, red, 0.3);
    flare[8] = set_flare(5, -0.25, 0.07f, red, 0.5);
    flare[9] = set_flare(5, -0.4, 0.02f, red, 0.6);
    flare[10] = set_flare(5, -0.6, 0.04f, red, 0.4);
    flare[11] = set_flare(5, -1.0, 0.03f, red, 0.2);
    num_flares = 12;
  }
  
  #include "vec3d.c"  /* Simple 3D vector math routines. */
  
  void
  DoFlares(GLfloat from[3], GLfloat at[3], GLfloat light[3], GLfloat near_clip)
  {
    GLfloat view_dir[3], tmp[3], light_dir[3], position[3], dx[3], dy[3],
      center[3], axis[3], sx[3], sy[3], dot, global_scale = 1.5;
    GLuint bound_to = 0;
    int i;
  
    /* view_dir = normalize(at-from) */
    vdiff(view_dir, at, from);
    vnorm(view_dir);
  
    /* center = from + near_clip * view_dir */
    vscale(tmp, view_dir, near_clip);
    vadd(center, from, tmp);
  
    /* light_dir = normalize(light-from) */
    vdiff(light_dir, light, from);
    vnorm(light_dir);
  
    /* light = from + dot(light,view_dir)*near_clip*light_dir */
    dot = vdot(light_dir, view_dir);
    vscale(tmp, light_dir, near_clip / dot);
    vadd(light, from, light_dir);
  
    /* axis = light - center */
    vdiff(axis, light, center);
    vcopy(dx, axis);
  
    /* dx = normalize(axis) */
    vnorm(dx);
  
    /* dy = cross(dx,view_dir) */
    vcross(dy, dx, view_dir);
  
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_DITHER);
    glEnable(GL_BLEND);
    glBlendFunc(GL_ONE, GL_ONE);
  
    for (i = 0; i < num_flares; i++) {
      vscale(sx, dx, flare[i].scale * global_scale);
      vscale(sy, dy, flare[i].scale * global_scale);
  
      glColor3fv(flare[i].color);
      /* Note logic below to eliminate duplicate texture binds. */
      if (flare[i].type < 0) {
        if (bound_to)
  	glEnd();
        glBindTexture(GL_TEXTURE_2D, shineTex[shine_tic]);
        bound_to = shineTex[shine_tic];
        shine_tic = (shine_tic + 1) % 10;
        glBegin(GL_QUADS);
      } else {
        if (bound_to != flareTex[flare[i].type]) {
  	glEnd();
          glBindTexture(GL_TEXTURE_2D, flareTex[flare[i].type]);
          bound_to = flareTex[flare[i].type];
  	glBegin(GL_QUADS);
        }
      }
  
      /* position = center + flare[i].loc * axis */
      vscale(tmp, axis, flare[i].loc);
      vadd(position, center, tmp);
  
      glTexCoord2f(0.0, 0.0);
      vadd(tmp, position, sx);
      vadd(tmp, tmp, sy);
      glVertex3fv(tmp);
  
      glTexCoord2f(1.0, 0.0);
      vdiff(tmp, position, sx);
      vadd(tmp, tmp, sy);
      glVertex3fv(tmp);
  
      glTexCoord2f(1.0, 1.0);
      vdiff(tmp, position, sx);
      vdiff(tmp, tmp, sy);
      glVertex3fv(tmp);
  
      glTexCoord2f(0.0, 1.0);
      vadd(tmp, position, sx);
      vdiff(tmp, tmp, sy);
      glVertex3fv(tmp);
    }
    glEnd();
  }
  
  void
  DoBackground(void)
  {
    glEnable(GL_DITHER);
    glDisable(GL_BLEND);
    glBindTexture(GL_TEXTURE_2D, logoTex);
  
    glBegin(GL_QUADS);
    glColor3f(0.0, 0.0, 1.0);
    glTexCoord2f(0.075, 0.1);
    glVertex3f(-11.0, -7.0, 0.0);
  
    glColor3f(0.8, 0.8, 1.0);
    glTexCoord2f(1.0, 0.1);
    glVertex3f(11.0, -7.0, 0.0);
  
    glColor3f(0.0, 0.0, 1.0);
    glTexCoord2f(1.0, 0.9);
    glVertex3f(11.0, 7.0, 0.0);
  
    glColor3f(0.0, 0.5, 1.0);
    glTexCoord2f(0.075, 0.9);
    glVertex3f(-11.0, 7.0, 0.0);
    glEnd();
  }
  
  void
  display(void)
  {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
    position[0] = sin(tic * 0.73) * 6;
    position[1] = 4.0 + 8.0 * sin(tic * 0.678);
    position[2] = sin(tic * 0.895) * 6;
    DoBackground();
    DoFlares(from, at, position, near_clip);
  
    glutSwapBuffers();
  }
  
  void
  idle(void)
  {
    tic += 0.08f;
    glutPostRedisplay();
  }
  
  void
  visible(int vis)
  {
    if (vis == GLUT_VISIBLE)
      glutIdleFunc(idle);
    else
      glutIdleFunc(NULL);
  }
  
  void
  setup_texture(char *filename, GLuint texobj,
    GLenum minFilter, GLenum maxFilter)
  {
    unsigned char *buf;
    int width, height, components;
  
    glBindTexture(GL_TEXTURE_2D, texobj);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, maxFilter);
    if (verbose)
      printf("Loading %s:", filename);
    buf = load_luminance(filename, &width, &height, &components);
    if (verbose)
      printf(" %dx%dx%d\n", width, height, components);
    if (useMipmaps)
      gluBuild2DMipmaps(GL_TEXTURE_2D, 1, width, height,
        GL_LUMINANCE, GL_UNSIGNED_BYTE, buf);
    else
      glTexImage2D(GL_TEXTURE_2D, 0, 1, width, height, 0,
        GL_LUMINANCE, GL_UNSIGNED_BYTE, buf);
    free(buf);
  }
  
  void
  load_textures(void)
  {
    char filename[256];
    GLenum minFilter, maxFilter;
    int id = 1, i;
  
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  
    if (useMipmaps) {
      minFilter = GL_LINEAR_MIPMAP_LINEAR;
      maxFilter = GL_LINEAR;
    } else {
      minFilter = GL_LINEAR;
      maxFilter = GL_LINEAR;
    }
    logoTex = id;
    setup_texture("OpenGL.bw", logoTex, minFilter, maxFilter);
    id++;
  
    if (!useMipmaps) {
      minFilter = GL_NEAREST;
      maxFilter = GL_NEAREST;
    }
    for (i = 0; i < 10; i++) {
      shineTex[i] = id;
      sprintf(filename, "Shine%d.bw", i);
      setup_texture(filename, shineTex[i], minFilter, maxFilter);
      id++;
    }
    for (i = 0; i < 6; i++) {
      flareTex[i] = id;
      sprintf(filename, "Flare%d.bw", i + 1);
      setup_texture(filename, flareTex[i], minFilter, maxFilter);
      id++;
    }
  }
  
  int
  main(int argc, char **argv)
  {
    int i;
  
    glutInit(&argc, argv);
    for (i=1; i<argc; i++) {
      if (!strcmp(argv[i], "-mipmap"))
        useMipmaps = 1;
      else if (!strcmp(argv[i], "-v"))
        verbose = 1;
    }
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutCreateWindow("glflare");
    glutDisplayFunc(display);
    glutVisibilityFunc(visible);
  
    init_flares();
  
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(
      60.0,               /* field of view in degree */
      1.0,                /* aspect ratio */
      0.5, 30.0);
  
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(
      from[0], from[1], from[2],
      at[0], at[1], at[2],
      0.0, 1.0, 0.);      /* up is in positive Y direction */
  
    load_textures();
  
    glEnable(GL_TEXTURE_2D);
  
    glutMainLoop();
    return 0;             /* ANSI C requires main to return int. */
  }
  