Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.examples.feedback;

import android.content.Context;

import android.content.res.Resources;

import android.opengl.GLES30;

import android.util.Log;

import org.distorted.library.Distorted;

import org.distorted.library.program.DistortedProgram;

import java.io.InputStream;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

///////////////////////////////////////////////////////////////////////////////////////////////////

public class TransformFeedback

    {

    private static DistortedProgram mFeedbackProgram;

    private static int mProgramHandle;

///////////////////////////////////////////////////////////////////////////////////////////////////

    public TransformFeedback(final Context context)

        {

        final Resources resources = context.getResources();

        final InputStream vertStream = resources.openRawResource(org.distorted.library.R.raw.feedback_vertex_shader);

        final InputStream fragStream = resources.openRawResource(org.distorted.library.R.raw.feedback_fragment_shader);

        String vertHeader= Distorted.GLSL_VERSION;

        String fragHeader= Distorted.GLSL_VERSION;

        String[] feedback = { "outValue" };

        try

          {

          mFeedbackProgram = new DistortedProgram(vertStream,fragStream, vertHeader, fragHeader, Distorted.GLSL, feedback );

          mProgramHandle = mFeedbackProgram.getProgramHandle();

          }

        catch(Exception ex)

          {

          Log.e("TransformFeedback", "exception creating feedback program: "+ex.getMessage());

          }

        }

///////////////////////////////////////////////////////////////////////////////////////////////////

    void render()

        {

        GLES30.glUseProgram(mProgramHandle);

        checkGlError("glUseProgram");

        // Create data to fill VBO

        float[] floatData = { 1.0f, 4.0f, 9.0f, 16.0f, 25.0f, 100.0f };

        int bufferLength = floatData.length * 4;

        FloatBuffer data = ByteBuffer.allocateDirect(bufferLength).order(ByteOrder.nativeOrder()).asFloatBuffer();

        data.put(floatData).position(0);

        // Create VBO and fill with data

        int[] vbo = new int[1];

        GLES30.glGenBuffers(1, vbo, 0);

        GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo[0]);

        GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, bufferLength, data, GLES30.GL_STATIC_READ);

        checkGlError("glBufferData GL_ARRAY_BUFFER");

        // Link created VBO to shader attribute "inValue"

        int inputAttrib = GLES30.glGetAttribLocation(mProgramHandle, "inValue");

        GLES30.glEnableVertexAttribArray(inputAttrib);

        GLES30.glVertexAttribPointer(inputAttrib, 1, GLES30.GL_FLOAT, false, 4, 0);

        checkGlError("glVertexAttribPointer");

        // Create transform feedback buffer object and bind to transform feedback

        //  this creates space in a buffer object for the TransformFeedback.

        int[] tbo = new int[1];

        GLES30.glGenBuffers(1, tbo, 0);

        GLES30.glBindBuffer(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, tbo[0]);

        GLES30.glBufferData(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, bufferLength, null, GLES30.GL_STATIC_READ);

        GLES30.glBindBufferBase(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, tbo[0]); //very important

        checkGlError("glBindBufferBase");

        // Disable Rasterizer if you just need the data

        GLES30.glEnable(GLES30.GL_RASTERIZER_DISCARD);

        // Start the TransformFeedback, Draw the Arrays, then End the Transform Feedback

        GLES30.glBeginTransformFeedback(GLES30.GL_POINTS);

        GLES30.glDrawArrays(GLES30.GL_POINTS, 0, bufferLength);

        checkGlError("glDrawArrays");

        GLES30.glEndTransformFeedback();

        // Reenable Rasterizer if you need it, which you do if you are drawing anything.

        GLES30.glDisable(GLES30.GL_RASTERIZER_DISCARD);

        // Flush out anything in GL before mapping the buffer.

        GLES30.glFlush();

        checkGlError("pre-glMapBufferRange ");

        // Map the transform feedback buffer to local address space.

        Buffer mappedBuffer =  GLES30.glMapBufferRange(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER,

                0, bufferLength, GLES30.GL_MAP_READ_BIT);

        checkGlError("glMapBufferRange");

        // Read out the data, here we write to logcat.

        if (mappedBuffer!=null){

            ByteBuffer bb = ((ByteBuffer) mappedBuffer);

            bb.order(ByteOrder.nativeOrder());

            FloatBuffer transformedData = bb.asFloatBuffer();

            Log.d( "TransofrmFeedback", String.format("output values = %f %f %f %f %f %f\n",

                    transformedData.get(), transformedData.get(), transformedData.get(),

                    transformedData.get(), transformedData.get(), transformedData.get() ));

        }

        // Don't forget to Unmap the Transform Feeback Buffer.

        GLES30.glUnmapBuffer(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER);

        }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private static void checkGlError(String op)

        {

        int error = GLES30.glGetError();

        if (error != GLES30.GL_NO_ERROR)

          {

          String msg = op + ": glError 0x" + Integer.toHexString(error);

          throw new RuntimeException(msg);

          }

        }

}