source: anuga_work/development/anugavis/src/height_quantity.c @ 5267

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#ifdef HAVE_STDLIB_H
#  include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#  include <string.h>
#endif
#ifdef HAVE_GL_GL_H
#  include <GL/gl.h>
#elif HAVE_OPENGL_GL_H
#  include <OpenGL/gl.h>
#endif
#include <netcdf.h>
#include <SDL.h>
#include "error.h"
#include "globals.h"
#include "height_quantity.h"
#include "netcdf_util.h"
#include "xfunctions.h"

static int compileDisplayLists(struct height_quantity_simple *height){
  int frame;
  unsigned int vol;
  unsigned int vertex;
  int vertIndex;
  int x[3];
  int y[3];
  int z[3];
  float *heights = xmalloc(sizeof(float)
                           * anugavis.number_of_points
                           * height->frames, "compileDisplayLists()");
  if(heights == NULL)
    return -1;
  if(nc_get_var_float_by_name(anugavis.netcdfId,
                              height->name, heights) != NC_NOERR){
    free(heights);
    return -1;
  }

  for(frame = 0 ; frame < height->frames ; frame++){
    glNewList(height->displayLists + frame, GL_COMPILE);
    for(vol = 0 ; vol < anugavis.number_of_volumes ; vol++){
      glBegin(GL_POLYGON);
      for(vertex = 0 ; vertex < 3 ; vertex++){ /* Calculate normal */
        vertIndex = anugavis.volumes[vol*anugavis.number_of_vertices + vertex];
        x[vertex] = anugavis.x[vertIndex];
        y[vertex] = anugavis.y[vertIndex];
        z[vertex] = heights[frame * anugavis.number_of_timesteps + vertIndex];
      }
      glNormal3f((y[1] - y[0]) * (z[2] - z[0]) - (z[1] - z[0]) * (y[2] - y[0]),
                 (z[1] - z[0]) * (x[2] - x[0]) - (x[1] - x[0]) * (z[2] - z[0]),
                 (x[1] - x[0]) * (y[2] - y[0]) - (y[1] - y[0]) * (x[2] - x[0]));
      for(vertex = 0 ; vertex < anugavis.number_of_vertices ; vertex++){
        vertIndex = anugavis.volumes[vol*anugavis.number_of_vertices + vertex];
        glVertex3f(anugavis.x[vertIndex], anugavis.y[vertIndex],
                   heights[frame * anugavis.number_of_timesteps + vertIndex]);
      }
      glEnd();
    }
    glEndList();
  }

  free(heights);
  return 0;
}

static void freeHeightQuantity(struct height_quantity_simple *height){
  if(height->name != NULL) free(height->name);
  if(glIsList(height->displayLists) == GL_TRUE)
    glDeleteLists(height->displayLists, height->frames);
  free(height);
}

int AnugaVis_DefineHeightQuantity(const char *name,
                                  double offset, double scale,
                                  int red, int green, int blue){
  struct height_quantity_simple *height;
  int ncstatus;
  int ncvarid;
  int numdims;
  GLenum glerror;
  /* Check that it's actually in the NetCDF file */
  if((ncstatus = nc_inq_varid(anugavis.netcdfId, name, &ncvarid)) != NC_NOERR){
    AnugaVis_NetCDFError(ncstatus);
    return -1;
  }     

  /* Redefining a quantity? */
  for(height = anugavis.heights ; height != NULL ; height = height->next)
    if(!strcmp(name, height->name)) break;

  if(height == NULL){ /* Make a new entry. */
    if((height = xmalloc(sizeof(struct height_quantity_simple),
                         "AnugaVis_DefineHeightQuantity()")) == NULL)
      return -1;

    height->name = NULL;
    height->displayLists = -1;

    if((height->name = xstrdup(name,
                               "AnugaVis_DefineHeightQuantity()")) == NULL){
      freeHeightQuantity(height);
      return -1;
    }

    /* If the NetCDF variable is 2-dimensional, then it's dynamic. */
    if((ncstatus = nc_inq_varndims(anugavis.netcdfId,
                                   ncvarid, &numdims)) != NC_NOERR){
      AnugaVis_NetCDFError(ncstatus);
      freeHeightQuantity(height);
      return -1;
    }

    height->frames = (numdims == 2) ? anugavis.number_of_timesteps : 1;
    height->displayLists = glGenLists(height->frames);
    if((glerror = glGetError()) != GL_NO_ERROR){
      AnugaVis_OpenGLError(glerror);
      freeHeightQuantity(height);
      return -1;
    }

    if(compileDisplayLists(height) == -1){
      freeHeightQuantity(height);
      return -1;
    }

    height->next = anugavis.heights;
    anugavis.heights = height;
  }

  height->offset = offset;
  height->scale = scale;
  height->color = SDL_MapRGB(anugavis.screen->format, red, green, blue);
  return 0;
}

void AnugaVis_UndefineHeightQuantity(char *name){
  struct height_quantity_simple *height = anugavis.heights;
  struct height_quantity_simple *nextHeight;
  if(height == NULL) return;
  if(!strcmp(name, height->name)){
    anugavis.heights = height->next;
    freeHeightQuantity(height);
    return;
  }
  for(; height != NULL ; height = height->next)
    if(height->next == NULL) return;
    if(!strcmp(name, height->next->name)){
      nextHeight = height->next;
      height->next = height->next->next;
      freeHeightQuantity(nextHeight);
      return;
    }
}