Home | History | Annotate | Download | only in libpixelflinger
      1 /* libs/pixelflinger/picker.cpp
      2 **
      3 ** Copyright 2006, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** You may obtain a copy of the License at
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     11 ** Unless required by applicable law or agreed to in writing, software
     12 ** distributed under the License is distributed on an "AS IS" BASIS,
     13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14 ** See the License for the specific language governing permissions and
     15 ** limitations under the License.
     16 */
     17 
     18 
     19 #include <stdio.h>
     20 
     21 #include "buffer.h"
     22 #include "scanline.h"
     23 #include "picker.h"
     24 
     25 namespace android {
     26 
     27 // ----------------------------------------------------------------------------
     28 
     29 void ggl_init_picker(context_t* c)
     30 {
     31 }
     32 
     33 void ggl_pick(context_t* c)
     34 {
     35     if (ggl_likely(!c->dirty))
     36         return;
     37 
     38     // compute needs, see if they changed...
     39     const uint32_t enables = c->state.enables;
     40     needs_t new_needs(c->state.needs);
     41 
     42     if (c->dirty & GGL_CB_STATE) {
     43         new_needs.n &= ~GGL_NEEDS_CB_FORMAT_MASK;
     44         new_needs.n |= GGL_BUILD_NEEDS(c->state.buffers.color.format, CB_FORMAT);
     45         if (enables & GGL_ENABLE_BLENDING)
     46             c->dirty |= GGL_PIXEL_PIPELINE_STATE;
     47     }
     48 
     49     if (c->dirty & GGL_PIXEL_PIPELINE_STATE) {
     50         uint32_t n = GGL_BUILD_NEEDS(c->state.buffers.color.format, CB_FORMAT);
     51         uint32_t p = 0;
     52         if (enables & GGL_ENABLE_BLENDING) {
     53             uint32_t src = c->state.blend.src;
     54             uint32_t dst = c->state.blend.dst;
     55             uint32_t src_alpha = c->state.blend.src_alpha;
     56             uint32_t dst_alpha = c->state.blend.dst_alpha;
     57             const GGLFormat& cbf = c->formats[ c->state.buffers.color.format ];
     58             if (!cbf.c[GGLFormat::ALPHA].h) {
     59                 if ((src == GGL_ONE_MINUS_DST_ALPHA) ||
     60                     (src == GGL_DST_ALPHA)) {
     61                     src = GGL_ONE;
     62                 }
     63                 if ((src_alpha == GGL_ONE_MINUS_DST_ALPHA) ||
     64                     (src_alpha == GGL_DST_ALPHA)) {
     65                     src_alpha = GGL_ONE;
     66                 }
     67                 if ((dst == GGL_ONE_MINUS_DST_ALPHA) ||
     68                     (dst == GGL_DST_ALPHA)) {
     69                     dst = GGL_ONE;
     70                 }
     71                 if ((dst_alpha == GGL_ONE_MINUS_DST_ALPHA) ||
     72                     (dst_alpha == GGL_DST_ALPHA)) {
     73                     dst_alpha = GGL_ONE;
     74                 }
     75             }
     76 
     77             src       = ggl_blendfactor_to_needs(src);
     78             dst       = ggl_blendfactor_to_needs(dst);
     79             src_alpha = ggl_blendfactor_to_needs(src_alpha);
     80             dst_alpha = ggl_blendfactor_to_needs(dst_alpha);
     81 
     82             n |= GGL_BUILD_NEEDS( src, BLEND_SRC );
     83             n |= GGL_BUILD_NEEDS( dst, BLEND_DST );
     84             if (c->state.blend.alpha_separate) {
     85                 n |= GGL_BUILD_NEEDS( src_alpha, BLEND_SRCA );
     86                 n |= GGL_BUILD_NEEDS( dst_alpha, BLEND_DSTA );
     87             } else {
     88                 n |= GGL_BUILD_NEEDS( src, BLEND_SRCA );
     89                 n |= GGL_BUILD_NEEDS( dst, BLEND_DSTA );
     90             }
     91         } else {
     92             n |= GGL_BUILD_NEEDS( GGL_ONE,  BLEND_SRC );
     93             n |= GGL_BUILD_NEEDS( GGL_ZERO, BLEND_DST );
     94             n |= GGL_BUILD_NEEDS( GGL_ONE,  BLEND_SRCA );
     95             n |= GGL_BUILD_NEEDS( GGL_ZERO, BLEND_DSTA );
     96         }
     97 
     98 
     99         n |= GGL_BUILD_NEEDS(c->state.mask.color^0xF,               MASK_ARGB);
    100         n |= GGL_BUILD_NEEDS((enables & GGL_ENABLE_SMOOTH)  ?1:0,   SHADE);
    101         if (enables & GGL_ENABLE_TMUS) {
    102             n |= GGL_BUILD_NEEDS((enables & GGL_ENABLE_W)       ?1:0,   W);
    103         }
    104         p |= GGL_BUILD_NEEDS((enables & GGL_ENABLE_DITHER)  ?1:0,   P_DITHER);
    105         p |= GGL_BUILD_NEEDS((enables & GGL_ENABLE_AA)      ?1:0,   P_AA);
    106         p |= GGL_BUILD_NEEDS((enables & GGL_ENABLE_FOG)     ?1:0,   P_FOG);
    107 
    108         if (enables & GGL_ENABLE_LOGIC_OP) {
    109             n |= GGL_BUILD_NEEDS(c->state.logic_op.opcode, LOGIC_OP);
    110         } else {
    111             n |= GGL_BUILD_NEEDS(GGL_COPY, LOGIC_OP);
    112         }
    113 
    114         if (enables & GGL_ENABLE_ALPHA_TEST) {
    115             p |= GGL_BUILD_NEEDS(c->state.alpha_test.func, P_ALPHA_TEST);
    116         } else {
    117             p |= GGL_BUILD_NEEDS(GGL_ALWAYS, P_ALPHA_TEST);
    118         }
    119 
    120         if (enables & GGL_ENABLE_DEPTH_TEST) {
    121             p |= GGL_BUILD_NEEDS(c->state.depth_test.func, P_DEPTH_TEST);
    122             p |= GGL_BUILD_NEEDS(c->state.mask.depth&1, P_MASK_Z);
    123         } else {
    124             p |= GGL_BUILD_NEEDS(GGL_ALWAYS, P_DEPTH_TEST);
    125             // writing to the z-buffer is always disabled if depth-test
    126             // is disabled.
    127         }
    128         new_needs.n = n;
    129         new_needs.p = p;
    130     }
    131 
    132     if (c->dirty & GGL_TMU_STATE) {
    133         int idx = 0;
    134         for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; ++i) {
    135             const texture_t& tx = c->state.texture[i];
    136             if (tx.enable) {
    137                 uint32_t t = 0;
    138                 t |= GGL_BUILD_NEEDS(tx.surface.format, T_FORMAT);
    139                 t |= GGL_BUILD_NEEDS(ggl_env_to_needs(tx.env), T_ENV);
    140                 t |= GGL_BUILD_NEEDS(0, T_POT);       // XXX: not used yet
    141                 if (tx.s_coord==GGL_ONE_TO_ONE && tx.t_coord==GGL_ONE_TO_ONE) {
    142                     // we encode 1-to-1 into the wrap mode
    143                     t |= GGL_BUILD_NEEDS(GGL_NEEDS_WRAP_11, T_S_WRAP);
    144                     t |= GGL_BUILD_NEEDS(GGL_NEEDS_WRAP_11, T_T_WRAP);
    145                 } else {
    146                     t |= GGL_BUILD_NEEDS(ggl_wrap_to_needs(tx.s_wrap), T_S_WRAP);
    147                     t |= GGL_BUILD_NEEDS(ggl_wrap_to_needs(tx.t_wrap), T_T_WRAP);
    148                 }
    149                 if (tx.mag_filter == GGL_LINEAR) {
    150                     t |= GGL_BUILD_NEEDS(1, T_LINEAR);
    151                 }
    152                 if (tx.min_filter == GGL_LINEAR) {
    153                     t |= GGL_BUILD_NEEDS(1, T_LINEAR);
    154                 }
    155                 new_needs.t[idx++] = t;
    156             } else {
    157                 new_needs.t[i] = 0;
    158             }
    159         }
    160     }
    161 
    162     if (new_needs != c->state.needs) {
    163         c->state.needs = new_needs;
    164         ggl_pick_texture(c);
    165         ggl_pick_cb(c);
    166         ggl_pick_scanline(c);
    167     }
    168     c->dirty = 0;
    169 }
    170 
    171 // ----------------------------------------------------------------------------
    172 }; // namespace android
    173 
    174