f0c90b1f36
For packages: android.renderscript This is an automatically generated CL. See go/UnsupportedAppUsage for more details. Exempted-From-Owner-Approval: Mechanical changes to the codebase which have been approved by Android API council and announced on android-eng@ Bug: 110868826 Test: m Change-Id: I1aa8ebca448547031b426a7b305c5c3d6fcf2652
344 lines
11 KiB
Java
344 lines
11 KiB
Java
/*
|
|
* Copyright (C) 2008-2012 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.renderscript;
|
|
|
|
import android.annotation.UnsupportedAppUsage;
|
|
|
|
|
|
/**
|
|
* @hide
|
|
* @deprecated in API 16
|
|
* <p>ProgramFragmentFixedFunction is a helper class that provides
|
|
* a way to make a simple fragment shader without writing any
|
|
* GLSL code. This class allows for display of constant color, interpolated
|
|
* color from the vertex shader, or combinations of the both
|
|
* blended with results of up to two texture lookups.</p
|
|
*
|
|
**/
|
|
public class ProgramFragmentFixedFunction extends ProgramFragment {
|
|
ProgramFragmentFixedFunction(long id, RenderScript rs) {
|
|
super(id, rs);
|
|
}
|
|
|
|
static class InternalBuilder extends BaseProgramBuilder {
|
|
/**
|
|
* @deprecated in API 16
|
|
*/
|
|
public InternalBuilder(RenderScript rs) {
|
|
super(rs);
|
|
}
|
|
|
|
/**
|
|
* @deprecated in API 16
|
|
* Creates ProgramFragmentFixedFunction from the current state
|
|
* of the builder
|
|
*
|
|
* @return ProgramFragmentFixedFunction
|
|
*/
|
|
public ProgramFragmentFixedFunction create() {
|
|
mRS.validate();
|
|
long[] tmp = new long[(mInputCount + mOutputCount + mConstantCount + mTextureCount) * 2];
|
|
String[] texNames = new String[mTextureCount];
|
|
int idx = 0;
|
|
|
|
for (int i=0; i < mInputCount; i++) {
|
|
tmp[idx++] = ProgramParam.INPUT.mID;
|
|
tmp[idx++] = mInputs[i].getID(mRS);
|
|
}
|
|
for (int i=0; i < mOutputCount; i++) {
|
|
tmp[idx++] = ProgramParam.OUTPUT.mID;
|
|
tmp[idx++] = mOutputs[i].getID(mRS);
|
|
}
|
|
for (int i=0; i < mConstantCount; i++) {
|
|
tmp[idx++] = ProgramParam.CONSTANT.mID;
|
|
tmp[idx++] = mConstants[i].getID(mRS);
|
|
}
|
|
for (int i=0; i < mTextureCount; i++) {
|
|
tmp[idx++] = ProgramParam.TEXTURE_TYPE.mID;
|
|
tmp[idx++] = mTextureTypes[i].mID;
|
|
texNames[i] = mTextureNames[i];
|
|
}
|
|
|
|
long id = mRS.nProgramFragmentCreate(mShader, texNames, tmp);
|
|
ProgramFragmentFixedFunction pf = new ProgramFragmentFixedFunction(id, mRS);
|
|
initProgram(pf);
|
|
return pf;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @deprecated in API 16
|
|
*/
|
|
public static class Builder {
|
|
/**
|
|
* @deprecated in API 16
|
|
*/
|
|
public static final int MAX_TEXTURE = 2;
|
|
int mNumTextures;
|
|
boolean mPointSpriteEnable;
|
|
boolean mVaryingColorEnable;
|
|
String mShader;
|
|
RenderScript mRS;
|
|
|
|
/**
|
|
* @deprecated in API 16
|
|
* EnvMode describes how textures are combined with the existing
|
|
* color in the fixed function fragment shader
|
|
*
|
|
**/
|
|
public enum EnvMode {
|
|
/**
|
|
* @deprecated in API 16
|
|
**/
|
|
@UnsupportedAppUsage
|
|
REPLACE (1),
|
|
/**
|
|
* @deprecated in API 16
|
|
**/
|
|
@UnsupportedAppUsage
|
|
MODULATE (2),
|
|
/**
|
|
* @deprecated in API 16
|
|
**/
|
|
DECAL (3);
|
|
|
|
int mID;
|
|
EnvMode(int id) {
|
|
mID = id;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @deprecated in API 16
|
|
* Format describes the pixel format of textures in the fixed
|
|
* function fragment shader and how they are sampled
|
|
*
|
|
**/
|
|
public enum Format {
|
|
/**
|
|
* @deprecated in API 16
|
|
**/
|
|
@UnsupportedAppUsage
|
|
ALPHA (1),
|
|
/**
|
|
* @deprecated in API 16
|
|
**/
|
|
LUMINANCE_ALPHA (2),
|
|
/**
|
|
* @deprecated in API 16
|
|
**/
|
|
@UnsupportedAppUsage
|
|
RGB (3),
|
|
/**
|
|
* @deprecated in API 16
|
|
**/
|
|
@UnsupportedAppUsage
|
|
RGBA (4);
|
|
|
|
int mID;
|
|
Format(int id) {
|
|
mID = id;
|
|
}
|
|
}
|
|
|
|
private class Slot {
|
|
EnvMode env;
|
|
Format format;
|
|
Slot(EnvMode _env, Format _fmt) {
|
|
env = _env;
|
|
format = _fmt;
|
|
}
|
|
}
|
|
Slot[] mSlots;
|
|
|
|
private void buildShaderString() {
|
|
mShader = "//rs_shader_internal\n";
|
|
mShader += "varying lowp vec4 varColor;\n";
|
|
mShader += "varying vec2 varTex0;\n";
|
|
|
|
mShader += "void main() {\n";
|
|
if (mVaryingColorEnable) {
|
|
mShader += " lowp vec4 col = varColor;\n";
|
|
} else {
|
|
mShader += " lowp vec4 col = UNI_Color;\n";
|
|
}
|
|
|
|
if (mNumTextures != 0) {
|
|
if (mPointSpriteEnable) {
|
|
mShader += " vec2 t0 = gl_PointCoord;\n";
|
|
} else {
|
|
mShader += " vec2 t0 = varTex0.xy;\n";
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < mNumTextures; i ++) {
|
|
switch(mSlots[i].env) {
|
|
case REPLACE:
|
|
switch (mSlots[i].format) {
|
|
case ALPHA:
|
|
mShader += " col.a = texture2D(UNI_Tex0, t0).a;\n";
|
|
break;
|
|
case LUMINANCE_ALPHA:
|
|
mShader += " col.rgba = texture2D(UNI_Tex0, t0).rgba;\n";
|
|
break;
|
|
case RGB:
|
|
mShader += " col.rgb = texture2D(UNI_Tex0, t0).rgb;\n";
|
|
break;
|
|
case RGBA:
|
|
mShader += " col.rgba = texture2D(UNI_Tex0, t0).rgba;\n";
|
|
break;
|
|
}
|
|
break;
|
|
case MODULATE:
|
|
switch (mSlots[i].format) {
|
|
case ALPHA:
|
|
mShader += " col.a *= texture2D(UNI_Tex0, t0).a;\n";
|
|
break;
|
|
case LUMINANCE_ALPHA:
|
|
mShader += " col.rgba *= texture2D(UNI_Tex0, t0).rgba;\n";
|
|
break;
|
|
case RGB:
|
|
mShader += " col.rgb *= texture2D(UNI_Tex0, t0).rgb;\n";
|
|
break;
|
|
case RGBA:
|
|
mShader += " col.rgba *= texture2D(UNI_Tex0, t0).rgba;\n";
|
|
break;
|
|
}
|
|
break;
|
|
case DECAL:
|
|
mShader += " col = texture2D(UNI_Tex0, t0);\n";
|
|
break;
|
|
}
|
|
}
|
|
|
|
mShader += " gl_FragColor = col;\n";
|
|
mShader += "}\n";
|
|
}
|
|
|
|
/**
|
|
* @deprecated
|
|
* Creates a builder for fixed function fragment program
|
|
*
|
|
* @param rs Context to which the program will belong.
|
|
*/
|
|
@UnsupportedAppUsage
|
|
public Builder(RenderScript rs) {
|
|
mRS = rs;
|
|
mSlots = new Slot[MAX_TEXTURE];
|
|
mPointSpriteEnable = false;
|
|
}
|
|
|
|
/**
|
|
* @deprecated in API 16
|
|
* Adds a texture to be fetched as part of the fixed function
|
|
* fragment program
|
|
*
|
|
* @param env specifies how the texture is combined with the
|
|
* current color
|
|
* @param fmt specifies the format of the texture and how its
|
|
* components will be used to combine with the
|
|
* current color
|
|
* @param slot index of the texture to apply the operations on
|
|
*
|
|
* @return this
|
|
*/
|
|
@UnsupportedAppUsage
|
|
public Builder setTexture(EnvMode env, Format fmt, int slot)
|
|
throws IllegalArgumentException {
|
|
if((slot < 0) || (slot >= MAX_TEXTURE)) {
|
|
throw new IllegalArgumentException("MAX_TEXTURE exceeded.");
|
|
}
|
|
mSlots[slot] = new Slot(env, fmt);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @deprecated in API 16
|
|
* Specifies whether the texture coordinate passed from the
|
|
* vertex program is replaced with an openGL internal point
|
|
* sprite texture coordinate
|
|
*
|
|
**/
|
|
public Builder setPointSpriteTexCoordinateReplacement(boolean enable) {
|
|
mPointSpriteEnable = enable;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @deprecated in API 16
|
|
* Specifies whether the varying color passed from the vertex
|
|
* program or the constant color set on the fragment program is
|
|
* used in the final color calculation in the fixed function
|
|
* fragment shader
|
|
*
|
|
**/
|
|
@UnsupportedAppUsage
|
|
public Builder setVaryingColor(boolean enable) {
|
|
mVaryingColorEnable = enable;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @deprecated in API 16
|
|
* Creates the fixed function fragment program from the current
|
|
* state of the builder.
|
|
*
|
|
*/
|
|
@UnsupportedAppUsage
|
|
public ProgramFragmentFixedFunction create() {
|
|
InternalBuilder sb = new InternalBuilder(mRS);
|
|
mNumTextures = 0;
|
|
for(int i = 0; i < MAX_TEXTURE; i ++) {
|
|
if(mSlots[i] != null) {
|
|
mNumTextures ++;
|
|
}
|
|
}
|
|
buildShaderString();
|
|
sb.setShader(mShader);
|
|
|
|
Type constType = null;
|
|
if (!mVaryingColorEnable) {
|
|
Element.Builder b = new Element.Builder(mRS);
|
|
b.add(Element.F32_4(mRS), "Color");
|
|
Type.Builder typeBuilder = new Type.Builder(mRS, b.create());
|
|
typeBuilder.setX(1);
|
|
constType = typeBuilder.create();
|
|
sb.addConstant(constType);
|
|
}
|
|
for (int i = 0; i < mNumTextures; i ++) {
|
|
sb.addTexture(TextureType.TEXTURE_2D);
|
|
}
|
|
|
|
ProgramFragmentFixedFunction pf = sb.create();
|
|
pf.mTextureCount = MAX_TEXTURE;
|
|
if (!mVaryingColorEnable) {
|
|
Allocation constantData = Allocation.createTyped(mRS,constType);
|
|
FieldPacker fp = new FieldPacker(16);
|
|
Float4 f4 = new Float4(1.f, 1.f, 1.f, 1.f);
|
|
fp.addF32(f4);
|
|
constantData.setFromFieldPacker(0, fp);
|
|
pf.bindConstants(constantData, 0);
|
|
}
|
|
return pf;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|