[vtkusers] Depth Peeling VTK5.2 ATI Cars

Inigo Barandiaran ibarandiaran at vicomtech.org
Fri Oct 3 14:25:46 EDT 2008


Sorry Francois, not to give you all the details.

I added the following code just after

vtkgl::CompileShader(shader); in vtkOpenglRenderer.cxx
//////
GLenum glErr;
glErr:glGetError();
std::cout<<gluErrorString(glErr)<<std::endl;
/////

I added this code trying to "debug" the code. Then i started to comment
lines in the shader till the error dissapears. 

I will try the code you suggest, and I will tell you the results.

Best,




Francois Bertel wrote:
> 
> Let's be accurate. When you say the message "Validation failed!"
> happens when linking the shader, is it really *right after*
> vtkgl::LinkProgram()?
> or did you add some code like:
> 
> vtkgl::ValidateProgram(this->ProgramShader);
> Glint status;
> vtkgl::GetProgramiv(this->ProgramShader,vtkgl::VALIDATE_STATUS,&status);
> if(status!=GL_TRUE)
> {
>  cout <<"Validation failed" << endl;
> }
> 
> because link and validation are different issues. The link stage has
> to be successful before to be able to validate a program.
> Validate means the program is correct but let's check if in the
> current OpenGL state, we can use it, basically. It will check if the
> uniform variables are correctly
> initialized. And I just found one that is not...
> 
> Can try the following test please:
> 
> 1. restore the glsl code in its original state ( put back the
> "if(useTexture==1)..." part)
> 2. change the following block in vtk/Rendering/vtkOpenGLProperty.cxx at
> line 50:
> 
> {
> GLint uUseTexture=-1;
>     uUseTexture=oRenderer->GetUseTextureUniformVariable();
>     vtkgl::Uniform1i(uUseTexture,0);
> }
> 
> by adding the following lines:
> 
> GLint uTexture=oRenderer->GetTextureUniformVariable();
> vtkgl::Uniform1i(uTexture,0); // active texture 0
> 
> the block will look like:
> {
>     GLint uUseTexture=-1;
>     uUseTexture=oRenderer->GetUseTextureUniformVariable();
>     vtkgl::Uniform1i(uUseTexture,0);
>     GLint uTexture=oRenderer->GetTextureUniformVariable();
>     vtkgl::Uniform1i(uTexture,0); // active texture 0
> }
> 
> Tell me if you still have the validation error or if it is working.
> 
> On Fri, Oct 3, 2008 at 1:47 PM, Inigo Barandiaran
> <ibarandiaran at vicomtech.org> wrote:
>>
>> Hi Francois.
>>
>> No. I modified the original code in VTK5.2. I did not change
>> vtkgl::TEXTURE_RECTANGLE_ARB by GL_TEXTURE_2D. I only comment the part of
>> the frangment that access to the texture if useTexture flag is enable. 
>> This
>> is the Code.
>>
>> /*
>> const char *vtkOpenGLRenderer_PeelingFS=
>> //  "#extension GL_ARB_texture_rectangle: enable\n"
>>  "uniform sampler2DRectShadow   shadowTex;\n"
>>  "uniform sampler2DRectShadow   opaqueShadowTex;\n"
>>  "uniform float offsetX;\n"
>>  "uniform float offsetY;\n"
>>  "uniform int useTexture;\n"
>>  "uniform sampler2D texture;\n"
>>  "void main()\n"
>>  "{\n"
>>  "vec4 r0=gl_FragCoord;\n"
>>  "r0.x=r0.x-offsetX;\n"
>>  "r0.y=r0.y-offsetY;\n"
>>  "float r1=shadow2DRect(opaqueShadowTex,r0.xyz).x;\n"
>>  "r1=r1-0.5;\n"
>>  "if(r1<0.0)\n"
>>  "{\n"
>>  " discard;\n"
>>  "}\n"
>>  "r0.x=shadow2DRect(shadowTex,r0.xyz).x;\n"
>>  "r0.x=r0.x-0.5;\n"
>>  "if(r0.x<0.0)\n"
>>  "{\n"
>>  " discard;\n"
>>  "}\n"
>>  "//if(useTexture==1)\n"
>>  "//{\n"
>>  " //gl_FragColor=gl_Color*texture2D(texture,gl_TexCoord[0].xy);\n"
>>  "//}\n"
>>  "//else\n"
>>  "//{\n"
>>  " gl_FragColor=gl_Color;\n"
>>  "//}\n"
>>  "}\n";
>> */
>>
>> Because we are not using textured surfaces, we dont need the line:
>> gl_Color*texture2D(texture,gl_TexCoord[0].xy;
>>
>> We also updated the drivers of the laptop with (
>> http://www.driverheaven.net/modtool.php) tool to be the driver able to
>> support TEXTURE_RECTANGLE_ARB, that was not supported in old ATI drivers.
>>
>> Tell me if this info is usefull for you. If yoy want me to try something
>> in
>> the software, please tell me.
>>
>> Best,
>>
>>
>>
>> Francois Bertel wrote:
>>>
>>> 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,
>>>>>                            &params);
>>>>>         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,&params);
>>>>>   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,&params);
>>>>>     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,&params);
>>>>>     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,&params);
>>>>>       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
>>> _______________________________________________
>>> 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-tp19796076p19802599.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
> _______________________________________________
> 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-tp19796076p19803210.html
Sent from the VTK - Users mailing list archive at Nabble.com.




More information about the vtkusers mailing list