Esempio n. 1
0
void GPUChromaKeyFilter::applyOnGPU(GLTexturePtr pSrcTex)
{
    // Set up double-buffering
    int curBufferIndex = m_Erosion%2;
    getFBO(curBufferIndex)->activate();
    getShader()->activate();
    m_pTextureParam->set(0);

    float h, s, l;
    m_Color.toHSL(h, s, l);
    m_pHKeyParam->set(h);
    m_pHToleranceParam->set(m_HTolerance*360);
    m_pHSoftToleranceParam->set((m_HTolerance+m_Softness)*360.0f);
    m_pSKeyParam->set(s);
    m_pSToleranceParam->set(m_STolerance);
    m_pSSoftToleranceParam->set(m_STolerance+m_Softness);
    m_pLKeyParam->set(l);
    m_pLToleranceParam->set(m_LTolerance);
    m_pLSoftToleranceParam->set(m_LTolerance+m_Softness);
    m_pSpillThresholdParam->set(m_SpillThreshold*360);
    m_pIsLastParam->set(int(m_Erosion==0));
    draw(pSrcTex);

    for (int i = 0; i < m_Erosion; ++i) {
        curBufferIndex = (curBufferIndex+1)%2;
        getFBO(curBufferIndex)->activate();
        OGLShaderPtr pShader = avg::getShader(SHADERID_EROSION);
        pShader->activate();
        m_pErosionTextureParam->set(0);
        m_pErosionIsLastParam->set(int(i==m_Erosion-1));
        getDestTex((curBufferIndex+1)%2)->activate(GL_TEXTURE0);
        m_pProjection2->draw(avg::getShader(SHADERID_EROSION));
    }
}
Esempio n. 2
0
void IrrDriver::renderLightsScatter(unsigned pointlightcount)
{
    getFBO(FBO_HALF1).Bind();
    glClearColor(0., 0., 0., 0.);
    glClear(GL_COLOR_BUFFER_BIT);

    const Track * const track = World::getWorld()->getTrack();

    // This function is only called once per frame - thus no need for setters.
    float start = track->getFogStart() + .001;
    const video::SColor tmpcol = track->getFogColor();

    core::vector3df col(tmpcol.getRed() / 255.0f,
        tmpcol.getGreen() / 255.0f,
        tmpcol.getBlue() / 255.0f);

    glDisable(GL_DEPTH_TEST);
    glDepthMask(GL_FALSE);
    glEnable(GL_BLEND);
    glBlendEquation(GL_FUNC_ADD);
    glBlendFunc(GL_ONE, GL_ONE);

    FullScreenShader::FogShader::getInstance()->SetTextureUnits(irr_driver->getDepthStencilTexture());
    DrawFullScreenEffect<FullScreenShader::FogShader>(1.f / (40.f * start), col);

    glEnable(GL_DEPTH_TEST);
    core::vector3df col2(1., 1., 1.);

    glUseProgram(LightShader::PointLightScatterShader::getInstance()->Program);
    glBindVertexArray(LightShader::PointLightScatterShader::getInstance()->vao);

    LightShader::PointLightScatterShader::getInstance()->SetTextureUnits(irr_driver->getDepthStencilTexture());
    LightShader::PointLightScatterShader::getInstance()->setUniforms(1.f / (40.f * start), col2);

    glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, MIN2(pointlightcount, MAXLIGHT));

    glDisable(GL_BLEND);
    m_post_processing->renderGaussian6Blur(getFBO(FBO_HALF1), getFBO(FBO_HALF2), 5., 5.);
    glEnable(GL_BLEND);

    glDisable(GL_DEPTH_TEST);
    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
    getFBO(FBO_COLORS).Bind();
    m_post_processing->renderPassThrough(getRenderTargetTexture(RTT_HALF1));
}
void FBOSourceTextureFilter::updateOuputSlots(void)
{
    bool AttachedFiltersNeedUpdate(false);

    //Update the number of slots
    UInt8 NumSlots(0);
    if(getFBO() != NullFC)
    {
        NumSlots = getFBO()->getTextures().size();
    }

    if(NumSlots != getOutputSlots().size())
    {
        //Need to resize the number of slots
        getOutputSlots().resize(NumSlots);
    }

    UInt32 FormatClasses(OSG_TEXTURE_INTERNAL_FORMAT_NONE);
    UInt32 DataTypeClasses(OSG_TEXTURE_DATA_TYPE_NONE);
    //Update the definitions of each of the slots
    for(UInt8 i(0) ; i<NumSlots ; ++i)
    {
        FormatClasses = determinTextureFormatClasses(getFBO()->getTextures(i));
        DataTypeClasses = determinTextureDataTypeClasses(getFBO()->getTextures(i));

        //Update the Format Class
        if(FormatClasses != getOutputSlots(i).getTextureFormatClasses())
        {
            editOutputSlots(i).setTextureFormatClasses(FormatClasses);
        }

        //Update the Data Type Class
        if(DataTypeClasses != getOutputSlots(i).getTextureDataTypeClasses())
        {
            editOutputSlots(i).setTextureDataTypeClasses(DataTypeClasses);
        }

        //Update the Description
        //TODO: Implement
    }
}
Esempio n. 4
0
void GPUBlurFilter::applyOnGPU(GLContext* pContext, GLTexturePtr pSrcTex)
{
    int kernelWidth = m_pGaussCurveTex->getSize().x;
    getFBO(pContext, 1)->activate();
    getShader()->activate();
    m_pHorizWidthParam->set(pContext, float(kernelWidth));
    m_pHorizRadiusParam->set(pContext, (kernelWidth-1)/2);
    m_pHorizTextureParam->set(pContext, 0);
    m_pHorizKernelTexParam->set(pContext, 1);
    m_pGaussCurveTex->getTex(pContext)->activate(WrapMode(), GL_TEXTURE1);
    draw(pContext, pSrcTex, m_WrapMode);

    getFBO(pContext, 0)->activate();
    OGLShaderPtr pVShader = avg::getShader(SHADERID_VERT);
    pVShader->activate();
    m_pVertWidthParam->set(pContext, float(kernelWidth));
    m_pVertRadiusParam->set(pContext, (kernelWidth-1)/2);
    m_pVertTextureParam->set(pContext, 0);
    m_pVertKernelTexParam->set(pContext, 1);
    getDestTex(pContext, 1)->activate(m_WrapMode, GL_TEXTURE0);
    m_pProjection2->draw(pContext, pVShader);
}
Esempio n. 5
0
void GPUBlurFilter::applyOnGPU(GLTexturePtr pSrcTex)
{
    int kernelWidth = m_pGaussCurveTex->getSize().x;
    getFBO(1)->activate();
    getShader()->activate();
    m_pHorizWidthParam->set(float(kernelWidth));
    m_pHorizRadiusParam->set((kernelWidth-1)/2);
    m_pHorizTextureParam->set(0);
    m_pHorizKernelTexParam->set(1);
    m_pGaussCurveTex->activate(GL_TEXTURE1);
    draw(pSrcTex);

    getFBO(0)->activate();
    OGLShaderPtr pVShader = avg::getShader(SHADERID_VERT);
    pVShader->activate();
    m_pVertWidthParam->set(float(kernelWidth));
    m_pVertRadiusParam->set((kernelWidth-1)/2);
    m_pVertTextureParam->set(0);
    m_pVertKernelTexParam->set(1);
    getDestTex(1)->activate(GL_TEXTURE0);
    m_pProjection2->draw(pVShader);
}
Esempio n. 6
0
void GPUBandpassFilter::applyOnGPU(GLTexturePtr pSrcTex)
{
    m_MinFilter.apply(pSrcTex);
    m_MaxFilter.apply(pSrcTex);

    getFBO()->activate();
    getShader()->activate();
    m_pMinTexParam->set(0);
    m_pMaxTexParam->set(1);
    m_pPostScaleParam->set(float(m_PostScale));
    m_pInvertParam->set(m_bInvert);
    m_MaxFilter.getDestTex()->activate(GL_TEXTURE1);
    draw(m_MinFilter.getDestTex());
}
Esempio n. 7
0
bool GLResource::black( Frame *dst )
{
	int w = dst->profile.getVideoWidth();
	int h = dst->profile.getVideoHeight();

	FBO *fbo = getFBO( w, h, GL_RGBA );
	if ( !fbo )
		return false;

	glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo() );
	glClear( GL_COLOR_BUFFER_BIT );
	glBindFramebuffer( GL_FRAMEBUFFER, 0 );

	dst->setFBO( fbo );
	return true;
}
void RenderingEffects::attachAllEffects()
{
    backdropFX::Manager& mgr = *( backdropFX::Manager::instance() );
    EffectVector& ev = getEffectVector();

    EffectVector::iterator it, prevIt( ev.end() );
    for( it = ev.begin(); it != ev.end(); it++ )
    {
        if( it == ev.begin() )
        {
            // First Effect.
            (*it)->addInput( 0, mgr.getColorBufferA() );
        }
        else
        {
            (*prevIt)->attachOutputTo( (*it).get(), 0 );
        }
        prevIt = it;
    }

    if( prevIt != ev.end() )
        (*prevIt)->setOutput( getFBO() );
}
void FBOSourceTextureFilter::internalUpdate(RenderActionBase *action, const Vec2f& DrawnSize)
{
    Vec2f NewFBOSize(getFBOSize());
    ImagePtr TheImage(getFBO()->getTextures(0)->getImage());
    if(getFBOSize().x() < 0.0f)
    {
        NewFBOSize[0] = DrawnSize.x();
    }
    if(getFBOSize().y() < 0.0f)
    {
        NewFBOSize[1] = DrawnSize.y();
    }
    if(Vec2f(TheImage->getWidth(), TheImage->getHeight()) != NewFBOSize)
    {
        //If the size of the FBO Texture has changed then update it
        for( unsigned int nt = 0; nt < getFBO()->getTextures().getSize(); ++ nt )
        {
            osg::TextureChunkPtr tex = getFBO()->getTextures()[nt];
            beginEditCP (tex);
                beginEditCP(tex->getImage());
                    tex->getImage()->set(tex->getImage()->getPixelFormat(),NewFBOSize.x(), NewFBOSize.y(),
                                         tex->getImage()->getDepth(), tex->getImage()->getMipMapCount(),
                                         tex->getImage()->getFrameCount(),tex->getImage()->getFrameDelay(),
                                         NULL,tex->getImage()->getDataType());
                endEditCP(tex->getImage());
            endEditCP (tex);
        }

        beginEditCP(getFBO(), FBOViewport::DirtyFieldMask | FBOViewport::LeftFieldMask | FBOViewport::RightFieldMask | FBOViewport::BottomFieldMask | FBOViewport::TopFieldMask | FBOViewport::StorageHeightFieldMask | FBOViewport::StorageWidthFieldMask);
            getFBO()->setSize(0,0,NewFBOSize.x()-1, NewFBOSize.y()-1);
            
            getFBO()->setStorageWidth(NewFBOSize.x());
            getFBO()->setStorageHeight(NewFBOSize.y());
            getFBO()->setDirty(true);

        endEditCP(getFBO(), FBOViewport::DirtyFieldMask | FBOViewport::LeftFieldMask | FBOViewport::RightFieldMask | FBOViewport::BottomFieldMask | FBOViewport::TopFieldMask | FBOViewport::StorageHeightFieldMask | FBOViewport::StorageWidthFieldMask);
    }

    //Update the parent wintow of the FBO
    WindowPtr ParentWin(action->getWindow());
    if(getFBO()->getParent() != ParentWin)
    {
        beginEditCP(getFBO(), FBOViewport::ParentFieldMask);
            getFBO()->setParent(ParentWin);
        endEditCP(getFBO(), FBOViewport::ParentFieldMask);
    }

    getFBO()->render(action);
}
TextureChunkPtr FBOSourceTextureFilter::pullTexture(UInt8 OutputSlot) const
{
    return getFBO()->getTextures(OutputSlot);
}
Esempio n. 11
0
BitmapPtr GPURGB2YUVFilter::getResults()
{
    BitmapPtr pBmp = getFBO()->getImage();

    return pBmp;
}