tests/RenderScriptTests/SceneGraph/src/com/android/testapp/FullscreenBlur.java

/*
 * Copyright (C) 2011 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 com.android.testapp;

import java.util.ArrayList;

import com.android.scenegraph.*;

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.renderscript.*;
import android.renderscript.Allocation.MipmapControl;
import android.renderscript.Element.Builder;
import android.renderscript.Font.Style;
import android.renderscript.Program.TextureType;
import android.renderscript.ProgramStore.DepthFunc;
import android.util.Log;

class FullscreenBlur {

    static TextureRenderTarget sRenderTargetBlur0Color;
    static TextureRenderTarget sRenderTargetBlur0Depth;
    static TextureRenderTarget sRenderTargetBlur1Color;
    static TextureRenderTarget sRenderTargetBlur1Depth;
    static TextureRenderTarget sRenderTargetBlur2Color;
    static TextureRenderTarget sRenderTargetBlur2Depth;

    static FragmentShader mPF_BlurH;
    static FragmentShader mPF_BlurV;
    static FragmentShader mPF_SelectColor;
    static FragmentShader mPF_Texture;
    static VertexShader mPV_Paint;
    static VertexShader mPV_Blur;

    static int targetWidth;
    static int targetHeight;

    // This is only used when full screen blur is enabled
    // Basically, it's the offscreen render targets
    static void createRenderTargets(RenderScriptGL rs, int w, int h) {
        targetWidth = w/8;
        targetHeight = h/8;
        Type.Builder b = new Type.Builder(rs, Element.RGBA_8888(rs));
        Type renderType = b.setX(targetWidth).setY(targetHeight).create();
        int usage = Allocation.USAGE_GRAPHICS_TEXTURE | Allocation.USAGE_GRAPHICS_RENDER_TARGET;
        sRenderTargetBlur0Color = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
        sRenderTargetBlur1Color = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
        sRenderTargetBlur2Color = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));

        b = new Type.Builder(rs, Element.createPixel(rs, Element.DataType.UNSIGNED_16,
                                                     Element.DataKind.PIXEL_DEPTH));
        renderType = b.setX(targetWidth).setY(targetHeight).create();
        usage = Allocation.USAGE_GRAPHICS_RENDER_TARGET;
        sRenderTargetBlur0Depth = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
        sRenderTargetBlur1Depth = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
        sRenderTargetBlur2Depth = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
    }

    static void addOffsets(Renderable quad, float advance) {
        quad.appendSourceParams(new Float4Param("blurOffset0", - advance * 2.5f));
        quad.appendSourceParams(new Float4Param("blurOffset1", - advance * 0.5f));
        quad.appendSourceParams(new Float4Param("blurOffset2", advance * 1.5f));
        quad.appendSourceParams(new Float4Param("blurOffset3", advance * 3.5f));
    }

    static RenderPass addPass(Scene scene, Camera cam, TextureRenderTarget color, TextureRenderTarget depth) {
        RenderPass pass = new RenderPass();
        pass.setColorTarget(color);
        pass.setDepthTarget(depth);
        pass.setShouldClearColor(false);
        pass.setShouldClearDepth(false);
        pass.setCamera(cam);
        scene.appendRenderPass(pass);
        return pass;
    }

    static void addBlurPasses(Scene scene, RenderScriptGL rs, Camera cam) {
        SceneManager sceneManager = SceneManager.getInstance();
        ArrayList<RenderableBase> allDraw = scene.getRenderables();
        int numDraw = allDraw.size();

        ProgramRaster cullNone = ProgramRaster.CULL_NONE(rs);
        ProgramStore blendAdd = SceneManager.BLEND_ADD_DEPTH_NONE(rs);
        ProgramStore blendNone = ProgramStore.BLEND_NONE_DEPTH_NONE(rs);

        RenderState drawTex = new RenderState(mPV_Blur, mPF_Texture, blendAdd, cullNone);
        RenderState selectCol = new RenderState(mPV_Blur, mPF_SelectColor, blendNone, cullNone);
        RenderState hBlur = new RenderState(mPV_Blur, mPF_BlurH, blendNone, cullNone);
        RenderState vBlur = new RenderState(mPV_Blur, mPF_BlurV, blendNone, cullNone);

        // Renders the scene off screen
        RenderPass blurSourcePass = addPass(scene, cam,
                                            sRenderTargetBlur0Color,
                                            sRenderTargetBlur0Depth);
        blurSourcePass.setClearColor(new Float4(1.0f, 1.0f, 1.0f, 1.0f));
        blurSourcePass.setShouldClearColor(true);
        blurSourcePass.setClearDepth(1.0f);
        blurSourcePass.setShouldClearDepth(true);
        for (int i = 0; i < numDraw; i ++) {
            blurSourcePass.appendRenderable((Renderable)allDraw.get(i));
        }

        // Pass for selecting bright colors
        RenderPass selectColorPass = addPass(scene, cam,
                                             sRenderTargetBlur2Color,
                                             sRenderTargetBlur2Depth);
        Renderable quad = sceneManager.getRenderableQuad("ScreenAlignedQuadS", selectCol);
        quad.appendSourceParams(new TextureParam("color", sRenderTargetBlur0Color));
        selectColorPass.appendRenderable(quad);

        // Horizontal blur
        RenderPass horizontalBlurPass = addPass(scene, cam,
                                                sRenderTargetBlur1Color,
                                                sRenderTargetBlur1Depth);
        quad = sceneManager.getRenderableQuad("ScreenAlignedQuadH", hBlur);
        quad.appendSourceParams(new TextureParam("color", sRenderTargetBlur2Color));
        addOffsets(quad, 1.0f / (float)targetWidth);
        horizontalBlurPass.appendRenderable(quad);

        // Vertical Blur
        RenderPass verticalBlurPass = addPass(scene, cam,
                                              sRenderTargetBlur2Color,
                                              sRenderTargetBlur2Depth);
        quad = sceneManager.getRenderableQuad("ScreenAlignedQuadV", vBlur);
        quad.appendSourceParams(new TextureParam("color", sRenderTargetBlur1Color));
        addOffsets(quad, 1.0f / (float)targetHeight);
        verticalBlurPass.appendRenderable(quad);
    }

    // Additively renders the blurred colors on top of the scene
    static void addCompositePass(Scene scene, RenderScriptGL rs, Camera cam) {
        SceneManager sceneManager = SceneManager.getInstance();
        RenderState drawTex = new RenderState(mPV_Blur, mPF_Texture,
                                              SceneManager.BLEND_ADD_DEPTH_NONE(rs),
                                              ProgramRaster.CULL_NONE(rs));

        RenderPass compositePass = addPass(scene, cam, null, null);
        Renderable quad = sceneManager.getRenderableQuad("ScreenAlignedQuadComposite", drawTex);
        quad.appendSourceParams(new TextureParam("color", sRenderTargetBlur2Color));
        compositePass.appendRenderable(quad);
    }

    static private FragmentShader getShader(Resources res, RenderScriptGL rs,
                                            int resID, Type constants) {
        FragmentShader.Builder fb = new FragmentShader.Builder(rs);
        fb.setShader(res, resID);
        fb.addTexture(TextureType.TEXTURE_2D, "color");
        if (constants != null) {
            fb.setObjectConst(constants);
        }
        FragmentShader prog = fb.create();
        prog.getProgram().bindSampler(Sampler.CLAMP_LINEAR(rs), 0);
        return prog;
    }

    static void initShaders(Resources res, RenderScriptGL rs) {
        ScriptField_BlurOffsets blurConst = new ScriptField_BlurOffsets(rs, 1);
        VertexShader.Builder vb = new VertexShader.Builder(rs);
        vb.addInput(ScriptField_VertexShaderInputs.createElement(rs));
        vb.setShader(res, R.raw.blur_vertex);
        mPV_Blur = vb.create();

        mPF_Texture = getShader(res, rs, R.raw.texture, null);
        mPF_Texture.getProgram().bindSampler(Sampler.WRAP_LINEAR_MIP_LINEAR(rs), 0);
        mPF_BlurH = getShader(res, rs, R.raw.blur_h, blurConst.getAllocation().getType());
        mPF_BlurV = getShader(res, rs, R.raw.blur_v, blurConst.getAllocation().getType());
        mPF_SelectColor = getShader(res, rs, R.raw.select_color, null);
    }

}