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

import android.opengl.GLES30;

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

/**

 * Remember the OpenGL state.

 * This is a member of DistortedNode. Remembers the OpenGL state we want to set just before rendering

 * the Node.

class DistortedRenderState

{

  private static final int STENCIL_MASK = (1<<8)-1;

    {

    private int colorMaskR, colorMaskG, colorMaskB, colorMaskA;

    private int depthMask;

    private int stencilMask;

    private int depthTest;

    private int stencilTest;

    private int stencilFuncFunc, stencilFuncRef, stencilFuncMask;

    private int stencilOpSfail, stencilOpDpfail, stencilOpDppass;

    private int depthFunc;

    private int blend;

    private int blendSrc, blendDst;

    }

  private RenderState mState;          // state the current object wants to have

  static private RenderState cState = new RenderState();   // current OpenGL Stave

  static private RenderState sState = new RenderState();   // saved OpenGL state

  private int mClear;

  DistortedRenderState()

    {

    mState.colorMaskR = 1;

    mState.colorMaskG = 1;

    mState.colorMaskB = 1;

    mState.colorMaskA = 1;

    mState.depthTest  = 1;

    mState.depthMask  = 1;

    mState.depthFunc  = GLES30.GL_LEQUAL;

    mState.blend      = 1;

    mState.blendSrc   = GLES30.GL_SRC_ALPHA;

    mState.blendDst   = GLES30.GL_ONE_MINUS_SRC_ALPHA;

    mState.stencilTest     = 0;

    mState.stencilMask     = STENCIL_MASK;

    mState.stencilFuncFunc = GLES30.GL_NEVER;

    mState.stencilFuncRef  = 0;

    mState.stencilFuncMask = STENCIL_MASK;

    mState.stencilOpSfail  = GLES30.GL_KEEP;

    mState.stencilOpDpfail = GLES30.GL_KEEP;

    mState.stencilOpDppass = GLES30.GL_KEEP;

    mClear = 0;

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

  static void reset()

    {

    cState.colorMaskG = -1;

    cState.colorMaskB = -1;

    cState.colorMaskA = -1;

    cState.depthTest  = -1;

    cState.depthMask  = -1;

    cState.depthFunc  = -1;

    cState.blend      = -1;

    cState.blendSrc   = -1;

    cState.blendDst   = -1;

    cState.stencilTest     = -1;

    cState.stencilMask     = -1;

    cState.stencilFuncFunc = -1;

    cState.stencilFuncRef  = -1;

    cState.stencilFuncMask = -1;

    cState.stencilOpSfail  = -1;

    cState.stencilOpDpfail = -1;

    cState.stencilOpDppass = -1;

      cState.colorMaskG = 1;

      cState.colorMaskB = 1;

      cState.colorMaskA = 1;

      }

      }

      GLES30.glStencilMask(cState.stencilMask);

  static void switchOffDrawing()

    {

    GLES30.glEnable(GLES30.GL_SCISSOR_TEST);

    GLES30.glScissor(0,0,0,0);

    }

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

  static void restoreDrawing()

    {

    GLES30.glDisable(GLES30.GL_SCISSOR_TEST);

    }

  static void setUpStencilMark()

    {

      }

      cState.stencilFuncRef  = 1;

      cState.stencilFuncMask = STENCIL_MASK;

      cState.stencilOpDpfail= GLES30.GL_KEEP;

      cState.stencilOpDppass= GLES30.GL_REPLACE;

      cState.colorMaskG = 0;

      cState.colorMaskB = 0;

      cState.colorMaskA = 0;

      }

      }

    }

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

  static void useStencilMark()

    {

      cState.stencilTest = 1;

      }

      sState.stencilFuncRef  = cState.stencilFuncRef;

      sState.stencilFuncMask = cState.stencilFuncMask;

      cState.stencilFuncFunc = GLES30.GL_EQUAL;

      cState.stencilFuncRef  = 1;

      cState.stencilFuncMask = STENCIL_MASK;

      GLES30.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);

    // TODO: Debatable

      cState.stencilMask = 0x00;

      GLES30.glStencilMask(cState.stencilMask);

    }

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

        GLES30.glDisable(GLES30.GL_STENCIL_TEST);

        }

      else

        {

        GLES30.glEnable(GLES30.GL_STENCIL_TEST);

        }

      }

      cState.stencilFuncRef  = sState.stencilFuncRef ;

      cState.stencilFuncMask = sState.stencilFuncMask;

      GLES30.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);

      GLES30.glStencilMask(cState.stencilMask);

    }

  void apply()

    {

    // 1. Write to color buffer?

      cState.colorMaskG = mState.colorMaskG;

      cState.colorMaskB = mState.colorMaskB;

      cState.colorMaskA = mState.colorMaskA;

      GLES30.glColorMask(cState.colorMaskR==1,cState.colorMaskG==1,cState.colorMaskB==1,cState.colorMaskA==1);

        //android.util.Log.d("State", "disabling depth test");

        GLES30.glDisable(GLES30.GL_DEPTH_TEST);

        }

        {

        GLES30.glEnable(GLES30.GL_DEPTH_TEST);

      }

    // 3. Change Depth Function?

      //android.util.Log.d("State", "setting depth func");

      GLES30.glDepthFunc(cState.depthFunc);

    // 4. Write to Depth buffer?

      GLES30.glDepthMask(cState.depthMask==1);

    // 5. Enable Blending?

        //android.util.Log.d("State", "disabling blending");

        GLES30.glDisable(GLES30.GL_BLEND);

        }

        {

        }

      }

    // 6. Change Blend function?

      //android.util.Log.d("State", "setting blend function");

      cState.blendDst = mState.blendDst;

      GLES30.glBlendFunc(cState.blendSrc,cState.blendDst);

    // 7. Enable/Disable Stencil Test?

        //android.util.Log.d("State", "disabling stencil test");

        GLES30.glDisable(GLES30.GL_STENCIL_TEST);

        }

        {

        }

      }

    // 8. Adjust Stencil function?

      //android.util.Log.d("State", "setting stencil function");

      cState.stencilFuncRef  = mState.stencilFuncRef ;

      cState.stencilFuncMask = mState.stencilFuncMask;

      GLES30.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask);

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

    // 9. Adjust Stencil operation?

      //android.util.Log.d("State", "setting stencil op");

      cState.stencilOpDpfail= mState.stencilOpDpfail;

      cState.stencilOpDppass= mState.stencilOpDppass;

      GLES30.glStencilOp(cState.stencilOpSfail,cState.stencilOpDpfail,cState.stencilOpDppass);

    // 10. Write to Stencil buffer?

      GLES30.glStencilMask(cState.stencilMask);

    // 11. Clear buffers?

      {

      }

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

  void glColorMask(boolean r, boolean g, boolean b, boolean a)

    {

    mState.colorMaskG = (g ? 1:0);

    mState.colorMaskB = (b ? 1:0);

    mState.colorMaskA = (a ? 1:0);

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

  void glDepthMask(boolean mask)

    {

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

  void glStencilMask(int mask)

    {

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

  void glEnable(int test)

    {

    else if( test==GLES30.GL_STENCIL_TEST ) mState.stencilTest = 1;

    else if( test==GLES30.GL_BLEND        ) mState.blend       = 1;

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

  void glDisable(int test)

    {

    else if( test==GLES30.GL_STENCIL_TEST ) mState.stencilTest = 0;

    else if( test==GLES30.GL_BLEND        ) mState.blend       = 0;

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

  void glStencilFunc(int func, int ref, int mask)

    {

    mState.stencilFuncRef  = ref;

    mState.stencilFuncMask = mask;

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

  void glStencilOp(int sfail, int dpfail, int dppass)

    {

    mState.stencilOpDpfail= dpfail;

    mState.stencilOpDppass= dppass;

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

  void glDepthFunc(int func)

    {

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

  void glBlendFunc(int src, int dst)

    {

    mState.blendDst = dst;

  void glClear(int mask)

    {

    mClear = mask;

    }