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; }