caaaa66e57
This change also fixes an issue with RGBA16F bitmaps when modulated
with a color (for instance by setting an alpha on the Paint object).
The color space conversion is currently done entirely in the shader,
by doing these operations in order:
1. Sample the texture
2. Un-premultiply alpha
3. Apply the EOTF
4. Multiply by the 3x3 color space matrix
5. Apply the OETF
6. Premultiply alpha
Optimizations:
- Steps 2 & 6 are skipped for opaque (common) bitmaps
- Step 3 is skipped when the color space's EOTF is close
to sRGB (Display P3 for instance). Instead, we use
a hardware sRGB fetch (when the GPU supports it)
- When step 3 is necessary, we use one of four standard
EOTF implementations, to save cycles when possible:
+ Linear (doesn't do anything)
+ Full parametric (ICC parametric curve type 4 as defined
in ICC.1:2004-10, section 10.15)
+ Limited parametric (ICC parametric curve type 3)
+ Gamma (ICC parametric curve type 0)
Color space conversion could be done using texture samplers
instead, for instance 3D LUTs, with or without transfer
functions baked in, or 1D LUTs for transfer functions. This
would result in dependent texture fetches which may or may
not be an advantage over an ALU based implementation. The
current solution favor the use of ALUs to save precious
bandwidth.
Test: CtsUiRenderingTests, CtsGraphicsTests
Bug: 32984164
Change-Id: I10bc3db515e13973b45220f129c66b23f0f7f8fe
96 lines
2.3 KiB
C++
96 lines
2.3 KiB
C++
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "Layer.h"
|
|
|
|
#include "Texture.h"
|
|
|
|
namespace android {
|
|
namespace uirenderer {
|
|
|
|
// Forward declarations
|
|
class Caches;
|
|
|
|
/**
|
|
* A layer has dimensions and is backed by an OpenGL texture or FBO.
|
|
*/
|
|
class GlLayer : public Layer {
|
|
public:
|
|
GlLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
|
|
SkColorFilter* colorFilter, int alpha, SkBlendMode mode, bool blend);
|
|
virtual ~GlLayer();
|
|
|
|
uint32_t getWidth() const override {
|
|
return texture.mWidth;
|
|
}
|
|
|
|
uint32_t getHeight() const override {
|
|
return texture.mHeight;
|
|
}
|
|
|
|
void setSize(uint32_t width, uint32_t height) override {
|
|
texture.updateLayout(width, height, texture.internalFormat(), texture.format(),
|
|
texture.target());
|
|
}
|
|
|
|
void setBlend(bool blend) override {
|
|
texture.blend = blend;
|
|
}
|
|
|
|
bool isBlend() const override {
|
|
return texture.blend;
|
|
}
|
|
|
|
inline GLuint getTextureId() const {
|
|
return texture.id();
|
|
}
|
|
|
|
inline Texture& getTexture() {
|
|
return texture;
|
|
}
|
|
|
|
inline GLenum getRenderTarget() const {
|
|
return texture.target();
|
|
}
|
|
|
|
inline bool isRenderable() const {
|
|
return texture.target() != GL_NONE;
|
|
}
|
|
|
|
void setRenderTarget(GLenum renderTarget);
|
|
|
|
void generateTexture();
|
|
|
|
/**
|
|
* Lost the GL context but the layer is still around, mark it invalid internally
|
|
* so the dtor knows not to do any GL work
|
|
*/
|
|
void onGlContextLost();
|
|
|
|
private:
|
|
Caches& caches;
|
|
|
|
/**
|
|
* The texture backing this layer.
|
|
*/
|
|
Texture texture;
|
|
}; // struct GlLayer
|
|
|
|
}; // namespace uirenderer
|
|
}; // namespace android
|