[vtkusers] Depth Peeling VTK5.2 ATI Cars
Francois Bertel
francois.bertel at kitware.com
Fri Oct 3 13:38:31 EDT 2008
Do you mean you originally modified the VTK code by just replacing
vtkgl::TEXTURE_RECTANGLE_ARB by GL_TEXTURE_2D without changing the
shader code
from sampler2DRectShadow to sampler2DShadow and calls from
shadow2DRect() to shadow2D()?
Which code is working? Is it the code I just sent you?
On Fri, Oct 3, 2008 at 1:26 PM, Inigo Barandiaran
<ibarandiaran at vicomtech.org> wrote:
>
> Hi Francois.
>
> Good News!!
>
> We get depth peeling working right in ATI Card! :)
>
> We have found that there is a conflict in the shader between shadow2DRect
> and texture2D, accesing textures.
>
> We found an error when linking the shader: "Validation failed! - Different
> sampler types for same sample texture unit in fragment shader"
>
> For the moment we dont need textured surfaces, so we comment the line
> gl_FragColor=gl_Color*texture2D(texture,gl_TexCoord[0].xy); in the shader
> and works perfect.
>
> I dont know if you already knew this problem.
>
> Best,
>
>
> Francois Bertel wrote:
>>
>> I don't want to discourage you but I just google "depth peeling ati
>> glsl". The first item is "Doesn't work quite right on ATI cards"...
>> And if it was that easy it would have been fixed in VTK.
>>
>> But if you really want to focus on finding a solution to make it work
>> on some ATI card, feel free to ask me question about the algorithm
>> itself. I'll be happy to help you because
>> I'll be happy to see it working on something else than nVidia and Mesa.
>>
>> In attachment, I have some version that use regular 2D texture (it
>> means the card has to support none-power-of-two (NPOT) textures
>> instead of rectangle textures. You can try it on your side if you
>> want.
>>
>> BTW. If you want to move to an implementation question, you should
>> start a new thread on vtk-developers list instead.
>>
>> On Fri, Oct 3, 2008 at 12:01 PM, Inigo Barandiaran
>> <ibarandiaran at vicomtech.org> wrote:
>>>
>>> Thanks goodwin for your reply.
>>> I tested depth peeling in both laptop and non-laptop PC. With an old ATI
>>> card and with a New ATI card with the lastest drivers installed (i used
>>> this
>>> tool http://www.driverheaven.net/modtool.php that allows to install the
>>> lastest ATI drivers for non-Laptop PC in any laptop).
>>>
>>> Depth peeling did not work nor in laptop neither in non-laptop PC.
>>>
>>> Francois, i don't know where is exactly the problem. In your code, you
>>> mention that the problem is the implementation in GLSL of some funtions
>>> in
>>> ATI's driver isnt it?
>>>
>>> I will try to find a solution, but, do you think is going to be difficult
>>> to
>>> solve? Thanks in advance, and thanks for your efforts in VTK :)
>>>
>>> Best,
>>>
>>>
>>>
>>> Goodwin Lawlor wrote:
>>>>
>>>> Francois Bertel wrote:
>>>>> Iñigo,
>>>>>
>>>>> No I don't have solution for VTK depth peeling on ATI cards.
>>>>>
>>>>> Goodwin,
>>>>>
>>>>> VTK depth peeling working on an old ATI laptop is break news for me!
>>>>>
>>>>> You are the first saying that VTK depth peeling is working with an ATI
>>>>> card.
>>>>> Can you send me your OpenGL profile please (any of the following
>>>>> methods allows you to save the result into a text file):
>>>>> http://www.vtk.org/Wiki/VTK_FAQ#How_do_I_check_which_OpenGL_versions_or_extensions_are_supported_by_my_graphic_card_or_OpenGL_implementation.3F
>>>>>
>>>>> What's the result of
>>>>>
>>>>> $ ctest -R TestTranslucentLUTDepthPeeling -V
>>>>>
>>>>> Does it fail or pass?
>>>>> Does it say: "depth peeling was used" or does it say "depth peeling
>>>>> was not used (alpha blending instead)"?
>>>>>
>>>>> The best is actually to submit this test on the vtk dahsboard as an
>>>>> experimental build:
>>>>>
>>>>> $ ctest -D ExperimentalTest -R
>>>>> "LoadOpenGLExtension|TestTranslucentLUTDepthPeeling"
>>>>>
>>>>> ... it will run LoadOpenGLExtension test (this test will display the
>>>>> OpenGL version and the list of OpenGL extensions,
>>>>> it will run TestTranslucentLUTDepthPeeling as well.
>>>>>
>>>>> Regards.
>>>>
>>>> Sorry - false alarm. That test fails.
>>>>
>>>> Looking at my app is falls back to sorting polys on the laptop.
>>>>
>>>> That reminds me that those omega drivers add accelerated 3d texture
>>>> volume rendering over the official drivers, not depth peeling :-(
>>>>
>>>> Goodwin
>>>>
>>>> _______________________________________________
>>>> This is the private VTK discussion list.
>>>> Please keep messages on-topic. Check the FAQ at:
>>>> http://www.vtk.org/Wiki/VTK_FAQ
>>>> Follow this link to subscribe/unsubscribe:
>>>> http://www.vtk.org/mailman/listinfo/vtkusers
>>>>
>>>>
>>>
>>> --
>>> View this message in context:
>>> http://www.nabble.com/Depth-Peeling-VTK5.2-ATI-Cars-tp19796076p19800766.html
>>> Sent from the VTK - Users mailing list archive at Nabble.com.
>>>
>>> _______________________________________________
>>> This is the private VTK discussion list.
>>> Please keep messages on-topic. Check the FAQ at:
>>> http://www.vtk.org/Wiki/VTK_FAQ
>>> Follow this link to subscribe/unsubscribe:
>>> http://www.vtk.org/mailman/listinfo/vtkusers
>>>
>>
>>
>>
>> --
>> François Bertel, PhD | Kitware Inc. Suite 204
>> 1 (518) 371 3971 x113 | 28 Corporate Drive
>> | Clifton Park NY 12065, USA
>>
>> /*=========================================================================
>>
>> Program: Visualization Toolkit
>> Module: $RCSfile: vtkOpenGLRenderer.cxx,v $
>>
>> Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
>> All rights reserved.
>> See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
>>
>> This software is distributed WITHOUT ANY WARRANTY; without even
>> the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
>> PURPOSE. See the above copyright notice for more information.
>>
>> =========================================================================*/
>> #include "vtkOpenGLRenderer.h"
>>
>> #include "vtkCuller.h"
>> #include "vtkLightCollection.h"
>> #include "vtkObjectFactory.h"
>> #include "vtkOpenGLCamera.h"
>> #include "vtkOpenGLLight.h"
>> #include "vtkOpenGLProperty.h"
>> #include "vtkRenderWindow.h"
>> #include "vtkOpenGLExtensionManager.h"
>> #include "vtkgl.h" // vtkgl namespace
>> #include "vtkImageImport.h"
>> #include "vtkPNGWriter.h"
>>
>> #ifndef VTK_IMPLEMENT_MESA_CXX
>> # include "vtkOpenGL.h"
>> #endif
>>
>> #include <math.h>
>> #include <assert.h>
>> #include <vtkstd/list>
>>
>> class vtkGLPickInfo
>> {
>> public:
>> GLuint* PickBuffer;
>> GLuint PickedId;
>> GLuint NumPicked;
>> };
>>
>> #ifndef VTK_IMPLEMENT_MESA_CXX
>> vtkCxxRevisionMacro(vtkOpenGLRenderer, "$Revision: 1.91 $");
>> vtkStandardNewMacro(vtkOpenGLRenderer);
>> #endif
>>
>> #define VTK_MAX_LIGHTS 8
>>
>> // List of rgba layers, id are 2D rectangle texture Ids.
>> class vtkOpenGLRendererLayerList
>> {
>> public:
>> vtkstd::list<GLuint> List;
>> };
>>
>> extern const char *vtkOpenGLRenderer_PeelingFS;
>> // #define USE_RECT
>>
>> #ifdef USE_RECT
>> # define TEXTURE_TARGET vtkgl::TEXTURE_RECTANGLE_ARB
>> #else
>> // NPOT
>> # define TEXTURE_TARGET GL_TEXTURE_2D
>> #endif
>>
>> vtkOpenGLRenderer::vtkOpenGLRenderer()
>> {
>> this->PickInfo = new vtkGLPickInfo;
>> this->NumberOfLightsBound = 0;
>> this->PickInfo->PickBuffer = 0;
>> this->PickInfo->PickedId = 0;
>> this->PickInfo->NumPicked = 0;
>> this->PickedZ = 0;
>>
>> this->DepthPeelingIsSupported=0;
>> this->DepthPeelingIsSupportedChecked=0;
>> this->LayerList=0;
>> this->OpaqueLayerZ=0;
>> this->TransparentLayerZ=0;
>> this->ProgramShader=0;
>> this->DepthFormat=0;
>> this->DepthPeelingHigherLayer=0;
>> }
>>
>> // Internal method temporarily removes lights before reloading them
>> // into graphics pipeline.
>> void vtkOpenGLRenderer::ClearLights (void)
>> {
>> short curLight;
>> float Info[4];
>>
>> // define a lighting model and set up the ambient light.
>> // use index 11 for the heck of it. Doesn't matter except for 0.
>>
>> // update the ambient light
>> Info[0] = this->Ambient[0];
>> Info[1] = this->Ambient[1];
>> Info[2] = this->Ambient[2];
>> Info[3] = 1.0;
>> glLightModelfv(GL_LIGHT_MODEL_AMBIENT, Info);
>>
>> if ( this->TwoSidedLighting )
>> {
>> glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
>> }
>> else
>> {
>> glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
>> }
>>
>> // now delete all the old lights
>> for (curLight = GL_LIGHT0; curLight < GL_LIGHT0 + VTK_MAX_LIGHTS;
>> curLight++)
>> {
>> glDisable(static_cast<GLenum>(curLight));
>> }
>>
>> this->NumberOfLightsBound = 0;
>> }
>>
>> // Ask lights to load themselves into graphics pipeline.
>> int vtkOpenGLRenderer::UpdateLights ()
>> {
>> vtkLight *light;
>> short curLight;
>> float status;
>> int count;
>>
>> // Check if a light is on. If not then make a new light.
>> count = 0;
>> curLight= this->NumberOfLightsBound + GL_LIGHT0;
>>
>> vtkCollectionSimpleIterator sit;
>> for(this->Lights->InitTraversal(sit);
>> (light = this->Lights->GetNextLight(sit)); )
>> {
>> status = light->GetSwitch();
>> if ((status > 0.0)&& (curLight < (GL_LIGHT0+VTK_MAX_LIGHTS)))
>> {
>> curLight++;
>> count++;
>> }
>> }
>>
>> if( !count )
>> {
>> vtkDebugMacro(<<"No lights are on, creating one.");
>> this->CreateLight();
>> }
>>
>> count = 0;
>> curLight= this->NumberOfLightsBound + GL_LIGHT0;
>>
>> // set the matrix mode for lighting. ident matrix on viewing stack
>> glMatrixMode(GL_MODELVIEW);
>> glPushMatrix();
>>
>> for(this->Lights->InitTraversal(sit);
>> (light = this->Lights->GetNextLight(sit)); )
>> {
>>
>> status = light->GetSwitch();
>>
>> // if the light is on then define it and bind it.
>> // also make sure we still have room.
>> if ((status > 0.0)&& (curLight < (GL_LIGHT0+VTK_MAX_LIGHTS)))
>> {
>> light->Render(this,curLight);
>> glEnable(static_cast<GLenum>(curLight));
>> // increment the current light by one
>> curLight++;
>> count++;
>> }
>> }
>>
>> this->NumberOfLightsBound = curLight - GL_LIGHT0;
>>
>> glPopMatrix();
>> glEnable(GL_LIGHTING);
>> return count;
>> }
>>
>> //
>> ----------------------------------------------------------------------------
>> // Description:
>> // Access to the OpenGL program shader uniform variable "useTexture" from
>> the
>> // vtkOpenGLProperty or vtkOpenGLTexture.
>> int vtkOpenGLRenderer::GetUseTextureUniformVariable()
>> {
>> GLint
>> result=vtkgl::GetUniformLocation(this->ProgramShader,"useTexture");
>> if(result==-1)
>> {
>> vtkErrorMacro(<<"useTexture is not a uniform variable");
>> }
>> return result;
>> }
>>
>> //
>> ----------------------------------------------------------------------------
>> // Description:
>> // Access to the OpenGL program shader uniform variable "texture" from the
>> // vtkOpenGLProperty or vtkOpenGLTexture.
>> int vtkOpenGLRenderer::GetTextureUniformVariable()
>> {
>> GLint result=vtkgl::GetUniformLocation(this->ProgramShader,"texture");
>> if(result==-1)
>> {
>> vtkErrorMacro(<<"texture is not a uniform variable");
>> }
>> return result;
>> }
>>
>> //
>> ----------------------------------------------------------------------------
>> // Description:
>> // Is rendering at translucent geometry stage using depth peeling and
>> // rendering a layer other than the first one? (Boolean value)
>> // If so, the uniform variables UseTexture and Texture can be set.
>> // (Used by vtkOpenGLProperty or vtkOpenGLTexture)
>> int vtkOpenGLRenderer::GetDepthPeelingHigherLayer()
>> {
>> return this->DepthPeelingHigherLayer;
>> }
>>
>> //
>> ----------------------------------------------------------------------------
>> // Concrete open gl render method.
>> void vtkOpenGLRenderer::DeviceRender(void)
>> {
>> // Do not remove this MakeCurrent! Due to Start / End methods on
>> // some objects which get executed during a pipeline update,
>> // other windows might get rendered since the last time
>> // a MakeCurrent was called.
>> this->RenderWindow->MakeCurrent();
>>
>> // standard render method
>> this->ClearLights();
>>
>> this->UpdateCamera();
>> this->UpdateLightGeometry();
>> this->UpdateLights();
>>
>> // set matrix mode for actors
>> glMatrixMode(GL_MODELVIEW);
>>
>> this->UpdateGeometry();
>>
>> // clean up the model view matrix set up by the camera
>> glMatrixMode(GL_MODELVIEW);
>> glPopMatrix();
>> }
>>
>> //
>> ----------------------------------------------------------------------------
>> // Description:
>> // Render translucent polygonal geometry. Default implementation just call
>> // UpdateTranslucentPolygonalGeometry().
>> // Subclasses of vtkRenderer that can deal with depth peeling must
>> // override this method.
>> void vtkOpenGLRenderer::DeviceRenderTranslucentPolygonalGeometry()
>> {
>> if(this->UseDepthPeeling)
>> {
>> if(!this->DepthPeelingIsSupportedChecked)
>> {
>> this->DepthPeelingIsSupportedChecked=1;
>> vtkOpenGLExtensionManager
>> *extensions=vtkOpenGLExtensionManager::New();
>> extensions->SetRenderWindow(this->RenderWindow);
>>
>> int
>> supports_GL_1_3=extensions->ExtensionSupported("GL_VERSION_1_3");
>> int
>> supports_GL_1_4=extensions->ExtensionSupported("GL_VERSION_1_4");
>> int
>> supports_GL_1_5=extensions->ExtensionSupported("GL_VERSION_1_5");
>> int
>> supports_GL_2_0=extensions->ExtensionSupported("GL_VERSION_2_0");
>>
>> int supports_vertex_shader;
>> int supports_fragment_shader;
>> int supports_shader_objects;
>> if(supports_GL_2_0)
>> {
>> supports_vertex_shader=1;
>> supports_fragment_shader=1;
>> supports_shader_objects=1;
>> }
>> else
>> {
>>
>> supports_vertex_shader=extensions->ExtensionSupported("GL_ARB_vertex_shader");
>>
>> supports_fragment_shader=extensions->ExtensionSupported("GL_ARB_fragment_shader");
>>
>> supports_shader_objects=extensions->ExtensionSupported("GL_ARB_shader_objects");
>> }
>> int supports_multitexture=supports_GL_1_3 ||
>> extensions->ExtensionSupported("GL_ARB_multitexture");
>> int supports_occlusion_query;
>> int supports_shadow_funcs;
>> if(supports_GL_1_5)
>> {
>> supports_occlusion_query=1;
>> supports_shadow_funcs=1;
>> }
>> else
>> {
>>
>> supports_occlusion_query=extensions->ExtensionSupported("GL_ARB_occlusion_query");
>>
>> supports_shadow_funcs=extensions->ExtensionSupported("GL_EXT_shadow_funcs");
>> }
>>
>> int supports_depth_texture;
>> int supports_shadow;
>> int supports_blend_func_separate;
>> if(supports_GL_1_4)
>> {
>> supports_depth_texture=1;
>> supports_blend_func_separate=1;
>> supports_shadow=1;
>> }
>> else
>> {
>>
>> supports_depth_texture=extensions->ExtensionSupported("GL_ARB_depth_texture");
>> supports_shadow=extensions->ExtensionSupported("GL_ARB_shadow");
>>
>> supports_blend_func_separate=extensions->ExtensionSupported("GL_EXT_blend_func_separate");
>> }
>>
>> int
>> supports_GL_ARB_texture_rectangle=extensions->ExtensionSupported("GL_ARB_texture_rectangle");
>>
>> // spec claims it is GL_SGIS_texture_edge_clamp, reality shows it is
>> // GL_EXT_texture_edge_clamp on Nvidia.
>> // part of OpenGL 1.2 core
>> // there is no new function with this extension, we don't need to
>> load
>> // it.
>> int
>> supports_edge_clamp=extensions->ExtensionSupported("GL_VERSION_1_2");
>> if(!supports_edge_clamp)
>> {
>>
>> supports_edge_clamp=extensions->ExtensionSupported("GL_SGIS_texture_edge_clamp");
>> if(!supports_edge_clamp)
>> {
>> // nvidia cards.
>>
>> supports_edge_clamp=extensions->ExtensionSupported("GL_EXT_texture_edge_clamp");
>> }
>> }
>>
>> GLint alphaBits;
>> glGetIntegerv(GL_ALPHA_BITS, &alphaBits);
>> int supportsAtLeast8AlphaBits=alphaBits>=8;
>>
>> this->DepthPeelingIsSupported =
>> supports_depth_texture &&
>> supports_shadow &&
>> supports_blend_func_separate &&
>> supports_shadow_funcs &&
>> supports_vertex_shader &&
>> supports_fragment_shader &&
>> supports_shader_objects &&
>> supports_occlusion_query &&
>> supports_multitexture &&
>> supports_GL_ARB_texture_rectangle &&
>> supports_edge_clamp &&
>> supportsAtLeast8AlphaBits;
>>
>> if(this->DepthPeelingIsSupported)
>> {
>> vtkDebugMacro("depth peeling supported");
>> if(supports_GL_1_3)
>> {
>> extensions->LoadExtension("GL_VERSION_1_3");
>> }
>> else
>> {
>> extensions->LoadCorePromotedExtension("GL_ARB_multitexture");
>> }
>> // GL_ARB_depth_texture, GL_ARB_shadow and GL_EXT_shadow_funcs
>> // don't introduce new functions.
>> if(supports_GL_1_4)
>> {
>> extensions->LoadExtension("GL_VERSION_1_4");
>> }
>> else
>> {
>>
>> extensions->LoadCorePromotedExtension("GL_EXT_blend_func_separate");
>> }
>>
>> if(supports_GL_2_0)
>> {
>> extensions->LoadExtension("GL_VERSION_2_0");
>> }
>> else
>> {
>> extensions->LoadCorePromotedExtension("GL_ARB_vertex_shader");
>> extensions->LoadCorePromotedExtension("GL_ARB_fragment_shader");
>> extensions->LoadCorePromotedExtension("GL_ARB_shader_objects");
>> }
>> if(supports_GL_1_5)
>> {
>> extensions->LoadExtension("GL_VERSION_1_5");
>> }
>> else
>> {
>> extensions->LoadCorePromotedExtension("GL_ARB_occlusion_query");
>> }
>>
>> extensions->LoadExtension("GL_ARB_texture_rectangle");
>> }
>> else
>> {
>> vtkDebugMacro(<<"depth peeling is not supported.");
>> if(!supports_depth_texture)
>> {
>> vtkDebugMacro(<<"neither OpenGL 1.4 nor GL_ARB_depth_texture is
>> supported");
>> }
>> if(!supports_shadow)
>> {
>> vtkDebugMacro(<<"neither OpenGL 1.4 nor GL_ARB_shadow is
>> supported");
>> }
>> if(!supports_shadow_funcs)
>> {
>> vtkDebugMacro(<<"neither OpenGL 1.5 nor GL_EXT_shadow_funcs is
>> supported");
>> }
>> if(!supports_vertex_shader)
>> {
>> vtkDebugMacro(<<"neither OpenGL 2.0 nor GL_ARB_vertex_shader is
>> supported");
>> }
>> if(!supports_fragment_shader)
>> {
>> vtkDebugMacro(<<"neither OpenGL 2.0 nor GL_ARB_fragment_shader
>> is supported");
>> }
>> if(!supports_shader_objects)
>> {
>> vtkDebugMacro(<<"neither OpenGL 2.0 nor GL_ARB_shader_objects is
>> supported");
>> }
>> if(!supports_occlusion_query)
>> {
>> vtkDebugMacro(<<"neither OpenGL 1.5 nor GL_ARB_occlusion_query
>> is supported");
>> }
>> if(!supports_multitexture)
>> {
>> vtkDebugMacro(<<"neither OpenGL 1.3 nor GL_ARB_multitexture is
>> supported");
>> }
>> if(!supports_GL_ARB_texture_rectangle)
>> {
>> vtkDebugMacro(<<"GL_ARB_texture_rectangle is not supported");
>> }
>> if(!supports_edge_clamp)
>> {
>> vtkDebugMacro(<<"neither OpenGL 1.2 nor
>> GL_SGIS_texture_edge_clamp nor GL_EXT_texture_edge_clamp is not
>> supported");
>> }
>> if(!supportsAtLeast8AlphaBits)
>> {
>> vtkDebugMacro(<<"at least 8 alpha bits is not supported");
>> }
>> }
>> extensions->Delete();
>>
>> if(this->DepthPeelingIsSupported)
>> {
>> // Some OpenGL implementations such as Mesa or ATI
>> // claim to support both GLSL and GL_ARB_texture_rectangle but
>> // don't actually support sampler2DRectShadow in a GLSL code.
>> // To test that, we compile the shader, if it fails, we don't use
>> // deph peeling
>> GLuint shader =
>> vtkgl::CreateShader(vtkgl::FRAGMENT_SHADER);
>> vtkgl::ShaderSource(
>> shader, 1,
>> const_cast<const char **>(&vtkOpenGLRenderer_PeelingFS), 0);
>> vtkgl::CompileShader(shader);
>> GLint params;
>> vtkgl::GetShaderiv(shader,vtkgl::COMPILE_STATUS,
>> ¶ms);
>> this->DepthPeelingIsSupported = params==GL_TRUE;
>> vtkgl::DeleteShader(shader);
>> if(!this->DepthPeelingIsSupported)
>> {
>> vtkDebugMacro("this OpenGL implementation does not support "
>> "GL_ARB_texture_rectangle in GLSL code");
>> }
>> }
>> if(this->DepthPeelingIsSupported)
>> {
>> // Some OpenGL implementations are buggy so depth peeling does not
>> work:
>> // - ATI on iMac, Mac Pro, Power Mac G5, etc. Bug
>> <rdar://4975997>.
>> // - ATI on some PCs
>> // - Mesa 6.5.2 and lower
>> // Do alpha blending always.
>> const char* gl_renderer =
>> reinterpret_cast<const char *>(glGetString(GL_RENDERER));
>> int isATIRadeonX1600 =
>> strstr(gl_renderer, "ATI Radeon X1600 OpenGL Engine") != 0;
>> int isATIRadeonX1900 =
>> strstr(gl_renderer, "ATI Radeon X1900 OpenGL Engine") != 0;
>> int isATIFireGLV3300 =
>> strstr(gl_renderer, "ATI FireGL V3300 Pentium 4 (SSE2)") != 0;
>> int isATIRadeon9600XT =
>> strstr(gl_renderer, "ATI Radeon 9600 XT OpenGL Engine") != 0;
>> int isATIRadeonX300X550 =
>> strstr(gl_renderer, "RADEON X300/X550 Series x86/SSE2") != 0;
>>
>> const char* gl_version =
>> reinterpret_cast<const char *>(glGetString(GL_VERSION));
>> if(const char* mesa_version = strstr(gl_version, "Mesa"))
>> {
>> // Mesa versions 6.5.3 and higher work. Versions much lower
>> // than 6.5.2 do not report support for the extensions to
>> // get this far. Therefore if parsing of the version fails
>> // just assume it is a higher version that changed the
>> // format of the version string.
>> int mesa_major = 0;
>> int mesa_minor = 0;
>> int mesa_patch = 0;
>> if(sscanf(mesa_version, "Mesa %d.%d.%d",
>> &mesa_major, &mesa_minor, &mesa_patch) >= 2)
>> {
>> if(mesa_major < 6 ||
>> (mesa_major == 6 && mesa_major < 5) ||
>> (mesa_major == 6 && mesa_minor == 5 && mesa_patch < 3))
>> {
>> this->DepthPeelingIsSupported = 0;
>> }
>> }
>> }
>> else if(isATIRadeon9600XT)
>> {
>> // The Mac OS X 10.4.9->10.4.10, 10.5.0->10.5.1
>> // versions of the ATI driver, known not to work
>> // 1.5 ATI-1.4.18, 2.0 ATI-1.5.16, 2.0 ATI-1.5.18
>> this->DepthPeelingIsSupported = 0;
>> }
>> else if(isATIFireGLV3300)
>> {
>> // so far, 2.0.6237 and 2.0.6672 don't work
>> this->DepthPeelingIsSupported = 0;
>> }
>> else if(isATIRadeonX1600 || isATIRadeonX1900)
>> {
>> // The Mac OS X 10.4.8->10.4.11, 10.5.0->10.5.1
>> // versions of the ATI driver, known not to work
>> // 2.0 ATI-1.4.40, 2.0 ATI-1.4.52, 2.0 ATI-1.4.56,
>> // 2.0 ATI-1.4.58
>> // 2.0 ATI-1.5.16, 2.0 ATI-1.5.18,
>> this->DepthPeelingIsSupported = 0;
>> }
>> else if(isATIRadeonX300X550)
>> {
>> // Windows XP 2.0.6479 version of the ATI driver, known not to
>> work
>> if(strstr(gl_version, "2.0.6479 WinXP Release")==0)
>> {
>> this->DepthPeelingIsSupported = 0;
>> }
>> }
>> }
>> }
>> }
>>
>> if(!this->UseDepthPeeling || !this->DepthPeelingIsSupported)
>> {
>> // just alpha blending
>> this->LastRenderingUsedDepthPeeling=0;
>> this->UpdateTranslucentPolygonalGeometry();
>> }
>> else
>> {
>> // depth peeling.
>>
>> // get the viewport dimensions
>>
>> this->GetTiledSizeAndOrigin(&this->ViewportWidth,&this->ViewportHeight,
>> &this->ViewportX,&this->ViewportY);
>>
>> // get z bits
>> GLint depthBits;
>> glGetIntegerv(GL_DEPTH_BITS,&depthBits);
>> if(depthBits==16)
>> {
>> this->DepthFormat=vtkgl::DEPTH_COMPONENT16_ARB;
>> }
>> else
>> {
>> this->DepthFormat=vtkgl::DEPTH_COMPONENT24_ARB;
>> }
>> // 1. Grab the RGBAZ of the opaque layer.
>> GLuint opaqueLayerZ=0;
>> GLuint opaqueLayerRgba=0;
>> glGenTextures(1,&opaqueLayerZ);
>> this->OpaqueLayerZ=opaqueLayerZ;
>>
>> glGenTextures(1,&opaqueLayerRgba);
>> // opaque z format
>> vtkgl::ActiveTexture(vtkgl::TEXTURE1 );
>> glBindTexture(TEXTURE_TARGET,opaqueLayerZ);
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_MIN_FILTER,
>> GL_NEAREST);
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_MAG_FILTER,
>> GL_NEAREST);
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_WRAP_S,
>> vtkgl::CLAMP_TO_EDGE);
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_WRAP_T,
>> vtkgl::CLAMP_TO_EDGE);
>> glTexParameteri(TEXTURE_TARGET,
>> vtkgl::TEXTURE_COMPARE_MODE,
>> vtkgl::COMPARE_R_TO_TEXTURE);
>> glTexParameteri(TEXTURE_TARGET,
>> vtkgl::TEXTURE_COMPARE_FUNC,
>> GL_LESS);
>>
>> // Allocate memory
>> glTexImage2D(vtkgl::PROXY_TEXTURE_RECTANGLE_ARB,0,this->DepthFormat,
>> this->ViewportWidth,this->ViewportHeight,
>> 0,GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0);
>> GLint width;
>> glGetTexLevelParameteriv(vtkgl::PROXY_TEXTURE_RECTANGLE_ARB,0,
>> GL_TEXTURE_WIDTH,&width);
>> if(width==0)
>> {
>> vtkDebugMacro(<<"not enough GPU RAM for opaque z");
>> // not enough GPU RAM. Do alpha blending technique instead
>> glDeleteTextures(1,&opaqueLayerRgba);
>> glDeleteTextures(1,&opaqueLayerZ);
>> this->LastRenderingUsedDepthPeeling=0;
>> vtkgl::ActiveTexture(vtkgl::TEXTURE0 );
>> this->UpdateTranslucentPolygonalGeometry();
>> return;
>> }
>> glTexImage2D(TEXTURE_TARGET,0,this->DepthFormat,
>> this->ViewportWidth,this->ViewportHeight, 0,
>> GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0);
>> // Grab the z-buffer
>> glCopyTexSubImage2D(TEXTURE_TARGET, 0, 0, 0, this->ViewportX,
>> this->ViewportY,this->ViewportWidth,
>> this->ViewportHeight);
>> glBindTexture(TEXTURE_TARGET,opaqueLayerRgba);
>> // opaque rgba format
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_MIN_FILTER,
>> GL_NEAREST);
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_MAG_FILTER,
>> GL_NEAREST);
>> // Allocate memory
>> glTexImage2D(vtkgl::PROXY_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
>> this->ViewportWidth,this->ViewportHeight,
>> 0,GL_RGBA, GL_UNSIGNED_BYTE, 0);
>> glGetTexLevelParameteriv(vtkgl::PROXY_TEXTURE_RECTANGLE_ARB,0,
>> GL_TEXTURE_WIDTH,&width);
>> if(width==0)
>> {
>> vtkDebugMacro(<<"not enough GPU RAM for opaque rgba");
>> // not enough GPU RAM. Do alpha blending technique instead
>> glDeleteTextures(1,&opaqueLayerRgba);
>> glDeleteTextures(1,&opaqueLayerZ);
>> this->LastRenderingUsedDepthPeeling=0;
>> vtkgl::ActiveTexture(vtkgl::TEXTURE0 );
>> this->UpdateTranslucentPolygonalGeometry();
>> return;
>> }
>>
>> // Have to be set before a call to
>> UpdateTranslucentPolygonalGeometry()
>> // because UpdateTranslucentPolygonalGeometry() will eventually call
>> // vtkOpenGLActor::Render() that uses this flag.
>> this->LastRenderingUsedDepthPeeling=1;
>>
>> glTexImage2D(TEXTURE_TARGET, 0, GL_RGBA8,
>> this->ViewportWidth,this->ViewportHeight, 0, GL_RGBA,
>> GL_UNSIGNED_BYTE, 0);
>> // Grab the rgba-buffer
>> glCopyTexSubImage2D(TEXTURE_TARGET, 0, 0, 0, this->ViewportX,
>> this->ViewportY,this->ViewportWidth,
>> this->ViewportHeight);
>>
>> GLuint queryId;
>> vtkgl::GenQueries(1,&queryId);
>> int stop=0;
>> int infiniteLoop=this->MaximumNumberOfPeels==0;
>>
>> unsigned int threshold=static_cast<unsigned
>> int>(this->ViewportWidth*this->ViewportHeight*OcclusionRatio);
>> this->LayerList=new vtkOpenGLRendererLayerList;
>>
>>
>> GLint hasMultisampleBuffer;
>> glGetIntegerv(GL_SAMPLE_BUFFERS,&hasMultisampleBuffer);
>> cout << "hasMultisampleBuffer=" << hasMultisampleBuffer << endl;
>>
>> GLint samples;
>> glGetIntegerv(GL_SAMPLES,&samples);
>> cout << "number of samples=" <<samples << endl;
>>
>> GLboolean status;
>> glGetBooleanv(GL_MULTISAMPLE,&status);
>> cout << "multisampling=";
>> if(status)
>> {
>> cout << "true" <<endl;
>> }
>> else
>> {
>> cout << "false" <<endl;
>> }
>>
>> // save the default blend function.
>> glPushAttrib(GL_COLOR_BUFFER_BIT);
>>
>> int multiSampleStatus=glIsEnabled(vtkgl::MULTISAMPLE);
>>
>> if(multiSampleStatus)
>> {
>> // glDisable(vtkgl::MULTISAMPLE);
>> }
>> glDisable(GL_BLEND);
>> GLuint nbPixels=0;
>> GLuint previousNbPixels=0;
>> int l=0;
>> while(!stop)
>> {
>> vtkgl::BeginQuery(vtkgl::SAMPLES_PASSED,queryId);
>> stop=!this->RenderPeel(l);
>> vtkgl::EndQuery(vtkgl::SAMPLES_PASSED);
>> // blocking call
>> previousNbPixels=nbPixels;
>> if(!stop || l>0) // stop && l==0 <=> no translucent geometry
>> {
>> vtkgl::GetQueryObjectuiv(queryId,vtkgl::QUERY_RESULT,&nbPixels);
>> glFinish();
>> cout << "flush after query object at l=" << l << endl;
>> glFlush();
>> if(!stop)
>> {
>> stop=(nbPixels<=threshold) || (nbPixels==previousNbPixels);
>> ++l;
>> if(!stop && !infiniteLoop)
>> {
>> stop=l>=this->MaximumNumberOfPeels;
>> }
>> }
>> }
>> }
>> if(multiSampleStatus)
>> {
>> glEnable(vtkgl::MULTISAMPLE);
>> }
>> // The two following lines are taken from vtkOpenGLProperty to
>> // reset texturing state after rendering the props.
>> glDisable(GL_TEXTURE_2D);
>> glDisable (GL_ALPHA_TEST);
>> glDepthFunc(GL_LEQUAL);
>> vtkgl::DeleteQueries(1,&queryId);
>> if(this->TransparentLayerZ!=0)
>> {
>> GLuint
>> transparentLayerZ=static_cast<GLuint>(this->TransparentLayerZ);
>> glDeleteTextures(1,&transparentLayerZ);
>> this->TransparentLayerZ=0;
>> }
>>
>> // Finally, draw sorted opacity
>> glMatrixMode(GL_PROJECTION);
>> glPushMatrix();
>> glLoadIdentity();
>> glOrtho(0, this->ViewportWidth, 0, this->ViewportHeight, -1, 1);
>> glMatrixMode(GL_MODELVIEW);
>> glPushMatrix();
>> glLoadIdentity();
>> glClearColor( static_cast<GLclampf>(0),static_cast<GLclampf>(0),
>> static_cast<GLclampf>(0),static_cast<GLclampf>(0));
>>
>> glClear(GL_COLOR_BUFFER_BIT);
>> glDisable(GL_DEPTH_TEST);
>>
>> vtkgl::ActiveTexture(vtkgl::TEXTURE0 );
>> glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
>> glEnable(TEXTURE_TARGET);
>>
>> // actor in wireframe may have change that
>> glPolygonMode(GL_FRONT, GL_FILL);
>>
>> glDisable(GL_BLEND);
>> // First the opaque layer
>> glBindTexture(TEXTURE_TARGET,opaqueLayerRgba);
>> glBegin(GL_QUADS);
>> glTexCoord2f(0, 0);
>> glVertex2f(0, 0);
>> #ifdef USE_RECT
>> glTexCoord2f(this->ViewportWidth, 0);
>> glVertex2f(this->ViewportWidth, 0);
>> glTexCoord2f(this->ViewportWidth, this->ViewportHeight);
>> glVertex2f(this->ViewportWidth, this->ViewportHeight);
>> glTexCoord2f(0, this->ViewportHeight);
>> glVertex2f(0, this->ViewportHeight);
>> #else
>> glTexCoord2f(1.0, 0);
>> glVertex2f(this->ViewportWidth, 0);
>> glTexCoord2f(1.0,1.0);
>> glVertex2f(this->ViewportWidth, this->ViewportHeight);
>> glTexCoord2f(0, 1.0);
>> glVertex2f(0, this->ViewportHeight);
>> #endif
>> glEnd();
>>
>> vtkgl::BlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
>> GL_ONE,GL_ONE_MINUS_SRC_ALPHA);
>> glEnable(GL_BLEND);
>> // the transparent layers
>> vtkstd::list<GLuint>::reverse_iterator
>> it=this->LayerList->List.rbegin();
>> vtkstd::list<GLuint>::reverse_iterator
>> itEnd=this->LayerList->List.rend();
>> while(it!=itEnd)
>> {
>> glBindTexture(TEXTURE_TARGET,(*it));
>>
>> glBegin(GL_QUADS);
>> glTexCoord2f(0, 0);
>> glVertex2f(0, 0);
>> #ifdef USE_RECT
>> glTexCoord2f(this->ViewportWidth, 0);
>> glVertex2f(this->ViewportWidth, 0);
>> glTexCoord2f(this->ViewportWidth, this->ViewportHeight);
>> glVertex2f(this->ViewportWidth, this->ViewportHeight);
>> glTexCoord2f(0, this->ViewportHeight);
>> glVertex2f(0, this->ViewportHeight);
>> #else
>> glTexCoord2f(1.0, 0);
>> glVertex2f(this->ViewportWidth, 0);
>> glTexCoord2f(1.0,1.0);
>> glVertex2f(this->ViewportWidth, this->ViewportHeight);
>> glTexCoord2f(0, 1.0);
>> glVertex2f(0, this->ViewportHeight);
>> #endif
>> glEnd();
>> ++it;
>> }
>> // Restore the default blend function for the next stage (overlay)
>> glPopAttrib();
>>
>> glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
>> glDisable(TEXTURE_TARGET);
>> glEnable(GL_DEPTH_TEST);
>> glMatrixMode(GL_PROJECTION);
>> glPopMatrix();
>> glMatrixMode(GL_MODELVIEW);
>> glPopMatrix();
>> // Destroy the shader
>> if(this->ProgramShader!=0)
>> {
>> vtkgl::DeleteProgram(this->ProgramShader);
>> this->ProgramShader=0;
>> }
>>
>> // Destroy the layers
>> size_t c=this->LayerList->List.size();
>> GLuint *ids=new GLuint[c];
>> vtkstd::list<GLuint>::const_iterator
>> it2=this->LayerList->List.begin();
>> size_t layer=0;
>> while(layer<c)
>> {
>> ids[layer]=(*it2);
>> ++layer;
>> ++it2;
>> }
>> glDeleteTextures(static_cast<GLsizei>(c),ids);
>> delete[] ids;
>> delete this->LayerList;
>> this->LayerList=0;
>>
>> glDeleteTextures(1,&opaqueLayerRgba);
>> glDeleteTextures(1,&opaqueLayerZ);
>> }
>> }
>>
>> //
>> ----------------------------------------------------------------------------
>> // Description:
>> // Check the compilation status of some fragment shader source.
>> void vtkOpenGLRenderer::CheckCompilation(
>> unsigned int fragmentShader)
>> {
>> GLuint fs=static_cast<GLuint>(fragmentShader);
>> GLint params;
>> vtkgl::GetShaderiv(fs,vtkgl::COMPILE_STATUS,¶ms);
>> if(params==GL_TRUE)
>> {
>> vtkDebugMacro(<<"shader source compiled successfully");
>> }
>> else
>> {
>> vtkErrorMacro(<<"shader source compile error");
>> // include null terminator
>> vtkgl::GetShaderiv(fs,vtkgl::INFO_LOG_LENGTH,¶ms);
>> if(params>0)
>> {
>> char *buffer=new char[params];
>> vtkgl::GetShaderInfoLog(fs,params,0,buffer);
>> vtkErrorMacro(<<"log: "<<buffer);
>> delete[] buffer;
>> }
>> else
>> {
>> vtkErrorMacro(<<"no log");
>> }
>> }
>> }
>>
>> //
>> ----------------------------------------------------------------------------
>> // Description:
>> // Render a peel layer. If there is no more GPU RAM to save the texture,
>> // return false otherwise returns true. Also if layer==0 and no prop have
>> // been rendered (there is no translucent geometry), it returns false.
>> // \pre positive_layer: layer>=0
>> int vtkOpenGLRenderer::RenderPeel(int layer)
>> {
>> assert("pre: positive_layer" && layer>=0);
>>
>> GLbitfield mask=GL_COLOR_BUFFER_BIT;
>> if(layer>0)
>> {
>> mask=mask|GL_DEPTH_BUFFER_BIT;
>> }
>>
>> glClearColor(0.0, 0.0, 0.0, 0.0);
>> glClear(mask);
>>
>> vtkgl::ActiveTexture(vtkgl::TEXTURE2);
>> glBindTexture(TEXTURE_TARGET,this->OpaqueLayerZ);
>> vtkgl::ActiveTexture(vtkgl::TEXTURE1 );
>>
>> if(this->ProgramShader==0)
>> {
>> this->ProgramShader=vtkgl::CreateProgram();
>> GLuint shader=vtkgl::CreateShader(vtkgl::FRAGMENT_SHADER);
>> vtkgl::ShaderSource(shader,1,const_cast<const char
>> **>(&vtkOpenGLRenderer_PeelingFS),0);
>> vtkgl::CompileShader(shader);
>> this->CheckCompilation(shader);
>> vtkgl::AttachShader(this->ProgramShader,shader);
>> vtkgl::LinkProgram(this->ProgramShader);
>>
>> GLint params;
>>
>> vtkgl::GetProgramiv(static_cast<GLuint>(this->ProgramShader),vtkgl::LINK_STATUS,¶ms);
>> if(params==GL_TRUE)
>> {
>> vtkDebugMacro(<<"program linked successfully");
>> }
>> else
>> {
>> vtkErrorMacro(<<"program link error");
>> // include null terminator
>>
>> vtkgl::GetProgramiv(static_cast<GLuint>(this->ProgramShader),vtkgl::INFO_LOG_LENGTH,¶ms);
>> if(params>0)
>> {
>> #if 1
>> char *buffer=new char[params];
>>
>> vtkgl::GetProgramInfoLog(static_cast<GLuint>(this->ProgramShader),params,0,buffer);
>> vtkErrorMacro(<<"log: "<<buffer);
>> delete[] buffer;
>> #endif
>> }
>> else
>> {
>> vtkErrorMacro(<<"no log: ");
>> }
>> }
>> vtkgl::DeleteShader(shader); // reference counting
>> }
>>
>> if(layer>0)
>> {
>> glBindTexture(TEXTURE_TARGET,this->TransparentLayerZ);
>> vtkgl::UseProgram(this->ProgramShader);
>> GLint
>> uShadowTex=vtkgl::GetUniformLocation(this->ProgramShader,"shadowTex");
>> if(uShadowTex!=-1)
>> {
>> vtkgl::Uniform1i(uShadowTex,1);
>> }
>> else
>> {
>> vtkErrorMacro(<<"error: shadowTex is not a uniform.");
>> }
>> GLint
>> uOpaqueShadowTex=vtkgl::GetUniformLocation(this->ProgramShader,"opaqueShadowTex");
>> if(uOpaqueShadowTex!=-1)
>> {
>> vtkgl::Uniform1i(uOpaqueShadowTex,2);
>> }
>> else
>> {
>> vtkErrorMacro(<<"error: opaqueShadowTex is not a uniform.");
>> }
>>
>> GLint
>> uOffsetX=vtkgl::GetUniformLocation(this->ProgramShader,"offsetX");
>> if(uOffsetX!=-1)
>> {
>> vtkgl::Uniform1f(uOffsetX,this->ViewportX);
>> }
>> else
>> {
>> vtkErrorMacro(<<"error: offsetX is not a uniform.");
>> }
>>
>> GLint
>> uOffsetY=vtkgl::GetUniformLocation(this->ProgramShader,"offsetY");
>> if(uOffsetY!=-1)
>> {
>> vtkgl::Uniform1f(uOffsetY,this->ViewportY);
>> }
>> else
>> {
>> vtkErrorMacro(<<"error: offsetY is not a uniform.");
>> }
>> #ifndef USE_RECT
>> GLint
>> uInvWidth=vtkgl::GetUniformLocation(this->ProgramShader,"invWidth");
>> if(uInvWidth!=-1)
>> {
>> vtkgl::Uniform1f(uInvWidth,1.0/this->ViewportWidth);
>> }
>> else
>> {
>> vtkErrorMacro(<<"error: invWidth is not a uniform.");
>> }
>>
>> GLint
>> uInvHeight=vtkgl::GetUniformLocation(this->ProgramShader,"invHeight");
>> if(uInvHeight!=-1)
>> {
>> vtkgl::Uniform1f(uInvHeight,1.0/this->ViewportHeight);
>> }
>> else
>> {
>> vtkErrorMacro(<<"error: invHeight is not a uniform.");
>> }
>> #endif
>>
>> }
>>
>> vtkgl::ActiveTexture(vtkgl::TEXTURE0 );
>> glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
>> this->DepthPeelingHigherLayer=layer>0;
>> int numberOfRenderedProps=this->UpdateTranslucentPolygonalGeometry();
>> if(layer>0)
>> {
>> this->DepthPeelingHigherLayer=0;
>> vtkgl::UseProgram(0);
>> }
>>
>> GLint width;
>> vtkgl::ActiveTexture(vtkgl::TEXTURE1 );
>> if(layer==0)
>> {
>> if(numberOfRenderedProps>0)
>> {
>> GLuint transparentLayerZ;
>> glGenTextures(1,&transparentLayerZ);
>> this->TransparentLayerZ=static_cast<unsigned
>> int>(transparentLayerZ);
>> glBindTexture(TEXTURE_TARGET,this->TransparentLayerZ);
>>
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_MIN_FILTER,
>> GL_NEAREST);
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_MAG_FILTER,
>> GL_NEAREST);
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_WRAP_S,
>> vtkgl::CLAMP_TO_EDGE);
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_WRAP_T,
>> vtkgl::CLAMP_TO_EDGE);
>> glTexParameteri(TEXTURE_TARGET,
>> vtkgl::TEXTURE_COMPARE_MODE,
>> vtkgl::COMPARE_R_TO_TEXTURE);
>> glTexParameteri(TEXTURE_TARGET,
>> vtkgl::TEXTURE_COMPARE_FUNC,
>> GL_GREATER);
>>
>> // Allocate memory
>> glTexImage2D(vtkgl::PROXY_TEXTURE_RECTANGLE_ARB,0,this->DepthFormat,
>> this->ViewportWidth,this->ViewportHeight,
>> 0,GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0);
>> glGetTexLevelParameteriv(vtkgl::PROXY_TEXTURE_RECTANGLE_ARB,0,
>> GL_TEXTURE_WIDTH,&width);
>> if(width==0)
>> {
>> // not enough GPU RAM. Use alpha blending technique instead
>> glDeleteTextures(1,&transparentLayerZ);
>> this->TransparentLayerZ=0;
>> return 0;
>> }
>> glTexImage2D(TEXTURE_TARGET,0,this->DepthFormat,
>> this->ViewportWidth,this->ViewportHeight, 0,
>> GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0);
>> }
>> }
>> else
>> {
>> glBindTexture(TEXTURE_TARGET,this->TransparentLayerZ);
>> }
>> if((layer==0 && numberOfRenderedProps>0) || layer>0)
>> {
>> // Grab the z-buffer
>> glCopyTexSubImage2D(TEXTURE_TARGET, 0, 0, 0, this->ViewportX,
>> this->ViewportY,this->ViewportWidth,
>> this->ViewportHeight);
>>
>> // Grab the rgba buffer
>> GLuint rgba;
>> glGenTextures(1,&rgba);
>> glBindTexture(TEXTURE_TARGET,rgba);
>> // rgba format
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_MIN_FILTER,
>> GL_NEAREST);
>> glTexParameteri(TEXTURE_TARGET,GL_TEXTURE_MAG_FILTER,
>> GL_NEAREST);
>>
>> // Allocate memory
>> glTexImage2D(vtkgl::PROXY_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
>> this->ViewportWidth,this->ViewportHeight,
>> 0,GL_RGBA, GL_UNSIGNED_BYTE, 0);
>> glGetTexLevelParameteriv(vtkgl::PROXY_TEXTURE_RECTANGLE_ARB,0,
>> GL_TEXTURE_WIDTH,&width);
>> if(width==0)
>> {
>> // not enough GPU RAM. Do alpha blending technique instead
>> glDeleteTextures(1,&rgba);
>> return 0;
>> }
>>
>> glTexImage2D(TEXTURE_TARGET, 0, GL_RGBA8,
>> this->ViewportWidth,this->ViewportHeight, 0, GL_RGBA,
>> GL_UNSIGNED_BYTE, 0);
>>
>> // Grab the rgba-buffer
>> glCopyTexSubImage2D(TEXTURE_TARGET, 0, 0, 0, this->ViewportX,
>> this->ViewportY,this->ViewportWidth,
>> this->ViewportHeight);
>> this->LayerList->List.push_back(rgba);
>>
>> return 1;
>> }
>> else
>> {
>> return 0;
>> }
>> }
>>
>> //
>> ----------------------------------------------------------------------------
>> void vtkOpenGLRenderer::PrintSelf(ostream& os, vtkIndent indent)
>> {
>> this->Superclass::PrintSelf(os,indent);
>>
>> os << indent << "Number Of Lights Bound: " <<
>> this->NumberOfLightsBound << "\n";
>> os << indent << "PickBuffer " << this->PickInfo->PickBuffer << "\n";
>> os << indent << "PickedId" << this->PickInfo->PickedId<< "\n";
>> os << indent << "NumPicked" << this->PickInfo->NumPicked<< "\n";
>> os << indent << "PickedZ " << this->PickedZ << "\n";
>> }
>>
>>
>> void vtkOpenGLRenderer::Clear(void)
>> {
>> GLbitfield clear_mask = 0;
>>
>> if (! this->Transparent())
>> {
>> glClearColor( static_cast<GLclampf>(this->Background[0]),
>> static_cast<GLclampf>(this->Background[1]),
>> static_cast<GLclampf>(this->Background[2]),
>> static_cast<GLclampf>(0.0));
>> clear_mask |= GL_COLOR_BUFFER_BIT;
>> }
>>
>> glClearDepth(static_cast<GLclampf>(1.0));
>> clear_mask |= GL_DEPTH_BUFFER_BIT;
>>
>> vtkDebugMacro(<< "glClear\n");
>> glClear(clear_mask);
>>
>> // If gradient background is turned on, draw it now.
>> if (!this->Transparent() && this->GradientBackground)
>> {
>> glPushAttrib(GL_ENABLE_BIT);
>> glDisable(GL_DEPTH_TEST);
>> glDisable(GL_LIGHTING);
>> glDisable(GL_TEXTURE_1D);
>> glDisable(GL_TEXTURE_2D);
>> glShadeModel(GL_SMOOTH); // color interpolation
>>
>> glMatrixMode(GL_MODELVIEW);
>> glPushMatrix();
>> {
>> glLoadIdentity();
>> glMatrixMode(GL_PROJECTION);
>> glPushMatrix();
>> {
>> glLoadIdentity();
>> glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0);
>>
>> glBegin(GL_QUADS);
>>
>> //top vertices
>> glColor3dv(this->Background);
>> glVertex2f(-1.0, -1.0);
>> glVertex2f(1.0, -1.0);
>>
>> //bottom vertices
>> glColor3dv(this->Background2);
>> glVertex2f(1.0, 1.0);
>> glVertex2f(-1.0, 1.0);
>> glEnd();
>> }
>> glPopMatrix();
>> glMatrixMode(GL_MODELVIEW);
>> }
>> glPopMatrix();
>> glPopAttrib();
>> }
>> }
>>
>> void vtkOpenGLRenderer::StartPick(unsigned int pickFromSize)
>> {
>>
>> int bufferSize = pickFromSize * 4;
>>
>> // Do not remove this MakeCurrent! Due to Start / End methods on
>> // some objects which get executed during a pipeline update,
>> // other windows might get rendered since the last time
>> // a MakeCurrent was called.
>> this->RenderWindow->MakeCurrent();
>> this->RenderWindow->IsPickingOn();
>> if (this->PickInfo->PickBuffer)
>> {
>> delete [] this->PickInfo->PickBuffer;
>> this->PickInfo->PickBuffer = 0;
>> }
>> this->PickInfo->PickBuffer = new GLuint[bufferSize];
>> glSelectBuffer(bufferSize, this->PickInfo->PickBuffer);
>> // change to selection mode
>> (void)glRenderMode(GL_SELECT);
>> // initialize the pick names and add a 0 name, for no pick
>> glInitNames();
>> glPushName(0);
>> }
>>
>>
>>
>> void vtkOpenGLRenderer::UpdatePickId()
>> {
>> glLoadName(this->CurrentPickId++);
>> }
>>
>>
>> void vtkOpenGLRenderer::DevicePickRender()
>> {
>> // Do not remove this MakeCurrent! Due to Start / End methods on
>> // some objects which get executed during a pipeline update,
>> // other windows might get rendered since the last time
>> // a MakeCurrent was called.
>> this->RenderWindow->MakeCurrent();
>>
>> // standard render method
>> this->ClearLights();
>>
>> this->UpdateCamera();
>> this->UpdateLightGeometry();
>> this->UpdateLights();
>>
>> // set matrix mode for actors
>> glMatrixMode(GL_MODELVIEW);
>>
>> this->PickGeometry();
>>
>> // clean up the model view matrix set up by the camera
>> glMatrixMode(GL_MODELVIEW);
>> glPopMatrix();
>> }
>>
>>
>> void vtkOpenGLRenderer::DonePick()
>> {
>> glFlush();
>> GLuint hits = glRenderMode(GL_RENDER);
>> this->PickInfo->NumPicked = hits;
>>
>> unsigned int depth = static_cast<unsigned int>(-1);
>> GLuint* ptr = this->PickInfo->PickBuffer;
>> this->PickInfo->PickedId = 0;
>> for(unsigned int k =0; k < hits; k++)
>> {
>> int num_names = *ptr;
>> int save = 0;
>> ptr++; // move to first depth value
>> if(*ptr <= depth)
>> {
>> depth = *ptr;
>> save = 1;
>> }
>> ptr++; // move to next depth value
>> if(*ptr <= depth)
>> {
>> depth = *ptr;
>> save = 1;
>> }
>> // move to first name picked
>> ptr++;
>> if(save)
>> {
>> this->PickInfo->PickedId = *ptr;
>> }
>> // skip additonal names
>> ptr += num_names;
>> }
>> // If there was a pick, then get the Z value
>> if(this->PickInfo->PickedId)
>> {
>> // convert from pick depth described as:
>> // Returned depth values are mapped such that the largest unsigned
>> // integer value corresponds to window coordinate depth 1.0,
>> // and zero corresponds to window coordinate depth 0.0.
>>
>> this->PickedZ = depth/static_cast<double>(VTK_UNSIGNED_INT_MAX);
>>
>> // Clamp to range [0,1]
>> this->PickedZ = (this->PickedZ < 0.0) ? 0.0 : this->PickedZ;
>> this->PickedZ = (this->PickedZ > 1.0) ? 1.0: this->PickedZ;
>> }
>>
>> //Don't delete the list, keep it around in case caller wants all
>> //of the hits. Delete it elsewhere when needed.
>> //delete [] this->PickInfo->PickBuffer;
>> //this->PickInfo->PickBuffer = 0;
>>
>> this->RenderWindow->IsPickingOff();
>> }
>>
>> double vtkOpenGLRenderer::GetPickedZ()
>> {
>> return this->PickedZ;
>> }
>>
>> unsigned int vtkOpenGLRenderer::GetPickedId()
>> {
>> return static_cast<unsigned int>(this->PickInfo->PickedId);
>> }
>>
>> vtkOpenGLRenderer::~vtkOpenGLRenderer()
>> {
>> if (this->PickInfo->PickBuffer)
>> {
>> delete [] this->PickInfo->PickBuffer;
>> this->PickInfo->PickBuffer = 0;
>> }
>> delete this->PickInfo;
>> }
>>
>> unsigned int vtkOpenGLRenderer::GetNumPickedIds()
>> {
>> return static_cast<unsigned int>(this->PickInfo->NumPicked);
>> }
>>
>> int vtkOpenGLRenderer::GetPickedIds(unsigned int atMost,
>> unsigned int *callerBuffer)
>> {
>> if (!this->PickInfo->PickBuffer)
>> {
>> return 0;
>> }
>>
>> unsigned int max = (atMost < this->PickInfo->NumPicked) ? atMost :
>> this->PickInfo->NumPicked;
>> GLuint* iptr = this->PickInfo->PickBuffer;
>> unsigned int *optr = callerBuffer;
>> unsigned int k;
>> for(k =0; k < max; k++)
>> {
>> int num_names = *iptr;
>> iptr++; // move to first depth value
>> iptr++; // move to next depth value
>> iptr++; // move to first name picked
>> *optr = static_cast<unsigned int>(*iptr);
>> optr++;
>> // skip additonal names
>> iptr += num_names;
>> }
>> return k;
>> }
>>
>>
>> _______________________________________________
>> This is the private VTK discussion list.
>> Please keep messages on-topic. Check the FAQ at:
>> http://www.vtk.org/Wiki/VTK_FAQ
>> Follow this link to subscribe/unsubscribe:
>> http://www.vtk.org/mailman/listinfo/vtkusers
>>
>>
>
> --
> View this message in context: http://www.nabble.com/Depth-Peeling-VTK5.2-ATI-Cars-tp19796076p19802293.html
> Sent from the VTK - Users mailing list archive at Nabble.com.
>
> _______________________________________________
> This is the private VTK discussion list.
> Please keep messages on-topic. Check the FAQ at: http://www.vtk.org/Wiki/VTK_FAQ
> Follow this link to subscribe/unsubscribe:
> http://www.vtk.org/mailman/listinfo/vtkusers
>
--
François Bertel, PhD | Kitware Inc. Suite 204
1 (518) 371 3971 x113 | 28 Corporate Drive
| Clifton Park NY 12065, USA
More information about the vtkusers
mailing list