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.

 * <p>

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

 * the Node.

 */

class DistortedRenderState

{

  private static int sColorMaskR, sColorMaskG, sColorMaskB, sColorMaskA;   //

  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

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

// default: color writes on, depth test and writes on, blending on, stencil off.

  DistortedRenderState()

    {

    mColorMaskR = 1;

    mColorMaskG = 1;

    mColorMaskB = 1;

    mColorMaskA = 1;

    mDepthTest  = 1;

    mDepthMask  = 1;

    mDepthFunc  = GLES30.GL_LEQUAL;

    mBlend      = 1;

    mBlendSrc   = GLES30.GL_SRC_ALPHA;

    mBlendDst   = GLES30.GL_ONE_MINUS_SRC_ALPHA;

    mStencilTest     = 0;

    mStencilMask     = 0x11111111;

    mStencilFuncFunc = GLES30.GL_NEVER;

    mStencilFuncRef  = 0;

    mStencilFuncMask = 0x11111111;

    mStencilOpSfail  = GLES30.GL_KEEP;

    mStencilOpDpfail = GLES30.GL_KEEP;

    mStencilOpDppass = GLES30.GL_KEEP;

    mClear = 0;

    }

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

// reset state of everything to 'unknown'

  static void reset()

    {

    sColorMaskR = -1;

    sColorMaskG = -1;

    sColorMaskB = -1;

    sColorMaskA = -1;

    sDepthTest  = -1;

    sDepthMask  = -1;

    sDepthFunc  = -1;

    sBlend      = -1;

    sBlendSrc   = -1;

    sBlendDst   = -1;

    sStencilTest     = -1;

    sStencilMask     = -1;

    sStencilFuncFunc = -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?

    if( mColorMaskR!=sColorMaskR || mColorMaskG!=sColorMaskG || mColorMaskB!=sColorMaskB || mColorMaskA!=sColorMaskA)

      {

      sColorMaskR = mColorMaskR;

      sColorMaskG = mColorMaskG;

      sColorMaskB = mColorMaskB;

      sColorMaskA = mColorMaskA;

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

      }

    // 2. Enable Depth test?

    if( mDepthTest!=sDepthTest )

      {

      sDepthTest = mDepthTest;

      if( sDepthTest==0 ) GLES30.glDisable(GLES30.GL_DEPTH_TEST);

      else

        {

        GLES30.glEnable (GLES30.GL_DEPTH_TEST);

        if( mDepthFunc!=sDepthFunc )

          {

          sDepthFunc = mDepthFunc;

          GLES30.glDepthFunc(sDepthFunc);

          }

        }

      }

    // 3. Write to Depth buffer?

    if( mDepthMask!=sDepthMask )

      {

      sDepthMask = mDepthMask;

      GLES30.glDepthMask(sDepthMask==1);

      }

    // 4. Enable Blending?

    if( mBlend!=sBlend )

      {

      sBlend = mBlend;

      if( sBlend==0 ) GLES30.glDisable(GLES30.GL_BLEND);

      else

        {

        GLES30.glEnable(GLES30.GL_BLEND);

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

          {

          sBlendSrc = mBlendSrc;

          sBlendDst = mBlendDst;

          GLES30.glBlendFunc(sBlendSrc,sBlendDst);

          }

        }

      }

    // 5. Enable Stencil Test?

    if( mStencilTest!=sStencilTest )

      {

      sStencilTest = mStencilTest;

      if( sStencilTest==0 ) GLES30.glDisable(GLES30.GL_STENCIL_TEST);

      else

        {

        GLES30.glEnable(GLES30.GL_STENCIL_TEST);

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

          {

          sStencilFuncFunc = mStencilFuncFunc;

          sStencilFuncRef  = mStencilFuncRef ;

          sStencilFuncMask = mStencilFuncMask;

          GLES30.glStencilFunc(sStencilFuncFunc,sStencilFuncRef,sStencilFuncMask);

          }

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

          {

          sStencilOpSfail = mStencilOpSfail;

          sStencilOpDpfail= mStencilOpDpfail;

          sStencilOpDppass= mStencilOpDppass;

          GLES30.glStencilOp(sStencilOpSfail,sStencilOpDpfail,sStencilOpDppass);

          }

        }

      }

    // 6. Write to Stencil buffer?

    if( mStencilMask!=sStencilMask )

      {

      sStencilMask = mStencilMask;

      GLES30.glStencilMask(sStencilMask);

      }

    // 7. Clear buffers?

    if( mClear!=0 )

      {

      GLES30.glClear(mClear);

      }

    }

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

  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;

    else if( test==GLES30.GL_BLEND        ) mBlend       = 1;

    }

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

  void glDisable(int test)

    {

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

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

    else if( test==GLES30.GL_BLEND        ) mBlend       = 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;

    }

}