Test3D-windows-impl

#include "Window.h"

#include <QtCore/QDebug>

#include <QtGui/QKeyEvent>
#include <QtGui/QMouseEvent>
#include <QtGui/QScreen>
#include <QtGui/QWheelEvent>

#include <QtWidgets/QWidget>
#include <QtWidgets/QHBoxLayout>

#include <Qt3DCore/QAspectEngine>
#include <Qt3DCore/QCamera>
#include <Qt3DCore/QComponent>
#include <Qt3DCore/QEntity>
#include <Qt3DCore/QTransform>

#include <Qt3DInput/QInputAspect>

#include <Qt3DRender/QForwardRenderer>
#include <Qt3DRender/QFrameGraph>
#include <Qt3DRender/QPhongMaterial>
#include <Qt3DRender/QRenderAspect>
#include <Qt3DRender/QSphereMesh>
Window::Window()
    : Qt3DRender::QWindow()
    , _Engine( new Qt3DCore::QAspectEngine( this ) )
    , _Input( new Qt3DInput::QInputAspect() )
    , _Camera( 0 )
    , _RootEntity( new Qt3DCore::QEntity() )
    , _SphereEntities()
    , _Widget( new QWidget() )
    , _PanEngaged( false )
    , _OriginPan()
{
    _RootEntity->setObjectName( "Root entity" );
}

Window::~Window()
{}

bool Window::initialise()
{
    _Widget = QWidget::createWindowContainer( this );
    _Widget->setMinimumSize( QSize( 200, 200 ) );
    QSize screenSize( screen()->size() );
    _Widget->setMaximumSize( screenSize );

    _Engine->registerAspect( new Qt3DRender::QRenderAspect() );

    _Engine->registerAspect( _Input );

    qDebug() << "Aspects registered";

    QVariantMap data;
    data.insert( QStringLiteral( "surface" ),
                 QVariant::fromValue( static_cast< QSurface* >( this ) ) );
    data.insert( QStringLiteral( "eventSource" ), QVariant::fromValue( this ) );
    _Engine->setData( data );

    qDebug() << "Engine data set";

    // Camera
    Qt3DCore::QCamera* cameraEntity( new Qt3DCore::QCamera( _RootEntity ) );
    _Camera = cameraEntity;
    cameraEntity->setObjectName( QStringLiteral( "cameraEntity" ) );

    cameraEntity->lens()->setPerspectiveProjection( 45.0f, 16.0f / 9.0f, 0.1f,
                                                    1000.0f );
    cameraEntity->setPosition( QVector3D( 0, 0, 40.0f ) );
    cameraEntity->setUpVector( QVector3D( 0, 1, 0 ) );
    cameraEntity->setViewCenter( QVector3D( 0, 0, 0 ) );
    _Input->setCamera( cameraEntity );

    qDebug() << "Camera set";

    // FrameGraph
    Qt3DRender::QFrameGraph* frameGraph( new Qt3DRender::QFrameGraph() );
    Qt3DRender::QForwardRenderer* forwardRenderer(
        new Qt3DRender::QForwardRenderer() );

    forwardRenderer->setCamera( cameraEntity );
    forwardRenderer->setClearColor( QColor( QRgb( 0x4d4d4f ) ) );
    frameGraph->setActiveFrameGraph( forwardRenderer );

    qDebug() << "FrameGraph initialised";

    // Setting the FrameGraph
    _RootEntity->addComponent( frameGraph );

    qDebug() << "FrameGraph added";


    const unsigned vertexNbr( 11u );

    // Sphere object
    Qt3DRender::QSphereMesh* sphereMesh( new Qt3DRender::QSphereMesh() );
    sphereMesh->setRings( 4 );
    sphereMesh->setSlices( 4 );
    sphereMesh->setRadius( 0.5 );

    // Material
    Qt3DRender::QPhongMaterial* sphereMaterial(
        new Qt3DRender::QPhongMaterial() );
    sphereMaterial->setDiffuse( QColor( QRgb( 0xa69929 ) ) );

    for ( unsigned i( 0u ); i < vertexNbr*vertexNbr*vertexNbr; ++i )
    {
        // Sphere mesh transform
        Qt3DCore::QTransform* sphereTransform( new Qt3DCore::QTransform() );

        sphereTransform->setScale( 1.f );

        sphereTransform->setTranslation( QVector3D( ( i % vertexNbr ) * 10.f - 10.f * ( vertexNbr / 2u ),
                                                    ( ( i / vertexNbr ) % vertexNbr ) * 10.f - 10.f * ( vertexNbr / 2u ),
                                                    ( i / ( vertexNbr * vertexNbr ) ) * 10.f  - 10.f * ( vertexNbr / 2u ) ) );

        qDebug() << "Sphere transformation initialised to"
                 << ( i % vertexNbr ) * 10.f - 10.f * vertexNbr / 2u
                 << ( ( i / vertexNbr ) % vertexNbr ) * 10.f - 10.f * vertexNbr / 2u
                 << ( i / vertexNbr * vertexNbr ) * 10.f  - 10.f * vertexNbr / 2u;

        // Spheres
        _SphereEntities.append( new Qt3DCore::QEntity( _RootEntity ) );
        _SphereEntities.back()->addComponent( sphereMesh );
        _SphereEntities.back()->addComponent( sphereMaterial );
        _SphereEntities.back()->addComponent( sphereTransform );
    }

    // Set root object of the scene
    _Engine->setRootEntity( _RootEntity );
    qDebug() << "Root entity set";

    QSize widgetSize( _Widget->size() );
    qDebug() << "Size of containing widget" << widgetSize;

    float aspectRatio = float( widgetSize.width() ) /
                        float( widgetSize.height() );
    cameraEntity->lens()->setPerspectiveProjection( 45.0f, aspectRatio, 0.1f,
                                                    1000.0f );

    return true;
}

QWidget* Window::widget()
{
    return _Widget;
}

void Window::wheelEvent( QWheelEvent* event )
{
    QPoint numDegrees( event->angleDelta() / 8 );
    if ( ! numDegrees.isNull() )
    {
        float value( float( numDegrees.y() ) / 30.f );

        poorMansZoom( value );
    }
}

void Window::poorMansZoom( float factor )
{
    QVector3D pos( _Camera->position() );
    QVector3D centre( _Camera->viewCenter() );

    QVector3D vec( pos - centre );
    vec /= vec.length();

    _Camera->setPosition( pos + factor * vec * 5.f );
}

void Window::pan( const QPoint& pt )
{
    QVector3D vec( pt.x(), 0.f, pt.y() );

    qDebug() << "pos" << _Camera->position();
    qDebug() << "up" << _Camera->upVector();
    qDebug() << "trans vec" << vec;

    _Camera->translateWorld( vec );
    // _Camera->setPosition( pos );
    // _Camera->setViewCenter( centre );

}