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)32void 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)41void 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)56void 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)74void 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)96void 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)115void 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)138void 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)156void 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)178void 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)196void 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