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.stencil;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.GLES31;

import android.opengl.GLSurfaceView;

import org.distorted.examples.R;

import org.distorted.library.effect.FragmentEffectBrightness;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectRotate;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedFramebuffer;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshCubes;

import org.distorted.library.mesh.MeshQuad;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import java.io.IOException;

import java.io.InputStream;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

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

class StencilRenderer implements GLSurfaceView.Renderer

{

    private GLSurfaceView mView;

    private DistortedScreen mScreen;

    private DistortedTexture mCubeTex, mFloorTex, mFBOTex;

    private DistortedNode mCube1Node, mCube2Node, mFloorNode, mFBONode;

    private Static3D mScale, mFBOScale;

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

    void setScreen(boolean screen)

      {

      if( screen )

        {

        mScreen.detachAll();

        mScreen.attach(mCube1Node);

        mScreen.attach(mFloorNode);

        mScreen.attach(mCube2Node);

        }

      else

        {

        mScreen.detachAll();

        mScreen.attach(mFBONode);

        mFBONode.attach(mCube1Node);

        mFBONode.attach(mFloorNode);

        mFBONode.attach(mCube2Node);

        mFBONode.enableDepthStencil(DistortedFramebuffer.BOTH_DEPTH_STENCIL);

        }

      }

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

    StencilRenderer(GLSurfaceView v)

      {

      mView = v;

      MeshCubes cube   = new MeshCubes(1,1,1);

      MeshQuad  quaFlo = new MeshQuad();

      MeshQuad  quaFBO = new MeshQuad();

      mScale      = new Static3D(1,1,1);

      mFBOScale   = new Static3D(1,1,1);

      mCubeTex   = new DistortedTexture();

      mFloorTex  = new DistortedTexture();

      mFBOTex    = new DistortedTexture();

      DistortedEffects cube1Effects = new DistortedEffects();

      DistortedEffects cube2Effects = new DistortedEffects();

      DistortedEffects floorEffects = new DistortedEffects();

      DistortedEffects FBOEffects   = new DistortedEffects();

      quaFlo.setStretch(2,2,0);

      mCube1Node = new DistortedNode(mCubeTex , cube1Effects, cube   );

      mCube2Node = new DistortedNode(mCubeTex , cube2Effects, cube   );

      mFloorNode = new DistortedNode(mFloorTex, floorEffects, quaFlo );

      mFBONode   = new DistortedNode(mFBOTex  , FBOEffects  , quaFBO );

      ///////////////// The Meat of this App - shamelessly ripped off https://open.gl/depthstencils ///////////////////////

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

      // Stuff to do just before we render the upper Cube

      // Nothing - i.e. use default OpenGL settings (one difference - in Distorted, Depth Test is on by default).

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

      // Stuff to do just before we render the Floor

      mFloorNode.glEnable(GLES31.GL_STENCIL_TEST);                               // Enable Stencil when rendering this Node

      mFloorNode.glStencilFunc(GLES31.GL_ALWAYS, 1, 0xFF);                       // Set any stencil to 1

      mFloorNode.glStencilOp(GLES31.GL_KEEP, GLES31.GL_KEEP, GLES31.GL_REPLACE); // replace with 1 when we fail Depth test

      mFloorNode.glStencilMask(0xFF);                                            // Write to stencil buffer

      mFloorNode.glDepthMask(false);                                             // Don't write to depth buffer

      mFloorNode.glClear(GLES31.GL_STENCIL_BUFFER_BIT);                          // Clear stencil buffer (by default, with a 0)

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

      // Stuff to do just before we render the lower Cube

      mCube2Node.glEnable(GLES31.GL_STENCIL_TEST);                               // Enable Stencil when rendering this Node

                                                                                 // no, this is not retained; we have to set

                                                                                 // this again even though Floor just set it

      mCube2Node.glStencilFunc(GLES31.GL_EQUAL, 1, 0xFF);                        // Pass test if stencil value is 1

      mCube2Node.glStencilMask(0x00);                                            // Don't write anything to stencil buffer

      mCube2Node.glDepthMask(true);                                              // Write to depth buffer

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

      mScreen = new DistortedScreen();

      mScreen.glClearColor(1.0f,1.0f,1.0f,1.0f);

      setScreen(true);

      Static3D axisX = new Static3D(1,0,0);

      Static3D axisZ = new Static3D(0,0,1);

      Dynamic1D rotDyn = new Dynamic1D(5000,0.0f);

      rotDyn.setMode(Dynamic1D.MODE_JUMP);

      rotDyn.add(new Static1D(  0));

      rotDyn.add(new Static1D(360));

      Static3D rotCenter  = new Static3D(0,0,0);

      MatrixEffectScale  scale = new MatrixEffectScale(mScale);

      MatrixEffectMove   move1 = new MatrixEffectMove( new Static3D( 0, 0, cube.getStretchX()/2) );

      MatrixEffectRotate rotaX = new MatrixEffectRotate(new Static1D(-60.0f), axisX, rotCenter);

      MatrixEffectRotate rotaZ = new MatrixEffectRotate(rotDyn, axisZ, rotCenter);

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

      // First move the cube and its reflection to the middle of the floor. Then scale the floor, the cube

      // and its reflection. Then keep rotating all along the Z axis, tilt all.

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

      // The cube

      cube1Effects.apply( move1 );

      cube1Effects.apply( scale );

      cube1Effects.apply( rotaZ );

      cube1Effects.apply( rotaX );

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

      // Floor

      floorEffects.apply( scale );

      floorEffects.apply( rotaZ );

      floorEffects.apply( rotaX );

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

      // Reflection

      cube2Effects.apply( move1 );

      cube2Effects.apply( new MatrixEffectScale(new Static3D(1,1,-1)) );

      cube2Effects.apply( scale );

      cube2Effects.apply( rotaZ );

      cube2Effects.apply( rotaX );

      cube2Effects.apply( new FragmentEffectBrightness(new Static1D(0.5f)) );

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

      // Framebuffer

      FBOEffects.apply( new MatrixEffectScale(mFBOScale) );

      }

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

    public void onDrawFrame(GL10 glUnused) 

      {

      mScreen.render(System.currentTimeMillis());

      }

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

    public void onSurfaceChanged(GL10 glUnused, int width, int height) 

      {

      float cw = mCube1Node.getMesh().getStretchX();

      float ch = mCube1Node.getMesh().getStretchY();

      float bw = mFBONode.getMesh().getStretchX();

      float bh = mFBONode.getMesh().getStretchY();

      float scale = 0.4f*(width>height ? height/ch:width/cw);

      mScale.set(scale,scale,scale);

      mFBOScale.set((float)width/bw, (float)height/bh, 1.0f );

      mFBONode.resize(width,height);

      mScreen.resize( width,height);

      }

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

    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) 

      {

      InputStream is = mView.getContext().getResources().openRawResource(R.raw.cat);

      Bitmap bitmap;

      try

        {

        bitmap = BitmapFactory.decodeStream(is);

        }

      finally

        {

        try

          {

          is.close();

          }

        catch(IOException e) { }

        }

      mCubeTex.setTexture(bitmap);

      mFloorTex.setColor(0xff000000);  // ARGB

      FragmentEffectBrightness.enable();

      try

        {

        DistortedLibrary.onCreate(mView.getContext());

        }

      catch(Exception ex)

        {

        android.util.Log.e("Stencil", ex.getMessage() );

        }

      }

}