Move all raycasting code as private in Qt3DRender

Change-Id: I871cbc57166493f30ea307305d8664e2f8a8873f
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

4 files changed, 56 insertions, 58 deletions

diff --git a/src/render/backend/triangleboundingvolume.cpp b/src/render/backend/triangleboundingvolume.cpp
index 75b87dc75..8353e0cef 100644
--- a/src/render/backend/triangleboundingvolume.cpp
+++ b/src/render/backend/triangleboundingvolume.cpp
@@ -89,7 +89,7 @@ bool intersectsSegmentTriangle(const Qt3DCore::QRay3D &ray,
 }
 
 TriangleBoundingVolume::TriangleBoundingVolume()
-    : Qt3DCore::QBoundingVolume()
+    : QBoundingVolume()
 {
 }
 
@@ -97,7 +97,7 @@ TriangleBoundingVolume::TriangleBoundingVolume()
     The vertices a, b, c are assumed to be in counter clockwise order.
  */
 TriangleBoundingVolume::TriangleBoundingVolume(const Qt3DCore::QNodeId &id, const QVector3D &a, const QVector3D &b, const QVector3D &c)
-    : Qt3DCore::QBoundingVolume()
+    : QBoundingVolume()
     , m_id(id)
     , m_a(a)
     , m_b(b)
@@ -121,9 +121,9 @@ bool TriangleBoundingVolume::intersects(const Qt3DCore::QRay3D &ray, QVector3D *
     return intersected;
 }
 
-Qt3DCore::QBoundingVolume::Type TriangleBoundingVolume::type() const
+QBoundingVolume::Type TriangleBoundingVolume::type() const
 {
-    return Qt3DCore::QBoundingVolume::Triangle;
+    return QBoundingVolume::Triangle;
 }
 
 QVector3D TriangleBoundingVolume::a() const
diff --git a/src/render/backend/triangleboundingvolume_p.h b/src/render/backend/triangleboundingvolume_p.h
index 5cdbbd9f2..849a3abe1 100644
--- a/src/render/backend/triangleboundingvolume_p.h
+++ b/src/render/backend/triangleboundingvolume_p.h
@@ -48,7 +48,7 @@
 // We mean it.
 //
 
-#include <Qt3DCore/qboundingvolume.h>
+#include <Qt3DRender/private/qboundingvolume_p.h>
 #include <Qt3DCore/qnodeid.h>
 #include <QVector3D>
 
@@ -65,7 +65,7 @@ Q_AUTOTEST_EXPORT bool intersectsSegmentTriangle(const Qt3DCore::QRay3D &ray,
                                                  QVector3D &uvw,
                                                  float &t);
 
-class Q_AUTOTEST_EXPORT TriangleBoundingVolume : public Qt3DCore::QBoundingVolume
+class Q_AUTOTEST_EXPORT TriangleBoundingVolume : public QBoundingVolume
 {
 public:
     TriangleBoundingVolume();
diff --git a/src/render/backend/trianglesextractor.cpp b/src/render/backend/trianglesextractor.cpp
index 7a5ecf180..85eba29df 100644
--- a/src/render/backend/trianglesextractor.cpp
+++ b/src/render/backend/trianglesextractor.cpp
@@ -90,13 +90,13 @@ struct BufferInfo
 
 // indices, vertices are already offset
 template<typename index, typename vertex>
-QVector<Qt3DCore::QBoundingVolume *> traverseTrianglesIndexed(index *indices,
-                                                              vertex *vertices,
-                                                              const BufferInfo &indexInfo,
-                                                              const BufferInfo &vertexInfo,
-                                                              const Qt3DCore::QNodeId id)
+QVector<QBoundingVolume *> traverseTrianglesIndexed(index *indices,
+                                                    vertex *vertices,
+                                                    const BufferInfo &indexInfo,
+                                                    const BufferInfo &vertexInfo,
+                                                    const Qt3DCore::QNodeId id)
 {
-    QVector<Qt3DCore::QBoundingVolume *> tris;
+    QVector<QBoundingVolume *> tris;
     uint i = 0;
     const uint verticesStride = vertexInfo.byteStride / sizeof(vertex);
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
@@ -118,11 +118,11 @@ QVector<Qt3DCore::QBoundingVolume *> traverseTrianglesIndexed(index *indices,
 
 // vertices are already offset
 template<typename vertex>
-QVector<Qt3DCore::QBoundingVolume *> traverseTriangles(vertex *vertices,
-                                                       const BufferInfo &vertexInfo,
-                                                       const Qt3DCore::QNodeId id)
+QVector<QBoundingVolume *> traverseTriangles(vertex *vertices,
+                                             const BufferInfo &vertexInfo,
+                                             const Qt3DCore::QNodeId id)
 {
-    QVector<Qt3DCore::QBoundingVolume *> tris;
+    QVector<QBoundingVolume *> tris;
     uint i = 0;
 
     const uint verticesStride = vertexInfo.byteStride / sizeof(vertex);
@@ -144,13 +144,13 @@ QVector<Qt3DCore::QBoundingVolume *> traverseTriangles(vertex *vertices,
 
 // indices, vertices are already offset
 template<typename index, typename vertex>
-QVector<Qt3DCore::QBoundingVolume *> traverseTriangleStripIndexed(index *indices,
-                                                                  vertex *vertices,
-                                                                  const BufferInfo &indexInfo,
-                                                                  const BufferInfo &vertexInfo,
-                                                                  const Qt3DCore::QNodeId id)
+QVector<QBoundingVolume *> traverseTriangleStripIndexed(index *indices,
+                                                        vertex *vertices,
+                                                        const BufferInfo &indexInfo,
+                                                        const BufferInfo &vertexInfo,
+                                                        const Qt3DCore::QNodeId id)
 {
-    QVector<Qt3DCore::QBoundingVolume *> tris;
+    QVector<QBoundingVolume *> tris;
     uint i = 0;
     const uint verticesStride = vertexInfo.byteStride / sizeof(vertex);
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
@@ -172,11 +172,11 @@ QVector<Qt3DCore::QBoundingVolume *> traverseTriangleStripIndexed(index *indices
 
 // vertices are already offset
 template<typename vertex>
-QVector<Qt3DCore::QBoundingVolume *> traverseTriangleStrip(vertex *vertices,
-                                                           const BufferInfo &vertexInfo,
-                                                           const Qt3DCore::QNodeId id)
+QVector<QBoundingVolume *> traverseTriangleStrip(vertex *vertices,
+                                                 const BufferInfo &vertexInfo,
+                                                 const Qt3DCore::QNodeId id)
 {
-    QVector<Qt3DCore::QBoundingVolume *> tris;
+    QVector<QBoundingVolume *> tris;
     uint i = 0;
 
     const uint verticesStride = vertexInfo.byteStride / sizeof(vertex);
@@ -198,13 +198,13 @@ QVector<Qt3DCore::QBoundingVolume *> traverseTriangleStrip(vertex *vertices,
 
 // indices, vertices are already offset
 template<typename index, typename vertex>
-QVector<Qt3DCore::QBoundingVolume *> traverseTriangleFanIndexed(index *indices,
-                                                                vertex *vertices,
-                                                                const BufferInfo &indexInfo,
-                                                                const BufferInfo &vertexInfo,
-                                                                const Qt3DCore::QNodeId id)
+QVector<QBoundingVolume *> traverseTriangleFanIndexed(index *indices,
+                                                      vertex *vertices,
+                                                      const BufferInfo &indexInfo,
+                                                      const BufferInfo &vertexInfo,
+                                                      const Qt3DCore::QNodeId id)
 {
-    QVector<Qt3DCore::QBoundingVolume *> tris;
+    QVector<QBoundingVolume *> tris;
     const uint verticesStride = vertexInfo.byteStride / sizeof(vertex);
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
 
@@ -231,11 +231,11 @@ QVector<Qt3DCore::QBoundingVolume *> traverseTriangleFanIndexed(index *indices,
 
 // vertices are already offset
 template<typename vertex>
-QVector<Qt3DCore::QBoundingVolume *> traverseTriangleFan(vertex *vertices,
-                                                         const BufferInfo &vertexInfo,
-                                                         const Qt3DCore::QNodeId id)
+QVector<QBoundingVolume *> traverseTriangleFan(vertex *vertices,
+                                               const BufferInfo &vertexInfo,
+                                               const Qt3DCore::QNodeId id)
 {
-    QVector<Qt3DCore::QBoundingVolume *> tris;
+    QVector<QBoundingVolume *> tris;
 
     const uint verticesStride = vertexInfo.byteStride / sizeof(vertex);
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
@@ -262,13 +262,13 @@ QVector<Qt3DCore::QBoundingVolume *> traverseTriangleFan(vertex *vertices,
 
 // indices, vertices are already offset
 template<typename index, typename vertex>
-QVector<Qt3DCore::QBoundingVolume *> traverseTriangleAdjacencyIndexed(index *indices,
-                                                              vertex *vertices,
-                                                              const BufferInfo &indexInfo,
-                                                              const BufferInfo &vertexInfo,
-                                                              const Qt3DCore::QNodeId id)
+QVector<QBoundingVolume *> traverseTriangleAdjacencyIndexed(index *indices,
+                                                            vertex *vertices,
+                                                            const BufferInfo &indexInfo,
+                                                            const BufferInfo &vertexInfo,
+                                                            const Qt3DCore::QNodeId id)
 {
-    QVector<Qt3DCore::QBoundingVolume *> tris;
+    QVector<QBoundingVolume *> tris;
     uint i = 0;
     const uint verticesStride = vertexInfo.byteStride / sizeof(vertex);
     const uint maxVerticesDataSize = qMin(vertexInfo.dataSize, 3U);
@@ -290,11 +290,11 @@ QVector<Qt3DCore::QBoundingVolume *> traverseTriangleAdjacencyIndexed(index *ind
 
 // vertices are already offset
 template<typename vertex>
-QVector<Qt3DCore::QBoundingVolume *> traverseTriangleAdjacency(vertex *vertices,
-                                                               const BufferInfo &vertexInfo,
-                                                               const Qt3DCore::QNodeId id)
+QVector<QBoundingVolume *> traverseTriangleAdjacency(vertex *vertices,
+                                                     const BufferInfo &vertexInfo,
+                                                     const Qt3DCore::QNodeId id)
 {
-    QVector<Qt3DCore::QBoundingVolume *> tris;
+    QVector<QBoundingVolume *> tris;
     uint i = 0;
 
     const uint verticesStride = vertexInfo.byteStride / sizeof(vertex);
@@ -332,7 +332,7 @@ typename EnumToType<v>::type *castToType(const QByteArray &u, uint byteOffset)
 }
 
 template<typename ReturnType, typename Func>
-QVector<Qt3DCore::QBoundingVolume *> processBuffer(const BufferInfo &info, Func &f)
+QVector<QBoundingVolume *> processBuffer(const BufferInfo &info, Func &f)
 {
     switch (info.type) {
     case QAttribute::Byte: return f(info, castToType<QAttribute::Byte>(info.data, info.byteOffset));
@@ -428,7 +428,7 @@ TrianglesExtractor::TrianglesExtractor(GeometryRenderer *renderer, NodeManagers
 {
 }
 
-QVector<Qt3DCore::QBoundingVolume *> TrianglesExtractor::extract(const Qt3DCore::QNodeId id)
+QVector<QBoundingVolume *> TrianglesExtractor::extract(const Qt3DCore::QNodeId id)
 {
     if (m_renderer && m_renderer->instanceCount() == 1 && isTriangleBased(m_renderer->primitiveType())) {
         Attribute *positionAttribute = Q_NULLPTR;
@@ -473,26 +473,26 @@ QVector<Qt3DCore::QBoundingVolume *> TrianglesExtractor::extract(const Qt3DCore:
                     indexBufferInfo.byteStride = indexAttribute->byteStride();
                     indexBufferInfo.count = indexAttribute->count();
 
-                    IndexExecutor<QVector<Qt3DCore::QBoundingVolume *> > executor;
+                    IndexExecutor<QVector<QBoundingVolume *> > executor;
                     executor.vertexBufferInfo = vertexBufferInfo;
                     executor.primitiveType = m_renderer->primitiveType();
                     executor.id = id;
 
-                    return processBuffer<QVector<Qt3DCore::QBoundingVolume *> >(indexBufferInfo, executor);
+                    return processBuffer<QVector<QBoundingVolume *> >(indexBufferInfo, executor);
 
                 } else { // Non Indexed
 
                     // Check into which type the buffer needs to be casted
-                    VertexExecutor<QVector<Qt3DCore::QBoundingVolume *> > executor;
+                    VertexExecutor<QVector<QBoundingVolume *> > executor;
                     executor.primitiveType = m_renderer->primitiveType();
                     executor.id = id;
 
-                    return processBuffer<QVector<Qt3DCore::QBoundingVolume *> >(vertexBufferInfo, executor);
+                    return processBuffer<QVector<QBoundingVolume *> >(vertexBufferInfo, executor);
                 }
             }
         }
     }
-    return QVector<Qt3DCore::QBoundingVolume *>();
+    return QVector<QBoundingVolume *>();
 }
 
 } // namespace Render
diff --git a/src/render/backend/trianglesextractor_p.h b/src/render/backend/trianglesextractor_p.h
index d324cd183..7353278fe 100644
--- a/src/render/backend/trianglesextractor_p.h
+++ b/src/render/backend/trianglesextractor_p.h
@@ -52,12 +52,10 @@
 
 QT_BEGIN_NAMESPACE
 
-namespace Qt3DCore {
-class QBoundingVolume;
-}
-
 namespace Qt3DRender {
 
+class QBoundingVolume;
+
 namespace Render {
 
 class GeometryRenderer;
@@ -69,7 +67,7 @@ public:
     explicit TrianglesExtractor(GeometryRenderer *renderer,
                                 NodeManagers *manager);
 
-    QVector<Qt3DCore::QBoundingVolume *> extract(const Qt3DCore::QNodeId id);
+    QVector<QBoundingVolume *> extract(const Qt3DCore::QNodeId id);
 
 private:
     GeometryRenderer *m_renderer;