Transformations to 2D/3D objects with Cardboard SDK and Surface Texture
<p>What I want to do:</p>

<ul>
<li>Create an augmented reality app that supports camera feed and uses cardboard.</li>
<li>Virtual objects will not be using markers to be rendered</li>
<li>Integration to OpenCV for interaction/transformation</li>
</ul>

<p>What I currently have:</p>

<blockquote>
  <p>MainActivity</p>
</blockquote>

<pre><code>public class MainActivity extends CardboardActivity implements CardboardView.StereoRenderer, OnFrameAvailableListener {
private static String TAG = "Sample";
private static final float Z_NEAR = 0.1f;
private static final float Z_FAR = 100.0f;

private CardboardView mCardboardView;
private SurfaceTexture surface;
private Camera camera;
private CameraClass mCamClass;
private Triangle mTriClass;
private float[] headView, view;
float[] modelCube = new float[16];
float[] modelView = new float[16];
float[] modelViewProjection = new float[16];
float[] mCamMM = new float[16];


@Override
protected void onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    Log.i(TAG, "onCreate");

    setContentView(R.layout.activity_main);
    mCardboardView = (CardboardView)findViewById(R.id.cardboard_view);
    mCardboardView.setRenderer(this);
    setCardboardView(mCardboardView);

    headView = new float[16];
    view = new float[16];
}
@Override
public void onNewFrame(HeadTransform headTransform) {
    Log.i(TAG, "onNewFrame");
    float[] mtx = new float[16];
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);

    surface.updateTexImage();
    surface.getTransformMatrix(mtx);
    Matrix.setLookAtM(mCamMM, 0, 0.0f, 0.0f, 1.5f, 0.0f, 0.0f, -5.0f, 0.0f, 1.0f, 0.0f);
    headTransform.getHeadView(headView, 0);


}

@Override
public void onDrawEye(Eye eye) {
    Log.i(TAG, "onDrawEye");
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);


    mCamClass.draw();

    Matrix.setIdentityM(modelCube, 0);

    Matrix.multiplyMM(view, 0, eye.getEyeView(), 0, mCamMM, 0);

    float[] perspective = eye.getPerspective(Z_NEAR, Z_FAR);
    Matrix.multiplyMM(modelView, 0, view, 0, modelCube, 0);
    Matrix.multiplyMM(modelViewProjection, 0, perspective, 0, modelView, 0);

    mTriClass.draw(modelViewProjection);
}

@Override
public void onFinishFrame(Viewport viewport) {
    Log.i(TAG, "onFinishFrame");
}

@Override
public void onSurfaceChanged(int width, int height) {
    Log.i(TAG, "onSurfaceChanged");
}

@Override
public void onSurfaceCreated(EGLConfig eglConfig) {
    Log.i(TAG, "onSurfaceCreated");


    GLES20.glClearColor(0.5f, 0.5f, 0.5f, 0.5f);

    mCamClass = new CameraClass();
    mTriClass = new Triangle();
    startCamera(mCamClass.returnTexture());
}

@Override
public void onRendererShutdown() {
    Log.i(TAG, "onRenderedShutdown");
}

public void startCamera(int texture)
{
    surface = new SurfaceTexture(texture);
    surface.setOnFrameAvailableListener(this);


    camera = android.hardware.Camera.open();

    try
    {
        camera.setPreviewTexture(surface);
        camera.startPreview();
    }
    catch (IOException ioe)
    {
        Log.w("MainActivity", "CAM LAUNCH FAILED");
    }
}

@Override
public void onFrameAvailable(SurfaceTexture arg0) {
    this.mCardboardView.requestRender();

}
</code></pre>

<p>}</p>

<blockquote>
  <p>Triangle Class</p>
</blockquote>

<pre><code>public class Triangle {
private FloatBuffer vertexBuffer;

private final int mProgram;

private final String vertexShaderCode =
        "uniform mat4 u_MVPMatrix;" +
        "attribute vec4 vPosition;" +
                "void main() {" +
                "  gl_Position = u_MVPMatrix * vPosition;" +
                "}";

private final String fragmentShaderCode =
        "precision mediump float;" +
                "uniform vec4 vColor;" +
                "void main() {" +
                "  gl_FragColor = vColor;" +
                "}";

static final int COORDS_PER_VERTEX = 3;
static float triangleCoords[] = {   // in counterclockwise order:
        0.0f,  0.622008459f, 0.0f, // top
        -0.5f, -0.311004243f, 0.0f, // bottom left
        0.5f, -0.311004243f, 0.0f  // bottom right
};

// Set color with red, green, blue and alpha (opacity) values
float color[] = { 0.63671875f, 0.76953125f, 0.22265625f, 0.0f };

private int mPositionHandle;
private int mColorHandle;
private int mMVPHandle;

private final int vertexCount = triangleCoords.length / COORDS_PER_VERTEX;
private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex

public Triangle() {
    // initialize vertex byte buffer for shape coordinates
    ByteBuffer bb = ByteBuffer.allocateDirect(
            // (number of coordinate values * 4 bytes per float)
            triangleCoords.length * 4);
    // use the device hardware's native byte order
    bb.order(ByteOrder.nativeOrder());

    // create a floating point buffer from the ByteBuffer
    vertexBuffer = bb.asFloatBuffer();
    // add the coordinates to the FloatBuffer
    vertexBuffer.put(triangleCoords);
    // set the buffer to read the first coordinate
    vertexBuffer.position(0);

    int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER,
            vertexShaderCode);
    int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER,
            fragmentShaderCode);

    // create empty OpenGL ES Program
    mProgram = GLES20.glCreateProgram();

    // add the vertex shader to program
    GLES20.glAttachShader(mProgram, vertexShader);

    // add the fragment shader to program
    GLES20.glAttachShader(mProgram, fragmentShader);

    // creates OpenGL ES program executables
    GLES20.glLinkProgram(mProgram);

    // get handle to vertex shader's vPosition member
    mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");

    // get handle to fragment shader's vColor member
    mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");

    mMVPHandle = GLES20.glGetUniformLocation(mProgram, "u_MVPMatrix");



}

public static int loadShader(int type, String shaderCode){

    // create a vertex shader type (GLES20.GL_VERTEX_SHADER)
    // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
    int shader = GLES20.glCreateShader(type);

    // add the source code to the shader and compile it
    GLES20.glShaderSource(shader, shaderCode);
    GLES20.glCompileShader(shader);

    return shader;
}

public void draw(float[] mMVPMatrix) {
//public void draw() {
    // Add program to OpenGL ES environment
    GLES20.glUseProgram(mProgram);

    // Prepare the triangle coordinate data
    GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, vertexStride, vertexBuffer);

    // Enable a handle to the triangle vertices
    GLES20.glEnableVertexAttribArray(mPositionHandle);

    // Set color for drawing the triangle
    GLES20.glUniform4fv(mColorHandle, 1, color, 0);
    GLES20.glUniformMatrix4fv(mMVPHandle, 1, false, mMVPMatrix, 0);

    // Draw the triangle
    GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);



    // Disable vertex array
    GLES20.glDisableVertexAttribArray(mPositionHandle);
}
</code></pre>

<p>}</p>

<blockquote>
  <p>CameraClass</p>
</blockquote>

<pre><code>public class CameraClass {
static float squareVerticesA[] = { // in counterclockwise order:
        -1.0f, -1.0f,   // 0.left - mid
        1.0f, -1.0f,   // 1. right - mid
        -1.0f, 1.0f,   // 2. left - top
        1.0f, 1.0f,   // 3. right - top
};

static float squareVerticesB[] = {
        0.0f, 1.0f,  // A. left-bottom
        1.0f, 1.0f,  // B. right-bottom
        0.0f, 0.0f,  // C. left-top
        1.0f, 0.0f   // D. right-top
};

private final String vertexShaderCode =
        "attribute vec4 position;" +
                "attribute vec2 inputTextureCoordinate;" +
                "varying vec2 textureCoordinate;" +
                "void main()" +
                "{"+
                "gl_Position = position;"+
                "textureCoordinate = inputTextureCoordinate;" +
                "}";

private final String fragmentShaderCode =
        "#extension GL_OES_EGL_image_external : require\n"+
                "precision mediump float;" +
                "varying vec2 textureCoordinate;                            \n" +
                "uniform samplerExternalOES s_texture;               \n" +
                "void main(void) {" +
                "  gl_FragColor = texture2D( s_texture, textureCoordinate );\n" +
                "}";

private static final int GL_TEXTURE_EXTERNAL_OES = 0x8D65;

private int texture;
private int mTextureCoordHandle, mPositionHandle, mColorHandle;
private FloatBuffer vertexBuffer, vertexBuffer2;
private ShortBuffer drawListBuffer;
static final int COORDS_PER_VERTEX = 2;
private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex
private short drawOrder[] =  {0, 2, 1, 1, 2, 3 }; // order to draw vertices

private int mProgram;

public CameraClass(){
    GLES20.glClearColor(0.1f, 0.1f, 0.1f, 0.5f); //set initial color

    ByteBuffer bb = ByteBuffer.allocateDirect(squareVerticesA.length * 4);
    bb.order(ByteOrder.nativeOrder());
    vertexBuffer = bb.asFloatBuffer();
    vertexBuffer.put(squareVerticesA);
    vertexBuffer.position(0);


    ByteBuffer dlb = ByteBuffer.allocateDirect(drawOrder.length * 2);
    dlb.order(ByteOrder.nativeOrder());
    drawListBuffer = dlb.asShortBuffer();
    drawListBuffer.put(drawOrder);
    drawListBuffer.position(0);


    ByteBuffer bb2 = ByteBuffer.allocateDirect(squareVerticesB.length * 4);
    bb2.order(ByteOrder.nativeOrder());
    vertexBuffer2 = bb2.asFloatBuffer();
    vertexBuffer2.put(squareVerticesB);
    vertexBuffer2.position(0);

    int vertexShader = loadGLShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
    int fragmentShader = loadGLShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

    mProgram = GLES20.glCreateProgram();             // create empty OpenGL ES Program
    GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program
    GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
    GLES20.glLinkProgram(mProgram);
    texture = createTexture();
}

public int returnTexture(){
    return texture;
}

public void draw(){
    GLES20.glUseProgram(mProgram);

    GLES20.glActiveTexture(GL_TEXTURE_EXTERNAL_OES);
    GLES20.glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);

    mPositionHandle = GLES20.glGetAttribLocation(mProgram, "position");
    GLES20.glEnableVertexAttribArray(mPositionHandle);
    GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT,
            false, vertexStride, vertexBuffer);


    mTextureCoordHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");
    GLES20.glEnableVertexAttribArray(mTextureCoordHandle);
    GLES20.glVertexAttribPointer(mTextureCoordHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT,
            false,vertexStride, vertexBuffer2);

    mColorHandle = GLES20.glGetAttribLocation(mProgram, "s_texture");


    GLES20.glDrawElements(GLES20.GL_TRIANGLES, drawOrder.length,
            GLES20.GL_UNSIGNED_SHORT, drawListBuffer);


    // Disable vertex array
    GLES20.glDisableVertexAttribArray(mPositionHandle);
    GLES20.glDisableVertexAttribArray(mTextureCoordHandle);
}

private int loadGLShader(int type, String code) {
    int shader = GLES20.glCreateShader(type);
    GLES20.glShaderSource(shader, code);
    GLES20.glCompileShader(shader);
    return shader;
}

static private int createTexture()
{
    int[] texture = new int[1];

    GLES20.glGenTextures(1,texture, 0);
    GLES20.glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture[0]);
    GLES20.glTexParameterf(GL_TEXTURE_EXTERNAL_OES,
            GLES20.GL_TEXTURE_MIN_FILTER,GLES20.GL_LINEAR);
    GLES20.glTexParameterf(GL_TEXTURE_EXTERNAL_OES,
            GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
    GLES20.glTexParameteri(GL_TEXTURE_EXTERNAL_OES,
            GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
    GLES20.glTexParameteri(GL_TEXTURE_EXTERNAL_OES,
            GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);

    return texture[0];
}
</code></pre>

<p>}</p>

<p><img src="https://i.stack.imgur.com/vDfF4.png" alt="Camera Texture"></p>

<p><img src="https://i.stack.imgur.com/351k6.png" alt="With 2D Triangle"></p>

<p><a href="https://i.stack.imgur.com/6C9li.png" rel="nofollow noreferrer">One of the eyes is offcentered</a></p>

<p>The original version of this code is from this link: <a href="https://github.com/Sveder/CardboardPassthrough" rel="nofollow noreferrer">https://github.com/Sveder/CardboardPassthrough</a></p>