void LLRender::blendFunc(eBlendFactor color_sfactor, eBlendFactor color_dfactor, eBlendFactor alpha_sfactor, eBlendFactor alpha_dfactor) { llassert(color_sfactor < BF_UNDEF); llassert(color_dfactor < BF_UNDEF); llassert(alpha_sfactor < BF_UNDEF); llassert(alpha_dfactor < BF_UNDEF); if (!gGLManager.mHasBlendFuncSeparate) { LL_WARNS_ONCE("render") << "no glBlendFuncSeparateEXT(), using color-only blend func" << llendl; blendFunc(color_sfactor, color_dfactor); return; } if (mCurrBlendColorSFactor != color_sfactor || mCurrBlendColorDFactor != color_dfactor || mCurrBlendAlphaSFactor != alpha_sfactor || mCurrBlendAlphaDFactor != alpha_dfactor) { mCurrBlendColorSFactor = color_sfactor; mCurrBlendAlphaSFactor = alpha_sfactor; mCurrBlendColorDFactor = color_dfactor; mCurrBlendAlphaDFactor = alpha_dfactor; flush(); glBlendFuncSeparateEXT(sGLBlendFactor[color_sfactor], sGLBlendFactor[color_dfactor], sGLBlendFactor[alpha_sfactor], sGLBlendFactor[alpha_dfactor]); } }
void RenderTarget::applyBlendMode(BlendMode mode) { switch (mode) { // Alpha blending // glBlendFuncSeparateEXT is used when available to avoid an incorrect alpha value when the target // is a RenderTexture -- in this case the alpha value must be written directly to the target buffer default : case BlendAlpha : if (GLEW_EXT_blend_func_separate) glCheck(glBlendFuncSeparateEXT(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA)); else glCheck(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); break; // Additive blending case BlendAdd : glCheck(glBlendFunc(GL_SRC_ALPHA, GL_ONE)); break; // Multiplicative blending case BlendMultiply : glCheck(glBlendFunc(GL_DST_COLOR, GL_ZERO)); break; // No blending case BlendNone : glCheck(glBlendFunc(GL_ONE, GL_ZERO)); break; } m_cache.lastBlendMode = mode; }
//----------------------------------------------------------------------------// void OpenGLRenderer::setupRenderingBlendMode(const BlendMode mode, const bool force) { // exit if mode is already set up (and update not forced) if ((d_activeBlendMode == mode) && !force) return; d_activeBlendMode = mode; if (d_activeBlendMode == BM_RTT_PREMULTIPLIED) { glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); } else { if (GLEW_VERSION_1_4) glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_ONE); else if (GLEW_EXT_blend_func_separate) glBlendFuncSeparateEXT(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_ONE); else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } }
inline void VL_glBlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { if (glBlendFuncSeparate) glBlendFuncSeparate( srcRGB, dstRGB, srcAlpha, dstAlpha); else if (glBlendFuncSeparateEXT) glBlendFuncSeparateEXT( srcRGB, dstRGB, srcAlpha, dstAlpha); else VL_UNSUPPORTED_FUNC(); }
bool RawVolumeModelRenderer::render( const eq::Range& range, const eq::Matrix4d& modelviewM, const eq::Matrix4f& invRotationM, const eq::Vector4f& taintColor, const int normalsQuality ) { VolumeInfo volumeInfo; if( !_rawModel.getVolumeInfo( volumeInfo, range )) { LBERROR << "Can't get volume data" << std::endl; return false; } glScalef( volumeInfo.volScaling.W, volumeInfo.volScaling.H, volumeInfo.volScaling.D ); // Enable shaders glUseProgramObjectARB( _shaders.getProgram( )); // Calculate and put necessary data to shaders const uint32_t resolution = _rawModel.getResolution(); const double sliceDistance = 3.6 / ( resolution * _precision ); _putVolumeDataToShader( volumeInfo, float( sliceDistance ), invRotationM, taintColor, normalsQuality ); _sliceClipper.updatePerFrameInfo( modelviewM, sliceDistance, range ); //Render slices glEnable( GL_BLEND ); glBlendFuncSeparateEXT( GL_ONE, GL_SRC_ALPHA, GL_ZERO, GL_SRC_ALPHA ); renderSlices( _sliceClipper ); glDisable( GL_BLEND ); // Disable shader glUseProgramObjectARB( 0 ); return true; }
void Renderer::SetBlendMode(Blend::Mode mode) { if ((mode != myBlendMode) || !myBlendModeIsValid) { // Apply the new blending mode if (mode == Blend::None) { GLCheck(glDisable(GL_BLEND)); } else { GLCheck(glEnable(GL_BLEND)); switch (mode) { // Alpha blending // glBlendFuncSeparateEXT is used when available to avoid an incorrect alpha value when the target // is a RenderImage -- in this case the alpha value must be written directly to the target buffer default : case Blend::Alpha : if (GLEW_EXT_blend_func_separate) GLCheck(glBlendFuncSeparateEXT(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA)); else GLCheck(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); break; // Additive blending case Blend::Add : GLCheck(glBlendFunc(GL_SRC_ALPHA, GL_ONE)); break; // Multiplicative blending case Blend::Multiply : GLCheck(glBlendFunc(GL_DST_COLOR, GL_ZERO)); break; } } // Store it myBlendMode = mode; myBlendModeIsValid = true; } }