1/*
2 * Copyright (C) 2008-2012 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
17package android.renderscript;
18
19
20/**
21 * @hide
22 * @deprecated in API 16
23 * <p>ProgramFragmentFixedFunction is a helper class that provides
24 * a way to make a simple fragment shader without writing any
25 * GLSL code. This class allows for display of constant color, interpolated
26 * color from the vertex shader, or combinations of the both
27 * blended with results of up to two texture lookups.</p
28 *
29 **/
30public class ProgramFragmentFixedFunction extends ProgramFragment {
31    ProgramFragmentFixedFunction(long id, RenderScript rs) {
32        super(id, rs);
33    }
34
35    static class InternalBuilder extends BaseProgramBuilder {
36        /**
37         * @deprecated in API 16
38         */
39        public InternalBuilder(RenderScript rs) {
40            super(rs);
41        }
42
43        /**
44         * @deprecated in API 16
45         * Creates ProgramFragmentFixedFunction from the current state
46         * of the builder
47         *
48         * @return  ProgramFragmentFixedFunction
49         */
50        public ProgramFragmentFixedFunction create() {
51            mRS.validate();
52            long[] tmp = new long[(mInputCount + mOutputCount + mConstantCount + mTextureCount) * 2];
53            String[] texNames = new String[mTextureCount];
54            int idx = 0;
55
56            for (int i=0; i < mInputCount; i++) {
57                tmp[idx++] = ProgramParam.INPUT.mID;
58                tmp[idx++] = mInputs[i].getID(mRS);
59            }
60            for (int i=0; i < mOutputCount; i++) {
61                tmp[idx++] = ProgramParam.OUTPUT.mID;
62                tmp[idx++] = mOutputs[i].getID(mRS);
63            }
64            for (int i=0; i < mConstantCount; i++) {
65                tmp[idx++] = ProgramParam.CONSTANT.mID;
66                tmp[idx++] = mConstants[i].getID(mRS);
67            }
68            for (int i=0; i < mTextureCount; i++) {
69                tmp[idx++] = ProgramParam.TEXTURE_TYPE.mID;
70                tmp[idx++] = mTextureTypes[i].mID;
71                texNames[i] = mTextureNames[i];
72            }
73
74            long id = mRS.nProgramFragmentCreate(mShader, texNames, tmp);
75            ProgramFragmentFixedFunction pf = new ProgramFragmentFixedFunction(id, mRS);
76            initProgram(pf);
77            return pf;
78        }
79    }
80
81    /**
82     * @deprecated in API 16
83     */
84    public static class Builder {
85        /**
86         * @deprecated in API 16
87         */
88        public static final int MAX_TEXTURE = 2;
89        int mNumTextures;
90        boolean mPointSpriteEnable;
91        boolean mVaryingColorEnable;
92        String mShader;
93        RenderScript mRS;
94
95        /**
96         * @deprecated in API 16
97         * EnvMode describes how textures are combined with the existing
98         * color in the fixed function fragment shader
99         *
100         **/
101        public enum EnvMode {
102            /**
103             * @deprecated in API 16
104             **/
105            REPLACE (1),
106            /**
107             * @deprecated in API 16
108             **/
109            MODULATE (2),
110            /**
111             * @deprecated in API 16
112             **/
113            DECAL (3);
114
115            int mID;
116            EnvMode(int id) {
117                mID = id;
118            }
119        }
120
121        /**
122         * @deprecated in API 16
123         * Format describes the pixel format of textures in the fixed
124         * function fragment shader and how they are sampled
125         *
126         **/
127        public enum Format {
128            /**
129             * @deprecated in API 16
130             **/
131            ALPHA (1),
132            /**
133             * @deprecated in API 16
134             **/
135            LUMINANCE_ALPHA (2),
136            /**
137             * @deprecated in API 16
138             **/
139            RGB (3),
140            /**
141             * @deprecated in API 16
142             **/
143            RGBA (4);
144
145            int mID;
146            Format(int id) {
147                mID = id;
148            }
149        }
150
151        private class Slot {
152            EnvMode env;
153            Format format;
154            Slot(EnvMode _env, Format _fmt) {
155                env = _env;
156                format = _fmt;
157            }
158        }
159        Slot[] mSlots;
160
161        private void buildShaderString() {
162            mShader  = "//rs_shader_internal\n";
163            mShader += "varying lowp vec4 varColor;\n";
164            mShader += "varying vec2 varTex0;\n";
165
166            mShader += "void main() {\n";
167            if (mVaryingColorEnable) {
168                mShader += "  lowp vec4 col = varColor;\n";
169            } else {
170                mShader += "  lowp vec4 col = UNI_Color;\n";
171            }
172
173            if (mNumTextures != 0) {
174                if (mPointSpriteEnable) {
175                    mShader += "  vec2 t0 = gl_PointCoord;\n";
176                } else {
177                    mShader += "  vec2 t0 = varTex0.xy;\n";
178                }
179            }
180
181            for(int i = 0; i < mNumTextures; i ++) {
182                switch(mSlots[i].env) {
183                case REPLACE:
184                    switch (mSlots[i].format) {
185                    case ALPHA:
186                        mShader += "  col.a = texture2D(UNI_Tex0, t0).a;\n";
187                        break;
188                    case LUMINANCE_ALPHA:
189                        mShader += "  col.rgba = texture2D(UNI_Tex0, t0).rgba;\n";
190                        break;
191                    case RGB:
192                        mShader += "  col.rgb = texture2D(UNI_Tex0, t0).rgb;\n";
193                        break;
194                    case RGBA:
195                        mShader += "  col.rgba = texture2D(UNI_Tex0, t0).rgba;\n";
196                        break;
197                    }
198                    break;
199                case MODULATE:
200                    switch (mSlots[i].format) {
201                    case ALPHA:
202                        mShader += "  col.a *= texture2D(UNI_Tex0, t0).a;\n";
203                        break;
204                    case LUMINANCE_ALPHA:
205                        mShader += "  col.rgba *= texture2D(UNI_Tex0, t0).rgba;\n";
206                        break;
207                    case RGB:
208                        mShader += "  col.rgb *= texture2D(UNI_Tex0, t0).rgb;\n";
209                        break;
210                    case RGBA:
211                        mShader += "  col.rgba *= texture2D(UNI_Tex0, t0).rgba;\n";
212                        break;
213                    }
214                    break;
215                case DECAL:
216                    mShader += "  col = texture2D(UNI_Tex0, t0);\n";
217                    break;
218                }
219            }
220
221            mShader += "  gl_FragColor = col;\n";
222            mShader += "}\n";
223        }
224
225        /**
226         * @deprecated
227         * Creates a builder for fixed function fragment program
228         *
229         * @param rs Context to which the program will belong.
230         */
231        public Builder(RenderScript rs) {
232            mRS = rs;
233            mSlots = new Slot[MAX_TEXTURE];
234            mPointSpriteEnable = false;
235        }
236
237        /**
238         * @deprecated in API 16
239         * Adds a texture to be fetched as part of the fixed function
240         * fragment program
241         *
242         * @param env specifies how the texture is combined with the
243         *            current color
244         * @param fmt specifies the format of the texture and how its
245         *            components will be used to combine with the
246         *            current color
247         * @param slot index of the texture to apply the operations on
248         *
249         * @return this
250         */
251        public Builder setTexture(EnvMode env, Format fmt, int slot)
252            throws IllegalArgumentException {
253            if((slot < 0) || (slot >= MAX_TEXTURE)) {
254                throw new IllegalArgumentException("MAX_TEXTURE exceeded.");
255            }
256            mSlots[slot] = new Slot(env, fmt);
257            return this;
258        }
259
260        /**
261         * @deprecated in API 16
262         * Specifies whether the texture coordinate passed from the
263         * vertex program is replaced with an openGL internal point
264         * sprite texture coordinate
265         *
266         **/
267        public Builder setPointSpriteTexCoordinateReplacement(boolean enable) {
268            mPointSpriteEnable = enable;
269            return this;
270        }
271
272        /**
273         * @deprecated in API 16
274         * Specifies whether the varying color passed from the vertex
275         * program or the constant color set on the fragment program is
276         * used in the final color calculation in the fixed function
277         * fragment shader
278         *
279         **/
280        public Builder setVaryingColor(boolean enable) {
281            mVaryingColorEnable = enable;
282            return this;
283        }
284
285        /**
286         * @deprecated in API 16
287        * Creates the fixed function fragment program from the current
288        * state of the builder.
289        *
290        */
291        public ProgramFragmentFixedFunction create() {
292            InternalBuilder sb = new InternalBuilder(mRS);
293            mNumTextures = 0;
294            for(int i = 0; i < MAX_TEXTURE; i ++) {
295                if(mSlots[i] != null) {
296                    mNumTextures ++;
297                }
298            }
299            buildShaderString();
300            sb.setShader(mShader);
301
302            Type constType = null;
303            if (!mVaryingColorEnable) {
304                Element.Builder b = new Element.Builder(mRS);
305                b.add(Element.F32_4(mRS), "Color");
306                Type.Builder typeBuilder = new Type.Builder(mRS, b.create());
307                typeBuilder.setX(1);
308                constType = typeBuilder.create();
309                sb.addConstant(constType);
310            }
311            for (int i = 0; i < mNumTextures; i ++) {
312                sb.addTexture(TextureType.TEXTURE_2D);
313            }
314
315            ProgramFragmentFixedFunction pf = sb.create();
316            pf.mTextureCount = MAX_TEXTURE;
317            if (!mVaryingColorEnable) {
318                Allocation constantData = Allocation.createTyped(mRS,constType);
319                FieldPacker fp = new FieldPacker(16);
320                Float4 f4 = new Float4(1.f, 1.f, 1.f, 1.f);
321                fp.addF32(f4);
322                constantData.setFromFieldPacker(0, fp);
323                pf.bindConstants(constantData, 0);
324            }
325            return pf;
326        }
327    }
328}
329
330
331
332
333