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