libs/hwui/SkiaShader.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2010 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.
  */

 #define LOG_TAG "OpenGLRenderer"

 #include "SkiaShader.h"

 #include "Caches.h"
 #include "Extensions.h"
 #include "Layer.h"
 #include "Matrix.h"
 #include "Texture.h"

 #include <SkMatrix.h>
 #include <utils/Log.h>

 namespace android {
 namespace uirenderer {

 ///////////////////////////////////////////////////////////////////////////////
 // Support
 ///////////////////////////////////////////////////////////////////////////////

 static const GLenum gTileModes[] = {
         GL_CLAMP_TO_EDGE,   // == SkShader::kClamp_TileMode
         GL_REPEAT,          // == SkShader::kRepeat_Mode
         GL_MIRRORED_REPEAT  // == SkShader::kMirror_TileMode
 };

 /**
  * This function does not work for n == 0.
  */
 static inline bool isPowerOfTwo(unsigned int n) {
     return !(n & (n - 1));
 }

 static inline void bindUniformColor(int slot, FloatColor color) {
     glUniform4fv(slot, 1, reinterpret_cast<const float*>(&color));
 }

 static inline void bindTexture(Caches* caches, Texture* texture, GLenum wrapS, GLenum wrapT) {
     caches->textureState().bindTexture(texture->id);
     texture->setWrapST(wrapS, wrapT);
 }

 /**
  * Compute the matrix to transform to screen space.
  * @param screenSpace Output param for the computed matrix.
  * @param unitMatrix The unit matrix for gradient shaders, as returned by SkShader::asAGradient,
  *      or identity.
  * @param localMatrix Local matrix, as returned by SkShader::getLocalMatrix().
  * @param modelViewMatrix Model view matrix, as supplied by the OpenGLRenderer.
  */
 static void computeScreenSpaceMatrix(mat4& screenSpace, const SkMatrix& unitMatrix,
         const SkMatrix& localMatrix, const mat4& modelViewMatrix) {
     mat4 shaderMatrix;
     // uses implicit construction
     shaderMatrix.loadInverse(localMatrix);
     // again, uses implicit construction
     screenSpace.loadMultiply(unitMatrix, shaderMatrix);
     screenSpace.multiply(modelViewMatrix);
 }

 ///////////////////////////////////////////////////////////////////////////////
 // gradient shader matrix helpers
 ///////////////////////////////////////////////////////////////////////////////

 static void toLinearUnitMatrix(const SkPoint pts[2], SkMatrix* matrix) {
     SkVector vec = pts[1] - pts[0];
     const float mag = vec.length();
     const float inv = mag ? 1.0f / mag : 0;

     vec.scale(inv);
     matrix->setSinCos(-vec.fY, vec.fX, pts[0].fX, pts[0].fY);
     matrix->postTranslate(-pts[0].fX, -pts[0].fY);
     matrix->postScale(inv, inv);
 }

 static void toCircularUnitMatrix(const float x, const float y, const float radius,
         SkMatrix* matrix) {
     const float inv = 1.0f / radius;
     matrix->setTranslate(-x, -y);
     matrix->postScale(inv, inv);
 }

 static void toSweepUnitMatrix(const float x, const float y, SkMatrix* matrix) {
     matrix->setTranslate(-x, -y);
 }

 ///////////////////////////////////////////////////////////////////////////////
 // Common gradient code
 ///////////////////////////////////////////////////////////////////////////////

 static bool isSimpleGradient(const SkShader::GradientInfo& gradInfo) {
     return gradInfo.fColorCount == 2 && gradInfo.fTileMode == SkShader::kClamp_TileMode;
 }

 ///////////////////////////////////////////////////////////////////////////////
 // Store / apply
 ///////////////////////////////////////////////////////////////////////////////

 bool tryStoreGradient(Caches& caches, const SkShader& shader, const Matrix4 modelViewMatrix,
         GLuint* textureUnit, ProgramDescription* description,
         SkiaShaderData::GradientShaderData* outData) {
     SkShader::GradientInfo gradInfo;
     gradInfo.fColorCount = 0;
     gradInfo.fColors = nullptr;
     gradInfo.fColorOffsets = nullptr;

     SkMatrix unitMatrix;
     switch (shader.asAGradient(&gradInfo)) {
         case SkShader::kLinear_GradientType:
             description->gradientType = ProgramDescription::kGradientLinear;

             toLinearUnitMatrix(gradInfo.fPoint, &unitMatrix);
             break;
         case SkShader::kRadial_GradientType:
             description->gradientType = ProgramDescription::kGradientCircular;

             toCircularUnitMatrix(gradInfo.fPoint[0].fX, gradInfo.fPoint[0].fY,
                     gradInfo.fRadius[0], &unitMatrix);
             break;
         case SkShader::kSweep_GradientType:
             description->gradientType = ProgramDescription::kGradientSweep;

             toSweepUnitMatrix(gradInfo.fPoint[0].fX, gradInfo.fPoint[0].fY, &unitMatrix);
             break;
         default:
             // Do nothing. This shader is unsupported.
             return false;
     }
     description->hasGradient = true;
     description->isSimpleGradient = isSimpleGradient(gradInfo);

     computeScreenSpaceMatrix(outData->screenSpace, unitMatrix,
             shader.getLocalMatrix(), modelViewMatrix);

     // re-query shader to get full color / offset data
     std::unique_ptr<SkColor[]> colorStorage(new SkColor[gradInfo.fColorCount]);
     std::unique_ptr<SkScalar[]> colorOffsets(new SkScalar[gradInfo.fColorCount]);
     gradInfo.fColors = &colorStorage[0];
     gradInfo.fColorOffsets = &colorOffsets[0];
     shader.asAGradient(&gradInfo);

     if (CC_UNLIKELY(!isSimpleGradient(gradInfo))) {
         outData->gradientSampler = (*textureUnit)++;

 #ifndef SK_SCALAR_IS_FLOAT
     #error Need to convert gradInfo.fColorOffsets to float!
 #endif
         outData->gradientTexture = caches.gradientCache.get(
                 gradInfo.fColors, gradInfo.fColorOffsets, gradInfo.fColorCount);
         outData->wrapST = gTileModes[gradInfo.fTileMode];
     } else {
         outData->gradientSampler = 0;
         outData->gradientTexture = nullptr;

         outData->startColor.set(gradInfo.fColors[0]);
         outData->endColor.set(gradInfo.fColors[1]);
     }

     outData->ditherSampler = (*textureUnit)++;
     return true;
 }

 void applyGradient(Caches& caches, const SkiaShaderData::GradientShaderData& data) {
     if (CC_UNLIKELY(data.gradientTexture)) {
         caches.textureState().activateTexture(data.gradientSampler);
         bindTexture(&caches, data.gradientTexture, data.wrapST, data.wrapST);
         glUniform1i(caches.program().getUniform("gradientSampler"), data.gradientSampler);
     } else {
         bindUniformColor(caches.program().getUniform("startColor"), data.startColor);
         bindUniformColor(caches.program().getUniform("endColor"), data.endColor);
     }

     // TODO: remove sampler slot incrementing from dither.setupProgram,
     // since this assignment of slots is done at store, not apply time
     GLuint ditherSampler = data.ditherSampler;
     caches.dither.setupProgram(caches.program(), &ditherSampler);
     glUniformMatrix4fv(caches.program().getUniform("screenSpace"), 1,
             GL_FALSE, &data.screenSpace.data[0]);
 }

 bool tryStoreBitmap(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
         GLuint* textureUnit, ProgramDescription* description,
         SkiaShaderData::BitmapShaderData* outData) {
     SkBitmap bitmap;
     SkShader::TileMode xy[2];
     if (shader.asABitmap(&bitmap, nullptr, xy) != SkShader::kDefault_BitmapType) {
         return false;
     }

     /*
      * Bypass the AssetAtlas, since those textures:
      * 1) require UV mapping, which isn't implemented in matrix computation below
      * 2) can't handle REPEAT simply
      * 3) are safe to upload here (outside of sync stage), since they're static
      */
     outData->bitmapTexture = caches.textureCache.getAndBypassAtlas(&bitmap);
     if (!outData->bitmapTexture) return false;

     outData->bitmapSampler = (*textureUnit)++;

     const float width = outData->bitmapTexture->width;
     const float height = outData->bitmapTexture->height;

     description->hasBitmap = true;
     if (!caches.extensions().hasNPot()
             && (!isPowerOfTwo(width) || !isPowerOfTwo(height))
             && (xy[0] != SkShader::kClamp_TileMode || xy[1] != SkShader::kClamp_TileMode)) {
         description->isBitmapNpot = true;
         description->bitmapWrapS = gTileModes[xy[0]];
         description->bitmapWrapT = gTileModes[xy[1]];

         outData->wrapS = GL_CLAMP_TO_EDGE;
         outData->wrapT = GL_CLAMP_TO_EDGE;
     } else {
         outData->wrapS = gTileModes[xy[0]];
         outData->wrapT = gTileModes[xy[1]];
     }

     computeScreenSpaceMatrix(outData->textureTransform, SkMatrix::I(), shader.getLocalMatrix(),
             modelViewMatrix);
     outData->textureDimension[0] = 1.0f / width;
     outData->textureDimension[1] = 1.0f / height;

     return true;
 }

 void applyBitmap(Caches& caches, const SkiaShaderData::BitmapShaderData& data) {
     caches.textureState().activateTexture(data.bitmapSampler);
     bindTexture(&caches, data.bitmapTexture, data.wrapS, data.wrapT);
     data.bitmapTexture->setFilter(GL_LINEAR);

     glUniform1i(caches.program().getUniform("bitmapSampler"), data.bitmapSampler);
     glUniformMatrix4fv(caches.program().getUniform("textureTransform"), 1, GL_FALSE,
             &data.textureTransform.data[0]);
     glUniform2fv(caches.program().getUniform("textureDimension"), 1, &data.textureDimension[0]);
 }

 SkiaShaderType getComposeSubType(const SkShader& shader) {
     // First check for a gradient shader.
     switch (shader.asAGradient(nullptr)) {
         case SkShader::kNone_GradientType:
             // Not a gradient shader. Fall through to check for other types.
             break;
         case SkShader::kLinear_GradientType:
         case SkShader::kRadial_GradientType:
         case SkShader::kSweep_GradientType:
             return kGradient_SkiaShaderType;
         default:
             // This is a Skia gradient that has no SkiaShader equivalent. Return None to skip.
             return kNone_SkiaShaderType;
     }

     // The shader is not a gradient. Check for a bitmap shader.
     if (shader.asABitmap(nullptr, nullptr, nullptr) == SkShader::kDefault_BitmapType) {
         return kBitmap_SkiaShaderType;
     }
     return kNone_SkiaShaderType;
 }

 void storeCompose(Caches& caches, const SkShader& bitmapShader, const SkShader& gradientShader,
         const Matrix4& modelViewMatrix, GLuint* textureUnit,
         ProgramDescription* description, SkiaShaderData* outData) {
     LOG_ALWAYS_FATAL_IF(!tryStoreBitmap(caches, bitmapShader, modelViewMatrix,
                 textureUnit, description, &outData->bitmapData),
             "failed storing bitmap shader data");
     LOG_ALWAYS_FATAL_IF(!tryStoreGradient(caches, gradientShader, modelViewMatrix,
                 textureUnit, description, &outData->gradientData),
             "failing storing gradient shader data");
 }

 bool tryStoreCompose(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
         GLuint* textureUnit, ProgramDescription* description,
         SkiaShaderData* outData) {

     SkShader::ComposeRec rec;
     if (!shader.asACompose(&rec)) return false;

     const SkiaShaderType shaderAType = getComposeSubType(*rec.fShaderA);
     const SkiaShaderType shaderBType = getComposeSubType(*rec.fShaderB);

     // check that type enum values are the 2 flags that compose the kCompose value
     if ((shaderAType & shaderBType) != 0) return false;
     if ((shaderAType | shaderBType) != kCompose_SkiaShaderType) return false;

     mat4 transform;
     computeScreenSpaceMatrix(transform, SkMatrix::I(), shader.getLocalMatrix(), modelViewMatrix);
     if (shaderAType == kBitmap_SkiaShaderType) {
         description->isBitmapFirst = true;
         storeCompose(caches, *rec.fShaderA, *rec.fShaderB,
                 transform, textureUnit, description, outData);
     } else {
         description->isBitmapFirst = false;
         storeCompose(caches, *rec.fShaderB, *rec.fShaderA,
                 transform, textureUnit, description, outData);
     }
     if (!SkXfermode::AsMode(rec.fMode, &description->shadersMode)) {
         // TODO: Support other modes.
         description->shadersMode = SkXfermode::kSrcOver_Mode;
     }
     return true;
 }

 bool tryStoreLayer(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
         GLuint* textureUnit, ProgramDescription* description,
         SkiaShaderData::LayerShaderData* outData) {
     Layer* layer;
     if (!shader.asACustomShader(reinterpret_cast<void**>(&layer))) {
         return false;
     }

     description->hasBitmap = true;
     outData->layer = layer;
     outData->bitmapSampler = (*textureUnit)++;

     const float width = layer->getWidth();
     const float height = layer->getHeight();

     computeScreenSpaceMatrix(outData->textureTransform, SkMatrix::I(), shader.getLocalMatrix(),
             modelViewMatrix);

     outData->textureDimension[0] = 1.0f / width;
     outData->textureDimension[1] = 1.0f / height;
     return true;
 }

 void applyLayer(Caches& caches, const SkiaShaderData::LayerShaderData& data) {
     caches.textureState().activateTexture(data.bitmapSampler);

     data.layer->bindTexture();
     data.layer->setWrap(GL_CLAMP_TO_EDGE);
     data.layer->setFilter(GL_LINEAR);

     glUniform1i(caches.program().getUniform("bitmapSampler"), data.bitmapSampler);
     glUniformMatrix4fv(caches.program().getUniform("textureTransform"), 1,
             GL_FALSE, &data.textureTransform.data[0]);
     glUniform2fv(caches.program().getUniform("textureDimension"), 1, &data.textureDimension[0]);
 }

 void SkiaShader::store(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
         GLuint* textureUnit, ProgramDescription* description,
         SkiaShaderData* outData) {
     if (tryStoreGradient(caches, shader, modelViewMatrix,
             textureUnit, description, &outData->gradientData)) {
         outData->skiaShaderType = kGradient_SkiaShaderType;
         return;
     }

     if (tryStoreBitmap(caches, shader, modelViewMatrix,
             textureUnit, description, &outData->bitmapData)) {
         outData->skiaShaderType = kBitmap_SkiaShaderType;
         return;
     }

     if (tryStoreCompose(caches, shader, modelViewMatrix,
             textureUnit, description, outData)) {
         outData->skiaShaderType = kCompose_SkiaShaderType;
         return;
     }

     if (tryStoreLayer(caches, shader, modelViewMatrix,
             textureUnit, description, &outData->layerData)) {
         outData->skiaShaderType = kLayer_SkiaShaderType;
         return;
     }

     // Unknown/unsupported type, so explicitly ignore shader
     outData->skiaShaderType = kNone_SkiaShaderType;
 }

 void SkiaShader::apply(Caches& caches, const SkiaShaderData& data) {
     if (!data.skiaShaderType) return;

     if (data.skiaShaderType & kGradient_SkiaShaderType) {
         applyGradient(caches, data.gradientData);
     }
     if (data.skiaShaderType & kBitmap_SkiaShaderType) {
         applyBitmap(caches, data.bitmapData);
     }

     if (data.skiaShaderType == kLayer_SkiaShaderType) {
         applyLayer(caches, data.layerData);
     }
 }

 }; // namespace uirenderer
 }; // namespace android
	/*
	* Copyright (C) 2010 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.
	*/

	#define LOG_TAG "OpenGLRenderer"

	#include "SkiaShader.h"

	#include "Caches.h"
	#include "Extensions.h"
	#include "Layer.h"
	#include "Matrix.h"
	#include "Texture.h"

	#include <SkMatrix.h>
	#include <utils/Log.h>

	namespace android {
	namespace uirenderer {

	///////////////////////////////////////////////////////////////////////////////
	// Support
	///////////////////////////////////////////////////////////////////////////////

	static const GLenum gTileModes[] = {
	GL_CLAMP_TO_EDGE, // == SkShader::kClamp_TileMode
	GL_REPEAT, // == SkShader::kRepeat_Mode
	GL_MIRRORED_REPEAT // == SkShader::kMirror_TileMode
	};

	/**
	* This function does not work for n == 0.
	*/
	static inline bool isPowerOfTwo(unsigned int n) {
	return !(n & (n - 1));
	}

	static inline void bindUniformColor(int slot, FloatColor color) {
	glUniform4fv(slot, 1, reinterpret_cast<const float*>(&color));
	}

	static inline void bindTexture(Caches* caches, Texture* texture, GLenum wrapS, GLenum wrapT) {
	caches->textureState().bindTexture(texture->id);
	texture->setWrapST(wrapS, wrapT);
	}

	/**
	* Compute the matrix to transform to screen space.
	* @param screenSpace Output param for the computed matrix.
	* @param unitMatrix The unit matrix for gradient shaders, as returned by SkShader::asAGradient,
	* or identity.
	* @param localMatrix Local matrix, as returned by SkShader::getLocalMatrix().
	* @param modelViewMatrix Model view matrix, as supplied by the OpenGLRenderer.
	*/
	static void computeScreenSpaceMatrix(mat4& screenSpace, const SkMatrix& unitMatrix,
	const SkMatrix& localMatrix, const mat4& modelViewMatrix) {
	mat4 shaderMatrix;
	// uses implicit construction
	shaderMatrix.loadInverse(localMatrix);
	// again, uses implicit construction
	screenSpace.loadMultiply(unitMatrix, shaderMatrix);
	screenSpace.multiply(modelViewMatrix);
	}

	///////////////////////////////////////////////////////////////////////////////
	// gradient shader matrix helpers
	///////////////////////////////////////////////////////////////////////////////

	static void toLinearUnitMatrix(const SkPoint pts[2], SkMatrix* matrix) {
	SkVector vec = pts[1] - pts[0];
	const float mag = vec.length();
	const float inv = mag ? 1.0f / mag : 0;

	vec.scale(inv);
	matrix->setSinCos(-vec.fY, vec.fX, pts[0].fX, pts[0].fY);
	matrix->postTranslate(-pts[0].fX, -pts[0].fY);
	matrix->postScale(inv, inv);
	}

	static void toCircularUnitMatrix(const float x, const float y, const float radius,
	SkMatrix* matrix) {
	const float inv = 1.0f / radius;
	matrix->setTranslate(-x, -y);
	matrix->postScale(inv, inv);
	}

	static void toSweepUnitMatrix(const float x, const float y, SkMatrix* matrix) {
	matrix->setTranslate(-x, -y);
	}

	///////////////////////////////////////////////////////////////////////////////
	// Common gradient code
	///////////////////////////////////////////////////////////////////////////////

	static bool isSimpleGradient(const SkShader::GradientInfo& gradInfo) {
	return gradInfo.fColorCount == 2 && gradInfo.fTileMode == SkShader::kClamp_TileMode;
	}

	///////////////////////////////////////////////////////////////////////////////
	// Store / apply
	///////////////////////////////////////////////////////////////////////////////

	bool tryStoreGradient(Caches& caches, const SkShader& shader, const Matrix4 modelViewMatrix,
	GLuint* textureUnit, ProgramDescription* description,
	SkiaShaderData::GradientShaderData* outData) {
	SkShader::GradientInfo gradInfo;
	gradInfo.fColorCount = 0;
	gradInfo.fColors = nullptr;
	gradInfo.fColorOffsets = nullptr;

	SkMatrix unitMatrix;
	switch (shader.asAGradient(&gradInfo)) {
	case SkShader::kLinear_GradientType:
	description->gradientType = ProgramDescription::kGradientLinear;

	toLinearUnitMatrix(gradInfo.fPoint, &unitMatrix);
	break;
	case SkShader::kRadial_GradientType:
	description->gradientType = ProgramDescription::kGradientCircular;

	toCircularUnitMatrix(gradInfo.fPoint[0].fX, gradInfo.fPoint[0].fY,
	gradInfo.fRadius[0], &unitMatrix);
	break;
	case SkShader::kSweep_GradientType:
	description->gradientType = ProgramDescription::kGradientSweep;

	toSweepUnitMatrix(gradInfo.fPoint[0].fX, gradInfo.fPoint[0].fY, &unitMatrix);
	break;
	default:
	// Do nothing. This shader is unsupported.
	return false;
	}
	description->hasGradient = true;
	description->isSimpleGradient = isSimpleGradient(gradInfo);

	computeScreenSpaceMatrix(outData->screenSpace, unitMatrix,
	shader.getLocalMatrix(), modelViewMatrix);

	// re-query shader to get full color / offset data
	std::unique_ptr<SkColor[]> colorStorage(new SkColor[gradInfo.fColorCount]);
	std::unique_ptr<SkScalar[]> colorOffsets(new SkScalar[gradInfo.fColorCount]);
	gradInfo.fColors = &colorStorage[0];
	gradInfo.fColorOffsets = &colorOffsets[0];
	shader.asAGradient(&gradInfo);

	if (CC_UNLIKELY(!isSimpleGradient(gradInfo))) {
	outData->gradientSampler = (*textureUnit)++;

	#ifndef SK_SCALAR_IS_FLOAT
	#error Need to convert gradInfo.fColorOffsets to float!
	#endif
	outData->gradientTexture = caches.gradientCache.get(
	gradInfo.fColors, gradInfo.fColorOffsets, gradInfo.fColorCount);
	outData->wrapST = gTileModes[gradInfo.fTileMode];
	} else {
	outData->gradientSampler = 0;
	outData->gradientTexture = nullptr;

	outData->startColor.set(gradInfo.fColors[0]);
	outData->endColor.set(gradInfo.fColors[1]);
	}

	outData->ditherSampler = (*textureUnit)++;
	return true;
	}

	void applyGradient(Caches& caches, const SkiaShaderData::GradientShaderData& data) {
	if (CC_UNLIKELY(data.gradientTexture)) {
	caches.textureState().activateTexture(data.gradientSampler);
	bindTexture(&caches, data.gradientTexture, data.wrapST, data.wrapST);
	glUniform1i(caches.program().getUniform("gradientSampler"), data.gradientSampler);
	} else {
	bindUniformColor(caches.program().getUniform("startColor"), data.startColor);
	bindUniformColor(caches.program().getUniform("endColor"), data.endColor);
	}

	// TODO: remove sampler slot incrementing from dither.setupProgram,
	// since this assignment of slots is done at store, not apply time
	GLuint ditherSampler = data.ditherSampler;
	caches.dither.setupProgram(caches.program(), &ditherSampler);
	glUniformMatrix4fv(caches.program().getUniform("screenSpace"), 1,
	GL_FALSE, &data.screenSpace.data[0]);
	}

	bool tryStoreBitmap(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
	GLuint* textureUnit, ProgramDescription* description,
	SkiaShaderData::BitmapShaderData* outData) {
	SkBitmap bitmap;
	SkShader::TileMode xy[2];
	if (shader.asABitmap(&bitmap, nullptr, xy) != SkShader::kDefault_BitmapType) {
	return false;
	}

	/*
	* Bypass the AssetAtlas, since those textures:
	* 1) require UV mapping, which isn't implemented in matrix computation below
	* 2) can't handle REPEAT simply
	* 3) are safe to upload here (outside of sync stage), since they're static
	*/
	outData->bitmapTexture = caches.textureCache.getAndBypassAtlas(&bitmap);
	if (!outData->bitmapTexture) return false;

	outData->bitmapSampler = (*textureUnit)++;

	const float width = outData->bitmapTexture->width;
	const float height = outData->bitmapTexture->height;

	description->hasBitmap = true;
	if (!caches.extensions().hasNPot()
	&& (!isPowerOfTwo(width) \|\| !isPowerOfTwo(height))
	&& (xy[0] != SkShader::kClamp_TileMode \|\| xy[1] != SkShader::kClamp_TileMode)) {
	description->isBitmapNpot = true;
	description->bitmapWrapS = gTileModes[xy[0]];
	description->bitmapWrapT = gTileModes[xy[1]];

	outData->wrapS = GL_CLAMP_TO_EDGE;
	outData->wrapT = GL_CLAMP_TO_EDGE;
	} else {
	outData->wrapS = gTileModes[xy[0]];
	outData->wrapT = gTileModes[xy[1]];
	}

	computeScreenSpaceMatrix(outData->textureTransform, SkMatrix::I(), shader.getLocalMatrix(),
	modelViewMatrix);
	outData->textureDimension[0] = 1.0f / width;
	outData->textureDimension[1] = 1.0f / height;

	return true;
	}

	void applyBitmap(Caches& caches, const SkiaShaderData::BitmapShaderData& data) {
	caches.textureState().activateTexture(data.bitmapSampler);
	bindTexture(&caches, data.bitmapTexture, data.wrapS, data.wrapT);
	data.bitmapTexture->setFilter(GL_LINEAR);

	glUniform1i(caches.program().getUniform("bitmapSampler"), data.bitmapSampler);
	glUniformMatrix4fv(caches.program().getUniform("textureTransform"), 1, GL_FALSE,
	&data.textureTransform.data[0]);
	glUniform2fv(caches.program().getUniform("textureDimension"), 1, &data.textureDimension[0]);
	}

	SkiaShaderType getComposeSubType(const SkShader& shader) {
	// First check for a gradient shader.
	switch (shader.asAGradient(nullptr)) {
	case SkShader::kNone_GradientType:
	// Not a gradient shader. Fall through to check for other types.
	break;
	case SkShader::kLinear_GradientType:
	case SkShader::kRadial_GradientType:
	case SkShader::kSweep_GradientType:
	return kGradient_SkiaShaderType;
	default:
	// This is a Skia gradient that has no SkiaShader equivalent. Return None to skip.
	return kNone_SkiaShaderType;
	}

	// The shader is not a gradient. Check for a bitmap shader.
	if (shader.asABitmap(nullptr, nullptr, nullptr) == SkShader::kDefault_BitmapType) {
	return kBitmap_SkiaShaderType;
	}
	return kNone_SkiaShaderType;
	}

	void storeCompose(Caches& caches, const SkShader& bitmapShader, const SkShader& gradientShader,
	const Matrix4& modelViewMatrix, GLuint* textureUnit,
	ProgramDescription* description, SkiaShaderData* outData) {
	LOG_ALWAYS_FATAL_IF(!tryStoreBitmap(caches, bitmapShader, modelViewMatrix,
	textureUnit, description, &outData->bitmapData),
	"failed storing bitmap shader data");
	LOG_ALWAYS_FATAL_IF(!tryStoreGradient(caches, gradientShader, modelViewMatrix,
	textureUnit, description, &outData->gradientData),
	"failing storing gradient shader data");
	}

	bool tryStoreCompose(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
	GLuint* textureUnit, ProgramDescription* description,
	SkiaShaderData* outData) {

	SkShader::ComposeRec rec;
	if (!shader.asACompose(&rec)) return false;

	const SkiaShaderType shaderAType = getComposeSubType(*rec.fShaderA);
	const SkiaShaderType shaderBType = getComposeSubType(*rec.fShaderB);

	// check that type enum values are the 2 flags that compose the kCompose value
	if ((shaderAType & shaderBType) != 0) return false;
	if ((shaderAType \| shaderBType) != kCompose_SkiaShaderType) return false;

	mat4 transform;
	computeScreenSpaceMatrix(transform, SkMatrix::I(), shader.getLocalMatrix(), modelViewMatrix);
	if (shaderAType == kBitmap_SkiaShaderType) {
	description->isBitmapFirst = true;
	storeCompose(caches, rec.fShaderA, rec.fShaderB,
	transform, textureUnit, description, outData);
	} else {
	description->isBitmapFirst = false;
	storeCompose(caches, rec.fShaderB, rec.fShaderA,
	transform, textureUnit, description, outData);
	}
	if (!SkXfermode::AsMode(rec.fMode, &description->shadersMode)) {
	// TODO: Support other modes.
	description->shadersMode = SkXfermode::kSrcOver_Mode;
	}
	return true;
	}

	bool tryStoreLayer(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
	GLuint* textureUnit, ProgramDescription* description,
	SkiaShaderData::LayerShaderData* outData) {
	Layer* layer;
	if (!shader.asACustomShader(reinterpret_cast<void**>(&layer))) {
	return false;
	}

	description->hasBitmap = true;
	outData->layer = layer;
	outData->bitmapSampler = (*textureUnit)++;

	const float width = layer->getWidth();
	const float height = layer->getHeight();

	computeScreenSpaceMatrix(outData->textureTransform, SkMatrix::I(), shader.getLocalMatrix(),
	modelViewMatrix);

	outData->textureDimension[0] = 1.0f / width;
	outData->textureDimension[1] = 1.0f / height;
	return true;
	}

	void applyLayer(Caches& caches, const SkiaShaderData::LayerShaderData& data) {
	caches.textureState().activateTexture(data.bitmapSampler);

	data.layer->bindTexture();
	data.layer->setWrap(GL_CLAMP_TO_EDGE);
	data.layer->setFilter(GL_LINEAR);

	glUniform1i(caches.program().getUniform("bitmapSampler"), data.bitmapSampler);
	glUniformMatrix4fv(caches.program().getUniform("textureTransform"), 1,
	GL_FALSE, &data.textureTransform.data[0]);
	glUniform2fv(caches.program().getUniform("textureDimension"), 1, &data.textureDimension[0]);
	}

	void SkiaShader::store(Caches& caches, const SkShader& shader, const Matrix4& modelViewMatrix,
	GLuint* textureUnit, ProgramDescription* description,
	SkiaShaderData* outData) {
	if (tryStoreGradient(caches, shader, modelViewMatrix,
	textureUnit, description, &outData->gradientData)) {
	outData->skiaShaderType = kGradient_SkiaShaderType;
	return;
	}

	if (tryStoreBitmap(caches, shader, modelViewMatrix,
	textureUnit, description, &outData->bitmapData)) {
	outData->skiaShaderType = kBitmap_SkiaShaderType;
	return;
	}

	if (tryStoreCompose(caches, shader, modelViewMatrix,
	textureUnit, description, outData)) {
	outData->skiaShaderType = kCompose_SkiaShaderType;
	return;
	}

	if (tryStoreLayer(caches, shader, modelViewMatrix,
	textureUnit, description, &outData->layerData)) {
	outData->skiaShaderType = kLayer_SkiaShaderType;
	return;
	}

	// Unknown/unsupported type, so explicitly ignore shader
	outData->skiaShaderType = kNone_SkiaShaderType;
	}

	void SkiaShader::apply(Caches& caches, const SkiaShaderData& data) {
	if (!data.skiaShaderType) return;

	if (data.skiaShaderType & kGradient_SkiaShaderType) {
	applyGradient(caches, data.gradientData);
	}
	if (data.skiaShaderType & kBitmap_SkiaShaderType) {
	applyBitmap(caches, data.bitmapData);
	}

	if (data.skiaShaderType == kLayer_SkiaShaderType) {
	applyLayer(caches, data.layerData);
	}
	}

	}; // namespace uirenderer
	}; // namespace android