Fix build without QtConcurrent

Change-Id: I9ce68e849e45e85c6dc84a73c8836efa8e94c499
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@qt.io>
Reviewed-by: Andy Nichols <andy.nichols@qt.io>

4 files changed, 67 insertions, 1 deletions

diff --git a/src/render/jobs/calcboundingvolumejob.cpp b/src/render/jobs/calcboundingvolumejob.cpp
index 841a158b6..2afda6efe 100644
--- a/src/render/jobs/calcboundingvolumejob.cpp
+++ b/src/render/jobs/calcboundingvolumejob.cpp
@@ -53,7 +53,9 @@
 #include <Qt3DRender/private/buffervisitor_p.h>
 
 #include <QtCore/qmath.h>
+#if QT_CONFIG(concurrent)
 #include <QtConcurrent/QtConcurrent>
+#endif
 #include <Qt3DRender/private/job_common_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -284,12 +286,15 @@ void calculateLocalBoundingVolume(NodeManagers *manager, Entity *node)
         }
     }
 
+#if QT_CONFIG(concurrent)
     const QVector<Qt3DRender::Render::Entity *> children = node->children();
     if (children.size() > 1) {
         UpdateBoundFunctor functor;
         functor.manager = manager;
         QtConcurrent::blockingMap(children, functor);
-    } else {
+    } else
+#endif
+    {
         const auto children = node->children();
         for (Entity *child : children)
             calculateLocalBoundingVolume(manager, child);
diff --git a/src/render/jobs/pickboundingvolumeutils.cpp b/src/render/jobs/pickboundingvolumeutils.cpp
index a9c2aee10..5fed946d6 100644
--- a/src/render/jobs/pickboundingvolumeutils.cpp
+++ b/src/render/jobs/pickboundingvolumeutils.cpp
@@ -496,7 +496,15 @@ HitList EntityCollisionGathererFunctor::computeHits(const QVector<Entity *> &ent
 {
     const auto reducerOp = allHitsRequested ? PickingUtils::reduceToAllHits : PickingUtils::reduceToFirstHit;
     const MapFunctorHolder holder(this);
+#if QT_CONFIG(concurrent)
     return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
+#else
+    HitList sphereHits;
+    QVector<PickingUtils::EntityCollisionGathererFunctor::result_type> results;
+    for (const Entity *entity : entities)
+        sphereHits = reducerOp(sphereHits, holder(entity));
+    return sphereHits;
+#endif
 }
 
 HitList EntityCollisionGathererFunctor::pick(const Entity *entity) const
@@ -515,7 +523,15 @@ HitList TriangleCollisionGathererFunctor::computeHits(const QVector<Entity *> &e
 {
     const auto reducerOp = allHitsRequested ? PickingUtils::reduceToAllHits : PickingUtils::reduceToFirstHit;
     const MapFunctorHolder holder(this);
+#if QT_CONFIG(concurrent)
     return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
+#else
+    HitList sphereHits;
+    QVector<PickingUtils::TriangleCollisionGathererFunctor::result_type> results;
+    for (const Entity *entity : entities)
+        sphereHits = reducerOp(sphereHits, holder(entity));
+        return sphereHits;
+#endif
 }
 
 HitList TriangleCollisionGathererFunctor::pick(const Entity *entity) const
@@ -541,7 +557,15 @@ HitList LineCollisionGathererFunctor::computeHits(const QVector<Entity *> &entit
 {
     const auto reducerOp = allHitsRequested ? PickingUtils::reduceToAllHits : PickingUtils::reduceToFirstHit;
     const MapFunctorHolder holder(this);
+#if QT_CONFIG(concurrent)
     return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
+#else
+    HitList sphereHits;
+    QVector<PickingUtils::LineCollisionGathererFunctor::result_type> results;
+    for (const Entity *entity : entities)
+        sphereHits = reducerOp(sphereHits, holder(entity));
+    return sphereHits;
+#endif
 }
 
 HitList LineCollisionGathererFunctor::pick(const Entity *entity) const
@@ -566,7 +590,15 @@ HitList PointCollisionGathererFunctor::computeHits(const QVector<Entity *> &enti
 {
     const auto reducerOp = allHitsRequested ? PickingUtils::reduceToAllHits : PickingUtils::reduceToFirstHit;
     const MapFunctorHolder holder(this);
+#if QT_CONFIG(concurrent)
     return QtConcurrent::blockingMappedReduced<HitList>(entities, holder, reducerOp);
+#else
+    HitList sphereHits;
+    QVector<PickingUtils::PointCollisionGathererFunctor::result_type> results;
+    for (const Entity *entity : entities)
+        sphereHits = reducerOp(sphereHits, holder(entity));
+    return sphereHits;
+#endif
 }
 
 HitList PointCollisionGathererFunctor::pick(const Entity *entity) const
diff --git a/src/render/raycasting/qraycastingservice.cpp b/src/render/raycasting/qraycastingservice.cpp
index 8debeac6a..a0f21aa41 100644
--- a/src/render/raycasting/qraycastingservice.cpp
+++ b/src/render/raycasting/qraycastingservice.cpp
@@ -133,11 +133,23 @@ QCollisionQueryResult QRayCastingServicePrivate::collides(const QRay3D &ray, QBo
     gathererFunctor.ray = ray;
 
     if (mode == QAbstractCollisionQueryService::FirstHit) {
+#if QT_CONFIG(concurrent)
         Hit firstHit = QtConcurrent::blockingMappedReduced<Hit>(volumes, gathererFunctor, reduceToFirstHit);
+#else
+        Hit firstHit;
+        for (const QBoundingVolume *volume : volumes)
+            firstHit = reduceToFirstHit(firstHit, gathererFunctor(volume));
+#endif
         if (firstHit.intersects)
             q->addEntityHit(result, firstHit.id, firstHit.intersection, firstHit.distance, firstHit.uvw);
     } else {
+#if QT_CONFIG(concurrent)
         QVector<Hit> hits = QtConcurrent::blockingMappedReduced<QVector<Hit> >(volumes, gathererFunctor, reduceToAllHits);
+#else
+        QVector<Hit> hits;
+        for (const QBoundingVolume *volume : volumes)
+            hits = reduceToAllHits(hits, gathererFunctor(volume));
+#endif
         std::sort(hits.begin(), hits.end(), compareHitsDistance);
         for (const Hit &hit : qAsConst(hits))
             q->addEntityHit(result, hit.id, hit.intersection, hit.distance, hit.uvw);
@@ -182,9 +194,13 @@ QQueryHandle QRayCastingService::query(const QRay3D &ray,
 
     // Blocking mapReduce
 
+#if QT_CONFIG(concurrent)
     FutureQueryResult future = QtConcurrent::run(d, &QRayCastingServicePrivate::collides,
                                                  ray, provider, mode, handle);
     d->m_results.insert(handle, future);
+#else
+    d->m_results.insert(handle, d->collides(ray, provider, mode, handle));
+#endif
 
     return handle;
 }
@@ -200,7 +216,11 @@ QCollisionQueryResult QRayCastingService::fetchResult(const QQueryHandle &handle
 {
     Q_D(QRayCastingService);
 
+#if QT_CONFIG(concurrent)
     return d->m_results.value(handle).result();
+#else
+    return d->m_results.value(handle);
+#endif
 }
 
 QVector<QCollisionQueryResult> QRayCastingService::fetchAllResults() const
@@ -210,8 +230,13 @@ QVector<QCollisionQueryResult> QRayCastingService::fetchAllResults() const
     QVector<QCollisionQueryResult> results;
     results.reserve(d->m_results.size());
 
+#if QT_CONFIG(concurrent)
     for (const FutureQueryResult &future : d->m_results)
         results.append(future.result());
+#else
+    for (const QCollisionQueryResult &result : d->m_results)
+        results.append(result);
+#endif
 
     return results;
 }
diff --git a/src/render/raycasting/qraycastingservice_p.h b/src/render/raycasting/qraycastingservice_p.h
index 56d9e226e..b77c8af9f 100644
--- a/src/render/raycasting/qraycastingservice_p.h
+++ b/src/render/raycasting/qraycastingservice_p.h
@@ -109,7 +109,11 @@ public:
         QRayCastingService::QueryMode mode;
     };
 
+#if QT_CONFIG(concurrent)
     QHash<QQueryHandle, FutureQueryResult> m_results;
+#else
+    QHash<QQueryHandle, QCollisionQueryResult> m_results;
+#endif
     QAtomicInt m_handlesCount;
 };