[vtkusers] Depth Peeling VTK5.2 ATI Cars
Francois Bertel
francois.bertel at kitware.com
Mon Oct 6 14:18:32 EDT 2008
It just mean this card does not have proper hardware support for depth
peeling. Just don't expect to have depth peeling working on this card.
That's it.
By the way, the message I put "not enough GPU RAM for opaque z" is
actually not accurate. There are many other reasons for
glTexImage2D(vtkgl::PROXY_TEXTURE_RECTANGLE_ARB,..) to fail. Notably
the depth format. I bet you that a couple of lines above the value
of depthBits is 24, so this->DepthFormat is initialized to
this->DepthFormat=vtkgl::DEPTH_COMPONENT24_ARB. But ATI only supports
16-bit depth textures.
We cannot fix that because storing the 24bit depth buffer in a 16bit
texture will make the algorithm fail.
On Mon, Oct 6, 2008 at 6:43 AM, Inigo Barandiaran
<ibarandiaran at vicomtech.org> wrote:
>
> Hi Francois.
>
> I've added the proposed lines and the validation error is gone.
>
> The problem is that I've tested the same code, with the if(useTexture==1)\n"
> commented in another laptop and I got the error in:
>
> /*
> 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");
> }
> */
>
> where width is equal to 0. The renderer of the laptop is a X300 that I've
> realized you already identified as "buggy" implementation. I commented the
> lines where you reset the depth peeling usage, but I got the mentioned
> error.
>
> Any idea, suggestion. Thanks in advance.
>
>
> 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,
>>>>>> ¶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
>>>> _______________________________________________
>>>> 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-tp19796076p19835555.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