/* MapPreviewCanvas::createImage
* Draws the map in an image
* TODO: Factorize code with normal draw() and showMap() functions.
* TODO: Find a way to generate an arbitrary-sized image through
* tiled rendering.
*******************************************************************/
void MapPreviewCanvas::createImage(ArchiveEntry& ae, int width, int height)
{
// Find extents of map
mep_vertex_t m_min(999999.0, 999999.0);
mep_vertex_t m_max(-999999.0, -999999.0);
for (unsigned a = 0; a < verts.size(); a++)
{
if (verts[a].x < m_min.x)
m_min.x = verts[a].x;
if (verts[a].x > m_max.x)
m_max.x = verts[a].x;
if (verts[a].y < m_min.y)
m_min.y = verts[a].y;
if (verts[a].y > m_max.y)
m_max.y = verts[a].y;
}
double mapwidth = m_max.x - m_min.x;
double mapheight = m_max.y - m_min.y;
if (width == 0) width = -5;
if (height == 0) height = -5;
if (width < 0)
width = mapwidth / abs(width);
if (height < 0)
height = mapheight / abs(height);
// Setup colours
wxColour wxc;
wxc.Set(map_image_col_background); rgba_t col_save_background(wxc.Red(), wxc.Green(), wxc.Blue(), 255);
wxc.Set(map_image_col_line_1s); rgba_t col_save_line_1s(wxc.Red(), wxc.Green(), wxc.Blue(), 255);
wxc.Set(map_image_col_line_2s); rgba_t col_save_line_2s(wxc.Red(), wxc.Green(), wxc.Blue(), 255);
wxc.Set(map_image_col_line_special); rgba_t col_save_line_special(wxc.Red(), wxc.Green(), wxc.Blue(), 255);
wxc.Set(map_image_col_line_macro); rgba_t col_save_line_macro(wxc.Red(), wxc.Green(), wxc.Blue(), 255);
col_save_background.a = map_image_alpha_background;
// Setup OpenGL rigmarole
GLuint texID, fboID;
if (GLEW_ARB_framebuffer_object)
{
glGenTextures(1, &texID);
glBindTexture(GL_TEXTURE_2D, texID);
// We don't use mipmaps, but OpenGL will refuse to attach
// the texture to the framebuffer if they are not present
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffersEXT(1, &fboID);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboID);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texID, 0);
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
}
glViewport(0, 0, width, height);
// Setup the screen projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, width, 0, height, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Clear
glClearColor(((double)col_save_background.r)/255.f, ((double)col_save_background.g)/255.f,
((double)col_save_background.b)/255.f, ((double)col_save_background.a)/255.f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// Translate to inside of pixel (otherwise inaccuracies can occur on certain gl implementations)
if (OpenGL::accuracyTweak())
glTranslatef(0.375f, 0.375f, 0);
// Zoom/offset to show full map
// Offset to center of map
offset_x = m_min.x + (mapwidth * 0.5);
offset_y = m_min.y + (mapheight * 0.5);
// Zoom to fit whole map
double x_scale = ((double)width) / mapwidth;
double y_scale = ((double)height) / mapheight;
zoom = MIN(x_scale, y_scale);
zoom *= 0.95;
// Translate to middle of canvas
glTranslated(width>>1, height>>1, 0);
// Zoom
glScaled(zoom, zoom, 1);
// Translate to offset
glTranslated(-offset_x, -offset_y, 0);
// Setup drawing
glDisable(GL_TEXTURE_2D);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glLineWidth(map_image_thickness);
glEnable(GL_LINE_SMOOTH);
// Draw lines
for (unsigned a = 0; a < lines.size(); a++)
{
mep_line_t line = lines[a];
// Check ends
if (line.v1 >= verts.size() || line.v2 >= verts.size())
continue;
// Get vertices
mep_vertex_t v1 = verts[lines[a].v1];
mep_vertex_t v2 = verts[lines[a].v2];
// Set colour
if (line.special)
OpenGL::setColour(col_save_line_special);
else if (line.macro)
OpenGL::setColour(col_save_line_macro);
else if (line.twosided)
OpenGL::setColour(col_save_line_2s);
else
OpenGL::setColour(col_save_line_1s);
// Draw line
glBegin(GL_LINES);
glVertex2d(v1.x, v1.y);
glVertex2d(v2.x, v2.y);
glEnd();
}
glLineWidth(1.0f);
glDisable(GL_LINE_SMOOTH);
uint8_t* ImageBuffer = new uint8_t[width * height * 4];
glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, ImageBuffer);
if (GLEW_ARB_framebuffer_object)
{
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glDeleteTextures( 1, &texID );
glDeleteFramebuffersEXT( 1, &fboID );
}
SImage img;
img.setImageData(ImageBuffer, width, height, RGBA);
img.mirror(true);
MemChunk mc;
SIFormat::getFormat("png")->saveImage(img, mc);
ae.importMemChunk(mc);
}
bool fbo::setup( GLint color_format, GLint depth_format, GLsizei w, GLsizei h)
{
ready = false;
_w = w, _h = h;
GLint o[1], v[4];
get_framebuffer(o, v);
$glGenFramebuffersEXT(1, &frame);
$glGenTextures (1, &color);
$glGenTextures (1, &depth);
// Initialize the color render buffer object.
$glBindTexture(GL_TEXTURE_2D, color);
$glTexImage2D (GL_TEXTURE_2D, 0, color_format, w, h, 0,GL_RGBA, GL_INT, NULL);
$glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
$glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
$glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
$glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Initialize the depth render buffer object.
$glBindTexture(GL_TEXTURE_2D, depth);
$glTexImage2D (GL_TEXTURE_2D, 0, depth_format, w, h, 0,GL_DEPTH_COMPONENT, GL_INT, NULL);
$glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
$glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
$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_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
// Initialize the frame buffer object.
$glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, frame);
$glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D, color, 0);
$glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D, depth, 0);
// Confirm the frame buffer object status.
auto result = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );
;
switch( result )
{
case GL_FRAMEBUFFER_COMPLETE_EXT:
break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
assert( !"Framebuffer incomplete attachment" );
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
assert( !"Framebuffer missing attachment" );
case GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT:
assert( !"Framebuffer duplicate attachment" );
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
assert( !"Framebuffer dimensions" );
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
assert( !"Framebuffer formats" );
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
assert( !"Framebuffer draw buffer" );
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
assert( !"Framebuffer read buffer" );
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
assert( !"Framebuffer unsupported" );
default:
assert( !"Framebuffer error" );
}
// Zero the buffer.
$glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
set_framebuffer(o, v);
ready = true;
return true;
}
static int
create_cube_fbo(void)
{
GLuint tex, fb;
GLenum status;
int face, dim;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
for (face = 0; face < 6; face++) {
int level = 0;
for (dim = BUF_WIDTH; dim > 0; dim /= 2) {
glTexImage2D(cube_face_targets[face], level, GL_RGBA,
dim, dim,
0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
level++;
}
}
assert(glGetError() == 0);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
for (face = 0; face < 6; face++) {
int level = 0;
for (dim = BUF_WIDTH; dim > 0; dim /= 2) {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
cube_face_targets[face],
tex,
level);
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO incomplete\n");
goto done;
}
glViewport(0, 0, dim, dim);
piglit_ortho_projection(dim, dim, GL_FALSE);
glColor4fv(get_face_color(face, level));
/* Draw a little outside the bounds to make
* sure clipping's working.
*/
piglit_draw_rect(-2, -2, dim + 2, dim + 2);
level++;
}
}
done:
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
return tex;
}
void init()
{
GLint maxBuffers;
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &maxBuffers);
printf("MAX_COLOR_ATTACHMENTS: %d\n", maxBuffers);
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.2f, 0.5f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glViewport(0, 0, 800, 600);
// setup the FBO
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
// create the render buffer for depth
glGenRenderbuffersEXT(1, &depthBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height);
// setup the texture to render to
glGenTextures(1, &img);
glBindTexture(GL_TEXTURE_2D, img);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// mipmap
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
//glGenerateMipmapEXT(GL_TEXTURE_2D);
// Attach the texture to the FBO for rendering
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, img, 0);
// setup the second texture to render to
glGenTextures(1, &img2);
glBindTexture(GL_TEXTURE_2D, img2);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// attach the second texture
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, img2, 0);
// attach the depth buffer to the FBO
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthBuffer);
// check the FBO status
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
{
printf("ERROR: FBO status not complete\n");
exit(1);
}
// detach the FBO
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
enum piglit_result piglit_display(void)
{
static const char *frag_src =
"!!ARBfp1.0\n"
"TEX result.color, fragment.texcoord[0], texture[0], 2D;\n"
"END";
static const struct
{
int x;
int y;
float color[3];
}
expected[] =
{
{ 64, 240, {0.1f, 0.1f, 0.1f}},
{ 192, 240, {0.3f, 0.3f, 0.3f}},
{ 320, 240, {0.5f, 0.5f, 0.5f}},
{ 448, 240, {0.7f, 0.7f, 0.7f}},
{ 576, 240, {0.9f, 0.9f, 0.9f}},
};
GLuint fbo, frag, db_tex, cb_tex;
GLboolean pass = GL_TRUE;
char *tex_data;
unsigned int i;
frag = piglit_compile_program(GL_FRAGMENT_PROGRAM_ARB, frag_src);
glGenFramebuffersEXT(1, &fbo);
glGenTextures(1, &cb_tex);
glGenTextures(1, &db_tex);
tex_data = calloc(piglit_width * piglit_height, 4);
glBindTexture(GL_TEXTURE_2D, db_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, piglit_width, piglit_height,
0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, tex_data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, cb_tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, piglit_width, piglit_height,
0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, tex_data);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
free(tex_data);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, db_tex, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, cb_tex, 0);
check_fbo_status();
glViewport(0, 0, piglit_width, piglit_height);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
glDepthMask(GL_TRUE);
/* Draw with the texture to make sure a sampler view is created for
* it before it's used as depth buffer by the FBO. */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glBindTexture(GL_TEXTURE_2D, db_tex);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, frag);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glEnable(GL_TEXTURE_2D);
piglit_draw_rect_tex(-1.0f, -1.0f, 2.0f, 2.0f,
0.0f, 0.0f, 1.0f, 1.0f);
/* Fill the depth buffer with a gradient. */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
check_fbo_status();
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glDisable(GL_TEXTURE_2D);
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClearDepth(0.5f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(0.0f, 1.0f, 1.0f);
glBegin(GL_TRIANGLE_STRIP);
glVertex3f(-1.0f, -1.0f, -1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glVertex3f( 1.0f, -1.0f, 1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);
glEnd();
/* Draw the depth texture as greyscale to the backbuffer. */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glEnable(GL_TEXTURE_2D);
piglit_draw_rect_tex(-1.0f, -1.0f, 2.0f, 2.0f,
0.0f, 0.0f, 1.0f, 1.0f);
for (i = 0; i < sizeof(expected) / sizeof(*expected); ++i)
{
pass &= piglit_probe_pixel_rgb(expected[i].x, expected[i].y, expected[i].color);
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void GPU_offscreen_read_pixels(GPUOffScreen *ofs, int type, void *pixels)
{
const int w = GPU_texture_width(ofs->color);
const int h = GPU_texture_height(ofs->color);
if (GPU_texture_target(ofs->color) == GL_TEXTURE_2D_MULTISAMPLE) {
/* For a multi-sample texture,
* we need to create an intermediate buffer to blit to,
* before its copied using 'glReadPixels' */
/* not needed since 'ofs' needs to be bound to the framebuffer already */
// #define USE_FBO_CTX_SWITCH
GLuint fbo_blit = 0;
GLuint tex_blit = 0;
GLenum status;
/* create texture for new 'fbo_blit' */
glGenTextures(1, &tex_blit);
if (!tex_blit) {
goto finally;
}
glBindTexture(GL_TEXTURE_2D, tex_blit);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, type, 0);
#ifdef USE_FBO_CTX_SWITCH
/* read from multi-sample buffer */
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, ofs->color->fb->object);
glFramebufferTexture2DEXT(
GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT + ofs->color->fb_attachment,
GL_TEXTURE_2D_MULTISAMPLE, ofs->color->bindcode, 0);
status = glCheckFramebufferStatusEXT(GL_READ_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
goto finally;
}
#endif
/* write into new single-sample buffer */
glGenFramebuffersEXT(1, &fbo_blit);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo_blit);
glFramebufferTexture2DEXT(
GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, tex_blit, 0);
status = glCheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
goto finally;
}
/* perform the copy */
glBlitFramebufferEXT(0, 0, w, h, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
/* read the results */
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fbo_blit);
glReadPixels(0, 0, w, h, GL_RGBA, type, pixels);
#ifdef USE_FBO_CTX_SWITCH
/* restore the original frame-bufer */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, ofs->color->fb->object);
#undef USE_FBO_CTX_SWITCH
#endif
finally:
/* cleanup */
if (tex_blit) {
glDeleteTextures(1, &tex_blit);
}
if (fbo_blit) {
glDeleteFramebuffersEXT(1, &fbo_blit);
}
GPU_ASSERT_NO_GL_ERRORS("Read Multi-Sample Pixels");
}
else {
glReadPixels(0, 0, w, h, GL_RGBA, type, pixels);
}
}
enum piglit_result
piglit_display(void)
{
static GLenum buffers[] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT};
static const float red[] = {1.0f, 0.0f, 0.0f};
static const float green[] = {0.0f, 1.0f, 0.0f};
static const float blue[] = {0.0f, 0.0f, 1.0f};
static const struct {
GLsizei buffer_count;
const float *clear_color;
const float *expected_0;
const float *expected_1;
} tests[] = {
{2, red, red, red},
{1, green, green, red},
{2, blue, blue, blue},
};
int w = piglit_width;
int h = piglit_height;
GLuint fbo, tex[2];
unsigned i;
glGenTextures(2, tex);
glBindTexture(GL_TEXTURE_2D, tex[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h,
0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
glBindTexture(GL_TEXTURE_2D, tex[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h,
0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, tex[0], 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT,
GL_TEXTURE_2D, tex[1], 0);
check_fbo_status();
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
for (i = 0; i < sizeof(tests) / sizeof(*tests); ++i) {
GLint buffer, expected_buffer;
glDrawBuffersARB(tests[i].buffer_count, buffers);
check_fbo_status();
glGetIntegerv(GL_DRAW_BUFFER1_ARB, &buffer);
expected_buffer = tests[i].buffer_count < 2 ? GL_NONE : GL_COLOR_ATTACHMENT1_EXT;
if (buffer != expected_buffer) {
printf("Unexpected buffer %#x for DRAW_BUFFER1_ARB in test %u, expected %#x.\n",
buffer, i, expected_buffer);
piglit_report_result(PIGLIT_FAIL);
}
glClearColor(tests[i].clear_color[0], tests[i].clear_color[1],
tests[i].clear_color[2], 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
if (!piglit_probe_pixel_rgb(w / 2, h / 2, tests[i].expected_0)) {
printf("Probe failed for test %u, attachment 0.\n", i);
piglit_report_result(PIGLIT_FAIL);
}
glReadBuffer(GL_COLOR_ATTACHMENT1_EXT);
if (!piglit_probe_pixel_rgb(w / 2, h / 2, tests[i].expected_1)) {
printf("Probe failed for test %u, attachment 1.\n", i);
piglit_report_result(PIGLIT_FAIL);
}
}
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
return PIGLIT_PASS;
}
//////////////////////////////////////////////////////////////////////////
// This is the routine where we create the data being output by the Virtual
// Camera device.
// Modified as per red5 to allow for dropped frames and reset of time stamps
//
// http://comSender.googlecode.com/svn/trunk/
//
//////////////////////////////////////////////////////////////////////////
HRESULT CVCamStream::FillBuffer(IMediaSample *pms)
{
unsigned char *buffer;
unsigned char *src;
unsigned char *dst;
unsigned char red, grn, blu;
unsigned int i, imagesize, width, height;
long l, lDataLen;
HRESULT hr=S_OK;;
BYTE *pData;
HGLRC glCtx;
float dim[4]; // for saving the viewport dimensions
VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER *) m_mt.Format();
// If graph is inactive stop cueing samples
if(!m_pParent->IsActive()) {
return S_FALSE;
}
// first get the timing right
// create some working info
REFERENCE_TIME rtNow, rtDelta, rtDelta2=0; // delta for dropped, delta 2 for sleep.
REFERENCE_TIME avgFrameTime = ((VIDEOINFOHEADER*)m_mt.pbFormat)->AvgTimePerFrame;
// Simple method - avoids "stuttering" in yawcam but VLC fails !
/*
rtNow = m_rtLastTime;
m_rtLastTime += avgFrameTime;
pms->SetTime(&rtNow, &m_rtLastTime);
pms->SetSyncPoint(TRUE);
*/
// What Time is it REALLY ???
m_pParent->GetSyncSource(&m_pClock);
m_pClock->GetTime(&refSync1);
if(m_pClock) m_pClock->Release();
if(NumFrames <= 1) {
// initiate values
refStart = refSync1; // FirstFrame No Drop.
refSync2 = 0;
}
// Set the timestamps that will govern playback frame rate.
// The current time is the sample's start
rtNow = m_rtLastTime;
m_rtLastTime = avgFrameTime + m_rtLastTime;
// IAMDropppedFrame. We only have avgFrameTime to generate image.
// Find generated stream time and compare to real elapsed time
rtDelta=((refSync1-refStart)-(((NumFrames)*avgFrameTime)-avgFrameTime));
if(rtDelta-refSync2 < 0) {
//we are early
rtDelta2=rtDelta-refSync2;
if( abs(rtDelta2/10000)>=1)
Sleep(abs(rtDelta2/10000));
} // endif (rtDelta-refSync2 < 0)
else if(rtDelta/avgFrameTime>NumDroppedFrames) {
// new dropped frame
NumDroppedFrames = rtDelta/avgFrameTime;
// Figure new RT for sleeping
refSync2 = NumDroppedFrames*avgFrameTime;
// Our time stamping needs adjustment.
// Find total real stream time from start time
rtNow = refSync1-refStart;
m_rtLastTime = rtNow+avgFrameTime;
pms->SetDiscontinuity(true);
} // end else if(rtDelta/avgFrameTime>NumDroppedFrames)
// The SetTime method sets the stream times when this sample should begin and finish.
hr = pms->SetTime(&rtNow, &m_rtLastTime);
// Set true on every sample for uncompressed frames
hr = pms->SetSyncPoint(true);
// ============== END OF INITIAL TIMING ============
// Check access to the sample's data buffer
pms->GetPointer(&pData);
if(pData == NULL) {
return NOERROR;
}
// Get the current frame size for texture transfers
imagesize = (unsigned int)pvi->bmiHeader.biSizeImage;
width = (unsigned int)pvi->bmiHeader.biWidth;
height = (unsigned int)pvi->bmiHeader.biHeight;
if(width == 0 || height == 0) {
return NOERROR;
}
// don't do anything if disconnected because it will already have connected
// previously and something has changed. It can only disconnect after it has connected.
if(!bDisconnected) {
// This also initialises OpenGL and Glew - bInitialized is set if all is OK
if(!bInitialized) {
if(OpenReceiver() == NOERROR) {
bInitialized = true;
bDisconnected = false;
if(!bMemoryMode) {
InitTexture(g_Width, g_Height); // the size of the camera window
}
}
else {
bInitialized = false;
bDisconnected = true;
}
return NOERROR;
}
// check gl context again
glCtx = wglGetCurrentContext();
if(glCtx == NULL) {
receiver.ReleaseReceiver();
bInitialized = false;
bDisconnected = true; // don't try again
return NOERROR;
}
// Check that a texture Sender has not changed size
// If connected, sizes should be OK, but check again
unsigned int size = (unsigned int)pms->GetSize();
imagesize = width*height*3; // also retrieved above
if(size != imagesize) {
receiver.ReleaseReceiver();
bInitialized = false;
bDisconnected = true; // don't try again
return NOERROR;
}
//
// everything matches so go ahead with the shared texture read
if(!bDisconnected) {
if(bMemoryMode) {
//
// Memoryshare instead of interop texture share
//
// A memoryshare sender cannot change from startup like a texture sender
// so the global width and height are always the same as the camera width and height
//
// Read the bitmap from shared memory into a local buffer
buffer = (unsigned char *)malloc(g_Width*g_Height*3);
if(buffer) {
// Format for Receiveimage in memoryshare mode is GL_RGB
// because there is no texture to receive
if(receiver.ReceiveImage(SharedMemoryName, senderWidth, senderHeight, buffer, GL_RGB)) {
// first check that the image size has not changed
if(senderWidth == g_Width && senderHeight == g_Height) {
// all is OK - flip the data for correct orientation and change pixel format
FlipVertical(buffer, g_Width, g_Height);
dst = (unsigned char *)pData;
src = buffer;
for(i=0; i<g_Width*g_Height; i++) {
red = *src++;
grn = *src++;
blu = *src++;
*dst++ = blu;
*dst++ = grn;
*dst++ = red;
}
}
else {
// Sender has changed the image size
// no way presently to deal with it so deinit
receiver.ReleaseReceiver();
bMemoryMode = false; // it will go to a static image from now on
bDisconnected = true; // and not try again
} // end image size check
} // received OK
free((void *)buffer);
} // endif buffer OK
NumFrames++;
return NOERROR;
}
else if(receiver.ReceiveTexture(SharedMemoryName, senderWidth, senderHeight)) {
//
// ======= RENDER THE SHARED TEXTURE INVERTED TO A LOCAL TEXTURE VIA FBO ==========
//
// The shared texture can be a different size to the local texture because this is
// rendering and not copying. The local texture is always the same size as the filter.
//
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_TRANSFORM_BIT);
glGetFloatv(GL_VIEWPORT, dim);
glViewport(0, 0, g_Width, g_Height); // size of the camera window
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity(); // reset the current matrix back to its default state
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
// Attach the local texture (desination) to the color buffer in our frame buffer
// and draw into it with the shared texture
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, g_fbo);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, g_fbo_texture, 0);
receiver.DrawSharedTexture();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glPopAttrib();
glViewport(dim[0], dim[1], dim[2], dim[3]);
glMatrixMode(GL_TEXTURE);
glPopMatrix();
// now read the local texture into the sample's data buffer because the sizes match
glBindTexture(GL_TEXTURE_2D, g_fbo_texture);
glEnable(GL_TEXTURE_2D);
glGetTexImage(GL_TEXTURE_2D, 0, GL_BGR, GL_UNSIGNED_BYTE, (void *)pData);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
// LJ DEBUG for flip test
// FlipVertical(pData, g_Width, g_Height);
NumFrames++;
return NOERROR;
} // endif received OK
else {
receiver.ReleaseReceiver();
bInitialized = false;
bDisconnected = true; // don't try again
} // endif received texture OK
} // endif texture mode
} // endif not disconnected
// drop through to default static image if it did not work
pms->GetPointer(&pData);
lDataLen = pms->GetSize();
for(l = 0; l <lDataLen; ++l)
pData[l] = rand();
NumFrames++;
return NOERROR;
} // FillBuffer
/** Detect which internal formats are allowed as RTT
Also detect what combinations of stencil and depth are allowed with this internal
format.
*/
void GLFBOManager::detectFBOFormats()
{
// Try all formats, and report which ones work as target
GLuint fb = 0, tid = 0;
GLint old_drawbuffer = 0, old_readbuffer = 0;
GLenum target = GL_TEXTURE_2D;
glGetIntegerv (GL_DRAW_BUFFER, &old_drawbuffer);
glGetIntegerv (GL_READ_BUFFER, &old_readbuffer);
for(size_t x=0; x<PF_COUNT; ++x)
{
mProps[x].valid = false;
// Fetch GL format token
GLenum fmt = GLPixelUtil::getGLInternalFormat((PixelFormat)x);
if(fmt == GL_NONE && x!=0)
continue;
// No test for compressed formats
if(PixelUtil::isCompressed((PixelFormat)x))
continue;
// Buggy ATI cards *crash* on non-RGB(A) formats
int depths[4];
PixelUtil::getBitDepths((PixelFormat)x, depths);
if(fmt!=GL_NONE && mATIMode && (!depths[0] || !depths[1] || !depths[2]))
continue;
// Create and attach framebuffer
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
if (fmt!=GL_NONE)
{
// Create and attach texture
glGenTextures(1, &tid);
glBindTexture(target, tid);
// Set some default parameters so it won't fail on NVidia cards
if (GLEW_VERSION_1_2)
glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, 0);
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(target, 0, fmt, PROBE_SIZE, PROBE_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
target, tid, 0);
}
else
{
// Draw to nowhere -- stencil/depth only
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
}
// Check status
GLuint status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
// Ignore status in case of fmt==GL_NONE, because no implementation will accept
// a buffer without *any* attachment. Buffers with only stencil and depth attachment
// might still be supported, so we must continue probing.
if(fmt == GL_NONE || status == GL_FRAMEBUFFER_COMPLETE_EXT)
{
mProps[x].valid = true;
StringUtil::StrStreamType str;
str << "FBO " << PixelUtil::getFormatName((PixelFormat)x)
<< " depth/stencil support: ";
// For each depth/stencil formats
for (size_t depth = 0; depth < DEPTHFORMAT_COUNT; ++depth)
{
if (depthFormats[depth] != GL_DEPTH24_STENCIL8_EXT)
{
// General depth/stencil combination
for (size_t stencil = 0; stencil < STENCILFORMAT_COUNT; ++stencil)
{
//StringUtil::StrStreamType l;
//l << "Trying " << PixelUtil::getFormatName((PixelFormat)x)
// << " D" << depthBits[depth]
// << "S" << stencilBits[stencil];
//LogManager::getSingleton().logMessage(l.str());
if (_tryFormat(depthFormats[depth], stencilFormats[stencil]))
{
/// Add mode to allowed modes
str << "D" << depthBits[depth] << "S" << stencilBits[stencil] << " ";
FormatProperties::Mode mode;
mode.depth = depth;
mode.stencil = stencil;
mProps[x].modes.push_back(mode);
}
}
}
else
{
// Packed depth/stencil format
// #if OGRE_PLATFORM == OGRE_PLATFORM_LINUX
// It now seems as if this workaround now *breaks* nvidia cards on Linux with the 169.12 drivers on Linux
#if 0
// Only query packed depth/stencil formats for 32-bit
// non-floating point formats (ie not R32!)
// Linux nVidia driver segfaults if you query others
if (PixelUtil::getNumElemBits((PixelFormat)x) != 32 ||
PixelUtil::isFloatingPoint((PixelFormat)x))
{
continue;
}
#endif
if (_tryPackedFormat(depthFormats[depth]))
{
/// Add mode to allowed modes
str << "Packed-D" << depthBits[depth] << "S" << 8 << " ";
FormatProperties::Mode mode;
mode.depth = depth;
mode.stencil = 0; // unuse
mProps[x].modes.push_back(mode);
}
}
}
LogManager::getSingleton().logMessage(str.str());
}
// Delete texture and framebuffer
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glDeleteFramebuffersEXT(1, &fb);
// Workaround for NVIDIA / Linux 169.21 driver problem
// see http://www.ogre3d.org/phpBB2/viewtopic.php?t=38037&start=25
glFinish();
if (fmt!=GL_NONE)
glDeleteTextures(1, &tid);
}
// It seems a bug in nVidia driver: glBindFramebufferEXT should restore
// draw and read buffers, but in some unclear circumstances it won't.
glDrawBuffer(old_drawbuffer);
glReadBuffer(old_readbuffer);
String fmtstring = "";
for(size_t x=0; x<PF_COUNT; ++x)
{
if(mProps[x].valid)
fmtstring += PixelUtil::getFormatName((PixelFormat)x)+" ";
}
LogManager::getSingleton().logMessage("[GL] : Valid FBO targets " + fmtstring);
}
bool GutCreateRenderTargetOpenGL(int w, int h, GLuint *pFrameBuffer,
GLuint color_fmt, GLuint *pFrameTexture, int num_mrts,
GLuint depth_fmt, GLuint *pDepthTexture)
{
GLuint framebuffer = 0;
GLuint frametexture = 0;
GLuint depthtexture = 0;
glGenFramebuffersEXT(1, &framebuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer);
if ( pFrameTexture )
{
for ( int i=0; i<num_mrts; i++ )
{
// 配罝貼圖空間
glGenTextures(1, &frametexture);
glBindTexture(GL_TEXTURE_2D, frametexture);
// 套用一個預設的filter
//glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// 設定filter
if ( color_fmt==GL_RGBA32F_ARB || color_fmt==GL_RGBA16F_ARB )
{
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
else
{
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
// 宣告貼圖大小及格式
glTexImage2D(GL_TEXTURE_2D, 0, color_fmt, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
// framebuffer的RGBA貼圖
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+i, GL_TEXTURE_2D, frametexture, 0);
pFrameTexture[i] = frametexture;
}
}
else
{
glDrawBuffer(FALSE);
glReadBuffer(FALSE);
}
if ( pDepthTexture )
{
// 配罝貼圖空間
glGenTextures(1, &depthtexture);
glBindTexture(GL_TEXTURE_2D, depthtexture);
// 套用一個預設的filter
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// 宣告貼圖大小及格式
glTexImage2D(GL_TEXTURE_2D, 0, depth_fmt, w, h, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
// framebuffer的ZBuffer部份
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depthtexture, 0);
*pDepthTexture = depthtexture;
}
/*
檢查framebuffer object有沒有配置成功
*/
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if ( status!=GL_FRAMEBUFFER_COMPLETE_EXT )
{
return false;
}
*pFrameBuffer = framebuffer;
return true;
}
/* Render::initializeShadowMap: initialize OpenGL for shadow mapping */
void Render::initializeShadowMap(int textureSize)
{
static const GLdouble genfunc[][4] = {
{ 1.0, 0.0, 0.0, 0.0 },
{ 0.0, 1.0, 0.0, 0.0 },
{ 0.0, 0.0, 1.0, 0.0 },
{ 0.0, 0.0, 0.0, 1.0 },
};
/* initialize model view matrix */
glPushMatrix();
glLoadIdentity();
/* use 4th texture unit for depth texture, make it current */
glActiveTextureARB(GL_TEXTURE3_ARB);
/* prepare a texture object for depth texture rendering in frame buffer object */
glGenTextures(1, &m_depthTextureID);
glBindTexture(GL_TEXTURE_2D, m_depthTextureID);
/* assign depth component to the texture */
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, textureSize, textureSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
/* set texture parameters for shadow mapping */
#ifdef RENDER_SHADOWPCF
/* use hardware PCF */
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#else
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
#endif /* RENDER_SHADOWPCF */
/* tell OpenGL to compare the R texture coordinates to the (depth) texture value */
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
/* also tell OpenGL to get the compasiron result as alpha value */
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_ALPHA);
/* set texture coordinates generation mode to use the raw texture coordinates (S, T, R, Q) in eye view */
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGendv(GL_S, GL_EYE_PLANE, genfunc[0]);
glTexGendv(GL_T, GL_EYE_PLANE, genfunc[1]);
glTexGendv(GL_R, GL_EYE_PLANE, genfunc[2]);
glTexGendv(GL_Q, GL_EYE_PLANE, genfunc[3]);
/* finished configuration of depth texture: unbind the texture */
glBindTexture(GL_TEXTURE_2D, 0);
/* allocate a frame buffer object (FBO) for depth buffer rendering */
glGenFramebuffersEXT(1, &m_fboID);
/* switch to the newly allocated FBO */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fboID);
/* bind the texture to the FBO, telling that it should render the depth information to the texture */
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, m_depthTextureID, 0);
/* also tell OpenGL not to draw and read the color buffers */
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
/* check FBO status */
if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) {
/* cannot use FBO */
}
/* finished configuration of FBO, now switch to default frame buffer */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
/* reset the current texture unit to default */
glActiveTextureARB(GL_TEXTURE0_ARB);
/* restore the model view matrix */
glPopMatrix();
}
void cgtk::init()
{
cout << "glew init " << endl;
GLenum err = glewInit();
// initialize all the OpenGL extensions
glewGetExtension("glMultiTexCoord2fvARB");
if(glewGetExtension("GL_EXT_framebuffer_object") )cout << "GL_EXT_framebuffer_object support " << endl;
if(glewGetExtension("GL_EXT_renderbuffer_object"))cout << "GL_EXT_renderbuffer_object support " << endl;
if(glewGetExtension("GL_ARB_vertex_buffer_object")) cout << "GL_ARB_vertex_buffer_object support" << endl;
if(GL_ARB_multitexture)cout << "GL_ARB_multitexture support " << endl;
if (glewGetExtension("GL_ARB_fragment_shader") != GL_TRUE ||
glewGetExtension("GL_ARB_vertex_shader") != GL_TRUE ||
glewGetExtension("GL_ARB_shader_objects") != GL_TRUE ||
glewGetExtension("GL_ARB_shading_language_100") != GL_TRUE)
{
cout << "Driver does not support OpenGL Shading Language" << endl;
exit(1);
}
//glEnable(GL_CULL_FACE);
glClearColor(0.0, 0.0, 0.0, 0);
create_volumetexture();
//load_volumetexture_k("data\\output31_int.bin");
//load_volumetexture_step("data\\step_by_step2.bin");
// CG init
//cgSetErrorCallback(cgErrorCallback);
context = cgCreateContext();
if (cgGLIsProfileSupported(CG_PROFILE_VP40))
{
vertexProfile = CG_PROFILE_VP40;
cout << "CG_PROFILE_VP40 supported." << endl;
}
else
{
if (cgGLIsProfileSupported(CG_PROFILE_ARBVP1))
vertexProfile = CG_PROFILE_ARBVP1;
else
{
cout << "Neither arbvp1 or vp40 vertex profiles supported on this system." << endl;
exit(1);
}
}
if (cgGLIsProfileSupported(CG_PROFILE_FP40))
{
fragmentProfile = CG_PROFILE_FP40;
cout << "CG_PROFILE_FP40 supported." << endl;
}
else
{
if (cgGLIsProfileSupported(CG_PROFILE_ARBFP1))
fragmentProfile = CG_PROFILE_ARBFP1;
else
{
cout << "Neither arbfp1 or fp40 fragment profiles supported on this system." << endl;
exit(1);
}
}
// load the vertex and fragment raycasting programs
load_vertex_program(vertex_main,"raycasting_shader.cg","vertex_main");
cgErrorCallback();
load_fragment_program(fragment_main,"raycasting_shader.cg","fragment_main");
cgErrorCallback();
// Create the to FBO's one for the backside of the volumecube and one for the finalimage rendering
glGenFramebuffersEXT(1, &framebuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,framebuffer);
glGenTextures(1, &backface_buffer);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, backface_buffer);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,GL_RGBA16F_ARB, WINDOW_SIZE_W, WINDOW_SIZE_H, 0, GL_RGBA, GL_FLOAT, NULL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, backface_buffer, 0);
glGenTextures(1, &final_image);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, final_image);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,GL_RGBA16F_ARB, WINDOW_SIZE_W, WINDOW_SIZE_H, 0, GL_RGBA, GL_FLOAT, NULL);
glGenRenderbuffersEXT(1, &renderbuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, WINDOW_SIZE_W, WINDOW_SIZE_H);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, renderbuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
RenderTarget::RenderTarget(const glm::ivec2& size, GLenum format, int flags, GLenum filter) throw()
: TextureBase()
, id(0)
, front(0)
, back(0)
, max(1) {
checkForGLErrors("RenderTarget() pre");
this->size = size;
/* init_vbo is a no-op if it already is initialized */
init_vbo();
/* generate projection matrix for this target */
projection = glm::ortho(0.0f, (float)size.x, 0.0f, (float)size.y, -1.0f, 1.0f);
projection = glm::scale(projection, glm::vec3(1.0f, -1.0f, 1.0f));
projection = glm::translate(projection, glm::vec3(0.0f, -(float)size.y, 0.0f));
glGenFramebuffers(1, &id);
glGenTextures(2, color);
glGenTextures(1, &depth);
glBindFramebuffer(GL_FRAMEBUFFER, id);
Engine::setup_opengl();
/* bind color buffers */
for ( int i = 0; i < 2; i++ ){
glBindTexture(GL_TEXTURE_2D, color[i]);
glTexImage2D(GL_TEXTURE_2D, 0, format, size.x, size.y, 0, format == GL_RGB8 ? GL_RGB : GL_RGBA, GL_UNSIGNED_INT, NULL);
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_MAG_FILTER, filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
}
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color[front], 0);
checkForGLErrors("glFramebufferTexture2D::color");
/* bind depth buffer */
if ( flags & DEPTH_BUFFER ){
glBindTexture(GL_TEXTURE_2D, depth);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, size.x, size.y, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
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_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE );
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth, 0);
checkForGLErrors("glFramebufferTexture2D::depth");
}
/* enable doublebuffering */
if ( flags & DOUBLE_BUFFER ){
max = 2;
}
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(status != GL_FRAMEBUFFER_COMPLETE){
switch( status ) {
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
fprintf(stderr, "Framebuffer object format is unsupported by the video hardware. (GL_FRAMEBUFFER_UNSUPPORTED_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
fprintf(stderr, "Framebuffer incomplete attachment. (GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
fprintf(stderr, "Framebuffer incomplete missing attachment. (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
fprintf(stderr, "Framebuffer incomplete dimensions. (GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
fprintf(stderr, "Framebuffer incomplete formats. (GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
fprintf(stderr, "Framebuffer incomplete draw buffer. (GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
fprintf(stderr, "Framebuffer incomplete read buffer. (GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT:
fprintf(stderr, "Framebuffer incomplete multisample buffer. (GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT)\n");
break;
default:
fprintf(stderr, "Framebuffer incomplete: %s\n", gluErrorString(status));
}
util_abort();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
checkForGLErrors("RenderTarget() fin");
with([this](){
RenderTarget::clear(Color::black);
} );
}
void SSEffect::smoothDepth( RTPSSettings* settings)
{
GLuint smoothingProgram;
switch(settings->GetSettingAs<int>("filter_type","0"))
{
case NO_SMOOTHING:
return;
case SEPERABLE_GAUSSIAN_BLUR:
smoothingProgram= m_shaderLibrary->shaders["gaussianBlurXShader"].getProgram();
glUseProgram(smoothingProgram);
glUniform1i( glGetUniformLocation(smoothingProgram, "depthTex"),0);
glUniform1f( glGetUniformLocation(smoothingProgram, "del_x"),1.0f/(float)width);
glUniform1f( glGetUniformLocation(smoothingProgram, "falloff"),settings->GetSettingAs<float>("blur_falloff","1.0"));
glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0"));
RenderUtils::fullscreenQuad();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
smoothingProgram= m_shaderLibrary->shaders["gaussianBlurYShader"].getProgram();
glUseProgram(smoothingProgram);
glUniform1i( glGetUniformLocation(smoothingProgram, "depthTex"),0);
glUniform1f( glGetUniformLocation(smoothingProgram, "del_y"),1.0f/(float)height);
glUniform1f( glGetUniformLocation(smoothingProgram, "falloff"),settings->GetSettingAs<float>("blur_falloff","1.0"));
glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0"));
currentDepthBuffer="depth2";
break;
case GAUSSIAN_BLUR:
smoothingProgram= m_shaderLibrary->shaders["gaussianBlurShader"].getProgram();
glUseProgram(smoothingProgram);
glUniform1i(glGetUniformLocation(smoothingProgram,"depthTex"),0);
glUniform1f( glGetUniformLocation(smoothingProgram, "del_x"),1.0/((float)width));
glUniform1f( glGetUniformLocation(smoothingProgram, "del_y"),1.0/((float)height));
glUniform1f( glGetUniformLocation(smoothingProgram, "falloff"),settings->GetSettingAs<float>("blur_falloff","1.0"));
glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0"));
currentDepthBuffer="depth";
break;
case BILATERAL_GAUSSIAN_BLUR:
{
smoothingProgram= m_shaderLibrary->shaders["bilateralGaussianBlurShader"].getProgram();
float xdir[] = {1.0f/height,0.0f};
float ydir[] = {0.0f,1.0f/width};
glUseProgram(smoothingProgram);
glUniform1i( glGetUniformLocation(smoothingProgram, "depthTex"),0);
glUniform2fv( glGetUniformLocation(smoothingProgram, "blurDir"),1,xdir);
glUniform1f( glGetUniformLocation(smoothingProgram, "sig_range"),settings->GetSettingAs<float>("bilateral_range","0.01"));
glUniform1f( glGetUniformLocation(smoothingProgram, "sig"),settings->GetSettingAs<float>("blur_radius","8.0"));
RenderUtils::fullscreenQuad();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0);
//glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glUniform2fv( glGetUniformLocation(smoothingProgram, "blurDir"),1,ydir);
//glUniform1f( glGetUniformLocation(smoothingProgram, "sig_range"),bilateralRange);
//glUniform1f( glGetUniformLocation(glsl_program[BILATERAL_GAUSSIAN_SHADER], "sig"),filterRadius);
currentDepthBuffer="depth2";
break;
}
case CURVATURE_FLOW:
{
//int numberIterations=settings->GetSettingAs<int>("curvature_flow_iterations","20");
smoothingProgram= m_shaderLibrary->shaders["curvatureFlowShader"].getProgram();
glUseProgram(smoothingProgram);
int numberIterations=settings->GetSettingAs<int>("curvature_flow_iterations","1");
glUniform1i(glGetUniformLocation(smoothingProgram,"depthTex"),0);
//glUniform1f(glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER],"width"),(float)window_width);
//glUniform1f(glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER],"height"),(float)window_height);
glUniform1f( glGetUniformLocation(smoothingProgram, "del_x"),1.0/((float)width));
glUniform1f( glGetUniformLocation(smoothingProgram, "del_y"),1.0/((float)height));
//glUniform1f( glGetUniformLocation(smoothingProgram, "h_x"),1.0/((float)width-1));
//glUniform1f( glGetUniformLocation(smoothingProgram, "h_y"),1.0/((float)height-1));
//glUniform1f( glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER], "focal_x"),focal_x);
//glUniform1f( glGetUniformLocation(glsl_program[CURVATURE_FLOW_SHADER], "focal_y"),focal_y);
//glUniform1f( glGetUniformLocation(smoothingProgram, "dt"),1.0f/numberIterations);
glUniform1f( glGetUniformLocation(smoothingProgram, "dt"),settings->GetSettingAs<float>("curvature_flow_dt","0.005"));
//glUniform1f( glGetUniformLocation(smoothingProgram, "distance_threshold"), falloff);
string curReadBuffer;
for(unsigned int i = 0; i<numberIterations; i++)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
RenderUtils::fullscreenQuad();
if(i%2==0)
{
curReadBuffer = "depth2";
currentDepthBuffer="depth";
}
else
{
curReadBuffer = "depth";
currentDepthBuffer="depth2";
}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[curReadBuffer]);
//glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0);
}
//currentDepthBuffer=curReadBuffer;
glUseProgram(0);
return;
}
default:
break;
}
RenderUtils::fullscreenQuad();
glUseProgram(0);
}
void SSEffect::render(GLuint posVBO, GLuint colVBO, unsigned int num, RTPSSettings* settings, const Light* light,const Material* material, float scale, GLuint sceneTex, GLuint sceneDepthTex, GLuint framebuffer)
{
if(num==0)
return;
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
currentDepthBuffer="depth";
bool blending = settings->GetSettingAs<bool>("blending","1");
//QT send 2 for check boxes when enable(due to the possiblity of adding a tristate option.
//Apparently the default string-to-bool conversion is true for 1 and false otherwise
//I need it to be false for 0 and true otherwise.
//bool thickness = !settings->GetSettingAs<int>("thickness","1");
bool thickness = settings->GetSettingAs<bool>("thickness","1");
//perserve original buffer
GLint buffer;
glGetIntegerv(GL_DRAW_BUFFER,&buffer);
glClearColor(0.0f,0.0f,0.0f,0.0f);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,m_fbos[0]);
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glActiveTexture(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
//Should probably conditionally create the thickness buffer as well.
//Render Thickness buffer.
if(thickness)
{
m_timers["render_thickness"]->start();
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
//give the fluid some thickness everywhere
glClearColor(0.1f,0.1f,0.1f,1.0f);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"],0);
//glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClear(GL_COLOR_BUFFER_BIT);
renderPointsAsSpheres( m_shaderLibrary->shaders["sphereThicknessShader"].getProgram(),posVBO, colVBO, num,settings, light,material,scale);
//renderPointsAsSpheres( m_shaderLibrary->shaders["sphereShader"].getProgram(),posVBO, colVBO, num,settings, light,material,scale);
glFinish();
m_timers["render_thickness"]->stop();
m_timers["blur_thickness"]->start();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness2"],0);
GLuint program= m_shaderLibrary->shaders["fixedWidthGaussianShader"].getProgram();
glEnable(GL_TEXTURE_2D);
float xdir[] = {1.0f/height,0.0f};
float ydir[] = {0.0f,1.0f/width};
glUseProgram(program);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]);
glUniform1i( glGetUniformLocation(program, "imgTex"),0);
glUniform2fv( glGetUniformLocation(program, "dTex"),1,xdir);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
RenderUtils::fullscreenQuad();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness2"]);
glUniform2fv( glGetUniformLocation(program, "dTex"),1,ydir);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
RenderUtils::fullscreenQuad();
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDisable(GL_TEXTURE_2D);
glFinish();
m_timers["blur_thickness"]->stop();
}
//glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,framebuffer);
m_timers["render_spheres"]->start();
//Render Color and depth buffer of spheres.
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0);
glEnable(GL_TEXTURE_2D);
GLuint sphereProgram = m_shaderLibrary->shaders["sphereShader"].getProgram();
glBindTexture(GL_TEXTURE_2D,sceneDepthTex);
glUseProgram(sphereProgram);
glUniform1i(glGetUniformLocation(sphereProgram,"sceneDepth"),0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
renderPointsAsSpheres(sphereProgram,posVBO, colVBO, num,settings, light,material,scale);
glFinish();
m_timers["render_spheres"]->stop();
//Smooth the depth texture to emulate a surface.
m_timers["smooth_depth"]->start();
//glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth2"],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth"]);
currentDepthBuffer="depth2";
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
smoothDepth(settings);
glFinish();
m_timers["smooth_depth"]->stop();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0);
//Switch to the buffer that was written to in the smoothing step
if(currentDepthBuffer=="depth2")
currentDepthBuffer="depth";
else
currentDepthBuffer="depth2";
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
//if (blending)
//{
//glDepthMask(GL_FALSE);
// glEnable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"],0);
m_timers["calculate_normals"]->start();
//Now we use the depth to normal shader which converts screenspace depth into
//world coordinates and then computes lighting.
glClear(GL_COLOR_BUFFER_BIT);
GLuint normalProgram = m_shaderLibrary->shaders["depth2NormalShader"].getProgram();
glUseProgram(normalProgram);
glUniform1i( glGetUniformLocation(normalProgram, "depthTex"),0);
glUniform1f( glGetUniformLocation(normalProgram, "del_x"),1.0/((float)width));
glUniform1f( glGetUniformLocation(normalProgram, "del_y"),1.0/((float)height));
RenderUtils::fullscreenQuad();
glFinish();
m_timers["calculate_normals"]->stop();
m_timers["render_composite"]->start();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0);
GLuint compositeProgram = m_shaderLibrary->shaders["compositeFluidShader"].getProgram();
glUseProgram(compositeProgram);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D,sceneTex);
glUniform1i( glGetUniformLocation(compositeProgram, "depthTex"),0);
glUniform1i( glGetUniformLocation(compositeProgram, "normalTex"),1);
glUniform1i( glGetUniformLocation(compositeProgram, "thicknessTex"),2);
glUniform1i( glGetUniformLocation(compositeProgram, "sceneTex"),3);
glUniform1f( glGetUniformLocation(compositeProgram, "gamma"),settings->GetSettingAs<float>("thickness_gamma","0.1"));
//dout<<"Here"<<endl;
if(material)
{
glUniform3fv(glGetUniformLocation(compositeProgram,"material.diffuse"),1,&material->diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.specular"),1,&material->specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.ambient"),1,&material->ambient.x);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.shininess"),1,&material->shininess);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.opacity"),1,&material->opacity);
}
else
{
Material defaultMat;
defaultMat.ambient=float3(0.05f,0.075f,0.25f);
defaultMat.diffuse=float3(0.05f,0.075f,0.25f);
defaultMat.specular=float3(1.0f,1.f,1.0f);
defaultMat.opacity=0.5;
defaultMat.shininess=100;
glUniform3fv(glGetUniformLocation(compositeProgram,"material.diffuse"),1,&defaultMat.diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.specular"),1,&defaultMat.specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.ambient"),1,&defaultMat.ambient.x);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.shininess"),1,&defaultMat.shininess);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.opacity"),1,&defaultMat.opacity);
}
if(light)
{
glUniform3fv(glGetUniformLocation(compositeProgram,"light.diffuse"),1,&light->diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.specular"),1,&light->specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.ambient"),1,&light->ambient.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.position"),1,&light->pos.x);
}
else
{
Light defaultLight;
defaultLight.ambient = float3(0.2f,0.2f,0.2f);
defaultLight.diffuse = float3(1.0f,1.0f,1.0f);
defaultLight.specular = float3(1.0f,1.0f,1.0f);
defaultLight.pos = float3(5.0f,10.0f,-5.0f);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.diffuse"),1,&defaultLight.diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.specular"),1,&defaultLight.specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.ambient"),1,&defaultLight.ambient.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.position"),1,&defaultLight.pos.x);
}
RenderUtils::fullscreenQuad();
glFinish();
m_timers["render_composite"]->stop();
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D,0);
//glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,framebuffer);
m_timers["copy_to_fbo"]->start();
glDrawBuffer(buffer);
glActiveTexture(GL_TEXTURE0);
GLuint copyProgram = m_shaderLibrary->shaders["copyShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "colorTex"),0);
if(settings->GetSettingAs<bool>("render_composite","1"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["Color"]);
}
else if(settings->GetSettingAs<bool>("render_normal","0"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"]);
copyProgram = m_shaderLibrary->shaders["copyInverseShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "colorTex"),0);
}
else if(settings->GetSettingAs<bool>("render_depth","0"))
{
if(currentDepthBuffer=="depth2")
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth"]);
else
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]);
copyProgram = m_shaderLibrary->shaders["copyDepthColorShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0);
}
else if(settings->GetSettingAs<bool>("render_depth_smoothed","0"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
copyProgram = m_shaderLibrary->shaders["copyDepthColorShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0);
}
else if(settings->GetSettingAs<bool>("render_thickness","0"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]);
copyProgram = m_shaderLibrary->shaders["copyScalarShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0);
}
else
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["Color"]);
}
//need to copy the contents to the back buffer. It's important that we copy the
//depth as well. Otherwise anything drawn afterwards may incorrecly occlude the fluid.
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
glUseProgram(copyProgram);
glUniform1i( glGetUniformLocation(copyProgram, "depthTex"),1);
RenderUtils::fullscreenQuad();
glFinish();
m_timers["copy_to_fbo"]->stop();
glUseProgram(0);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,0);
//if (blending)
//{
//glDisable(GL_BLEND);
//}
glPopAttrib();
glPopClientAttrib();
if (m_writeFramebuffers)
{
glFinish();
writeFramebufferTextures();
m_writeFramebuffers = false;
}
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
GLuint tex, fb;
GLenum status;
float fbo_white[] = {0.0, 0.0, 0.0, 1.0};
float fbo_black[] = {0.0, 0.0, 0.0, 0.0};
float fbo_gray[] = {0.0, 0.0, 0.0, 0.5};
float white[] = {1.0, 1.0, 1.0, 1.0};
float black[] = {0.0, 0.0, 0.0, 0.0};
float gray[] = {0.5, 0.5, 0.5, 0.5};
int fbo_width = 64;
int fbo_height = 64;
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glViewport(0, 0, fbo_width, fbo_height);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
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, GL_ALPHA,
fbo_width, fbo_height, 0,
GL_ALPHA, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "fbo incomplete (status = 0x%04x)\n", status);
piglit_report_result(PIGLIT_SKIP);
}
/* Clear to no alpha. */
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor4f(0.0, 0.0, 0.0, 0.0);
piglit_draw_rect(-1.0, -1.0, 0.5, 2.0);
glColor4f(0.0, 0.0, 0.0, 1.0);
piglit_draw_rect(-0.5, -1.0, 0.5, 2.0);
glColor4f(0.0, 0.0, 0.0, 0.5);
piglit_draw_rect(0.0, -1.0, 0.5, 2.0);
glEnable(GL_BLEND);
glBlendFunc(GL_DST_ALPHA, GL_ZERO);
glColor4f(0.0, 0.0, 0.0, 1.0);
piglit_draw_rect(0.0, -1.0, 0.5, 2.0);
glDisable(GL_BLEND);
glColor4f(0.0, 0.0, 0.0, 0.5);
piglit_draw_rect(0.5, -1.0, 0.5, 2.0);
glEnable(GL_BLEND);
glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
glColor4f(0.0, 0.0, 0.0, 1.0);
piglit_draw_rect(0.5, -1.0, 0.5, 2.0);
glDisable(GL_BLEND);
printf("Testing FBO result.\n");
pass = piglit_probe_pixel_rgba(fbo_width * 1 / 8, 0, fbo_black) && pass;
pass = piglit_probe_pixel_rgba(fbo_width * 3 / 8, 0, fbo_white) && pass;
pass = piglit_probe_pixel_rgba(fbo_width * 5 / 8, 0, fbo_gray) && pass;
pass = piglit_probe_pixel_rgba(fbo_width * 7 / 8, 0, fbo_gray) && pass;
/* Draw the two textures to halves of the window. */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glViewport(0, 0, piglit_width, piglit_height);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_ALPHA);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glBindTexture(GL_TEXTURE_2D, tex);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &tex);
glDeleteFramebuffersEXT(1, &fb);
printf("Testing window result.\n");
pass = piglit_probe_pixel_rgba(piglit_width * 1 / 8, 0, black) && pass;
pass = piglit_probe_pixel_rgba(piglit_width * 3 / 8, 0, white) && pass;
pass = piglit_probe_pixel_rgba(piglit_width * 5 / 8, 0, gray) && pass;
pass = piglit_probe_pixel_rgba(piglit_width * 7 / 8, 0, gray) && pass;
glutSwapBuffers();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void WebGraphicsContext3DDefaultImpl::reshape(int width, int height)
{
#ifdef RENDER_TO_DEBUGGING_WINDOW
SetWindowPos(m_canvasWindow, HWND_TOP, 0, 0, width, height,
SWP_NOMOVE);
ShowWindow(m_canvasWindow, SW_SHOW);
#endif
m_cachedWidth = width;
m_cachedHeight = height;
makeContextCurrent();
#ifndef RENDER_TO_DEBUGGING_WINDOW
#ifdef USE_TEXTURE_RECTANGLE_FOR_FRAMEBUFFER
// GL_TEXTURE_RECTANGLE_ARB is the best supported render target on Mac OS X
GLenum target = GL_TEXTURE_RECTANGLE_ARB;
#else
GLenum target = GL_TEXTURE_2D;
#endif
if (!m_texture) {
// Generate the texture object
m_texture = createTextureObject(target);
// Generate the framebuffer object
glGenFramebuffersEXT(1, &m_fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
m_boundFBO = m_fbo;
if (m_attributes.depth || m_attributes.stencil)
glGenRenderbuffersEXT(1, &m_depthStencilBuffer);
// Generate the multisample framebuffer object
if (m_attributes.antialias) {
glGenFramebuffersEXT(1, &m_multisampleFBO);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
m_boundFBO = m_multisampleFBO;
glGenRenderbuffersEXT(1, &m_multisampleColorBuffer);
if (m_attributes.depth || m_attributes.stencil)
glGenRenderbuffersEXT(1, &m_multisampleDepthStencilBuffer);
}
}
GLint internalColorFormat, colorFormat, internalDepthStencilFormat = 0;
if (m_attributes.alpha) {
internalColorFormat = GL_RGBA8;
colorFormat = GL_RGBA;
} else {
internalColorFormat = GL_RGB8;
colorFormat = GL_RGB;
}
if (m_attributes.stencil || m_attributes.depth) {
// We don't allow the logic where stencil is required and depth is not.
// See GraphicsContext3DInternal constructor.
if (m_attributes.stencil && m_attributes.depth)
internalDepthStencilFormat = GL_DEPTH24_STENCIL8_EXT;
else
internalDepthStencilFormat = GL_DEPTH_COMPONENT;
}
bool mustRestoreFBO = false;
// Resize multisampling FBO
if (m_attributes.antialias) {
GLint maxSampleCount;
glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSampleCount);
GLint sampleCount = std::min(8, maxSampleCount);
if (m_boundFBO != m_multisampleFBO) {
mustRestoreFBO = true;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
}
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalColorFormat, width, height);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
if (m_attributes.stencil || m_attributes.depth) {
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalDepthStencilFormat, width, height);
if (m_attributes.stencil)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
if (m_attributes.depth)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
}
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("GraphicsContext3D: multisampling framebuffer was incomplete\n");
// FIXME: cleanup.
notImplemented();
}
}
// Resize regular FBO
if (m_boundFBO != m_fbo) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
mustRestoreFBO = true;
}
glBindTexture(target, m_texture);
glTexImage2D(target, 0, internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, m_texture, 0);
glBindTexture(target, 0);
if (!m_attributes.antialias && (m_attributes.stencil || m_attributes.depth)) {
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internalDepthStencilFormat, width, height);
if (m_attributes.stencil)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
if (m_attributes.depth)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("WebGraphicsContext3DDefaultImpl: framebuffer was incomplete\n");
// FIXME: cleanup.
notImplemented();
}
if (mustRestoreFBO)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
#endif // RENDER_TO_DEBUGGING_WINDOW
#ifdef FLIP_FRAMEBUFFER_VERTICALLY
if (m_scanline) {
delete[] m_scanline;
m_scanline = 0;
}
m_scanline = new unsigned char[width * 4];
#endif // FLIP_FRAMEBUFFER_VERTICALLY
GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
if (m_attributes.stencil)
clearMask |= GL_STENCIL_BUFFER_BIT;
if (m_attributes.depth)
clearMask |= GL_DEPTH_BUFFER_BIT;
glClear(clearMask);
}
/* Do piglit_rgbw_texture() image but using glClear */
static bool
do_rgba_clear(GLenum format, GLuint tex, int level, int size)
{
float red[4] = {1.0, 0.0, 0.0, 0.0};
float green[4] = {0.0, 1.0, 0.0, 0.25};
float blue[4] = {0.0, 0.0, 1.0, 0.5};
float white[4] = {1.0, 1.0, 1.0, 1.0};
float black[4] = {0.0, 0.0, 0.0, 0.0};
float *color;
GLuint fb;
GLenum status;
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
level);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
return false;
}
/* Handle the small sizes of compressed mipmap blocks */
switch (format) {
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
case GL_COMPRESSED_RGB_FXT1_3DFX:
case GL_COMPRESSED_RGBA_FXT1_3DFX:
if (size == 4)
color = red;
else if (size == 2)
color = green;
else if (size == 1)
color = blue;
else {
assert(0);
color = black;
}
glClearColor(color[0], color[1], color[2], color[3]);
glClear(GL_COLOR_BUFFER_BIT);
return true;
}
glEnable(GL_SCISSOR_TEST);
glScissor(0, 0, size / 2, size / 2);
glClearColor(red[0], red[1], red[2], red[3]);
glClear(GL_COLOR_BUFFER_BIT);
glScissor(size / 2, 0, size / 2, size / 2);
glClearColor(green[0], green[1], green[2], green[3]);
glClear(GL_COLOR_BUFFER_BIT);
glScissor(0, size / 2, size / 2, size / 2);
glClearColor(blue[0], blue[1], blue[2], blue[3]);
glClear(GL_COLOR_BUFFER_BIT);
glScissor(size / 2, size / 2, size / 2, size / 2);
glClearColor(white[0], white[1], white[2], white[3]);
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glDeleteFramebuffersEXT(1, &fb);
return true;
}
void piglit_init(int argc, char **argv)
{
GLuint tex, fb;
GLenum status;
int i, j, dim;
piglit_require_GLSL();
piglit_require_extension("GL_EXT_framebuffer_object");
piglit_require_extension("GL_ARB_shader_texture_lod");
prog_tex = piglit_build_simple_program(NULL, sh_tex);
prog_texgrad = piglit_build_simple_program(NULL, sh_texgrad);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
for (j = GL_TEXTURE_CUBE_MAP_POSITIVE_X; j <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; j++) {
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glTexImage2D(j, i, GL_RGBA,
dim, dim,
0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
}
assert(glGetError() == 0);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
glDisable(GL_TEXTURE_CUBE_MAP);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
for (j = GL_TEXTURE_CUBE_MAP_POSITIVE_X; j <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; j++) {
for (i = 0, dim = TEX_WIDTH; dim >0; i++, dim /= 2) {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
j,
tex,
i);
status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO incomplete\n");
piglit_report_result(PIGLIT_SKIP);
}
glClearColor(colors[i][0],
colors[i][1],
colors[i][2],
0.0);
glClear(GL_COLOR_BUFFER_BIT);
assert(glGetError() == 0);
}
}
glDeleteFramebuffersEXT(1, &fb);
glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-0.1, 0.1, -0.1, 0.1, 0.1, 1000.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(-0.5, -0.5, -1.2);
glRotatef(68, 0, 1, 0);
glScalef(2000, 1, 1);
glEnable(GL_TEXTURE_CUBE_MAP);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
piglit_set_tolerance_for_bits(7, 7, 7, 7);
printf("Left: textureCube, Right: textureCubeGradARB\n");
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
GLuint tex, fb;
GLenum status;
float fbo_simple1[] = {0.3, 0.0, 0.0, 0.0};
float fbo_simple2[] = {0.6, 0.0, 0.0, 1.0};
float fbo_blend1[] = {0.4, 0.0, 0.0, 0.5};
float fbo_blend2[] = {0.56, 0.0, 0.0, 0.4};
float win_simple1[] = {0.3, 0.3, 0.3, 0.0};
float win_simple2[] = {0.6, 0.6, 0.6, 1.0};
float win_blend1[] = {0.4, 0.4, 0.4, 0.5};
float win_blend2[] = {0.56, 0.56, 0.56, 0.4};
int fbo_width = 64;
int fbo_height = 64;
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glViewport(0, 0, fbo_width, fbo_height);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
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, GL_LUMINANCE8_ALPHA8,
fbo_width, fbo_height, 0,
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
assert(glGetError() == 0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "fbo incomplete (status = 0x%04x)\n", status);
piglit_report_result(PIGLIT_SKIP);
}
/* Clear to no alpha. */
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
/* Draw with two different colors, simple shading. */
glColor4fv(fbo_simple1);
piglit_draw_rect(-1.0, -1.0, 0.5, 2.0);
glColor4fv(fbo_simple2);
piglit_draw_rect(-0.5, -1.0, 0.5, 2.0);
/* Draw with blending, test DST_ALPHA. */
glColor4f(0.0, 0.0, 0.0, 0.5);
piglit_draw_rect(0.0, -1.0, 0.5, 2.0);
glEnable(GL_BLEND);
glBlendFunc(GL_DST_ALPHA, GL_ZERO);
glColor4f(0.8, 0.8, 0.8, 1.0);
piglit_draw_rect(0.0, -1.0, 0.5, 2.0);
glDisable(GL_BLEND);
/* Draw with blending, test SRC_ALPHA. */
glColor4f(0.7, 0.7, 0.7, 0.5);
piglit_draw_rect(0.5, -1.0, 0.5, 2.0);
glEnable(GL_BLEND);
glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
glColor4f(0.0, 0.0, 0.0, 0.8);
piglit_draw_rect(0.5, -1.0, 0.5, 2.0);
glDisable(GL_BLEND);
printf("Testing FBO result, simple 1.\n");
pass = piglit_probe_pixel_rgba(fbo_width * 1 / 8, 0, fbo_simple1) && pass;
printf("Testing FBO result, simple 2.\n");
pass = piglit_probe_pixel_rgba(fbo_width * 3 / 8, 0, fbo_simple2) && pass;
printf("Testing FBO result, blending DST_ALPHA.\n");
pass = piglit_probe_pixel_rgba(fbo_width * 5 / 8, 0, fbo_blend1) && pass;
printf("Testing FBO result, blending SRC_ALPHA.\n");
pass = piglit_probe_pixel_rgba(fbo_width * 7 / 8, 0, fbo_blend2) && pass;
/* Draw the two textures to halves of the window. */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glViewport(0, 0, piglit_width, piglit_height);
glColor4f(1, 1, 1, 1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, tex);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &tex);
glDeleteFramebuffersEXT(1, &fb);
printf("Testing window result, simple 1.\n");
pass = piglit_probe_pixel_rgba(piglit_width * 1 / 8, 0, win_simple1) && pass;
printf("Testing window result, simple 2.\n");
pass = piglit_probe_pixel_rgba(piglit_width * 3 / 8, 0, win_simple2) && pass;
printf("Testing window result, blending DST_ALPHA.\n");
pass = piglit_probe_pixel_rgba(piglit_width * 5 / 8, 0, win_blend1) && pass;
printf("Testing window result, blending SRC_ALPHA.\n");
pass = piglit_probe_pixel_rgba(piglit_width * 7 / 8, 0, win_blend2) && pass;
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
int x, y;
GLuint tex, fb;
float blue[] = {1, 0, 0, 0};
float green[] = {0, 1, 0, 0};
bool draw_green;
float *draw_colors[] = {blue, green};
float w_screen = 2.0f * TEX_WIDTH / piglit_width;
float h_screen = 2.0f * TEX_HEIGHT / piglit_height;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
TEX_WIDTH, TEX_HEIGHT, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
tex,
0);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) ==
GL_FRAMEBUFFER_COMPLETE_EXT);
draw_green = true;
for (y = 0; y <= piglit_height - TEX_HEIGHT; y += TEX_HEIGHT) {
float y_screen = -1.0 + 2.0 * ((float)y / piglit_height);
for (x = 0; x <= piglit_width - TEX_WIDTH; x += TEX_WIDTH) {
float x_screen = -1.0 + 2.0 * ((float)x / piglit_width);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
glDisable(GL_TEXTURE_2D);
glColor4fv(draw_colors[draw_green]);
piglit_draw_rect(-1, -1, 2, 2);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_2D);
piglit_draw_rect_tex(x_screen, y_screen,
w_screen, h_screen,
0, 0,
1, 1);
draw_green = !draw_green;
}
/* Make it a checkerboard. */
draw_green = !draw_green;
}
glDeleteFramebuffersEXT(1, &fb);
glDeleteTextures(1, &tex);
draw_green = true;
for (y = 0; y <= piglit_height - TEX_HEIGHT; y += TEX_HEIGHT) {
for (x = 0; x <= piglit_width - TEX_WIDTH; x += TEX_WIDTH) {
float *expected = draw_colors[draw_green];
pass = pass && piglit_probe_rect_rgb(x, y,
TEX_WIDTH,
TEX_HEIGHT,
expected);
draw_green = !draw_green;
}
draw_green = !draw_green;
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void pattern_render(struct pattern * pattern, GLuint input_tex) {
GLenum e;
glLoadIdentity();
glViewport(0, 0, config.pattern.master_width, config.pattern.master_height);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pattern->fb);
pattern->intensity_integral = fmod(pattern->intensity_integral + pattern->intensity / config.ui.fps, MAX_INTEGRAL);
for (int i = pattern->n_shaders - 1; i >= 0; i--) {
glUseProgramObjectARB(pattern->shader[i]);
// Don't worry about this part.
for(int j = 0; j < pattern->n_shaders; j++) {
// Or, worry about it, but don't think about it.
glActiveTexture(GL_TEXTURE1 + j);
glBindTexture(GL_TEXTURE_2D, pattern->tex[(pattern->flip + j + (i < j)) % (pattern->n_shaders + 1)]);
}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
pattern->tex[(pattern->flip + i + 1) % (pattern->n_shaders + 1)], 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
GLint loc;
loc = glGetUniformLocationARB(pattern->shader[i], "iTime");
glUniform1fARB(loc, time_master.beat_frac + time_master.beat_index);
loc = glGetUniformLocationARB(pattern->shader[i], "iAudioHi");
glUniform1fARB(loc, audio_hi);
loc = glGetUniformLocationARB(pattern->shader[i], "iAudioMid");
glUniform1fARB(loc, audio_mid);
loc = glGetUniformLocationARB(pattern->shader[i], "iAudioLow");
glUniform1fARB(loc, audio_low);
loc = glGetUniformLocationARB(pattern->shader[i], "iAudioLevel");
glUniform1fARB(loc, audio_level);
loc = glGetUniformLocationARB(pattern->shader[i], "iResolution");
glUniform2fARB(loc, config.pattern.master_width, config.pattern.master_height);
loc = glGetUniformLocationARB(pattern->shader[i], "iIntensity");
glUniform1fARB(loc, pattern->intensity);
loc = glGetUniformLocationARB(pattern->shader[i], "iIntensityIntegral");
glUniform1fARB(loc, pattern->intensity_integral);
loc = glGetUniformLocationARB(pattern->shader[i], "iFPS");
glUniform1fARB(loc, config.ui.fps);
loc = glGetUniformLocationARB(pattern->shader[i], "iFrame");
glUniform1iARB(loc, 0);
loc = glGetUniformLocationARB(pattern->shader[i], "iChannel");
glUniform1ivARB(loc, pattern->n_shaders, pattern->uni_tex);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, input_tex);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glVertex2d(-1, -1);
glVertex2d(-1, 1);
glVertex2d(1, 1);
glVertex2d(1, -1);
glEnd();
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
}
pattern->flip = (pattern->flip + 1) % (pattern->n_shaders + 1);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
pattern->tex_output = pattern->tex[pattern->flip];
}
// ok let's start things up
void GPUVolRTV2::init(DrawEnv *pEnv)
{
create_volumetexture();
load_vertex_program (vertexprog, "raycasting_shader.vp.cg");
load_fragment_program(fragmentprog,"raycasting_shader.fp.cg");
shaderprog = glCreateProgram();
glAttachShader(shaderprog, vertexprog);
glAttachShader(shaderprog, fragmentprog);
glLinkProgram(shaderprog);
check_program_status(shaderprog);
stepsizeLoc = glGetUniformLocation(shaderprog, "stepsize");
mvLoc = glGetUniformLocation(shaderprog, "ModelView");
mpLoc = glGetUniformLocation(shaderprog, "Proj");
texLoc = glGetUniformLocation(shaderprog, "tex");
volumeTexLoc = glGetUniformLocation(shaderprog, "volume_tex");
// Create the to FBO's one for the backside of the volumecube and one for the finalimage rendering
glGenFramebuffersEXT(1, &framebuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,framebuffer);
glGenTextures(1, &backface_buffer);
glBindTexture(GL_TEXTURE_2D, backface_buffer);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
// glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA16F_ARB, WINDOW_SIZE, WINDOW_SIZE, 0, GL_RGBA, GL_FLOAT, NULL);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA16F_ARB,
pEnv->getPixelWidth(),
pEnv->getPixelHeight(),
0, GL_RGBA, GL_FLOAT, NULL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, backface_buffer, 0);
glGenTextures(1, &final_image);
glBindTexture(GL_TEXTURE_2D, final_image);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
// glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA16F_ARB, WINDOW_SIZE, WINDOW_SIZE, 0, GL_RGBA, GL_FLOAT, NULL);
glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA16F_ARB,
pEnv->getPixelWidth(),
pEnv->getPixelHeight(),
0, GL_RGBA, GL_FLOAT, NULL);
glGenRenderbuffersEXT(1, &renderbuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer);
// glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, WINDOW_SIZE, WINDOW_SIZE);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
pEnv->getPixelWidth(), pEnv->getPixelHeight());
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, renderbuffer);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
bInitialized = true;
}
int pattern_init(struct pattern * pattern, const char * prefix) {
GLenum e;
memset(pattern, 0, sizeof *pattern);
pattern->intensity = 0;
pattern->intensity_integral = 0;
pattern->name = strdup(prefix);
if(pattern->name == NULL) ERROR("Could not allocate memory");
int n = 0;
for(;;) {
char * filename;
struct stat statbuf;
filename = rsprintf("%s%s.%d.glsl", config.pattern.dir, prefix, n);
if(filename == NULL) MEMFAIL();
int rc = stat(filename, &statbuf);
free(filename);
if (rc != 0 || S_ISDIR(statbuf.st_mode)) {
break;
}
n++;
}
if(n == 0) {
ERROR("Could not find any shaders for %s", prefix);
return 1;
}
pattern->n_shaders = n;
pattern->shader = calloc(pattern->n_shaders, sizeof *pattern->shader);
if(pattern->shader == NULL) MEMFAIL();
pattern->tex = calloc(pattern->n_shaders, sizeof *pattern->tex);
if(pattern->tex == NULL) MEMFAIL();
bool success = true;
for(int i = 0; i < pattern->n_shaders; i++) {
char * filename;
filename = rsprintf("%s%s.%d.glsl", config.pattern.dir, prefix, i);
if(filename == NULL) MEMFAIL();
GLhandleARB h = load_shader(filename);
if (h == 0) {
fprintf(stderr, "%s", load_shader_error);
WARN("Unable to load shader %s", filename);
success = false;
} else {
pattern->shader[i] = h;
DEBUG("Loaded shader #%d", i);
}
free(filename);
}
if(!success) {
ERROR("Failed to load some shaders.");
return 2;
}
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
// Render targets
glGenFramebuffersEXT(1, &pattern->fb);
glGenTextures(pattern->n_shaders + 1, pattern->tex);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
for(int i = 0; i < pattern->n_shaders + 1; i++) {
glBindTexture(GL_TEXTURE_2D, pattern->tex[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.pattern.master_width, config.pattern.master_height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
glBindTexture(GL_TEXTURE_2D, 0);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pattern->fb);
for(int i = 0; i < pattern->n_shaders + 1; i++) {
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
pattern->tex[i], 0);
glClear(GL_COLOR_BUFFER_BIT);
}
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
// Some OpenGL API garbage
pattern->uni_tex = calloc(pattern->n_shaders, sizeof *pattern->uni_tex);
if(pattern->uni_tex == NULL) MEMFAIL();
for(int i = 0; i < pattern->n_shaders; i++) {
pattern->uni_tex[i] = i + 1;
}
return 0;
}
void DiGLFBOManager::DetectFBOFormats()
{
// Try all formats, and report which ones work as target
GLuint fb = 0, tid = 0;
GLint old_drawbuffer = 0, old_readbuffer = 0;
GLenum target = GL_TEXTURE_2D;
glGetIntegerv(GL_DRAW_BUFFER, &old_drawbuffer);
glGetIntegerv(GL_READ_BUFFER, &old_readbuffer);
for (uint32 x = 0; x < PIXEL_FORMAT_MAX; ++x)
{
mProps[x].valid = false;
GLenum fmt = DiGLTypeMappings::GLInternalFormatMapping[(DiPixelFormat)x];
if (fmt == GL_NONE && x != 0)
continue;
if (DiPixelBox::IsCompressedFormat((DiPixelFormat)x))
continue;
// Buggy ATI cards *crash* on non-RGB(A) formats
int depths[4];
DiPixelBox::GetBitDepths((DiPixelFormat)x, depths);
if (fmt != GL_NONE && mATIMode && (!depths[0] || !depths[1] || !depths[2]))
continue;
// Create and attach framebuffer
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
if (fmt != GL_NONE)
{
// Create and attach texture
glGenTextures(1, &tid);
glBindTexture(target, tid);
// Set some default parameters so it won't fail on NVidia cards
if (GLEW_VERSION_1_2)
glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, 0);
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(target, 0, fmt, PROBE_SIZE, PROBE_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
target, tid, 0);
}
else
{
// Draw to nowhere -- stencil/depth only
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
}
// Check status
GLuint status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
// Ignore status in case of fmt==GL_NONE, because no implementation will accept
// a buffer without *any* attachment. Buffers with only stencil and depth attachment
// might still be supported, so we must continue probing.
if (fmt == GL_NONE || status == GL_FRAMEBUFFER_COMPLETE_EXT)
{
mProps[x].valid = true;
// For each depth/stencil formats
for (size_t depth = 0; depth < DEPTHFORMAT_COUNT; ++depth)
{
if (depthFormats[depth] != GL_DEPTH24_STENCIL8_EXT)
{
// General depth/stencil combination
for (size_t stencil = 0; stencil < STENCILFORMAT_COUNT; ++stencil)
{
if (TryFormat(depthFormats[depth], stencilFormats[stencil]))
{
/// Add mode to allowed modes
FormatProperties::Mode mode;
mode.depth = depth;
mode.stencil = stencil;
mProps[x].modes.push_back(mode);
}
}
}
else
{
if (TryPackedFormat(depthFormats[depth]))
{
/// Add mode to allowed modes
FormatProperties::Mode mode;
mode.depth = depth;
mode.stencil = 0;
mProps[x].modes.push_back(mode);
}
}
}
}
// Delete texture and framebuffer
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glDeleteFramebuffersEXT(1, &fb);
// Workaround for NVIDIA / Linux 169.21 driver problem
// see http://www.ogre3d.org/phpBB2/viewtopic.php?t=38037&start=25
glFinish();
if (fmt != GL_NONE)
glDeleteTextures(1, &tid);
}
// It seems a bug in nVidia driver: glBindFramebufferEXT should restore
// draw and read buffers, but in some unclear circumstances it won't.
glDrawBuffer(old_drawbuffer);
glReadBuffer(old_readbuffer);
for (size_t x = 0; x < PIXEL_FORMAT_MAX; ++x)
{
if (mProps[x].valid)
{
DI_INFO("Valid format for FBO targets: %s", DiPixelBox::GetPixelTypeName((DiPixelFormat)x).c_str());
}
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTFramebufferObject_nglFramebufferTexture2DEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint textarget, jint texture, jint level, jlong function_pointer) {
glFramebufferTexture2DEXTPROC glFramebufferTexture2DEXT = (glFramebufferTexture2DEXTPROC)((intptr_t)function_pointer);
glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
}
FBO *fbo_ext_create(int width, int height, int num_color_textures, bool z_stencil, FBOColorDepth colorDepth) {
FBO *fbo = new FBO();
fbo->native_fbo = false;
fbo->width = width;
fbo->height = height;
fbo->colorDepth = colorDepth;
// Color texture is same everywhere
glGenFramebuffersEXT(1, &fbo->handle);
glGenTextures(1, &fbo->color_texture);
// Create the surfaces.
glBindTexture(GL_TEXTURE_2D, fbo->color_texture);
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_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// TODO: We could opt to only create 16-bit render targets on slow devices. For later.
switch (colorDepth) {
case FBO_8888:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
break;
case FBO_4444:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, NULL);
break;
case FBO_5551:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, NULL);
break;
case FBO_565:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);
break;
}
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_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fbo->stencil_buffer = 0;
fbo->z_buffer = 0;
// 24-bit Z, 8-bit stencil
glGenRenderbuffersEXT(1, &fbo->z_stencil_buffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fbo->z_stencil_buffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, width, height);
//glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8, width, height);
// Bind it all together
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo->handle);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fbo->color_texture, 0);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, fbo->z_stencil_buffer);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, fbo->z_stencil_buffer);
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
switch(status) {
case GL_FRAMEBUFFER_COMPLETE_EXT:
// ILOG("Framebuffer verified complete.");
break;
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
ELOG("GL_FRAMEBUFFER_UNSUPPORTED");
break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
ELOG("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT ");
break;
default:
FLOG("Other framebuffer error: %i", status);
break;
}
// Unbind state we don't need
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
glBindTexture(GL_TEXTURE_2D, 0);
currentDrawHandle_ = fbo->handle;
currentReadHandle_ = fbo->handle;
return fbo;
}
void WaterSurface::init()
{
// init textures & buffers
//textureManager->loadTexture(...);
dudv_ID = textureManager->loadTexture(WATER_DUDV_MAP, "water_dudvmap", 3, false, GL_REPEAT, GL_LINEAR);
glGenTextures(1, &cb_refl_ID);
glBindTexture(GL_TEXTURE_2D, cb_refl_ID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, g_WinWidth, g_WinHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glGenTextures(1, &db_refl_ID );
glBindTexture(GL_TEXTURE_2D, db_refl_ID );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, g_WinWidth, g_WinHeight, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glGenFramebuffersEXT(1, &fb_refl_ID);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb_refl_ID);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, cb_refl_ID, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, db_refl_ID, 0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glGenTextures(1, &cb_refr_ID);
glBindTexture(GL_TEXTURE_2D, cb_refr_ID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, g_WinWidth, g_WinHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glGenTextures(1, &db_refr_ID );
glBindTexture(GL_TEXTURE_2D, db_refr_ID );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, g_WinWidth, g_WinHeight, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glGenFramebuffersEXT(1, &fb_refr_ID);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb_refr_ID);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, cb_refr_ID, 0);
//glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_2D, color_tex1_id, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, db_refr_ID, 0);
assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT)==GL_FRAMEBUFFER_COMPLETE_EXT);
assert( glGetError() == GL_NO_ERROR );
// init shaders...
int shaderID = shaderManager->loadShader("Water", WATER_VS_FILENAME, WATER_FS_FILENAME);
shader = shaderManager->getShader(shaderID);
water_reflection_loc = shader->getLocation("water_reflection");
water_refraction_loc = shader->getLocation("water_refraction");
water_depth_loc = shader->getLocation("water_depthmap");
shader->linkTexture(textureManager->getTexture(dudv_ID));
}
bool C4FoWRegion::BindFramebuf()
{
#ifndef USE_CONSOLE
// Flip texture
C4Surface *pSfc = pSurface;
pSurface = pBackSurface;
pBackSurface = pSfc;
// Can simply reuse old texture?
if (!pSurface || pSurface->Wdt < Region.Wdt || (pSurface->Hgt / 2) < Region.Hgt)
{
// Determine texture size. Round up to next power of two in order to
// prevent rounding errors, as well as preventing lots of
// re-allocations when region size changes quickly (think zoom).
if (!pSurface)
pSurface = new C4Surface();
int iWdt = 1, iHgt = 1;
while (iWdt < Region.Wdt) iWdt *= 2;
while (iHgt < Region.Hgt) iHgt *= 2;
// Double the texture size. The second half of the texture
// will contain the light color information, while the
// first half contains the brightness and direction information
iHgt *= 2;
// Create the texture
if (!pSurface->Create(iWdt, iHgt))
return false;
}
// Generate frame buffer object
if (!hFrameBufDraw)
{
glGenFramebuffersEXT(1, &hFrameBufDraw);
glGenFramebuffersEXT(1, &hFrameBufRead);
}
// Bind current texture to frame buffer
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, hFrameBufDraw);
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, hFrameBufRead);
glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
pSurface->textures[0].texName, 0);
if (pBackSurface)
glFramebufferTexture2DEXT(GL_READ_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D,
pBackSurface->textures[0].texName, 0);
// Check status, unbind if something was amiss
GLenum status1 = glCheckFramebufferStatusEXT(GL_READ_FRAMEBUFFER_EXT),
status2 = glCheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
if (status1 != GL_FRAMEBUFFER_COMPLETE_EXT ||
(pBackSurface && status2 != GL_FRAMEBUFFER_COMPLETE_EXT) ||
!glCheck())
{
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
return false;
}
#endif
// Worked!
return true;
}
void PCSSShadowMap::createShadowMapsFBO(RenderActionBase *action)
{
UInt32 oldWidth, oldHeight;
oldWidth = _shadowVP->getPixelWidth();
oldHeight = _shadowVP->getPixelHeight();
//------Setting up Window to fit size of ShadowMap----------------
_shadowVP->setVPSize(0, 0, _shadowVP->getMapSize() - 1,
_shadowVP->getMapSize() - 1);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glShadeModel(GL_FLAT);
glDisable(GL_LIGHTING);
glDepthMask(GL_TRUE);
// disable all lights more speed
std::vector<bool> lightStates;
for(UInt32 i = 0;i < _shadowVP->_lights.size();++i)
{
// store old states.
lightStates.push_back(_shadowVP->_lights[i].second->getOn());
_shadowVP->_lights[i].second->setOn(false);
}
// deactivate exclude nodes:
for(UInt32 i = 0;i < _shadowVP->getMFExcludeNodes()->getSize();++i)
{
NodePtr exnode = _shadowVP->getExcludeNodes(i);
if(exnode != NullFC)
exnode->setTravMask(0);
}
for(UInt32 i = 0;i < _shadowVP->_lights.size();++i)
{
if(_shadowVP->_lightStates[i] != 0)
{
if(_shadowVP->getGlobalShadowIntensity() != 0.0 ||
_shadowVP->_lights[i].second->getShadowIntensity() != 0.0)
{
action->getWindow()->validateGLObject(
_shadowVP->_texChunks[i]->getGLId());
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fb2);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT
, GL_TEXTURE_2D,
action->getWindow()->getGLObjectId(
_shadowVP->_texChunks[i]->getGLId()),
0);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
glPolygonOffset(_shadowVP->getOffFactor(),
_shadowVP->getOffBias());
glEnable(GL_POLYGON_OFFSET_FILL);
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
action->setCamera(getCPtr(_shadowVP->_lightCameras[i]));
_shadowVP->renderLight(action, getCPtr(_unlitMat), i);
glDisable(GL_POLYGON_OFFSET_FILL);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glClearColor(0.0, 0.0, 0.0, 1.0);
action->setCamera(getCPtr(_shadowVP->getCamera()));
}
}
}
//-------Restoring old states of Window and Viewport----------
// enable all lights.
for(UInt32 i = 0;i < _shadowVP->_lights.size();++i)
{
// restore old states.
_shadowVP->_lights[i].second->setOn(lightStates[i]);
}
// activate exclude nodes:
for(UInt32 i = 0;i < _shadowVP->getMFExcludeNodes()->getSize();++i)
{
NodePtr exnode = _shadowVP->getExcludeNodes(i);
if(exnode != NullFC)
exnode->setTravMask(_shadowVP->_excludeNodeTravMask[i]);
}
_shadowVP->setVPSize(0, 0, oldWidth - 1, oldHeight - 1);
_shadowVP->setVPSize(0, 0, 1, 1);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glShadeModel(GL_SMOOTH);
glEnable(GL_LIGHTING);
}
