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

import org.distorted.library.EffectTypes;

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 DistortedEffects mCube1Effects, mCube2Effects, mFloorEffects, mFBOEffects;

    private DistortedNode mCube1Node, mCube2Node, mFloorNode, mFBONode;

    private MeshObject mCubeMesh, mQuad;

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

    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);

      mCubeTex   = new DistortedTexture(1,1);

      mFloorTex  = new DistortedTexture(1,1);

      mFBOTex    = new DistortedTexture(1,1);

      mCube1Effects = new DistortedEffects();

      mCube2Effects = new DistortedEffects();

      mFloorEffects = new DistortedEffects();

      mFBOEffects   = new DistortedEffects();

      mCube2Effects.brightness(new Static1D(0.5f));

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

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

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

      mFBONode   = new DistortedNode(mFBOTex  ,mFBOEffects  ,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(mView);

      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);

      }

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

    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);

      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);

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

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

      // Figured out of experimentation.

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

      // Upper cube

      mCube1Effects.abortEffects(EffectTypes.MATRIX);

      mCube1Effects.move( new Static3D( (width-cubeScale*cw)/2 , height/2-cubeScale*ch , cubeScale *cd/2) );

      mCube1Effects.scale(cubeScale);

      mCube1Effects.rotate(rotSt1, axisX, cubeCenter);

      mCube1Effects.rotate(rotDyn, axisY, cubeCenter);

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

      // Floor

      mFloorEffects.abortEffects(EffectTypes.MATRIX);

      mFloorEffects.move( new Static3D( (width-floorScale*fw)/2 ,height/2-floorScale*fh/2, floorScale*fd/2) );

      mFloorEffects.scale(floorScale);

      mFloorEffects.rotate(rotSt2, axisX, floorCenter);

      mFloorEffects.rotate(rotDyn, axisZ, floorCenter);

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

      // Lower cube

      mCube2Effects.abortEffects(EffectTypes.MATRIX);

      mCube2Effects.move( new Static3D( (width-cubeScale*cw)/2 , height/2-cubeScale*ch , cubeScale *cd/2) );

      mCube2Effects.scale(cubeScale);

      mCube2Effects.rotate(rotSt1, axisX, cubeCenter);

      mCube2Effects.rotate(rotDyn, axisY, cubeCenter);

      mCube2Effects.scale(new Static3D(1,-1,1) );

      mCube2Effects.move( new Static3D( 0, -2*ch , 0) );

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

      // Framebuffer

      mFBOEffects.abortEffects(EffectTypes.MATRIX);

      mFBOEffects.scale( new Static3D( (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() );

        }

      }

}