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