commit 5b959cc598ebc9cf91678353b89704d10a9e9e75 Author: Leszek Koltunski Date: Mon May 22 14:36:24 2017 +0100 Some improvements to DistortedRenderState. diff --git a/src/main/java/org/distorted/library/DistortedFramebuffer.java b/src/main/java/org/distorted/library/DistortedFramebuffer.java index a6bbde2..ff77038 100644 --- a/src/main/java/org/distorted/library/DistortedFramebuffer.java +++ b/src/main/java/org/distorted/library/DistortedFramebuffer.java @@ -123,20 +123,20 @@ public class DistortedFramebuffer extends DistortedOutputSurface implements Dist { if( mColorH[0]>0 ) { - if( mDepthStencilH[0]>0 ) - { - GLES30.glDeleteTextures(1, mDepthStencilH, 0); - mDepthStencilH[0]=0; - mDepthStencilCreated = NOT_CREATED_YET; - } - GLES30.glDeleteTextures(1, mColorH, 0); mColorH[0] = 0; mColorCreated = NOT_CREATED_YET; + } - GLES30.glDeleteFramebuffers(1, mFBOH, 0); - mFBOH[0] = 0; + if( mDepthStencilH[0]>0 ) + { + GLES30.glDeleteTextures(1, mDepthStencilH, 0); + mDepthStencilH[0]=0; + mDepthStencilCreated = NOT_CREATED_YET; } + + GLES30.glDeleteFramebuffers(1, mFBOH, 0); + mFBOH[0] = 0; } /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/main/java/org/distorted/library/DistortedRenderState.java b/src/main/java/org/distorted/library/DistortedRenderState.java index 48e35ee..6711768 100644 --- a/src/main/java/org/distorted/library/DistortedRenderState.java +++ b/src/main/java/org/distorted/library/DistortedRenderState.java @@ -33,61 +33,54 @@ class DistortedRenderState // TODO: figure this out dynamically; this assumes 8 bit stencil buffer. private static final int STENCIL_MASK = (1<<8)-1; - 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 - - private static int rStencilTest; // - private static int rStencilFuncFunc; // - private static int rStencilFuncRef; // Remember values of Stencil. - private static int rStencilFuncMask; // - private static int rStencilMask; // + private static class RenderState + { + 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; /////////////////////////////////////////////////////////////////////////////////////////////////// // 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 = STENCIL_MASK; - mStencilFuncFunc = GLES30.GL_NEVER; - mStencilFuncRef = 0; - mStencilFuncMask = STENCIL_MASK; - mStencilOpSfail = GLES30.GL_KEEP; - mStencilOpDpfail = GLES30.GL_KEEP; - mStencilOpDppass = GLES30.GL_KEEP; + mState = new RenderState(); + + 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; } @@ -97,50 +90,50 @@ class DistortedRenderState 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; + cState.colorMaskR = -1; + 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; } /////////////////////////////////////////////////////////////////////////////////////////////////// static void colorDepthStencilOn() { - if( sColorMaskR!=1 || sColorMaskG!=1 || sColorMaskB!=1 || sColorMaskA!=1 ) + if( cState.colorMaskR!=1 || cState.colorMaskG!=1 || cState.colorMaskB!=1 || cState.colorMaskA!=1 ) { - sColorMaskR = 1; - sColorMaskG = 1; - sColorMaskB = 1; - sColorMaskA = 1; + cState.colorMaskR = 1; + cState.colorMaskG = 1; + cState.colorMaskB = 1; + cState.colorMaskA = 1; GLES30.glColorMask(true,true,true,true); } - if( sDepthMask!=1 ) + if( cState.depthMask!=1 ) { - sDepthMask = 1; + cState.depthMask = 1; GLES30.glDepthMask(true); } - if( sStencilMask!= STENCIL_MASK ) + if( cState.stencilMask!= STENCIL_MASK ) { - sStencilMask = STENCIL_MASK; - GLES30.glStencilMask(sStencilMask); + cState.stencilMask = STENCIL_MASK; + GLES30.glStencilMask(cState.stencilMask); } } @@ -163,48 +156,48 @@ class DistortedRenderState static void setUpStencilMark() { - if( sStencilTest!=1 ) + if( cState.stencilTest!=1 ) { - sStencilTest = 1; + cState.stencilTest = 1; //android.util.Log.d("State", "stencil test on"); GLES30.glEnable(GLES30.GL_STENCIL_TEST); } - if( sStencilFuncFunc!=GLES30.GL_ALWAYS || sStencilFuncRef!=1 || sStencilFuncMask!=STENCIL_MASK ) + if( cState.stencilFuncFunc!=GLES30.GL_ALWAYS || cState.stencilFuncRef!=1 || cState.stencilFuncMask!=STENCIL_MASK ) { - sStencilFuncFunc = GLES30.GL_ALWAYS; - sStencilFuncRef = 1; - sStencilFuncMask = STENCIL_MASK; + cState.stencilFuncFunc = GLES30.GL_ALWAYS; + cState.stencilFuncRef = 1; + cState.stencilFuncMask = STENCIL_MASK; //android.util.Log.d("State", "stencil func on"); - GLES30.glStencilFunc(sStencilFuncFunc,sStencilFuncRef,sStencilFuncMask); + GLES30.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask); } - if( sStencilOpSfail!=GLES30.GL_KEEP || sStencilOpDpfail!=GLES30.GL_KEEP || sStencilOpDppass!=GLES30.GL_REPLACE ) + if( cState.stencilOpSfail!=GLES30.GL_KEEP || cState.stencilOpDpfail!=GLES30.GL_KEEP || cState.stencilOpDppass!=GLES30.GL_REPLACE ) { - sStencilOpSfail = GLES30.GL_KEEP; - sStencilOpDpfail= GLES30.GL_KEEP; - sStencilOpDppass= GLES30.GL_REPLACE; + cState.stencilOpSfail = GLES30.GL_KEEP; + cState.stencilOpDpfail= GLES30.GL_KEEP; + cState.stencilOpDppass= GLES30.GL_REPLACE; //android.util.Log.d("State", "stencil op on"); - GLES30.glStencilOp(sStencilOpSfail,sStencilOpDpfail,sStencilOpDppass); + GLES30.glStencilOp(cState.stencilOpSfail,cState.stencilOpDpfail,cState.stencilOpDppass); } - if( sColorMaskR!=0 || sColorMaskG!=0 || sColorMaskB!=0 || sColorMaskA!=0 ) + if( cState.colorMaskR!=0 || cState.colorMaskG!=0 || cState.colorMaskB!=0 || cState.colorMaskA!=0 ) { - sColorMaskR = 0; - sColorMaskG = 0; - sColorMaskB = 0; - sColorMaskA = 0; + cState.colorMaskR = 0; + cState.colorMaskG = 0; + cState.colorMaskB = 0; + cState.colorMaskA = 0; //android.util.Log.d("State", "switch off color writing"); GLES30.glColorMask(false,false,false,false); } - if( sDepthMask!=0 ) + if( cState.depthMask!=0 ) { - sDepthMask = 0; + cState.depthMask = 0; //android.util.Log.d("State", "switch off depth writing"); GLES30.glDepthMask(false); } - if( sStencilMask!= STENCIL_MASK ) + if( cState.stencilMask!= STENCIL_MASK ) { - sStencilMask = STENCIL_MASK; + cState.stencilMask = STENCIL_MASK; //android.util.Log.d("State", "stencil mask on"); - GLES30.glStencilMask(sStencilMask); + GLES30.glStencilMask(cState.stencilMask); } } @@ -212,29 +205,29 @@ class DistortedRenderState static void useStencilMark() { - if( sStencilTest!=1 ) + if( cState.stencilTest!=1 ) { - rStencilTest = sStencilTest; - sStencilTest = 1; + sState.stencilTest = cState.stencilTest; + cState.stencilTest = 1; GLES30.glEnable(GLES30.GL_STENCIL_TEST); } - if( sStencilFuncFunc!=GLES30.GL_EQUAL || sStencilFuncRef!=1 || sStencilFuncMask!=STENCIL_MASK ) + if( cState.stencilFuncFunc!=GLES30.GL_EQUAL || cState.stencilFuncRef!=1 || cState.stencilFuncMask!=STENCIL_MASK ) { - rStencilFuncFunc = sStencilFuncFunc; - rStencilFuncRef = sStencilFuncRef; - rStencilFuncMask = sStencilFuncMask; - sStencilFuncFunc = GLES30.GL_EQUAL; - sStencilFuncRef = 1; - sStencilFuncMask = STENCIL_MASK; - GLES30.glStencilFunc(sStencilFuncFunc,sStencilFuncRef,sStencilFuncMask); + sState.stencilFuncFunc = cState.stencilFuncFunc; + 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 - if( sStencilMask!= 0x00 ) + if( cState.stencilMask!= 0x00 ) { - rStencilMask = sStencilMask; - sStencilMask = 0x00; - GLES30.glStencilMask(sStencilMask); + sState.stencilMask = cState.stencilMask; + cState.stencilMask = 0x00; + GLES30.glStencilMask(cState.stencilMask); } } @@ -242,11 +235,11 @@ class DistortedRenderState static void unuseStencilMark() { - if( rStencilTest!=sStencilTest ) + if( sState.stencilTest!=cState.stencilTest ) { - sStencilTest = rStencilTest; + cState.stencilTest = sState.stencilTest; - if (sStencilTest == 0) + if (cState.stencilTest == 0) { GLES30.glDisable(GLES30.GL_STENCIL_TEST); } @@ -256,18 +249,18 @@ class DistortedRenderState } } - if( rStencilFuncFunc!=sStencilFuncFunc || rStencilFuncRef!=sStencilFuncRef || rStencilFuncMask!=sStencilFuncMask ) + if( sState.stencilFuncFunc!=cState.stencilFuncFunc || sState.stencilFuncRef!=cState.stencilFuncRef || sState.stencilFuncMask!=cState.stencilFuncMask ) { - sStencilFuncFunc = rStencilFuncFunc; - sStencilFuncRef = rStencilFuncRef ; - sStencilFuncMask = rStencilFuncMask; - GLES30.glStencilFunc(sStencilFuncFunc,sStencilFuncRef,sStencilFuncMask); + cState.stencilFuncFunc = sState.stencilFuncFunc; + cState.stencilFuncRef = sState.stencilFuncRef ; + cState.stencilFuncMask = sState.stencilFuncMask; + GLES30.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask); } - if( rStencilMask!=sStencilMask ) + if( sState.stencilMask!=cState.stencilMask ) { - sStencilMask = rStencilMask; - GLES30.glStencilMask(sStencilMask); + cState.stencilMask = sState.stencilMask; + GLES30.glStencilMask(cState.stencilMask); } } @@ -279,23 +272,23 @@ class DistortedRenderState ///////////////////////////////////////////////////// // 1. Write to color buffer? - if( mColorMaskR!=sColorMaskR || mColorMaskG!=sColorMaskG || mColorMaskB!=sColorMaskB || mColorMaskA!=sColorMaskA) + if( mState.colorMaskR!=cState.colorMaskR || mState.colorMaskG!=cState.colorMaskG || mState.colorMaskB!=cState.colorMaskB || mState.colorMaskA!=cState.colorMaskA) { //android.util.Log.d("State", "setting color mask"); - sColorMaskR = mColorMaskR; - sColorMaskG = mColorMaskG; - sColorMaskB = mColorMaskB; - sColorMaskA = mColorMaskA; - GLES30.glColorMask(sColorMaskR==1,sColorMaskG==1,sColorMaskB==1,sColorMaskA==1); + cState.colorMaskR = mState.colorMaskR; + 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); } ///////////////////////////////////////////////////// // 2. Enable Depth test? - if( mDepthTest!=sDepthTest ) + if( mState.depthTest!=cState.depthTest ) { - sDepthTest = mDepthTest; + cState.depthTest = mState.depthTest; - if (sDepthTest == 0) + if (cState.depthTest == 0) { //android.util.Log.d("State", "disabling depth test"); GLES30.glDisable(GLES30.GL_DEPTH_TEST); @@ -309,29 +302,29 @@ class DistortedRenderState ///////////////////////////////////////////////////// // 3. Change Depth Function? - if( mDepthFunc!=sDepthFunc ) + if( mState.depthFunc!=cState.depthFunc ) { //android.util.Log.d("State", "setting depth func"); - sDepthFunc = mDepthFunc; - GLES30.glDepthFunc(sDepthFunc); + cState.depthFunc = mState.depthFunc; + GLES30.glDepthFunc(cState.depthFunc); } ///////////////////////////////////////////////////// // 4. Write to Depth buffer? - if( mDepthMask!=sDepthMask ) + if( mState.depthMask!=cState.depthMask ) { //android.util.Log.d("State", "setting depth mask"); - sDepthMask = mDepthMask; - GLES30.glDepthMask(sDepthMask==1); + cState.depthMask = mState.depthMask; + GLES30.glDepthMask(cState.depthMask==1); } ///////////////////////////////////////////////////// // 5. Enable Blending? - if( mBlend!=sBlend ) + if( mState.blend!=cState.blend ) { - sBlend = mBlend; + cState.blend = mState.blend; - if (sBlend == 0) + if (cState.blend == 0) { //android.util.Log.d("State", "disabling blending"); GLES30.glDisable(GLES30.GL_BLEND); @@ -345,21 +338,21 @@ class DistortedRenderState ///////////////////////////////////////////////////// // 6. Change Blend function? - if( mBlendSrc!=sBlendSrc || mBlendDst!=sBlendDst ) + if( mState.blendSrc!=cState.blendSrc || mState.blendDst!=cState.blendDst ) { //android.util.Log.d("State", "setting blend function"); - sBlendSrc = mBlendSrc; - sBlendDst = mBlendDst; - GLES30.glBlendFunc(sBlendSrc,sBlendDst); + cState.blendSrc = mState.blendSrc; + cState.blendDst = mState.blendDst; + GLES30.glBlendFunc(cState.blendSrc,cState.blendDst); } ///////////////////////////////////////////////////// // 7. Enable/Disable Stencil Test? - if( mStencilTest!=sStencilTest ) + if( mState.stencilTest!=cState.stencilTest ) { - sStencilTest = mStencilTest; + cState.stencilTest = mState.stencilTest; - if (sStencilTest == 0) + if (cState.stencilTest == 0) { //android.util.Log.d("State", "disabling stencil test"); GLES30.glDisable(GLES30.GL_STENCIL_TEST); @@ -373,33 +366,33 @@ class DistortedRenderState ///////////////////////////////////////////////////// // 8. Adjust Stencil function? - if( mStencilFuncFunc!=sStencilFuncFunc || mStencilFuncRef!=sStencilFuncRef || mStencilFuncMask!=sStencilFuncMask ) + if( mState.stencilFuncFunc!=cState.stencilFuncFunc || mState.stencilFuncRef!=cState.stencilFuncRef || mState.stencilFuncMask!=cState.stencilFuncMask ) { //android.util.Log.d("State", "setting stencil function"); - sStencilFuncFunc = mStencilFuncFunc; - sStencilFuncRef = mStencilFuncRef ; - sStencilFuncMask = mStencilFuncMask; - GLES30.glStencilFunc(sStencilFuncFunc,sStencilFuncRef,sStencilFuncMask); + cState.stencilFuncFunc = mState.stencilFuncFunc; + cState.stencilFuncRef = mState.stencilFuncRef ; + cState.stencilFuncMask = mState.stencilFuncMask; + GLES30.glStencilFunc(cState.stencilFuncFunc,cState.stencilFuncRef,cState.stencilFuncMask); } ///////////////////////////////////////////////////// // 9. Adjust Stencil operation? - if( mStencilOpSfail!=sStencilOpSfail || mStencilOpDpfail!=sStencilOpDpfail || mStencilOpDppass!=sStencilOpDppass ) + if( mState.stencilOpSfail!=cState.stencilOpSfail || mState.stencilOpDpfail!=cState.stencilOpDpfail || mState.stencilOpDppass!=cState.stencilOpDppass ) { //android.util.Log.d("State", "setting stencil op"); - sStencilOpSfail = mStencilOpSfail; - sStencilOpDpfail= mStencilOpDpfail; - sStencilOpDppass= mStencilOpDppass; - GLES30.glStencilOp(sStencilOpSfail,sStencilOpDpfail,sStencilOpDppass); + cState.stencilOpSfail = mState.stencilOpSfail; + cState.stencilOpDpfail= mState.stencilOpDpfail; + cState.stencilOpDppass= mState.stencilOpDppass; + GLES30.glStencilOp(cState.stencilOpSfail,cState.stencilOpDpfail,cState.stencilOpDppass); } ///////////////////////////////////////////////////// // 10. Write to Stencil buffer? - if( mStencilMask!=sStencilMask ) + if( mState.stencilMask!=cState.stencilMask ) { //android.util.Log.d("State", "setting stencil mask"); - sStencilMask = mStencilMask; - GLES30.glStencilMask(sStencilMask); + cState.stencilMask = mState.stencilMask; + GLES30.glStencilMask(cState.stencilMask); } ///////////////////////////////////////////////////// @@ -415,75 +408,75 @@ class DistortedRenderState 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); + mState.colorMaskR = (r ? 1:0); + mState.colorMaskG = (g ? 1:0); + mState.colorMaskB = (b ? 1:0); + mState.colorMaskA = (a ? 1:0); } /////////////////////////////////////////////////////////////////////////////////////////////////// void glDepthMask(boolean mask) { - mDepthMask = (mask ? 1:0); + mState.depthMask = (mask ? 1:0); } /////////////////////////////////////////////////////////////////////////////////////////////////// void glStencilMask(int mask) { - mStencilMask = mask; + mState.stencilMask = 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; + if( test==GLES30.GL_DEPTH_TEST ) mState.depthTest = 1; + else if( test==GLES30.GL_STENCIL_TEST ) mState.stencilTest = 1; + else if( test==GLES30.GL_BLEND ) mState.blend = 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; + if( test==GLES30.GL_DEPTH_TEST ) mState.depthTest = 0; + 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) { - mStencilFuncFunc = func; - mStencilFuncRef = ref; - mStencilFuncMask = mask; + mState.stencilFuncFunc = func; + mState.stencilFuncRef = ref; + mState.stencilFuncMask = mask; } /////////////////////////////////////////////////////////////////////////////////////////////////// void glStencilOp(int sfail, int dpfail, int dppass) { - mStencilOpSfail = sfail; - mStencilOpDpfail= dpfail; - mStencilOpDppass= dppass; + mState.stencilOpSfail = sfail; + mState.stencilOpDpfail= dpfail; + mState.stencilOpDppass= dppass; } /////////////////////////////////////////////////////////////////////////////////////////////////// void glDepthFunc(int func) { - mDepthFunc = func; + mState.depthFunc = func; } /////////////////////////////////////////////////////////////////////////////////////////////////// void glBlendFunc(int src, int dst) { - mBlendSrc = src; - mBlendDst = dst; + mState.blendSrc = src; + mState.blendDst = dst; } ///////////////////////////////////////////////////////////////////////////////////////////////////