コード例 #1
0
void ShaderProgram::drawQuad(const DrawQuadData* data)
{
    GLfloat* matrix = getTileProjectionMatrix(data);

    float opacity = data->opacity();
    bool forceBlending = data->forceBlending();
    bool enableBlending = forceBlending || opacity < 1.0;

    ShaderType shaderType = UndefinedShader;
    int textureId = 0;
    GLint textureFilter = 0;
    GLenum textureTarget = 0;

    Color quadColor = data->quadColor();
    if (data->pureColor()) {
        shaderType = PureColor;
        quadColor = shaderColor(quadColor, opacity);
        enableBlending = enableBlending || quadColor.hasAlpha();
        if (!quadColor.alpha() && enableBlending)
            return;
    } else {
        textureId = data->textureId();
        textureFilter = GL_LINEAR;
        textureTarget = data->textureTarget();
        shaderType = getTextureShaderType(textureTarget, data->hasRepeatScale());
    }
    setBlendingState(enableBlending);
    drawQuadInternal(shaderType, matrix, textureId, opacity,
                     textureTarget, textureFilter, quadColor, data->fillPortion(),
                     data->repeatScale());
}
コード例 #2
0
void ShaderProgram::drawQuad(SkRect& geometry, int textureId, float opacity,
                             GLenum textureTarget, GLint texFilter)
{
    if (textureTarget == GL_TEXTURE_2D) {
        if (!TilesManager::instance()->invertedScreen()) {
            drawQuadInternal(geometry, textureId, opacity, m_program,
                             m_hProjectionMatrix,
                             m_hTexSampler, GL_TEXTURE_2D,
                             m_hPosition, m_hAlpha, texFilter);
        } else {
            // With the new GPU texture upload path, we do not use an FBO
            // to blit the texture we receive from the TexturesGenerator thread.
            // To implement inverted rendering, we thus have to do the rendering
            // live, by using a different shader.
            drawQuadInternal(geometry, textureId, opacity, m_programInverted,
                             m_hProjectionMatrixInverted,
                             m_hTexSamplerInverted, GL_TEXTURE_2D,
                             m_hPositionInverted, m_hAlphaInverted, texFilter,
                             m_hContrastInverted);
        }
    } else if (textureTarget == GL_TEXTURE_EXTERNAL_OES
               && !TilesManager::instance()->invertedScreen()) {
        drawQuadInternal(geometry, textureId, opacity, m_surfTexOESProgram,
                         m_hSTOESProjectionMatrix,
                         m_hSTOESTexSampler, GL_TEXTURE_EXTERNAL_OES,
                         m_hSTOESPosition, m_hSTOESAlpha, texFilter);
    } else if (textureTarget == GL_TEXTURE_EXTERNAL_OES
               && TilesManager::instance()->invertedScreen()) {
        drawQuadInternal(geometry, textureId, opacity, m_surfTexOESProgramInverted,
                         m_hSTOESProjectionMatrixInverted,
                         m_hSTOESTexSamplerInverted, GL_TEXTURE_EXTERNAL_OES,
                         m_hSTOESPositionInverted, m_hSTOESAlphaInverted,
                         texFilter, m_hSTOESContrastInverted);
    }
    GLUtils::checkGlError("drawQuad");
}