ganeswidgets/src/hgmediawallrenderer.cpp
changeset 1 e48454f237ca
parent 0 89c329efa980
child 2 49c70dcc3f17
equal deleted inserted replaced
0:89c329efa980 1:e48454f237ca
    33 #include <qvariantanimation>
    33 #include <qvariantanimation>
    34 #include <qpolygon>
    34 #include <qpolygon>
    35 #include <qpainter>
    35 #include <qpainter>
    36 #include <qpaintengine>
    36 #include <qpaintengine>
    37 
    37 
    38 const Qt::Orientation KDefaultOrientation(Qt::Vertical);
       
    39 const qreal KPi = 3.1415926535897932384626433832795;
    38 const qreal KPi = 3.1415926535897932384626433832795;
    40 
    39 
    41 static qreal lerp(qreal start, qreal end, qreal t)
    40 static qreal lerp(qreal start, qreal end, qreal t)
    42 {
    41 {
    43     return start * (1.0f - t) + end * t;
    42     return start * (1.0f - t) + end * t;
    97     HgQuad* mQuad;
    96     HgQuad* mQuad;
    98     MyVectorAnimation mPositionAnimation;
    97     MyVectorAnimation mPositionAnimation;
    99     MyVectorAnimation mScaleAnimation;
    98     MyVectorAnimation mScaleAnimation;
   100 };
    99 };
   101 
   100 
   102 HgMediaWallRenderer::HgMediaWallRenderer(HgMediaWallDataProvider* provider) :
   101 HgMediaWallRenderer::HgMediaWallRenderer(HgMediaWallDataProvider* provider, 
       
   102     Qt::Orientation scrollDirection, bool coverflowMode) :
   103     mDataProvider(provider),
   103     mDataProvider(provider),
   104     mRenderer(NULL),
   104     mRenderer(NULL),
   105     mIndicatorRenderer(NULL),
   105     mIndicatorRenderer(NULL),
   106     mRendererInitialized(false),
   106     mRendererInitialized(false),
   107     mOrientation(KDefaultOrientation),
   107     mOrientation(scrollDirection),
   108     mNextOrientation(KDefaultOrientation),
   108     mNextOrientation(scrollDirection),
   109     mStateAnimationAlpha(0),
   109     mStateAnimationAlpha(0),
   110     mStateAnimationOnGoing(false),
   110     mStateAnimationOnGoing(false),
   111     mAnimationAlpha(0),
   111     mAnimationAlpha(0),
   112     mOpeningAnimationDuration(500),
   112     mOpeningAnimationDuration(500),
   113     mOpenedItem(-1),
   113     mOpenedItem(-1),
   114     mFlipAngle(qreal(360)),
   114     mFlipAngle(qreal(360)),
   115     mZoomAmount(qreal(0.5)),
   115     mZoomAmount(qreal(0.5)),
   116     mCoverflowMode(false),
   116     mCoverflowMode(coverflowMode),
   117     mRowCount(1),
   117     mRowCount(1),
   118     mNextRowCount(1),
   118     mNextRowCount(1),
   119     mStateAnimationDuration(300),
   119     mStateAnimationDuration(300),
   120     mStep(1.1),
   120     mStep(1.1),
   121     mZfar(-2),
   121     mZfar(-2),
   125     mCameraRotationY(0),
   125     mCameraRotationY(0),
   126     mCameraRotationZ(0),
   126     mCameraRotationZ(0),
   127     mFrontCoverElevation(0.4),
   127     mFrontCoverElevation(0.4),
   128     mReflectionsEnabled(true),
   128     mReflectionsEnabled(true),
   129     mItemCountChanged(false),
   129     mItemCountChanged(false),
   130     mOpenedItemState(ItemClosed)
   130     mOpenedItemState(ItemClosed),
       
   131     mFrontItemPosition(0,0),
       
   132     mFrontItemPositionSet(false)    
   131 {
   133 {
   132     createStateMachine();
   134     createStateMachine();
   133     mImageFader = new HgImageFader();    
   135     mImageFader = new HgImageFader();    
   134     mRenderer = new HgVgQuadRenderer(256);
   136     mRenderer = new HgVgQuadRenderer(256);
   135     mRendererInitialized = true;
   137     mRendererInitialized = true;
       
   138     if (mCoverflowMode) {
       
   139         mOrientation = Qt::Horizontal;
       
   140         mNextOrientation = mOrientation;
       
   141     }
   136 }
   142 }
   137 
   143 
   138 HgMediaWallRenderer::~HgMediaWallRenderer()
   144 HgMediaWallRenderer::~HgMediaWallRenderer()
   139 {
   145 {
   140     delete mRenderer;
   146     delete mRenderer;
   367     emit itemOpened(mOpenedItem);
   373     emit itemOpened(mOpenedItem);
   368 }
   374 }
   369 
   375 
   370 void HgMediaWallRenderer::setOrientation(Qt::Orientation orientation, bool animate)
   376 void HgMediaWallRenderer::setOrientation(Qt::Orientation orientation, bool animate)
   371 {
   377 {
       
   378     // coverflow is always horizontal
       
   379     if (mCoverflowMode)
       
   380     {
       
   381         mOrientation = Qt::Horizontal;
       
   382         mNextOrientation = mOrientation;
       
   383         return;
       
   384     }
       
   385     
   372     if (mOrientation != orientation)
   386     if (mOrientation != orientation)
   373     {
   387     {
   374         mStateMachine->setAnimated(animate);
   388         mStateMachine->setAnimated(animate);
   375         mNextOrientation = orientation;
   389         mNextOrientation = orientation;
   376 
   390 
   388     return mOrientation;
   402     return mOrientation;
   389 }
   403 }
   390 
   404 
   391 void HgMediaWallRenderer::drawQuads(QPainter* painter)
   405 void HgMediaWallRenderer::drawQuads(QPainter* painter)
   392 {
   406 {
       
   407     
   393     mRenderer->transformQuads(mViewMatrix, mProjMatrix, mRect);
   408     mRenderer->transformQuads(mViewMatrix, mProjMatrix, mRect);
   394 
   409 
   395     mRenderer->drawQuads(mRect, painter);    
   410     mRenderer->drawQuads(mRect, painter);    
   396 }
   411 }
   397 
   412 
   528         proj.frustum(-0.5f*aspect, 0.5f*aspect, -0.5f, 0.5f, 1.0f, 1000.0f);
   543         proj.frustum(-0.5f*aspect, 0.5f*aspect, -0.5f, 0.5f, 1.0f, 1000.0f);
   529     }
   544     }
   530 
   545 
   531     mViewMatrix = view;
   546     mViewMatrix = view;
   532     mProjMatrix = proj;
   547     mProjMatrix = proj;
   533     
   548 
   534     qreal mirrorPlaneY = getRowPosY(mRowCount-1)-mImageSize3D.height()/2;
   549     qreal mirrorPlaneY;
       
   550     if (mCoverflowMode)
       
   551     {
       
   552         mirrorPlaneY = -mImageSize3D.height()/2;
       
   553     }
       
   554     else // grid
       
   555     {
       
   556         mirrorPlaneY = getRowPosY(mRowCount-1)-mImageSize3D.height()/2;
       
   557     }
       
   558 
   535     mRenderer->setMirroringPlaneY(mirrorPlaneY);
   559     mRenderer->setMirroringPlaneY(mirrorPlaneY);
   536 }
   560 }
       
   561 
   537 
   562 
   538 void HgMediaWallRenderer::updateSpacingAndImageSize()
   563 void HgMediaWallRenderer::updateSpacingAndImageSize()
   539 {
   564 {
   540     qreal div = mRect.width() <= mRect.height() ? mRect.width() : mRect.height();
   565     qreal div = mRect.width() <= mRect.height() ? mRect.width() : mRect.height();
   541     
   566     
   643 }
   668 }
   644 
   669 
   645 
   670 
   646 qreal HgMediaWallRenderer::getWorldWidth() const
   671 qreal HgMediaWallRenderer::getWorldWidth() const
   647 {   
   672 {   
   648     qreal width = (qreal)mDataProvider->imageCount() / (qreal)mRowCount - 1.0f;
   673     qreal width = ceil((qreal)mDataProvider->imageCount() / (qreal)mRowCount - 1.0f);
   649     
   674     
       
   675     // if we are in vertical orientation we want last and first item
       
   676     // to place at the top and bottom of the screen instead of center
   650     if (mOrientation == Qt::Vertical)
   677     if (mOrientation == Qt::Vertical)
   651     {
   678     {
   652         qreal step = mSpacing2D.height() + mImageSize2D.height(); 
   679         qreal step = mSpacing2D.height() + mImageSize2D.height(); 
   653         width -= (mRect.height() / step - 1.0f);
   680         width -= (mRect.height() / step - 1.0f);
   654     }
   681     }
   655    
   682        
   656     return width;
   683     return width;
   657 }
   684 }
   658 
   685 
   659 void HgMediaWallRenderer::beginRemoveRows(int start, int end)
   686 void HgMediaWallRenderer::beginRemoveRows(int start, int end)
   660 {
   687 {
   729     qreal step = mSpacing3D.width() + mImageSize3D.width();                
   756     qreal step = mSpacing3D.width() + mImageSize3D.width();                
   730     qreal ipos = floorf(position.x());
   757     qreal ipos = floorf(position.x());
   731     qreal frac = (position.x() - ipos) * step;
   758     qreal frac = (position.x() - ipos) * step;
   732     qreal posX = -(qreal)(selectedItemIndex + 0) * step - frac;
   759     qreal posX = -(qreal)(selectedItemIndex + 0) * step - frac;
   733     qreal zFar = -mFrontCoverElevation;
   760     qreal zFar = -mFrontCoverElevation;
   734     qreal posY = 0;    
   761     qreal posY = 0;
   735     
   762 
   736     int count = mDataProvider->imageCount();
   763     int count = mDataProvider->imageCount();
   737     int quadIndex = 0;
   764     int quadIndex = 0;
   738     int itemIndex = ((int)(ipos - (qreal)selectedItemIndex));
   765     int itemIndex = ((int)(ipos - (qreal)selectedItemIndex));
   739     int index = 0;
   766     int index = 0;
   740     
   767     
   972 QList<HgQuad*> HgMediaWallRenderer::getVisibleQuads() const
   999 QList<HgQuad*> HgMediaWallRenderer::getVisibleQuads() const
   973 {
  1000 {
   974     return mRenderer->getVisibleQuads(QRectF(0, 0, mRect.width(), mRect.height()));
  1001     return mRenderer->getVisibleQuads(QRectF(0, 0, mRect.width(), mRect.height()));
   975 }
  1002 }
   976 
  1003 
   977 
  1004 void HgMediaWallRenderer::setFrontItemPosition(const QPointF& position)
       
  1005 {
       
  1006     mFrontItemPosition = position;
       
  1007     
       
  1008     mRenderer->setTranslation(
       
  1009         QVector2D(position.x(), position.y()));    
       
  1010 }
       
  1011 
       
  1012 QPointF HgMediaWallRenderer::frontItemPosition() const
       
  1013 {
       
  1014     return mFrontItemPosition;
       
  1015 }