bool initBlend()
{
glEnable(GL_SAMPLE_MASK);
glSampleMaski(0, 0xFF);
glEnablei(GL_BLEND, 0);
glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
glBlendEquationSeparatei(0, GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_ADD);
glBlendFuncSeparatei(0, GL_SRC_COLOR, GL_ONE, GL_ZERO, GL_ZERO);
glEnablei(GL_BLEND, 1);
glColorMaski(1, GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE);
glBlendEquationSeparatei(1, GL_FACTOR_MIN_AMD, GL_FUNC_ADD);
glBlendFuncSeparatei(1, GL_SRC_COLOR, GL_SRC_COLOR, GL_ZERO, GL_ZERO);
glEnablei(GL_BLEND, 2);
glColorMaski(2, GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE);
glBlendEquationSeparatei(2, GL_FACTOR_MAX_AMD, GL_FUNC_ADD);
glBlendFuncSeparatei(2, GL_SRC_COLOR, GL_SRC_COLOR, GL_ZERO, GL_ZERO);
glEnablei(GL_BLEND, 3);
glColorMaski(3, GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE);
glBlendEquationSeparatei(3, GL_FUNC_ADD, GL_FUNC_ADD);
glBlendFuncSeparatei(3, GL_SRC_COLOR, GL_SRC_COLOR, GL_ZERO, GL_ZERO);
return glf::checkError("initBlend");
}
static int BlendFunc(lua_State *L)
{
GLuint buf;
GLenum sfactor, dfactor, sfactorAlpha, dfactorAlpha;
if(lua_isinteger(L, 1))
{
buf = luaL_checkinteger(L, 1);
sfactor = checkblendfactor(L, 2);
dfactor = checkblendfactor(L, 3);
if(lua_isstring(L, 4))
{
sfactorAlpha = checkblendfactor(L, 4);
dfactorAlpha = checkblendfactor(L, 5);
glBlendFuncSeparatei(buf, sfactor, dfactor, sfactorAlpha, dfactorAlpha);
}
else
glBlendFunci(buf, sfactor, dfactor);
}
else
{
sfactor = checkblendfactor(L, 1);
dfactor = checkblendfactor(L, 2);
if(lua_isstring(L, 3))
{
sfactorAlpha = checkblendfactor(L, 3);
dfactorAlpha = checkblendfactor(L, 4);
glBlendFuncSeparate(sfactor, dfactor, sfactorAlpha, dfactorAlpha);
}
else
glBlendFunc(sfactor, dfactor);
}
CheckError(L);
return 0;
}
//! glBlendFuncSeparatei wrapper. May throw.
inline void blendFuncSeparatei(GLuint const buf,
GLenum const srcRgb,
GLenum const dstRgb,
GLenum const srcAlpha,
GLenum const dstAlpha) {
glBlendFuncSeparatei(buf, srcRgb, dstRgb, srcAlpha, dstAlpha);
checkError("glBlendFuncSeparatei");
}
void StateSystem::BlendState::applyGL() const
{
if (separateEnable){
for (GLuint i = 0; i < MAX_DRAWBUFFERS; i++){
if (isBitSet(separateEnable,i)) glEnablei(GL_BLEND,i);
else glDisablei(GL_BLEND,i);
}
}
if (useSeparate){
for (GLuint i = 0; i < MAX_DRAWBUFFERS; i++){
glBlendFuncSeparatei(i,blends[i].rgb.srcw,blends[i].rgb.dstw,blends[i].alpha.srcw,blends[i].alpha.dstw);
glBlendEquationSeparatei(i,blends[i].rgb.equ,blends[i].alpha.equ);
}
}
else{
glBlendFuncSeparate(blends[0].rgb.srcw,blends[0].rgb.dstw,blends[0].alpha.srcw,blends[0].alpha.dstw);
glBlendEquationSeparate(blends[0].rgb.equ,blends[0].alpha.equ);
}
//glBlendColor(color[0],color[1],color[2],color[3]);
}
int MFMat_Standard_Begin(MFMaterial *pMaterial, MFRendererState &state)
{
MFMat_Standard_Data *pData = (MFMat_Standard_Data*)pMaterial->pInstanceData;
MFEffectTechnique *pTechnique = NULL;
if(pData->pEffect)
pTechnique = MFEffect_GetTechnique(pData->pEffect, state);
MFDebug_Assert(pTechnique, "No technique!");
MFEffectData_OpenGL &techniqueData = *(MFEffectData_OpenGL*)pTechnique->pPlatformData;
if(pTechnique != state.pTechniqueSet)
{
state.pTechniqueSet = pTechnique;
glUseProgram(techniqueData.program);
// need to clear all the cache states
//... or ignore the state caching for now
}
// bools
/* do a bitscan loop over the bool states
uint32 boolState = state.bools & state.rsSet[MFSB_CT_Bool];
uint32 req = pTechnique->renderStateRequirements[MFSB_CT_Bool];
if(req)
{
uint32 vsReq = pVS->renderStateRequirements[MFSB_CT_Bool];
uint32 psReq = pPS->renderStateRequirements[MFSB_CT_Bool];
if((state.boolsSet & req) != (boolState & req))
{
BOOL bools[32];
for(uint32 i=0, b=1; i<MFSCB_Max; ++i, b<<=1)
bools[i] = (boolState & b) != 0;
if((state.boolsSet & vsReq) != (boolState & vsReq))
pd3dDevice->SetVertexShaderConstantB(0, bools, 32);
if((state.boolsSet & psReq) != (boolState & psReq))
pd3dDevice->SetPixelShaderConstantB(0, bools, 32);
}
}
*/
// matrices
uint32 req = pTechnique->renderStateRequirements[MFSB_CT_Matrix];
uint32 i;
while(MFUtil_BitScanReverse(req, &i))
{
uint32 b = MFBIT(i);
req ^= b;
// if(state.pMatrixStatesSet[i] != state.pMatrixStates[i])
{
MFMatrix *pM;
if(i > MFSCM_DerivedStart)
pM = state.getDerivedMatrix((MFStateConstant_Matrix)i);
else
pM = state.pMatrixStates[i];
// state.pMatrixStatesSet[i] = pM;
GLint uniform = techniqueData.uniformLocation[MFSB_CT_Matrix][i];
glUniformMatrix4fv(uniform, 1, GL_TRUE, (float*)pM);
}
}
// vectors
req = pTechnique->renderStateRequirements[MFSB_CT_Vector];
while(MFUtil_BitScanReverse(req, &i))
{
uint32 b = MFBIT(i);
req ^= b;
// if(state.pVectorStatesSet[i] != state.pVectorStates[i])
{
MFVector *pV = state.pVectorStates[i];
// state.pVectorStatesSet[i] = pV;
GLint uniform = techniqueData.uniformLocation[MFSB_CT_Vector][i];
glUniform4fv(uniform, 1, (float*)pV);
}
}
// textures
req = pTechnique->renderStateRequirements[MFSB_CT_Texture];
while(MFUtil_BitScanReverse(req, &i))
{
req ^= MFBIT(i);
MFTexture *pT = state.pTextures[i];
if(state.pTexturesSet[i] != pT)
{
state.pTexturesSet[i] = pT;
glActiveTexture(GL_TEXTURE0 + i);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, (GLuint)(size_t)pT->pInternalData);
}
/*
else
{
glActiveTexture(GL_TEXTURE0 + i);
glDisable(GL_TEXTURE_2D);
}
*/
MFSamplerState *pS = (MFSamplerState*)state.pRenderStates[MFSCRS_DiffuseSamplerState + i];
// if(state.pRenderStatesSet[MFSCRS_DiffuseSamplerState + i] != pS)
{
// state.pRenderStatesSet[MFSCRS_DiffuseSamplerState + i] = pS;
GLint uniform = techniqueData.uniformLocation[MFSB_CT_RenderState][MFSCRS_DiffuseSamplerState + i];
GLint sampler = (GLint)(size_t)pS->pPlatformData;
glUniform1i(uniform, i);
glBindSampler(i, sampler);
}
}
// blend state
MFBlendState *pBlendState = (MFBlendState*)state.pRenderStates[MFSCRS_BlendState];
if(state.pRenderStatesSet[MFSCRS_BlendState] != pBlendState)
{
state.pRenderStatesSet[MFSCRS_BlendState] = pBlendState;
if(pBlendState->stateDesc.bIndependentBlendEnable)
{
for(int j=0; j<8; ++j)
{
MFBlendStateDesc::RenderTargetBlendDesc &target = pBlendState->stateDesc.renderTarget[j];
if(target.bEnable)
{
glEnable(GL_BLEND);
glBlendEquationSeparatei(j, glBlendOp[target.blendOp], glBlendOp[target.blendOpAlpha]);
glBlendFuncSeparatei(j, glBlendArg[target.srcBlend], glBlendArg[target.destBlend], glBlendArg[target.srcBlendAlpha], glBlendArg[target.destBlendAlpha]);
}
else
glDisable(GL_BLEND);
glColorMaski(j, target.writeMask & MFColourWriteEnable_Red, target.writeMask & MFColourWriteEnable_Green, target.writeMask & MFColourWriteEnable_Blue, target.writeMask & MFColourWriteEnable_Alpha);
}
}
else
{
MFBlendStateDesc::RenderTargetBlendDesc &target = pBlendState->stateDesc.renderTarget[0];
if(target.bEnable)
{
glEnable(GL_BLEND);
glBlendEquationSeparate(glBlendOp[target.blendOp], glBlendOp[target.blendOpAlpha]);
glBlendFuncSeparate(glBlendArg[target.srcBlend], glBlendArg[target.destBlend], glBlendArg[target.srcBlendAlpha], glBlendArg[target.destBlendAlpha]);
}
else
glDisable(GL_BLEND);
glColorMask(target.writeMask & MFColourWriteEnable_Red, target.writeMask & MFColourWriteEnable_Green, target.writeMask & MFColourWriteEnable_Blue, target.writeMask & MFColourWriteEnable_Alpha);
}
}
// rasteriser state
MFRasteriserState *pRasteriserState = (MFRasteriserState*)state.pRenderStates[MFSCRS_RasteriserState];
if(state.pRenderStatesSet[MFSCRS_RasteriserState] != pRasteriserState)
{
state.pRenderStatesSet[MFSCRS_RasteriserState] = pRasteriserState;
switch(pRasteriserState->stateDesc.cullMode)
{
case MFCullMode_None:
glDisable(GL_CULL_FACE);
break;
case MFCullMode_CCW:
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
glCullFace(GL_BACK);
break;
case MFCullMode_CW:
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
break;
default:
MFUNREACHABLE;
}
}
// depth/stencil state
MFDepthStencilState *pDSState = (MFDepthStencilState*)state.pRenderStates[MFSCRS_DepthStencilState];
if(state.pRenderStatesSet[MFSCRS_DepthStencilState] != pDSState)
{
state.pRenderStatesSet[MFSCRS_DepthStencilState] = pDSState;
if(pDSState->stateDesc.bDepthEnable)
{
glEnable(GL_DEPTH_TEST);
glDepthFunc(glCompareFunc[pDSState->stateDesc.depthFunc]);
glDepthMask(pDSState->stateDesc.depthWriteMask == MFDepthWriteMask_Zero ? GL_FALSE : GL_TRUE);
}
else
glDisable(GL_DEPTH_TEST);
}
// setup alpha test
if(state.boolChanged(MFSCB_AlphaTest) || (state.pVectorStatesSet[MFSCV_RenderState] != state.pVectorStates[MFSCV_RenderState] && state.getBool(MFSCB_AlphaTest)))
{
MFVector *pRS = state.pVectorStates[MFSCV_RenderState];
state.pVectorStatesSet[MFSCV_RenderState] = pRS;
state.boolsSet = (state.boolsSet & ~MFBIT(MFSCB_AlphaTest)) | (state.bools & MFBIT(MFSCB_AlphaTest));
#if !defined(MF_OPENGL_ES)
if(state.getBool(MFSCB_AlphaTest))
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GEQUAL, pRS->x);
}
else
glDisable(GL_ALPHA_TEST);
#else
// TODO: do something here...
//I guess we need to implement the alpha test in the shader...
#endif
}
/*
// set clour/alpha scales
if(state.pVectorStatesSet[MFSCV_User0] != state.pVectorStates[MFSCV_User0])
{
MFVector *pMask = state.pVectorStates[MFSCV_User0];
state.pVectorStatesSet[MFSCV_User0] = pMask;
// pd3dDevice->SetVertexShaderConstantF(r_colourMask, (float*)pMask, 1);
}
*/
// set animation matrices
if(state.getBool(MFSCB_Animated))
{
MFDebug_Assert(false, "TODO!");
// for(uint32 b=0; b<state.matrixBatch.numMatrices; b++)
// MFRendererPC_SetAnimationMatrix(b, state.animation.pMatrices[state.matrixBatch.pIndices[b]]);
}
// set viewport
if(state.pViewportSet != state.pViewport)
{
if(!state.pViewport)
MFRenderer_ResetViewport();
else
MFRenderer_SetViewport(state.pViewport);
state.pViewportSet = state.pViewport;
}
MFCheckForOpenGLError(true);
// update the bools 'set' state
state.boolsSet = state.bools & state.rsSet[MFSB_CT_Bool];
return 0;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengles_GLES32_glBlendFuncSeparatei(JNIEnv *__env, jclass clazz, jint buf, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
glBlendFuncSeparateiPROC glBlendFuncSeparatei = (glBlendFuncSeparateiPROC)tlsGetFunction(332);
UNUSED_PARAM(clazz)
glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL40_nglBlendFuncSeparatei(JNIEnv *__env, jclass clazz, jint buf, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha, jlong __functionAddress) {
glBlendFuncSeparateiPROC glBlendFuncSeparatei = (glBlendFuncSeparateiPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
