539 lines
14 KiB
C++
539 lines
14 KiB
C++
/****************************************************************************
|
|
* VCGLib o o *
|
|
* Visual and Computer Graphics Library o o *
|
|
* _ O _ *
|
|
* Copyright(C) 2004 \/)\/ *
|
|
* Visual Computing Lab /\/| *
|
|
* ISTI - Italian National Research Council | *
|
|
* \ *
|
|
* All rights reserved. *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
|
|
* for more details. *
|
|
* *
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
History
|
|
|
|
$Log: not supported by cvs2svn $
|
|
Revision 1.1 2007/07/26 16:22:47 m_di_benedetto
|
|
First Commit.
|
|
|
|
|
|
|
|
****************************************************************************/
|
|
|
|
#ifndef VCGLIB_GL_SURFACE_H
|
|
#define VCGLIB_GL_SURFACE_H
|
|
|
|
#include <vector>
|
|
#include <GL/glew.h>
|
|
|
|
namespace vcg
|
|
{
|
|
|
|
/****************************************************************************
|
|
The gl_surface class simplify the render-to-texture OpenGL functionality.
|
|
|
|
It provides a framebuffer composed of single or multiple color buffers and
|
|
a depth buffer; color-only and depth-only framebuffers can also be created.
|
|
|
|
Sample usage:
|
|
|
|
****************************************************************
|
|
// *** declaration
|
|
|
|
gl_surface my_srf;
|
|
|
|
|
|
***********************
|
|
// *** initialization: single color render target, with depth buffer
|
|
{
|
|
std::vector<GLenum> color_formats;
|
|
color_formats.push_back(GL_RGBA8);
|
|
|
|
my_srf.set(width, height, color_formats, GL_DEPTH_COMPONENT);
|
|
}
|
|
***********************
|
|
|
|
|
|
***********************
|
|
// *** initialization: two color render targets, without depth buffer
|
|
// NOTE: the maximum number of color targets is implementation dependent.
|
|
// NOTE: DX10 class hardware allows different formats for each color target.
|
|
{
|
|
std::vector<GLenum> color_formats;
|
|
color_formats.push_back(GL_RGBA8);
|
|
color_formats.push_back(GL_RGBA8);
|
|
|
|
my_srf.set(width, height, color_formats, GL_NONE);
|
|
}
|
|
***********************
|
|
|
|
|
|
***********************
|
|
// *** usage: render-to-targets
|
|
{
|
|
my_srf.begin_write();
|
|
application_draw_code();
|
|
my_srf.end_write();
|
|
}
|
|
***********************
|
|
|
|
|
|
***********************
|
|
// *** usage: using rendered textures
|
|
{
|
|
// 2 buffers
|
|
|
|
// bind the second
|
|
glActiveTexture(GL_TEXTURE1);
|
|
my_srf.begin_read_color(1); // actually does a glBindTexture();
|
|
|
|
// bind the first
|
|
glActiveTexture(GL_TEXTURE0);
|
|
my_srf.begin_read_color(0);
|
|
|
|
application_draw_code();
|
|
|
|
// unbind the second
|
|
glActiveTexture(GL_TEXTURE1);
|
|
my_srf.end_read_color(1);
|
|
|
|
// unbind first
|
|
glActiveTexture(GL_TEXTURE0);
|
|
my_srf.end_read_color(0);
|
|
}
|
|
|
|
***********************
|
|
// *** usage: use depth map
|
|
{
|
|
my_srf.begin_read_depth();
|
|
|
|
// use depth map here
|
|
application_draw_code();
|
|
|
|
my_srf.end_read_depth();
|
|
}
|
|
|
|
***********************
|
|
// *** usage: cleanup
|
|
{
|
|
my_srf.clear();
|
|
// clear() is also safely called in the destructor.
|
|
}
|
|
***********************
|
|
|
|
Other commodity methods for getting/setting pixels are also provided.
|
|
|
|
****************************************************************************/
|
|
|
|
class gl_surface
|
|
{
|
|
public:
|
|
|
|
typedef gl_surface this_type;
|
|
|
|
gl_surface(void) : width(0), height(0), depth_tex(0), fb(0)
|
|
{
|
|
;
|
|
}
|
|
|
|
~gl_surface(void)
|
|
{
|
|
this->clear();
|
|
}
|
|
|
|
bool set(int width, int height, const std::vector<GLenum> & color_formats, GLenum depth_format)
|
|
{
|
|
this->clear();
|
|
|
|
this->width = width;
|
|
this->height = height;
|
|
|
|
this->color_formats = color_formats;
|
|
|
|
this->color_texs.resize(color_formats.size());
|
|
|
|
for (size_t i=0; i<this->color_texs.size(); ++i)
|
|
{
|
|
glGenTextures (1, &(this->color_texs[i]));
|
|
glBindTexture (GL_TEXTURE_2D, this->color_texs[i]);
|
|
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);
|
|
glTexImage2D (GL_TEXTURE_2D, 0, this->color_formats[i], this->width, this->height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
|
|
}
|
|
|
|
this->depth_format = depth_format;
|
|
if (this->depth_format != GL_NONE)
|
|
{
|
|
glGenTextures (1, &(this->depth_tex));
|
|
glBindTexture (GL_TEXTURE_2D, this->depth_tex);
|
|
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);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
|
|
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
|
|
glTexImage2D (GL_TEXTURE_2D, 0, this->depth_format, this->width, this->height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0);
|
|
}
|
|
|
|
glGenFramebuffersEXT(1, &(this->fb));
|
|
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, this->fb);
|
|
|
|
std::vector<GLenum> sites(this->color_texs.size());
|
|
for (size_t i=0; i<this->color_texs.size(); ++i)
|
|
{
|
|
sites[i] = GL_COLOR_ATTACHMENT0_EXT + ((GLenum)i);
|
|
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, sites[i], GL_TEXTURE_2D, this->color_texs[i], 0);
|
|
}
|
|
|
|
if (this->depth_format != GL_NONE)
|
|
{
|
|
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, this->depth_tex, 0);
|
|
}
|
|
|
|
if (!sites.empty())
|
|
{
|
|
glDrawBuffers((GLsizei)(sites.size()), &(sites[0]));
|
|
}
|
|
|
|
const GLenum s = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
|
|
const bool res = (s == GL_FRAMEBUFFER_COMPLETE_EXT);
|
|
|
|
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
|
|
|
|
if (!res)
|
|
{
|
|
glDeleteFramebuffersEXT(1, &(this->fb));
|
|
this->fb = 0;
|
|
|
|
for (size_t i=0; i<this->color_texs.size(); ++i)
|
|
{
|
|
glDeleteTextures(1, &(this->color_texs[i]));
|
|
}
|
|
this->color_texs.clear();
|
|
|
|
this->color_formats.clear();
|
|
|
|
if (this->depth_tex != 0)
|
|
{
|
|
glDeleteTextures(1, &(this->depth_tex));
|
|
this->depth_tex = 0;
|
|
}
|
|
|
|
this->width = 0;
|
|
this->height = 0;
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool set_simple(int width, int height)
|
|
{
|
|
std::vector<GLenum> c_formats;
|
|
c_formats.push_back(GL_RGBA8);
|
|
|
|
return this->set(width, height, c_formats, GL_DEPTH_COMPONENT);
|
|
}
|
|
|
|
bool set_color_only(int width, int height, GLenum color_format)
|
|
{
|
|
std::vector<GLenum> c_formats;
|
|
c_formats.push_back(color_format);
|
|
|
|
return this->set(width, height, c_formats, GL_NONE);
|
|
}
|
|
|
|
bool set_color_only(int width, int height, const std::vector<GLenum> & color_formats)
|
|
{
|
|
return this->set(width, height, color_formats, GL_NONE);
|
|
}
|
|
|
|
bool set_depth_only(int width, int height, GLenum depth_format)
|
|
{
|
|
std::vector<GLenum> c_formats;
|
|
|
|
return this->set(width, height, c_formats, depth_format);
|
|
}
|
|
|
|
bool clear(void)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
|
|
glDeleteFramebuffersEXT(1, &(this->fb));
|
|
this->fb = 0;
|
|
|
|
for (size_t i=0; i<this->color_texs.size(); ++i)
|
|
{
|
|
glDeleteTextures(1, &(this->color_texs[i]));
|
|
}
|
|
this->color_texs.clear();
|
|
|
|
this->color_formats.clear();
|
|
|
|
if (this->depth_tex != 0)
|
|
{
|
|
glDeleteTextures(1, &(this->depth_tex));
|
|
this->depth_tex = 0;
|
|
}
|
|
|
|
this->width = 0;
|
|
this->height = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool is_valid(void) const
|
|
{
|
|
return (this->fb != 0);
|
|
}
|
|
|
|
int get_width(void) const
|
|
{
|
|
return this->width;
|
|
}
|
|
|
|
int get_height(void) const
|
|
{
|
|
return this->height;
|
|
}
|
|
|
|
int color_attachments_count(void) const
|
|
{
|
|
return ((int)(this->color_texs.size()));
|
|
}
|
|
|
|
GLenum get_color_attachment_format(int attachment) const
|
|
{
|
|
if (!this->is_valid()) return GL_NONE;
|
|
if ((attachment < 0) || (attachment >= this->color_attachments_count())) return GL_NONE;
|
|
|
|
return this->color_formats[attachment];
|
|
}
|
|
|
|
bool has_depth_attachment(void) const
|
|
{
|
|
return (this->depth_tex != 0);
|
|
}
|
|
|
|
GLenum get_depth_attachment_format(void) const
|
|
{
|
|
if (!this->is_valid()) return GL_NONE;
|
|
if (!this->has_depth_attachment()) return GL_NONE;
|
|
|
|
return this->depth_format;
|
|
}
|
|
|
|
bool set_color_pixels(int attachment, GLenum format, GLenum type, const void * pixels)
|
|
{
|
|
if (!this->begin_read_color(attachment)) return false;
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, this->color_formats[attachment], this->width, this->height, 0, format, type, pixels);
|
|
|
|
this->end_read_color(attachment);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool get_color_pixels(int attachment, GLenum format, GLenum type, void * pixels)
|
|
{
|
|
if (!this->begin_read_color(attachment)) return false;
|
|
|
|
glGetTexImage(GL_TEXTURE_2D, 0, format, type, pixels);
|
|
|
|
this->end_read_color(attachment);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool set_depth_pixels(GLenum format, GLenum type, const void * pixels)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
if (!this->has_depth_attachment()) return false;
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, this->depth_format, this->width, this->height, 0, format, type, pixels);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool get_depth_pixels(GLenum format, GLenum type, void * pixels)
|
|
{
|
|
if (!this->begin_read_depth()) return false;
|
|
|
|
glGetTexImage(GL_TEXTURE_2D, 0, format, type, pixels);
|
|
|
|
this->end_read_depth();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool begin_read_color(int attachment)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
if ((attachment < 0) || (attachment >= this->color_attachments_count())) return false;
|
|
|
|
glBindTexture(GL_TEXTURE_2D, this->color_texs[attachment]);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool end_read_color(int attachment)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
if ((attachment < 0) || (attachment >= this->color_attachments_count())) return false;
|
|
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool begin_read_depth(void)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
if (!this->has_depth_attachment()) return false;
|
|
|
|
glBindTexture(GL_TEXTURE_2D, this->depth_tex);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool end_read_depth(void)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
if (!this->has_depth_attachment()) return false;
|
|
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool begin_write(void)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
|
|
glPushAttrib(GL_VIEWPORT_BIT);
|
|
|
|
glViewport(0, 0, this->width, this->height);
|
|
|
|
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, this->fb);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool end_write(void)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
|
|
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
|
|
|
|
glPopAttrib();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool draw_color_attachment(int x, int y, int width, int height, int attachment)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
if ((attachment < 0) || (attachment >= this->color_attachments_count())) return false;
|
|
|
|
glPushAttrib(GL_ALL_ATTRIB_BITS);
|
|
|
|
glViewport(x, y, width, height);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
this->begin_read_color(attachment);
|
|
glBegin(GL_QUADS);
|
|
glTexCoord2f(0.0f, 0.0f); glVertex2f(-1.0f, -1.0f);
|
|
glTexCoord2f(1.0f, 0.0f); glVertex2f( 1.0f, -1.0f);
|
|
glTexCoord2f(1.0f, 1.0f); glVertex2f( 1.0f, 1.0f);
|
|
glTexCoord2f(0.0f, 1.0f); glVertex2f(-1.0f, 1.0f);
|
|
glEnd();
|
|
this->end_read_color(attachment);
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPopMatrix();
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
|
|
glPopAttrib();
|
|
return true;
|
|
}
|
|
|
|
bool draw_depth_attachment(int x, int y, int width, int height)
|
|
{
|
|
if (!this->is_valid()) return false;
|
|
if (!this->has_depth_attachment()) return false;
|
|
|
|
glPushAttrib(GL_ALL_ATTRIB_BITS);
|
|
|
|
glViewport(x, y, width, height);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
this->begin_read_depth();
|
|
glBegin(GL_QUADS);
|
|
glTexCoord2f(0.0f, 0.0f); glVertex2f(-1.0f, -1.0f);
|
|
glTexCoord2f(1.0f, 0.0f); glVertex2f( 1.0f, -1.0f);
|
|
glTexCoord2f(1.0f, 1.0f); glVertex2f( 1.0f, 1.0f);
|
|
glTexCoord2f(0.0f, 1.0f); glVertex2f(-1.0f, 1.0f);
|
|
glEnd();
|
|
this->end_read_depth();
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
glPopMatrix();
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glPopMatrix();
|
|
|
|
glPopAttrib();
|
|
return true;
|
|
}
|
|
|
|
protected:
|
|
|
|
int width;
|
|
int height;
|
|
std::vector<GLenum> color_formats;
|
|
std::vector<GLuint> color_texs;
|
|
GLenum depth_format;
|
|
GLuint depth_tex;
|
|
GLuint fb;
|
|
};
|
|
|
|
} // end namespace vcg
|
|
|
|
#endif // VCGLIB_GL_SURFACE_H
|