igl::opengl Namespace Reference

Namespaces
namespace	glfw

Classes
struct	gliGenericImage
class	MeshGL
struct	TgaFooter
struct	TgaHeader
class	ViewerCore
class	ViewerData

Functions
IGL_INLINE bool	render_to_tga (const std::string tga_file, const int width, const int height, const bool alpha)
	alpha whether to include alpha channel
IGL_INLINE bool	texture_from_tga (const std::string tga_file, GLuint &id)
IGL_INLINE gliGenericImage *	gliReadTGA (FILE *fp, char *name, int hflip, int vflip)
IGL_INLINE int	gli_verbose (int new_verbose)
IGL_INLINE int	gliVerbose (int newVerbose)
IGL_INLINE void	writeTGA (gliGenericImage *image, FILE *fp)
IGL_INLINE GLint	bind_vertex_attrib_array (const GLuint program_shader, const std::string &name, GLuint bufferID, const Eigen::Matrix< float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > &M, bool refresh)
IGL_INLINE void	create_index_vbo (const Eigen::MatrixXi &F, GLuint &F_vbo_id)
IGL_INLINE void	create_mesh_vbo (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, GLuint &V_vbo_id, GLuint &F_vbo_id)
IGL_INLINE void	create_mesh_vbo (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const Eigen::MatrixXd &N, GLuint &V_vbo_id, GLuint &F_vbo_id, GLuint &N_vbo_id)
IGL_INLINE bool	create_shader_program (const std::string &geom_source, const std::string &vert_source, const std::string &frag_source, const std::map< std::string, GLuint > &attrib, GLuint &id)
IGL_INLINE bool	create_shader_program (const std::string &vert_source, const std::string &frag_source, const std::map< std::string, GLuint > &attrib, GLuint &id)
IGL_INLINE GLuint	create_shader_program (const std::string &geom_source, const std::string &vert_source, const std::string &frag_source, const std::map< std::string, GLuint > &attrib)
IGL_INLINE GLuint	create_shader_program (const std::string &vert_source, const std::string &frag_source, const std::map< std::string, GLuint > &attrib)
template<typename T >
IGL_INLINE void	create_vector_vbo (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &V, GLuint &V_vbo_id)
IGL_INLINE bool	destroy_shader_program (const GLuint id)
IGL_INLINE int	gl_type_size (const GLenum type)
IGL_INLINE void	init_render_to_texture (const size_t width, const size_t height, const bool depth_texture, GLuint &tex_id, GLuint &fbo_id, GLuint &d_id)
IGL_INLINE void	init_render_to_texture (const size_t width, const size_t height, GLuint &tex_id, GLuint &fbo_id, GLuint &dfbo_id)
IGL_INLINE GLuint	load_shader (const std::string &src, const GLenum type)
IGL_INLINE void	print_program_info_log (const GLuint obj)
IGL_INLINE void	print_shader_info_log (const GLuint obj)
IGL_INLINE GLenum	report_gl_error (const std::string id)
IGL_INLINE GLenum	report_gl_error ()
IGL_INLINE std::string	uniform_type_to_string (const GLenum type)
template<typename DerivedV , typename DerivedF >
IGL_INLINE void	vertex_array (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, GLuint &va_id, GLuint &ab_id, GLuint &eab_id)

---

Class Documentation

igl::opengl::gliGenericImage

struct igl::opengl::gliGenericImage

Class Members
GLubyte *	cmap
GLsizei	cmapEntries
GLenum	cmapFormat
GLint	components
GLenum	format
GLsizei	height
GLubyte *	pixels
GLsizei	width

igl::opengl::TgaFooter

struct igl::opengl::TgaFooter

Class Members
unsigned int	developerDirectoryOffset
char	dot
unsigned int	extensionAreaOffset
char	null
char	signature[16]

igl::opengl::TgaHeader

struct igl::opengl::TgaHeader

Class Members
unsigned char	bpp
unsigned char	colorMapIndexHi
unsigned char	colorMapIndexLo
unsigned char	colorMapLengthHi
unsigned char	colorMapLengthLo
unsigned char	colorMapSize
unsigned char	colorMapType
unsigned char	descriptor
unsigned char	heightHi
unsigned char	heightLo
unsigned char	idLength
unsigned char	imageType
unsigned char	widthHi
unsigned char	widthLo
unsigned char	xOriginHi
unsigned char	xOriginLo
unsigned char	yOriginHi
unsigned char	yOriginLo

Function Documentation

bind_vertex_attrib_array()

IGL_INLINE GLint igl::opengl::bind_vertex_attrib_array	(	const GLuint	program_shader,
		const std::string &	name,
		GLuint	bufferID,
		const Eigen::Matrix< float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > &	M,
		bool	refresh
	)

{
  GLint id = glGetAttribLocation(program_shader, name.c_str());
  if (id < 0)
    return id;
  if (M.size() == 0)
  {
    glDisableVertexAttribArray(id);
    return id;
  }
  glBindBuffer(GL_ARRAY_BUFFER, bufferID);
  if (refresh)
    glBufferData(GL_ARRAY_BUFFER, sizeof(float)*M.size(), M.data(), GL_DYNAMIC_DRAW);
  glVertexAttribPointer(id, M.cols(), GL_FLOAT, GL_FALSE, 0, 0);
  glEnableVertexAttribArray(id);
  return id;
}

References Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::data(), and GL_FALSE.

Referenced by igl::opengl::MeshGL::bind_mesh(), igl::opengl::MeshGL::bind_overlay_lines(), and igl::opengl::MeshGL::bind_overlay_points().

Here is the call graph for this function:

Here is the caller graph for this function:

create_index_vbo()

IGL_INLINE void igl::opengl::create_index_vbo	(	const Eigen::MatrixXi &	F,
		GLuint &	F_vbo_id
	)

{
  // Generate Buffers
  glGenBuffers(1,&F_vbo_id);
  // Bind Buffers
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,F_vbo_id);
  // Copy data to buffers
  // We expect a matrix with each vertex position on a row, we then want to
  // pass this data to OpenGL reading across rows (row-major)
  if(F.Options & Eigen::RowMajor)
  {
    glBufferData(
      GL_ELEMENT_ARRAY_BUFFER,
      sizeof(int)*F.size(),
      F.data(),
      GL_STATIC_DRAW);
  }else
  {
    // Create temporary copy of transpose
    Eigen::MatrixXi FT = F.transpose();
    // If its column major then we need to temporarily store a transpose
    glBufferData(
      GL_ELEMENT_ARRAY_BUFFER,
      sizeof(int)*F.size(),
      FT.data(),
      GL_STATIC_DRAW);
  }
  // bind with 0, so, switch back to normal pointer operation
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

References Eigen::RowMajor.

Referenced by create_mesh_vbo().

Here is the caller graph for this function:

create_mesh_vbo() [1/2]

IGL_INLINE void igl::opengl::create_mesh_vbo	(	const Eigen::MatrixXd &	V,
		const Eigen::MatrixXi &	F,
		const Eigen::MatrixXd &	N,
		GLuint &	V_vbo_id,
		GLuint &	F_vbo_id,
		GLuint &	N_vbo_id
	)

{
  // Create VBOs for faces and vertices
  create_mesh_vbo(V,F,V_vbo_id,F_vbo_id);
  // Create VBO for normal vectors
  create_vector_vbo(N,N_vbo_id);
}

References create_mesh_vbo(), and create_vector_vbo().

Here is the call graph for this function:

create_mesh_vbo() [2/2]

IGL_INLINE void igl::opengl::create_mesh_vbo	(	const Eigen::MatrixXd &	V,
		const Eigen::MatrixXi &	F,
		GLuint &	V_vbo_id,
		GLuint &	F_vbo_id
	)

{
  // Create VBO for vertex position vectors
  create_vector_vbo(V,V_vbo_id);
  // Create VBO for face index lists
  create_index_vbo(F,F_vbo_id);
}

References create_index_vbo(), and create_vector_vbo().

Referenced by create_mesh_vbo().

Here is the call graph for this function:

Here is the caller graph for this function:

create_shader_program() [1/4]

IGL_INLINE GLuint igl::opengl::create_shader_program	(	const std::string &	geom_source,
		const std::string &	vert_source,
		const std::string &	frag_source,
		const std::map< std::string, GLuint > &	attrib
	)

{
  GLuint prog_id = 0;
  create_shader_program(geom_source,vert_source,frag_source,attrib,prog_id);
  return prog_id;
}

References create_shader_program().

Here is the call graph for this function:

create_shader_program() [2/4]

IGL_INLINE bool igl::opengl::create_shader_program	(	const std::string &	geom_source,
		const std::string &	vert_source,
		const std::string &	frag_source,
		const std::map< std::string, GLuint > &	attrib,
		GLuint &	id
	)

{
  using namespace std;
  if(vert_source == "" && frag_source == "")
  {
    cerr<<
      "create_shader_program() could not create shader program,"
      " both .vert and .frag source given were empty"<<endl;
    return false;
  }
 
  // create program
  id = glCreateProgram();
  if(id == 0)
  {
    cerr<<"create_shader_program() could not create shader program."<<endl;
    return false;
  }
  GLuint g = 0,f = 0,v = 0;
 
  if(geom_source != "")
  {
    // load vertex shader
    g = igl::opengl::load_shader(geom_source.c_str(),GL_GEOMETRY_SHADER);
    if(g == 0)
    {
      cerr<<"geometry shader failed to compile."<<endl;
      return false;
    }
    glAttachShader(id,g);
  }
 
  if(vert_source != "")
  {
    // load vertex shader
    v = igl::opengl::load_shader(vert_source.c_str(),GL_VERTEX_SHADER);
    if(v == 0)
    {
      cerr<<"vertex shader failed to compile."<<endl;
      return false;
    }
    glAttachShader(id,v);
  }
 
  if(frag_source != "")
  {
    // load fragment shader
    f = igl::opengl::load_shader(frag_source.c_str(),GL_FRAGMENT_SHADER);
    if(f == 0)
    {
      cerr<<"fragment shader failed to compile."<<endl;
      return false;
    }
    glAttachShader(id,f);
  }
 
  // loop over attributes
  for(
    std::map<std::string,GLuint>::const_iterator ait = attrib.begin();
    ait != attrib.end();
    ait++)
  {
    glBindAttribLocation(
      id,
      (*ait).second,
      (*ait).first.c_str());
  }
  // Link program
  glLinkProgram(id);
  const auto & detach = [&id](const GLuint shader)
  {
    if(shader)
    {
      glDetachShader(id,shader);
      glDeleteShader(shader);
    }
  };
  detach(g);
  detach(f);
  detach(v);
 
  // print log if any
  igl::opengl::print_program_info_log(id);
 
  return true;
}

References load_shader(), and print_program_info_log().

Referenced by create_shader_program(), create_shader_program(), and create_shader_program().

Here is the call graph for this function:

Here is the caller graph for this function:

create_shader_program() [3/4]

IGL_INLINE GLuint igl::opengl::create_shader_program	(	const std::string &	vert_source,
		const std::string &	frag_source,
		const std::map< std::string, GLuint > &	attrib
	)

{
  GLuint prog_id = 0;
  create_shader_program(vert_source,frag_source,attrib,prog_id);
  return prog_id;
}

References create_shader_program().

Here is the call graph for this function:

create_shader_program() [4/4]

IGL_INLINE bool igl::opengl::create_shader_program	(	const std::string &	vert_source,
		const std::string &	frag_source,
		const std::map< std::string, GLuint > &	attrib,
		GLuint &	id
	)

{
  return create_shader_program("",vert_source,frag_source,attrib,prog_id);
}

References create_shader_program().

Here is the call graph for this function:

create_vector_vbo()

template<typename T >

IGL_INLINE void igl::opengl::create_vector_vbo	(	const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	V,
		GLuint &	V_vbo_id
	)

{
  //assert(V.cols() == 3);
 
  // Generate Buffers
  glGenBuffers(1,&V_vbo_id);
  // Bind Buffers
  glBindBuffer(GL_ARRAY_BUFFER,V_vbo_id);
  // Copy data to buffers
  // We expect a matrix with each vertex position on a row, we then want to
  // pass this data to OpenGL reading across rows (row-major)
  if(V.Options & Eigen::RowMajor)
  {
    glBufferData(
      GL_ARRAY_BUFFER,
      sizeof(T)*V.size(),
      V.data(),
      GL_STATIC_DRAW);
  }else
  {
    // Create temporary copy of transpose
    Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> VT = V.transpose();
    // If its column major then we need to temporarily store a transpose
    glBufferData(
      GL_ARRAY_BUFFER,
      sizeof(T)*V.size(),
      VT.data(),
      GL_STATIC_DRAW);
  }
  // bind with 0, so, switch back to normal pointer operation
  glBindBuffer(GL_ARRAY_BUFFER, 0);
}

References Eigen::PlainObjectBase< Derived >::data(), Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >::Options, and Eigen::RowMajor.

Referenced by create_mesh_vbo(), and create_mesh_vbo().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_shader_program()

IGL_INLINE bool igl::opengl::destroy_shader_program

(

const GLuint

id

)

{
  // Don't try to destroy id == 0 (no shader program)
  if(id == 0)
  {
    fprintf(stderr,"Error: destroy_shader_program() id = %d"
      " but must should be positive\n",id);
    return false;
  }
  // Get each attached shader one by one and detach and delete it
  GLsizei count;
  // shader id
  GLuint s;
  do
  {
    // Try to get at most *1* attached shader
    glGetAttachedShaders(id,1,&count,&s);
    GLenum err = igl::opengl::report_gl_error();
    if (GL_NO_ERROR != err)
    {
      return false;
    }
    // Check that we actually got *1*
    if(count == 1)
    {
      // Detach and delete this shader
      glDetachShader(id,s);
      glDeleteShader(s);
    }
  }while(count > 0);
  // Now that all of the shaders are gone we can just delete the program
  glDeleteProgram(id);
  return true;
}

References igl::count(), and report_gl_error().

Here is the call graph for this function:

gl_type_size()

IGL_INLINE int igl::opengl::gl_type_size

(

const GLenum

type

)

{
  switch(type)
  {
    case GL_DOUBLE:
      return 8;
      break;
    case GL_FLOAT:
      return 4;
      break;
    case GL_INT:
      return 4;
      break;
    default:
      // should handle all other GL_[types]
      assert(false && "Implementation incomplete.");
      break;
  }
  return -1;
}

gli_verbose()

IGL_INLINE int igl::opengl::gli_verbose

(

int

new_verbose

)

{
  _verbose = new_verbose;
  return _verbose;
}

References _verbose.

gliReadTGA()

IGL_INLINE igl::opengl::gliGenericImage * igl::opengl::gliReadTGA	(	FILE *	fp,
		char *	name,
		int	hflip,
		int	vflip
	)

{
  igl::opengl::TgaHeader tgaHeader;
  igl::opengl::TgaFooter tgaFooter;
  char horzrev, vertrev;
  int width, height, bpp;
  int start, end, dir;
  int i, j, k;
  int pelbytes, wbytes;
  GLenum format;
  int components;
  RLEstate rleRec;
  RLEstate *rleInfo;
  int rle;
  int index, colors, length;
  GLubyte *cmap, *pixels, *data;
  int (*myfread)(RLEstate *rleInfo, unsigned char*, size_t, size_t, FILE*);
  igl::opengl::gliGenericImage *genericImage;
 
  /* Check the footer. */
  if (fseek(fp, 0L - sizeof(tgaFooter), SEEK_END)
      || fread(&tgaFooter, sizeof(tgaFooter), 1, fp) != 1) {
    sprintf(error, "TGA: Cannot read footer from \"%s\"", name);
    if (_verbose) printf("%s\n", error);
    return NULL;
  }  
 
  /* Check the signature. */
  if (memcmp(tgaFooter.signature, TGA_SIGNATURE,
             sizeof(tgaFooter.signature)) == 0) {
    if (_verbose) printf("TGA: found New TGA\n");
  } else {
    if (_verbose) printf("TGA: found Original TGA\n");
  }
 
  if (fseek(fp, 0, SEEK_SET) ||
      fread(&tgaHeader, sizeof(tgaHeader), 1, fp) != 1) {
    sprintf(error, "TGA: Cannot read header from \"%s\"", name);
    if (_verbose) printf("%s\n", error);
    return NULL;
  }
 
  if (_verbose && tgaHeader.idLength) {
    char *idString = (char*) malloc(tgaHeader.idLength);
    
    if (fread(idString, tgaHeader.idLength, 1, fp) != 1) {
      sprintf(error, "TGA: Cannot read ID field in \"%s\"", name);
      printf("%s\n", error);
    } else {
      printf("TGA: ID field: \"%*s\"\n", tgaHeader.idLength, idString);
    }
    free(idString);
  } else {
    /* Skip the image ID field. */
    if (tgaHeader.idLength && fseek(fp, tgaHeader.idLength, SEEK_CUR)) {
      sprintf(error, "TGA: Cannot skip ID field in \"%s\"", name);
      if (_verbose) printf("%s\n", error);
      return NULL;
    }
  }
  
  /* Reassemble the multi-byte values correctly, regardless of
     host endianness. */
  width = (tgaHeader.widthHi << 8) | tgaHeader.widthLo;
  height = (tgaHeader.heightHi << 8) | tgaHeader.heightLo;
  bpp = tgaHeader.bpp;
  if (_verbose) {
    printf("TGA: width=%d, height=%d, bpp=%d\n", width, height, bpp);
  }
 
  horzrev = tgaHeader.descriptor & TGA_DESC_HORIZONTAL;
  vertrev = tgaHeader.descriptor & TGA_DESC_VERTICAL;
  //vertrev=0;
 
//   // JASON - we can force this stuff if we want
//   if( hflip )
//       horzrev = 1;
  if( vflip )
      vertrev = 1;
 
  if (_verbose && horzrev) printf("TGA: horizontal reversed\n");
  if (_verbose && vertrev) printf("TGA: vertical reversed\n");
 
  rle = 0;
  switch (tgaHeader.imageType) {
  case TGA_TYPE_MAPPED_RLE:
    rle = 1;
    if (_verbose) printf("TGA: run-length encoded\n");
  case TGA_TYPE_MAPPED:
    /* Test for alpha channel. */
    format = GL_COLOR_INDEX;
    components = 1;
    if (_verbose) {
      printf("TGA: %d bit indexed image (%d bit palette)\n",
        tgaHeader.colorMapSize, bpp);
    }
    break;
 
  case TGA_TYPE_GRAY_RLE:
    rle = 1;
    if (_verbose) printf("TGA: run-length encoded\n");
  case TGA_TYPE_GRAY:
    format = GL_LUMINANCE;
    components = 1;
    if (_verbose) printf("TGA: %d bit grayscale image\n", bpp);
    break;
 
  case TGA_TYPE_COLOR_RLE:
    rle = 1;
    if (_verbose) printf("TGA: run-length encoded\n");
  case TGA_TYPE_COLOR:
    /* Test for alpha channel. */
    if (bpp == 32) {
      format = GL_BGRA_EXT;
      components = 4;
      if (_verbose) {
        printf("TGA: %d bit color image with alpha channel\n", bpp);
      }
    } else {
      format = GL_BGR_EXT;
      components = 3;
      if (_verbose) printf("TGA: %d bit color image\n", bpp);
    }
    break;
 
  default:
    sprintf(error,
      "TGA: unrecognized image type %d\n", tgaHeader.imageType);
    if (_verbose) printf("%s\n", error);
    return NULL;
  }
 
  if ((format == GL_BGRA_EXT && bpp != 32) ||
      (format == GL_BGR_EXT && bpp != 24) ||
      ((format == GL_LUMINANCE || format == GL_COLOR_INDEX) && bpp != 8)) {
    /* FIXME: We haven't implemented bit-packed fields yet. */
    fprintf(stderr, "bpp %d, format %x\n", bpp, (unsigned int)format); 
    sprintf(error, "TGA: channel sizes other than 8 bits are unimplemented");
    if (_verbose) printf("%s\n", error);
    return NULL;
  }
 
  /* Check that we have a color map only when we need it. */
  if (format == GL_COLOR_INDEX) {
    if (tgaHeader.colorMapType != 1) {
      sprintf(error, "TGA: indexed image has invalid color map type %d\n",
        tgaHeader.colorMapType);
      if (_verbose) printf("%s\n", error);
      return NULL;
    }
  } else if (tgaHeader.colorMapType != 0) {
    sprintf(error, "TGA: non-indexed image has invalid color map type %d\n",
      tgaHeader.colorMapType);
    if (_verbose) printf("%s\n", error);
    return NULL;
  }
 
  if (tgaHeader.colorMapType == 1) {
    /* We need to read in the colormap. */
    index = (tgaHeader.colorMapIndexHi << 8) | tgaHeader.colorMapIndexLo;
    length = (tgaHeader.colorMapLengthHi << 8) | tgaHeader.colorMapLengthLo;
 
    if (_verbose) {
      printf("TGA: reading color map (%d + %d) * (%d / 8)\n",
        index, length, tgaHeader.colorMapSize);
    }
    if (length == 0) {
      sprintf(error, "TGA: invalid color map length %d", length);
      if (_verbose) printf("%s\n", error);
      return NULL;
    }
    if (tgaHeader.colorMapSize != 24) {
      /* We haven't implemented bit-packed fields yet. */
      sprintf(error, "TGA: channel sizes other than 8 bits are unimplemented");
      if (_verbose) printf("%s\n", error);
      return NULL;
    }
 
    pelbytes = tgaHeader.colorMapSize / 8;
    colors = length + index;
    cmap = (GLubyte*)malloc (colors * pelbytes);
 
    /* Zero the entries up to the beginning of the map. */
    memset(cmap, 0, index * pelbytes);
 
    /* Read in the rest of the colormap. */
    if (fread(cmap, pelbytes, length, fp) != (size_t) length) {
      sprintf(error, "TGA: error reading colormap (ftell == %ld)\n",
        ftell (fp));
      if (_verbose) printf("%s\n", error);
      return NULL;
    }
 
    if (pelbytes >= 3) {
      /* Rearrange the colors from BGR to RGB. */
      int tmp;
      for (j = index; j < length * pelbytes; j += pelbytes) {
        tmp = cmap[j];
        cmap[j] = cmap[j + 2];
        cmap[j + 2] = tmp;
      }
    }
  } else {
    colors = 0;
    cmap = NULL;
  }
 
  /* Allocate the data. */
  pelbytes = bpp / 8;
  pixels = (unsigned char *) malloc (width * height * pelbytes);
 
  if (rle) {
    rleRec.statebuf = 0;
    rleRec.statelen = 0;
    rleRec.laststate = 0;
    rleInfo = &rleRec;
    myfread = rle_fread;
  } else {
    rleInfo = NULL;
    myfread = std_fread;
  }
 
  wbytes = width * pelbytes;
 
  if (vertrev) {
    start = 0;
    end = height;
    dir = 1;
  } else {
    /* We need to reverse loading order of rows. */
    start = height-1;
    end = -1;
    dir = -1;
  }
 
  for (i = start; i != end; i += dir) {
    data = pixels + i*wbytes;
 
    /* Suck in the data one row at a time. */
    if (myfread(rleInfo, data, pelbytes, width, fp) != width) {
      /* Probably premature end of file. */
      if (_verbose) {
        printf ("TGA: error reading (ftell == %ld, width=%d)\n",
          ftell(fp), width);
      }
      return NULL;
    }  
 
    if (horzrev) {
      /* We need to mirror row horizontally. */
      for (j = 0; j < width/2; j++) {
        GLubyte tmp;
 
        for (k = 0; k < pelbytes; k++) {
          tmp = data[j*pelbytes+k];
          data[j*pelbytes+k] = data[(width-j-1)*pelbytes+k];
          data[(width-j-1)*pelbytes+k] = tmp;
        }
      }
    }
  }
 
  if (rle) {
    free(rleInfo->statebuf);
  }
 
  if (fgetc (fp) != EOF) {
    if (_verbose) printf ("TGA: too much input data, ignoring extra...\n");
  }
 
  genericImage = (igl::opengl::gliGenericImage*) malloc(sizeof(igl::opengl::gliGenericImage));
  genericImage->width = width;
  genericImage->height = height;
  genericImage->format = format;
  genericImage->components = components;
  genericImage->cmapEntries = colors;
  genericImage->cmapFormat = GL_BGR_EXT;  // XXX fix me
  genericImage->cmap = cmap;
  genericImage->pixels = pixels;
 
  return genericImage;
}

References _verbose, igl::opengl::TgaHeader::bpp, igl::opengl::gliGenericImage::cmap, igl::opengl::gliGenericImage::cmapEntries, igl::opengl::gliGenericImage::cmapFormat, igl::opengl::TgaHeader::colorMapIndexHi, igl::opengl::TgaHeader::colorMapIndexLo, igl::opengl::TgaHeader::colorMapLengthHi, igl::opengl::TgaHeader::colorMapLengthLo, igl::opengl::TgaHeader::colorMapSize, igl::opengl::TgaHeader::colorMapType, igl::components(), igl::opengl::gliGenericImage::components, igl::opengl::TgaHeader::descriptor, error, igl::opengl::gliGenericImage::format, free(), igl::opengl::gliGenericImage::height, igl::opengl::TgaHeader::heightHi, igl::opengl::TgaHeader::heightLo, igl::opengl::TgaHeader::idLength, igl::opengl::TgaHeader::imageType, L, RLEstate::laststate, malloc(), igl::opengl::gliGenericImage::pixels, rle_fread(), SEEK_SET, igl::opengl::TgaFooter::signature, RLEstate::statebuf, RLEstate::statelen, std_fread(), TGA_DESC_HORIZONTAL, TGA_DESC_VERTICAL, TGA_SIGNATURE, TGA_TYPE_COLOR, TGA_TYPE_COLOR_RLE, TGA_TYPE_GRAY, TGA_TYPE_GRAY_RLE, TGA_TYPE_MAPPED, TGA_TYPE_MAPPED_RLE, igl::opengl::gliGenericImage::width, igl::opengl::TgaHeader::widthHi, and igl::opengl::TgaHeader::widthLo.

Referenced by texture_from_tga().

Here is the call graph for this function:

Here is the caller graph for this function:

gliVerbose()

IGL_INLINE int igl::opengl::gliVerbose

(

int

newVerbose

)

init_render_to_texture() [1/2]

IGL_INLINE void igl::opengl::init_render_to_texture	(	const size_t	width,
		const size_t	height,
		const bool	depth_texture,
		GLuint &	tex_id,
		GLuint &	fbo_id,
		GLuint &	d_id
	)

{
  using namespace std;
  // http://www.opengl.org/wiki/Framebuffer_Object_Examples#Quick_example.2C_render_to_texture_.282D.29
  const auto & gen_tex = [](GLuint & tex_id)
  {
    glGenTextures(1, &tex_id);
    glBindTexture(GL_TEXTURE_2D, tex_id);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  };
  gen_tex(tex_id);
  //NULL means reserve texture memory, but texels are undefined
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_BGRA, GL_FLOAT, NULL);
  glBindTexture(GL_TEXTURE_2D, 0);
 
  glGenFramebuffers(1, &fbo_id);
  glBindFramebuffer(GL_FRAMEBUFFER, fbo_id);
  //Attach 2D texture to this FBO
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex_id, 0);
  if(depth_texture)
  {
    // Generate a depth texture
    gen_tex(d_id);
    glTexImage2D(
      GL_TEXTURE_2D,
      0,
      GL_DEPTH_COMPONENT32,
      width,
      height,
      0,
      GL_DEPTH_COMPONENT,
      GL_FLOAT,
      NULL);
    glFramebufferTexture2D(
      GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D,d_id,0);
  }else
  {
    // Attach a depth buffer
    glGenRenderbuffers(1, &d_id);
    glBindRenderbuffer(GL_RENDERBUFFER, d_id);
    glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH_COMPONENT24,width,height);
    glFramebufferRenderbuffer(
      GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,d_id);
  }
 
  //Does the GPU support current FBO configuration?
  GLenum status;
  status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
  assert(status == GL_FRAMEBUFFER_COMPLETE);
  // Unbind to clean up
  if(!depth_texture)
  {
    glBindRenderbuffer(GL_RENDERBUFFER, 0);
  }
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

Referenced by init_render_to_texture().

Here is the caller graph for this function:

init_render_to_texture() [2/2]

IGL_INLINE void igl::opengl::init_render_to_texture	(	const size_t	width,
		const size_t	height,
		GLuint &	tex_id,
		GLuint &	fbo_id,
		GLuint &	dfbo_id
	)

{
  return init_render_to_texture(width,height,false,tex_id,fbo_id,dfbo_id);
}

References init_render_to_texture().

Here is the call graph for this function:

load_shader()

IGL_INLINE GLuint igl::opengl::load_shader	(	const std::string &	src,
		const GLenum	type
	)

{
  if(src.empty())
  {
    return (GLuint) 0;
  }
 
  GLuint s = glCreateShader(type);
  if(s == 0)
  {
    fprintf(stderr,"Error: load_shader() failed to create shader.\n");
    return 0;
  }
  // Pass shader source string
  const char *c = src.c_str();
  glShaderSource(s, 1, &c, NULL);
  glCompileShader(s);
  // Print info log (if any)
  igl::opengl::print_shader_info_log(s);
  return s;
}

References print_shader_info_log().

Referenced by create_shader_program().

Here is the call graph for this function:

Here is the caller graph for this function:

print_program_info_log()

IGL_INLINE void igl::opengl::print_program_info_log

(

const GLuint

obj

)

{
  GLint infologLength = 0;
  GLint charsWritten  = 0;
  char *infoLog;
  
  glGetProgramiv(obj, GL_INFO_LOG_LENGTH,&infologLength);
  
  if (infologLength > 0)
  {
    infoLog = (char *)malloc(infologLength);
    glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog);
    printf("%s\n",infoLog);
    free(infoLog);
  }
}

References free(), and malloc().

Referenced by create_shader_program().

Here is the call graph for this function:

Here is the caller graph for this function:

print_shader_info_log()

IGL_INLINE void igl::opengl::print_shader_info_log

(

const GLuint

obj

)

{
  GLint infologLength = 0;
  GLint charsWritten  = 0;
  char *infoLog;
  
  // Get shader info log from opengl
  glGetShaderiv(obj, GL_INFO_LOG_LENGTH,&infologLength);
  // Only print if there is something in the log
  if (infologLength > 0)
  {
    infoLog = (char *)malloc(infologLength);
    glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog);
    printf("%s\n",infoLog);
    free(infoLog);
  }
}

References free(), and malloc().

Referenced by load_shader().

Here is the call graph for this function:

Here is the caller graph for this function:

render_to_tga()

IGL_INLINE bool igl::opengl::render_to_tga	(	const std::string	tga_file,
		const int	width,
		const int	height,
		const bool	alpha
	)

alpha whether to include alpha channel

{
 
  size_t components = 3;
  GLenum format = GL_BGR;
  if(alpha)
  {
    format = GL_BGRA;
    components = 4;
  }
  GLubyte * cmap = NULL;
 
  // OpenGL by default tries to read data in multiples of 4, if our data is
  // only RGB or BGR and the width is not divible by 4 then we need to alert
  // opengl
  if((width % 4) != 0 && 
   (format == GL_RGB || 
    format == GL_BGR))
  {
    glPixelStorei(GL_PACK_ALIGNMENT, 1);
  }
  GLubyte *pixels;
  pixels = (unsigned char *) malloc (width * height * components);
  glReadPixels(
    0,
    0,
    width,
    height,
    format,
    GL_UNSIGNED_BYTE,
    pixels);
 
  // set up generic image struct
  gliGenericImage * genericImage;
  genericImage = (gliGenericImage*) malloc(sizeof(gliGenericImage));
  genericImage->width = width;
  genericImage->height = height;
  genericImage->format = format;
  genericImage->components = components;
  genericImage->pixels = pixels;
  // CMAP is not supported, but we need to put something here
  genericImage->cmapEntries = 0;
  genericImage->cmapFormat = GL_BGR;
  genericImage->cmap = cmap;
 
  // write pixels to tga file
  FILE * imgFile;
  // "-" as output file name is code for write to stdout
  if(tga_file.compare("-") == 0)
  {
    imgFile = stdout;
  }else{
    imgFile = fopen(tga_file.c_str(),"w");
    if(NULL==imgFile)
    {
      printf("IOError: %s could not be opened...\n",tga_file.c_str());
      return false;
    }
  }
 
  writeTGA(genericImage,imgFile);
 
  free(genericImage);
  return fclose(imgFile) == 0;
}

References igl::opengl::gliGenericImage::cmap, igl::opengl::gliGenericImage::cmapEntries, igl::opengl::gliGenericImage::cmapFormat, igl::components(), igl::opengl::gliGenericImage::components, igl::opengl::gliGenericImage::format, free(), igl::opengl::gliGenericImage::height, malloc(), igl::opengl::gliGenericImage::pixels, igl::opengl::gliGenericImage::width, and writeTGA().

Here is the call graph for this function:

report_gl_error() [1/2]

IGL_INLINE GLenum igl::opengl::report_gl_error

(

)

{
  return igl::opengl::report_gl_error(std::string(""));
}

References report_gl_error().

Referenced by destroy_shader_program(), and report_gl_error().

Here is the call graph for this function:

Here is the caller graph for this function:

report_gl_error() [2/2]

IGL_INLINE GLenum igl::opengl::report_gl_error

(

const std::string

id

)

{
  // http://stackoverflow.com/q/28485180/148668
 
  // gluErrorString was deprecated
  const auto gluErrorString = [](GLenum errorCode)->const char *
  {
    switch(errorCode)
    {
      default:
        return "unknown error code";
      case GL_NO_ERROR:
        return "no error";
      case GL_INVALID_ENUM:
        return "invalid enumerant";
      case GL_INVALID_VALUE:
        return "invalid value";
      case GL_INVALID_OPERATION:
        return "invalid operation";
#ifndef GL_VERSION_3_0
      case GL_STACK_OVERFLOW:
        return "stack overflow";
      case GL_STACK_UNDERFLOW:
        return "stack underflow";
      case GL_TABLE_TOO_LARGE:
        return "table too large";
#endif
      case GL_OUT_OF_MEMORY:
        return "out of memory";
#ifdef GL_EXT_framebuffer_object
      case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:
        return "invalid framebuffer operation";
#endif
    }
  };
 
  GLenum err = glGetError();
  if(GL_NO_ERROR != err)
  {
    verbose("GL_ERROR: ");
    fprintf(stderr,"%s%s\n",id.c_str(),gluErrorString(err));
  }
  return err;
}

References verbose.

texture_from_tga()

IGL_INLINE bool igl::opengl::texture_from_tga	(	const std::string	tga_file,
		GLuint &	id
	)

{
  using namespace std;
 
  // read pixels to tga file
  FILE * imgFile;
  // "-" as input file name is code for read from stdin
  imgFile = fopen(tga_file.c_str(),"r");
  if(NULL==imgFile)
  {
    printf("IOError: %s could not be opened...",tga_file.c_str());
    return false;
  }
 
  // gliReadTGA annoyingly uses char * instead of const char *
  size_t len = tga_file.length();
  char* tga_file_char = new char [ len + 1 ];
  strcpy( tga_file_char, tga_file.c_str() );
  // read image
  gliGenericImage* img = gliReadTGA(imgFile, tga_file_char, 0, 0);
  // clean up filename buffer
  delete[] tga_file_char;
  fclose( imgFile );
 
  // set up texture mapping parameters and generate texture id
  glGenTextures(1,&id);
  glBindTexture(GL_TEXTURE_2D, id);
  // Texture parameters
  float empty[] = {1.0f,1.0f,1.0f,0.0f};
  glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_BORDER_COLOR,empty);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
  //  GL_LINEAR_MIPMAP_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
    GL_LINEAR);
 
  // OpenGL by default tries to read data in multiples of 4, if our data is
  // only RGB or BGR and the width is not divible by 4 then we need to alert
  // opengl
  if((img->width % 4) != 0 && 
   (img->format == GL_RGB || 
    img->format == GL_BGR))
  {
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  }
 
  // Load texture
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img->width,
    img->height, 0, img->format, GL_UNSIGNED_BYTE,
    img->pixels);
  return id;
}

References igl::opengl::gliGenericImage::format, gliReadTGA(), igl::opengl::gliGenericImage::height, igl::opengl::gliGenericImage::pixels, and igl::opengl::gliGenericImage::width.

Here is the call graph for this function:

uniform_type_to_string()

IGL_INLINE std::string igl::opengl::uniform_type_to_string

(

const GLenum

type

)

{
  switch(type)
  {
    case GL_FLOAT:
      return "GL_FLOAT";
    case GL_FLOAT_VEC2:
      return "GL_FLOAT_VEC2";
    case GL_FLOAT_VEC3:
      return "GL_FLOAT_VEC3";
    case GL_FLOAT_VEC4:
      return "GL_FLOAT_VEC4";
    case GL_INT:
      return "GL_INT";
    case GL_INT_VEC2:
      return "GL_INT_VEC2";
    case GL_INT_VEC3:
      return "GL_INT_VEC3";
    case GL_INT_VEC4:
      return "GL_INT_VEC4";
    case GL_BOOL:
      return "GL_BOOL";
    case GL_BOOL_VEC2:
      return "GL_BOOL_VEC2";
    case GL_BOOL_VEC3:
      return "GL_BOOL_VEC3";
    case GL_BOOL_VEC4:
      return "GL_BOOL_VEC4";
    case GL_FLOAT_MAT2:
      return "GL_FLOAT_MAT2";
    case GL_FLOAT_MAT3:
      return "GL_FLOAT_MAT3";
    case GL_FLOAT_MAT4:
      return "GL_FLOAT_MAT4";
    case GL_FLOAT_MAT2x3:
      return "GL_FLOAT_MAT2x3";
    case GL_FLOAT_MAT2x4:
      return "GL_FLOAT_MAT2x4";
    case GL_FLOAT_MAT3x2:
      return "GL_FLOAT_MAT3x2";
    case GL_FLOAT_MAT3x4:
      return "GL_FLOAT_MAT3x4";
    case GL_FLOAT_MAT4x2:
      return "GL_FLOAT_MAT4x2";
    case GL_FLOAT_MAT4x3:
      return "GL_FLOAT_MAT4x3";
    case GL_SAMPLER_1D:
      return "GL_SAMPLER_1D";
    case GL_SAMPLER_2D:
      return "GL_SAMPLER_2D";
    case GL_SAMPLER_3D:
      return "GL_SAMPLER_3D";
    case GL_SAMPLER_CUBE:
      return "GL_SAMPLER_CUBE";
    case GL_SAMPLER_1D_SHADOW:
      return "GL_SAMPLER_1D_SHADOW";
    case GL_SAMPLER_2D_SHADOW:
      return "GL_SAMPLER_2D_SHADOW";
    default:
      return "UNKNOWN_TYPE";
  }
}

vertex_array()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::opengl::vertex_array	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		GLuint &	va_id,
		GLuint &	ab_id,
		GLuint &	eab_id
	)

{
  // Inputs should be in RowMajor storage. If not, we have no choice but to
  // create a copy.
  if(!(V.Options & Eigen::RowMajor))
  {
    Eigen::Matrix<
      typename DerivedV::Scalar,
      DerivedV::RowsAtCompileTime,
      DerivedV::ColsAtCompileTime,
      Eigen::RowMajor> VR = V;
    return vertex_array(VR,F,va_id,ab_id,eab_id);
  }
  if(!(F.Options & Eigen::RowMajor))
  {
    Eigen::Matrix<
      typename DerivedF::Scalar,
      DerivedF::RowsAtCompileTime,
      DerivedF::ColsAtCompileTime,
      Eigen::RowMajor> FR = F;
    return vertex_array(V,FR,va_id,ab_id,eab_id);
  }
  // Generate and attach buffers to vertex array
  glGenVertexArrays(1, &va_id);
  glGenBuffers(1, &ab_id);
  glGenBuffers(1, &eab_id);
  glBindVertexArray(va_id);
  glBindBuffer(GL_ARRAY_BUFFER, ab_id);
  const auto size_VScalar = sizeof(typename DerivedV::Scalar);
  const auto size_FScalar = sizeof(typename DerivedF::Scalar);
  glBufferData(GL_ARRAY_BUFFER,size_VScalar*V.size(),V.data(),GL_STATIC_DRAW);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, eab_id);
  assert(sizeof(GLuint) == size_FScalar && "F type does not match GLuint");
  glBufferData(
    GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*F.size(), F.data(), GL_STATIC_DRAW);
  glVertexAttribPointer(
    0,
    V.cols(),
    size_VScalar==sizeof(float)?GL_FLOAT:GL_DOUBLE,
    GL_FALSE,
    V.cols()*size_VScalar,
    (GLvoid*)0);
  glEnableVertexAttribArray(0);
  glBindBuffer(GL_ARRAY_BUFFER, 0); 
  glBindVertexArray(0);
}

References Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::data(), GL_FALSE, Eigen::PlainObjectBase< Derived >::Options, Eigen::RowMajor, and vertex_array().

Referenced by vertex_array().

Here is the call graph for this function:

Here is the caller graph for this function:

writeTGA()

IGL_INLINE void igl::opengl::writeTGA	(	gliGenericImage *	image,
		FILE *	fp
	)

                                                                              {
 
  assert(!image->cmap); // we do not deal with color map images
    
  if(image->components == 3 || image->components == 4) 
    fwrite(TGAHeaderColor, 12, sizeof(unsigned char),fp);
  else { 
    if(image->components == 1 ) 
      fwrite(TGAHeaderBW, 12, sizeof(unsigned char),fp);        
    else { fprintf(stderr,"Supported component number: 1,3 or 4\n"); exit(1); }
  }
 
  write16bit(image->width,fp);  
  write16bit(image->height,fp);  
  switch (image->components ) { 
  case 1: 
    putc(8,fp);
    break;
  case 3: 
    putc(24,fp); 
    break;
  case 4:
    putc(32,fp);
    break;
  default: fprintf(stderr,"Supported component number: 1,3 or 4\n"); exit(1); 
  };
  
  if(image-> components == 4) 
    putc(0x04,fp); // bottom left image (0x00) + 8 bit alpha (0x4)
  else 
    putc(0x00,fp);
 
  fwrite(image->pixels, image->height*image->width*image->components, sizeof(char),fp);
}

References igl::opengl::gliGenericImage::cmap, igl::components(), igl::opengl::gliGenericImage::components, igl::opengl::gliGenericImage::height, igl::opengl::gliGenericImage::pixels, TGAHeaderBW, TGAHeaderColor, igl::opengl::gliGenericImage::width, and write16bit().

Referenced by render_to_tga().

Here is the call graph for this function:

Here is the caller graph for this function: