Qgs3DMapScene::Qgs3DMapScene( const Qgs3DMapSettings &map, QgsAbstract3DEngine *engine )
: mMap( map )
, mEngine( engine )
{
connect( &map, &Qgs3DMapSettings::backgroundColorChanged, this, &Qgs3DMapScene::onBackgroundColorChanged );
onBackgroundColorChanged();
// TODO: strange - setting OnDemand render policy still keeps QGIS busy (Qt 5.9.0)
// actually it is more busy than with the default "Always" policy although there are no changes in the scene.
//mRenderer->renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::OnDemand );
#if QT_VERSION >= 0x050900
// we want precise picking of terrain (also bounding volume picking does not seem to work - not sure why)
mEngine->renderSettings()->pickingSettings()->setPickMethod( Qt3DRender::QPickingSettings::TrianglePicking );
#endif
QRect viewportRect( QPoint( 0, 0 ), mEngine->size() );
// Camera
float aspectRatio = ( float )viewportRect.width() / viewportRect.height();
mEngine->camera()->lens()->setPerspectiveProjection( mMap.fieldOfView(), aspectRatio, 10.f, 10000.0f );
mFrameAction = new Qt3DLogic::QFrameAction();
connect( mFrameAction, &Qt3DLogic::QFrameAction::triggered,
this, &Qgs3DMapScene::onFrameTriggered );
addComponent( mFrameAction ); // takes ownership
// Camera controlling
mCameraController = new QgsCameraController( this ); // attaches to the scene
mCameraController->setViewport( viewportRect );
mCameraController->setCamera( mEngine->camera() );
mCameraController->resetView( 1000 );
addCameraViewCenterEntity( mEngine->camera() );
// create terrain entity
createTerrainDeferred();
connect( &map, &Qgs3DMapSettings::terrainGeneratorChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::terrainVerticalScaleChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::mapTileResolutionChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::maxTerrainScreenErrorChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::maxTerrainGroundErrorChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::terrainShadingChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::pointLightsChanged, this, &Qgs3DMapScene::updateLights );
connect( &map, &Qgs3DMapSettings::fieldOfViewChanged, this, &Qgs3DMapScene::updateCameraLens );
// create entities of renderers
Q_FOREACH ( const QgsAbstract3DRenderer *renderer, map.renderers() )
{
Qt3DCore::QEntity *newEntity = renderer->createEntity( map );
newEntity->setParent( this );
}
// listen to changes of layers in order to add/remove 3D renderer entities
connect( &map, &Qgs3DMapSettings::layersChanged, this, &Qgs3DMapScene::onLayersChanged );
updateLights();
#if 0
ChunkedEntity *testChunkEntity = new ChunkedEntity( AABB( -500, 0, -500, 500, 100, 500 ), 2.f, 3.f, 7, new TestChunkLoaderFactory );
testChunkEntity->setEnabled( false );
testChunkEntity->setParent( this );
chunkEntities << testChunkEntity;
#endif
connect( mCameraController, &QgsCameraController::cameraChanged, this, &Qgs3DMapScene::onCameraChanged );
connect( mCameraController, &QgsCameraController::viewportChanged, this, &Qgs3DMapScene::onCameraChanged );
#if 0
// experiments with loading of existing 3D models.
// scene loader only gets loaded only when added to a scene...
// it loads everything: geometries, materials, transforms, lights, cameras (if any)
Qt3DCore::QEntity *loaderEntity = new Qt3DCore::QEntity;
Qt3DRender::QSceneLoader *loader = new Qt3DRender::QSceneLoader;
loader->setSource( QUrl( "file:///home/martin/Downloads/LowPolyModels/tree.dae" ) );
loaderEntity->addComponent( loader );
loaderEntity->setParent( this );
// mesh loads just geometry as one geometry...
// so if there are different materials (e.g. colors) used in the model, this information is lost
Qt3DCore::QEntity *meshEntity = new Qt3DCore::QEntity;
Qt3DRender::QMesh *mesh = new Qt3DRender::QMesh;
mesh->setSource( QUrl( "file:///home/martin/Downloads/LowPolyModels/tree.obj" ) );
meshEntity->addComponent( mesh );
Qt3DExtras::QPhongMaterial *material = new Qt3DExtras::QPhongMaterial;
material->setAmbient( Qt::red );
meshEntity->addComponent( material );
Qt3DCore::QTransform *meshTransform = new Qt3DCore::QTransform;
meshTransform->setScale( 1 );
meshEntity->addComponent( meshTransform );
meshEntity->setParent( this );
#endif
if ( map.hasSkyboxEnabled() )
{
Qt3DExtras::QSkyboxEntity *skybox = new Qt3DExtras::QSkyboxEntity;
skybox->setBaseName( map.skyboxFileBase() );
skybox->setExtension( map.skyboxFileExtension() );
skybox->setParent( this );
// docs say frustum culling must be disabled for skybox.
// it _somehow_ works even when frustum culling is enabled with some camera positions,
// but then when zoomed in more it would disappear - so let's keep frustum culling disabled
mEngine->setFrustumCullingEnabled( false );
}
// force initial update of chunked entities
onCameraChanged();
}
void QgsPolygon3DSymbolEntity::addEntityForSelectedPolygons( const Qgs3DMapSettings &map, QgsVectorLayer *layer, const QgsPolygon3DSymbol &symbol )
{
// build the default material
Qt3DExtras::QPhongMaterial *mat = material( symbol );
// update the material with selection colors
mat->setDiffuse( map.selectionColor() );
mat->setAmbient( map.selectionColor().darker() );
// build a transform function
Qt3DCore::QTransform *tform = new Qt3DCore::QTransform;
tform->setTranslation( QVector3D( 0, 0, 0 ) );
// build the feature request to select features
QgsFeatureRequest req;
req.setDestinationCrs( map.crs() );
req.setSubsetOfAttributes( _requiredAttributes( symbol, layer ), layer->fields() );
req.setFilterFids( layer->selectedFeatureIds() );
// build the entity
QgsPolygon3DSymbolEntityNode *entity = new QgsPolygon3DSymbolEntityNode( map, layer, symbol, req );
entity->addComponent( mat );
entity->addComponent( tform );
entity->setParent( this );
}
void PhysicsTransform::updateFromPeer(Qt3DCore::QNode *peer){
Qt3DCore::QTransform *transform = static_cast<Qt3DCore::QTransform *>(peer);
m_rotation = transform->rotation();
m_scale = transform->scale3D();
m_translation = transform->translation();
updateMatrix();
m_enabled = transform->isEnabled();
m_dirty=true;
}
Qt3DCore::QEntity *QgsDemTerrainTileLoader::createEntity( Qt3DCore::QEntity *parent )
{
QgsTerrainTileEntity *entity = new QgsTerrainTileEntity;
// create geometry renderer
Qt3DRender::QGeometryRenderer *mesh = new Qt3DRender::QGeometryRenderer;
mesh->setGeometry( new DemTerrainTileGeometry( mResolution, mHeightMap, mesh ) );
entity->addComponent( mesh ); // takes ownership if the component has no parent
// create material
createTextureComponent( entity );
// create transform
Qt3DCore::QTransform *transform;
transform = new Qt3DCore::QTransform();
entity->addComponent( transform );
float zMin, zMax;
_heightMapMinMax( mHeightMap, zMin, zMax );
const Qgs3DMapSettings &map = terrain()->map3D();
QgsRectangle extent = map.terrainGenerator()->tilingScheme().tileToExtent( mNode->tileX(), mNode->tileY(), mNode->tileZ() ); //node->extent;
double x0 = extent.xMinimum() - map.originX();
double y0 = extent.yMinimum() - map.originY();
double side = extent.width();
double half = side / 2;
transform->setScale3D( QVector3D( side, map.terrainVerticalScale(), side ) );
transform->setTranslation( QVector3D( x0 + half, 0, - ( y0 + half ) ) );
mNode->setExactBbox( QgsAABB( x0, zMin * map.terrainVerticalScale(), -y0, x0 + side, zMax * map.terrainVerticalScale(), -( y0 + side ) ) );
entity->setEnabled( false );
entity->setParent( parent );
return entity;
}
Transformer::Transformer()
: m_bed(new Qt3DCore::QEntity())
{
Qt3DRender::QPlaneMesh * cube = new Qt3DRender::QPlaneMesh();
cube->setWidth(20.0f);
cube->setHeight(20.0f);
cube->setMeshResolution(QSize(20,20));
m_bed->addComponent(cube);
Qt3DCore::QTransform *cylinderTransform = new Qt3DCore::QTransform;
cylinderTransform->setScale(1.0f);
cylinderTransform->setRotation(QQuaternion::fromAxisAndAngle(QVector3D(1, 0, 0), 90.0f));
cylinderTransform->setTranslation(QVector3D{0,0,10});
m_material = new Qt3DRender::QPhongMaterial();
m_material->setAmbient(Qt::red);
m_material->setDiffuse(Qt::red);
m_material->setSpecular(Qt::black);
m_material->setEnabled(true);
m_bed->addComponent(m_material);
}
virtual Qt3DCore::QEntity *createEntity( Qt3DCore::QEntity *parent )
{
Qt3DCore::QEntity *entity = new Qt3DCore::QEntity;
// create geometry renderer
Qt3DRender::QGeometryRenderer *mesh = new Qt3DRender::QGeometryRenderer;
mesh->setGeometry( new QuantizedMeshGeometry( qmt, mTerrain->map3D(), mapSettings.mapToPixel(), mTerrain->terrainToMapTransform(), mesh ) );
entity->addComponent( mesh );
// create material
createTextureComponent( entity );
// create transform
Qt3DCore::QTransform *transform;
transform = new Qt3DCore::QTransform();
entity->addComponent( transform );
const Map3D &map = mTerrain->map3D();
transform->setScale3D( QVector3D( 1.f, map.zExaggeration, 1.f ) );
QgsRectangle mapExtent = mapSettings.extent();
float x0 = mapExtent.xMinimum() - map.originX;
float y0 = mapExtent.yMinimum() - map.originY;
float x1 = mapExtent.xMaximum() - map.originX;
float y1 = mapExtent.yMaximum() - map.originY;
float z0 = qmt->header.MinimumHeight, z1 = qmt->header.MaximumHeight;
node->setExactBbox( AABB( x0, z0 * map.zExaggeration, -y0, x1, z1 * map.zExaggeration, -y1 ) );
//epsilon = mapExtent.width() / map.tileTextureSize;
entity->setEnabled( false );
entity->setParent( parent );
return entity;
}
Qt3DCore::QEntity *FlatTerrainChunkLoader::createEntity( Qt3DCore::QEntity *parent )
{
QgsTerrainTileEntity *entity = new QgsTerrainTileEntity;
// make geometry renderer
// simple quad geometry shared by all tiles
// QPlaneGeometry by default is 1x1 with mesh resolution QSize(2,2), centered at 0
// TODO: the geometry could be shared inside Terrain instance (within terrain-generator specific data?)
mTileGeometry = new Qt3DExtras::QPlaneGeometry;
Qt3DRender::QGeometryRenderer *mesh = new Qt3DRender::QGeometryRenderer;
mesh->setGeometry( mTileGeometry ); // takes ownership if the component has no parent
entity->addComponent( mesh ); // takes ownership if the component has no parent
// create material
createTextureComponent( entity );
// create transform
Qt3DCore::QTransform *transform = nullptr;
transform = new Qt3DCore::QTransform();
entity->addComponent( transform );
// set up transform according to the extent covered by the quad geometry
QgsAABB bbox = mNode->bbox();
double side = bbox.xMax - bbox.xMin;
double half = side / 2;
transform->setScale( side );
transform->setTranslation( QVector3D( bbox.xMin + half, 0, bbox.zMin + half ) );
entity->setEnabled( false );
entity->setParent( parent );
return entity;
}
void View3D::initLight()
{
//Setup light positions, intensities and color
QList<QVector3D> lLightPositions;
const QColor lightColor(255,255,255);
const float lightIntensity = 0.2f;
lLightPositions << QVector3D(-0.5,0,0) << QVector3D(0.5,0,0); /*<< QVector3D(0,0,-0.5)
<< QVector3D(0.5,0,0) << QVector3D(0,0,0.5)
<< QVector3D(0,0.5,0) << QVector3D(0,-0.5,0);*/
//Create all the lights - make it shine
for(int i = 0; i < lLightPositions.size(); ++i) {
//Light source
Qt3DCore::QEntity* pLightEntity = new Qt3DCore::QEntity(m_pLightEntity);
Qt3DCore::QTransform* pTransform = new Qt3DCore::QTransform();
pTransform->setTranslation(lLightPositions.at(i));
pLightEntity->addComponent(pTransform);
Qt3DRender::QPointLight *pPointLight = new Qt3DRender::QPointLight(pLightEntity);
pPointLight->setColor(lightColor);
pPointLight->setIntensity(lightIntensity);
pLightEntity->addComponent(pPointLight);
m_lLightSources.append(pPointLight);
//Uncomment the following to visualize the light sources for debugging:
// Qt3DExtras::QSphereMesh* lightSphere = new Qt3DExtras::QSphereMesh(pLightEntity);
// lightSphere->setRadius(0.1f);
// pLightEntity->addComponent(lightSphere);
// Qt3DExtras::QPhongMaterial* material = new Qt3DExtras::QPhongMaterial(pLightEntity);
// material->setAmbient(lightColor);
// pLightEntity->addComponent(material);
}
}
void checkCompositionDecomposition()
{
// GIVEN
Qt3DCore::QTransform t;
Qt3DCore::QTransform t2;
QMatrix4x4 m = Qt3DCore::QTransform::rotateAround(QVector3D(0.1877f, 0.6868f, 0.3884f), 45.0f, QVector3D(0.0f, 0.0f, 1.0f));
// WHEN
t.setMatrix(m);
t2.setScale3D(t.scale3D());
t2.setRotation(t.rotation());
t2.setTranslation(t.translation());
// THEN
QCOMPARE(t.scale3D(), t2.scale3D());
QCOMPARE(t.rotation(), t2.rotation());
QCOMPARE(t.translation(), t2.translation());
// Note: t.matrix() != t2.matrix() since different matrices
// can result in the same scale, rotation, translation
}
void View3D::createCoordSystem(Qt3DCore::QEntity* parent)
{
// Y - red
Qt3DRender::QCylinderMesh *YAxis = new Qt3DRender::QCylinderMesh();
YAxis->setRadius(0.1f);
YAxis->setLength(3);
YAxis->setRings(100);
YAxis->setSlices(20);
m_YAxisEntity = QSharedPointer<Qt3DCore::QEntity>(new Qt3DCore::QEntity(parent));
m_YAxisEntity->addComponent(YAxis);
Qt3DRender::QPhongMaterial *phongMaterialY = new Qt3DRender::QPhongMaterial();
phongMaterialY->setDiffuse(QColor(255, 0, 0));
phongMaterialY->setAmbient(Qt::gray);
phongMaterialY->setSpecular(Qt::white);
phongMaterialY->setShininess(50.0f);
m_YAxisEntity->addComponent(phongMaterialY);
// Z - blue
Qt3DRender::QCylinderMesh *ZAxis = new Qt3DRender::QCylinderMesh();
ZAxis->setRadius(0.1f);
ZAxis->setLength(3);
ZAxis->setRings(100);
ZAxis->setSlices(20);
Qt3DCore::QTransform *transformZ = new Qt3DCore::QTransform();
transformZ->setRotation(QQuaternion::fromAxisAndAngle(QVector3D(1,0,0), 90));
m_ZAxisEntity = QSharedPointer<Qt3DCore::QEntity>(new Qt3DCore::QEntity(parent));
m_ZAxisEntity->addComponent(ZAxis);
m_ZAxisEntity->addComponent(transformZ);
Qt3DRender::QPhongMaterial *phongMaterialZ = new Qt3DRender::QPhongMaterial();
phongMaterialZ->setDiffuse(QColor(0, 0, 255));
phongMaterialZ->setAmbient(Qt::gray);
phongMaterialZ->setSpecular(Qt::white);
phongMaterialZ->setShininess(50.0f);
m_ZAxisEntity->addComponent(phongMaterialZ);
// X - green
Qt3DRender::QCylinderMesh *XAxis = new Qt3DRender::QCylinderMesh();
XAxis->setRadius(0.1f);
XAxis->setLength(3);
XAxis->setRings(100);
XAxis->setSlices(20);
Qt3DCore::QTransform *transformX = new Qt3DCore::QTransform();
transformX->setRotation(QQuaternion::fromAxisAndAngle(QVector3D(0,0,1), 90));
m_XAxisEntity = QSharedPointer<Qt3DCore::QEntity>(new Qt3DCore::QEntity(parent));
m_XAxisEntity->addComponent(XAxis);
m_XAxisEntity->addComponent(transformX);
Qt3DRender::QPhongMaterial *phongMaterialX = new Qt3DRender::QPhongMaterial();
phongMaterialX->setDiffuse(QColor(0, 255, 0));
phongMaterialX->setAmbient(Qt::gray);
phongMaterialX->setSpecular(Qt::white);
phongMaterialX->setShininess(50.0f);
m_XAxisEntity->addComponent(phongMaterialX);
}
bool BrainSurfaceTreeItem::addData(const Surface& tSurface, Qt3DCore::QEntity* parent)
{
//Create renderable 3D entity
m_pParentEntity = parent;
m_pRenderable3DEntity = new Renderable3DEntity(parent);
m_pRenderable3DEntityActivationOverlay = new Renderable3DEntity(parent);
QMatrix4x4 m;
Qt3DCore::QTransform* transform = new Qt3DCore::QTransform();
m.rotate(180, QVector3D(0.0f, 1.0f, 0.0f));
m.rotate(-90, QVector3D(1.0f, 0.0f, 0.0f));
transform->setMatrix(m);
m_pRenderable3DEntity->addComponent(transform);
m_pRenderable3DEntityActivationOverlay->addComponent(transform);
//Create color from curvature information with default gyri and sulcus colors
QByteArray arrayCurvatureColor = createCurvatureVertColor(tSurface.curv());
//Set renderable 3D entity mesh and color data
m_pRenderable3DEntity->setMeshData(tSurface.rr(), tSurface.nn(), tSurface.tris(), -tSurface.offset(), arrayCurvatureColor);
//Generate activation overlay surface
// MatrixX3f overlayAdds = tSurface.rr();
// for(int i = 0; i<tSurface.nn().rows(); i++) {
// RowVector3f direction = tSurface.nn().row(i);
// direction.normalize();
// overlayAdds.row(i) = direction*0.0001;
// }
// m_pRenderable3DEntityActivationOverlay->setMeshData(tSurface.rr()+overlayAdds, tSurface.nn(), tSurface.tris(), -tSurface.offset(), matCurvatureColor);
//Add data which is held by this BrainSurfaceTreeItem
QVariant data;
data.setValue(arrayCurvatureColor);
this->setData(data, BrainSurfaceTreeItemRoles::SurfaceCurrentColorVert);
this->setData(data, BrainSurfaceTreeItemRoles::SurfaceCurvatureColorVert);
data.setValue(tSurface.rr());
this->setData(data, BrainSurfaceTreeItemRoles::SurfaceVert);
data.setValue(tSurface.tris());
this->setData(data, BrainSurfaceTreeItemRoles::SurfaceTris);
data.setValue(tSurface.nn());
this->setData(data, BrainSurfaceTreeItemRoles::SurfaceNorm);
data.setValue(tSurface.curv());
this->setData(data, BrainSurfaceTreeItemRoles::SurfaceCurv);
data.setValue(tSurface.offset());
this->setData(data, BrainSurfaceTreeItemRoles::SurfaceOffset);
data.setValue(m_pRenderable3DEntity);
this->setData(data, BrainSurfaceTreeItemRoles::SurfaceRenderable3DEntity);
data.setValue(m_pRenderable3DEntityActivationOverlay);
this->setData(data, BrainSurfaceTreeItemRoles::SurfaceRenderable3DEntityAcivationOverlay);
//Add surface meta information as item children
m_pItemSurfColorInfoOrigin = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceColorInfoOrigin, "Color from curvature");
connect(m_pItemSurfColorInfoOrigin, &BrainTreeMetaItem::colorInfoOriginChanged,
this, &BrainSurfaceTreeItem::onColorInfoOriginOrCurvColorChanged);
*this<<m_pItemSurfColorInfoOrigin;
data.setValue(QString("Color from curvature"));
m_pItemSurfColorInfoOrigin->setData(data, BrainTreeMetaItemRoles::SurfaceColorInfoOrigin);
m_pItemSurfColSulci = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceColorSulci, "Sulci color");
connect(m_pItemSurfColSulci, &BrainTreeMetaItem::curvColorsChanged,
this, &BrainSurfaceTreeItem::onColorInfoOriginOrCurvColorChanged);
*this<<m_pItemSurfColSulci;
data.setValue(QColor(50,50,50));
m_pItemSurfColSulci->setData(data, BrainTreeMetaItemRoles::SurfaceColorSulci);
m_pItemSurfColSulci->setData(data, Qt::DecorationRole);
m_pItemSurfColGyri = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceColorGyri, "Gyri color");
connect(m_pItemSurfColGyri, &BrainTreeMetaItem::curvColorsChanged,
this, &BrainSurfaceTreeItem::onColorInfoOriginOrCurvColorChanged);
*this<<m_pItemSurfColGyri;
data.setValue(QColor(125,125,125));
m_pItemSurfColGyri->setData(data, BrainTreeMetaItemRoles::SurfaceColorGyri);
m_pItemSurfColGyri->setData(data, Qt::DecorationRole);
BrainTreeMetaItem *itemSurfFileName = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceFileName, tSurface.fileName());
itemSurfFileName->setEditable(false);
*this<<itemSurfFileName;
data.setValue(tSurface.fileName());
itemSurfFileName->setData(data, BrainTreeMetaItemRoles::SurfaceFileName);
BrainTreeMetaItem *itemSurfType = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceType, tSurface.surf());
itemSurfType->setEditable(false);
*this<<itemSurfType;
data.setValue(tSurface.surf());
itemSurfType->setData(data, BrainTreeMetaItemRoles::SurfaceType);
BrainTreeMetaItem *itemSurfPath = new BrainTreeMetaItem(BrainTreeMetaItemTypes::SurfaceFilePath, tSurface.filePath());
itemSurfPath->setEditable(false);
*this<<itemSurfPath;
data.setValue(tSurface.filePath());
itemSurfPath->setData(data, BrainTreeMetaItemRoles::SurfaceFilePath);
return true;
}
SceneModifier::SceneModifier(Qt3DCore::QEntity *rootEntity)
: m_rootEntity(rootEntity)
{
// Torus shape data
//! [0]
m_torus = new Qt3DExtras::QTorusMesh();
m_torus->setRadius(1.0f);
m_torus->setMinorRadius(0.4f);
m_torus->setRings(100);
m_torus->setSlices(20);
//! [0]
// TorusMesh Transform
//! [1]
Qt3DCore::QTransform *torusTransform = new Qt3DCore::QTransform();
torusTransform->setScale(2.0f);
torusTransform->setRotation(QQuaternion::fromAxisAndAngle(QVector3D(0.0f, 1.0f, 0.0f), 25.0f));
torusTransform->setTranslation(QVector3D(5.0f, 4.0f, 0.0f));
//! [1]
//! [2]
Qt3DExtras::QPhongMaterial *torusMaterial = new Qt3DExtras::QPhongMaterial();
torusMaterial->setDiffuse(QColor(QRgb(0xbeb32b)));
//! [2]
// Torus
//! [3]
m_torusEntity = new Qt3DCore::QEntity(m_rootEntity);
m_torusEntity->addComponent(m_torus);
m_torusEntity->addComponent(torusMaterial);
m_torusEntity->addComponent(torusTransform);
//! [3]
// Cone shape data
Qt3DExtras::QConeMesh *cone = new Qt3DExtras::QConeMesh();
cone->setTopRadius(0.5);
cone->setBottomRadius(1);
cone->setLength(3);
cone->setRings(50);
cone->setSlices(20);
// ConeMesh Transform
Qt3DCore::QTransform *coneTransform = new Qt3DCore::QTransform();
coneTransform->setScale(1.5f);
coneTransform->setRotation(QQuaternion::fromAxisAndAngle(QVector3D(1.0f, 0.0f, 0.0f), 45.0f));
coneTransform->setTranslation(QVector3D(0.0f, 4.0f, -1.5));
Qt3DExtras::QPhongMaterial *coneMaterial = new Qt3DExtras::QPhongMaterial();
coneMaterial->setDiffuse(QColor(QRgb(0x928327)));
// Cone
m_coneEntity = new Qt3DCore::QEntity(m_rootEntity);
m_coneEntity->addComponent(cone);
m_coneEntity->addComponent(coneMaterial);
m_coneEntity->addComponent(coneTransform);
// Cylinder shape data
Qt3DExtras::QCylinderMesh *cylinder = new Qt3DExtras::QCylinderMesh();
cylinder->setRadius(1);
cylinder->setLength(3);
cylinder->setRings(100);
cylinder->setSlices(20);
// CylinderMesh Transform
Qt3DCore::QTransform *cylinderTransform = new Qt3DCore::QTransform();
cylinderTransform->setScale(1.5f);
cylinderTransform->setRotation(QQuaternion::fromAxisAndAngle(QVector3D(1.0f, 0.0f, 0.0f), 45.0f));
cylinderTransform->setTranslation(QVector3D(-5.0f, 4.0f, -1.5));
Qt3DExtras::QPhongMaterial *cylinderMaterial = new Qt3DExtras::QPhongMaterial();
cylinderMaterial->setDiffuse(QColor(QRgb(0x928327)));
// Cylinder
m_cylinderEntity = new Qt3DCore::QEntity(m_rootEntity);
m_cylinderEntity->addComponent(cylinder);
m_cylinderEntity->addComponent(cylinderMaterial);
m_cylinderEntity->addComponent(cylinderTransform);
// Cuboid shape data
Qt3DExtras::QCuboidMesh *cuboid = new Qt3DExtras::QCuboidMesh();
// CuboidMesh Transform
Qt3DCore::QTransform *cuboidTransform = new Qt3DCore::QTransform();
cuboidTransform->setScale(4.0f);
cuboidTransform->setTranslation(QVector3D(5.0f, -4.0f, 0.0f));
Qt3DExtras::QPhongMaterial *cuboidMaterial = new Qt3DExtras::QPhongMaterial();
cuboidMaterial->setDiffuse(QColor(QRgb(0x665423)));
//Cuboid
m_cuboidEntity = new Qt3DCore::QEntity(m_rootEntity);
m_cuboidEntity->addComponent(cuboid);
m_cuboidEntity->addComponent(cuboidMaterial);
m_cuboidEntity->addComponent(cuboidTransform);
// Plane shape data
Qt3DExtras::QPlaneMesh *planeMesh = new Qt3DExtras::QPlaneMesh();
planeMesh->setWidth(2);
planeMesh->setHeight(2);
// Plane mesh transform
Qt3DCore::QTransform *planeTransform = new Qt3DCore::QTransform();
planeTransform->setScale(1.3f);
planeTransform->setRotation(QQuaternion::fromAxisAndAngle(QVector3D(1.0f, 0.0f, 0.0f), 45.0f));
planeTransform->setTranslation(QVector3D(0.0f, -4.0f, 0.0f));
Qt3DExtras::QPhongMaterial *planeMaterial = new Qt3DExtras::QPhongMaterial();
planeMaterial->setDiffuse(QColor(QRgb(0xa69929)));
// Plane
m_planeEntity = new Qt3DCore::QEntity(m_rootEntity);
m_planeEntity->addComponent(planeMesh);
m_planeEntity->addComponent(planeMaterial);
m_planeEntity->addComponent(planeTransform);
// Sphere shape data
Qt3DExtras::QSphereMesh *sphereMesh = new Qt3DExtras::QSphereMesh();
sphereMesh->setRings(20);
sphereMesh->setSlices(20);
sphereMesh->setRadius(2);
// Sphere mesh transform
Qt3DCore::QTransform *sphereTransform = new Qt3DCore::QTransform();
sphereTransform->setScale(1.3f);
sphereTransform->setTranslation(QVector3D(-5.0f, -4.0f, 0.0f));
Qt3DExtras::QPhongMaterial *sphereMaterial = new Qt3DExtras::QPhongMaterial();
sphereMaterial->setDiffuse(QColor(QRgb(0xa69929)));
// Sphere
m_sphereEntity = new Qt3DCore::QEntity(m_rootEntity);
m_sphereEntity->addComponent(sphereMesh);
m_sphereEntity->addComponent(sphereMaterial);
m_sphereEntity->addComponent(sphereTransform);
}
void checkCloning_data()
{
QTest::addColumn<Qt3DCore::QTransform *>("transform");
Qt3DCore::QTransform *defaultConstructed = new Qt3DCore::QTransform();
QTest::newRow("defaultConstructed") << defaultConstructed;
Qt3DCore::QTransform *matrixPropertySet = new Qt3DCore::QTransform();
matrixPropertySet->setMatrix(Qt3DCore::QTransform::rotateAround(QVector3D(0.1877f, 0.6868f, 0.3884f), 45.0f, QVector3D(0.0f, 0.0f, 1.0f)));
QTest::newRow("matrixPropertySet") << matrixPropertySet;
Qt3DCore::QTransform *translationSet = new Qt3DCore::QTransform();
translationSet->setTranslation(QVector3D(0.1877f, 0.6868f, 0.3884f));
QTest::newRow("translationSet") << translationSet;
Qt3DCore::QTransform *scaleSet = new Qt3DCore::QTransform();
scaleSet->setScale3D(QVector3D(0.1f, 0.6f, 0.3f));
QTest::newRow("scaleSet") << scaleSet;
Qt3DCore::QTransform *rotationSet = new Qt3DCore::QTransform();
scaleSet->setRotation(Qt3DCore::QTransform::fromAxisAndAngle(0.0f, 0.0f, 1.0f, 30.0f));
QTest::newRow("rotationSet") << rotationSet;
Qt3DCore::QTransform *eulerRotationSet = new Qt3DCore::QTransform();
eulerRotationSet->setRotationX(90.0f);
eulerRotationSet->setRotationY(10.0f);
eulerRotationSet->setRotationZ(1.0f);
QTest::newRow("eulerRotationSet") << eulerRotationSet;
}