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 // John Allison 17th June 2019 27 28 #include "G4Qt3DSceneHandler.hh" 29 30 #include "G4PhysicalVolumeModel.hh" 31 #include "G4LogicalVolumeModel.hh" 32 #include "G4VPhysicalVolume.hh" 33 #include "G4LogicalVolume.hh" 34 #include "G4TransportationManager.hh" 35 #include "G4Box.hh" 36 #include "G4Polyline.hh" 37 #include "G4Polymarker.hh" 38 #include "G4Text.hh" 39 #include "G4Circle.hh" 40 #include "G4Square.hh" 41 #include "G4Polyhedron.hh" 42 #include "G4Scene.hh" 43 #include "G4Threading.hh" 44 #include "G4Mesh.hh" 45 #include "G4PseudoScene.hh" 46 #include "G4VisManager.hh" 47 48 #include "G4Qt3DViewer.hh" 49 #include "G4Qt3DUtils.hh" 50 #include "G4Qt3DQEntity.hh" 51 52 #include <Qt3DCore> 53 #include <Qt3DExtras> 54 #include <Qt3DRender> 55 56 #include <utility> 57 58 #define G4warn G4cout 59 60 // Qt3D seems to offer a choice of type - floa 61 // to use double since it offers the prospect 62 // avoiding some issues that we see at high zo 63 // following warning: 64 // Qt5: "findBoundingVolumeComputeData: Positi 65 // suited for bounding volume computation", 66 // Qt6: "Failed to build graphics pipeline: Ge 67 // An attribute type is not supported "vertexP 68 // so for now we use float. 69 #define PRECISION float 70 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) 71 #define BASETYPE Qt3DRender::QAttribute::Float 72 #else 73 #define BASETYPE Qt3DCore::QAttribute::Float 74 #endif 75 76 // Qt3D types move between namespaces between 77 namespace G4Qt3DCompat 78 { 79 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) 80 using Qt3DRender::QAttribute; 81 using Qt3DRender::QBuffer; 82 using Qt3DRender::QGeometry; 83 #else 84 using Qt3DCore::QAttribute; 85 using Qt3DCore::QBuffer; 86 using Qt3DCore::QGeometry; 87 #endif 88 } 89 90 G4int G4Qt3DSceneHandler::fSceneIdCount = 0; 91 92 G4Qt3DSceneHandler::G4Qt3DSceneHandler 93 (G4VGraphicsSystem& system, const G4String& n 94 : G4VSceneHandler(system, fSceneIdCount++, nam 95 ,fpQt3DScene(nullptr) 96 ,fpTransientObjects(nullptr) 97 ,fpPersistentObjects(nullptr) 98 { 99 #ifdef G4QT3DDEBUG 100 G4cout << "G4Qt3DSceneHandler::G4Qt3DSceneHa 101 #endif 102 fpQt3DScene = new Qt3DCore::QEntity; 103 fpQt3DScene->setObjectName("G4Qt3DSceneRoot" 104 EstablishG4Qt3DQEntities(); 105 } 106 107 G4Qt3DSceneHandler::~G4Qt3DSceneHandler() 108 { 109 if (fpQt3DScene) { 110 G4Qt3DUtils::delete_components_and_childre 111 delete fpQt3DScene; 112 } 113 } 114 115 void G4Qt3DSceneHandler::EstablishG4Qt3DQEntit 116 { 117 fpTransientObjects = new G4Qt3DQEntity(fpQt 118 fpTransientObjects ->setObjectName("G4Qt3DT 119 fpPersistentObjects = new G4Qt3DQEntity(fpQt 120 fpPersistentObjects ->setObjectName("G4Qt3DP 121 122 // Physical volume objects hang from POs 123 fpPhysicalVolumeObjects.clear(); 124 if (fpScene) { 125 const auto& sceneModels = fpScene->GetRunD 126 for (const auto& sceneModel : sceneModels) 127 const auto& pvModel = dynamic_cast<G4Phy 128 if (pvModel) { 129 auto entity = new G4Qt3DQEntity(fpPers 130 const auto& pv = pvModel->GetTopPhysic 131 entity->setObjectName("G4Qt3DPORoot_"+ 132 entity->SetPVNodeID(G4PhysicalVolumeMo 133 fpPhysicalVolumeObjects.push_back(enti 134 } 135 } 136 } 137 } 138 139 G4Qt3DQEntity* G4Qt3DSceneHandler::CreateNewNo 140 { 141 // Create a G4Qt3DQEntity node suitable for 142 143 G4Qt3DQEntity* newNode = nullptr; 144 145 if (fReadyForTransients) { // All transient 146 newNode = new G4Qt3DQEntity(fpTransientObj 147 G4String name = fpModel? fpModel->GetGloba 148 newNode->setObjectName(name.c_str()); 149 return newNode; 150 } 151 152 G4PhysicalVolumeModel* pPVModel = 153 dynamic_cast<G4PhysicalVolumeModel*>(fpMod 154 155 if (!pPVModel) { // Persistent objects (e.g 156 newNode = new G4Qt3DQEntity(fpPersistentOb 157 newNode->setObjectName(fpModel->GetGlobalT 158 return newNode; 159 } 160 161 // So this is a G4PhysicalVolumeModel 162 163 typedef G4PhysicalVolumeModel::G4PhysicalVol 164 typedef std::vector<PVNodeID> PVPath; 165 // const PVPath& drawnPVPath = pPVModel->GetD 166 const PVPath& fullPVPath = pPVModel->GetFul 167 //G4int currentDepth = pPVModel->GetCurrentD 168 //G4VPhysicalVolume* pCurrentPV = pPVModel-> 169 //G4LogicalVolume* pCurrentLV = pPVModel->Ge 170 //G4Material* pCurrentMaterial = pPVModel->G 171 // Note: pCurrentMaterial may be zero (paral 172 173 #ifdef G4QTDEBUG 174 G4cout << "A: " << fullPVPath << G4endl; // 175 #endif 176 177 // Find appropriate root 178 const std::size_t nWorlds = fpPhysicalVolume 179 std::size_t iWorld = 0; 180 for (; iWorld < nWorlds; ++iWorld) { 181 if (fullPVPath[0].GetPhysicalVolume() == 182 fpPhysicalVolumeObjects[iWorld]->GetPV 183 } 184 if (iWorld == nWorlds) { 185 G4Exception("G4Qt3DSceneHandler::CreateNew 186 "World mis-match - not possibl 187 } 188 189 // (Re-)establish pv path of root entity 190 G4Qt3DQEntity* wrld = fpPhysicalVolumeObject 191 wrld->SetPVNodeID(fullPVPath[0]); 192 193 // Create nodes as required 194 G4Qt3DQEntity* node = wrld; 195 newNode = node; 196 const std::size_t depth = fullPVPath.size(); 197 std::size_t iDepth = 1; 198 while (iDepth < depth) { 199 const auto& children = node->children(); 200 const G4int nChildren = (G4int)children.si 201 G4int iChild = 0; 202 G4Qt3DQEntity* child = nullptr; 203 for (; iChild < nChildren; ++iChild) { 204 child = static_cast<G4Qt3DQEntity*>(chil 205 if (child->GetPVNodeID() == fullPVPath[i 206 } 207 if (iChild != nChildren) { // Existing no 208 node = child; // Must be the ancestor o 209 } else { 210 // Add a new node as child of node 211 newNode = new G4Qt3DQEntity(node); 212 newNode->SetPVNodeID(fullPVPath[iDepth]) 213 std::ostringstream oss; 214 oss << newNode->GetPVNodeID().GetPhysica 215 << ':' << newNode->GetPVNodeID().GetCopy 216 newNode->setObjectName(oss.str().c_str() 217 node = newNode; 218 } 219 ++iDepth; 220 } 221 222 return node; 223 } 224 225 void G4Qt3DSceneHandler::PreAddSolid 226 (const G4Transform3D& objectTransformation, 227 const G4VisAttributes& visAttribs) 228 { 229 G4VSceneHandler::PreAddSolid(objectTransform 230 } 231 232 void G4Qt3DSceneHandler::PostAddSolid() 233 { 234 G4VSceneHandler::PostAddSolid(); 235 } 236 237 void G4Qt3DSceneHandler::BeginPrimitives2D(con 238 { 239 // The x,y coordinates of the primitives passe 240 // intrepreted as screen coordinates, -1 < x,y 241 // z-coordinate is ignored. 242 // IMPORTANT: invoke this from your polymorphi 243 // void MyXXXSceneHandler::BeginPrimitives2D 244 // (const G4Transform3D& objectTransformation) 245 static G4bool first = true; 246 if (first) { 247 first = false; 248 G4Exception("G4Qt3DSceneHandler::BeginPrim 249 JustWarning, 250 "2D drawing not yet implemente 251 } 252 G4VSceneHandler::BeginPrimitives2D (objectT 253 // ... 254 } 255 256 void G4Qt3DSceneHandler::EndPrimitives2D () 257 { 258 // IMPORTANT: invoke this from your polymorphi 259 // void MyXXXSceneHandler::EndPrimitives2D () 260 // ... 261 G4VSceneHandler::EndPrimitives2D (); 262 } 263 264 void G4Qt3DSceneHandler::BeginPrimitives 265 (const G4Transform3D& objectTransformation) 266 { 267 G4VSceneHandler::BeginPrimitives(objectTrans 268 } 269 270 void G4Qt3DSceneHandler::EndPrimitives () 271 { 272 G4VSceneHandler::EndPrimitives (); 273 } 274 275 void G4Qt3DSceneHandler::AddPrimitive(const G4 276 { 277 #ifdef G4QT3DDEBUG 278 G4cout << 279 "G4Qt3DSceneHandler::AddPrimitive(const G4Po 280 << polyline 281 << G4endl; 282 #endif 283 284 if (polyline.size() == 0) return; 285 286 auto currentNode = CreateNewNode(); 287 if (!currentNode) { 288 static G4bool first = true; 289 if (first) { 290 first = false; 291 G4Exception("G4Qt3DSceneHandler::AddPrim 292 "qt3d-0003", JustWarning, 293 "No available node!"); 294 } 295 return; 296 } 297 298 fpVisAttribs = fpViewer->GetApplicableVisAtt 299 300 auto transform = G4Qt3DUtils::CreateQTransfo 301 transform->setObjectName("transform"); 302 303 auto polylineEntity = new Qt3DCore::QEntity( 304 polylineEntity->addComponent(transform); 305 306 const auto vertexByteSize = 3*sizeof(PRECIS 307 308 const std::size_t nLines = polyline.size() - 309 QByteArray polylineByteArray; 310 const auto polylineBufferByteSize = 2*nLines 311 polylineByteArray.resize((G4int)polylineBuff 312 auto polylineBufferArray = reinterpret_cast< 313 G4int iLine = 0; 314 for (std::size_t i = 0; i < nLines; ++i) { 315 polylineBufferArray[iLine++] = polyline[i] 316 polylineBufferArray[iLine++] = polyline[i] 317 polylineBufferArray[iLine++] = polyline[i] 318 polylineBufferArray[iLine++] = polyline[i+ 319 polylineBufferArray[iLine++] = polyline[i+ 320 polylineBufferArray[iLine++] = polyline[i+ 321 } 322 auto polylineGeometry = new G4Qt3DCompat::QG 323 polylineGeometry->setObjectName("polylineGeo 324 325 auto polylineBuffer = new G4Qt3DCompat::QBuf 326 polylineBuffer->setObjectName("Polyline buff 327 polylineBuffer->setData(polylineByteArray); 328 329 auto polylineAtt = new G4Qt3DCompat::QAttrib 330 polylineAtt->setObjectName("Position attribu 331 polylineAtt->setName(G4Qt3DCompat::QAttribut 332 polylineAtt->setBuffer(polylineBuffer); 333 polylineAtt->setAttributeType(G4Qt3DCompat:: 334 polylineAtt->setVertexBaseType(BASETYPE); 335 polylineAtt->setVertexSize(3); 336 polylineAtt->setCount((G4int)nLines); 337 polylineAtt->setByteOffset(0); 338 polylineAtt->setByteStride(vertexByteSize); 339 // Normal attribute (a dummy with count==0) 340 auto dummyNormalLineAtt = new G4Qt3DCompat:: 341 dummyNormalLineAtt->setObjectName("Normal at 342 dummyNormalLineAtt->setName(G4Qt3DCompat::QA 343 dummyNormalLineAtt->setBuffer(polylineBuffer 344 dummyNormalLineAtt->setAttributeType(G4Qt3DC 345 dummyNormalLineAtt->setVertexBaseType(BASETY 346 dummyNormalLineAtt->setVertexSize(3); 347 dummyNormalLineAtt->setCount(0); 348 dummyNormalLineAtt->setByteOffset(0); 349 dummyNormalLineAtt->setByteStride(vertexByte 350 351 const auto& colour = fpVisAttribs->GetColour 352 353 polylineGeometry->addAttribute(polylineAtt); 354 polylineGeometry->addAttribute(dummyNormalLi 355 356 auto material = new Qt3DExtras::QDiffuseSpec 357 material->setObjectName("materialForPolyline 358 material->setAmbient(G4Qt3DUtils::ConvertToQ 359 material->setShininess(0.); 360 material->setSpecular(0.); 361 polylineEntity->addComponent(material); 362 363 auto renderer = new Qt3DRender::QGeometryRen 364 renderer->setObjectName("polylineRenderer"); 365 renderer->setGeometry(polylineGeometry); 366 renderer->setVertexCount(2*(G4int)nLines); 367 renderer->setPrimitiveType(Qt3DRender::QGeom 368 polylineEntity->addComponent(renderer); 369 } 370 371 void G4Qt3DSceneHandler::AddPrimitive (const G 372 { 373 if (polymarker.size() == 0) return; 374 375 auto currentNode = CreateNewNode(); 376 if (!currentNode) { 377 static G4bool first = true; 378 if (first) { 379 first = false; 380 G4Exception("G4Qt3DSceneHandler::AddPrim 381 "qt3d-0003", JustWarning, 382 "No available node!"); 383 } 384 return; 385 } 386 387 fpVisAttribs = fpViewer->GetApplicableVisAtt 388 389 MarkerSizeType markerSizeType; 390 G4double markerSize = GetMarkerSize(polymark 391 392 switch (polymarker.GetMarkerType()) { 393 default: 394 case G4Polymarker::dots: 395 { 396 const std::size_t nDots = polymarker.siz 397 398 auto transform = G4Qt3DUtils::CreateQTra 399 transform->setObjectName("transform"); 400 401 auto polymarkerEntity = new Qt3DCore::QE 402 polymarkerEntity->addComponent(transform 403 404 const auto vertexByteSize = 3*sizeof(PR 405 406 QByteArray polymarkerByteArray; 407 const auto polymarkerBufferByteSize = nD 408 polymarkerByteArray.resize((G4int)polyma 409 auto polymarkerBufferArray = reinterpret 410 G4int iMarker = 0; 411 for (std::size_t i = 0; i < polymarker.s 412 polymarkerBufferArray[iMarker++] = pol 413 polymarkerBufferArray[iMarker++] = pol 414 polymarkerBufferArray[iMarker++] = pol 415 } 416 auto polymarkerGeometry = new G4Qt3DComp 417 polymarkerGeometry->setObjectName("polym 418 auto polymarkerBuffer = new G4Qt3DCompat 419 polymarkerBuffer->setObjectName("Polymar 420 polymarkerBuffer->setData(polymarkerByte 421 422 auto polymarkerAtt = new G4Qt3DCompat::Q 423 polymarkerAtt->setObjectName("Position a 424 polymarkerAtt->setName(G4Qt3DCompat::QAt 425 polymarkerAtt->setBuffer(polymarkerBuffe 426 polymarkerAtt->setAttributeType(G4Qt3DCo 427 polymarkerAtt->setVertexBaseType(BASETYP 428 polymarkerAtt->setVertexSize(3); 429 polymarkerAtt->setCount((G4int)nDots); 430 polymarkerAtt->setByteOffset(0); 431 polymarkerAtt->setByteStride(vertexByteS 432 433 const auto& colour = fpVisAttribs->GetCo 434 435 polymarkerGeometry->addAttribute(polymar 436 437 auto material = new Qt3DExtras::QDiffuse 438 material->setObjectName("materialForPoly 439 material->setAmbient(G4Qt3DUtils::Conver 440 material->setShininess(0.); 441 material->setSpecular(0.); 442 polymarkerEntity->addComponent(material) 443 444 auto renderer = new Qt3DRender::QGeometr 445 renderer->setObjectName("polymarkerWiref 446 renderer->setGeometry(polymarkerGeometry 447 renderer->setVertexCount((G4int)nDots); 448 renderer->setPrimitiveType(Qt3DRender::Q 449 polymarkerEntity->addComponent(renderer) 450 } 451 break; 452 case G4Polymarker::circles: 453 { 454 G4Circle circle (polymarker); // Defaul 455 456 const auto& colour = fpVisAttribs->GetCo 457 auto material = new Qt3DExtras::QDiffuse 458 material->setObjectName("materialForCirc 459 material->setAmbient(G4Qt3DUtils::Conver 460 if (colour.GetAlpha() < 1.) material->se 461 462 auto sphereMesh = new Qt3DExtras::QSpher 463 sphereMesh->setObjectName("sphereMesh"); 464 G4double radius = markerSize/2.; 465 if (markerSizeType == G4VSceneHandler::s 466 // Not figured out how to do screen-si 467 const G4double scale = 200.; // Rough 468 radius *= fpScene->GetExtent().GetExte 469 } 470 sphereMesh->setRadius(radius); 471 // sphereMesh->setInstanceCount(polymarke 472 473 // auto currentEntity = new Qt3DCore::QEn 474 for (std::size_t iPoint = 0; iPoint < po 475 auto position = fObjectTransformation* 476 auto transform = G4Qt3DUtils::CreateQT 477 auto currentEntity = new Qt3DCore::QEntity(c 478 currentEntity->addComponent(material); 479 currentEntity->addComponent(transform) 480 currentEntity->addComponent(sphereMesh 481 } 482 } 483 break; 484 case G4Polymarker::squares: 485 { 486 G4Square square (polymarker); // Defaul 487 488 const auto& colour = fpVisAttribs->GetCo 489 auto material = new Qt3DExtras::QDiffuse 490 material->setObjectName("materialForSqua 491 material->setAmbient(G4Qt3DUtils::Conver 492 if (colour.GetAlpha() < 1.) material->se 493 494 auto boxMesh = new Qt3DExtras::QCuboidMe 495 boxMesh->setObjectName("boxMesh"); 496 G4double side = markerSize; 497 if (markerSizeType == G4VSceneHandler::s 498 // Not figured out how to do screen-si 499 const G4double scale = 200.; // Rough 500 side *= fpScene->GetExtent().GetExtent 501 } 502 boxMesh->setXExtent(side); 503 boxMesh->setYExtent(side); 504 boxMesh->setZExtent(side); 505 506 for (std::size_t iPoint = 0; iPoint < po 507 auto position = fObjectTransformation* 508 auto transform = G4Qt3DUtils::CreateQT 509 auto currentEntity = new Qt3DCore::QEn 510 currentEntity->addComponent(material); 511 currentEntity->addComponent(transform) 512 currentEntity->addComponent(boxMesh); 513 } 514 } 515 break; 516 } 517 } 518 519 #ifdef G4QT3DDEBUG 520 void G4Qt3DSceneHandler::AddPrimitive(const G4 521 G4cout << 522 "G4Qt3DSceneHandler::AddPrimitive(const G4Te 523 << text 524 << G4endl; 525 #else 526 void G4Qt3DSceneHandler::AddPrimitive(const G4 527 #endif 528 529 static G4bool first = true; 530 if (first) { 531 first = false; 532 G4Exception("G4Qt3DSceneHandler::AddPrimit 533 "qt3D-0002", JustWarning, 534 "Text drawing doesn't work yet 535 } // OK. Not working, but let it execute, w 536 537 /* But it crashes after /vis/viewer/rebuild! 538 auto currentNode = CreateNewNode(); 539 if (!currentNode) { 540 static G4bool first = true; 541 if (first) { 542 first = false; 543 G4Exception("G4Qt3DSceneHandler::AddPrimiti 544 "qt3d-0003", JustWarning, 545 "No available node!"); 546 } 547 return; 548 } 549 550 fpVisAttribs = fpViewer->GetApplicableVisAtt 551 552 auto position = fObjectTransformation*G4Tran 553 auto transform = G4Qt3DUtils::CreateQTransfo 554 // transform->setScale(10); 555 transform->setScale(0.1); 556 557 // auto currentEntity = new Qt3DCore::QEntity 558 559 // This simply does not work 560 auto qtext = new Qt3DExtras::QText2DEntity() 561 qtext->setParent(currentNode); 562 // qtext->setParent(currentEntity); // ?? D 563 qtext->setText(text.GetText().c_str()); 564 // qtext->setHeight(100); 565 // qtext->setWidth(1000); 566 qtext->setHeight(20); 567 qtext->setWidth(100); 568 qtext->setColor(Qt::green); 569 qtext->setFont(QFont("Courier New", 10)); 570 qtext->addComponent(transform); 571 572 // This produces text in 3D facing +z - not 573 // const auto& colour = GetTextColour(text); 574 // auto material = new Qt3DExtras::QDiffuseSp 575 // material->setObjectName("materialForText") 576 // material->setAmbient(G4Qt3DUtils::ConvertT 577 // if (colour.GetAlpha() < 1.) material->setA 578 // 579 // auto textMesh = new Qt3DExtras::QExtrudedT 580 // textMesh->setText(text.GetText().c_str()); 581 // textMesh->setFont(QFont("Courier New", 10) 582 // textMesh->setDepth(.01f); 583 // 584 // currentNode->addComponent(material); 585 // currentNode->addComponent(transform); 586 // currentNode->addComponent(textMesh); 587 */ 588 } 589 590 void G4Qt3DSceneHandler::AddPrimitive(const G4 591 { 592 #ifdef G4QT3DDEBUG 593 G4cout << 594 "G4Qt3DSceneHandler::AddPrimitive(const G4Ci 595 << circle 596 << G4endl; 597 #endif 598 599 #ifdef G4QT3DDEBUG 600 MarkerSizeType sizeType; 601 G4double size = GetMarkerSize (circle, sizeT 602 switch (sizeType) { 603 default: 604 case screen: 605 // Draw in screen coordinates. 606 G4cout << "screen"; 607 break; 608 case world: 609 // Draw in world coordinates. 610 G4cout << "world"; 611 break; 612 } 613 G4cout << " size: " << size << G4endl; 614 #endif 615 616 auto currentNode = CreateNewNode(); 617 if (!currentNode) { 618 static G4bool first = true; 619 if (first) { 620 first = false; 621 G4Exception("G4Qt3DSceneHandler::AddPrim 622 "qt3d-0003", JustWarning, 623 "No available node!"); 624 } 625 return; 626 } 627 628 fpVisAttribs = fpViewer->GetApplicableVisAtt 629 630 auto position = fObjectTransformation*G4Tran 631 auto transform = G4Qt3DUtils::CreateQTransfo 632 633 const auto& colour = fpVisAttribs->GetColour 634 auto material = new Qt3DExtras::QDiffuseSpec 635 material->setObjectName("materialForCircle") 636 material->setAmbient(G4Qt3DUtils::ConvertToQ 637 if (colour.GetAlpha() < 1.) material->setAlp 638 639 auto sphereMesh = new Qt3DExtras::QSphereMes 640 sphereMesh->setObjectName("sphereMesh"); 641 G4double radius; 642 if (circle.GetSizeType() == G4VMarker::world 643 radius =circle.GetWorldRadius(); 644 } else { // Screen-size or none 645 // Not figured out how to do screen-size, 646 const G4double scale = 200.; // Roughly p 647 radius = circle.GetScreenRadius()*fpScene- 648 } 649 sphereMesh->setRadius(radius); 650 651 auto currentEntity = new Qt3DCore::QEntity(c 652 currentEntity->addComponent(material); 653 currentEntity->addComponent(transform); 654 currentEntity->addComponent(sphereMesh); 655 } 656 657 void G4Qt3DSceneHandler::AddPrimitive(const G4 658 { 659 #ifdef G4QT3DDEBUG 660 G4cout << 661 "G4Qt3DSceneHandler::AddPrimitive(const G4Sq 662 << square 663 << G4endl; 664 #endif 665 666 #ifdef G4QT3DDEBUG 667 MarkerSizeType sizeType; 668 G4double size = GetMarkerSize (square, sizeT 669 switch (sizeType) { 670 default: 671 case screen: 672 // Draw in screen coordinates. 673 G4cout << "screen"; 674 break; 675 case world: 676 // Draw in world coordinates. 677 G4cout << "world"; 678 break; 679 } 680 G4cout << " size: " << size << G4endl; 681 #endif 682 683 auto currentNode = CreateNewNode(); 684 if (!currentNode) { 685 static G4bool first = true; 686 if (first) { 687 first = false; 688 G4Exception("G4Qt3DSceneHandler::AddPrim 689 "qt3d-0003", JustWarning, 690 "No available node!"); 691 } 692 return; 693 } 694 695 fpVisAttribs = fpViewer->GetApplicableVisAtt 696 697 auto position = fObjectTransformation*G4Tran 698 auto transform = G4Qt3DUtils::CreateQTransfo 699 700 const auto& colour = fpVisAttribs->GetColour 701 auto material = new Qt3DExtras::QDiffuseSpec 702 material->setObjectName("materialForSquare") 703 material->setAmbient(G4Qt3DUtils::ConvertToQ 704 if (colour.GetAlpha() < 1.) material->setAlp 705 706 auto boxMesh = new Qt3DExtras::QCuboidMesh() 707 boxMesh->setObjectName("boxMesh"); 708 G4double side; 709 if (square.GetSizeType() == G4VMarker::world 710 side = square.GetWorldDiameter(); 711 } else { // Screen-size or none 712 // Not figured out how to do screen-size, 713 const G4double scale = 200.; // Roughly p 714 side = square.GetScreenDiameter()*fpScene- 715 } 716 boxMesh->setXExtent(side); 717 boxMesh->setYExtent(side); 718 boxMesh->setZExtent(side); 719 720 auto currentEntity = new Qt3DCore::QEntity(c 721 currentEntity->addComponent(material); 722 currentEntity->addComponent(transform); 723 currentEntity->addComponent(boxMesh); 724 } 725 726 void G4Qt3DSceneHandler::AddPrimitive(const G4 727 { 728 auto currentNode = CreateNewNode(); 729 if (!currentNode) { 730 static G4bool first = true; 731 if (first) { 732 first = false; 733 G4Exception("G4Qt3DSceneHandler::AddPrim 734 "qt3d-0003", JustWarning, 735 "No available node!"); 736 } 737 return; 738 } 739 740 if (polyhedron.GetNoFacets() == 0) return; 741 742 fpVisAttribs = fpViewer->GetApplicableVisAtt 743 744 // Roll out vertices and normals for the fac 745 // are duplicated. For example a box has 8 v 746 // you need 12 triangles and 36 vertices. If 747 // we could restrict the number to 8 and use 748 // triangles, but we also have to consider t 749 // more than one normal, depending on which 750 // So we roll out all the vertices and norma 751 std::vector<G4Point3D> vertices; 752 std::vector<G4Normal3D> normals; 753 754 // Also roll out edges (as lines) for wirefr 755 // including those that differ only in the o 756 typedef std::pair<G4Point3D,G4Point3D> Line; 757 std::vector<Line> lines; 758 auto insertIfNew = [&lines](const Line& newL 759 // For a large polyhedron, eliminating lin 760 // expensive. Comment out for now, and may 761 // Allow the graphics-reps utilities to op 762 // for (const auto& line: lines) { 763 // if ((newLine.first==line.first && newL 764 // (newLine.first==line.second && new 765 // return; 766 // } 767 lines.push_back(newLine); 768 }; 769 770 G4bool isAuxilaryEdgeVisible = fpViewer->Get 771 G4bool notLastFace; 772 do { 773 G4int nEdges; 774 G4Point3D vertex [4]; 775 G4int edgeFlag[4]; 776 G4Normal3D normal [4]; 777 notLastFace = polyhedron.GetNextFacet(nEdg 778 vertices.push_back(vertex[0]); 779 vertices.push_back(vertex[1]); 780 vertices.push_back(vertex[2]); 781 normals.push_back(normal[0]); 782 normals.push_back(normal[1]); 783 normals.push_back(normal[2]); 784 if(isAuxilaryEdgeVisible||edgeFlag[0]>0)in 785 if(isAuxilaryEdgeVisible||edgeFlag[1]>0)in 786 if (nEdges == 3) { 787 // Face is a triangle 788 // One more line for wireframe, triangle 789 if(isAuxilaryEdgeVisible||edgeFlag[2]>0) 790 } else if (nEdges == 4) { 791 // Face is a quadrilateral 792 // Create another triangle for surfaces, 793 vertices.push_back(vertex[2]); 794 vertices.push_back(vertex[3]); 795 vertices.push_back(vertex[0]); 796 normals.push_back(normal[2]); 797 normals.push_back(normal[3]); 798 normals.push_back(normal[0]); 799 if(isAuxilaryEdgeVisible||edgeFlag[2]>0) 800 if(isAuxilaryEdgeVisible||edgeFlag[3]>0) 801 } else { 802 G4warn 803 << "ERROR: polyhedron face with unexpect 804 << "\n Tag: " << fpModel->GetCurrentTag 805 << G4endl; 806 return; 807 } 808 } while (notLastFace); 809 const auto nVerts = vertices.size(); 810 const auto nLines = lines.size(); 811 812 // Now put stuff into Qt objects 813 814 auto transform = G4Qt3DUtils::CreateQTransfo 815 transform->setObjectName("transform"); 816 817 Qt3DCore::QEntity* wireframeEntity = nullptr 818 Qt3DCore::QEntity* surfaceEntity = nullptr 819 static G4int errorCount = 0; 820 G4ViewParameters::DrawingStyle drawing_style 821 switch (drawing_style) { 822 case G4ViewParameters::wireframe: 823 wireframeEntity = new Qt3DCore::QEntity( 824 wireframeEntity->addComponent(transform) 825 break; 826 case G4ViewParameters::hlr: 827 wireframeEntity = new Qt3DCore::QEntity( 828 wireframeEntity->addComponent(transform) 829 surfaceEntity = new Qt3DCore::QEntity(cu 830 surfaceEntity->addComponent(transform); 831 break; 832 case G4ViewParameters::hsr: 833 surfaceEntity = new Qt3DCore::QEntity(cu 834 surfaceEntity->addComponent(transform); 835 break; 836 case G4ViewParameters::hlhsr: 837 wireframeEntity = new Qt3DCore::QEntity( 838 wireframeEntity->addComponent(transform) 839 surfaceEntity = new Qt3DCore::QEntity(cu 840 surfaceEntity->addComponent(transform); 841 break; 842 case G4ViewParameters::cloud: 843 // Shouldn't happen in this function (it 844 if (errorCount == 0) { 845 ++errorCount; 846 G4warn << "WARNING: Qt3D: cloud drawin 847 } 848 return; 849 break; 850 } 851 852 const auto vertexByteSize = 3*sizeof(PRECIS 853 854 G4Qt3DCompat::QGeometry* vertexGeometry = nu 855 G4Qt3DCompat::QGeometry* lineGeometry = nu 856 857 G4Qt3DCompat::QAttribute* positionAtt = null 858 G4Qt3DCompat::QAttribute* normalAtt = null 859 G4Qt3DCompat::QAttribute* lineAtt = null 860 G4Qt3DCompat::QAttribute* dummyNormalLineAtt 861 862 G4Qt3DCompat::QBuffer* vertexBuffer = nullpt 863 if (drawing_style == G4ViewParameters::hlr | 864 drawing_style == G4ViewParameters::hsr | 865 drawing_style == G4ViewParameters::hlhsr 866 867 // Put vertices, normals into QByteArray 868 // Accomodates both vertices and normals - 869 QByteArray vertexByteArray; 870 const auto vertexBufferByteSize = 2*nVerts 871 vertexByteArray.resize((G4int)vertexBuffer 872 auto vertexBufferArray = reinterpret_cast< 873 G4int i1 = 0; 874 for (std::size_t i = 0; i < nVerts; ++i) { 875 vertexBufferArray[i1++] = vertices[i].x( 876 vertexBufferArray[i1++] = vertices[i].y( 877 vertexBufferArray[i1++] = vertices[i].z( 878 vertexBufferArray[i1++] = normals[i].x() 879 vertexBufferArray[i1++] = normals[i].y() 880 vertexBufferArray[i1++] = normals[i].z() 881 } 882 // Vertex buffer (vertices and normals) 883 vertexGeometry = new G4Qt3DCompat::QGeomet 884 vertexGeometry->setObjectName("vertexGeome 885 vertexBuffer = new G4Qt3DCompat::QBuffer(v 886 vertexBuffer->setObjectName("Vertex buffer 887 vertexBuffer->setData(vertexByteArray); 888 889 // Position attribute 890 positionAtt = new G4Qt3DCompat::QAttribute 891 positionAtt->setObjectName("Position attri 892 positionAtt->setName(G4Qt3DCompat::QAttrib 893 positionAtt->setBuffer(vertexBuffer); 894 positionAtt->setAttributeType(G4Qt3DCompat 895 positionAtt->setVertexBaseType(BASETYPE); 896 positionAtt->setVertexSize(3); 897 positionAtt->setCount((G4int)nVerts); 898 positionAtt->setByteOffset(0); 899 positionAtt->setByteStride(2*vertexByteSiz 900 901 // Normal attribute 902 normalAtt = new G4Qt3DCompat::QAttribute; 903 normalAtt->setObjectName("Normal attribute 904 normalAtt->setName(G4Qt3DCompat::QAttribut 905 normalAtt->setBuffer(vertexBuffer); 906 normalAtt->setAttributeType(G4Qt3DCompat:: 907 normalAtt->setVertexBaseType(BASETYPE); 908 normalAtt->setVertexSize(3); 909 normalAtt->setCount((G4int)nVerts); 910 normalAtt->setByteOffset(vertexByteSize); 911 normalAtt->setByteStride(2*vertexByteSize) 912 } 913 914 G4Qt3DCompat::QBuffer* lineBuffer = nullptr; 915 if (drawing_style == G4ViewParameters::wiref 916 drawing_style == G4ViewParameters::hlr | 917 drawing_style == G4ViewParameters::hlhsr 918 919 // Put lines into a QByteArray 920 QByteArray lineByteArray; 921 const auto lineBufferByteSize = 2*nLines*v 922 lineByteArray.resize((G4int)lineBufferByte 923 auto lineBufferArray = reinterpret_cast<PR 924 G4int i2 = 0; 925 for (const auto& line: lines) { 926 lineBufferArray[i2++] = line.first.x(); 927 lineBufferArray[i2++] = line.first.y(); 928 lineBufferArray[i2++] = line.first.z(); 929 lineBufferArray[i2++] = line.second.x(); 930 lineBufferArray[i2++] = line.second.y(); 931 lineBufferArray[i2++] = line.second.z(); 932 } 933 // Line loop buffer 934 lineGeometry = new G4Qt3DCompat::QGeometry 935 lineGeometry->setObjectName("lineGeometry" 936 lineBuffer = new G4Qt3DCompat::QBuffer(lin 937 lineBuffer->setObjectName("Line buffer"); 938 lineBuffer->setData(lineByteArray); 939 940 // Line attribute 941 lineAtt = new G4Qt3DCompat::QAttribute; 942 lineAtt->setObjectName("Position attribute 943 lineAtt->setName(G4Qt3DCompat::QAttribute: 944 lineAtt->setBuffer(lineBuffer); 945 lineAtt->setAttributeType(G4Qt3DCompat::QA 946 lineAtt->setVertexBaseType(BASETYPE); 947 lineAtt->setVertexSize(3); 948 lineAtt->setCount((G4int)nLines); 949 lineAtt->setByteOffset(0); 950 lineAtt->setByteStride(vertexByteSize); 951 // Normal attribute (a dummy with count==0 952 dummyNormalLineAtt = new G4Qt3DCompat::QAt 953 dummyNormalLineAtt->setObjectName("Normal 954 dummyNormalLineAtt->setName(G4Qt3DCompat:: 955 dummyNormalLineAtt->setBuffer(lineBuffer); 956 dummyNormalLineAtt->setAttributeType(G4Qt3 957 dummyNormalLineAtt->setVertexBaseType(BASE 958 dummyNormalLineAtt->setVertexSize(3); 959 dummyNormalLineAtt->setCount(0); 960 dummyNormalLineAtt->setByteOffset(0); 961 dummyNormalLineAtt->setByteStride(vertexBy 962 } 963 964 // Create material and renderer(s)... 965 966 const auto& colour = fpVisAttribs->GetColour 967 Qt3DExtras::QDiffuseSpecularMaterial* materi 968 Qt3DRender::QGeometryRenderer* renderer; 969 switch (drawing_style) { 970 971 case G4ViewParameters::wireframe: 972 973 lineGeometry->addAttribute(lineAtt); 974 lineGeometry->addAttribute(dummyNormalLi 975 976 material = new Qt3DExtras::QDiffuseSpecu 977 material->setObjectName("materialForWire 978 material->setAmbient(G4Qt3DUtils::Conver 979 material->setShininess(0.); 980 material->setSpecular(0.); 981 wireframeEntity->addComponent(material); 982 983 renderer = new Qt3DRender::QGeometryRend 984 renderer->setObjectName("polyhedronWiref 985 renderer->setGeometry(lineGeometry); 986 renderer->setVertexCount(2*(G4int)nLines 987 renderer->setPrimitiveType(Qt3DRender::Q 988 wireframeEntity->addComponent(renderer); 989 990 break; 991 992 case G4ViewParameters::hlr: 993 994 // Surfaces with background colour to hi 995 996 vertexGeometry->addAttribute(positionAtt 997 vertexGeometry->addAttribute(normalAtt); 998 999 material = new Qt3DExtras::QDiffuseSpecu 1000 material->setObjectName("materialForHid 1001 material->setAmbient(Qt::white); // Wh 1002 material->setShininess(0.); 1003 material->setSpecular(0.); 1004 surfaceEntity->addComponent(material); 1005 1006 renderer = new Qt3DRender::QGeometryRen 1007 renderer->setObjectName("polyhedronSurf 1008 renderer->setGeometry(vertexGeometry); 1009 renderer->setVertexCount((G4int)nVerts) 1010 renderer->setPrimitiveType(Qt3DRender:: 1011 surfaceEntity->addComponent(renderer); 1012 1013 // Edges 1014 1015 lineGeometry->addAttribute(lineAtt); 1016 lineGeometry->addAttribute(dummyNormalL 1017 1018 material = new Qt3DExtras::QDiffuseSpec 1019 material->setObjectName("materialForWir 1020 material->setAmbient(G4Qt3DUtils::Conve 1021 material->setShininess(0.); 1022 material->setSpecular(0.); 1023 wireframeEntity->addComponent(material) 1024 1025 renderer = new Qt3DRender::QGeometryRen 1026 renderer->setObjectName("polyhedronWire 1027 renderer->setGeometry(lineGeometry); 1028 renderer->setVertexCount(2*(G4int)nLine 1029 renderer->setPrimitiveType(Qt3DRender:: 1030 wireframeEntity->addComponent(renderer) 1031 1032 break; 1033 1034 case G4ViewParameters::hsr: 1035 1036 vertexGeometry->addAttribute(positionAt 1037 vertexGeometry->addAttribute(normalAtt) 1038 1039 material = new Qt3DExtras::QDiffuseSpec 1040 material->setObjectName("materialForSur 1041 material->setAmbient(G4Qt3DUtils::Conve 1042 if (colour.GetAlpha() < 1.) material->s 1043 surfaceEntity->addComponent(material); 1044 1045 renderer = new Qt3DRender::QGeometryRen 1046 renderer->setObjectName("polyhedronSurf 1047 renderer->setGeometry(vertexGeometry); 1048 renderer->setVertexCount((G4int)nVerts) 1049 renderer->setPrimitiveType(Qt3DRender:: 1050 surfaceEntity->addComponent(renderer); 1051 1052 break; 1053 1054 case G4ViewParameters::hlhsr: 1055 1056 // Surfaces 1057 1058 vertexGeometry->addAttribute(positionAt 1059 vertexGeometry->addAttribute(normalAtt) 1060 1061 material = new Qt3DExtras::QDiffuseSpec 1062 material->setObjectName("materialForSur 1063 material->setAmbient(G4Qt3DUtils::Conve 1064 if (colour.GetAlpha() < 1.) material->s 1065 surfaceEntity->addComponent(material); 1066 1067 renderer = new Qt3DRender::QGeometryRen 1068 renderer->setObjectName("polyhedronSurf 1069 renderer->setGeometry(vertexGeometry); 1070 renderer->setVertexCount((G4int)nVerts) 1071 renderer->setPrimitiveType(Qt3DRender:: 1072 surfaceEntity->addComponent(renderer); 1073 1074 // Edges 1075 1076 lineGeometry->addAttribute(lineAtt); 1077 lineGeometry->addAttribute(dummyNormalL 1078 1079 material = new Qt3DExtras::QDiffuseSpec 1080 material->setObjectName("materialForWir 1081 material->setAmbient(G4Qt3DUtils::Conve 1082 material->setShininess(0.); 1083 material->setSpecular(0.); 1084 wireframeEntity->addComponent(material) 1085 1086 renderer = new Qt3DRender::QGeometryRen 1087 renderer->setObjectName("polyhedronSurf 1088 renderer->setGeometry(lineGeometry); 1089 renderer->setVertexCount(2*(G4int)nLine 1090 renderer->setPrimitiveType(Qt3DRender:: 1091 wireframeEntity->addComponent(renderer) 1092 1093 break; 1094 1095 case G4ViewParameters::cloud: 1096 // Case trapped at start of function, s 1097 break; 1098 } 1099 } 1100 1101 void G4Qt3DSceneHandler::AddCompound(const G4 1102 { 1103 StandardSpecialMeshRendering(mesh); 1104 } 1105 1106 void G4Qt3DSceneHandler::ClearStore () 1107 { 1108 G4Qt3DUtils::delete_components_and_children 1109 EstablishG4Qt3DQEntities(); 1110 } 1111 1112 void G4Qt3DSceneHandler::ClearTransientStore 1113 { 1114 G4Qt3DUtils::delete_components_and_children 1115 } 1116