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 BlendEquation(lua_State *L) { GLuint buf; GLenum mode, alpha; if(lua_isinteger(L, 1)) { buf = luaL_checkinteger(L, 1); mode = checkblendmode(L, 2); if(lua_isstring(L, 3)) { alpha = checkblendmode(L,3); glBlendEquationSeparatei(buf, mode, alpha); } else glBlendEquationi(buf, mode); } else { mode = checkblendmode(L, 1); if(lua_isstring(L, 2)) { alpha = checkblendmode(L,2); glBlendEquationSeparate(mode, alpha); } else glBlendEquation(mode); } CheckError(L); return 0; }
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_glBlendEquationSeparatei(JNIEnv *__env, jclass clazz, jint buf, jint modeRGB, jint modeAlpha) { glBlendEquationSeparateiPROC glBlendEquationSeparatei = (glBlendEquationSeparateiPROC)tlsGetFunction(330); UNUSED_PARAM(clazz) glBlendEquationSeparatei(buf, modeRGB, modeAlpha); }
//! glBlendEquationSeparatei wrapper. May throw. inline void blendEquationSeparatei(GLuint const buf, GLenum const mode_rgb, GLenum const mode_alpha) { glBlendEquationSeparatei(buf, mode_rgb, mode_alpha); checkError("glBlendEquationSeparatei"); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL40_nglBlendEquationSeparatei(JNIEnv *__env, jclass clazz, jint buf, jint modeRGB, jint modeAlpha, jlong __functionAddress) { glBlendEquationSeparateiPROC glBlendEquationSeparatei = (glBlendEquationSeparateiPROC)(intptr_t)__functionAddress; UNUSED_PARAMS(__env, clazz) glBlendEquationSeparatei(buf, modeRGB, modeAlpha); }