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 int sDepthMask;                                           //

  private static int sStencilMask;                                         //

  private static int sDepthTest;                                           //

  private static int sStencilTest;                                         //

  private static int sStencilFuncFunc, sStencilFuncRef, sStencilFuncMask;  // current OpenGL state

  private static int sStencilOpSfail, sStencilOpDpfail, sStencilOpDppass;  //

  private static int sDepthFunc;                                           //

  private static int sBlend;                                               //

  private static int sBlendSrc, sBlendDst;                                 //

  private int mColorMaskR, mColorMaskG, mColorMaskB, mColorMaskA;          //

  private int mDepthMask;                                                  //

  private int mStencilMask;                                                //

  private int mDepthTest;                                                  //

  private int mStencilTest;                                                //

  private int mStencilFuncFunc, mStencilFuncRef, mStencilFuncMask;         // The state we want to have

  private int mStencilOpSfail, mStencilOpDpfail, mStencilOpDppass;         //

  private int mDepthFunc;                                                  //

  private int mBlend;                                                      //

  private int mBlendSrc, mBlendDst;                                        //

  private int mClear;                                                      // This does not have a 'static' compatriot

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

  DistortedRenderState()

    {

    mColorMaskR = 1;

    mColorMaskG = 1;

    mColorMaskB = 1;

    mColorMaskA = 1;

    mDepthFunc  = GLES30.GL_LEQUAL;

    mBlendSrc   = GLES30.GL_SRC_ALPHA;

    mBlendDst   = GLES30.GL_ONE_MINUS_SRC_ALPHA;

    mStencilTest     = 0;

    mStencilMask     = 0x11111111;

    mStencilFuncRef  = 0;

    mStencilFuncMask = 0x11111111;

    mStencilOpSfail  = GLES30.GL_KEEP;

    mStencilOpDpfail = GLES30.GL_KEEP;

    mStencilOpDppass = GLES30.GL_KEEP;

    mClear = 0;

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

  static void reset()

    {

    sColorMaskR = -1;

    sColorMaskG = -1;

    sColorMaskB = -1;

    sColorMaskA = -1;

    sDepthFunc  = -1;

    sBlend      = -1;

    sBlendSrc   = -1;

    sBlendDst   = -1;

    sStencilMask     = -1;

    sStencilFuncRef  = -1;

    sStencilFuncMask = -1;

    sStencilOpSfail  = -1;

    sStencilOpDpfail = -1;

    sStencilOpDppass = -1;

    }

  static void colorDepthOn()

    {

    if( sColorMaskR!=1 || sColorMaskG!=1 || sColorMaskB!=1 || sColorMaskA!=1 )

      {

      sColorMaskR = 1;

      sColorMaskG = 1;

      sColorMaskB = 1;

      sColorMaskA = 1;

      GLES30.glColorMask(true,true,true,true);

      }

    if( sDepthMask!=1 )

      {

      sDepthMask = 1;

      GLES30.glDepthMask(true);

      }

    }

  static void switchOffDrawing()

    {

    GLES30.glEnable(GLES30.GL_SCISSOR_TEST);

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

    }

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

  static void restoreDrawing()

    {

    GLES30.glDisable(GLES30.GL_SCISSOR_TEST);

    }

  void apply()

    {

    // 1. Write to color buffer?

      {

      sColorMaskG = mColorMaskG;

      sColorMaskB = mColorMaskB;

      sColorMaskA = mColorMaskA;

      GLES30.glColorMask(sColorMaskR==1,sColorMaskG==1,sColorMaskB==1,sColorMaskA==1);

      }

      {

      sDepthTest = mDepthTest;

        {

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

        GLES30.glDisable(GLES30.GL_DEPTH_TEST);

        }

        {

        GLES30.glEnable(GLES30.GL_DEPTH_TEST);

      }

    // 3. Change Depth Function?

    if( mDepthFunc!=sDepthFunc )

      {

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

      sDepthFunc = mDepthFunc;

      GLES30.glDepthFunc(sDepthFunc);

      }

    // 4. Write to Depth buffer?

      {

      GLES30.glDepthMask(sDepthMask==1);

      }

    // 5. Enable Blending?

      {

      sBlend = mBlend;

        {

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

        GLES30.glDisable(GLES30.GL_BLEND);

        }

        {

        }

      }

    // 6. Change Blend function?

    if( mBlendSrc!=sBlendSrc || mBlendDst!=sBlendDst )

      {

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

      sBlendSrc = mBlendSrc;

      sBlendDst = mBlendDst;

      GLES30.glBlendFunc(sBlendSrc,sBlendDst);

      }

    // 7. Enable/Disable Stencil Test?

      {

      sStencilTest = mStencilTest;

        {

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

        GLES30.glDisable(GLES30.GL_STENCIL_TEST);

        }

        {

        }

      }

//  android.util.Log.d("State", "GL_ALWAYS="+GLES30.GL_ALWAYS+" GL_EQUAL="+GLES30.GL_EQUAL);

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

    // 8. Adjust Stencil function?

    if( mStencilFuncFunc!=sStencilFuncFunc || mStencilFuncRef!=sStencilFuncRef || mStencilFuncMask!=sStencilFuncMask )

      {

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

      sStencilFuncFunc = mStencilFuncFunc;

      sStencilFuncRef  = mStencilFuncRef ;

      sStencilFuncMask = mStencilFuncMask;

      GLES30.glStencilFunc(sStencilFuncFunc,sStencilFuncRef,sStencilFuncMask);

      }

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

    // 9. Adjust Stencil operation?

    if( mStencilOpSfail!=sStencilOpSfail || mStencilOpDpfail!=sStencilOpDpfail || mStencilOpDppass!=sStencilOpDppass )

      {

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

      sStencilOpSfail = mStencilOpSfail;

      sStencilOpDpfail= mStencilOpDpfail;

      sStencilOpDppass= mStencilOpDppass;

      GLES30.glStencilOp(sStencilOpSfail,sStencilOpDpfail,sStencilOpDppass);

      }

    // 10. Write to Stencil buffer?

      {

      GLES30.glStencilMask(sStencilMask);

      }

    // 11. Clear buffers?

      {

      }

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

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

    {

    mColorMaskR = (r ? 1:0);

    mColorMaskG = (g ? 1:0);

    mColorMaskB = (b ? 1:0);

    mColorMaskA = (a ? 1:0);

    }

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

  void glDepthMask(boolean mask)

    {

    mDepthMask = (mask ? 1:0);

    }

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

  void glStencilMask(int mask)

    {

    mStencilMask = mask;

    }

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

  void glEnable(int test)

    {

         if( test==GLES30.GL_DEPTH_TEST   ) mDepthTest   = 1;

    else if( test==GLES30.GL_STENCIL_TEST ) mStencilTest = 1;

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

  void glDisable(int test)

    {

         if( test==GLES30.GL_DEPTH_TEST   ) mDepthTest   = 0;

    else if( test==GLES30.GL_STENCIL_TEST ) mStencilTest = 0;

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

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

    {

    mStencilFuncFunc = func;

    mStencilFuncRef  = ref;

    mStencilFuncMask = mask;

    }

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

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

    {

    mStencilOpSfail = sfail;

    mStencilOpDpfail= dpfail;

    mStencilOpDppass= dppass;

    }

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

  void glDepthFunc(int func)

    {

    mDepthFunc = func;

    }

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

  void glBlendFunc(int src, int dst)

    {

    mBlendSrc = src;

    mBlendDst = dst;

    }

  void glClear(int mask)

    {

    mClear = mask;

    }