Source/WebCore/platform/graphics/efl/LayerShaderManager.cpp

   1 /*
   2     Copyright (C) 2011 Samsung Electronics
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Library General Public
   6     License as published by the Free Software Foundation; either
   7     version 2 of the License, or (at your option) any later version.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Library General Public License for more details.
  13
  14     You should have received a copy of the GNU Library General Public License
  15     along with this library; see the file COPYING.LIB.  If not, write to
  16     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17     Boston, MA 02110-1301, USA.
  18 */
  19
  20 #include "config.h"
  21
  22 #if ENABLE(TIZEN_ACCELERATED_COMPOSITING)
  23 #if USE(ACCELERATED_COMPOSITING)
  24
  25 #include "LayerShaderManager.h"
  26
  27 #include "GraphicsContext3D.h"
  28 #include "LayerBorderShader.h"
  29 #include "LayerCanvasShader.h"
  30 #include "LayerTexShader.h"
  31 #include "LayerMaskShader.h"
  32 #include "LayerVideoShader.h"
  33
  34 namespace WebCore {
  35
  36 PassOwnPtr<LayerShaderManager> LayerShaderManager::create(GraphicsContext3D* context)
  37 {
  38     return adoptPtr(new LayerShaderManager(context));
  39 }
  40
  41 LayerShaderManager::LayerShaderManager(GraphicsContext3D* context)
  42     : LayerManager(context)
  43     , m_usedShader(0)
  44     , m_useMaskLayer(0)
  45 {
  46     m_bInitialized = initialize();
  47 }
  48
  49 LayerShaderManager::~LayerShaderManager()
  50 {
  51     release();
  52 }
  53
  54 bool LayerShaderManager::initialize()
  55 {
  56     m_texShader = LayerTexShader::create(m_context.get());
  57     m_maskShader = LayerMaskShader::create(m_context.get());
  58     m_videoShader = LayerVideoShader::create(m_context.get());
  59     m_canvasShader = LayerCanvasShader::create(m_context.get());
  60     m_borderShader = LayerBorderShader::create(m_context.get());
  61
  62     if (!m_texShader || !m_maskShader || !m_videoShader || !m_canvasShader || !m_borderShader)
  63         return false;
  64
  65     return true;
  66 }
  67
  68 void LayerShaderManager::release()
  69 {
  70     m_usedShader = 0;
  71     m_texShader.clear();
  72     m_videoShader.clear();
  73     m_canvasShader.clear();
  74     m_borderShader.clear();
  75 }
  76
  77 void LayerShaderManager::use(int type)
  78 {
  79     m_currentLayerType = type;
  80     m_useMaskLayer = 0;
  81
  82     LayerShader* requiredShader = m_usedShader;
  83     switch (type) {
  84     case EflLayer::HTMLContentsType:
  85     case EflLayer::ImageContentsType:
  86     case EflLayer::PluginContentsType:
  87         requiredShader = m_texShader.get();
  88         break;
  89     case EflLayer::VideoContentsType:
  90         requiredShader = m_videoShader.get();
  91         break;
  92     case EflLayer::WebGLContentsType:
  93         requiredShader = m_canvasShader.get();
  94         break;
  95     case EflLayer::CanvasContentsType:
  96 #if ENABLE(CANVAS_CAIRO_GLES_RENDERING)
  97         requiredShader = m_canvasShader.get();
  98 #else
  99         requiredShader = m_texShader.get();
 100 #endif
 101         break;
 102     case DebugBordersType:
 103         requiredShader = m_borderShader.get();
 104         break;
 105     default:
 106         return;
 107     }
 108
 109     if (requiredShader == m_usedShader)
 110         return;
 111
 112     requiredShader->use();
 113     m_usedShader = requiredShader;
 114 }
 115
 116 void LayerShaderManager::useMaskShader()
 117 {
 118     if (m_maskShader) {
 119         m_maskShader->use();
 120         m_useMaskLayer = 1;
 121         m_usedShader = 0;
 122     }
 123 }
 124
 125 void LayerShaderManager::setMatrix(float* matrix)
 126 {
 127     if (m_maskShader && m_useMaskLayer) {
 128         m_maskShader->setMatrix(matrix);
 129         return;
 130     }
 131
 132     if (m_usedShader)
 133         m_usedShader->setMatrix(matrix);
 134 }
 135
 136 void LayerShaderManager::setSampler(int sampler)
 137 {
 138     if (m_maskShader && m_useMaskLayer) {
 139         m_maskShader->setSampler(sampler);
 140         return;
 141     }
 142
 143     if (m_usedShader)
 144         m_usedShader->setSampler(sampler);
 145 }
 146
 147 void LayerShaderManager::setAlpha(float alpha)
 148 {
 149     if (m_maskShader && m_useMaskLayer) {
 150         m_maskShader->setAlpha(alpha);
 151         return;
 152     }
 153
 154     if (m_usedShader)
 155         m_usedShader->setAlpha(alpha);
 156 }
 157
 158 void LayerShaderManager::setMaskMatrix(float* matrix)
 159 {
 160     if (m_maskShader) {
 161         // Reverse image vertically.
 162         // We get WebGL reverse texture image. The reason is not found yet.
 163         if (m_currentLayerType == EflLayer::WebGLContentsType)
 164             matrix[5] *= -1;
 165
 166         m_maskShader->setMaskMatrix(matrix);
 167     }
 168 }
 169
 170 void LayerShaderManager::setMaskSampler(int sampler)
 171 {
 172     if (m_maskShader)
 173         m_maskShader->setMaskSampler(sampler);
 174 }
 175
 176 void LayerShaderManager::setMaskAlpha(float alpha)
 177 {
 178     if (m_maskShader)
 179         m_maskShader->setAlpha(alpha);
 180 }
 181
 182 void LayerShaderManager::setColor(const Color& color)
 183 {
 184     if (m_maskShader && m_useMaskLayer) {
 185         m_maskShader->setColor(color);
 186         return;
 187     }
 188
 189     if (m_usedShader)
 190         m_usedShader->setColor(color);
 191 }
 192
 193 } // namespace WebCore
 194
 195 #endif
 196 #endif