| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27
28 // /vis/geometry commands - John Allison 31st
29
30 #include "G4VisCommandsGeometrySet.hh"
31
32 #include "G4UIcommand.hh"
33 #include "G4VisManager.hh"
34 #include "G4LogicalVolumeStore.hh"
35 #include "G4UImanager.hh"
36
37 #include <sstream>
38
39 #define G4warn G4cout
40
41 void G4VVisCommandGeometrySet::Set
42 (const G4String& requestedName,
43 const G4VVisCommandGeometrySetFunction& setFu
44 G4int requestedDepth)
45 {
46 G4VisManager::Verbosity verbosity = fpVisMan
47 G4LogicalVolumeStore* pLVStore = G4LogicalVo
48 G4bool found = false;
49 for (std::size_t iLV = 0; iLV < pLVStore->si
50 G4LogicalVolume* pLV = (*pLVStore)[iLV];
51 const G4String& logVolName = pLV->GetName(
52 if (logVolName == requestedName) found = t
53 if (requestedName == "all" || logVolName =
54 SetLVVisAtts(pLV, setFunction, 0, reques
55 }
56 }
57 if (requestedName != "all" && !found) {
58 if (verbosity >= G4VisManager::errors) {
59 G4warn << "ERROR: Logical volume \"" <<
60 << "\" not found in logical volume stor
61 }
62 return;
63 }
64 // Recalculate extent of any physical volume
65 for (const auto& scene : fpVisManager->GetSc
66 const auto& runDurationModelList = scene->
67 for (const auto& sceneModel : runDurationM
68 auto model = sceneModel.fpModel;
69 auto pvModel = dynamic_cast<G4PhysicalVo
70 if (pvModel) pvModel->CalculateExtent();
71 }
72 // And re-calculate the scene's extent
73 scene->CalculateExtent();
74 }
75 if (fpVisManager->GetCurrentViewer()) {
76 G4UImanager::GetUIpointer()->ApplyCommand(
77 }
78 }
79
80 void G4VVisCommandGeometrySet::SetLVVisAtts
81 (G4LogicalVolume* pLV,
82 const G4VVisCommandGeometrySetFunction& setFu
83 G4int depth, G4int requestedDepth)
84 {
85 G4VisManager::Verbosity verbosity = fpVisMan
86 const G4VisAttributes* oldVisAtts = pLV->Get
87 fVisAttsMap.insert(std::make_pair(pLV,oldVis
88 G4VisAttributes* newVisAtts = new G4VisAttri
89 if (oldVisAtts) {
90 *newVisAtts = *oldVisAtts;
91 }
92 setFunction(newVisAtts); // Sets whatever a
93 // function object.
94 pLV->SetVisAttributes(newVisAtts);
95 if (verbosity >= G4VisManager::confirmations
96 G4cout << "\nLogical Volume \"" << pLV->Ge
97 << "\": setting vis attributes:";
98 if (oldVisAtts) {
99 G4cout << "\nwas: " << *oldVisAtts;
100 } else {
101 G4cout << "\n(no old attributes)";
102 }
103 G4cout << "\nnow: " << *newVisAtts
104 << G4endl;
105 }
106 if (requestedDepth < 0 || depth < requestedD
107 G4int nDaughters = (G4int)pLV->GetNoDaught
108 for (G4int i = 0; i < nDaughters; ++i) {
109 SetLVVisAtts(pLV->GetDaughter(i)->GetLog
110 setFunction, ++depth, requestedDepth);
111 }
112 }
113 }
114
115 ////////////// /vis/geometry/set/colour //////
116
117 G4VisCommandGeometrySetColour::G4VisCommandGeo
118 {
119 G4bool omitable;
120 fpCommand = new G4UIcommand("/vis/geometry/s
121 fpCommand->SetGuidance("Sets colour of logic
122 fpCommand->SetGuidance("\"all\" sets all log
123 fpCommand->SetGuidance
124 ("Optionally propagates down hierarchy to
125 G4UIparameter* parameter;
126 parameter = new G4UIparameter ("logical-volu
127 parameter->SetDefaultValue("all");
128 fpCommand->SetParameter(parameter);
129 parameter = new G4UIparameter("depth", 'd',
130 parameter->SetDefaultValue(0);
131 parameter->SetGuidance
132 ("Depth of propagation (-1 means unlimited
133 fpCommand->SetParameter(parameter);
134 parameter = new G4UIparameter("red", 's', om
135 parameter->SetDefaultValue("1.");
136 parameter->SetGuidance
137 ("Red component or a string, e.g., \"blue\
138 fpCommand->SetParameter(parameter);
139 parameter = new G4UIparameter("green", 'd',
140 parameter->SetDefaultValue(1.);
141 fpCommand->SetParameter(parameter);
142 parameter = new G4UIparameter("blue", 'd', o
143 parameter->SetDefaultValue(1.);
144 fpCommand->SetParameter(parameter);
145 parameter = new G4UIparameter("opacity", 'd'
146 parameter->SetDefaultValue(1.);
147 fpCommand->SetParameter(parameter);
148 }
149
150 G4VisCommandGeometrySetColour::~G4VisCommandGe
151 {
152 delete fpCommand;
153 }
154
155 G4String G4VisCommandGeometrySetColour::GetCur
156 {
157 return "";
158 }
159
160 void G4VisCommandGeometrySetColour::SetNewValu
161 (G4UIcommand*, G4String newValue)
162 {
163 G4String name, redOrString;
164 G4int requestedDepth;
165 G4double green, blue, opacity;
166 std::istringstream iss(newValue);
167 iss >> name >> requestedDepth >> redOrString
168 G4Colour colour(1,1,1,1); // Default white
169 ConvertToColour(colour, redOrString, green,
170 G4VisCommandGeometrySetColourFunction setCol
171 Set(name, setColour, requestedDepth);
172 }
173
174 ////////////// /vis/geometry/set/daughtersInvi
175
176 G4VisCommandGeometrySetDaughtersInvisible::G4V
177 {
178 G4bool omitable;
179 fpCommand = new G4UIcommand("/vis/geometry/s
180 fpCommand->SetGuidance("Makes daughters of l
181 fpCommand->SetGuidance("\"all\" sets all log
182 fpCommand->SetGuidance
183 ("Optionally propagates down hierarchy to
184 G4UIparameter* parameter;
185 parameter = new G4UIparameter ("logical-volu
186 parameter->SetDefaultValue("all");
187 fpCommand->SetParameter(parameter);
188 parameter = new G4UIparameter("depth", 'd',
189 parameter->SetDefaultValue(0);
190 parameter->SetGuidance
191 ("Depth of propagation (-1 means unlimited
192 fpCommand->SetParameter(parameter);
193 parameter = new G4UIparameter("daughtersInvi
194 parameter->SetDefaultValue(true);
195 fpCommand->SetParameter(parameter);
196 }
197
198 G4VisCommandGeometrySetDaughtersInvisible::~G4
199 {
200 delete fpCommand;
201 }
202
203 G4String
204 G4VisCommandGeometrySetDaughtersInvisible::Get
205 {
206 return "";
207 }
208
209 void G4VisCommandGeometrySetDaughtersInvisible
210 (G4UIcommand*, G4String newValue)
211 {
212 G4String name;
213 G4int requestedDepth;
214 G4String daughtersInvisibleString;
215 std::istringstream iss(newValue);
216 iss >> name >> requestedDepth >> daughtersIn
217 G4bool daughtersInvisible =
218 G4UIcommand::ConvertToBool(daughtersInvisi
219
220 if (requestedDepth !=0) {
221 requestedDepth = 0;
222 if (fpVisManager->GetVerbosity() >= G4VisM
223 G4warn << "Recursive application suppres
224 << G4endl;
225 }
226 }
227
228 G4VisCommandGeometrySetDaughtersInvisibleFun
229 setDaughtersInvisible(daughtersInvisible);
230 Set(name, setDaughtersInvisible, requestedDe
231
232 G4VViewer* pViewer = fpVisManager->GetCurren
233 if (pViewer) {
234 const G4ViewParameters& viewParams = pView
235 if (fpVisManager->GetVerbosity() >= G4VisM
236 if (!viewParams.IsCulling()) {
237 G4warn <<
238 "Culling must be on - \"/vis/viewer/set/cu
239 << G4endl;
240 }
241 }
242 }
243 }
244
245 ////////////// /vis/geometry/set/forceAuxEdgeV
246
247 G4VisCommandGeometrySetForceAuxEdgeVisible::G4
248 {
249 G4bool omitable;
250 fpCommand = new G4UIcommand("/vis/geometry/s
251 fpCommand->SetGuidance
252 ("Forces auxiliary (soft) edges of logical
253 "\nregardless of the view parameters.");
254 fpCommand->SetGuidance("\"all\" sets all log
255 fpCommand->SetGuidance
256 ("Optionally propagates down hierarchy to
257 G4UIparameter* parameter;
258 parameter = new G4UIparameter ("logical-volu
259 parameter->SetDefaultValue("all");
260 fpCommand->SetParameter(parameter);
261 parameter = new G4UIparameter("depth", 'd',
262 parameter->SetDefaultValue(0);
263 parameter->SetGuidance
264 ("Depth of propagation (-1 means unlimited
265 fpCommand->SetParameter(parameter);
266 parameter = new G4UIparameter("forceAuxEdgeV
267 parameter->SetDefaultValue(true);
268 fpCommand->SetParameter(parameter);
269 }
270
271 G4VisCommandGeometrySetForceAuxEdgeVisible::~G
272 {
273 delete fpCommand;
274 }
275
276 G4String
277 G4VisCommandGeometrySetForceAuxEdgeVisible::Ge
278 {
279 return "";
280 }
281
282 void G4VisCommandGeometrySetForceAuxEdgeVisibl
283 (G4UIcommand*, G4String newValue)
284 {
285 G4String name;
286 G4int requestedDepth;
287 G4String forceAuxEdgeVisibleString;
288 std::istringstream iss(newValue);
289 iss >> name >> requestedDepth >> forceAuxEdg
290 G4bool forceAuxEdgeVisible =
291 G4UIcommand::ConvertToBool(forceAuxEdgeVis
292
293 G4VisCommandGeometrySetForceAuxEdgeVisibleFu
294 setForceAuxEdgeVisible(forceAuxEdgeVisible
295 Set(name, setForceAuxEdgeVisible, requestedD
296 }
297
298 ////////////// /vis/geometry/set/forceCloud //
299
300 G4VisCommandGeometrySetForceCloud::G4VisComman
301 {
302 G4bool omitable;
303 fpCommand = new G4UIcommand("/vis/geometry/s
304 fpCommand->SetGuidance
305 ("Forces logical volume(s) always to be draw
306 "\nregardless of the view parameters.");
307 fpCommand->SetGuidance("\"all\" sets all log
308 fpCommand->SetGuidance
309 ("Optionally propagates down hierarchy to
310 G4UIparameter* parameter;
311 parameter = new G4UIparameter ("logical-volu
312 parameter->SetDefaultValue("all");
313 fpCommand->SetParameter(parameter);
314 parameter = new G4UIparameter("depth", 'd',
315 parameter->SetDefaultValue(0);
316 parameter->SetGuidance
317 ("Depth of propagation (-1 means unlimited
318 fpCommand->SetParameter(parameter);
319 parameter = new G4UIparameter("forceCloud",
320 parameter->SetDefaultValue(true);
321 fpCommand->SetParameter(parameter);
322 parameter = new G4UIparameter("nPoints", 'd'
323 parameter->SetGuidance
324 ("<= 0 means under control of viewer.");
325 parameter->SetDefaultValue(0);
326 fpCommand->SetParameter(parameter);
327 }
328
329 G4VisCommandGeometrySetForceCloud::~G4VisComma
330 {
331 delete fpCommand;
332 }
333
334 G4String
335 G4VisCommandGeometrySetForceCloud::GetCurrentV
336 {
337 return "";
338 }
339
340 void G4VisCommandGeometrySetForceCloud::SetNew
341 (G4UIcommand*, G4String newValue)
342 {
343 G4String name, forceCloudString;
344 G4int requestedDepth, nPoints;
345 std::istringstream iss(newValue);
346 iss >> name >> requestedDepth >> forceCloudS
347 G4bool forceCloud = G4UIcommand::ConvertToBo
348
349 G4VisCommandGeometrySetForceCloudFunction se
350 Set(name, setForceCloud, requestedDepth);
351 }
352
353 ////////////// /vis/geometry/set/forceLineSegm
354
355 G4VisCommandGeometrySetForceLineSegmentsPerCir
356 {
357 G4bool omitable;
358 fpCommand = new G4UIcommand("/vis/geometry/s
359 fpCommand->SetGuidance
360 ("Forces number of line segments per circl
361 "\ncurved line or surface is represented
362 "\nregardless of the view parameters.");
363 fpCommand->SetGuidance("\"all\" sets all log
364 fpCommand->SetGuidance
365 ("Optionally propagates down hierarchy to
366 G4UIparameter* parameter;
367 parameter = new G4UIparameter ("logical-volu
368 parameter->SetDefaultValue("all");
369 fpCommand->SetParameter(parameter);
370 parameter = new G4UIparameter("depth", 'd',
371 parameter->SetDefaultValue(0);
372 parameter->SetGuidance
373 ("Depth of propagation (-1 means unlimited
374 fpCommand->SetParameter(parameter);
375 parameter = new G4UIparameter("lineSegmentsP
376 parameter->SetGuidance
377 ("<= 0 means not forced, i.e., under contr
378 parameter->SetDefaultValue(0);
379 fpCommand->SetParameter(parameter);
380 }
381
382 G4VisCommandGeometrySetForceLineSegmentsPerCir
383 {
384 delete fpCommand;
385 }
386
387 G4String
388 G4VisCommandGeometrySetForceLineSegmentsPerCir
389 {
390 return "";
391 }
392
393 void G4VisCommandGeometrySetForceLineSegmentsP
394 (G4UIcommand*, G4String newValue)
395 {
396 G4String name;
397 G4int requestedDepth;
398 G4int lineSegmentsPerCircle;
399 std::istringstream iss(newValue);
400 iss >> name >> requestedDepth >> lineSegment
401
402 G4VisCommandGeometrySetForceLineSegmentsPerC
403 setForceLineSegmentsPerCircle(lineSegmentsPe
404 Set(name, setForceLineSegmentsPerCircle, req
405 }
406
407 ////////////// /vis/geometry/set/forceSolid //
408
409 G4VisCommandGeometrySetForceSolid::G4VisComman
410 {
411 G4bool omitable;
412 fpCommand = new G4UIcommand("/vis/geometry/s
413 fpCommand->SetGuidance
414 ("Forces logical volume(s) always to be dra
415 "\nregardless of the view parameters.");
416 fpCommand->SetGuidance("\"all\" sets all log
417 fpCommand->SetGuidance
418 ("Optionally propagates down hierarchy to
419 G4UIparameter* parameter;
420 parameter = new G4UIparameter ("logical-volu
421 parameter->SetDefaultValue("all");
422 fpCommand->SetParameter(parameter);
423 parameter = new G4UIparameter("depth", 'd',
424 parameter->SetDefaultValue(0);
425 parameter->SetGuidance
426 ("Depth of propagation (-1 means unlimited
427 fpCommand->SetParameter(parameter);
428 parameter = new G4UIparameter("force", 'b',
429 parameter->SetDefaultValue(true);
430 fpCommand->SetParameter(parameter);
431 }
432
433 G4VisCommandGeometrySetForceSolid::~G4VisComma
434 {
435 delete fpCommand;
436 }
437
438 G4String
439 G4VisCommandGeometrySetForceSolid::GetCurrentV
440 {
441 return "";
442 }
443
444 void G4VisCommandGeometrySetForceSolid::SetNew
445 (G4UIcommand*, G4String newValue)
446 {
447 G4String name;
448 G4int requestedDepth;
449 G4String forceString;
450 std::istringstream iss(newValue);
451 iss >> name >> requestedDepth >> forceString
452 G4bool force = G4UIcommand::ConvertToBool(fo
453
454 G4VisCommandGeometrySetForceSolidFunction se
455 Set(name, setForceSolid, requestedDepth);
456 }
457
458 ////////////// /vis/geometry/set/forceWirefram
459
460 G4VisCommandGeometrySetForceWireframe::G4VisCo
461 {
462 G4bool omitable;
463 fpCommand = new G4UIcommand("/vis/geometry/s
464 fpCommand->SetGuidance
465 ("Forces logical volume(s) always to be dra
466 "\nregardless of the view parameters.");
467 fpCommand->SetGuidance("\"all\" sets all log
468 fpCommand->SetGuidance
469 ("Optionally propagates down hierarchy to
470 G4UIparameter* parameter;
471 parameter = new G4UIparameter ("logical-volu
472 parameter->SetDefaultValue("all");
473 fpCommand->SetParameter(parameter);
474 parameter = new G4UIparameter("depth", 'd',
475 parameter->SetDefaultValue(0);
476 parameter->SetGuidance
477 ("Depth of propagation (-1 means unlimited
478 fpCommand->SetParameter(parameter);
479 parameter = new G4UIparameter("forceWirefram
480 parameter->SetDefaultValue(true);
481 fpCommand->SetParameter(parameter);
482 }
483
484 G4VisCommandGeometrySetForceWireframe::~G4VisC
485 {
486 delete fpCommand;
487 }
488
489 G4String
490 G4VisCommandGeometrySetForceWireframe::GetCurr
491 {
492 return "";
493 }
494
495 void G4VisCommandGeometrySetForceWireframe::Se
496 (G4UIcommand*, G4String newValue)
497 {
498 G4String name;
499 G4int requestedDepth;
500 G4String forceWireframeString;
501 std::istringstream iss(newValue);
502 iss >> name >> requestedDepth >> forceWirefr
503 G4bool forceWireframe = G4UIcommand::Convert
504
505 G4VisCommandGeometrySetForceWireframeFunctio
506 setForceWireframe(forceWireframe);
507 Set(name, setForceWireframe, requestedDepth)
508 }
509
510 ////////////// /vis/geometry/set/lineStyle ///
511
512 G4VisCommandGeometrySetLineStyle::G4VisCommand
513 {
514 G4bool omitable;
515 fpCommand = new G4UIcommand("/vis/geometry/s
516 fpCommand->SetGuidance("Sets line style of l
517 fpCommand->SetGuidance("\"all\" sets all log
518 fpCommand->SetGuidance
519 ("Optionally propagates down hierarchy to
520 G4UIparameter* parameter;
521 parameter = new G4UIparameter ("logical-volu
522 parameter->SetDefaultValue("all");
523 fpCommand->SetParameter(parameter);
524 parameter = new G4UIparameter("depth", 'd',
525 parameter->SetDefaultValue(0);
526 parameter->SetGuidance
527 ("Depth of propagation (-1 means unlimited
528 fpCommand->SetParameter(parameter);
529 parameter = new G4UIparameter("lineStyle", '
530 parameter->SetParameterCandidates("unbroken
531 parameter->SetDefaultValue("unbroken");
532 fpCommand->SetParameter(parameter);
533 }
534
535 G4VisCommandGeometrySetLineStyle::~G4VisComman
536 {
537 delete fpCommand;
538 }
539
540 G4String
541 G4VisCommandGeometrySetLineStyle::GetCurrentVa
542 {
543 return "";
544 }
545
546 void G4VisCommandGeometrySetLineStyle::SetNewV
547 (G4UIcommand*, G4String newValue)
548 {
549 G4String name, lineStyleString;
550 G4int requestedDepth;
551 std::istringstream iss(newValue);
552 iss >> name >> requestedDepth >> lineStyleSt
553 G4VisAttributes::LineStyle lineStyle = G4Vis
554 if (lineStyleString == "unbroken") lineStyle
555 if (lineStyleString == "dashed") lineStyle =
556 if (lineStyleString == "dotted") lineStyle =
557
558 G4VisCommandGeometrySetLineStyleFunction set
559 Set(name, setLineStyle, requestedDepth);
560 }
561
562 ////////////// /vis/geometry/set/lineWidth ///
563
564 G4VisCommandGeometrySetLineWidth::G4VisCommand
565 {
566 G4bool omitable;
567 fpCommand = new G4UIcommand("/vis/geometry/s
568 fpCommand->SetGuidance("Sets line width of l
569 fpCommand->SetGuidance("\"all\" sets all log
570 fpCommand->SetGuidance
571 ("Optionally propagates down hierarchy to
572 G4UIparameter* parameter;
573 parameter = new G4UIparameter ("logical-volu
574 parameter->SetDefaultValue("all");
575 fpCommand->SetParameter(parameter);
576 parameter = new G4UIparameter("depth", 'd',
577 parameter->SetDefaultValue(0);
578 parameter->SetGuidance
579 ("Depth of propagation (-1 means unlimited
580 fpCommand->SetParameter(parameter);
581 parameter = new G4UIparameter("lineWidth", '
582 parameter->SetDefaultValue(1.);
583 fpCommand->SetParameter(parameter);
584 }
585
586 G4VisCommandGeometrySetLineWidth::~G4VisComman
587 {
588 delete fpCommand;
589 }
590
591 G4String
592 G4VisCommandGeometrySetLineWidth::GetCurrentVa
593 {
594 return "";
595 }
596
597 void G4VisCommandGeometrySetLineWidth::SetNewV
598 (G4UIcommand*, G4String newValue)
599 {
600 G4String name;
601 G4int requestedDepth;
602 G4double lineWidth;
603 std::istringstream iss(newValue);
604 iss >> name >> requestedDepth >> lineWidth;
605
606 G4VisCommandGeometrySetLineWidthFunction set
607 Set(name, setLineWidth, requestedDepth);
608 }
609
610 ////////////// /vis/geometry/set/visibility //
611
612 G4VisCommandGeometrySetVisibility::G4VisComman
613 {
614 G4bool omitable;
615 fpCommand = new G4UIcommand("/vis/geometry/s
616 fpCommand->SetGuidance("Sets visibility of l
617 fpCommand->SetGuidance("\"all\" sets all log
618 fpCommand->SetGuidance
619 ("Optionally propagates down hierarchy to
620 G4UIparameter* parameter;
621 parameter = new G4UIparameter ("logical-volu
622 parameter->SetDefaultValue("all");
623 fpCommand->SetParameter(parameter);
624 parameter = new G4UIparameter("depth", 'd',
625 parameter->SetDefaultValue(0);
626 parameter->SetGuidance
627 ("Depth of propagation (-1 means unlimited
628 fpCommand->SetParameter(parameter);
629 parameter = new G4UIparameter("visibility",
630 parameter->SetDefaultValue(true);
631 fpCommand->SetParameter(parameter);
632 }
633
634 G4VisCommandGeometrySetVisibility::~G4VisComma
635 {
636 delete fpCommand;
637 }
638
639 G4String G4VisCommandGeometrySetVisibility::Ge
640 {
641 return "";
642 }
643
644 void G4VisCommandGeometrySetVisibility::SetNew
645 (G4UIcommand*, G4String newValue)
646 {
647 G4String name;
648 G4int requestedDepth;
649 G4String visibilityString;
650 std::istringstream iss(newValue);
651 iss >> name >> requestedDepth >> visibilityS
652 G4bool visibility = G4UIcommand::ConvertToBo
653
654 G4VisCommandGeometrySetVisibilityFunction se
655 Set(name, setVisibility, requestedDepth);
656
657 G4VViewer* pViewer = fpVisManager->GetCurren
658 if (pViewer) {
659 const G4ViewParameters& viewParams = pView
660 if (fpVisManager->GetVerbosity() >= G4VisM
661 if (!viewParams.IsCulling() ||
662 !viewParams.IsCullingInvisible()) {
663 G4warn <<
664 "Culling must be on - \"/vis/viewer/set/cu
665 "\n \"/vis/viewer/set/culling invisible t
666 << G4endl;
667 }
668 }
669 }
670 }
671
672 void G4VisCommandGeometrySetVisibility::SetNew
673 (G4LogicalVolume* pLV, G4int requestedDepth,G4
674 {
675 if (!pLV) return;
676 G4VisCommandGeometrySetVisibilityFunction se
677 SetLVVisAtts(pLV, setVisibility, 0, requeste
678
679 G4VViewer* pViewer = fpVisManager->GetCurren
680 if (pViewer) {
681 G4UImanager::GetUIpointer()->ApplyCommand(
682 const G4ViewParameters& viewParams = pView
683 if (fpVisManager->GetVerbosity() >= G4VisM
684 if (!viewParams.IsCulling() ||
685 !viewParams.IsCullingInvisible()) {
686 G4warn <<
687 "Culling must be on - \"/vis/viewer/set/cu
688 "\n \"/vis/viewer/set/culling invisible t
689 << G4endl;
690 }
691 }
692 }
693 }
694