Commit 06d0b30a authored by Francois Bertel's avatar Francois Bertel

ENH:Starting support for multipass rendering.

parent e5b01ebe
......@@ -17,6 +17,7 @@ vtkRenderWindow-GetEventPending
vtkSQLiteDatabase-GetQueryInstance
vtkMySQLDatabase-GetQueryInstance
vtkPostgreSQLDatabase-GetQueryInstance
vtkUniformVariables-GetCurrentName
vtkXOpenGLRenderWindow-GetEventPending
vtkXMesaRenderWindow-GetEventPending
vtkMPICommunicator-GetWorldCommunicator
......
......@@ -16,8 +16,13 @@
#include "vtkObjectFactory.h"
#include "vtkAssemblyPaths.h"
#include "vtkCommand.h"
#include "vtkInformation.h"
#include "vtkInformationIterator.h"
#include "vtkInformationKey.h"
#include <assert.h>
vtkCxxRevisionMacro(vtkProp, "1.26");
vtkCxxRevisionMacro(vtkProp, "1.27");
vtkCxxSetObjectMacro(vtkProp,PropertyKeys,vtkInformation);
//----------------------------------------------------------------------------
// Creates an Prop with the following defaults: visibility on.
......@@ -36,6 +41,8 @@ vtkProp::vtkProp()
this->NumberOfConsumers = 0;
this->Consumers = 0;
this->PropertyKeys=0;
}
//----------------------------------------------------------------------------
......@@ -49,6 +56,11 @@ vtkProp::~vtkProp()
{
delete [] this->Consumers;
}
if(this->PropertyKeys!=0)
{
this->PropertyKeys->Delete();
}
}
//----------------------------------------------------------------------------
......@@ -123,6 +135,17 @@ void vtkProp::PrintSelf(ostream& os, vtkIndent indent)
os << indent << "RenderTimeMultiplier: "
<< this->RenderTimeMultiplier << endl;
os << indent << "Visibility: " << (this->Visibility ? "On\n" : "Off\n");
os << indent << "PropertyKeys: ";
if(this->PropertyKeys!=0)
{
this->PropertyKeys->PrintSelf(os,indent);
os << endl;
}
else
{
os << "none." << endl;
}
}
......@@ -196,3 +219,131 @@ vtkObject *vtkProp::GetConsumer(int i)
}
return this->Consumers[i];
}
// ----------------------------------------------------------------------------
// Description:
// Tells if the prop has all the required keys.
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
bool vtkProp::HasKeys(vtkInformation *requiredKeys)
{
bool result=requiredKeys==0;
if(!result)
{
vtkInformationIterator *it=vtkInformationIterator::New();
it->SetInformation(requiredKeys);
it->GoToFirstItem();
result=true;
while(result && !it->IsDoneWithTraversal())
{
vtkInformationKey *k=it->GetCurrentKey();
result=this->PropertyKeys!=0 && this->PropertyKeys->Has(k);
it->GoToNextItem();
}
it->Delete();
}
return result;
}
// ----------------------------------------------------------------------------
// Description:
// Render the opaque geometry only if the prop has all the requiredKeys.
// This is recursive for composite props like vtkAssembly.
// An implementation is provided in vtkProp but each composite prop
// must override it.
// It returns if the rendering was performed.
// \pre v_exists: v!=0
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
bool vtkProp::RenderFilteredOpaqueGeometry(vtkViewport *v,
vtkInformation *requiredKeys)
{
assert("pre: v_exists" && v!=0);
bool result;
if(this->HasKeys(requiredKeys))
{
result=this->RenderOpaqueGeometry(v)==1;
}
else
{
result=false;
}
return result;
}
// ----------------------------------------------------------------------------
// Description:
// Render the translucent polygonal geometry only if the prop has all the
// requiredKeys.
// This is recursive for composite props like vtkAssembly.
// An implementation is provided in vtkProp but each composite prop
// must override it.
// It returns if the rendering was performed.
// \pre v_exists: v!=0
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
bool vtkProp::RenderFilteredTranslucentPolygonalGeometry(
vtkViewport *v,
vtkInformation *requiredKeys)
{
assert("pre: v_exists" && v!=0);
bool result;
if(this->HasKeys(requiredKeys))
{
result=this->RenderTranslucentPolygonalGeometry(v)==1;
}
else
{
result=false;
}
return result;
}
// ----------------------------------------------------------------------------
// Description:
// Render the volumetric geometry only if the prop has all the
// requiredKeys.
// This is recursive for composite props like vtkAssembly.
// An implementation is provided in vtkProp but each composite prop
// must override it.
// It returns if the rendering was performed.
// \pre v_exists: v!=0
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
bool vtkProp::RenderFilteredVolumetricGeometry(vtkViewport *v,
vtkInformation *requiredKeys)
{
assert("pre: v_exists" && v!=0);
bool result;
if(this->HasKeys(requiredKeys))
{
result=this->RenderVolumetricGeometry(v)==1;
}
else
{
result=false;
}
return result;
}
// ----------------------------------------------------------------------------
// Description:
// Render in the overlay of the viewport only if the prop has all the
// requiredKeys.
// This is recursive for composite props like vtkAssembly.
// An implementation is provided in vtkProp but each composite prop
// must override it.
// It returns if the rendering was performed.
// \pre v_exists: v!=0
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
bool vtkProp::RenderFilteredOverlay(vtkViewport *v,
vtkInformation *requiredKeys)
{
assert("pre: v_exists" && v!=0);
bool result;
if(this->HasKeys(requiredKeys))
{
result=this->RenderOverlay(v)==1;
}
else
{
result=false;
}
return result;
}
......@@ -33,6 +33,7 @@ class vtkMatrix4x4;
class vtkPropCollection;
class vtkViewport;
class vtkWindow;
class vtkInformation;
class VTK_COMMON_EXPORT vtkProp : public vtkObject
{
......@@ -114,6 +115,20 @@ public:
virtual void PokeMatrix(vtkMatrix4x4 *vtkNotUsed(matrix)) {}
virtual vtkMatrix4x4 *GetMatrix() {return NULL;}
// Description:
// Set/Get property keys. Property keys can be digest by some rendering
// passes.
// For instance, the user may mark a prop as a shadow caster for a
// shadow mapping render pass. Keys are documented in render pass classes.
// Initial value is NULL.
vtkGetObjectMacro(PropertyKeys,vtkInformation);
virtual void SetPropertyKeys(vtkInformation *keys);
// Description:
// Tells if the prop has all the required keys.
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
virtual bool HasKeys(vtkInformation *requiredKeys);
//BTX
// Description:
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
......@@ -135,6 +150,54 @@ public:
virtual int RenderVolumetricGeometry( vtkViewport *) { return 0; }
virtual int RenderOverlay( vtkViewport *) { return 0; }
// Description:
// Render the opaque geometry only if the prop has all the requiredKeys.
// This is recursive for composite props like vtkAssembly.
// An implementation is provided in vtkProp but each composite prop
// must override it.
// It returns if the rendering was performed.
// \pre v_exists: v!=0
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
virtual bool RenderFilteredOpaqueGeometry(vtkViewport *v,
vtkInformation *requiredKeys);
// Description:
// Render the translucent polygonal geometry only if the prop has all the
// requiredKeys.
// This is recursive for composite props like vtkAssembly.
// An implementation is provided in vtkProp but each composite prop
// must override it.
// It returns if the rendering was performed.
// \pre v_exists: v!=0
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
virtual bool RenderFilteredTranslucentPolygonalGeometry(
vtkViewport *v,
vtkInformation *requiredKeys);
// Description:
// Render the volumetric geometry only if the prop has all the
// requiredKeys.
// This is recursive for composite props like vtkAssembly.
// An implementation is provided in vtkProp but each composite prop
// must override it.
// It returns if the rendering was performed.
// \pre v_exists: v!=0
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
virtual bool RenderFilteredVolumetricGeometry(vtkViewport *v,
vtkInformation *requiredKeys);
// Description:
// Render in the overlay of the viewport only if the prop has all the
// requiredKeys.
// This is recursive for composite props like vtkAssembly.
// An implementation is provided in vtkProp but each composite prop
// must override it.
// It returns if the rendering was performed.
// \pre v_exists: v!=0
// \pre keys_can_be_null: requiredKeys==0 || requiredKeys!=0
virtual bool RenderFilteredOverlay(vtkViewport *v,
vtkInformation *requiredKeys);
// Description:
// WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
// DO NOT USE THESE METHODS OUTSIDE OF THE RENDERING PROCESS
......@@ -282,6 +345,8 @@ protected:
// stuff that follows is used to build the assembly hierarchy
vtkAssemblyPaths *Paths;
vtkInformation *PropertyKeys;
private:
vtkProp(const vtkProp&); // Not implemented.
void operator=(const vtkProp&); // Not implemented.
......
......@@ -125,6 +125,8 @@ SET( Kit_SRCS
vtkRenderer.cxx
vtkRendererDelegate.cxx
vtkRendererSource.cxx
vtkRenderPass.cxx
vtkRenderState.cxx
vtkRenderWindowCollection.cxx
vtkRenderWindow.cxx
vtkRenderWindowInteractor.cxx
......@@ -137,7 +139,6 @@ SET( Kit_SRCS
vtkShader.cxx
vtkShaderDeviceAdapter.cxx
vtkShaderProgram.cxx
vtkShaderProgram2.cxx
vtkStandardPolyDataPainter.cxx
vtkTesting.cxx
# vtkTextActor2D.cxx
......@@ -206,6 +207,10 @@ SET( KitOpenGL_SRCS
vtkOpenGLRepresentationPainter.cxx
vtkOpenGLScalarsToColorsPainter.cxx
vtkOpenGLTexture.cxx
vtkShader2.cxx
vtkShader2Collection.cxx
vtkShaderProgram2.cxx
vtkUniformVariables.cxx
)
IF(VTK_USE_GLSL_SHADERS)
......@@ -232,6 +237,8 @@ SET_SOURCE_FILES_PROPERTIES(
vtkPrimitivePainter
vtkProp3D
vtkRendererDelegate
vtkRenderPass
vtkRenderState # not abstract just not using instantiator
vtkShader
vtkShaderDeviceAdapter
vtkShaderProgram
......@@ -239,6 +246,15 @@ SET_SOURCE_FILES_PROPERTIES(
ABSTRACT
)
SET_SOURCE_FILES_PROPERTIES(
vtkRenderPass
vtkRenderState
vtkShader2
vtkShader2Collection
vtkShaderProgram2
WRAP_EXCLUDE
)
# Freetype stuff
SET(KitOpenGL_SRCS ${KitOpenGL_SRCS} vtkOpenGLFreeTypeTextMapper.cxx)
......@@ -268,6 +284,7 @@ ENDIF(VTK_USE_X)
# The set of source files to be encoded.
SET(glsl_files
vtkOpenGLRenderer_PeelingFS
vtkOpenGLProperty_fs
)
# Create custom commands to encode each assembly file into a C string
......
......@@ -25,5 +25,6 @@ IF(PYTHON_EXECUTABLE)
vtkOpenGLExtensionManagerConfigure.h
vtkCocoaMacOSXSDKCompatibility.h
vtkPythagoreanQuadruples.h
vtkRenderState.h
)
ENDIF(PYTHON_EXECUTABLE)
......@@ -31,11 +31,32 @@
#include "vtkgl.h" // vtkgl namespace
#include "vtkShader2.h"
#include "vtkShaderProgram2.h"
#include "vtkUniformVariables.h"
#include "vtkShader2Collection.h"
#include <assert.h>
#ifndef VTK_IMPLEMENT_MESA_CXX
vtkCxxRevisionMacro(vtkOpenGLProperty, "1.46");
vtkCxxRevisionMacro(vtkOpenGLProperty, "1.47");
vtkStandardNewMacro(vtkOpenGLProperty);
#endif
extern const char *vtkOpenGLProperty_fs;
vtkOpenGLProperty::vtkOpenGLProperty()
{
this->Shader=0;
}
vtkOpenGLProperty::~vtkOpenGLProperty()
{
if(this->Shader!=0)
{
this->Shader->Delete();
}
}
//-----------------------------------------------------------------------------
// Implement base class method.
......@@ -47,22 +68,35 @@ void vtkOpenGLProperty::Render(vtkActor *anActor,
float Info[4];
GLenum Face;
double color[4];
// unbind any textures for starters
vtkOpenGLRenderer *oRenderer=static_cast<vtkOpenGLRenderer *>(ren);
if(oRenderer->GetDepthPeelingHigherLayer())
vtkShaderProgram2 *prog=oRenderer->GetShaderProgram();
if(prog!=0)
{
GLint uUseTexture=-1;
uUseTexture=oRenderer->GetUseTextureUniformVariable();
vtkgl::Uniform1i(uUseTexture,0);
// Even if the texture is not used, initialize the uniform variable
// so that, the program in use is in a valid state.
// Some OpenGL implementations (ex: ATI) check (which is good) if the same
// sample texture unit is not used with different sampler types.
GLint uTexture=oRenderer->GetTextureUniformVariable();
vtkgl::Uniform1i(uTexture,0); // active texture 0
if(this->Shader==0)
{
this->Shader=vtkShader2::New();
this->Shader->SetType(VTK_SHADER_TYPE_FRAGMENT);
this->Shader->SetSourceCode(vtkOpenGLProperty_fs);
vtkUniformVariables *v=this->Shader->GetUniformVariables();
int value;
value=0;
v->SetUniformi("useTexture",1,&value);
value=0;
v->SetUniformi("uTexture",1,&value);
}
prog->GetShaders()->AddItem(this->Shader);
assert("check: prog is initialized" && prog->GetContext()!=0);
this->Shader->SetContext(prog->GetContext());
prog->Use();
if(!prog->IsValid())
{
vtkErrorMacro(<<prog->GetLastValidateLog());
}
}
glDisable(GL_TEXTURE_2D);
// disable alpha testing (this may have been enabled
......@@ -219,8 +253,16 @@ void vtkOpenGLProperty::Render(vtkActor *anActor,
}
//-----------------------------------------------------------------------------
void vtkOpenGLProperty::PostRender(vtkActor* actor, vtkRenderer* renderer)
void vtkOpenGLProperty::PostRender(vtkActor *actor,
vtkRenderer *renderer)
{
vtkOpenGLRenderer *oRenderer=static_cast<vtkOpenGLRenderer *>(renderer);
vtkShaderProgram2 *prog=oRenderer->GetShaderProgram();
if(prog!=0)
{
prog->Restore();
prog->GetShaders()->RemoveItem(this->Shader);
}
this->Superclass::PostRender(actor, renderer);
// render any textures.
......@@ -373,6 +415,10 @@ void vtkOpenGLProperty::ReleaseGraphicsResources(vtkWindow *win)
}
this->Superclass::ReleaseGraphicsResources(win);
if(this->Shader!=0)
{
this->Shader->ReleaseGraphicsResources();
}
}
//----------------------------------------------------------------------------
......
......@@ -23,6 +23,7 @@
#include "vtkProperty.h"
class vtkOpenGLRenderer;
class vtkShader2;
class VTK_RENDERING_EXPORT vtkOpenGLProperty : public vtkProperty
{
......@@ -38,13 +39,14 @@ public:
// Description:
// Implement base class method.
void BackfaceRender(vtkActor *a, vtkRenderer *ren);
//BTX
// Description:
// This method is called after the actor has been rendered.
// Don't call this directly. This method cleans up
// any shaders allocated.
virtual void PostRender(vtkActor*, vtkRenderer*);
virtual void PostRender(vtkActor *a,
vtkRenderer *r);
//ETX
// Description:
......@@ -52,14 +54,16 @@ public:
// property. The parameter window could be used to determine which graphic
// resources to release.
virtual void ReleaseGraphicsResources(vtkWindow *win);
protected:
vtkOpenGLProperty() {};
~vtkOpenGLProperty() {};
vtkOpenGLProperty();
~vtkOpenGLProperty();
// Description:
// Load OpenGL extensions for multi texturing.
void LoadMultiTexturingExtensions(vtkRenderer* ren);
vtkShader2 *Shader;
private:
vtkOpenGLProperty(const vtkOpenGLProperty&); // Not implemented.
void operator=(const vtkOpenGLProperty&); // Not implemented.
......
// ============================================================================
//
// Program: Visualization Toolkit
// Module: vtkOpenGLProperty_fs.glsl
//
// 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.
//
// ============================================================================
// Default fragment shader used on property.
uniform int useTexture;
uniform sampler2D texture;
void propFuncFS()
{
if(useTexture==1)
{
gl_FragColor=gl_Color*texture2D(texture,gl_TexCoord[0].xy);
}
else
{
gl_FragColor=gl_Color;
}
}
......@@ -30,6 +30,8 @@ PURPOSE. See the above copyright notice for more information.
# include "vtkOpenGL.h"
#endif
#include "vtkShaderProgram2.h"
#include <math.h>
#include <assert.h>
#include <vtkstd/list>
......@@ -43,10 +45,12 @@ public:
};
#ifndef VTK_IMPLEMENT_MESA_CXX
vtkCxxRevisionMacro(vtkOpenGLRenderer, "1.92");
vtkCxxRevisionMacro(vtkOpenGLRenderer, "1.93");
vtkStandardNewMacro(vtkOpenGLRenderer);
#endif
vtkCxxSetObjectMacro(vtkOpenGLRenderer,ShaderProgram,vtkShaderProgram2);
#define VTK_MAX_LIGHTS 8
// List of rgba layers, id are 2D rectangle texture Ids.
......@@ -75,6 +79,8 @@ vtkOpenGLRenderer::vtkOpenGLRenderer()
this->ProgramShader=0;
this->DepthFormat=0;
this->DepthPeelingHigherLayer=0;
this->ShaderProgram=0;
}
// Internal method temporarily removes lights before reloading them
......@@ -1254,6 +1260,11 @@ vtkOpenGLRenderer::~vtkOpenGLRenderer()
this->PickInfo->PickBuffer = 0;
}
delete this->PickInfo;
if(this->ShaderProgram!=0)
{
this->ShaderProgram->Delete();
}
}
unsigned int vtkOpenGLRenderer::GetNumPickedIds()
......
......@@ -23,6 +23,7 @@
#include "vtkRenderer.h"
class vtkOpenGLRendererLayerList; // Pimpl
class vtkShaderProgram2;
class VTK_RENDERING_EXPORT vtkOpenGLRenderer : public vtkRenderer
{
......@@ -63,6 +64,13 @@ public:
// (Used by vtkOpenGLProperty or vtkOpenGLTexture)
int GetDepthPeelingHigherLayer();
//BTX
// Description:
//
vtkGetObjectMacro(ShaderProgram,vtkShaderProgram2);
virtual void SetShaderProgram(vtkShaderProgram2 *program);
//ETX
protected:
vtkOpenGLRenderer();
~vtkOpenGLRenderer();
......@@ -145,6 +153,8 @@ protected:
// (Used by vtkOpenGLProperty or vtkOpenGLTexture)
int DepthPeelingHigherLayer;
vtkShaderProgram2 *ShaderProgram;
private:
vtkOpenGLRenderer(const vtkOpenGLRenderer&); // Not implemented.
void operator=(const vtkOpenGLRenderer&); // Not implemented.
......
/*=========================================================================
Program: Visualization Toolkit
Module: vtkRenderPass.cxx
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 "vtkRenderPass.h"
#include <assert.h>
#include "vtkRenderer.h"
#include "vtkOpenGLRenderer.h"
vtkCxxRevisionMacro(vtkRenderPass, "1.1");
// ----------------------------------------------------------------------------
// Description:
// Default constructor. Do nothing.
vtkRenderPass::vtkRenderPass()
{
this->NumberOfRenderedProps=0;
}
// ----------------------------------------------------------------------------
// Description:
// Destructor. Do nothing.
vtkRenderPass::~vtkRenderPass()
{
}
// ----------------------------------------------------------------------------
// Description:
// Release graphics resources and ask components to release their own
// resources. Default implementation is empty.
// \pre w_exists: w!=0
void vtkRenderPass::ReleaseGraphicsResources(vtkWindow *w)
{
assert("pre: w_exists" && w!=0);
// empty implementation;
static_cast<void>(w); // avoid warning in release mode.
}
// ----------------------------------------------------------------------------
// Description:
// Call UpdateCamera() on Renderer. This ugly mechanism gives access to
// a protected method of Renderer to subclasses of vtkRenderPass.
// \pre renderer_exists: renderer!=0
void vtkRenderPass::UpdateCamera(vtkRenderer *renderer)
{
assert("pre: renderer_exists" && renderer!=0);
renderer->UpdateCamera();
}
// ----------------------------------------------------------------------------
// Description:
// Call ClearLights() on Renderer. See note about UpdateCamera().
// \pre renderer_exists: renderer!=0
void vtkRenderPass::ClearLights(vtkRenderer *renderer)
{
assert("pre: renderer_exists" && renderer!=0);
vtkOpenGLRenderer *oRenderer=static_cast<vtkOpenGLRenderer *>(renderer);
oRenderer->ClearLights();
}
// ----------------------------------------------------------------------------
// Description:
// Call UpdateLightGeometry() on Renderer. See note about UpdateCamera().
// \pre renderer_exists: renderer!=0
void vtkRenderPass::UpdateLightGeometry(vtkRenderer *renderer)
{
assert("pre: renderer_exists" && renderer!=0);
renderer->UpdateLightGeometry();
}
// ----------------------------------------------------------------------------
// Description:
// Call UpdateLights() on Renderer. See note about UpdateCamera().
// \pre renderer_exists: renderer!=0
void vtkRenderPass::UpdateLights(vtkRenderer *renderer)
{
assert("pre: renderer_exists" && renderer!=0);
renderer->UpdateLights();
}
// ----------------------------------------------------------------------------
void vtkRenderPass::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os,indent);
os << indent << "NumberOfRenderedProps:" << this->NumberOfRenderedProps
<< endl;
}
/*=========================================================================
Program: Visualization Toolkit
Module: vtkRenderPass.h
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.
=========================================================================*/
// .NAME vtkRenderPass - Perform part of the rendering of a vtkRenderer.
// .SECTION Description
// vtkRenderPass is a deferred class with a simple deferred method Render.
// This method performs a rendering pass of the scene described in
// vtkRenderState.
// Subclasses define what really happens during rendering.
//
// Directions to write a subclass of vtkRenderPass:
// It is up to the subclass to decide if it needs to delegate part of its job
// to some other vtkRenderPass objects ("delegates").
// - The subclass has to define ivar to set/get its delegates.
// - The documentation of the subclass has to describe:
// -- what each delegate is supposed to perform
// -- if a delegate is supposed to be used once or multiple times
// -- what it expects to have in the framebuffer before starting (status
// of colorbuffers, depth buffer, stencil buffer)
// -- what it will change in the framebuffer.
// - A pass cannot modify the vtkRenderState where it will perform but
// it can build a new vtkRenderState (it can change the FrameBuffer, change the
// prop array, changed the required prop properties keys (usually adding some
// to a copy of the existing list) but it has to keep the same vtkRenderer
// object), make it current and pass it to its delegate.
// - at the end of the execution of Render, the pass has to ensure the
// current vtkRenderState is the one it has in argument.
// .SECTION See Also
// vtkRenderState vtkRenderer
#ifndef __vtkRenderPass_h
#define __vtkRenderPass_h