LibGdx texture blend test

package com.neet.blockbunny;

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Pixmap.Format;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.Texture.TextureFilter;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.glutils.FrameBuffer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;

public class Test2 extends ApplicationAdapter {

    private static final int width0 = 128, height0 = 128;
    private static final int width1 = 64, height1 = 64;

    private OrthographicCamera cam0;
    private ShapeRenderer renderer0;
    private SpriteBatch batch0;

    private FrameBuffer buffer1;
    private Texture original;
    private OrthographicCamera cam1;
    private ShapeRenderer renderer1;
    private SpriteBatch batch1;

    private FrameBuffer buffer2;
    private Texture mask;
    private OrthographicCamera cam2;
    private ShapeRenderer renderer2;
    private SpriteBatch batch2;

    private FrameBuffer buffer3;
    private Texture texture3;
    private OrthographicCamera cam3;
    private ShapeRenderer renderer3;
    private SpriteBatch batch3;

    private Color odd = new Color(.1f, 0, 0, 1);
    private Color even = new Color(0, .1f, 0, 1);

    @Override
    public void create() {
        // basic
        cam0 = new OrthographicCamera();
        cam0.setToOrtho(false, width0, height0);
        cam0.update();

        batch0 = new SpriteBatch();
        batch0.setProjectionMatrix(cam0.combined);

        renderer0 = new ShapeRenderer();
        renderer0.setProjectionMatrix(cam0.combined);

        // for texture
        cam1 = new OrthographicCamera();
        cam1.setToOrtho(true, width1, height1);
        cam1.update();

        batch1 = new SpriteBatch();
        batch1.setProjectionMatrix(cam1.combined);

        renderer1 = new ShapeRenderer();
        renderer1.setProjectionMatrix(cam1.combined);

        buffer1 = new FrameBuffer(Format.RGBA8888, width1, height1, false);
        original = buffer1.getColorBufferTexture();
        original.setFilter(TextureFilter.Nearest, TextureFilter.Nearest);

        // for mask
        cam2 = new OrthographicCamera();
        cam2.setToOrtho(true, width1, height1);
        cam2.update();

        batch2 = new SpriteBatch();
        batch2.setProjectionMatrix(cam2.combined);

        renderer2 = new ShapeRenderer();
        renderer2.setProjectionMatrix(cam2.combined);

        buffer2 = new FrameBuffer(Format.RGBA8888, width1, height1, false);
        mask = buffer2.getColorBufferTexture();
        mask.setFilter(TextureFilter.Nearest, TextureFilter.Nearest);

        // for result
        cam3 = new OrthographicCamera();
        cam3.setToOrtho(true, width1, height1);
        cam3.update();

        batch3 = new SpriteBatch();
        batch3.setProjectionMatrix(cam3.combined);

        renderer3 = new ShapeRenderer();
        renderer3.setProjectionMatrix(cam3.combined);

        buffer3 = new FrameBuffer(Format.RGBA8888, width1, height1, false);
        texture3 = buffer3.getColorBufferTexture();
        texture3.setFilter(TextureFilter.Nearest, TextureFilter.Nearest);

        // now paint texture
        buffer1.begin();

        Texture full = new Texture(Gdx.files.internal("ast.png"));
        batch1.begin();
        batch1.draw(full, 0, 0);
        batch1.end();

        buffer1.end();

        // now paint mask
        buffer2.begin();

        renderer2.begin(ShapeType.Filled);
        renderer2.setColor(Color.WHITE);
        renderer2.rect(width1 / 4, height1 / 4, width1 / 2, height1 / 2);
        renderer2.end();

        buffer2.end();

        // now paint result
        buffer3.begin();

        // Gdx.gl20.glBlendFunc(GL20.GL_ZERO, GL20.GL_ZERO);
        batch3.begin();
        batch3.enableBlending();
        batch3.draw(original, 0, 0);
        batch3.draw(mask, 0, 0);
        batch3.end();

        buffer3.end();

    }

    @Override
    public void render() {
        Gdx.gl.glClearColor(0f, 0f, 0f, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        // background
        // i = x
        renderer0.begin(ShapeType.Filled);
        for (int i = 0; i < width0; i++) {
            for (int j = 0; j < height0; j++) {
                boolean f = ((i + j) & 1) == 1;
                renderer0.setColor(f ? odd : even);
                renderer0.rect(i, j, 1, 1);
            }
        }
        renderer0.end();

        batch0.enableBlending();
        batch0.begin();

        batch0.draw(original, 0, 0); // to see the original
        batch0.draw(mask, width1, 0); // and the mask

        batch0.draw(original, 0, height1); // base for the result

        batch0.setBlendFunction(GL20.GL_ZERO, GL20.GL_SRC_ALPHA);
        batch0.draw(mask, 0, height1); // draw mask on result
        batch0.setBlendFunction(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);

        batch0.end();

    }

}