1 files changed, 199 insertions, 0 deletions
diff --git a/src/datavisualization/engine/q3dscene.cpp b/src/datavisualization/engine/q3dscene.cpp
new file mode 100644
index 00000000..49c08bbc
--- /dev/null
+++ b/src/datavisualization/engine/q3dscene.cpp
@@ -0,0 +1,199 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc
+** All rights reserved.
+** For any questions to Digia, please use contact form at http://qt.digia.com
+**
+** This file is part of the QtDataVisualization module.
+**
+** Licensees holding valid Qt Enterprise licenses may use this file in
+** accordance with the Qt Enterprise License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.
+**
+** If you have questions regarding the use of this file, please use
+** contact form at http://qt.digia.com
+**
+****************************************************************************/
+
+#include <qmath.h>
+
+#include "datavisualizationglobal_p.h"
+
+#include "q3dscene.h"
+#include "q3dscene_p.h"
+#include "q3dcamera.h"
+#include "q3dlight.h"
+
+QT_DATAVISUALIZATION_BEGIN_NAMESPACE
+
+Q3DScene::Q3DScene(QObject *parent) :
+    d_ptr(new Q3DScenePrivate(this))
+{
+}
+
+Q3DScene *Q3DScene::clone(QObject *parent)
+{
+    Q3DScene *cloneScene = new Q3DScene(parent);
+    cloneScene->setViewport(viewport());
+    cloneScene->setMainViewport(mainViewport());
+    cloneScene->setSliceViewport(sliceViewport());
+
+    if (d_ptr->m_camera) {
+        Q3DCamera *cloneCamera = new Q3DCamera();
+        cloneCamera->copyValuesFrom(*d_ptr->m_camera);
+        cloneScene->setCamera(cloneCamera);
+    }
+
+    if (d_ptr->m_light) {
+        Q3DLight *cloneLight = new Q3DLight();
+        cloneLight->copyValuesFrom(*d_ptr->m_light);
+        cloneScene->setLight(cloneLight);
+    }
+
+    cloneScene->setSlicingActivated(isSlicingActivated());
+    cloneScene->setUnderSideCameraEnabled(isUnderSideCameraEnabled());
+
+    return cloneScene;
+}
+
+Q3DScene::~Q3DScene()
+{
+}
+
+QRect Q3DScene::viewport() const
+{
+    return d_ptr->m_viewport;
+}
+
+void Q3DScene::setViewport(const QRect &viewport)
+{
+    d_ptr->m_viewport = viewport;
+    d_ptr->m_viewport.setX(0);
+    d_ptr->m_viewport.setY(0);
+}
+
+void Q3DScene::setViewportSize(int width, int height)
+{
+    d_ptr->m_viewport.setWidth(width);
+    d_ptr->m_viewport.setHeight(height);
+}
+
+QRect Q3DScene::mainViewport() const
+{
+    return d_ptr->m_mainViewport;
+}
+
+void Q3DScene::setMainViewport(const QRect &mainViewPort)
+{
+    d_ptr->m_mainViewport = mainViewPort;
+}
+
+bool Q3DScene::isInputInsideMainView(const QPoint &point)
+{
+    int x = point.x();
+    int y = point.y();
+    int areaMinX = d_ptr->m_mainViewport.x();
+    int areaMaxX = d_ptr->m_mainViewport.x() + d_ptr->m_mainViewport.width();
+    int areaMaxY = d_ptr->m_viewport.height() - d_ptr->m_mainViewport.y();
+    int areaMinY = d_ptr->m_viewport.height() - (d_ptr->m_mainViewport.y() + d_ptr->m_mainViewport.height());
+
+    return ( x > areaMinX && x < areaMaxX && y > areaMinY && y < areaMaxY );
+}
+
+bool Q3DScene::isInputInsideSliceView(const QPoint &point)
+{
+    int x = point.x();
+    int y = point.y();
+    int areaMinX = d_ptr->m_sliceViewport.x();
+    int areaMaxX = d_ptr->m_sliceViewport.x() + d_ptr->m_sliceViewport.width();
+    int areaMaxY = d_ptr->m_viewport.height() - d_ptr->m_sliceViewport.y();
+    int areaMinY = d_ptr->m_viewport.height() - (d_ptr->m_sliceViewport.y() + d_ptr->m_sliceViewport.height());
+
+    return ( x > areaMinX && x < areaMaxX && y > areaMinY && y < areaMaxY );
+}
+
+QRect Q3DScene::sliceViewport() const
+{
+    return d_ptr->m_sliceViewport;
+}
+
+void Q3DScene::setSliceViewport(const QRect &sliceViewPort)
+{
+    d_ptr->m_sliceViewport = sliceViewPort;
+}
+
+// TODO: Refactor the current way of building the scene...
+//       The scene should have clear ownership of camera, light and other future building blocks of the scene.
+
+Q3DCamera *Q3DScene::camera() const
+{
+    return d_ptr->m_camera;
+}
+
+void Q3DScene::setCamera(Q3DCamera *camera)
+{
+    if (d_ptr->m_camera)
+        d_ptr->m_camera->setParentScene(0);
+
+    d_ptr->m_camera = camera;
+    d_ptr->m_camera->setParentScene(this);
+}
+
+Q3DLight *Q3DScene::light() const
+{
+    return d_ptr->m_light;
+}
+
+void Q3DScene::setLight(Q3DLight *light)
+{
+    if (d_ptr->m_light)
+        d_ptr->m_light->setParentScene(0);
+
+    d_ptr->m_light = light;
+    d_ptr->m_light->setParentScene(this);
+}
+
+bool Q3DScene::isUnderSideCameraEnabled() const
+{
+    return d_ptr->m_isUnderSideCameraEnabled;
+}
+
+void Q3DScene::setUnderSideCameraEnabled(bool isEnabled)
+{
+    d_ptr->m_isUnderSideCameraEnabled = isEnabled;
+}
+
+bool Q3DScene::isSlicingActivated() const
+{
+    return d_ptr->m_isSlicingActivated;
+}
+
+void Q3DScene::setSlicingActivated(bool isSlicing)
+{
+    if (isSlicing != d_ptr->m_isSlicingActivated)
+        d_ptr->m_isSlicingActivated = isSlicing;
+}
+
+void Q3DScene::setLightPositionRelativeToCamera(const QVector3D &relativePosition, GLfloat fixedRotation, GLfloat distanceModifier)
+{
+    d_ptr->m_light->setPosition(d_ptr->m_camera->calculatePositionRelativeToCamera(relativePosition, fixedRotation, distanceModifier));
+}
+
+
+Q3DScenePrivate::Q3DScenePrivate(Q3DScene *q) :
+    q_ptr(q),
+    m_camera(0),
+    m_light(0),
+    m_isUnderSideCameraEnabled(false),
+    m_isSlicingActivated(false)
+{
+}
+
+Q3DScenePrivate::~Q3DScenePrivate()
+{
+    delete m_camera;
+    delete m_light;
+}
+
+QT_DATAVISUALIZATION_END_NAMESPACE