libs/hwui/Program.h - platform/frameworks/base - Gitiles

 /*
  * 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.
  */

 #ifndef ANDROID_HWUI_PROGRAM_H
 #define ANDROID_HWUI_PROGRAM_H

 #include <utils/KeyedVector.h>

 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>

 #include <SkBlendMode.h>

 #include "Debug.h"
 #include "FloatColor.h"
 #include "Matrix.h"
 #include "Properties.h"
 #include "utils/Color.h"

 namespace android {
 namespace uirenderer {

 ///////////////////////////////////////////////////////////////////////////////
 // Defines
 ///////////////////////////////////////////////////////////////////////////////

 // Debug
 #if DEBUG_PROGRAMS
 #define PROGRAM_LOGD(...) ALOGD(__VA_ARGS__)
 #else
 #define PROGRAM_LOGD(...)
 #endif

 #define COLOR_COMPONENT_THRESHOLD 1.0f
 #define COLOR_COMPONENT_INV_THRESHOLD 0.0f

 #define PROGRAM_KEY_TEXTURE 0x01
 #define PROGRAM_KEY_A8_TEXTURE 0x02
 #define PROGRAM_KEY_BITMAP 0x04
 #define PROGRAM_KEY_GRADIENT 0x08
 #define PROGRAM_KEY_BITMAP_FIRST 0x10
 #define PROGRAM_KEY_COLOR_MATRIX 0x20
 #define PROGRAM_KEY_COLOR_BLEND 0x40
 #define PROGRAM_KEY_BITMAP_NPOT 0x80
 #define PROGRAM_KEY_BITMAP_EXTERNAL 0x100

 #define PROGRAM_KEY_BITMAP_WRAPS_MASK 0x600
 #define PROGRAM_KEY_BITMAP_WRAPT_MASK 0x1800

 #define PROGRAM_KEY_SWAP_SRC_DST_SHIFT 13

 // Encode the xfermodes on 6 bits
 #define PROGRAM_MAX_XFERMODE 0x1f
 #define PROGRAM_XFERMODE_SHADER_SHIFT 26
 #define PROGRAM_XFERMODE_COLOR_OP_SHIFT 20
 #define PROGRAM_XFERMODE_FRAMEBUFFER_SHIFT 14

 #define PROGRAM_BITMAP_WRAPS_SHIFT 9
 #define PROGRAM_BITMAP_WRAPT_SHIFT 11

 #define PROGRAM_GRADIENT_TYPE_SHIFT 33  // 2 bits for gradient type
 #define PROGRAM_MODULATE_SHIFT 35

 #define PROGRAM_HAS_VERTEX_ALPHA_SHIFT 36
 #define PROGRAM_USE_SHADOW_ALPHA_INTERP_SHIFT 37

 #define PROGRAM_HAS_EXTERNAL_TEXTURE_SHIFT 38
 #define PROGRAM_HAS_TEXTURE_TRANSFORM_SHIFT 39

 #define PROGRAM_IS_SIMPLE_GRADIENT 40

 #define PROGRAM_HAS_COLORS 41

 #define PROGRAM_HAS_DEBUG_HIGHLIGHT 42
 #define PROGRAM_HAS_ROUND_RECT_CLIP 43

 #define PROGRAM_HAS_GAMMA_CORRECTION 44
 #define PROGRAM_HAS_LINEAR_TEXTURE 45

 #define PROGRAM_HAS_COLOR_SPACE_CONVERSION 46
 #define PROGRAM_TRANSFER_FUNCTION 47  // 2 bits for transfer function
 #define PROGRAM_HAS_TRANSLUCENT_CONVERSION 49

 ///////////////////////////////////////////////////////////////////////////////
 // Types
 ///////////////////////////////////////////////////////////////////////////////

 typedef uint64_t programid;

 ///////////////////////////////////////////////////////////////////////////////
 // Program description
 ///////////////////////////////////////////////////////////////////////////////

 /**
  * Describe the features required for a given program. The features
  * determine the generation of both the vertex and fragment shaders.
  * A ProgramDescription must be used in conjunction with a ProgramCache.
  */
 struct ProgramDescription {
     enum class ColorFilterMode : int8_t { None = 0, Matrix, Blend };

     enum Gradient : int8_t { kGradientLinear = 0, kGradientCircular, kGradientSweep };

     ProgramDescription() { reset(); }

     // Texturing
     bool hasTexture;
     bool hasAlpha8Texture;
     bool hasExternalTexture;
     bool hasTextureTransform;

     // Color attribute
     bool hasColors;

     // Modulate, this should only be set when setColor() return true
     bool modulate;

     // Shaders
     bool hasBitmap;
     bool isShaderBitmapExternal;
     bool useShaderBasedWrap;

     bool hasVertexAlpha;
     bool useShadowAlphaInterp;

     bool hasGradient;
     Gradient gradientType;
     bool isSimpleGradient;

     SkBlendMode shadersMode;

     bool isBitmapFirst;
     GLenum bitmapWrapS;
     GLenum bitmapWrapT;

     // Color operations
     ColorFilterMode colorOp;
     SkBlendMode colorMode;

     // Framebuffer blending (requires Extensions.hasFramebufferFetch())
     // Ignored for all values < SkBlendMode::kPlus
     SkBlendMode framebufferMode;
     bool swapSrcDst;

     bool hasDebugHighlight;
     bool hasRoundRectClip;

     // Extra gamma correction used for text
     bool hasGammaCorrection;
     // Set when sampling an image in linear space
     bool hasLinearTexture;

     bool hasColorSpaceConversion;
     TransferFunctionType transferFunction;
     // Indicates whether the bitmap to convert between color spaces is translucent
     bool hasTranslucentConversion;

     /**
      * Resets this description. All fields are reset back to the default
      * values they hold after building a new instance.
      */
     void reset() {
         hasTexture = false;
         hasAlpha8Texture = false;
         hasExternalTexture = false;
         hasTextureTransform = false;

         hasColors = false;

         hasVertexAlpha = false;
         useShadowAlphaInterp = false;

         modulate = false;

         hasBitmap = false;
         isShaderBitmapExternal = false;
         useShaderBasedWrap = false;

         hasGradient = false;
         gradientType = kGradientLinear;
         isSimpleGradient = false;

         shadersMode = SkBlendMode::kClear;

         isBitmapFirst = false;
         bitmapWrapS = GL_CLAMP_TO_EDGE;
         bitmapWrapT = GL_CLAMP_TO_EDGE;

         colorOp = ColorFilterMode::None;
         colorMode = SkBlendMode::kClear;

         framebufferMode = SkBlendMode::kClear;
         swapSrcDst = false;

         hasDebugHighlight = false;
         hasRoundRectClip = false;

         hasGammaCorrection = false;
         hasLinearTexture = false;

         hasColorSpaceConversion = false;
         transferFunction = TransferFunctionType::None;
         hasTranslucentConversion = false;
     }

     /**
      * Indicates, for a given color, whether color modulation is required in
      * the fragment shader. When this method returns true, the program should
      * be provided with a modulation color.
      */
     bool setColorModulate(const float a) {
         modulate = a < COLOR_COMPONENT_THRESHOLD;
         return modulate;
     }

     /**
      * Indicates, for a given color, whether color modulation is required in
      * the fragment shader. When this method returns true, the program should
      * be provided with a modulation color.
      */
     bool setAlpha8ColorModulate(const float r, const float g, const float b, const float a) {
         modulate = a < COLOR_COMPONENT_THRESHOLD || r > COLOR_COMPONENT_INV_THRESHOLD ||
                    g > COLOR_COMPONENT_INV_THRESHOLD || b > COLOR_COMPONENT_INV_THRESHOLD;
         return modulate;
     }

     /**
      * Computes the unique key identifying this program.
      */
     programid key() const {
         programid key = 0;
         if (hasTexture) key |= PROGRAM_KEY_TEXTURE;
         if (hasAlpha8Texture) key |= PROGRAM_KEY_A8_TEXTURE;
         if (hasBitmap) {
             key |= PROGRAM_KEY_BITMAP;
             if (useShaderBasedWrap) {
                 key |= PROGRAM_KEY_BITMAP_NPOT;
                 key |= getEnumForWrap(bitmapWrapS) << PROGRAM_BITMAP_WRAPS_SHIFT;
                 key |= getEnumForWrap(bitmapWrapT) << PROGRAM_BITMAP_WRAPT_SHIFT;
             }
             if (isShaderBitmapExternal) {
                 key |= PROGRAM_KEY_BITMAP_EXTERNAL;
             }
         }
         if (hasGradient) key |= PROGRAM_KEY_GRADIENT;
         key |= programid(gradientType) << PROGRAM_GRADIENT_TYPE_SHIFT;
         if (isBitmapFirst) key |= PROGRAM_KEY_BITMAP_FIRST;
         if (hasBitmap && hasGradient) {
             key |= ((int)shadersMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_SHADER_SHIFT;
         }
         switch (colorOp) {
             case ColorFilterMode::Matrix:
                 key |= PROGRAM_KEY_COLOR_MATRIX;
                 break;
             case ColorFilterMode::Blend:
                 key |= PROGRAM_KEY_COLOR_BLEND;
                 key |= ((int)colorMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_COLOR_OP_SHIFT;
                 break;
             case ColorFilterMode::None:
                 break;
         }
         key |= ((int)framebufferMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_FRAMEBUFFER_SHIFT;
         key |= programid(swapSrcDst) << PROGRAM_KEY_SWAP_SRC_DST_SHIFT;
         key |= programid(modulate) << PROGRAM_MODULATE_SHIFT;
         key |= programid(hasVertexAlpha) << PROGRAM_HAS_VERTEX_ALPHA_SHIFT;
         key |= programid(useShadowAlphaInterp) << PROGRAM_USE_SHADOW_ALPHA_INTERP_SHIFT;
         key |= programid(hasExternalTexture) << PROGRAM_HAS_EXTERNAL_TEXTURE_SHIFT;
         key |= programid(hasTextureTransform) << PROGRAM_HAS_TEXTURE_TRANSFORM_SHIFT;
         key |= programid(isSimpleGradient) << PROGRAM_IS_SIMPLE_GRADIENT;
         key |= programid(hasColors) << PROGRAM_HAS_COLORS;
         key |= programid(hasDebugHighlight) << PROGRAM_HAS_DEBUG_HIGHLIGHT;
         key |= programid(hasRoundRectClip) << PROGRAM_HAS_ROUND_RECT_CLIP;
         key |= programid(hasGammaCorrection) << PROGRAM_HAS_GAMMA_CORRECTION;
         key |= programid(hasLinearTexture) << PROGRAM_HAS_LINEAR_TEXTURE;
         key |= programid(hasColorSpaceConversion) << PROGRAM_HAS_COLOR_SPACE_CONVERSION;
         key |= programid(transferFunction) << PROGRAM_TRANSFER_FUNCTION;
         key |= programid(hasTranslucentConversion) << PROGRAM_HAS_TRANSLUCENT_CONVERSION;
         return key;
     }

     /**
      * Logs the specified message followed by the key identifying this program.
      */
     void log(const char* message) const {
 #if DEBUG_PROGRAMS
         programid k = key();
         PROGRAM_LOGD("%s (key = 0x%.8x%.8x)", message, uint32_t(k >> 32), uint32_t(k & 0xffffffff));
 #endif
     }

 private:
     static inline uint32_t getEnumForWrap(GLenum wrap) {
         switch (wrap) {
             case GL_CLAMP_TO_EDGE:
                 return 0;
             case GL_REPEAT:
                 return 1;
             case GL_MIRRORED_REPEAT:
                 return 2;
         }
         return 0;
     }

 };  // struct ProgramDescription

 /**
  * A program holds a vertex and a fragment shader. It offers several utility
  * methods to query attributes and uniforms.
  */
 class Program {
 public:
     enum ShaderBindings { kBindingPosition, kBindingTexCoords };

     /**
      * Creates a new program with the specified vertex and fragment
      * shaders sources.
      */
     Program(const ProgramDescription& description, const char* vertex, const char* fragment);
     virtual ~Program();

     /**
      * Binds this program to the GL context.
      */
     virtual void use();

     /**
      * Marks this program as unused. This will not unbind
      * the program from the GL context.
      */
     virtual void remove();

     /**
      * Returns the OpenGL name of the specified attribute.
      */
     int getAttrib(const char* name);

     /**
      * Returns the OpenGL name of the specified uniform.
      */
     int getUniform(const char* name);

     /**
      * Indicates whether this program is currently in use with
      * the GL context.
      */
     inline bool isInUse() const { return mUse; }

     /**
      * Indicates whether this program was correctly compiled and linked.
      */
     inline bool isInitialized() const { return mInitialized; }

     /**
      * Binds the program with the specified projection, modelView and
      * transform matrices.
      */
     void set(const mat4& projectionMatrix, const mat4& modelViewMatrix, const mat4& transformMatrix,
              bool offset = false);

     /**
      * Sets the color associated with this shader.
      */
     void setColor(FloatColor color);

     /**
      * Name of the texCoords attribute if it exists (kBindingTexCoords), -1 otherwise.
      */
     int texCoords;

     /**
      * Name of the transform uniform.
      */
     int transform;

     /**
      * Name of the projection uniform.
      */
     int projection;

 protected:
     /**
      * Adds an attribute with the specified name.
      *
      * @return The OpenGL name of the attribute.
      */
     int addAttrib(const char* name);

     /**
      * Binds the specified attribute name to the specified slot.
      */
     int bindAttrib(const char* name, ShaderBindings bindingSlot);

     /**
      * Adds a uniform with the specified name.
      *
      * @return The OpenGL name of the uniform.
      */
     int addUniform(const char* name);

 private:
     /**
      * Compiles the specified shader of the specified type.
      *
      * @return The name of the compiled shader.
      */
     GLuint buildShader(const char* source, GLenum type);

     // Name of the OpenGL program and shaders
     GLuint mProgramId;
     GLuint mVertexShader;
     GLuint mFragmentShader;

     // Keeps track of attributes and uniforms slots
     KeyedVector<const char*, int> mAttributes;
     KeyedVector<const char*, int> mUniforms;

     bool mUse;
     bool mInitialized;

     // Uniforms caching
     bool mHasColorUniform;
     int mColorUniform;

     bool mHasSampler;

     mat4 mProjection;
     bool mOffset;
 };  // class Program

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

 #endif  // ANDROID_HWUI_PROGRAM_H
	/*
	* 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.
	*/

	#ifndef ANDROID_HWUI_PROGRAM_H
	#define ANDROID_HWUI_PROGRAM_H

	#include <utils/KeyedVector.h>

	#include <GLES2/gl2.h>
	#include <GLES2/gl2ext.h>

	#include <SkBlendMode.h>

	#include "Debug.h"
	#include "FloatColor.h"
	#include "Matrix.h"
	#include "Properties.h"
	#include "utils/Color.h"

	namespace android {
	namespace uirenderer {

	///////////////////////////////////////////////////////////////////////////////
	// Defines
	///////////////////////////////////////////////////////////////////////////////

	// Debug
	#if DEBUG_PROGRAMS
	#define PROGRAM_LOGD(...) ALOGD(__VA_ARGS__)
	#else
	#define PROGRAM_LOGD(...)
	#endif

	#define COLOR_COMPONENT_THRESHOLD 1.0f
	#define COLOR_COMPONENT_INV_THRESHOLD 0.0f

	#define PROGRAM_KEY_TEXTURE 0x01
	#define PROGRAM_KEY_A8_TEXTURE 0x02
	#define PROGRAM_KEY_BITMAP 0x04
	#define PROGRAM_KEY_GRADIENT 0x08
	#define PROGRAM_KEY_BITMAP_FIRST 0x10
	#define PROGRAM_KEY_COLOR_MATRIX 0x20
	#define PROGRAM_KEY_COLOR_BLEND 0x40
	#define PROGRAM_KEY_BITMAP_NPOT 0x80
	#define PROGRAM_KEY_BITMAP_EXTERNAL 0x100

	#define PROGRAM_KEY_BITMAP_WRAPS_MASK 0x600
	#define PROGRAM_KEY_BITMAP_WRAPT_MASK 0x1800

	#define PROGRAM_KEY_SWAP_SRC_DST_SHIFT 13

	// Encode the xfermodes on 6 bits
	#define PROGRAM_MAX_XFERMODE 0x1f
	#define PROGRAM_XFERMODE_SHADER_SHIFT 26
	#define PROGRAM_XFERMODE_COLOR_OP_SHIFT 20
	#define PROGRAM_XFERMODE_FRAMEBUFFER_SHIFT 14

	#define PROGRAM_BITMAP_WRAPS_SHIFT 9
	#define PROGRAM_BITMAP_WRAPT_SHIFT 11

	#define PROGRAM_GRADIENT_TYPE_SHIFT 33 // 2 bits for gradient type
	#define PROGRAM_MODULATE_SHIFT 35

	#define PROGRAM_HAS_VERTEX_ALPHA_SHIFT 36
	#define PROGRAM_USE_SHADOW_ALPHA_INTERP_SHIFT 37

	#define PROGRAM_HAS_EXTERNAL_TEXTURE_SHIFT 38
	#define PROGRAM_HAS_TEXTURE_TRANSFORM_SHIFT 39

	#define PROGRAM_IS_SIMPLE_GRADIENT 40

	#define PROGRAM_HAS_COLORS 41

	#define PROGRAM_HAS_DEBUG_HIGHLIGHT 42
	#define PROGRAM_HAS_ROUND_RECT_CLIP 43

	#define PROGRAM_HAS_GAMMA_CORRECTION 44
	#define PROGRAM_HAS_LINEAR_TEXTURE 45

	#define PROGRAM_HAS_COLOR_SPACE_CONVERSION 46
	#define PROGRAM_TRANSFER_FUNCTION 47 // 2 bits for transfer function
	#define PROGRAM_HAS_TRANSLUCENT_CONVERSION 49

	///////////////////////////////////////////////////////////////////////////////
	// Types
	///////////////////////////////////////////////////////////////////////////////

	typedef uint64_t programid;

	///////////////////////////////////////////////////////////////////////////////
	// Program description
	///////////////////////////////////////////////////////////////////////////////

	/**
	* Describe the features required for a given program. The features
	* determine the generation of both the vertex and fragment shaders.
	* A ProgramDescription must be used in conjunction with a ProgramCache.
	*/
	struct ProgramDescription {
	enum class ColorFilterMode : int8_t { None = 0, Matrix, Blend };

	enum Gradient : int8_t { kGradientLinear = 0, kGradientCircular, kGradientSweep };

	ProgramDescription() { reset(); }

	// Texturing
	bool hasTexture;
	bool hasAlpha8Texture;
	bool hasExternalTexture;
	bool hasTextureTransform;

	// Color attribute
	bool hasColors;

	// Modulate, this should only be set when setColor() return true
	bool modulate;

	// Shaders
	bool hasBitmap;
	bool isShaderBitmapExternal;
	bool useShaderBasedWrap;

	bool hasVertexAlpha;
	bool useShadowAlphaInterp;

	bool hasGradient;
	Gradient gradientType;
	bool isSimpleGradient;

	SkBlendMode shadersMode;

	bool isBitmapFirst;
	GLenum bitmapWrapS;
	GLenum bitmapWrapT;

	// Color operations
	ColorFilterMode colorOp;
	SkBlendMode colorMode;

	// Framebuffer blending (requires Extensions.hasFramebufferFetch())
	// Ignored for all values < SkBlendMode::kPlus
	SkBlendMode framebufferMode;
	bool swapSrcDst;

	bool hasDebugHighlight;
	bool hasRoundRectClip;

	// Extra gamma correction used for text
	bool hasGammaCorrection;
	// Set when sampling an image in linear space
	bool hasLinearTexture;

	bool hasColorSpaceConversion;
	TransferFunctionType transferFunction;
	// Indicates whether the bitmap to convert between color spaces is translucent
	bool hasTranslucentConversion;

	/**
	* Resets this description. All fields are reset back to the default
	* values they hold after building a new instance.
	*/
	void reset() {
	hasTexture = false;
	hasAlpha8Texture = false;
	hasExternalTexture = false;
	hasTextureTransform = false;

	hasColors = false;

	hasVertexAlpha = false;
	useShadowAlphaInterp = false;

	modulate = false;

	hasBitmap = false;
	isShaderBitmapExternal = false;
	useShaderBasedWrap = false;

	hasGradient = false;
	gradientType = kGradientLinear;
	isSimpleGradient = false;

	shadersMode = SkBlendMode::kClear;

	isBitmapFirst = false;
	bitmapWrapS = GL_CLAMP_TO_EDGE;
	bitmapWrapT = GL_CLAMP_TO_EDGE;

	colorOp = ColorFilterMode::None;
	colorMode = SkBlendMode::kClear;

	framebufferMode = SkBlendMode::kClear;
	swapSrcDst = false;

	hasDebugHighlight = false;
	hasRoundRectClip = false;

	hasGammaCorrection = false;
	hasLinearTexture = false;

	hasColorSpaceConversion = false;
	transferFunction = TransferFunctionType::None;
	hasTranslucentConversion = false;
	}

	/**
	* Indicates, for a given color, whether color modulation is required in
	* the fragment shader. When this method returns true, the program should
	* be provided with a modulation color.
	*/
	bool setColorModulate(const float a) {
	modulate = a < COLOR_COMPONENT_THRESHOLD;
	return modulate;
	}

	/**
	* Indicates, for a given color, whether color modulation is required in
	* the fragment shader. When this method returns true, the program should
	* be provided with a modulation color.
	*/
	bool setAlpha8ColorModulate(const float r, const float g, const float b, const float a) {
	modulate = a < COLOR_COMPONENT_THRESHOLD \|\| r > COLOR_COMPONENT_INV_THRESHOLD \|\|
	g > COLOR_COMPONENT_INV_THRESHOLD \|\| b > COLOR_COMPONENT_INV_THRESHOLD;
	return modulate;
	}

	/**
	* Computes the unique key identifying this program.
	*/
	programid key() const {
	programid key = 0;
	if (hasTexture) key \|= PROGRAM_KEY_TEXTURE;
	if (hasAlpha8Texture) key \|= PROGRAM_KEY_A8_TEXTURE;
	if (hasBitmap) {
	key \|= PROGRAM_KEY_BITMAP;
	if (useShaderBasedWrap) {
	key \|= PROGRAM_KEY_BITMAP_NPOT;
	key \|= getEnumForWrap(bitmapWrapS) << PROGRAM_BITMAP_WRAPS_SHIFT;
	key \|= getEnumForWrap(bitmapWrapT) << PROGRAM_BITMAP_WRAPT_SHIFT;
	}
	if (isShaderBitmapExternal) {
	key \|= PROGRAM_KEY_BITMAP_EXTERNAL;
	}
	}
	if (hasGradient) key \|= PROGRAM_KEY_GRADIENT;
	key \|= programid(gradientType) << PROGRAM_GRADIENT_TYPE_SHIFT;
	if (isBitmapFirst) key \|= PROGRAM_KEY_BITMAP_FIRST;
	if (hasBitmap && hasGradient) {
	key \|= ((int)shadersMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_SHADER_SHIFT;
	}
	switch (colorOp) {
	case ColorFilterMode::Matrix:
	key \|= PROGRAM_KEY_COLOR_MATRIX;
	break;
	case ColorFilterMode::Blend:
	key \|= PROGRAM_KEY_COLOR_BLEND;
	key \|= ((int)colorMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_COLOR_OP_SHIFT;
	break;
	case ColorFilterMode::None:
	break;
	}
	key \|= ((int)framebufferMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_FRAMEBUFFER_SHIFT;
	key \|= programid(swapSrcDst) << PROGRAM_KEY_SWAP_SRC_DST_SHIFT;
	key \|= programid(modulate) << PROGRAM_MODULATE_SHIFT;
	key \|= programid(hasVertexAlpha) << PROGRAM_HAS_VERTEX_ALPHA_SHIFT;
	key \|= programid(useShadowAlphaInterp) << PROGRAM_USE_SHADOW_ALPHA_INTERP_SHIFT;
	key \|= programid(hasExternalTexture) << PROGRAM_HAS_EXTERNAL_TEXTURE_SHIFT;
	key \|= programid(hasTextureTransform) << PROGRAM_HAS_TEXTURE_TRANSFORM_SHIFT;
	key \|= programid(isSimpleGradient) << PROGRAM_IS_SIMPLE_GRADIENT;
	key \|= programid(hasColors) << PROGRAM_HAS_COLORS;
	key \|= programid(hasDebugHighlight) << PROGRAM_HAS_DEBUG_HIGHLIGHT;
	key \|= programid(hasRoundRectClip) << PROGRAM_HAS_ROUND_RECT_CLIP;
	key \|= programid(hasGammaCorrection) << PROGRAM_HAS_GAMMA_CORRECTION;
	key \|= programid(hasLinearTexture) << PROGRAM_HAS_LINEAR_TEXTURE;
	key \|= programid(hasColorSpaceConversion) << PROGRAM_HAS_COLOR_SPACE_CONVERSION;
	key \|= programid(transferFunction) << PROGRAM_TRANSFER_FUNCTION;
	key \|= programid(hasTranslucentConversion) << PROGRAM_HAS_TRANSLUCENT_CONVERSION;
	return key;
	}

	/**
	* Logs the specified message followed by the key identifying this program.
	*/
	void log(const char* message) const {
	#if DEBUG_PROGRAMS
	programid k = key();
	PROGRAM_LOGD("%s (key = 0x%.8x%.8x)", message, uint32_t(k >> 32), uint32_t(k & 0xffffffff));
	#endif
	}

	private:
	static inline uint32_t getEnumForWrap(GLenum wrap) {
	switch (wrap) {
	case GL_CLAMP_TO_EDGE:
	return 0;
	case GL_REPEAT:
	return 1;
	case GL_MIRRORED_REPEAT:
	return 2;
	}
	return 0;
	}

	}; // struct ProgramDescription

	/**
	* A program holds a vertex and a fragment shader. It offers several utility
	* methods to query attributes and uniforms.
	*/
	class Program {
	public:
	enum ShaderBindings { kBindingPosition, kBindingTexCoords };

	/**
	* Creates a new program with the specified vertex and fragment
	* shaders sources.
	*/
	Program(const ProgramDescription& description, const char* vertex, const char* fragment);
	virtual ~Program();

	/**
	* Binds this program to the GL context.
	*/
	virtual void use();

	/**
	* Marks this program as unused. This will not unbind
	* the program from the GL context.
	*/
	virtual void remove();

	/**
	* Returns the OpenGL name of the specified attribute.
	*/
	int getAttrib(const char* name);

	/**
	* Returns the OpenGL name of the specified uniform.
	*/
	int getUniform(const char* name);

	/**
	* Indicates whether this program is currently in use with
	* the GL context.
	*/
	inline bool isInUse() const { return mUse; }

	/**
	* Indicates whether this program was correctly compiled and linked.
	*/
	inline bool isInitialized() const { return mInitialized; }

	/**
	* Binds the program with the specified projection, modelView and
	* transform matrices.
	*/
	void set(const mat4& projectionMatrix, const mat4& modelViewMatrix, const mat4& transformMatrix,
	bool offset = false);

	/**
	* Sets the color associated with this shader.
	*/
	void setColor(FloatColor color);

	/**
	* Name of the texCoords attribute if it exists (kBindingTexCoords), -1 otherwise.
	*/
	int texCoords;

	/**
	* Name of the transform uniform.
	*/
	int transform;

	/**
	* Name of the projection uniform.
	*/
	int projection;

	protected:
	/**
	* Adds an attribute with the specified name.
	*
	* @return The OpenGL name of the attribute.
	*/
	int addAttrib(const char* name);

	/**
	* Binds the specified attribute name to the specified slot.
	*/
	int bindAttrib(const char* name, ShaderBindings bindingSlot);

	/**
	* Adds a uniform with the specified name.
	*
	* @return The OpenGL name of the uniform.
	*/
	int addUniform(const char* name);

	private:
	/**
	* Compiles the specified shader of the specified type.
	*
	* @return The name of the compiled shader.
	*/
	GLuint buildShader(const char* source, GLenum type);

	// Name of the OpenGL program and shaders
	GLuint mProgramId;
	GLuint mVertexShader;
	GLuint mFragmentShader;

	// Keeps track of attributes and uniforms slots
	KeyedVector<const char*, int> mAttributes;
	KeyedVector<const char*, int> mUniforms;

	bool mUse;
	bool mInitialized;

	// Uniforms caching
	bool mHasColorUniform;
	int mColorUniform;

	bool mHasSampler;

	mat4 mProjection;
	bool mOffset;
	}; // class Program

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

	#endif // ANDROID_HWUI_PROGRAM_H