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_TEXTURE_H
     18 #define ANDROID_HWUI_TEXTURE_H
     19 
     20 #include <GLES2/gl2.h>
     21 
     22 namespace android {
     23 namespace uirenderer {
     24 
     25 /**
     26  * Represents an OpenGL texture.
     27  */
     28 struct Texture {
     29     Texture() {
     30         cleanup = false;
     31         bitmapSize = 0;
     32 
     33         wrapS = GL_CLAMP_TO_EDGE;
     34         wrapT = GL_CLAMP_TO_EDGE;
     35 
     36         minFilter = GL_NEAREST;
     37         magFilter = GL_NEAREST;
     38 
     39         mipMap = false;
     40 
     41         firstFilter = true;
     42         firstWrap = true;
     43 
     44         id = 0;
     45     }
     46 
     47     void setWrap(GLenum wrap, bool bindTexture = false, bool force = false,
     48                 GLenum renderTarget = GL_TEXTURE_2D) {
     49         setWrapST(wrap, wrap, bindTexture, force, renderTarget);
     50     }
     51 
     52     void setWrapST(GLenum wrapS, GLenum wrapT, bool bindTexture = false, bool force = false,
     53             GLenum renderTarget = GL_TEXTURE_2D) {
     54 
     55         if (firstWrap || force || wrapS != this->wrapS || wrapT != this->wrapT) {
     56             firstWrap = false;
     57 
     58             this->wrapS = wrapS;
     59             this->wrapT = wrapT;
     60 
     61             if (bindTexture) {
     62                 glBindTexture(renderTarget, id);
     63             }
     64 
     65             glTexParameteri(renderTarget, GL_TEXTURE_WRAP_S, wrapS);
     66             glTexParameteri(renderTarget, GL_TEXTURE_WRAP_T, wrapT);
     67         }
     68     }
     69 
     70     void setFilter(GLenum filter, bool bindTexture = false, bool force = false,
     71                 GLenum renderTarget = GL_TEXTURE_2D) {
     72         setFilterMinMag(filter, filter, bindTexture, force, renderTarget);
     73     }
     74 
     75     void setFilterMinMag(GLenum min, GLenum mag, bool bindTexture = false, bool force = false,
     76             GLenum renderTarget = GL_TEXTURE_2D) {
     77 
     78         if (firstFilter || force || min != minFilter || mag != magFilter) {
     79             firstFilter = false;
     80 
     81             minFilter = min;
     82             magFilter = mag;
     83 
     84             if (bindTexture) {
     85                 glBindTexture(renderTarget, id);
     86             }
     87 
     88             if (mipMap && min == GL_LINEAR) min = GL_LINEAR_MIPMAP_LINEAR;
     89 
     90             glTexParameteri(renderTarget, GL_TEXTURE_MIN_FILTER, min);
     91             glTexParameteri(renderTarget, GL_TEXTURE_MAG_FILTER, mag);
     92         }
     93     }
     94 
     95     /**
     96      * Name of the texture.
     97      */
     98     GLuint id;
     99     /**
    100      * Generation of the backing bitmap,
    101      */
    102     uint32_t generation;
    103     /**
    104      * Indicates whether the texture requires blending.
    105      */
    106     bool blend;
    107     /**
    108      * Width of the backing bitmap.
    109      */
    110     uint32_t width;
    111     /**
    112      * Height of the backing bitmap.
    113      */
    114     uint32_t height;
    115     /**
    116      * Indicates whether this texture should be cleaned up after use.
    117      */
    118     bool cleanup;
    119     /**
    120      * Optional, size of the original bitmap.
    121      */
    122     uint32_t bitmapSize;
    123     /**
    124      * Indicates whether this texture will use trilinear filtering.
    125      */
    126     bool mipMap;
    127 
    128 private:
    129     /**
    130      * Last wrap modes set on this texture. Defaults to GL_CLAMP_TO_EDGE.
    131      */
    132     GLenum wrapS;
    133     GLenum wrapT;
    134 
    135     /**
    136      * Last filters set on this texture. Defaults to GL_NEAREST.
    137      */
    138     GLenum minFilter;
    139     GLenum magFilter;
    140 
    141     bool firstFilter;
    142     bool firstWrap;
    143 }; // struct Texture
    144 
    145 class AutoTexture {
    146 public:
    147     AutoTexture(const Texture* texture): mTexture(texture) { }
    148     ~AutoTexture() {
    149         if (mTexture && mTexture->cleanup) {
    150             glDeleteTextures(1, &mTexture->id);
    151             delete mTexture;
    152         }
    153     }
    154 
    155 private:
    156     const Texture* mTexture;
    157 }; // class AutoTexture
    158 
    159 }; // namespace uirenderer
    160 }; // namespace android
    161 
    162 #endif // ANDROID_HWUI_TEXTURE_H
    163