[vtkusers] Depth Peeling VTK5.2 ATI Cars
Inigo Barandiaran
ibarandiaran at vicomtech.org
Mon Oct 6 06:43:20 EDT 2008
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.
More information about the vtkusers
mailing list