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 
17 package android.renderscript;
18 
19 
20 /**
21  * @hide
22  * @deprecated in API 16
23  * ProgramVertexFixedFunction is a helper class that provides a
24  * simple way to create a fixed function emulation vertex shader
25  * without writing any GLSL code.
26  *
27  **/
28 public class ProgramVertexFixedFunction extends ProgramVertex {
29 
ProgramVertexFixedFunction(long id, RenderScript rs)30     ProgramVertexFixedFunction(long id, RenderScript rs) {
31         super(id, rs);
32     }
33 
34     /**
35      * @deprecated in API 16
36      * Binds the constant buffer containing fixed function emulation
37      * matrices
38      *
39      * @param va allocation containing fixed function matrices
40      */
bindConstants(Constants va)41     public void bindConstants(Constants va) {
42         mRS.validate();
43         bindConstants(va.getAllocation(), 0);
44     }
45 
46     static class InternalBuilder extends BaseProgramBuilder {
47         /**
48          * @deprecated in API 16
49          */
InternalBuilder(RenderScript rs)50         public InternalBuilder(RenderScript rs) {
51             super(rs);
52         }
53 
54         /**
55          * @deprecated in API 16
56          */
addInput(Element e)57         public InternalBuilder addInput(Element e) throws IllegalStateException {
58             // Should check for consistant and non-conflicting names...
59             if(mInputCount >= MAX_INPUT) {
60                 throw new RSIllegalArgumentException("Max input count exceeded.");
61             }
62             if (e.isComplex()) {
63                 throw new RSIllegalArgumentException("Complex elements not allowed.");
64             }
65             mInputs[mInputCount++] = e;
66             return this;
67         }
68 
69         /**
70          * @deprecated in API 16
71          * Creates ProgramVertexFixedFunction from the current state of
72          * the builder
73          *
74          * @return  ProgramVertexFixedFunction
75          */
create()76         public ProgramVertexFixedFunction create() {
77             mRS.validate();
78             long[] tmp = new long[(mInputCount + mOutputCount + mConstantCount + mTextureCount) * 2];
79             String[] texNames = new String[mTextureCount];
80             int idx = 0;
81 
82             for (int i=0; i < mInputCount; i++) {
83                 tmp[idx++] = ProgramParam.INPUT.mID;
84                 tmp[idx++] = mInputs[i].getID(mRS);
85             }
86             for (int i=0; i < mOutputCount; i++) {
87                 tmp[idx++] = ProgramParam.OUTPUT.mID;
88                 tmp[idx++] = mOutputs[i].getID(mRS);
89             }
90             for (int i=0; i < mConstantCount; i++) {
91                 tmp[idx++] = ProgramParam.CONSTANT.mID;
92                 tmp[idx++] = mConstants[i].getID(mRS);
93             }
94             for (int i=0; i < mTextureCount; i++) {
95                 tmp[idx++] = ProgramParam.TEXTURE_TYPE.mID;
96                 tmp[idx++] = mTextureTypes[i].mID;
97                 texNames[i] = mTextureNames[i];
98             }
99 
100             long id = mRS.nProgramVertexCreate(mShader, texNames, tmp);
101             ProgramVertexFixedFunction pv = new ProgramVertexFixedFunction(id, mRS);
102             initProgram(pv);
103             return pv;
104         }
105     }
106 
107     /**
108      * @deprecated in API 16
109      */
110     public static class Builder {
111         boolean mTextureMatrixEnable;
112         String mShader;
113         RenderScript mRS;
114 
115         /**
116          * @deprecated in API 16
117          * Creates a builder for fixed function vertex program
118          *
119          * @param rs Context to which the program will belong.
120          */
Builder(RenderScript rs)121         public Builder(RenderScript rs) {
122             mRS = rs;
123         }
124 
125         /**
126          * @deprecated in API 16
127          * Specifies whether texture matrix calculations are to be added
128          * to the shader
129          *
130          */
setTextureMatrixEnable(boolean enable)131         public Builder setTextureMatrixEnable(boolean enable) {
132             mTextureMatrixEnable = enable;
133             return this;
134         }
getConstantInputType(RenderScript rs)135         static Type getConstantInputType(RenderScript rs) {
136             Element.Builder b = new Element.Builder(rs);
137             b.add(Element.MATRIX4X4(rs), "MV");
138             b.add(Element.MATRIX4X4(rs), "P");
139             b.add(Element.MATRIX4X4(rs), "TexMatrix");
140             b.add(Element.MATRIX4X4(rs), "MVP");
141 
142             Type.Builder typeBuilder = new Type.Builder(rs, b.create());
143             typeBuilder.setX(1);
144             return typeBuilder.create();
145         }
146 
buildShaderString()147         private void buildShaderString() {
148 
149             mShader  = "//rs_shader_internal\n";
150             mShader += "varying vec4 varColor;\n";
151             mShader += "varying vec2 varTex0;\n";
152 
153             mShader += "void main() {\n";
154             mShader += "  gl_Position = UNI_MVP * ATTRIB_position;\n";
155             mShader += "  gl_PointSize = 1.0;\n";
156 
157             mShader += "  varColor = ATTRIB_color;\n";
158             if (mTextureMatrixEnable) {
159                 mShader += "  varTex0 = (UNI_TexMatrix * vec4(ATTRIB_texture0, 0.0, 1.0)).xy;\n";
160             } else {
161                 mShader += "  varTex0 = ATTRIB_texture0;\n";
162             }
163             mShader += "}\n";
164         }
165 
166         /**
167          * @deprecated in API 16
168          * Creates ProgramVertexFixedFunction from the current state of
169          * the builder
170          *
171          * @return Fixed function emulation ProgramVertex
172          */
create()173         public ProgramVertexFixedFunction create() {
174             buildShaderString();
175 
176             InternalBuilder sb = new InternalBuilder(mRS);
177             sb.setShader(mShader);
178             sb.addConstant(getConstantInputType(mRS));
179 
180             Element.Builder b = new Element.Builder(mRS);
181             b.add(Element.F32_4(mRS), "position");
182             b.add(Element.F32_4(mRS), "color");
183             b.add(Element.F32_3(mRS), "normal");
184             b.add(Element.F32_2(mRS), "texture0");
185             sb.addInput(b.create());
186 
187             return sb.create();
188         }
189     }
190 
191     /**
192      * @deprecated in API 16
193      * Helper class to store modelview, projection and texture
194      * matrices for ProgramVertexFixedFunction
195      *
196      */
197     public static class Constants {
198         static final int MODELVIEW_OFFSET = 0;
199         static final int PROJECTION_OFFSET = 16;
200         static final int TEXTURE_OFFSET = 32;
201 
202         Matrix4f mModel;
203         Matrix4f mProjection;
204         Matrix4f mTexture;
205 
206         Allocation mAlloc;
getAllocation()207         Allocation getAllocation() {
208             return mAlloc;
209         }
210         private FieldPacker mIOBuffer;
211 
212         /**
213         * @deprecated in API 16
214         * Creates a buffer to store fixed function emulation matrices
215         *
216         * @param rs Context to which the allocation will belong.
217         **/
Constants(RenderScript rs)218         public Constants(RenderScript rs) {
219             Type constInputType = ProgramVertexFixedFunction.Builder.getConstantInputType(rs);
220             mAlloc = Allocation.createTyped(rs, constInputType);
221             int bufferSize = constInputType.getElement().getBytesSize()*
222                              constInputType.getCount();
223             mIOBuffer = new FieldPacker(bufferSize);
224             mModel = new Matrix4f();
225             mProjection = new Matrix4f();
226             mTexture = new Matrix4f();
227             setModelview(new Matrix4f());
228             setProjection(new Matrix4f());
229             setTexture(new Matrix4f());
230         }
231 
232         /**
233         * @deprecated in API 16
234         * Forces deallocation of memory backing the contant matrices.
235         * Normally, this is unnecessary and will be garbage collected
236         *
237         */
destroy()238         public void destroy() {
239             mAlloc.destroy();
240             mAlloc = null;
241         }
242 
addToBuffer(int offset, Matrix4f m)243         private void addToBuffer(int offset, Matrix4f m) {
244             mIOBuffer.reset(offset);
245             for(int i = 0; i < 16; i ++) {
246                 mIOBuffer.addF32(m.mMat[i]);
247             }
248             // Reset the buffer back to the end, since we want to flush all of
249             // the contents back (and not just what we wrote now).
250             mIOBuffer.reset(mIOBuffer.getData().length);
251             mAlloc.setFromFieldPacker(0, mIOBuffer);
252         }
253 
254         /**
255         * @deprecated in API 16
256         * Sets the modelview matrix in the fixed function matrix buffer
257         *
258         * @param m modelview matrix
259         */
setModelview(Matrix4f m)260         public void setModelview(Matrix4f m) {
261             mModel.load(m);
262             addToBuffer(MODELVIEW_OFFSET*4, m);
263         }
264 
265         /**
266         * @deprecated in API 16
267         * Sets the projection matrix in the fixed function matrix buffer
268         *
269         * @param m projection matrix
270         */
setProjection(Matrix4f m)271         public void setProjection(Matrix4f m) {
272             mProjection.load(m);
273             addToBuffer(PROJECTION_OFFSET*4, m);
274         }
275 
276         /**
277         * @deprecated in API 16
278         * Sets the texture matrix in the fixed function matrix buffer.
279         * Texture matrix must be enabled in the
280         * ProgramVertexFixedFunction builder for the shader to utilize
281         * it.
282         *
283         * @param m modelview matrix
284         */
setTexture(Matrix4f m)285         public void setTexture(Matrix4f m) {
286             mTexture.load(m);
287             addToBuffer(TEXTURE_OFFSET*4, m);
288         }
289     }
290 }
291