ripple/FBO.cpp

225 lines
7.6 KiB
C++
Raw Normal View History

2017-11-26 05:47:29 +00:00
///////////////////////////////////////////////////////////////////////////////
/// @file FBO.cpp
/// @author Olivier Dionne
/// @brief Définit la classe FBO implémentant un Frame Buffer Object simple
/// pour openGL
/// @date 2008-10-19
/// @version 1.0
///
///////////////////////////////////////////////////////////////////////////////
#include "FBO.h"
using namespace std;
///////////////////////////////////////////////////////////////////////////////
/// public overloaded constructor FBO \n
///
/// Crée un FBO très simple où tous les membres privés sont à 0.
///
/// @return Aucune
///
/// @author Olivier Dionne
/// @date 2008-10-19
///
///////////////////////////////////////////////////////////////////////////////
FBO::FBO() :
m_FBO( 0 ),
m_Texture( 0 ),
m_InternalFormat( 0 ),
m_Target( GL_TEXTURE_2D ),
m_TextureW( 0 ),
m_TextureH( 0 )
{
}
///////////////////////////////////////////////////////////////////////////////
/// public destructor ~FBO \n
///
/// Détruit un objet FBO
///
/// @return Aucune
///
/// @author Olivier Dionne
/// @date 2008-10-19
///
///////////////////////////////////////////////////////////////////////////////
FBO::~FBO()
{
Liberer();
}
///////////////////////////////////////////////////////////////////////////////
/// public Init \n
///
/// Cette méthode initialise le FBO en créant les noms de texture à l'interne.
/// Pour une mise à jour du FBO à chaque image, cette fonction NE DEVRAIT PAS
/// être appelée constamment, parce qu'elle consomme de la mémoire et est
/// relativement lente. On conseille donc d'appeler Init() une seule fois au début
/// de l'application, puis simplement d'utiliser la paire CommencerCapture() et
/// TerminerCapture() afin de mettre à jour le contenu interne du FBO en tout temps.
/// Évidemment, parce qu'il est important que la taille du FBO soit la même que le
/// viewport courant, si la taille du viewport change en cours d'exécution, il est
/// impératif d'appeler Init() à nouveau (avec les nouvelles valeurs de w et de h), mais
/// en ayant pris soin au préalable de LIBERER la mémoire du FBO.
///
/// @param [in] w int La largeur du viewport / de la texture interne
/// @param [in] h int La hauteur du viewport / de la texture interne
/// @param [in] format int Le format interne de la texture du FBO (communément GL_RGB)
///
/// @return Aucune
///
/// @author Olivier Dionne
/// @date 2008-10-19
///
///////////////////////////////////////////////////////////////////////////////
void FBO::Init( int w, int h )
{
// Dimensions
m_TextureW = w;
m_TextureH = h;
// TODO: Remplir la fonction d'initialisation d'un FBO:
// Créer et lier un nouveau frame buffer avec l'ID m_fbo:
glGenFramebuffers(1, &m_FBO);
glBindFramebuffer(GL_FRAMEBUFFER, m_FBO);
// Créer une texture RGB pour les couleurs avec L'ID m_Texture:
// Pour échantillionner plus tard des valeurs exactes
// on veut des filtres de mignification et magnification de tpe NEAREST!
glGenTextures(1, &m_Texture);
glBindTexture(m_Target, m_Texture);
glTexParameteri(m_Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(m_Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(m_Target, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
// Créer une texture de profondeurs pour les couleurs avec L'ID m_Profondeur:
glGenTextures(1, &m_Profondeur);
glBindTexture(m_Target, m_Profondeur);
glTexParameteri(m_Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(m_Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(m_Target, 0, GL_DEPTH_COMPONENT, w, h, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
// Attacher nos deux textures au frame buffer à des fin d'affichage (DRAW):
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_Target, m_Texture, 0);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_Target, m_Profondeur, 0);
// Vérification des erreurs FBO
// Nous vous fournissons cette vérification d'erreurs
// pour que vous arriviez plus aisément à déboguer votre code.
GLenum status = glCheckFramebufferStatus( GL_FRAMEBUFFER );
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// On vérifie les erreurs à la suite de la création du FBO
switch( status )
{
case GL_FRAMEBUFFER_COMPLETE_EXT:
break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
cerr << "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT" << endl;
break;
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
cerr << "GL_FRAMEBUFFER_UNSUPPORTED_EXT" << endl;
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
cerr << "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT" << endl;
break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
cerr << "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT" << endl;
break;
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
cerr << "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT" << endl;
break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
cerr << "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT" << endl;
break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
cerr << "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT" << endl;
break;
default:
cerr << "ERREUR INCONNUE" << endl;
}
}
///////////////////////////////////////////////////////////////////////////////
/// public Liberer \n
///
/// Cette fonction libère l'espace mémoire interne du FBO
///
/// @return Aucune
///
/// @author Olivier Dionne
/// @date 2008-10-19
///
///////////////////////////////////////////////////////////////////////////////
void FBO::Liberer()
{
if ( m_Texture )
{
glDeleteTextures( 1, &m_Texture );
m_Texture = 0;
}
if ( m_FBO )
{
glDeleteFramebuffers( 1, &m_FBO );
m_FBO = 0;
}
if(m_Profondeur)
{
glDeleteTextures( 1, &m_Profondeur );
m_Profondeur = 0;
}
}
///////////////////////////////////////////////////////////////////////////////
/// public CommencerCapture \n
///
/// Cette fonction débute la définition du contenu du FBO. Son utilisation est
/// très simple et intuitive. Une fois le FBO construit et initialiser avec new ()
/// et Init(), on n'a qu'à insérer les commandes openGL produisant le rendu externe
/// voulu (qui sera enregistré dans le FBO) entre les commandes CommencerCapture() et
/// TerminerCapture();
///
/// @return Aucune
///
/// @author Olivier Dionne, Frédéric Plourde
/// @date 2008-10-19
///
///////////////////////////////////////////////////////////////////////////////
void FBO::CommencerCapture()
{
// TODO:
// Activer l'utilisation du FBO
// Attention à la résolution avec laquelle on veut afficher!
glBindFramebuffer(GL_FRAMEBUFFER, m_FBO);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushAttrib(GL_VIEWPORT_BIT);
glViewport(0,0,m_TextureW, m_TextureH);
}
///////////////////////////////////////////////////////////////////////////////
/// public TerminerCapture \n
///
/// Cette fonction termine la définition du contenu du FBO. Son utilisation est
/// très simple et intuitive. Une fois le FBO construit et initialiser avec new ()
/// et Init(), on n'a qu'à insérer les commandes openGL produisant le rendu externe
/// voulu (qui sera enregistré dans le FBO) entre les commandes CommencerCapture() et
/// TerminerCapture();
///
/// @return Aucune
///
/// @author Olivier Dionne
/// @date 2008-10-19
///
///////////////////////////////////////////////////////////////////////////////
void FBO::TerminerCapture()
{
// TODO:
// Remettre OpenGL dans l'état par défaut
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glPopAttrib();
}