qscreenahigl_qws.cpp

奇趣公司比较新的qt/emd版本

    glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(2, GL_SHORT, 0, coords);
    glEnable(GL_TEXTURE_2D);
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
    glDisable(GL_TEXTURE_2D);
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}

/*
  A helper function used by QAhiGLScreen::drawQuadWavyFlag().
 */
static void drawQuad_helper(GLshort *coords, GLfloat *texCoords,
                            int arraySize, int numArrays)
{
    glEnable(GL_TEXTURE_2D);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(2, GL_SHORT, 0, coords);

    for (int i = 0; i < numArrays-1; ++i)
        glDrawArrays(GL_TRIANGLE_STRIP, i*arraySize, arraySize);
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisable(GL_TEXTURE_2D);
}

/*
  A convenience function used by QAhiGLScreen::drawQuad().
 */
static void setRectCoords(GLshort *coords, QRect rect)
{
    coords[0] = GLshort(rect.left());
    coords[1] = GLshort(rect.top());

    coords[2] = GLshort(rect.right());
    coords[3] = GLshort(rect.top());

    coords[4] = GLshort(rect.right());
    coords[5] = GLshort(rect.bottom());

    coords[6] = GLshort(rect.left());
    coords[7] = GLshort(rect.bottom());
}

/*!
  A helper function used by QAhiGLScreen::drawWindow() and
  QAhiGLScreen::redrawScreen().
 */
void QAhiGLScreen::drawQuad(const QRect &textureGeometry,
                            const QRect &subGeometry,
                            const QRect &screenGeometry)
{
    qreal textureWidth = qreal(nextPowerOfTwo(textureGeometry.width()));
    qreal textureHeight = qreal(nextPowerOfTwo(textureGeometry.height()));

    GLshort coords[8];
    setRectCoords(coords, screenGeometry);

    GLfloat texcoords[8];
    texcoords[0] = (subGeometry.left() - textureGeometry.left()) / textureWidth;
    texcoords[1] = (subGeometry.top() - textureGeometry.top()) / textureHeight;

    texcoords[2] = (subGeometry.right() - textureGeometry.left()) / textureWidth;
    texcoords[3] = (subGeometry.top() - textureGeometry.top()) / textureHeight;

    texcoords[4] = (subGeometry.right() - textureGeometry.left()) / textureWidth;
    texcoords[5] = (subGeometry.bottom() - textureGeometry.top()) / textureHeight;

    texcoords[6] = (subGeometry.left() - textureGeometry.left()) / textureWidth;
    texcoords[7] = (subGeometry.bottom() - textureGeometry.top()) / textureHeight;

    drawQuad_helper(coords, texcoords);
}

/*
  My own sine function.
 */
static qreal mySin(QFixed radians)
{
    const QFixed twoPI = QFixed::fromReal(2*M_PI);

    const int tableSize = 40;
    static int *table = 0;

    if (!table) {
        table = new int[tableSize];
        for (int i = 0; i < tableSize; ++i) {
            table[i] = qRound(sin(M_PI*(i*360.0/40.0)/180.0) * 16776960.0);
        }
    }

    QFixed tableLookup = radians*tableSize/twoPI;
    return table[tableLookup.truncate()%tableSize]/16776960.0;
}

/*
  My own cosine function.
 */
static qreal myCos(QFixed radians)
{
    const int twoPI = qRound(2*M_PI);

    const int tableSize = 40;
    static int *table = 0;

    if (!table) {
        table = new int[tableSize];
        for (int i = 0; i < tableSize; ++i) {
            table[i] = int(cos(M_PI*(i*360.0/40.0)/180.0) * 16776960.0);
        }
    }

    QFixed tableLookup = radians*tableSize/twoPI;
    return table[tableLookup.truncate()%tableSize]/16776960.0;
}

// number of grid cells in wavy flag tesselation in x- and y-direction
const int subdivisions = 10;

/*
  A helper function used by drawQuadWavyFlag(). It computes 
  coordinates for grid cells for a wavy flag tesselation and
  stores them in the array called coords.
 */
static void setFlagCoords(GLshort *coords,
			  QRectF screenGeometry,
                          int frameNum,
			  qreal progress)
{
    int coordIndex = 0;
    qreal waveHeight = 30.0*(1.0-progress);
    for (int j = 0; j < subdivisions-1; ++j) {
        for (int i = 0; i < subdivisions; ++i) {
            qreal c;
            c = screenGeometry.left()
                + (i * screenGeometry.width() / (subdivisions - 1))
                + waveHeight * qRound(mySin(QFixed::fromReal(M_PI * 20 * (frameNum + i) / 180.0)))
                + waveHeight * qRound(myCos(QFixed::fromReal(M_PI * 20 * (frameNum + j) / 180.0)));
            coords[coordIndex++] = qRound(c);
            c = screenGeometry.top()
                + (j * screenGeometry.height() / (subdivisions - 1))
                + waveHeight * mySin(QFixed::fromReal(M_PI * 20 * (frameNum + i) / 180.0))
                + waveHeight * myCos(QFixed::fromReal(M_PI * 20 * (frameNum + j) / 180.0));
            coords[coordIndex++] = qRound(c);
            c = screenGeometry.left() + (i * screenGeometry.width() / (subdivisions - 1))
                + waveHeight * mySin(QFixed::fromReal(M_PI * 20 * (frameNum + i) / 180.0))
                + waveHeight * myCos(QFixed::fromReal(M_PI * 20 * (frameNum + (j+1)) / 180.0));
            coords[coordIndex++] = qRound(c);

            c = screenGeometry.top()
                + ((j + 1) * screenGeometry.height() / (subdivisions - 1))
                + waveHeight * mySin(QFixed::fromReal(M_PI * 20 * (frameNum + i) / 180.0))
                + waveHeight * myCos(QFixed::fromReal(M_PI * 20 * (frameNum + (j + 1)) / 180.0));
            coords[coordIndex++] = qRound(c);
        }
    }
}

static void setFlagTexCoords(GLfloat *texcoords,
                             const QRectF &subTexGeometry,
                             const QRectF &textureGeometry,
                             int textureWidth, int textureHeight)
{
    qreal topLeftX = (subTexGeometry.left() - textureGeometry.left())/textureWidth;
    qreal topLeftY = (textureGeometry.height() - (subTexGeometry.top() - textureGeometry.top()))/textureHeight;

    qreal width = (subTexGeometry.right() - textureGeometry.left())/textureWidth - topLeftX;
    qreal height = (textureGeometry.height() - (subTexGeometry.bottom() - textureGeometry.top()))/textureHeight - topLeftY;

    int coordIndex = 0;
    qreal spacing = subdivisions - 1;
    for (int j = 0; j < subdivisions-1; ++j) {
        for (int i = 0; i < subdivisions; ++i) {
            texcoords[coordIndex++] = topLeftX + (i*width) / spacing;
            texcoords[coordIndex++] = topLeftY + (j*height) / spacing;
            texcoords[coordIndex++] = topLeftX + (i*width) / spacing;
            texcoords[coordIndex++] = topLeftY + ((j+1)*height) / spacing;
        }
    }
}

void QAhiGLScreen::drawQuadWavyFlag(const QRect &textureGeometry,
                                    const QRect &subTexGeometry,
                                    const QRect &screenGeometry,
                                    qreal progress)
{
    const int textureWidth = nextPowerOfTwo(textureGeometry.width());
    const int textureHeight = nextPowerOfTwo(textureGeometry.height());

    static int frameNum = 0;

    GLshort coords[subdivisions*subdivisions*2*2];
    setFlagCoords(coords, screenGeometry, frameNum++, progress);

    GLfloat texcoords[subdivisions*subdivisions*2*2];
    setFlagTexCoords(texcoords, subTexGeometry, textureGeometry,
                     textureWidth, textureHeight);

    drawQuad_helper(coords, texcoords, subdivisions*2, subdivisions);
}

void QAhiGLScreen::invalidateTexture(int windowIndex)
{
    if (windowIndex < 0)
        return;

    QList<QWSWindow*> windows = QWSServer::instance()->clientWindows();
    if (windowIndex > windows.size() - 1)
        return;

    QWSWindow *win = windows.at(windowIndex);
    if (!win)
        return;

    WindowInfo *info = windowMap[win];
    if (info->texture) {
        glDeleteTextures(1, &info->texture);
        info->texture = 0;
    }
}

void QAhiGLScreen::drawWindow(QWSWindow *win, qreal progress)
{
    const QRect screenRect = win->allocatedRegion().boundingRect();
    QRect drawRect = screenRect;

    glColor4f(1.0, 1.0, 1.0, progress);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);

    QWSWindowSurface *surface = win->windowSurface();
    if (!surface)
        return;

    if (progress >= 1.0) {
        if (surface->key() == QLatin1String("ahigl")) {
            drawRect.setCoords(drawRect.left(), drawRect.bottom(),
                               drawRect.right(), drawRect.top());
        }
        drawQuad(win->requestedRegion().boundingRect(), screenRect, drawRect);
        return;
    }

    const int dx = qRound((1 - progress) * drawRect.width() / 2);
    const int dy = qRound((1 - progress) * drawRect.height() / 2);

    drawRect.adjust(dx, dy, -dx, -dy);

    if (surface->key() != QLatin1String("ahigl")) {
        drawRect.setCoords(drawRect.left(), drawRect.bottom(),
                           drawRect.right(), drawRect.top());
    }

    drawQuadWavyFlag(win->requestedRegion().boundingRect(), screenRect,
                     drawRect, progress);
}

/*!
  The window compositions are constructed here.
 */
void QAhiGLScreen::redrawScreen()
{
    glBindFramebufferOES(GL_FRAMEBUFFER_EXT, 0);
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrthof(0, w, h, 0, -999999, 999999);
    glViewport(0, 0, w, h);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    // Fill background color

    QColor bgColor = QWSServer::instance()->backgroundBrush().color();
    glClearColor(bgColor.redF(), bgColor.greenF(),
                 bgColor.blueF(), bgColor.alphaF());
    glClear(GL_COLOR_BUFFER_BIT);

    // Draw all windows

    glDisable(GL_CULL_FACE);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_STENCIL_TEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_ONE, GL_ZERO);
    glDisable(GL_ALPHA_TEST);
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

    QList<QWSWindow*> windows = QWSServer::instance()->clientWindows();
    for (int i = windows.size() - 1; i >= 0; --i) {
        QWSWindow *win = windows.at(i);
        QWSWindowSurface *surface = win->windowSurface();
        if (!surface)
            continue;

        WindowInfo *info = windowMap[win];

        if (!info->texture) {
            if (surface->key() == QLatin1String("ahigl"))
                info->texture = static_cast<QAhiGLWindowSurface*>(surface)->textureId();
            else
                info->texture = createTexture(surface->image());
        }
        qreal progress;
        if (info->animation)
            progress = info->animation->currentValue();
        else
            progress = 1.0;

        glBindTexture(GL_TEXTURE_2D, info->texture);
        drawWindow(win, progress);
    } // for i

    // Draw cursor

    const QAhiGLCursor *cursor = d_ptr->cursor;
    if (cursor->texture) {
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glBindTexture(GL_TEXTURE_2D, d_ptr->cursor->texture);
        drawQuad(cursor->boundingRect(), cursor->boundingRect(),
                 cursor->boundingRect());
    }

    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);

    eglSwapBuffers(d_ptr->eglDisplay, d_ptr->eglSurface);
}

/*!
  \reimp

 */
void QAhiGLScreen::exposeRegion(QRegion r, int windowIndex)
{
    if ((r & region()).isEmpty())
        return;

    invalidateTexture(windowIndex);

    if (!d_ptr->updateTimer.isActive())
        d_ptr->updateTimer.start(frameSpan);
}

/*!
  \reimp

  This overloading of createSurface() is called on the client side to
  create a window surface for a new window. If the \a widget is a
  QGLWidget, or if the widget's width and height are both less than or
  equal to 256, it creates an instance of QAhiGLWindowSurface.
  Otherwise, it calls QScreen::createSurface() to create a non-OpenGL
  window surface. The pointer to the new window surface is returned.

  Note that this function first asks whether this application is the
  server, and it only creates an instance of QAhiGLWindowSurface if
  the answer is yes. What this means is we only let the server have
  access to the OpenGL hardware, because of an implementation
  restyriction in the OpenGL libraries we are using. Thus only clients
  that are in the server process get to create OpenGL window surfaces.
 */
QWSWindowSurface* QAhiGLScreen::createSurface(QWidget *widget) const
{
    if (QApplication::type() == QApplication::GuiServer) {
        if (qobject_cast<QGLWidget*>(widget)) {
            return new QAhiGLWindowSurface(widget,
					   d_ptr->eglDisplay,
                                           d_ptr->eglSurface,
                                           d_ptr->eglContext);
        }

        const QRect rect = widget->frameGeometry();
        if (rect.width() <= 256 && rect.height() <= 256) {
            return new QAhiGLWindowSurface(widget,
					   d_ptr->eglDisplay,
                                           d_ptr->eglSurface,
                                           d_ptr->eglContext);
        }
    }

    return QScreen::createSurface(widget);
}

/*!
  \reimp

  This overloading of createSurface() is called on the server side
  to manage a window surface corresponding to a window surface
  already created on the client side.

  If the \a key is "ahigl", create an instance of QAhiGLWindowSurface
  and return it. Otherwise, call QScreen::createSurface() and return
  the window surface it creates.

  See QScreen::createSurface().
 */
QWSWindowSurface* QAhiGLScreen::createSurface(const QString &key) const
{
    if (key == QLatin1String("ahigl")) {
        return new QAhiGLWindowSurface(d_ptr->eglDisplay,
				       d_ptr->eglSurface,
                                       d_ptr->eglContext);
    }

    return QScreen::createSurface(key);
}

/*!
  This function would normally reset the frame buffer resolution
  according to \a width, \a height, and the bit \a depth. It would
  then notify other applications that their frame buffer size had
  changed so they could redraw. The function is a no-op in this
  example, which means the example screen driver can't change its
  frame buffer resolution. There is no significance to that in the
  example. You would normally implement setMode() in an OpenGL
  screen driver. This no-op reimplementation is required here
  because setMode() in QScreen is a pure virtual function.

  See QScreen::setMode()
 */
void QAhiGLScreen::setMode(int width, int height, int depth)
{
    Q_UNUSED(width);
    Q_UNUSED(height);
    Q_UNUSED(depth);
}

/*!
  This function would normally be reimplemented to prevent the
  screen driver from updating the screen if \a on is true. It is a
  no-op in this example, which means the screen driver can always
  update the screen.

  See QScreen::blank().
 */
void QAhiGLScreen::blank(bool on)
{
    Q_UNUSED(on);
}

/*!
  This function always returns true, since the purpose of
  this screen driver class is to implement an OpenGL ES
  screen driver. In some other class designed to handle both
  OpenGL and non-OpenGL graphics, it might test the system to
  determine whether OpenGL graphics are supported and return
  true or false accordingly.
 */
bool QAhiGLScreen::hasOpenGL()
{
    return true;
}

#include "qscreenahigl_qws.moc"