mlGLResources.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_GLRESOURCES_H
#define ML_GLRESOURCES_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() override { destroy(); };
 
  GLuint getHandle() const  { return _id; }
 
  bool isValid() const { return _id!=0; }
 
  void create();
 
  void destroy();
 
  void contextDestroyed() override { _id = 0; }
 
private:
  GLuint _id;
};
 
//-------------------------------------------------------------------------------------
 
class MLOPENGL_EXPORT GLTextures : public GLResource {
public:
  GLTextures() {};
  ~GLTextures() override { destroy(); };
 
  GLuint getHandle(GLsizei i) const;
 
  GLsizei getNumTextures() const { return static_cast<GLsizei>(_ids.size()); }
 
  bool isValid() const { return !_ids.empty(); }
 
  void create(GLsizei numberOfTextures);
 
  void destroy();
 
  void contextDestroyed() override { _ids.clear(); }
 
private:
  std::vector<GLuint> _ids;
};
 
//-------------------------------------------------------------------------------------
 
class MLOPENGL_EXPORT GLFragmentProgramARB : public GLResource {
public:
  GLFragmentProgramARB() { _id = 0; };
  ~GLFragmentProgramARB() override { destroy(); };
 
  GLuint getHandle() const { return _id; }
 
  bool isValid() const { return _id!=0; }
 
  void create();
 
  void destroy();
 
  void contextDestroyed() override { _id = 0; }
 
private:
  GLuint _id;
};
 
 
//-------------------------------------------------------------------------------------
 
class MLOPENGL_EXPORT GLRenderBuffer : public GLResource {
public:
  GLRenderBuffer() { _id = 0; };
  ~GLRenderBuffer() override { destroy(); };
 
  GLuint getHandle() const { return _id; }
 
  bool isValid() const { return _id!=0; }
 
  void create();
 
  void destroy();
 
  void contextDestroyed() override { _id = 0; }
 
private:
  GLuint _id;
};
 
 
//-------------------------------------------------------------------------------------
 
class MLOPENGL_EXPORT GLFrameBuffer : public GLResource {
public:
  GLFrameBuffer() { _id = 0; };
  ~GLFrameBuffer() override { destroy(); };
 
  GLuint getHandle() const { return _id; }
 
  bool isValid() const { return _id!=0; }
 
  void create();
 
  void destroy();
 
  void contextDestroyed() override { _id = 0; }
 
private:
  GLuint _id;
};
 
//-------------------------------------------------------------------------------------
 
class MLOPENGL_EXPORT GLBuffer : public GLResource {
 
public:
  GLBuffer() { _id = 0; };
  ~GLBuffer() override { destroy(); };
 
  GLuint getHandle() const { return _id; }
 
  bool isValid() const { return _id!=0; }
 
  void create();
 
  void destroy();
 
  void contextDestroyed() override { _id = 0; }
 
private:
  GLuint _id;
};
 
class MLOPENGL_EXPORT GLPixelBuffer : public GLBuffer {
};
 
class MLOPENGL_EXPORT GLVertexBuffer : public GLBuffer {
};
 
//-------------------------------------------------------------------------------------
 
class MLOPENGL_EXPORT GLSLShader : public GLResource {
public:
  GLSLShader(GLenum shaderType) : _shaderType(shaderType), _id(0) {}
  ~GLSLShader() override { destroy(); }
 
  inline GLuint getHandle() const { return _id; }
 
  inline bool isValid() const { return _id!=0; }
 
  void create();
 
  void destroy();
 
  void contextDestroyed() override { _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) {}
  ~GLSLVertexShader() override {}
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) {}
  ~GLSLFragmentShader() override {}
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) {}
  ~GLSLGeometryShader() override {}
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; }
  ~GLSLProgram() override { 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();
 
  void contextDestroyed() override { _id = 0; }
 
private:
  GLuint _id;
 
  GLSLProgram(const GLSLProgram &) : GLResource() {}
  GLSLProgram &operator = (const GLSLProgram &) { return *this; }
};
 
 
 
ML_OPENGL_END_NAMESPACE
 
#endif