SkiaShader.cpp revision 828407356dd5c34a3e441604aaf895cbec7c7e66 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "OpenGLRenderer"
18
19#include "SkiaShader.h"
20
21#include "Caches.h"
22#include "Extensions.h"
23#include "Layer.h"
24#include "Matrix.h"
25#include "Texture.h"
26
27#include <SkMatrix.h>
28#include <utils/Log.h>
29
30namespace android {
31namespace uirenderer {
32
33///////////////////////////////////////////////////////////////////////////////
34// Support
35///////////////////////////////////////////////////////////////////////////////
36
37static const GLenum gTileModes[] = {
38        GL_CLAMP_TO_EDGE,   // == SkShader::kClamp_TileMode
39        GL_REPEAT,          // == SkShader::kRepeat_Mode
40        GL_MIRRORED_REPEAT  // == SkShader::kMirror_TileMode
41};
42
43/**
44 * This function does not work for n == 0.
45 */
46static inline bool isPowerOfTwo(unsigned int n) {
47    return !(n & (n - 1));
48}
49
50static inline void bindUniformColor(int slot, FloatColor color) {
51    glUniform4fv(slot, 1, reinterpret_cast<const float*>(&color));
52}
53
54static inline void bindTexture(Caches* caches, Texture* texture, GLenum wrapS, GLenum wrapT) {
55    caches->textureState().bindTexture(texture->id);
56    texture->setWrapST(wrapS, wrapT);
57}
58
59/**
60 * Compute the matrix to transform to screen space.
61 * @param screenSpace Output param for the computed matrix.
62 * @param unitMatrix The unit matrix for gradient shaders, as returned by SkShader::asAGradient,
63 *      or identity.
64 * @param localMatrix Local matrix, as returned by SkShader::getLocalMatrix().
65 * @param modelViewMatrix Model view matrix, as supplied by the OpenGLRenderer.
66 */
67static void computeScreenSpaceMatrix(mat4& screenSpace, const SkMatrix& unitMatrix,
68        const SkMatrix& localMatrix, const mat4& modelViewMatrix) {
69    mat4 shaderMatrix;
70    // uses implicit construction
71    shaderMatrix.loadInverse(localMatrix);
72    // again, uses implicit construction
73    screenSpace.loadMultiply(unitMatrix, shaderMatrix);
74    screenSpace.multiply(modelViewMatrix);
75}
76
77///////////////////////////////////////////////////////////////////////////////
78// gradient shader matrix helpers
79///////////////////////////////////////////////////////////////////////////////
80
81static void toLinearUnitMatrix(const SkPoint pts[2], SkMatrix* matrix) {
82    SkVector vec = pts[1] - pts[0];
83    const float mag = vec.length();
84    const float inv = mag ? 1.0f / mag : 0;
85
86    vec.scale(inv);
87    matrix->setSinCos(-vec.fY, vec.fX, pts[0].fX, pts[0].fY);
88    matrix->postTranslate(-pts[0].fX, -pts[0].fY);
89    matrix->postScale(inv, inv);
90}
91
92static void toCircularUnitMatrix(const float x, const float y, const float radius,
93        SkMatrix* matrix) {
94    const float inv = 1.0f / radius;
95    matrix->setTranslate(-x, -y);
96    matrix->postScale(inv, inv);
97}
98
99static void toSweepUnitMatrix(const float x, const float y, SkMatrix* matrix) {
100    matrix->setTranslate(-x, -y);
101}
102
103///////////////////////////////////////////////////////////////////////////////
104// Common gradient code
105///////////////////////////////////////////////////////////////////////////////
106
107static bool isSimpleGradient(const SkShader::GradientInfo& gradInfo) {
108    return gradInfo.fColorCount == 2 && gradInfo.fTileMode == SkShader::kClamp_TileMode;
109}
110
111///////////////////////////////////////////////////////////////////////////////
112// Store / apply
113///////////////////////////////////////////////////////////////////////////////
114
115bool tryStoreGradient(Caches& caches, const SkShader& shader, const Matrix4 modelViewMatrix,
116        GLuint* textureUnit, ProgramDescription* description,
117        SkiaShaderData::GradientShaderData* outData) {
118    SkShader::GradientInfo gradInfo;
119    gradInfo.fColorCount = 0;
120    gradInfo.fColors = nullptr;
121    gradInfo.fColorOffsets = nullptr;
122
123    SkMatrix unitMatrix;
124    switch (shader.asAGradient(&gradInfo)) {
125        case SkShader::kLinear_GradientType:
126            description->gradientType = ProgramDescription::kGradientLinear;
127
128            toLinearUnitMatrix(gradInfo.fPoint, &unitMatrix);
129            break;
130        case SkShader::kRadial_GradientType:
131            description->gradientType = ProgramDescription::kGradientCircular;
132
133            toCircularUnitMatrix(gradInfo.fPoint[0].fX, gradInfo.fPoint[0].fY,
134                    gradInfo.fRadius[0], &unitMatrix);
135            break;
136        case SkShader::kSweep_GradientType:
137            description->gradientType = ProgramDescription::kGradientSweep;
138
139            toSweepUnitMatrix(gradInfo.fPoint[0].fX, gradInfo.fPoint[0].fY, &unitMatrix);
140            break;
141        default:
142            // Do nothing. This shader is unsupported.
143            return false;
144    }
145    description->hasGradient = true;
146    description->isSimpleGradient = isSimpleGradient(gradInfo);
147
148    computeScreenSpaceMatrix(outData->screenSpace, unitMatrix,
149            shader.getLocalMatrix(), modelViewMatrix);
150
151    // re-query shader to get full color / offset data
152    std::unique_ptr<SkColor[]> colorStorage(new SkColor[gradInfo.fColorCount]);
153    std::unique_ptr<SkScalar[]> colorOffsets(new SkScalar[gradInfo.fColorCount]);
154    gradInfo.fColors = &colorStorage[0];
155    gradInfo.fColorOffsets = &colorOffsets[0];
156    shader.asAGradient(&gradInfo);
157
158    if (CC_UNLIKELY(!isSimpleGradient(gradInfo))) {
159        outData->gradientSampler = (*textureUnit)++;
160
161#ifndef SK_SCALAR_IS_FLOAT
162    #error Need to convert gradInfo.fColorOffsets to float!
163#endif
164        outData->gradientTexture = caches.gradientCache.get(
165                gradInfo.fColors, gradInfo.fColorOffsets, gradInfo.fColorCount);
166        outData->wrapST = gTileModes[gradInfo.fTileMode];
167    } else {
168        outData->gradientSampler = 0;
169        outData->gradientTexture = nullptr;
170
171        outData->startColor.set(gradInfo.fColors[0]);
172        outData->endColor.set(gradInfo.fColors[1]);
173    }
174
175    outData->ditherSampler = (*textureUnit)++;
176    return true;
177}
178
179void applyGradient(Caches& caches, const SkiaShaderData::GradientShaderData& data) {
180    if (CC_UNLIKELY(data.gradientTexture)) {
181        caches.textureState().activateTexture(data.gradientSampler);
182        bindTexture(&caches, data.gradientTexture, data.wrapST, data.wrapST);
183        glUniform1i(caches.program().getUniform("gradientSampler"), data.gradientSampler);
184    } else {
185        bindUniformColor(caches.program().getUniform("startColor"), data.startColor);
186        bindUniformColor(caches.program().getUniform("endColor"), data.endColor);
187    }
188
189    // TODO: remove sampler slot incrementing from dither.setupProgram,
190    // since this assignment of slots is done at store, not apply time
191    GLuint ditherSampler = data.ditherSampler;
192    caches.dither.setupProgram(caches.program(), &ditherSampler);
193    glUniformMatrix4fv(caches.program().getUniform("screenSpace"), 1,
194            GL_FALSE, &data.screenSpace.data[0]);
195}
196
197bool tryStoreBitmap(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
198        GLuint* textureUnit, ProgramDescription* description,
199        SkiaShaderData::BitmapShaderData* outData) {
200    SkBitmap bitmap;
201    SkShader::TileMode xy[2];
202    if (shader.asABitmap(&bitmap, nullptr, xy) != SkShader::kDefault_BitmapType) {
203        return false;
204    }
205
206    outData->bitmapTexture = caches.textureCache.get(&bitmap);
207    if (!outData->bitmapTexture) return false;
208
209    outData->bitmapSampler = (*textureUnit)++;
210
211    const float width = outData->bitmapTexture->width;
212    const float height = outData->bitmapTexture->height;
213
214    description->hasBitmap = true;
215    if (!caches.extensions().hasNPot()
216            && (!isPowerOfTwo(width) || !isPowerOfTwo(height))
217            && (xy[0] != SkShader::kClamp_TileMode || xy[1] != SkShader::kClamp_TileMode)) {
218        description->isBitmapNpot = true;
219        description->bitmapWrapS = gTileModes[xy[0]];
220        description->bitmapWrapT = gTileModes[xy[1]];
221
222        outData->wrapS = GL_CLAMP_TO_EDGE;
223        outData->wrapT = GL_CLAMP_TO_EDGE;
224    } else {
225        outData->wrapS = gTileModes[xy[0]];
226        outData->wrapT = gTileModes[xy[1]];
227    }
228
229    computeScreenSpaceMatrix(outData->textureTransform, SkMatrix::I(), shader.getLocalMatrix(),
230            modelViewMatrix);
231    outData->textureDimension[0] = 1.0f / width;
232    outData->textureDimension[1] = 1.0f / height;
233
234    return true;
235}
236
237void applyBitmap(Caches& caches, const SkiaShaderData::BitmapShaderData& data) {
238    caches.textureState().activateTexture(data.bitmapSampler);
239    bindTexture(&caches, data.bitmapTexture, data.wrapS, data.wrapT);
240    data.bitmapTexture->setFilter(GL_LINEAR);
241
242    glUniform1i(caches.program().getUniform("bitmapSampler"), data.bitmapSampler);
243    glUniformMatrix4fv(caches.program().getUniform("textureTransform"), 1, GL_FALSE,
244            &data.textureTransform.data[0]);
245    glUniform2fv(caches.program().getUniform("textureDimension"), 1, &data.textureDimension[0]);
246}
247
248SkiaShaderType getComposeSubType(const SkShader& shader) {
249    // First check for a gradient shader.
250    switch (shader.asAGradient(nullptr)) {
251        case SkShader::kNone_GradientType:
252            // Not a gradient shader. Fall through to check for other types.
253            break;
254        case SkShader::kLinear_GradientType:
255        case SkShader::kRadial_GradientType:
256        case SkShader::kSweep_GradientType:
257            return kGradient_SkiaShaderType;
258        default:
259            // This is a Skia gradient that has no SkiaShader equivalent. Return None to skip.
260            return kNone_SkiaShaderType;
261    }
262
263    // The shader is not a gradient. Check for a bitmap shader.
264    if (shader.asABitmap(nullptr, nullptr, nullptr) == SkShader::kDefault_BitmapType) {
265        return kBitmap_SkiaShaderType;
266    }
267    return kNone_SkiaShaderType;
268}
269
270void storeCompose(Caches& caches, const SkShader& bitmapShader, const SkShader& gradientShader,
271        const Matrix4& modelViewMatrix, GLuint* textureUnit,
272        ProgramDescription* description, SkiaShaderData* outData) {
273    LOG_ALWAYS_FATAL_IF(!tryStoreBitmap(caches, bitmapShader, modelViewMatrix,
274                textureUnit, description, &outData->bitmapData),
275            "failed storing bitmap shader data");
276    LOG_ALWAYS_FATAL_IF(!tryStoreGradient(caches, gradientShader, modelViewMatrix,
277                textureUnit, description, &outData->gradientData),
278            "failing storing gradient shader data");
279}
280
281bool tryStoreCompose(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
282        GLuint* textureUnit, ProgramDescription* description,
283        SkiaShaderData* outData) {
284
285    SkShader::ComposeRec rec;
286    if (!shader.asACompose(&rec)) return false;
287
288    const SkiaShaderType shaderAType = getComposeSubType(*rec.fShaderA);
289    const SkiaShaderType shaderBType = getComposeSubType(*rec.fShaderB);
290
291    // check that type enum values are the 2 flags that compose the kCompose value
292    if ((shaderAType & shaderBType) != 0) return false;
293    if ((shaderAType | shaderBType) != kCompose_SkiaShaderType) return false;
294
295    mat4 transform;
296    computeScreenSpaceMatrix(transform, SkMatrix::I(), shader.getLocalMatrix(), modelViewMatrix);
297    if (shaderAType == kBitmap_SkiaShaderType) {
298        description->isBitmapFirst = true;
299        storeCompose(caches, *rec.fShaderA, *rec.fShaderB,
300                transform, textureUnit, description, outData);
301    } else {
302        description->isBitmapFirst = false;
303        storeCompose(caches, *rec.fShaderB, *rec.fShaderA,
304                transform, textureUnit, description, outData);
305    }
306    if (!SkXfermode::AsMode(rec.fMode, &description->shadersMode)) {
307        // TODO: Support other modes.
308        description->shadersMode = SkXfermode::kSrcOver_Mode;
309    }
310    return true;
311}
312
313bool tryStoreLayer(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
314        GLuint* textureUnit, ProgramDescription* description,
315        SkiaShaderData::LayerShaderData* outData) {
316    Layer* layer;
317    if (!shader.asACustomShader(reinterpret_cast<void**>(&layer))) {
318        return false;
319    }
320
321    description->hasBitmap = true;
322    outData->layer = layer;
323    outData->bitmapSampler = (*textureUnit)++;
324
325    const float width = layer->getWidth();
326    const float height = layer->getHeight();
327
328    computeScreenSpaceMatrix(outData->textureTransform, SkMatrix::I(), shader.getLocalMatrix(),
329            modelViewMatrix);
330
331    outData->textureDimension[0] = 1.0f / width;
332    outData->textureDimension[1] = 1.0f / height;
333    return true;
334}
335
336void applyLayer(Caches& caches, const SkiaShaderData::LayerShaderData& data) {
337    caches.textureState().activateTexture(data.bitmapSampler);
338
339    data.layer->bindTexture();
340    data.layer->setWrap(GL_CLAMP_TO_EDGE);
341    data.layer->setFilter(GL_LINEAR);
342
343    glUniform1i(caches.program().getUniform("bitmapSampler"), data.bitmapSampler);
344    glUniformMatrix4fv(caches.program().getUniform("textureTransform"), 1,
345            GL_FALSE, &data.textureTransform.data[0]);
346    glUniform2fv(caches.program().getUniform("textureDimension"), 1, &data.textureDimension[0]);
347}
348
349void SkiaShader::store(Caches& caches, const SkShader* shader, const Matrix4& modelViewMatrix,
350        GLuint* textureUnit, ProgramDescription* description,
351        SkiaShaderData* outData) {
352    if (!shader) {
353        outData->skiaShaderType = kNone_SkiaShaderType;
354        return;
355    }
356
357    if (tryStoreGradient(caches, *shader, modelViewMatrix,
358            textureUnit, description, &outData->gradientData)) {
359        outData->skiaShaderType = kGradient_SkiaShaderType;
360        return;
361    }
362
363    if (tryStoreBitmap(caches, *shader, modelViewMatrix,
364            textureUnit, description, &outData->bitmapData)) {
365        outData->skiaShaderType = kBitmap_SkiaShaderType;
366        return;
367    }
368
369    if (tryStoreCompose(caches, *shader, modelViewMatrix,
370            textureUnit, description, outData)) {
371        outData->skiaShaderType = kCompose_SkiaShaderType;
372        return;
373    }
374
375    if (tryStoreLayer(caches, *shader, modelViewMatrix,
376            textureUnit, description, &outData->layerData)) {
377        outData->skiaShaderType = kLayer_SkiaShaderType;
378    }
379}
380
381void SkiaShader::apply(Caches& caches, const SkiaShaderData& data) {
382    if (!data.skiaShaderType) return;
383
384    if (data.skiaShaderType & kGradient_SkiaShaderType) {
385        applyGradient(caches, data.gradientData);
386    }
387    if (data.skiaShaderType & kBitmap_SkiaShaderType) {
388        applyBitmap(caches, data.bitmapData);
389    }
390
391    if (data.skiaShaderType == kLayer_SkiaShaderType) {
392        applyLayer(caches, data.layerData);
393    }
394}
395
396}; // namespace uirenderer
397}; // namespace android
398