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

import android.opengl.GLSurfaceView;

import org.distorted.examples.R;

import org.distorted.library.effect.EffectName;

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

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.main.MeshCubes;

import org.distorted.library.main.MeshFlat;

import org.distorted.library.main.MeshObject;

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 MeshObject mCubeMesh, mQuad;

    private Static3D mCubeMove, mCubeScale, mFloorScale, mFloorMove, 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;

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

      mQuad     = new MeshFlat(1,1);

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

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

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

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

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

      mCubeTex   = new DistortedTexture(1,1);

      mFloorTex  = new DistortedTexture(1,1);

      mFBOTex    = new DistortedTexture(1,1);

      DistortedEffects cube1Effects = new DistortedEffects();

      DistortedEffects cube2Effects = new DistortedEffects();

      DistortedEffects floorEffects = new DistortedEffects();

      DistortedEffects FBOEffects   = new DistortedEffects();

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

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

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

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

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

      ///////////////// 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(GLES30.GL_STENCIL_TEST);                               // Enable Stencil when rendering this Node

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

      mFloorNode.glStencilOp(GLES30.GL_KEEP, GLES30.GL_KEEP, GLES30.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(GLES30.GL_STENCIL_BUFFER_BIT);                          // Clear stencil buffer (by default, with a 0)

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

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

      mCube2Node.glEnable(GLES30.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(GLES30.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);

      mView.setEGLConfigChooser(5,6,5,0,16,8);       // Screen: 16 bit depth, 8 bit STENCIL

      setScreen(true);

      float cw = mCubeTex.getWidth();

      float ch = mCubeTex.getHeight();

      float cd = mCubeTex.getDepth(mCubeMesh);

      float fw = mFloorTex.getWidth();

      float fh = mFloorTex.getHeight();

      float fd = mFloorTex.getDepth(mQuad);

      Static3D cubeCenter = new Static3D(cw/2,ch  ,-cd/2);

      Static3D floorCenter= new Static3D(fw/2,fh/2,-fd/2);

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

      Static3D axisY = new Static3D(0,1,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));

      float angle = 30.0f;

      Static1D rotSt1 = new Static1D(angle);

      Static1D rotSt2 = new Static1D(angle-90.0f);

      MatrixEffectRotate rot1 = new MatrixEffectRotate(rotSt1, axisX, cubeCenter);

      MatrixEffectRotate rot2 = new MatrixEffectRotate(rotDyn, axisY, cubeCenter);

      MatrixEffectScale  scal = new MatrixEffectScale(mCubeScale);

      MatrixEffectMove   move = new MatrixEffectMove(mCubeMove);

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

      // Those Matrix effects, i.e. correct positioning of Objects on the Screen, is admittedly quite hard.

      // Figured out of experimentation.

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

      // Upper cube

      cube1Effects.apply( move );

      cube1Effects.apply( scal );

      cube1Effects.apply( rot1 );

      cube1Effects.apply( rot2 );

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

      // Floor

      floorEffects.apply( new MatrixEffectMove(mFloorMove));

      floorEffects.apply( new MatrixEffectScale(mFloorScale) );

      floorEffects.apply( new MatrixEffectRotate(rotSt2, axisX, floorCenter) );

      floorEffects.apply( new MatrixEffectRotate(rotDyn, axisZ, floorCenter) );

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

      // Lower cube

      cube2Effects.apply( move );

      cube2Effects.apply( scal );

      cube2Effects.apply( rot1 );

      cube2Effects.apply( rot2 );

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

      cube2Effects.apply( new MatrixEffectMove(new Static3D( 0, -2*ch , 0)) );

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

      // 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 = mCubeTex.getWidth();

      float ch = mCubeTex.getHeight();

      float cd = mCubeTex.getDepth(mCubeMesh);

      float fw = mFloorTex.getWidth();

      float fh = mFloorTex.getHeight();

      float fd = mFloorTex.getDepth(mQuad);

      float bw = mFBOTex.getWidth();

      float bh = mFBOTex.getHeight();

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

      float floorScale= 0.8f*(width>height ? height/fh:width/fw);

      mCubeMove.set((width-cubeScale*cw)/2 , height/2-cubeScale*ch , cubeScale *cd/2 );

      mCubeScale.set(cubeScale,cubeScale,cubeScale);

      mFloorMove.set((width-floorScale*fw)/2 ,height/2-floorScale*fh/2, floorScale*fd/2 );

      mFloorScale.set(floorScale,floorScale,floorScale);

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

      mFBONode.resize( (int)((float)width/bw), (int)((float)height/bh) );

      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

      DistortedEffects.enableEffect(EffectName.BRIGHTNESS);

      try

        {

        Distorted.onCreate(mView.getContext());

        }

      catch(Exception ex)

        {

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

        }

      }

}