1 /*=========================================================================
2 
3   Program:   Visualization Toolkit
4   Module:    vtkDefaultPass.cxx
5 
6   Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7   All rights reserved.
8   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10      This software is distributed WITHOUT ANY WARRANTY; without even
11      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12      PURPOSE.  See the above copyright notice for more information.
13 
14 =========================================================================*/
15 
16 #include "vtkDefaultPass.h"
17 #include "vtkObjectFactory.h"
18 #include "vtkProp.h"
19 #include "vtkRenderState.h"
20 #include "vtkRenderer.h"
21 #include <cassert>
22 
23 vtkStandardNewMacro(vtkDefaultPass);
24 
25 //------------------------------------------------------------------------------
26 vtkDefaultPass::vtkDefaultPass() = default;
27 
28 //------------------------------------------------------------------------------
29 vtkDefaultPass::~vtkDefaultPass() = default;
30 
31 //------------------------------------------------------------------------------
PrintSelf(ostream & os,vtkIndent indent)32 void vtkDefaultPass::PrintSelf(ostream& os, vtkIndent indent)
33 {
34   this->Superclass::PrintSelf(os, indent);
35 }
36 
37 //------------------------------------------------------------------------------
38 // Description:
39 // Perform rendering according to a render state \p s.
40 // \pre s_exists: s!=0
Render(const vtkRenderState * s)41 void vtkDefaultPass::Render(const vtkRenderState* s)
42 {
43   assert("pre: s_exists" && s != nullptr);
44 
45   this->NumberOfRenderedProps = 0;
46   this->RenderOpaqueGeometry(s);
47   this->RenderTranslucentPolygonalGeometry(s);
48   this->RenderVolumetricGeometry(s);
49   this->RenderOverlay(s);
50 }
51 
52 //------------------------------------------------------------------------------
53 // Description:
54 // Opaque pass without key checking.
55 // \pre s_exists: s!=0
RenderOpaqueGeometry(const vtkRenderState * s)56 void vtkDefaultPass::RenderOpaqueGeometry(const vtkRenderState* s)
57 {
58   assert("pre s_exits" && s != nullptr);
59 
60   int c = s->GetPropArrayCount();
61   int i = 0;
62   while (i < c)
63   {
64     int rendered = s->GetPropArray()[i]->RenderOpaqueGeometry(s->GetRenderer());
65     this->NumberOfRenderedProps += rendered;
66     ++i;
67   }
68 }
69 
70 //------------------------------------------------------------------------------
71 // Description:
72 // Opaque pass with key checking.
73 // \pre s_exists: s!=0
RenderFilteredOpaqueGeometry(const vtkRenderState * s)74 void vtkDefaultPass::RenderFilteredOpaqueGeometry(const vtkRenderState* s)
75 {
76   assert("pre: s_exists" && s != nullptr);
77 
78   int c = s->GetPropArrayCount();
79   int i = 0;
80   while (i < c)
81   {
82     vtkProp* p = s->GetPropArray()[i];
83     if (p->HasKeys(s->GetRequiredKeys()))
84     {
85       int rendered = p->RenderFilteredOpaqueGeometry(s->GetRenderer(), s->GetRequiredKeys());
86       this->NumberOfRenderedProps += rendered;
87     }
88     ++i;
89   }
90 }
91 
92 //------------------------------------------------------------------------------
93 // Description:
94 // Translucent pass without key checking.
95 // \pre s_exists: s!=0
RenderTranslucentPolygonalGeometry(const vtkRenderState * s)96 void vtkDefaultPass::RenderTranslucentPolygonalGeometry(const vtkRenderState* s)
97 {
98   assert("pre: s_exists" && s != nullptr);
99 
100   int c = s->GetPropArrayCount();
101   int i = 0;
102   while (i < c)
103   {
104     vtkProp* p = s->GetPropArray()[i];
105     int rendered = p->RenderTranslucentPolygonalGeometry(s->GetRenderer());
106     this->NumberOfRenderedProps += rendered;
107     ++i;
108   }
109 }
110 
111 //------------------------------------------------------------------------------
112 // Description:
113 // Translucent pass with key checking.
114 // \pre s_exists: s!=0
RenderFilteredTranslucentPolygonalGeometry(const vtkRenderState * s)115 void vtkDefaultPass::RenderFilteredTranslucentPolygonalGeometry(const vtkRenderState* s)
116 {
117   assert("pre: s_exists" && s != nullptr);
118 
119   int c = s->GetPropArrayCount();
120   int i = 0;
121   while (i < c)
122   {
123     vtkProp* p = s->GetPropArray()[i];
124     if (p->HasKeys(s->GetRequiredKeys()))
125     {
126       int rendered =
127         p->RenderFilteredTranslucentPolygonalGeometry(s->GetRenderer(), s->GetRequiredKeys());
128       this->NumberOfRenderedProps += rendered;
129     }
130     ++i;
131   }
132 }
133 
134 //------------------------------------------------------------------------------
135 // Description:
136 // Volume pass without key checking.
137 // \pre s_exists: s!=0
RenderVolumetricGeometry(const vtkRenderState * s)138 void vtkDefaultPass::RenderVolumetricGeometry(const vtkRenderState* s)
139 {
140   assert("pre: s_exists" && s != nullptr);
141 
142   int c = s->GetPropArrayCount();
143   int i = 0;
144   while (i < c)
145   {
146     int rendered = s->GetPropArray()[i]->RenderVolumetricGeometry(s->GetRenderer());
147     this->NumberOfRenderedProps += rendered;
148     ++i;
149   }
150 }
151 
152 //------------------------------------------------------------------------------
153 // Description:
154 // Translucent pass with key checking.
155 // \pre s_exists: s!=0
RenderFilteredVolumetricGeometry(const vtkRenderState * s)156 void vtkDefaultPass::RenderFilteredVolumetricGeometry(const vtkRenderState* s)
157 {
158   assert("pre: s_exists" && s != nullptr);
159 
160   int c = s->GetPropArrayCount();
161   int i = 0;
162   while (i < c)
163   {
164     vtkProp* p = s->GetPropArray()[i];
165     if (p->HasKeys(s->GetRequiredKeys()))
166     {
167       int rendered = p->RenderFilteredVolumetricGeometry(s->GetRenderer(), s->GetRequiredKeys());
168       this->NumberOfRenderedProps += rendered;
169     }
170     ++i;
171   }
172 }
173 
174 //------------------------------------------------------------------------------
175 // Description:
176 // Overlay pass without key checking.
177 // \pre s_exists: s!=0
RenderOverlay(const vtkRenderState * s)178 void vtkDefaultPass::RenderOverlay(const vtkRenderState* s)
179 {
180   assert("pre: s_exists" && s != nullptr);
181 
182   int c = s->GetPropArrayCount();
183   int i = 0;
184   while (i < c)
185   {
186     int rendered = s->GetPropArray()[i]->RenderOverlay(s->GetRenderer());
187     this->NumberOfRenderedProps += rendered;
188     ++i;
189   }
190 }
191 
192 //------------------------------------------------------------------------------
193 // Description:
194 // Overlay pass with key checking.
195 // \pre s_exists: s!=0
RenderFilteredOverlay(const vtkRenderState * s)196 void vtkDefaultPass::RenderFilteredOverlay(const vtkRenderState* s)
197 {
198   assert("pre: s_exists" && s != nullptr);
199 
200   int c = s->GetPropArrayCount();
201   int i = 0;
202   while (i < c)
203   {
204     vtkProp* p = s->GetPropArray()[i];
205     if (p->HasKeys(s->GetRequiredKeys()))
206     {
207       int rendered = p->RenderFilteredOverlay(s->GetRenderer(), s->GetRequiredKeys());
208       this->NumberOfRenderedProps += rendered;
209     }
210     ++i;
211   }
212 }
213