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
ggl_init_picker(context_t *)29 void ggl_init_picker(context_t* /*c*/)
30 {
31 }
32
ggl_pick(context_t * c)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