Home | History | Annotate | Download | only in hwui 
      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 #ifndef ANDROID_HWUI_PROGRAM_H
     18 #define ANDROID_HWUI_PROGRAM_H
     19 
     20 #include <utils/KeyedVector.h>
     21 
     22 #include <GLES2/gl2.h>
     23 #include <GLES2/gl2ext.h>
     24 
     25 #include <SkXfermode.h>
     26 
     27 #include "Debug.h"
     28 #include "Matrix.h"
     29 #include "Properties.h"
     30 
     31 namespace android {
     32 namespace uirenderer {
     33 
     34 ///////////////////////////////////////////////////////////////////////////////
     35 // Defines
     36 ///////////////////////////////////////////////////////////////////////////////
     37 
     38 // Debug
     39 #if DEBUG_PROGRAMS
     40     #define PROGRAM_LOGD(...) ALOGD(__VA_ARGS__)
     41 #else
     42     #define PROGRAM_LOGD(...)
     43 #endif
     44 
     45 #define COLOR_COMPONENT_THRESHOLD 1.0f
     46 #define COLOR_COMPONENT_INV_THRESHOLD 0.0f
     47 
     48 #define PROGRAM_KEY_TEXTURE 0x1
     49 #define PROGRAM_KEY_A8_TEXTURE 0x2
     50 #define PROGRAM_KEY_BITMAP 0x4
     51 #define PROGRAM_KEY_GRADIENT 0x8
     52 #define PROGRAM_KEY_BITMAP_FIRST 0x10
     53 #define PROGRAM_KEY_COLOR_MATRIX 0x20
     54 #define PROGRAM_KEY_COLOR_LIGHTING 0x40
     55 #define PROGRAM_KEY_COLOR_BLEND 0x80
     56 #define PROGRAM_KEY_BITMAP_NPOT 0x100
     57 #define PROGRAM_KEY_SWAP_SRC_DST 0x2000
     58 
     59 #define PROGRAM_KEY_BITMAP_WRAPS_MASK 0x600
     60 #define PROGRAM_KEY_BITMAP_WRAPT_MASK 0x1800
     61 
     62 // Encode the xfermodes on 6 bits
     63 #define PROGRAM_MAX_XFERMODE 0x1f
     64 #define PROGRAM_XFERMODE_SHADER_SHIFT 26
     65 #define PROGRAM_XFERMODE_COLOR_OP_SHIFT 20
     66 #define PROGRAM_XFERMODE_FRAMEBUFFER_SHIFT 14
     67 
     68 #define PROGRAM_BITMAP_WRAPS_SHIFT 9
     69 #define PROGRAM_BITMAP_WRAPT_SHIFT 11
     70 
     71 #define PROGRAM_GRADIENT_TYPE_SHIFT 33 // 2 bits for gradient type
     72 #define PROGRAM_MODULATE_SHIFT 35
     73 
     74 #define PROGRAM_HAS_AA_SHIFT 36
     75 
     76 #define PROGRAM_HAS_EXTERNAL_TEXTURE_SHIFT 37
     77 #define PROGRAM_HAS_TEXTURE_TRANSFORM_SHIFT 38
     78 
     79 #define PROGRAM_HAS_GAMMA_CORRECTION 39
     80 
     81 #define PROGRAM_IS_SIMPLE_GRADIENT 40
     82 
     83 #define PROGRAM_HAS_COLORS 41
     84 
     85 #define PROGRAM_HAS_DEBUG_HIGHLIGHT 42
     86 #define PROGRAM_EMULATE_STENCIL 43
     87 
     88 ///////////////////////////////////////////////////////////////////////////////
     89 // Types
     90 ///////////////////////////////////////////////////////////////////////////////
     91 
     92 typedef uint64_t programid;
     93 
     94 ///////////////////////////////////////////////////////////////////////////////
     95 // Program description
     96 ///////////////////////////////////////////////////////////////////////////////
     97 
     98 /**
     99  * Describe the features required for a given program. The features
    100  * determine the generation of both the vertex and fragment shaders.
    101  * A ProgramDescription must be used in conjunction with a ProgramCache.
    102  */
    103 struct ProgramDescription {
    104     enum ColorModifier {
    105         kColorNone = 0,
    106         kColorMatrix,
    107         kColorLighting,
    108         kColorBlend
    109     };
    110 
    111     enum Gradient {
    112         kGradientLinear = 0,
    113         kGradientCircular,
    114         kGradientSweep
    115     };
    116 
    117     ProgramDescription() {
    118         reset();
    119     }
    120 
    121     // Texturing
    122     bool hasTexture;
    123     bool hasAlpha8Texture;
    124     bool hasExternalTexture;
    125     bool hasTextureTransform;
    126 
    127     // Color attribute
    128     bool hasColors;
    129 
    130     // Modulate, this should only be set when setColor() return true
    131     bool modulate;
    132 
    133     // Shaders
    134     bool hasBitmap;
    135     bool isBitmapNpot;
    136 
    137     bool isAA; // drawing with a per-vertex alpha
    138 
    139     bool hasGradient;
    140     Gradient gradientType;
    141     bool isSimpleGradient;
    142 
    143     SkXfermode::Mode shadersMode;
    144 
    145     bool isBitmapFirst;
    146     GLenum bitmapWrapS;
    147     GLenum bitmapWrapT;
    148 
    149     // Color operations
    150     ColorModifier colorOp;
    151     SkXfermode::Mode colorMode;
    152 
    153     // Framebuffer blending (requires Extensions.hasFramebufferFetch())
    154     // Ignored for all values < SkXfermode::kPlus_Mode
    155     SkXfermode::Mode framebufferMode;
    156     bool swapSrcDst;
    157 
    158     bool hasGammaCorrection;
    159     float gamma;
    160 
    161     bool hasDebugHighlight;
    162     bool emulateStencil;
    163 
    164     /**
    165      * Resets this description. All fields are reset back to the default
    166      * values they hold after building a new instance.
    167      */
    168     void reset() {
    169         hasTexture = false;
    170         hasAlpha8Texture = false;
    171         hasExternalTexture = false;
    172         hasTextureTransform = false;
    173 
    174         hasColors = false;
    175 
    176         isAA = false;
    177 
    178         modulate = false;
    179 
    180         hasBitmap = false;
    181         isBitmapNpot = false;
    182 
    183         hasGradient = false;
    184         gradientType = kGradientLinear;
    185         isSimpleGradient = false;
    186 
    187         shadersMode = SkXfermode::kClear_Mode;
    188 
    189         isBitmapFirst = false;
    190         bitmapWrapS = GL_CLAMP_TO_EDGE;
    191         bitmapWrapT = GL_CLAMP_TO_EDGE;
    192 
    193         colorOp = kColorNone;
    194         colorMode = SkXfermode::kClear_Mode;
    195 
    196         framebufferMode = SkXfermode::kClear_Mode;
    197         swapSrcDst = false;
    198 
    199         hasGammaCorrection = false;
    200         gamma = 2.2f;
    201 
    202         hasDebugHighlight = false;
    203     }
    204 
    205     /**
    206      * Indicates, for a given color, whether color modulation is required in
    207      * the fragment shader. When this method returns true, the program should
    208      * be provided with a modulation color.
    209      */
    210     bool setColor(const float r, const float g, const float b, const float a) {
    211         modulate = a < COLOR_COMPONENT_THRESHOLD;
    212         return modulate;
    213     }
    214 
    215     /**
    216      * Indicates, for a given color, whether color modulation is required in
    217      * the fragment shader. When this method returns true, the program should
    218      * be provided with a modulation color.
    219      */
    220     bool setAlpha8Color(const float r, const float g, const float b, const float a) {
    221         modulate = a < COLOR_COMPONENT_THRESHOLD || r > COLOR_COMPONENT_INV_THRESHOLD ||
    222                 g > COLOR_COMPONENT_INV_THRESHOLD || b > COLOR_COMPONENT_INV_THRESHOLD;
    223         return modulate;
    224     }
    225 
    226     /**
    227      * Computes the unique key identifying this program.
    228      */
    229     programid key() const {
    230         programid key = 0;
    231         if (hasTexture) key |= PROGRAM_KEY_TEXTURE;
    232         if (hasAlpha8Texture) key |= PROGRAM_KEY_A8_TEXTURE;
    233         if (hasBitmap) {
    234             key |= PROGRAM_KEY_BITMAP;
    235             if (isBitmapNpot) {
    236                 key |= PROGRAM_KEY_BITMAP_NPOT;
    237                 key |= getEnumForWrap(bitmapWrapS) << PROGRAM_BITMAP_WRAPS_SHIFT;
    238                 key |= getEnumForWrap(bitmapWrapT) << PROGRAM_BITMAP_WRAPT_SHIFT;
    239             }
    240         }
    241         if (hasGradient) key |= PROGRAM_KEY_GRADIENT;
    242         key |= programid(gradientType) << PROGRAM_GRADIENT_TYPE_SHIFT;
    243         if (isBitmapFirst) key |= PROGRAM_KEY_BITMAP_FIRST;
    244         if (hasBitmap && hasGradient) {
    245             key |= (shadersMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_SHADER_SHIFT;
    246         }
    247         switch (colorOp) {
    248             case kColorMatrix:
    249                 key |= PROGRAM_KEY_COLOR_MATRIX;
    250                 break;
    251             case kColorLighting:
    252                 key |= PROGRAM_KEY_COLOR_LIGHTING;
    253                 break;
    254             case kColorBlend:
    255                 key |= PROGRAM_KEY_COLOR_BLEND;
    256                 key |= (colorMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_COLOR_OP_SHIFT;
    257                 break;
    258             case kColorNone:
    259                 break;
    260         }
    261         key |= (framebufferMode & PROGRAM_MAX_XFERMODE) << PROGRAM_XFERMODE_FRAMEBUFFER_SHIFT;
    262         if (swapSrcDst) key |= PROGRAM_KEY_SWAP_SRC_DST;
    263         if (modulate) key |= programid(0x1) << PROGRAM_MODULATE_SHIFT;
    264         if (isAA) key |= programid(0x1) << PROGRAM_HAS_AA_SHIFT;
    265         if (hasExternalTexture) key |= programid(0x1) << PROGRAM_HAS_EXTERNAL_TEXTURE_SHIFT;
    266         if (hasTextureTransform) key |= programid(0x1) << PROGRAM_HAS_TEXTURE_TRANSFORM_SHIFT;
    267         if (hasGammaCorrection) key |= programid(0x1) << PROGRAM_HAS_GAMMA_CORRECTION;
    268         if (isSimpleGradient) key |= programid(0x1) << PROGRAM_IS_SIMPLE_GRADIENT;
    269         if (hasColors) key |= programid(0x1) << PROGRAM_HAS_COLORS;
    270         if (hasDebugHighlight) key |= programid(0x1) << PROGRAM_HAS_DEBUG_HIGHLIGHT;
    271         if (emulateStencil) key |= programid(0x1) << PROGRAM_EMULATE_STENCIL;
    272         return key;
    273     }
    274 
    275     /**
    276      * Logs the specified message followed by the key identifying this program.
    277      */
    278     void log(const char* message) const {
    279 #if DEBUG_PROGRAMS
    280         programid k = key();
    281         PROGRAM_LOGD("%s (key = 0x%.8x%.8x)", message, uint32_t(k >> 32),
    282                 uint32_t(k & 0xffffffff));
    283 #endif
    284     }
    285 
    286 private:
    287     static inline uint32_t getEnumForWrap(GLenum wrap) {
    288         switch (wrap) {
    289             case GL_CLAMP_TO_EDGE:
    290                 return 0;
    291             case GL_REPEAT:
    292                 return 1;
    293             case GL_MIRRORED_REPEAT:
    294                 return 2;
    295         }
    296         return 0;
    297     }
    298 
    299 }; // struct ProgramDescription
    300 
    301 /**
    302  * A program holds a vertex and a fragment shader. It offers several utility
    303  * methods to query attributes and uniforms.
    304  */
    305 class Program {
    306 public:
    307     enum ShaderBindings {
    308         kBindingPosition,
    309         kBindingTexCoords
    310     };
    311 
    312     /**
    313      * Creates a new program with the specified vertex and fragment
    314      * shaders sources.
    315      */
    316     Program(const ProgramDescription& description, const char* vertex, const char* fragment);
    317     virtual ~Program();
    318 
    319     /**
    320      * Binds this program to the GL context.
    321      */
    322     virtual void use();
    323 
    324     /**
    325      * Marks this program as unused. This will not unbind
    326      * the program from the GL context.
    327      */
    328     virtual void remove();
    329 
    330     /**
    331      * Returns the OpenGL name of the specified attribute.
    332      */
    333     int getAttrib(const char* name);
    334 
    335     /**
    336      * Returns the OpenGL name of the specified uniform.
    337      */
    338     int getUniform(const char* name);
    339 
    340     /**
    341      * Indicates whether this program is currently in use with
    342      * the GL context.
    343      */
    344     inline bool isInUse() const {
    345         return mUse;
    346     }
    347 
    348     /**
    349      * Indicates whether this program was correctly compiled and linked.
    350      */
    351     inline bool isInitialized() const {
    352         return mInitialized;
    353     }
    354 
    355     /**
    356      * Binds the program with the specified projection, modelView and
    357      * transform matrices.
    358      */
    359     void set(const mat4& projectionMatrix, const mat4& modelViewMatrix,
    360              const mat4& transformMatrix, bool offset = false);
    361 
    362     /**
    363      * Sets the color associated with this shader.
    364      */
    365     void setColor(const float r, const float g, const float b, const float a);
    366 
    367     /**
    368      * Name of the position attribute.
    369      */
    370     int position;
    371 
    372     /**
    373      * Name of the texCoords attribute if it exists, -1 otherwise.
    374      */
    375     int texCoords;
    376 
    377     /**
    378      * Name of the transform uniform.
    379      */
    380     int transform;
    381 
    382     /**
    383      * Name of the projection uniform.
    384      */
    385     int projection;
    386 
    387 protected:
    388     /**
    389      * Adds an attribute with the specified name.
    390      *
    391      * @return The OpenGL name of the attribute.
    392      */
    393     int addAttrib(const char* name);
    394 
    395     /**
    396      * Binds the specified attribute name to the specified slot.
    397      */
    398     int bindAttrib(const char* name, ShaderBindings bindingSlot);
    399 
    400     /**
    401      * Adds a uniform with the specified name.
    402      *
    403      * @return The OpenGL name of the uniform.
    404      */
    405     int addUniform(const char* name);
    406 
    407 private:
    408     /**
    409      * Compiles the specified shader of the specified type.
    410      *
    411      * @return The name of the compiled shader.
    412      */
    413     GLuint buildShader(const char* source, GLenum type);
    414 
    415     // Name of the OpenGL program and shaders
    416     GLuint mProgramId;
    417     GLuint mVertexShader;
    418     GLuint mFragmentShader;
    419 
    420     // Keeps track of attributes and uniforms slots
    421     KeyedVector<const char*, int> mAttributes;
    422     KeyedVector<const char*, int> mUniforms;
    423 
    424     bool mUse;
    425     bool mInitialized;
    426 
    427     // Uniforms caching
    428     bool mHasColorUniform;
    429     int mColorUniform;
    430 
    431     bool mHasSampler;
    432 
    433     mat4 mProjection;
    434 }; // class Program
    435 
    436 }; // namespace uirenderer
    437 }; // namespace android
    438 
    439 #endif // ANDROID_HWUI_PROGRAM_H
    440