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 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 */ 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 */ 50 public InternalBuilder(RenderScript rs) { 51 super(rs); 52 } 53 54 /** 55 * @deprecated in API 16 56 */ 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 */ 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 */ 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 */ 131 public Builder setTextureMatrixEnable(boolean enable) { 132 mTextureMatrixEnable = enable; 133 return this; 134 } 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 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 */ 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; 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 **/ 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 */ 238 public void destroy() { 239 mAlloc.destroy(); 240 mAlloc = null; 241 } 242 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 */ 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 */ 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 */ 285 public void setTexture(Matrix4f m) { 286 mTexture.load(m); 287 addToBuffer(TEXTURE_OFFSET*4, m); 288 } 289 } 290 } 291
