[vtkusers] Depth Peeling VTK5.2 ATI Cars
Inigo Barandiaran
ibarandiaran at vicomtech.org
Fri Oct 3 13:26:05 EDT 2008
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.
More information about the vtkusers
mailing list