/* 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); }