MeVis/Foundation/Sources/MLOpenGL/mlGLResources.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __mlGLResources_H
#define __mlGLResources_H

#include "mlOpenGL.h"
#include "mlOpenGLSystem.h"

ML_OPENGL_START_NAMESPACE

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLResource {
  public:
    GLResource();
    virtual ~GLResource();

    virtual void contextDestroyed() = 0;
    
    static GLenum getGLError();

  protected:
    GLResource* _next;
    GLResource* _previous;

    friend class GLResourceManager;
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLTexture : public GLResource
{
public:
  GLTexture() { _id = 0; };
  ~GLTexture() { destroy(); };

  GLuint getHandle() const  { return _id; }

  bool isValid() const { return _id!=0; }

  void create();

  void destroy();

  virtual void contextDestroyed() { _id = 0; }

private:
  GLuint _id;
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLTextures : public GLResource {
public:
  GLTextures() {};
  ~GLTextures() { destroy(); };

  GLuint getHandle(int i) const { return _ids[i]; }

  int getNumTextures() const { return static_cast<int>(_ids.size()); }

  bool isValid() const { return !_ids.empty(); }

  void create(unsigned int i);

  void destroy();

  virtual void contextDestroyed() { _ids.clear(); }

private:
  std::vector<GLuint> _ids;
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLFragmentProgramARB : public GLResource {
public:
  GLFragmentProgramARB() { _id = 0; };
  ~GLFragmentProgramARB() { destroy(); };

  GLuint getHandle() const { return _id; }

  bool isValid() const { return _id!=0; }

  void create();

  void destroy();

  virtual void contextDestroyed() { _id = 0; }

private:
  GLuint _id;
};


//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLRenderBuffer : public GLResource {
public:
  GLRenderBuffer() { _id = 0; };
  ~GLRenderBuffer() { destroy(); };

  GLuint getHandle() const { return _id; }

  bool isValid() const { return _id!=0; }

  void create();

  void destroy();

  virtual void contextDestroyed() { _id = 0; }

private:
  GLuint _id;
};


//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLFrameBuffer : public GLResource {
public:
  GLFrameBuffer() { _id = 0; };
  ~GLFrameBuffer() { destroy(); };

  GLuint getHandle() const { return _id; }

  bool isValid() const { return _id!=0; }

  void create();

  void destroy();

  virtual void contextDestroyed() { _id = 0; }

private:
  GLuint _id;
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLVertexBuffer : public GLResource {
public:
  GLVertexBuffer() { _id = 0; };
  ~GLVertexBuffer() { destroy(); };

  GLuint getHandle() const { return _id; }

  bool isValid() const { return _id!=0; }

  void create();

  void destroy();

  virtual void contextDestroyed() { _id = 0; }

private:
  GLuint _id;
};
//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLPixelBuffer : public GLResource {
public:
  GLPixelBuffer() { _id = 0; };
  ~GLPixelBuffer() { destroy(); };

  GLuint getHandle() const { return _id; }

  bool isValid() const { return _id!=0; }

  void create();

  void destroy();

  virtual void contextDestroyed() { _id = 0; }

private:
  GLuint _id;
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLDisplayList : public GLResource {
public:
  GLDisplayList() { _id = 0; };
  ~GLDisplayList() { destroy(); };

  GLuint getHandle() const { return _id; }

  bool isValid() const { return _id!=0; }

  void create();

  void destroy();

  virtual void contextDestroyed() { _id = 0; }

private:
  GLuint _id;
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLSLShader : public GLResource {
public:
  GLSLShader(GLenum shaderType) : _shaderType(shaderType), _id(0) {}
  virtual ~GLSLShader() { destroy(); }
  
  inline GLuint getHandle() const { return _id; }
  
  inline bool isValid() const { return _id!=0; }
  
  void create();
  
  void destroy();
  
  virtual void contextDestroyed() { _id = 0; }
  
private:
  GLSLShader() : _shaderType(GL_NONE), _id(0) {}
  
  GLSLShader(const GLSLShader &) : GLResource() {}
  GLSLShader &operator = (const GLSLShader &) { return *this; }

  GLenum _shaderType;
  GLuint _id;
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLSLVertexShader : public GLSLShader {
public:
  GLSLVertexShader() : GLSLShader(GL_VERTEX_SHADER) {}
  virtual ~GLSLVertexShader() {}
private:
  GLSLVertexShader(const GLSLVertexShader &) : GLSLShader(GL_VERTEX_SHADER) {}
  GLSLVertexShader &operator = (const GLSLVertexShader &) { return *this; }
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLSLFragmentShader : public GLSLShader {
public:
  GLSLFragmentShader() : GLSLShader(GL_FRAGMENT_SHADER) {}
  virtual ~GLSLFragmentShader() {}
private:
  GLSLFragmentShader(const GLSLFragmentShader &) : GLSLShader(GL_FRAGMENT_SHADER) {}
  GLSLFragmentShader &operator = (const GLSLFragmentShader &) { return *this; }
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLSLGeometryShader : public GLSLShader {
public:
  GLSLGeometryShader() : GLSLShader(GL_GEOMETRY_SHADER_EXT) {}
  virtual ~GLSLGeometryShader() {}
private:
  GLSLGeometryShader(const GLSLGeometryShader &) : GLSLShader(GL_GEOMETRY_SHADER_EXT) {}
  GLSLGeometryShader &operator = (const GLSLGeometryShader &) { return *this; }
};

//-------------------------------------------------------------------------------------

class MLOPENGL_EXPORT GLSLProgram : public GLResource {
public:
  GLSLProgram() { _id = 0; }
  virtual ~GLSLProgram() { destroy(); }

  void disable();
  
  void detachShader(GLSLShader& shader);

  void detachShader(GLuint shader);

  inline GLuint getHandle() const { return _id; }

  inline bool isValid() const { return _id!=0; }

  void create();

  void destroy();

  virtual void contextDestroyed() { _id = 0; }

private:
  GLuint _id;

  GLSLProgram(const GLSLProgram &) : GLResource() {}
  GLSLProgram &operator = (const GLSLProgram &) { return *this; }
};



ML_OPENGL_END_NAMESPACE

#endif