diff options
Diffstat (limited to 'Source/WebCore/platform/graphics/gpu')
10 files changed, 493 insertions, 6 deletions
diff --git a/Source/WebCore/platform/graphics/gpu/BicubicShader.cpp b/Source/WebCore/platform/graphics/gpu/BicubicShader.cpp new file mode 100644 index 0000000..40c9843 --- /dev/null +++ b/Source/WebCore/platform/graphics/gpu/BicubicShader.cpp @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2011 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if ENABLE(ACCELERATED_2D_CANVAS) + +#include "BicubicShader.h" + +#include "GraphicsContext3D.h" + +namespace WebCore { + +BicubicShader::BicubicShader(GraphicsContext3D* context, unsigned program) + : Shader(context, program) + , m_matrixLocation(context->getUniformLocation(program, "matrix")) + , m_texMatrixLocation(context->getUniformLocation(program, "texMatrix")) + , m_coefficientsLocation(context->getUniformLocation(program, "coefficients")) + , m_imageIncrementLocation(context->getUniformLocation(program, "imageIncrement")) + , m_imageLocation(context->getUniformLocation(program, "image")) + , m_alphaLocation(context->getUniformLocation(program, "alpha")) + , m_positionLocation(context->getAttribLocation(program, "position")) +{ +} + +PassOwnPtr<BicubicShader> BicubicShader::create(GraphicsContext3D* context) +{ + static const char* vertexShaderSource = + "uniform mat3 matrix;\n" + "uniform mat3 texMatrix;\n" + "attribute vec3 position;\n" + "varying vec2 texCoord;\n" + "void main() {\n" + " texCoord = (texMatrix * position).xy;\n" + " gl_Position = vec4(matrix * position, 1.0);\n" + "}\n"; + static const char* fragmentShaderSource = + "#ifdef GL_ES\n" + "precision mediump float;\n" + "#endif\n" + "uniform sampler2D image;\n" + "uniform vec2 imageIncrement;\n" + "uniform mat4 coefficients;\n" + "uniform float alpha;\n" + "varying vec2 texCoord;\n" + "vec4 cubicBlend(float t, vec4 c0, vec4 c1, vec4 c2, vec4 c3) {\n" + " vec4 ts = vec4(1.0, t, t * t, t * t * t);\n" + " vec4 result = coefficients * ts;\n" + " return result.w * c0 + result.z * c1 + result.y * c2 + result.x * c3;\n" + "}\n" + "void main() {\n" + " vec2 imageCoord = texCoord;\n" + " vec2 f = fract(imageCoord / imageIncrement) - vec2(0.5, 0.5);\n" + " vec4 t00 = texture2D(image, imageCoord + imageIncrement * vec2(-1, -1));\n" + " vec4 t10 = texture2D(image, imageCoord + imageIncrement * vec2( 0, -1));\n" + " vec4 t20 = texture2D(image, imageCoord + imageIncrement * vec2( 1, -1));\n" + " vec4 t30 = texture2D(image, imageCoord + imageIncrement * vec2( 2, -1));\n" + " vec4 t0 = cubicBlend(f.x, t00, t10, t20, t30);\n" + " vec4 t01 = texture2D(image, imageCoord + imageIncrement * vec2(-1, 0));\n" + " vec4 t11 = texture2D(image, imageCoord + imageIncrement * vec2( 0, 0));\n" + " vec4 t21 = texture2D(image, imageCoord + imageIncrement * vec2( 1, 0));\n" + " vec4 t31 = texture2D(image, imageCoord + imageIncrement * vec2( 2, 0));\n" + " vec4 t1 = cubicBlend(f.x, t01, t11, t21, t31);\n" + " vec4 t02 = texture2D(image, imageCoord + imageIncrement * vec2(-1, 1));\n" + " vec4 t12 = texture2D(image, imageCoord + imageIncrement * vec2( 0, 1));\n" + " vec4 t22 = texture2D(image, imageCoord + imageIncrement * vec2( 1, 1));\n" + " vec4 t32 = texture2D(image, imageCoord + imageIncrement * vec2( 2, 1));\n" + " vec4 t2 = cubicBlend(f.x, t02, t12, t22, t32);\n" + " vec4 t03 = texture2D(image, imageCoord + imageIncrement * vec2(-1, 2));\n" + " vec4 t13 = texture2D(image, imageCoord + imageIncrement * vec2( 0, 2));\n" + " vec4 t23 = texture2D(image, imageCoord + imageIncrement * vec2( 1, 2));\n" + " vec4 t33 = texture2D(image, imageCoord + imageIncrement * vec2( 2, 2));\n" + " vec4 t3 = cubicBlend(f.x, t03, t13, t23, t33);\n" + " gl_FragColor = cubicBlend(f.y, t0, t1, t2, t3);\n" + "}\n"; + + unsigned program = loadProgram(context, vertexShaderSource, fragmentShaderSource); + if (!program) + return 0; + + return new BicubicShader(context, program); +} + +void BicubicShader::use(const AffineTransform& transform, const AffineTransform& texTransform, const float coefficients[16], const float imageIncrement[2], float alpha) +{ + m_context->useProgram(m_program); + float matrix[9]; + affineTo3x3(transform, matrix); + m_context->uniformMatrix3fv(m_matrixLocation, false /*transpose*/, matrix, 1 /*count*/); + + float texMatrix[9]; + affineTo3x3(texTransform, texMatrix); + m_context->uniformMatrix3fv(m_texMatrixLocation, false /*transpose*/, texMatrix, 1 /*count*/); + m_context->uniformMatrix4fv(m_coefficientsLocation, false /*transpose*/, const_cast<float *>(coefficients), 1 /*count*/); + + m_context->uniform2f(m_imageIncrementLocation, imageIncrement[0], imageIncrement[1]); + + // For now, we always use texture unit 0. If that ever changes, we should + // expose this parameter to the caller. + m_context->uniform1i(m_imageLocation, 0); + m_context->uniform1f(m_alphaLocation, alpha); + + m_context->vertexAttribPointer(m_positionLocation, 3, GraphicsContext3D::FLOAT, false, 0, 0); + + m_context->enableVertexAttribArray(m_positionLocation); +} + +} + +#endif diff --git a/Source/WebCore/platform/graphics/gpu/BicubicShader.h b/Source/WebCore/platform/graphics/gpu/BicubicShader.h new file mode 100644 index 0000000..f7522f4 --- /dev/null +++ b/Source/WebCore/platform/graphics/gpu/BicubicShader.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2011 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef BicubicShader_h +#define BicubicShader_h + +#include "Shader.h" + +namespace WebCore { + +class BicubicShader : public Shader { +public: + static PassOwnPtr<BicubicShader> create(GraphicsContext3D*); + + void use(const AffineTransform&, const AffineTransform& texTransform, const float coefficients[16], const float imageIncrement[2], float alpha); + +private: + BicubicShader(GraphicsContext3D*, unsigned program); + + int m_matrixLocation; + int m_texMatrixLocation; + int m_coefficientsLocation; + int m_imageIncrementLocation; + int m_imageLocation; + int m_alphaLocation; + int m_positionLocation; +}; + +} + +#endif // BicubicShader_h diff --git a/Source/WebCore/platform/graphics/gpu/ConvolutionShader.cpp b/Source/WebCore/platform/graphics/gpu/ConvolutionShader.cpp new file mode 100644 index 0000000..f0b6bd9 --- /dev/null +++ b/Source/WebCore/platform/graphics/gpu/ConvolutionShader.cpp @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2011 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if ENABLE(ACCELERATED_2D_CANVAS) + +#include "ConvolutionShader.h" + +#include "GraphicsContext3D.h" +#include "StringExtras.h" + +namespace WebCore { + +ConvolutionShader::ConvolutionShader(GraphicsContext3D* context, unsigned program, int kernelWidth) + : Shader(context, program) + , m_kernelWidth(kernelWidth) + , m_matrixLocation(context->getUniformLocation(program, "matrix")) + , m_texMatrixLocation(context->getUniformLocation(program, "texMatrix")) + , m_kernelLocation(context->getUniformLocation(program, "kernel")) + , m_imageLocation(context->getUniformLocation(program, "image")) + , m_imageIncrementLocation(context->getUniformLocation(program, "imageIncrement")) + , m_positionLocation(context->getAttribLocation(program, "position")) +{ +} + +PassOwnPtr<ConvolutionShader> ConvolutionShader::create(GraphicsContext3D* context, int kernelWidth) +{ + static const char* vertexShaderRaw = + "#define KERNEL_WIDTH %d\n" + "uniform mat3 matrix;\n" + "uniform mat3 texMatrix;\n" + "uniform vec2 imageIncrement;\n" + "attribute vec3 position;\n" + "varying vec2 imageCoord;\n" + "void main() {\n" + " // Offset image coords by half of kernel width, in image texels\n" + " gl_Position = vec4(matrix * position, 1.0);\n" + " float scale = (float(KERNEL_WIDTH) - 1.0) / 2.0;\n" + " imageCoord = (texMatrix * position).xy - vec2(scale, scale) * imageIncrement;\n" + "}\n"; + char vertexShaderSource[1024]; + snprintf(vertexShaderSource, sizeof(vertexShaderSource), vertexShaderRaw, kernelWidth); + static const char* fragmentShaderRaw = + "#ifdef GL_ES\n" + "precision mediump float;\n" + "#endif\n" + "#define KERNEL_WIDTH %d\n" + "uniform sampler2D image;\n" + "uniform float kernel[KERNEL_WIDTH];\n" + "uniform vec2 imageIncrement;\n" + "varying vec2 imageCoord;\n" + "void main() {\n" + " vec2 coord = imageCoord;\n" + " vec4 sum = vec4(0, 0, 0, 0);\n" + " for (int i = 0; i < KERNEL_WIDTH; i++) {\n" + " sum += texture2D(image, coord) * kernel[i];\n" + " coord += imageIncrement;\n" + " }\n" + " gl_FragColor = sum;\n" + "}\n"; + char fragmentShaderSource[1024]; + snprintf(fragmentShaderSource, sizeof(fragmentShaderSource), fragmentShaderRaw, kernelWidth); + + unsigned program = loadProgram(context, vertexShaderSource, fragmentShaderSource); + if (!program) + return 0; + return new ConvolutionShader(context, program, kernelWidth); +} + +void ConvolutionShader::use(const AffineTransform& transform, const AffineTransform& texTransform, const float* kernel, int kernelWidth, float imageIncrement[2]) +{ + m_context->useProgram(m_program); + float matrix[9]; + affineTo3x3(transform, matrix); + m_context->uniformMatrix3fv(m_matrixLocation, false /*transpose*/, matrix, 1 /*count*/); + + float texMatrix[9]; + affineTo3x3(texTransform, texMatrix); + m_context->uniformMatrix3fv(m_texMatrixLocation, false /*transpose*/, texMatrix, 1 /*count*/); + + m_context->uniform2f(m_imageIncrementLocation, imageIncrement[0], imageIncrement[1]); + + // For now, we always use texture unit 0. If that ever changes, we should + // expose this parameter to the caller. + m_context->uniform1i(m_imageLocation, 0); + if (kernelWidth > m_kernelWidth) + kernelWidth = m_kernelWidth; + m_context->uniform1fv(m_kernelLocation, const_cast<float*>(kernel), kernelWidth); + + m_context->vertexAttribPointer(m_positionLocation, 3, GraphicsContext3D::FLOAT, false, 0, 0); + + m_context->enableVertexAttribArray(m_positionLocation); +} + +} + +#endif diff --git a/Source/WebCore/platform/graphics/gpu/ConvolutionShader.h b/Source/WebCore/platform/graphics/gpu/ConvolutionShader.h new file mode 100644 index 0000000..533e0f5 --- /dev/null +++ b/Source/WebCore/platform/graphics/gpu/ConvolutionShader.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2011 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ConvolutionShader_h +#define ConvolutionShader_h + +#include "Shader.h" + +namespace WebCore { + +class ConvolutionShader : public Shader { +public: + static PassOwnPtr<ConvolutionShader> create(GraphicsContext3D*, int kernelWidth); + + void use(const AffineTransform&, const AffineTransform& texTransform, const float* kernel, int kernelWidth, float imageIncrement[2]); + +private: + ConvolutionShader(GraphicsContext3D*, unsigned program, int kernelWidth); + + int m_kernelWidth; + int m_matrixLocation; + int m_texMatrixLocation; + int m_kernelLocation; + int m_imageLocation; + int m_imageIncrementLocation; + int m_positionLocation; +}; + +} + +#endif // ConvolutionShader_h diff --git a/Source/WebCore/platform/graphics/gpu/DrawingBuffer.h b/Source/WebCore/platform/graphics/gpu/DrawingBuffer.h index 49ae114..606484e 100644 --- a/Source/WebCore/platform/graphics/gpu/DrawingBuffer.h +++ b/Source/WebCore/platform/graphics/gpu/DrawingBuffer.h @@ -42,6 +42,10 @@ #include <wtf/RetainPtr.h> #endif +#if ENABLE(SKIA_GPU) +class GrContext; +#endif + namespace WebCore { #if PLATFORM(CHROMIUM) @@ -59,6 +63,7 @@ public: void reset(const IntSize&); void bind(); IntSize size() const { return m_size; } + Platform3DObject colorBuffer() const { return m_colorBuffer; } // Clear all resources from this object, as well as context. Called when context is destroyed // to prevent invalid accesses to the resources. @@ -94,6 +99,10 @@ public: void setWillPublishCallback(PassOwnPtr<WillPublishCallback> callback) { m_callback = callback; } #endif +#if ENABLE(SKIA_GPU) + void setGrContext(GrContext* ctx); +#endif + PassRefPtr<GraphicsContext3D> graphicsContext3D() const { return m_context; } private: @@ -130,6 +139,10 @@ private: #if PLATFORM(MAC) RetainPtr<WebGLLayer> m_platformLayer; #endif + +#if ENABLE(SKIA_GPU) + GrContext* m_grContext; +#endif }; } // namespace WebCore diff --git a/Source/WebCore/platform/graphics/gpu/LoopBlinnPathProcessor.cpp b/Source/WebCore/platform/graphics/gpu/LoopBlinnPathProcessor.cpp index 5439885..a96213c 100644 --- a/Source/WebCore/platform/graphics/gpu/LoopBlinnPathProcessor.cpp +++ b/Source/WebCore/platform/graphics/gpu/LoopBlinnPathProcessor.cpp @@ -42,6 +42,8 @@ #include <algorithm> #include <wtf/Assertions.h> #include <wtf/FastMalloc.h> +#include <wtf/UnusedParam.h> + #if USE(SKIA) #include "SkGeometry.h" @@ -701,6 +703,7 @@ void LoopBlinnPathProcessor::buildContours(const Path& path) } } while (verb != SkPath::kDone_Verb); #else // !USE(SKIA) + UNUSED_PARAM(path); // Must port to your platform. ASSERT_NOT_REACHED(); #endif @@ -1145,6 +1148,8 @@ static void combineCallback(GLdouble coords[3], void* vertexData[4], GLfloat weight[4], void** outData, void* polygonData) { + UNUSED_PARAM(vertexData); + UNUSED_PARAM(weight); TessellationState* state = static_cast<TessellationState*>(polygonData); GLdouble* outVertex = static_cast<GLdouble*>(fastMalloc(3 * sizeof(GLdouble))); state->allocatedPointers.append(outVertex); diff --git a/Source/WebCore/platform/graphics/gpu/PODRedBlackTree.h b/Source/WebCore/platform/graphics/gpu/PODRedBlackTree.h index bd08988..7dd9ddd 100644 --- a/Source/WebCore/platform/graphics/gpu/PODRedBlackTree.h +++ b/Source/WebCore/platform/graphics/gpu/PODRedBlackTree.h @@ -257,7 +257,7 @@ private: // properly update such summary information based only on the values // in the left and right children. This method should return true if // the node's summary information changed. - virtual bool updateNode(Node* node) { return false; } + virtual bool updateNode(Node*) { return false; } //---------------------------------------------------------------------- // Generic binary search tree operations @@ -713,7 +713,7 @@ private: } #ifdef NDEBUG - void logIfVerbose(const char* output) const { } + void logIfVerbose(const char*) const { } #else void logIfVerbose(const char* output) const { diff --git a/Source/WebCore/platform/graphics/gpu/SharedGraphicsContext3D.cpp b/Source/WebCore/platform/graphics/gpu/SharedGraphicsContext3D.cpp index ea8bc71..662d6a8 100644 --- a/Source/WebCore/platform/graphics/gpu/SharedGraphicsContext3D.cpp +++ b/Source/WebCore/platform/graphics/gpu/SharedGraphicsContext3D.cpp @@ -35,7 +35,10 @@ #include "SharedGraphicsContext3D.h" #include "AffineTransform.h" +#include "BicubicShader.h" #include "Color.h" +#include "ConvolutionShader.h" +#include "DrawingBuffer.h" #include "Extensions3D.h" #include "FloatRect.h" #include "IntSize.h" @@ -43,6 +46,15 @@ #include "SolidFillShader.h" #include "TexShader.h" +#if ENABLE(SKIA_GPU) +#include "GrContext.h" +// Limit the number of textures we hold in the bitmap->texture cache. +static const int maxTextureCacheCount = 512; +// Limit the bytes allocated toward textures in the bitmap->texture cache. +static const size_t maxTextureCacheBytes = 50 * 1024 * 1024; +#endif + +#include <wtf/OwnArrayPtr.h> #include <wtf/text/CString.h> #include <wtf/text/WTFString.h> @@ -65,16 +77,30 @@ PassRefPtr<SharedGraphicsContext3D> SharedGraphicsContext3D::create(HostWindow* OwnPtr<TexShader> texShader = TexShader::create(context.get()); if (!texShader) return 0; - return adoptRef(new SharedGraphicsContext3D(context.release(), solidFillShader.release(), texShader.release())); + OwnPtr<BicubicShader> bicubicShader = BicubicShader::create(context.get()); + if (!bicubicShader) + return 0; + OwnArrayPtr<OwnPtr<ConvolutionShader> > convolutionShaders = adoptArrayPtr(new OwnPtr<ConvolutionShader>[cMaxKernelWidth]); + for (int i = 0; i < cMaxKernelWidth; ++i) { + convolutionShaders[i] = ConvolutionShader::create(context.get(), i + 1); + if (!convolutionShaders[i]) + return 0; + } + return adoptRef(new SharedGraphicsContext3D(context.release(), solidFillShader.release(), texShader.release(), bicubicShader.release(), convolutionShaders.release())); } -SharedGraphicsContext3D::SharedGraphicsContext3D(PassRefPtr<GraphicsContext3D> context, PassOwnPtr<SolidFillShader> solidFillShader, PassOwnPtr<TexShader> texShader) +SharedGraphicsContext3D::SharedGraphicsContext3D(PassRefPtr<GraphicsContext3D> context, PassOwnPtr<SolidFillShader> solidFillShader, PassOwnPtr<TexShader> texShader, PassOwnPtr<BicubicShader> bicubicShader, PassOwnArrayPtr<OwnPtr<ConvolutionShader> > convolutionShaders) : m_context(context) , m_bgraSupported(false) , m_quadVertices(0) , m_solidFillShader(solidFillShader) , m_texShader(texShader) + , m_bicubicShader(bicubicShader) + , m_convolutionShaders(convolutionShaders) , m_oesStandardDerivativesSupported(false) +#if ENABLE(SKIA_GPU) + , m_grContext(0) +#endif { allContexts()->add(this); Extensions3D* extensions = m_context->getExtensions(); @@ -92,6 +118,9 @@ SharedGraphicsContext3D::~SharedGraphicsContext3D() { m_context->deleteBuffer(m_quadVertices); allContexts()->remove(this); +#if ENABLE(SKIA_GPU) + GrSafeUnref(m_grContext); +#endif } void SharedGraphicsContext3D::makeContextCurrent() @@ -369,6 +398,17 @@ void SharedGraphicsContext3D::useTextureProgram(const AffineTransform& transform m_texShader->use(transform, texTransform, 0, alpha); } +void SharedGraphicsContext3D::useBicubicProgram(const AffineTransform& transform, const AffineTransform& texTransform, const float coefficients[16], const float imageIncrement[2], float alpha) +{ + m_bicubicShader->use(transform, texTransform, coefficients, imageIncrement, alpha); +} + +void SharedGraphicsContext3D::useConvolutionProgram(const AffineTransform& transform, const AffineTransform& texTransform, const float* kernel, int kernelWidth, float imageIncrement[2]) +{ + ASSERT(kernelWidth >= 1 && kernelWidth <= cMaxKernelWidth); + m_convolutionShaders[kernelWidth - 1]->use(transform, texTransform, kernel, kernelWidth, imageIncrement); +} + void SharedGraphicsContext3D::bindFramebuffer(Platform3DObject framebuffer) { m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, framebuffer); @@ -411,6 +451,31 @@ void SharedGraphicsContext3D::useLoopBlinnExteriorProgram(unsigned vertexOffset, m_loopBlinnExteriorShader->use(vertexOffset, klmOffset, transform, color); } +DrawingBuffer* SharedGraphicsContext3D::getOffscreenBuffer(unsigned index, const IntSize& size) +{ + if (index >= m_offscreenBuffers.size()) + m_offscreenBuffers.resize(index + 1); + + if (!m_offscreenBuffers[index]) + m_offscreenBuffers[index] = m_context->createDrawingBuffer(size); + + if (size.width() != m_offscreenBuffers[index]->size().width() + || size.height() != m_offscreenBuffers[index]->size().height()) + m_offscreenBuffers[index]->reset(size); + return m_offscreenBuffers[index].get(); +} + +#if ENABLE(SKIA_GPU) +GrContext* SharedGraphicsContext3D::grContext() +{ + if (!m_grContext) { + m_grContext = GrContext::CreateGLShaderContext(); + m_grContext->setTextureCacheLimits(maxTextureCacheCount, maxTextureCacheBytes); + } + return m_grContext; +} +#endif + } // namespace WebCore #endif diff --git a/Source/WebCore/platform/graphics/gpu/SharedGraphicsContext3D.h b/Source/WebCore/platform/graphics/gpu/SharedGraphicsContext3D.h index 707fd24..8fb3d50 100644 --- a/Source/WebCore/platform/graphics/gpu/SharedGraphicsContext3D.h +++ b/Source/WebCore/platform/graphics/gpu/SharedGraphicsContext3D.h @@ -38,14 +38,22 @@ #include <wtf/HashMap.h> #include <wtf/HashSet.h> +#include <wtf/OwnArrayPtr.h> #include <wtf/OwnPtr.h> #include <wtf/RefCounted.h> #include <wtf/RefPtr.h> +#if ENABLE(SKIA_GPU) +class GrContext; +#endif + namespace WebCore { class AffineTransform; +class BicubicShader; class Color; +class ConvolutionShader; +class DrawingBuffer; class FloatRect; class HostWindow; class IntSize; @@ -101,6 +109,8 @@ public: void useFillSolidProgram(const AffineTransform&, const Color&); void useTextureProgram(const AffineTransform&, const AffineTransform&, float alpha); + void useBicubicProgram(const AffineTransform&, const AffineTransform&, const float coefficients[16], const float imageIncrement[2], float alpha); + void useConvolutionProgram(const AffineTransform&, const AffineTransform& texTransform, const float* kernel, int kernelWidth, float imageIncrement[2]); void setActiveTexture(GC3Denum textureUnit); void bindTexture(GC3Denum target, Platform3DObject texture); @@ -127,9 +137,14 @@ public: static bool useLoopBlinnForPathRendering(); void useLoopBlinnInteriorProgram(unsigned vertexOffset, const AffineTransform&, const Color&); void useLoopBlinnExteriorProgram(unsigned vertexOffset, unsigned klmOffset, const AffineTransform&, const Color&); + DrawingBuffer* getOffscreenBuffer(unsigned index, const IntSize&); + +#if ENABLE(SKIA_GPU) + GrContext* grContext(); +#endif private: - SharedGraphicsContext3D(PassRefPtr<GraphicsContext3D>, PassOwnPtr<SolidFillShader>, PassOwnPtr<TexShader>); + SharedGraphicsContext3D(PassRefPtr<GraphicsContext3D>, PassOwnPtr<SolidFillShader>, PassOwnPtr<TexShader>, PassOwnPtr<BicubicShader>, PassOwnArrayPtr<OwnPtr<ConvolutionShader> >); // Used to implement removeTexturesFor(), see the comment above. static HashSet<SharedGraphicsContext3D*>* allContexts(); @@ -142,6 +157,8 @@ private: OwnPtr<SolidFillShader> m_solidFillShader; OwnPtr<TexShader> m_texShader; + OwnPtr<BicubicShader> m_bicubicShader; + OwnArrayPtr<OwnPtr<ConvolutionShader> > m_convolutionShaders; TextureHashMap m_textures; @@ -150,8 +167,17 @@ private: OwnPtr<LoopBlinnSolidFillShader> m_loopBlinnInteriorShader; OwnPtr<LoopBlinnSolidFillShader> m_loopBlinnExteriorShader; bool m_oesStandardDerivativesSupported; + + WTF::Vector<RefPtr<DrawingBuffer> > m_offscreenBuffers; + +#if ENABLE(SKIA_GPU) + GrContext* m_grContext; +#endif }; +const float cMaxSigma = 4.0f; +const int cMaxKernelWidth = 25; + } // namespace WebCore #endif // SharedGraphicsContext3D_h diff --git a/Source/WebCore/platform/graphics/gpu/TilingData.cpp b/Source/WebCore/platform/graphics/gpu/TilingData.cpp index dd540b3..1370543 100644 --- a/Source/WebCore/platform/graphics/gpu/TilingData.cpp +++ b/Source/WebCore/platform/graphics/gpu/TilingData.cpp @@ -66,7 +66,7 @@ void TilingData::setTotalSize(int totalSizeX, int totalSizeY) void TilingData::setMaxTextureSize(int maxTextureSize) { - m_maxTextureSize = m_maxTextureSize; + m_maxTextureSize = maxTextureSize; recomputeNumTiles(); } |