#include <G4Qt3DSceneHandler.hh>

Inheritance diagram for G4Qt3DSceneHandler:

Public Member Functions
	G4Qt3DSceneHandler (G4VGraphicsSystem &system, const G4String &name)

virtual	~G4Qt3DSceneHandler ()

void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)

void	PostAddSolid ()

void	BeginPrimitives2D (const G4Transform3D &objectTransformation)

void	EndPrimitives2D ()

void	BeginPrimitives (const G4Transform3D &objectTransformation)

void	EndPrimitives ()

void	AddPrimitive (const G4Polyline &)

void	AddPrimitive (const G4Polymarker &)

void	AddPrimitive (const G4Text &)

void	AddPrimitive (const G4Circle &)

void	AddPrimitive (const G4Square &)

void	AddPrimitive (const G4Polyhedron &)

void	AddCompound (const G4Mesh &)

void	ClearStore ()

void	ClearTransientStore ()

virtual void	AddPrimitive (const G4Plotter &)

virtual void	AddCompound (const G4VTrajectory &)

virtual void	AddCompound (const G4VHit &)

virtual void	AddCompound (const G4VDigi &)

virtual void	AddCompound (const G4THitsMap< G4double > &)

virtual void	AddCompound (const G4THitsMap< G4StatDouble > &)

Public Member Functions inherited from G4VSceneHandler
	G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")

virtual	~G4VSceneHandler ()

virtual void	AddSolid (const G4Box &)

virtual void	AddSolid (const G4Cons &)

virtual void	AddSolid (const G4Orb &)

virtual void	AddSolid (const G4Para &)

virtual void	AddSolid (const G4Sphere &)

virtual void	AddSolid (const G4Torus &)

virtual void	AddSolid (const G4Trap &)

virtual void	AddSolid (const G4Trd &)

virtual void	AddSolid (const G4Tubs &)

virtual void	AddSolid (const G4Ellipsoid &)

virtual void	AddSolid (const G4Polycone &)

virtual void	AddSolid (const G4Polyhedra &)

virtual void	AddSolid (const G4TessellatedSolid &)

virtual void	AddSolid (const G4VSolid &)

virtual void	BeginModeling ()

virtual void	EndModeling ()

virtual const G4VisExtent &	GetExtent () const

const G4String &	GetName () const

G4int	GetSceneHandlerId () const

G4int	GetViewCount () const

G4VGraphicsSystem *	GetGraphicsSystem () const

G4Scene *	GetScene () const

const G4ViewerList &	GetViewerList () const

G4VModel *	GetModel () const

G4VViewer *	GetCurrentViewer () const

G4bool	GetMarkForClearingTransientStore () const

G4bool	IsReadyForTransients () const

G4bool	GetTransientsDrawnThisEvent () const

G4bool	GetTransientsDrawnThisRun () const

const G4Transform3D &	GetObjectTransformation () const

void	SetName (const G4String &)

void	SetCurrentViewer (G4VViewer *)

virtual void	SetScene (G4Scene *)

G4ViewerList &	SetViewerList ()

void	SetModel (G4VModel *)

void	SetMarkForClearingTransientStore (G4bool)

void	SetTransientsDrawnThisEvent (G4bool)

void	SetTransientsDrawnThisRun (G4bool)

void	SetObjectTransformation (const G4Transform3D &)

const G4Colour &	GetColour ()

const G4Colour &	GetColor ()

const G4Colour &	GetColour (const G4Visible &)

const G4Colour &	GetColor (const G4Visible &)

const G4Colour &	GetTextColour (const G4Text &)

const G4Colour &	GetTextColor (const G4Text &)

G4double	GetLineWidth (const G4VisAttributes *)

G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)

G4int	GetNumberOfCloudPoints (const G4VisAttributes *) const

G4bool	GetAuxEdgeVisible (const G4VisAttributes *)

G4int	GetNoOfSides (const G4VisAttributes *)

G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)

G4ModelingParameters *	CreateModelingParameters ()

void	DrawEvent (const G4Event *)

void	DrawEndOfRunModels ()

template<class T>
void	AddSolidT (const T &solid)

template<class T>
void	AddSolidWithAuxiliaryEdges (const T &solid)

G4int	IncrementViewCount ()

void	AddViewerToList (G4VViewer *pView)

void	RemoveViewerFromList (G4VViewer *pView)

Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()

virtual	~G4VGraphicsScene ()

Protected Member Functions
void	EstablishG4Qt3DQEntities ()

G4Qt3DQEntity *	CreateNewNode ()

Protected Member Functions inherited from G4VSceneHandler
virtual void	ProcessScene ()

virtual void	RequestPrimitives (const G4VSolid &solid)

virtual G4DisplacedSolid *	CreateSectionSolid ()

virtual G4DisplacedSolid *	CreateCutawaySolid ()

void	LoadAtts (const G4Visible &, G4AttHolder *)

void	StandardSpecialMeshRendering (const G4Mesh &)

void	Draw3DRectMeshAsDots (const G4Mesh &)

void	Draw3DRectMeshAsSurfaces (const G4Mesh &)

void	DrawTetMeshAsDots (const G4Mesh &)

void	DrawTetMeshAsSurfaces (const G4Mesh &)

G4ThreeVector	GetPointInBox (const G4ThreeVector &pos, G4double halfX, G4double halfY, G4double halfZ) const

G4ThreeVector	GetPointInTet (const std::vector< G4ThreeVector > &vertices) const

Protected Attributes
Qt3DCore::QEntity *	fpQt3DScene

Qt3DCore::QEntity *	fpTransientObjects

Qt3DCore::QEntity *	fpPersistentObjects

std::vector< G4Qt3DQEntity * >	fpPhysicalVolumeObjects

Protected Attributes inherited from G4VSceneHandler
G4VGraphicsSystem &	fSystem

const G4int	fSceneHandlerId

G4String	fName

G4int	fViewCount

G4ViewerList	fViewerList

G4VViewer *	fpViewer

G4Scene *	fpScene

G4bool	fMarkForClearingTransientStore

G4bool	fReadyForTransients

G4bool	fTransientsDrawnThisEvent

G4bool	fTransientsDrawnThisRun

G4bool	fProcessingSolid

G4bool	fProcessing2D

G4VModel *	fpModel

G4Transform3D	fObjectTransformation

G4int	fNestingDepth

const G4VisAttributes *	fpVisAttribs

const G4Transform3D	fIdentityTransformation

std::map< G4VPhysicalVolume *, G4String >	fProblematicVolumes

Static Protected Attributes
static G4int	fSceneIdCount = 0

Friends
class	G4Qt3DViewer

Additional Inherited Members
Public Types inherited from G4VSceneHandler
enum	MarkerSizeType { world , screen }

Detailed Description

Definition at line 40 of file G4Qt3DSceneHandler.hh.

Constructor & Destructor Documentation

◆ G4Qt3DSceneHandler()

G4Qt3DSceneHandler::G4Qt3DSceneHandler	(	G4VGraphicsSystem &	system,
		const G4String &	name )

Definition at line 92 of file G4Qt3DSceneHandler.cc.

: G4VSceneHandler(system, fSceneIdCount++, name)
,fpQt3DScene(nullptr)
,fpTransientObjects(nullptr)
,fpPersistentObjects(nullptr)
{
#ifdef G4QT3DDEBUG
  G4cout << "G4Qt3DSceneHandler::G4Qt3DSceneHandler called" << G4endl;
#endif
  fpQt3DScene = new Qt3DCore::QEntity;
  fpQt3DScene->setObjectName("G4Qt3DSceneRoot");
  EstablishG4Qt3DQEntities();
}

◆ ~G4Qt3DSceneHandler()

G4Qt3DSceneHandler::~G4Qt3DSceneHandler ( )

virtual

Definition at line 107 of file G4Qt3DSceneHandler.cc.

{
  if (fpQt3DScene) {
    G4Qt3DUtils::delete_components_and_children_of_entity_recursively(fpQt3DScene);
    delete fpQt3DScene;
  }
}

Member Function Documentation

◆ AddCompound() [1/6]

void G4Qt3DSceneHandler::AddCompound ( const G4Mesh & mesh )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1101 of file G4Qt3DSceneHandler.cc.

{
  StandardSpecialMeshRendering(mesh);
}

◆ AddCompound() [2/6]

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4double > & hits )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 133 of file G4VSceneHandler.cc.

                                                                   {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    std::size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
        const G4String& mapNam = const_cast<G4THitsMap<G4double>&>(hits).GetName();
    for(MeshScoreMap::const_iterator i = scoreMap.cbegin();
        i != scoreMap.cend(); ++i) {
      const G4String& scoreMapName = i->first;
      if (scoreMapName == mapNam) {
        G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
        scoreMapHits = true;
        mesh->DrawMesh(scoreMapName, &colorMap);
      }
    }
      }
    }
  }
  if (scoreMapHits) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4cout <<
    "Scoring map drawn with default parameters."
    "\n  To get gMocren file for gMocren browser:"
    "\n    /vis/open gMocrenFile"
    "\n    /vis/viewer/flush"
    "\n  Many other options available with /score/draw... commands."
    "\n  You might want to \"/vis/viewer/set/autoRefresh false\"."
         << G4endl;
    }
  } else {  // Not score map hits.  Just call DrawAllHits.
    // Cast away const because DrawAllHits is non-const!!!!
    const_cast<G4THitsMap<G4double>&>(hits).DrawAllHits();
  }
}

◆ AddCompound() [3/6]

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4StatDouble > & hits )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 134 of file G4VSceneHandler.cc.

                                                                       {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    std::size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
    for(MeshScoreMap::const_iterator i = scoreMap.cbegin();
        i != scoreMap.cend(); ++i) {
      const G4String& scoreMapName = i->first;
      const G4THitsMap<G4StatDouble>* foundHits = i->second;
      if (foundHits == &hits) {
        G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
        scoreMapHits = true;
        mesh->DrawMesh(scoreMapName, &colorMap);
      }
    }
      }
    }
  }
  if (scoreMapHits) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4cout <<
    "Scoring map drawn with default parameters."
    "\n  To get gMocren file for gMocren browser:"
    "\n    /vis/open gMocrenFile"
    "\n    /vis/viewer/flush"
    "\n  Many other options available with /score/draw... commands."
    "\n  You might want to \"/vis/viewer/set/autoRefresh false\"."
         << G4endl;
    }
  } else {  // Not score map hits.  Just call DrawAllHits.
    // Cast away const because DrawAllHits is non-const!!!!
    const_cast<G4THitsMap<G4StatDouble>&>(hits).DrawAllHits();
  }
}

◆ AddCompound() [4/6]

void G4VSceneHandler::AddCompound ( const G4VDigi & digi )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 132 of file G4VSceneHandler.cc.

                                                      {
  // Cast away const because Draw is non-const!!!!
  const_cast<G4VDigi&>(digi).Draw();
}

◆ AddCompound() [5/6]

void G4VSceneHandler::AddCompound ( const G4VHit & hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 131 of file G4VSceneHandler.cc.

                                                    {
  // Cast away const because Draw is non-const!!!!
  const_cast<G4VHit&>(hit).Draw();
}

◆ AddCompound() [6/6]

void G4VSceneHandler::AddCompound ( const G4VTrajectory & traj )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 130 of file G4VSceneHandler.cc.

                                                            {
  G4TrajectoriesModel* trajectoriesModel =
    dynamic_cast<G4TrajectoriesModel*>(fpModel);
  if (trajectoriesModel)
    traj.DrawTrajectory();
  else {
    G4Exception
    ("G4VSceneHandler::AddCompound(const G4VTrajectory&)",
     "visman0105", FatalException, "Not a G4TrajectoriesModel.");
  }
}

◆ AddPrimitive() [1/7]

void G4Qt3DSceneHandler::AddPrimitive ( const G4Circle & circle )

virtual

Implements G4VSceneHandler.

Definition at line 590 of file G4Qt3DSceneHandler.cc.

{
#ifdef G4QT3DDEBUG
  G4cout <<
  "G4Qt3DSceneHandler::AddPrimitive(const G4Circle& circle) called.\n"
  << circle
  << G4endl;
#endif
 
#ifdef G4QT3DDEBUG
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize (circle, sizeType);
  switch (sizeType) {
    default:
    case screen:
      // Draw in screen coordinates.
      G4cout << "screen";
      break;
    case world:
      // Draw in world coordinates.
      G4cout << "world";
      break;
  }
  G4cout << " size: " << size << G4endl;
#endif
 
  auto currentNode = CreateNewNode();
  if (!currentNode) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4Exception("G4Qt3DSceneHandler::AddPrimitive(const G4Circle&)",
          "qt3d-0003", JustWarning,
          "No available node!");
    }
    return;
  }
 
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(circle.GetVisAttributes());
 
  auto position = fObjectTransformation*G4Translate3D(circle.GetPosition());
  auto transform = G4Qt3DUtils::CreateQTransformFrom(position);
 
  const auto& colour = fpVisAttribs->GetColour();
  auto material = new Qt3DExtras::QDiffuseSpecularMaterial();
  material->setObjectName("materialForCircle");
  material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
  if (colour.GetAlpha() < 1.) material->setAlphaBlendingEnabled(true);
 
  auto sphereMesh = new Qt3DExtras::QSphereMesh;
  sphereMesh->setObjectName("sphereMesh");
  G4double radius;
  if (circle.GetSizeType() == G4VMarker::world ) {
    radius =circle.GetWorldRadius();
  } else {  // Screen-size or none
    // Not figured out how to do screen-size, so use scene extent
    const G4double scale = 200.;  // Roughly pixles per scene
    radius = circle.GetScreenRadius()*fpScene->GetExtent().GetExtentRadius()/scale;
  }
  sphereMesh->setRadius(radius);
 
  auto currentEntity = new Qt3DCore::QEntity(currentNode);
  currentEntity->addComponent(material);
  currentEntity->addComponent(transform);
  currentEntity->addComponent(sphereMesh);
}

◆ AddPrimitive() [2/7]

void G4VSceneHandler::AddPrimitive ( const G4Plotter & )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 195 of file G4VSceneHandler.cc.

                                                    {
  G4warn << "WARNING: Plotter not implemented for " << fSystem.GetName() << G4endl;
  G4warn << "  Open a plotter-aware graphics system or remove plotter with" << G4endl;
  G4warn << "  /vis/scene/removeModel Plotter" << G4endl;
}

◆ AddPrimitive() [3/7]

void G4Qt3DSceneHandler::AddPrimitive ( const G4Polyhedron & polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 726 of file G4Qt3DSceneHandler.cc.

{
  auto currentNode = CreateNewNode();
  if (!currentNode) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4Exception("G4Qt3DSceneHandler::AddPrimitive(const G4Polyhedron&)",
          "qt3d-0003", JustWarning,
          "No available node!");
    }
    return;
  }
 
  if (polyhedron.GetNoFacets() == 0) return;
 
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(polyhedron.GetVisAttributes());
 
  // Roll out vertices and normals for the faces. Note that this means vertices
  // are duplicated. For example a box has 8 vertices, but to define 6 faces
  // you need 12 triangles and 36 vertices. If it was just a matter of vertices
  // we could restrict the number to 8 and use the indices to define the
  // triangles, but we also have to consider the normals. A vertex can be have
  // more than one normal, depending on which face it is being used to define.
  // So we roll out all the vertices and normals for each triangle.
  std::vector<G4Point3D> vertices;
  std::vector<G4Normal3D> normals;
 
  // Also roll out edges (as lines) for wireframe. Avoid duplicate lines,
  // including those that differ only in the order of vertices.
  typedef std::pair<G4Point3D,G4Point3D> Line;
  std::vector<Line> lines;
  auto insertIfNew = [&lines](const Line& newLine) {
    // For a large polyhedron, eliminating lines like this is prohibitively
    // expensive. Comment out for now, and maybe unwind altogether in future.
    // Allow the graphics-reps utilities to optimise things like this.
//    for (const auto& line: lines) {
//      if ((newLine.first==line.first && newLine.second==line.second) ||
//          (newLine.first==line.second && newLine.second==line.first))
//      return;
//    }
    lines.push_back(newLine);
  };
 
  G4bool isAuxilaryEdgeVisible = fpViewer->GetViewParameters().IsAuxEdgeVisible();
  G4bool notLastFace;
  do {
    G4int      nEdges;
    G4Point3D  vertex  [4];
    G4int      edgeFlag[4];
    G4Normal3D normal  [4];
    notLastFace = polyhedron.GetNextFacet(nEdges, vertex, edgeFlag, normal);
    vertices.push_back(vertex[0]);
    vertices.push_back(vertex[1]);
    vertices.push_back(vertex[2]);
    normals.push_back(normal[0]);
    normals.push_back(normal[1]);
    normals.push_back(normal[2]);
    if(isAuxilaryEdgeVisible||edgeFlag[0]>0)insertIfNew(Line(vertex[0],vertex[1]));
    if(isAuxilaryEdgeVisible||edgeFlag[1]>0)insertIfNew(Line(vertex[1],vertex[2]));
    if (nEdges == 3) {
      // Face is a triangle
      // One more line for wireframe, triangles for surfaces are complete
      if(isAuxilaryEdgeVisible||edgeFlag[2]>0)insertIfNew(Line(vertex[2],vertex[0]));
    } else if (nEdges == 4) {
      // Face is a quadrilateral
      // Create another triangle for surfaces, add two more lines for wireframe
      vertices.push_back(vertex[2]);
      vertices.push_back(vertex[3]);
      vertices.push_back(vertex[0]);
      normals.push_back(normal[2]);
      normals.push_back(normal[3]);
      normals.push_back(normal[0]);
      if(isAuxilaryEdgeVisible||edgeFlag[2]>0)insertIfNew(Line(vertex[2],vertex[3]));
      if(isAuxilaryEdgeVisible||edgeFlag[3]>0)insertIfNew(Line(vertex[3],vertex[0]));
    } else {
      G4warn
      << "ERROR: polyhedron face with unexpected number of edges (" << nEdges << ')'
      << "\n  Tag: " << fpModel->GetCurrentTag()
      << G4endl;
      return;
    }
  } while (notLastFace);
  const auto nVerts = vertices.size();
  const auto nLines = lines.size();
 
  // Now put stuff into Qt objects
 
  auto transform = G4Qt3DUtils::CreateQTransformFrom(fObjectTransformation);
  transform->setObjectName("transform");
 
  Qt3DCore::QEntity* wireframeEntity = nullptr;
  Qt3DCore::QEntity* surfaceEntity   = nullptr;
  static G4int errorCount = 0;
  G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (fpVisAttribs);
  switch (drawing_style) {
    case G4ViewParameters::wireframe:
      wireframeEntity = new Qt3DCore::QEntity(currentNode);
      wireframeEntity->addComponent(transform);
      break;
    case G4ViewParameters::hlr:
      wireframeEntity = new Qt3DCore::QEntity(currentNode);
      wireframeEntity->addComponent(transform);
      surfaceEntity = new Qt3DCore::QEntity(currentNode);
      surfaceEntity->addComponent(transform);
      break;
    case G4ViewParameters::hsr:
      surfaceEntity = new Qt3DCore::QEntity(currentNode);
      surfaceEntity->addComponent(transform);
      break;
    case G4ViewParameters::hlhsr:
      wireframeEntity = new Qt3DCore::QEntity(currentNode);
      wireframeEntity->addComponent(transform);
      surfaceEntity = new Qt3DCore::QEntity(currentNode);
      surfaceEntity->addComponent(transform);
      break;
    case G4ViewParameters::cloud:
      // Shouldn't happen in this function (it's a polyhedron!)
      if (errorCount == 0) {
        ++errorCount;
        G4warn << "WARNING: Qt3D: cloud drawing not implemented" << G4endl;
      }
      return;
      break;
  }
 
  const auto vertexByteSize  = 3*sizeof(PRECISION);
 
  G4Qt3DCompat::QGeometry* vertexGeometry = nullptr;
  G4Qt3DCompat::QGeometry* lineGeometry   = nullptr;
 
  G4Qt3DCompat::QAttribute* positionAtt = nullptr;
  G4Qt3DCompat::QAttribute* normalAtt   = nullptr;
  G4Qt3DCompat::QAttribute* lineAtt     = nullptr;
  G4Qt3DCompat::QAttribute* dummyNormalLineAtt = nullptr;
 
  G4Qt3DCompat::QBuffer* vertexBuffer = nullptr;
  if (drawing_style == G4ViewParameters::hlr ||
      drawing_style == G4ViewParameters::hsr ||
      drawing_style == G4ViewParameters::hlhsr) {
 
    // Put vertices, normals into  QByteArray
    // Accomodates both vertices and normals - hence 2*
    QByteArray vertexByteArray;
    const auto vertexBufferByteSize = 2*nVerts*vertexByteSize;
    vertexByteArray.resize((G4int)vertexBufferByteSize);
    auto vertexBufferArray = reinterpret_cast<PRECISION*>(vertexByteArray.data());
    G4int i1 = 0;
    for (std::size_t i = 0; i < nVerts; ++i) {
      vertexBufferArray[i1++] = vertices[i].x();
      vertexBufferArray[i1++] = vertices[i].y();
      vertexBufferArray[i1++] = vertices[i].z();
      vertexBufferArray[i1++] = normals[i].x();
      vertexBufferArray[i1++] = normals[i].y();
      vertexBufferArray[i1++] = normals[i].z();
    }
    // Vertex buffer (vertices and normals)
    vertexGeometry = new G4Qt3DCompat::QGeometry();
    vertexGeometry->setObjectName("vertexGeometry");
    vertexBuffer = new G4Qt3DCompat::QBuffer(vertexGeometry);
    vertexBuffer->setObjectName("Vertex buffer");
    vertexBuffer->setData(vertexByteArray);
 
    // Position attribute
    positionAtt = new G4Qt3DCompat::QAttribute;
    positionAtt->setObjectName("Position attribute");
    positionAtt->setName(G4Qt3DCompat::QAttribute::defaultPositionAttributeName());
    positionAtt->setBuffer(vertexBuffer);
    positionAtt->setAttributeType(G4Qt3DCompat::QAttribute::VertexAttribute);
    positionAtt->setVertexBaseType(BASETYPE);
    positionAtt->setVertexSize(3);
    positionAtt->setCount((G4int)nVerts);
    positionAtt->setByteOffset(0);
    positionAtt->setByteStride(2*vertexByteSize);
 
    // Normal attribute
    normalAtt = new G4Qt3DCompat::QAttribute;
    normalAtt->setObjectName("Normal attribute");
    normalAtt->setName(G4Qt3DCompat::QAttribute::defaultNormalAttributeName());
    normalAtt->setBuffer(vertexBuffer);
    normalAtt->setAttributeType(G4Qt3DCompat::QAttribute::VertexAttribute);
    normalAtt->setVertexBaseType(BASETYPE);
    normalAtt->setVertexSize(3);
    normalAtt->setCount((G4int)nVerts);
    normalAtt->setByteOffset(vertexByteSize);
    normalAtt->setByteStride(2*vertexByteSize);
  }
 
  G4Qt3DCompat::QBuffer* lineBuffer = nullptr;
  if (drawing_style == G4ViewParameters::wireframe ||
      drawing_style == G4ViewParameters::hlr ||
      drawing_style == G4ViewParameters::hlhsr) {
 
    // Put lines into a QByteArray
    QByteArray lineByteArray;
    const auto lineBufferByteSize = 2*nLines*vertexByteSize;
    lineByteArray.resize((G4int)lineBufferByteSize);
    auto lineBufferArray = reinterpret_cast<PRECISION*>(lineByteArray.data());
    G4int i2 = 0;
    for (const auto& line: lines) {
      lineBufferArray[i2++] = line.first.x();
      lineBufferArray[i2++] = line.first.y();
      lineBufferArray[i2++] = line.first.z();
      lineBufferArray[i2++] = line.second.x();
      lineBufferArray[i2++] = line.second.y();
      lineBufferArray[i2++] = line.second.z();
    }
    // Line loop buffer
    lineGeometry = new G4Qt3DCompat::QGeometry();
    lineGeometry->setObjectName("lineGeometry");
    lineBuffer = new G4Qt3DCompat::QBuffer(lineGeometry);
    lineBuffer->setObjectName("Line buffer");
    lineBuffer->setData(lineByteArray);
 
    // Line attribute
    lineAtt = new G4Qt3DCompat::QAttribute;
    lineAtt->setObjectName("Position attribute");
    lineAtt->setName(G4Qt3DCompat::QAttribute::defaultPositionAttributeName());
    lineAtt->setBuffer(lineBuffer);
    lineAtt->setAttributeType(G4Qt3DCompat::QAttribute::VertexAttribute);
    lineAtt->setVertexBaseType(BASETYPE);
    lineAtt->setVertexSize(3);
    lineAtt->setCount((G4int)nLines);
    lineAtt->setByteOffset(0);
    lineAtt->setByteStride(vertexByteSize);
    // Normal attribute (a dummy with count==0) (Qt6 seems to require)
    dummyNormalLineAtt = new G4Qt3DCompat::QAttribute;
    dummyNormalLineAtt->setObjectName("Normal attribute");
    dummyNormalLineAtt->setName(G4Qt3DCompat::QAttribute::defaultNormalAttributeName());
    dummyNormalLineAtt->setBuffer(lineBuffer);
    dummyNormalLineAtt->setAttributeType(G4Qt3DCompat::QAttribute::VertexAttribute);
    dummyNormalLineAtt->setVertexBaseType(BASETYPE);
    dummyNormalLineAtt->setVertexSize(3);
    dummyNormalLineAtt->setCount(0);
    dummyNormalLineAtt->setByteOffset(0);
    dummyNormalLineAtt->setByteStride(vertexByteSize);
  }
 
  // Create material and renderer(s)...
 
  const auto& colour = fpVisAttribs->GetColour();
  Qt3DExtras::QDiffuseSpecularMaterial* material;
  Qt3DRender::QGeometryRenderer* renderer;
  switch (drawing_style) {
      
    case G4ViewParameters::wireframe:
 
      lineGeometry->addAttribute(lineAtt);
      lineGeometry->addAttribute(dummyNormalLineAtt);
 
      material = new Qt3DExtras::QDiffuseSpecularMaterial();
      material->setObjectName("materialForWireframe");
      material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
      material->setShininess(0.);
      material->setSpecular(0.);
      wireframeEntity->addComponent(material);
 
      renderer = new Qt3DRender::QGeometryRenderer;
      renderer->setObjectName("polyhedronWireframeRenderer");
      renderer->setGeometry(lineGeometry);
      renderer->setVertexCount(2*(G4int)nLines);
      renderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Lines);
      wireframeEntity->addComponent(renderer);
 
      break;
 
    case G4ViewParameters::hlr:
 
      // Surfaces with background colour to hide the edges
 
      vertexGeometry->addAttribute(positionAtt);
      vertexGeometry->addAttribute(normalAtt);
 
      material = new Qt3DExtras::QDiffuseSpecularMaterial();
      material->setObjectName("materialForHiddenLines");
      material->setAmbient(Qt::white);  // White for now (should be from fVP)
      material->setShininess(0.);
      material->setSpecular(0.);
      surfaceEntity->addComponent(material);
 
      renderer = new Qt3DRender::QGeometryRenderer;
      renderer->setObjectName("polyhedronSurfaceRenderer");
      renderer->setGeometry(vertexGeometry);
      renderer->setVertexCount((G4int)nVerts);
      renderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles);
      surfaceEntity->addComponent(renderer);
 
      // Edges
 
      lineGeometry->addAttribute(lineAtt);
      lineGeometry->addAttribute(dummyNormalLineAtt);
 
      material = new Qt3DExtras::QDiffuseSpecularMaterial();
      material->setObjectName("materialForWireFrame");
      material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
      material->setShininess(0.);
      material->setSpecular(0.);
      wireframeEntity->addComponent(material);
 
      renderer = new Qt3DRender::QGeometryRenderer;
      renderer->setObjectName("polyhedronWireframeRenderer");
      renderer->setGeometry(lineGeometry);
      renderer->setVertexCount(2*(G4int)nLines);
      renderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Lines);
      wireframeEntity->addComponent(renderer);
 
      break;
 
    case G4ViewParameters::hsr:
 
      vertexGeometry->addAttribute(positionAtt);
      vertexGeometry->addAttribute(normalAtt);
 
      material = new Qt3DExtras::QDiffuseSpecularMaterial();
      material->setObjectName("materialForSurface");
      material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
      if (colour.GetAlpha() < 1.) material->setAlphaBlendingEnabled(true);
      surfaceEntity->addComponent(material);
 
      renderer = new Qt3DRender::QGeometryRenderer;
      renderer->setObjectName("polyhedronSurfaceRenderer");
      renderer->setGeometry(vertexGeometry);
      renderer->setVertexCount((G4int)nVerts);
      renderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles);
      surfaceEntity->addComponent(renderer);
 
      break;
 
    case G4ViewParameters::hlhsr:
 
      // Surfaces
 
      vertexGeometry->addAttribute(positionAtt);
      vertexGeometry->addAttribute(normalAtt);
 
      material = new Qt3DExtras::QDiffuseSpecularMaterial();
      material->setObjectName("materialForSurface");
      material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
      if (colour.GetAlpha() < 1.) material->setAlphaBlendingEnabled(true);
      surfaceEntity->addComponent(material);
 
      renderer = new Qt3DRender::QGeometryRenderer;
      renderer->setObjectName("polyhedronSurfaceRenderer");
      renderer->setGeometry(vertexGeometry);
      renderer->setVertexCount((G4int)nVerts);
      renderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles);
      surfaceEntity->addComponent(renderer);
 
      // Edges
 
      lineGeometry->addAttribute(lineAtt);
      lineGeometry->addAttribute(dummyNormalLineAtt);
 
      material = new Qt3DExtras::QDiffuseSpecularMaterial();
      material->setObjectName("materialForWireframe");
      material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
      material->setShininess(0.);
      material->setSpecular(0.);
      wireframeEntity->addComponent(material);
 
      renderer = new Qt3DRender::QGeometryRenderer;
      renderer->setObjectName("polyhedronSurfaceRenderer");
      renderer->setGeometry(lineGeometry);
      renderer->setVertexCount(2*(G4int)nLines);
      renderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Lines);
      wireframeEntity->addComponent(renderer);
 
      break;
 
    case G4ViewParameters::cloud:
      // Case trapped at start of function, so no need to implement
      break;
  }
}

◆ AddPrimitive() [4/7]

void G4Qt3DSceneHandler::AddPrimitive ( const G4Polyline & polyline )

virtual

Implements G4VSceneHandler.

Definition at line 275 of file G4Qt3DSceneHandler.cc.

{
#ifdef G4QT3DDEBUG
  G4cout <<
  "G4Qt3DSceneHandler::AddPrimitive(const G4Polyline& polyline) called.\n"
  << polyline
  << G4endl;
#endif
  
  if (polyline.size() == 0) return;
 
  auto currentNode = CreateNewNode();
  if (!currentNode) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4Exception("G4Qt3DSceneHandler::AddPrimitive(const G4Polyline&)",
          "qt3d-0003", JustWarning,
          "No available node!");
    }
    return;
  }
 
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(polyline.GetVisAttributes());
 
  auto transform = G4Qt3DUtils::CreateQTransformFrom(fObjectTransformation);
  transform->setObjectName("transform");
 
  auto polylineEntity = new Qt3DCore::QEntity(currentNode);
  polylineEntity->addComponent(transform);
 
  const auto vertexByteSize  = 3*sizeof(PRECISION);
 
  const std::size_t nLines = polyline.size() - 1;
  QByteArray polylineByteArray;
  const auto polylineBufferByteSize = 2*nLines*vertexByteSize;
  polylineByteArray.resize((G4int)polylineBufferByteSize);
  auto polylineBufferArray = reinterpret_cast<PRECISION*>(polylineByteArray.data());
  G4int iLine = 0;
  for (std::size_t i = 0; i < nLines; ++i) {
    polylineBufferArray[iLine++] = polyline[i].x();
    polylineBufferArray[iLine++] = polyline[i].y();
    polylineBufferArray[iLine++] = polyline[i].z();
    polylineBufferArray[iLine++] = polyline[i+1].x();
    polylineBufferArray[iLine++] = polyline[i+1].y();
    polylineBufferArray[iLine++] = polyline[i+1].z();
  }
  auto polylineGeometry = new G4Qt3DCompat::QGeometry();
  polylineGeometry->setObjectName("polylineGeometry");
 
  auto polylineBuffer = new G4Qt3DCompat::QBuffer(polylineGeometry);
  polylineBuffer->setObjectName("Polyline buffer");
  polylineBuffer->setData(polylineByteArray);
 
  auto polylineAtt = new G4Qt3DCompat::QAttribute;
  polylineAtt->setObjectName("Position attribute");
  polylineAtt->setName(G4Qt3DCompat::QAttribute::defaultPositionAttributeName());
  polylineAtt->setBuffer(polylineBuffer);
  polylineAtt->setAttributeType(G4Qt3DCompat::QAttribute::VertexAttribute);
  polylineAtt->setVertexBaseType(BASETYPE);
  polylineAtt->setVertexSize(3);
  polylineAtt->setCount((G4int)nLines);
  polylineAtt->setByteOffset(0);
  polylineAtt->setByteStride(vertexByteSize);
  // Normal attribute (a dummy with count==0) (Qt6 seems to require)
  auto dummyNormalLineAtt = new G4Qt3DCompat::QAttribute;
  dummyNormalLineAtt->setObjectName("Normal attribute");
  dummyNormalLineAtt->setName(G4Qt3DCompat::QAttribute::defaultNormalAttributeName());
  dummyNormalLineAtt->setBuffer(polylineBuffer);
  dummyNormalLineAtt->setAttributeType(G4Qt3DCompat::QAttribute::VertexAttribute);
  dummyNormalLineAtt->setVertexBaseType(BASETYPE);
  dummyNormalLineAtt->setVertexSize(3);
  dummyNormalLineAtt->setCount(0);
  dummyNormalLineAtt->setByteOffset(0);
  dummyNormalLineAtt->setByteStride(vertexByteSize);
 
  const auto& colour = fpVisAttribs->GetColour();
 
  polylineGeometry->addAttribute(polylineAtt);
  polylineGeometry->addAttribute(dummyNormalLineAtt);
 
  auto material = new Qt3DExtras::QDiffuseSpecularMaterial();
  material->setObjectName("materialForPolyline");
  material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
  material->setShininess(0.);
  material->setSpecular(0.);
  polylineEntity->addComponent(material);
 
  auto renderer = new Qt3DRender::QGeometryRenderer;
  renderer->setObjectName("polylineRenderer");
  renderer->setGeometry(polylineGeometry);
  renderer->setVertexCount(2*(G4int)nLines);
  renderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Lines);
  polylineEntity->addComponent(renderer);
}

◆ AddPrimitive() [5/7]

void G4Qt3DSceneHandler::AddPrimitive ( const G4Polymarker & polymarker )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 371 of file G4Qt3DSceneHandler.cc.

{
  if (polymarker.size() == 0) return;
 
  auto currentNode = CreateNewNode();
  if (!currentNode) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4Exception("G4Qt3DSceneHandler::AddPrimitive(const G4Polymarker&)",
          "qt3d-0003", JustWarning,
          "No available node!");
    }
    return;
  }
 
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(polymarker.GetVisAttributes());
 
  MarkerSizeType markerSizeType;
  G4double markerSize = GetMarkerSize(polymarker, markerSizeType);
 
  switch (polymarker.GetMarkerType()) {
    default:
    case G4Polymarker::dots:
    {
      const std::size_t nDots = polymarker.size();
 
      auto transform = G4Qt3DUtils::CreateQTransformFrom(fObjectTransformation);
      transform->setObjectName("transform");
 
      auto polymarkerEntity = new Qt3DCore::QEntity(currentNode);
      polymarkerEntity->addComponent(transform);
 
      const auto vertexByteSize  = 3*sizeof(PRECISION);
 
      QByteArray polymarkerByteArray;
      const auto polymarkerBufferByteSize = nDots*vertexByteSize;
      polymarkerByteArray.resize((G4int)polymarkerBufferByteSize);
      auto polymarkerBufferArray = reinterpret_cast<PRECISION*>(polymarkerByteArray.data());
      G4int iMarker = 0;
      for (std::size_t i = 0; i < polymarker.size(); ++i) {
        polymarkerBufferArray[iMarker++] = polymarker[i].x();
        polymarkerBufferArray[iMarker++] = polymarker[i].y();
        polymarkerBufferArray[iMarker++] = polymarker[i].z();
      }
      auto polymarkerGeometry = new G4Qt3DCompat::QGeometry();
      polymarkerGeometry->setObjectName("polymarkerGeometry");
      auto polymarkerBuffer = new G4Qt3DCompat::QBuffer(polymarkerGeometry);
      polymarkerBuffer->setObjectName("Polymarker buffer");
      polymarkerBuffer->setData(polymarkerByteArray);
 
      auto polymarkerAtt = new G4Qt3DCompat::QAttribute;
      polymarkerAtt->setObjectName("Position attribute");
      polymarkerAtt->setName(G4Qt3DCompat::QAttribute::defaultPositionAttributeName());
      polymarkerAtt->setBuffer(polymarkerBuffer);
      polymarkerAtt->setAttributeType(G4Qt3DCompat::QAttribute::VertexAttribute);
      polymarkerAtt->setVertexBaseType(BASETYPE);
      polymarkerAtt->setVertexSize(3);
      polymarkerAtt->setCount((G4int)nDots);
      polymarkerAtt->setByteOffset(0);
      polymarkerAtt->setByteStride(vertexByteSize);
 
      const auto& colour = fpVisAttribs->GetColour();
 
      polymarkerGeometry->addAttribute(polymarkerAtt);
 
      auto material = new Qt3DExtras::QDiffuseSpecularMaterial();
      material->setObjectName("materialForPolymarker");
      material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
      material->setShininess(0.);
      material->setSpecular(0.);
      polymarkerEntity->addComponent(material);
 
      auto renderer = new Qt3DRender::QGeometryRenderer;
      renderer->setObjectName("polymarkerWireframeRenderer");
      renderer->setGeometry(polymarkerGeometry);
      renderer->setVertexCount((G4int)nDots);
      renderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Points);
      polymarkerEntity->addComponent(renderer);
    }
      break;
    case G4Polymarker::circles:
    {
      G4Circle circle (polymarker);  // Default circle
 
      const auto& colour = fpVisAttribs->GetColour();
      auto material = new Qt3DExtras::QDiffuseSpecularMaterial();
      material->setObjectName("materialForCircle");
      material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
      if (colour.GetAlpha() < 1.) material->setAlphaBlendingEnabled(true);
 
      auto sphereMesh = new Qt3DExtras::QSphereMesh;
      sphereMesh->setObjectName("sphereMesh");
      G4double radius = markerSize/2.;
      if (markerSizeType == G4VSceneHandler::screen ) {
        // Not figured out how to do screen-size, so use scene extent
        const G4double scale = 200.;  // Roughly pixels per scene
        radius *= fpScene->GetExtent().GetExtentRadius()/scale;
      }
      sphereMesh->setRadius(radius);
//      sphereMesh->setInstanceCount(polymarker.size());  // Not undertood instancing yet
 
//      auto currentEntity = new Qt3DCore::QEntity(currentNode);  // Not undertood instancing yet
      for (std::size_t iPoint = 0; iPoint < polymarker.size(); ++iPoint) {
        auto position = fObjectTransformation*G4Translate3D(polymarker[iPoint]);
        auto transform = G4Qt3DUtils::CreateQTransformFrom(position);
    auto currentEntity = new Qt3DCore::QEntity(currentNode);  // Not undertood instancing yet
        currentEntity->addComponent(material);
        currentEntity->addComponent(transform);
        currentEntity->addComponent(sphereMesh);
      }
    }
      break;
    case G4Polymarker::squares:
    {
      G4Square square (polymarker);  // Default square
 
      const auto& colour = fpVisAttribs->GetColour();
      auto material = new Qt3DExtras::QDiffuseSpecularMaterial();
      material->setObjectName("materialForSquare");
      material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
      if (colour.GetAlpha() < 1.) material->setAlphaBlendingEnabled(true);
 
      auto boxMesh = new Qt3DExtras::QCuboidMesh();
      boxMesh->setObjectName("boxMesh");
      G4double side = markerSize;
      if (markerSizeType == G4VSceneHandler::screen ) {
        // Not figured out how to do screen-size, so use scene extent
        const G4double scale = 200.;  // Roughly pixles per scene
        side *= fpScene->GetExtent().GetExtentRadius()/scale;
      }
      boxMesh->setXExtent(side);
      boxMesh->setYExtent(side);
      boxMesh->setZExtent(side);
 
      for (std::size_t iPoint = 0; iPoint < polymarker.size(); ++iPoint) {
        auto position = fObjectTransformation*G4Translate3D(polymarker[iPoint]);
        auto transform = G4Qt3DUtils::CreateQTransformFrom(position);
        auto currentEntity = new Qt3DCore::QEntity(currentNode);
        currentEntity->addComponent(material);
        currentEntity->addComponent(transform);
        currentEntity->addComponent(boxMesh);
      }
    }
      break;
  }
}

◆ AddPrimitive() [6/7]

void G4Qt3DSceneHandler::AddPrimitive ( const G4Square & square )

virtual

Implements G4VSceneHandler.

Definition at line 657 of file G4Qt3DSceneHandler.cc.

{
#ifdef G4QT3DDEBUG
  G4cout <<
  "G4Qt3DSceneHandler::AddPrimitive(const G4Square& square) called.\n"
  << square
  << G4endl;
#endif
 
#ifdef G4QT3DDEBUG
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize (square, sizeType);
  switch (sizeType) {
    default:
    case screen:
      // Draw in screen coordinates.
      G4cout << "screen";
      break;
    case world:
      // Draw in world coordinates.
      G4cout << "world";
      break;
  }
  G4cout << " size: " << size << G4endl;
#endif
 
  auto currentNode = CreateNewNode();
  if (!currentNode) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4Exception("G4Qt3DSceneHandler::AddPrimitive(const G4Square&)",
          "qt3d-0003", JustWarning,
          "No available node!");
    }
    return;
  }
 
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(square.GetVisAttributes());
 
  auto position = fObjectTransformation*G4Translate3D(square.GetPosition());
  auto transform = G4Qt3DUtils::CreateQTransformFrom(position);
 
  const auto& colour = fpVisAttribs->GetColour();
  auto material = new Qt3DExtras::QDiffuseSpecularMaterial();
  material->setObjectName("materialForSquare");
  material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
  if (colour.GetAlpha() < 1.) material->setAlphaBlendingEnabled(true);
 
  auto boxMesh = new Qt3DExtras::QCuboidMesh();
  boxMesh->setObjectName("boxMesh");
  G4double side;
  if (square.GetSizeType() == G4VMarker::world ) {
    side = square.GetWorldDiameter();
  } else {  // Screen-size or none
    // Not figured out how to do screen-size, so use scene extent
    const G4double scale = 200.;  // Roughly pixles per scene
    side = square.GetScreenDiameter()*fpScene->GetExtent().GetExtentRadius()/scale;
  }
  boxMesh->setXExtent(side);
  boxMesh->setYExtent(side);
  boxMesh->setZExtent(side);
 
  auto currentEntity = new Qt3DCore::QEntity(currentNode);
  currentEntity->addComponent(material);
  currentEntity->addComponent(transform);
  currentEntity->addComponent(boxMesh);
}

◆ AddPrimitive() [7/7]

void G4Qt3DSceneHandler::AddPrimitive ( const G4Text & )

virtual

Implements G4VSceneHandler.

Definition at line 526 of file G4Qt3DSceneHandler.cc.

                                                     {
#endif
 
  static G4bool first = true;
  if (first) {
    first = false;
    G4Exception("G4Qt3DSceneHandler::AddPrimitive(const G4Text&)",
                "qt3D-0002", JustWarning,
                "Text drawing doesn't work yet");
  }  // OK. Not working, but let it execute, which it does without error.
 
  /* But it crashes after /vis/viewer/rebuild!!!
  auto currentNode = CreateNewNode();
   if (!currentNode) {
   static G4bool first = true;
   if (first) {
   first = false;
   G4Exception("G4Qt3DSceneHandler::AddPrimitive(const G4Text&)",
   "qt3d-0003", JustWarning,
   "No available node!");
   }
   return;
   }
 
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(text.GetVisAttributes());
 
  auto position = fObjectTransformation*G4Translate3D(text.GetPosition());
  auto transform = G4Qt3DUtils::CreateQTransformFrom(position);
//  transform->setScale(10);
  transform->setScale(0.1);
 
//  auto currentEntity = new Qt3DCore::QEntity(currentNode);
 
  // This simply does not work
  auto qtext = new Qt3DExtras::QText2DEntity();
  qtext->setParent(currentNode);
//  qtext->setParent(currentEntity);  // ??  Doesn't help
  qtext->setText(text.GetText().c_str());
//  qtext->setHeight(100);
//  qtext->setWidth(1000);
  qtext->setHeight(20);
  qtext->setWidth(100);
  qtext->setColor(Qt::green);
  qtext->setFont(QFont("Courier New", 10));
  qtext->addComponent(transform);
 
  // This produces text in 3D facing +z - not what we want
//  const auto& colour = GetTextColour(text);
//  auto material = new Qt3DExtras::QDiffuseSpecularMaterial();
//  material->setObjectName("materialForText");
//  material->setAmbient(G4Qt3DUtils::ConvertToQColor(colour));
//  if (colour.GetAlpha() < 1.) material->setAlphaBlendingEnabled(true);
//
//  auto textMesh = new Qt3DExtras::QExtrudedTextMesh();
//  textMesh->setText(text.GetText().c_str());
//  textMesh->setFont(QFont("Courier New", 10));
//  textMesh->setDepth(.01f);
//
//  currentNode->addComponent(material);
//  currentNode->addComponent(transform);
//  currentNode->addComponent(textMesh);
   */
}

◆ BeginPrimitives()

void G4Qt3DSceneHandler::BeginPrimitives ( const G4Transform3D & objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 264 of file G4Qt3DSceneHandler.cc.

{
  G4VSceneHandler::BeginPrimitives(objectTransformation);
}

◆ BeginPrimitives2D()

void G4Qt3DSceneHandler::BeginPrimitives2D ( const G4Transform3D & objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 237 of file G4Qt3DSceneHandler.cc.

{
// The x,y coordinates of the primitives passed to AddPrimitive are
// intrepreted as screen coordinates, -1 < x,y < 1.  The
// z-coordinate is ignored.
// IMPORTANT: invoke this from your polymorphic versions, e.g.:
// void MyXXXSceneHandler::BeginPrimitives2D
// (const G4Transform3D& objectTransformation) {
  static G4bool first = true;
  if (first) {
    first = false;
    G4Exception("G4Qt3DSceneHandler::BeginPrimitives2D", "qt3D-0001",
                JustWarning,
                "2D drawing not yet implemented");
  }
   G4VSceneHandler::BeginPrimitives2D (objectTransformation);
//   ...
}

◆ ClearStore()

void G4Qt3DSceneHandler::ClearStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1106 of file G4Qt3DSceneHandler.cc.

{
  G4Qt3DUtils::delete_components_and_children_of_entity_recursively(fpQt3DScene);
  EstablishG4Qt3DQEntities();
}

◆ ClearTransientStore()

void G4Qt3DSceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1112 of file G4Qt3DSceneHandler.cc.

{
  G4Qt3DUtils::delete_components_and_children_of_entity_recursively(fpTransientObjects);
}

◆ CreateNewNode()

G4Qt3DQEntity * G4Qt3DSceneHandler::CreateNewNode ( )

protected

Definition at line 139 of file G4Qt3DSceneHandler.cc.

{
  // Create a G4Qt3DQEntity node suitable for next solid or primitive
 
  G4Qt3DQEntity* newNode = nullptr;
 
  if (fReadyForTransients) {  // All transients hang from this node
    newNode = new G4Qt3DQEntity(fpTransientObjects);
    G4String name = fpModel? fpModel->GetGlobalTag(): G4String("User");
    newNode->setObjectName(name.c_str());
    return newNode;
  }
 
  G4PhysicalVolumeModel* pPVModel =
    dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
 
  if (!pPVModel) {  // Persistent objects (e.g., axes)
    newNode = new G4Qt3DQEntity(fpPersistentObjects);
    newNode->setObjectName(fpModel->GetGlobalTag().c_str());
    return newNode;
  }
 
  // So this is a G4PhysicalVolumeModel
  
  typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
  typedef std::vector<PVNodeID> PVPath;
//  const PVPath& drawnPVPath = pPVModel->GetDrawnPVPath();
  const PVPath& fullPVPath  = pPVModel->GetFullPVPath();
  //G4int currentDepth = pPVModel->GetCurrentDepth();
  //G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
  //G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
  //G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
  // Note: pCurrentMaterial may be zero (parallel world).
 
#ifdef G4QTDEBUG
  G4cout << "A: " << fullPVPath << G4endl;  // DEBUG
#endif
 
  // Find appropriate root
  const std::size_t nWorlds = fpPhysicalVolumeObjects.size();
  std::size_t iWorld = 0;
  for (; iWorld < nWorlds; ++iWorld) {
    if (fullPVPath[0].GetPhysicalVolume() ==
        fpPhysicalVolumeObjects[iWorld]->GetPVNodeID().GetPhysicalVolume()) break;
  }
  if (iWorld == nWorlds) {
    G4Exception("G4Qt3DSceneHandler::CreateNewNode", "qt3D-0000", FatalException,
                "World mis-match - not possible(!?)");
  }
 
  // (Re-)establish pv path of root entity
  G4Qt3DQEntity* wrld = fpPhysicalVolumeObjects[iWorld];
  wrld->SetPVNodeID(fullPVPath[0]);
 
  // Create nodes as required
  G4Qt3DQEntity* node = wrld;
  newNode = node;
  const std::size_t depth = fullPVPath.size();
  std::size_t iDepth = 1;
  while (iDepth < depth) {
    const auto& children = node->children();
    const G4int nChildren = (G4int)children.size();
    G4int iChild = 0;
    G4Qt3DQEntity* child = nullptr;
    for (; iChild < nChildren; ++iChild) {
      child = static_cast<G4Qt3DQEntity*>(children[iChild]);
      if (child->GetPVNodeID() == fullPVPath[iDepth]) break;
    }
    if (iChild != nChildren) {  // Existing node found
      node = child;  // Must be the ancestor of new node (subsequent iteration)
    } else {
      // Add a new node as child of node
      newNode = new G4Qt3DQEntity(node);
      newNode->SetPVNodeID(fullPVPath[iDepth]);
      std::ostringstream oss;
      oss << newNode->GetPVNodeID().GetPhysicalVolume()->GetName()
      << ':' << newNode->GetPVNodeID().GetCopyNo();
      newNode->setObjectName(oss.str().c_str());
      node = newNode;
    }
    ++iDepth;
  }
 
  return node;
}

Referenced by AddPrimitive(), AddPrimitive(), AddPrimitive(), AddPrimitive(), and AddPrimitive().

◆ EndPrimitives()

void G4Qt3DSceneHandler::EndPrimitives ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 270 of file G4Qt3DSceneHandler.cc.

{
  G4VSceneHandler::EndPrimitives ();
}

◆ EndPrimitives2D()

void G4Qt3DSceneHandler::EndPrimitives2D ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 256 of file G4Qt3DSceneHandler.cc.

{
// IMPORTANT: invoke this from your polymorphic versions, e.g.:
// void MyXXXSceneHandler::EndPrimitives2D () {
//   ...
  G4VSceneHandler::EndPrimitives2D ();
}

◆ EstablishG4Qt3DQEntities()

void G4Qt3DSceneHandler::EstablishG4Qt3DQEntities ( )

protected

Definition at line 115 of file G4Qt3DSceneHandler.cc.

{
  fpTransientObjects  = new G4Qt3DQEntity(fpQt3DScene);  // Hangs from root
  fpTransientObjects  ->setObjectName("G4Qt3DTORoot");
  fpPersistentObjects = new G4Qt3DQEntity(fpQt3DScene);  // Hangs from root
  fpPersistentObjects ->setObjectName("G4Qt3DPORoot");
 
  // Physical volume objects hang from POs
  fpPhysicalVolumeObjects.clear();
  if (fpScene) {
    const auto& sceneModels = fpScene->GetRunDurationModelList();
    for (const auto& sceneModel : sceneModels) {
      const auto& pvModel = dynamic_cast<G4PhysicalVolumeModel*>(sceneModel.fpModel);
      if (pvModel) {
        auto entity = new G4Qt3DQEntity(fpPersistentObjects);
        const auto& pv = pvModel->GetTopPhysicalVolume();
        entity->setObjectName("G4Qt3DPORoot_"+QString(pv->GetName()));
        entity->SetPVNodeID(G4PhysicalVolumeModel::G4PhysicalVolumeNodeID(pv));
        fpPhysicalVolumeObjects.push_back(entity);
      }
    }
  }
}

Referenced by ClearStore(), and G4Qt3DSceneHandler().

◆ PostAddSolid()

void G4Qt3DSceneHandler::PostAddSolid ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 232 of file G4Qt3DSceneHandler.cc.

{
  G4VSceneHandler::PostAddSolid();
}

◆ PreAddSolid()

void G4Qt3DSceneHandler::PreAddSolid	(	const G4Transform3D &	objectTransformation,
		const G4VisAttributes &	visAttribs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 225 of file G4Qt3DSceneHandler.cc.

{  
  G4VSceneHandler::PreAddSolid(objectTransformation, visAttribs);
}

Friends And Related Symbol Documentation

◆ G4Qt3DViewer

friend class G4Qt3DViewer

friend

Definition at line 42 of file G4Qt3DSceneHandler.hh.

Referenced by G4Qt3DViewer.

Member Data Documentation

◆ fpPersistentObjects

Qt3DCore::QEntity* G4Qt3DSceneHandler::fpPersistentObjects

protected

Definition at line 83 of file G4Qt3DSceneHandler.hh.

Referenced by CreateNewNode(), EstablishG4Qt3DQEntities(), and G4Qt3DSceneHandler().

◆ fpPhysicalVolumeObjects

std::vector<G4Qt3DQEntity*> G4Qt3DSceneHandler::fpPhysicalVolumeObjects

protected

Definition at line 84 of file G4Qt3DSceneHandler.hh.

Referenced by CreateNewNode(), and EstablishG4Qt3DQEntities().

◆ fpQt3DScene

Qt3DCore::QEntity* G4Qt3DSceneHandler::fpQt3DScene

protected

Definition at line 81 of file G4Qt3DSceneHandler.hh.

Referenced by ClearStore(), EstablishG4Qt3DQEntities(), G4Qt3DSceneHandler(), and ~G4Qt3DSceneHandler().

◆ fpTransientObjects

Qt3DCore::QEntity* G4Qt3DSceneHandler::fpTransientObjects

protected

Definition at line 82 of file G4Qt3DSceneHandler.hh.

Referenced by ClearTransientStore(), CreateNewNode(), EstablishG4Qt3DQEntities(), and G4Qt3DSceneHandler().

◆ fSceneIdCount

G4int G4Qt3DSceneHandler::fSceneIdCount = 0

staticprotected

Definition at line 79 of file G4Qt3DSceneHandler.hh.

Referenced by G4Qt3DSceneHandler().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Qt3DSceneHandler()

◆ ~G4Qt3DSceneHandler()

Member Function Documentation

◆ AddCompound() [1/6]

◆ AddCompound() [2/6]

◆ AddCompound() [3/6]

◆ AddCompound() [4/6]

◆ AddCompound() [5/6]

◆ AddCompound() [6/6]

◆ AddPrimitive() [1/7]

◆ AddPrimitive() [2/7]

◆ AddPrimitive() [3/7]

◆ AddPrimitive() [4/7]

◆ AddPrimitive() [5/7]

◆ AddPrimitive() [6/7]

◆ AddPrimitive() [7/7]

◆ BeginPrimitives()

◆ BeginPrimitives2D()

◆ ClearStore()

◆ ClearTransientStore()

◆ CreateNewNode()

◆ EndPrimitives()

◆ EndPrimitives2D()

◆ EstablishG4Qt3DQEntities()

◆ PostAddSolid()

◆ PreAddSolid()

Friends And Related Symbol Documentation

◆ G4Qt3DViewer

Member Data Documentation

◆ fpPersistentObjects

◆ fpPhysicalVolumeObjects

◆ fpQt3DScene

◆ fpTransientObjects

◆ fSceneIdCount