Ejemplo n.º 1
0
void ComputeShaderChunk::activate(DrawEnv    *pEnv,              
                                  UInt32      uiIdx)
{
    Window *pWin    = pEnv->getWindow();

    UInt32 uiValRes = pWin->validateGLObject(getGLId(), 
                                             pEnv, 
                                             KeepProgActive);    

    GLuint uiProgId = GLuint(pWin->getGLObjectId(getGLId()));

    if(uiProgId == 0)
        return;

    pEnv->setActiveShader(uiProgId);

    if(0x0000 == (uiValRes & ProgActive))
    {
        OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
                                osgGlUseProgram,
                                ShaderProgram::getFuncIdUseProgram(),
                                pWin);

        osgGlUseProgram(uiProgId);
    }

    pEnv->incNumShaderChanges();
        
    updateProceduralVariables(pEnv, ShaderProcVariable::SHDAll);

}
Ejemplo n.º 2
0
void ComputeShaderChunk::changeFrom(DrawEnv    *pEnv, 
                                    StateChunk *pOther, 
                                    UInt32      uiIdx)
{
    ComputeShaderChunk *pOld = dynamic_cast<ComputeShaderChunk *>(pOther);

    // pOther can be a ShaderExecutableChunk, since we share the StateClass id
    // with it
    if(pOld != NULL)
    {
        Window   *pWin     = pEnv->getWindow();
        GLuint    uiProgId = GLuint(pWin->getGLObjectId(getGLId()));

        UInt32 uiDep = ShaderProcVariable::SHDObject;

        if(uiProgId != pEnv->getActiveShader())
        {
            UInt32 uiValRes = pWin->validateGLObject(getGLId(),
                                                     pEnv,
                                                     KeepProgActive);

            uiProgId = GLuint(pWin->getGLObjectId(getGLId()));

            if(uiProgId == 0)
                return;

            pEnv->setActiveShader(uiProgId);

            if(0x0000 == (uiValRes & ProgActive))
            {
                OSGGETGLFUNCBYID_GL3_ES(glUseProgram,
                                        osgGlUseProgram,
                                        ShaderProgram::getFuncIdUseProgram(),
                                        pWin);

                osgGlUseProgram(uiProgId);
            }

            uiDep = ShaderProcVariable::SHDAll;

            pEnv->incNumShaderChanges();
        }

        updateProceduralVariables(pEnv, uiDep);
    }
    else
    {
        pOther->deactivate(pEnv, uiIdx);
        activate          (pEnv, uiIdx);

        pEnv->incNumShaderChanges();
    }
}
void ShaderExecutableChunk::changeFrom(DrawEnv    *pEnv, 
                                       StateChunk *pOther, 
                                       UInt32      uiIdx)
{
    ShaderExecutableChunk *pOld = dynamic_cast<ShaderExecutableChunk *>(pOther);

    Window   *pWin     = pEnv->getWindow();
    GLuint    uiProgId = GLuint(pWin->getGLObjectId(getGLId()));

    UInt32 uiDep = ShaderProcVariable::SHDObject;

    if(uiProgId != pEnv->getActiveShader())
    {
#if 0
        FragmentShaderIt fIt  = _mfFragmentShader.begin();
        FragmentShaderIt fEnd = _mfFragmentShader.end  ();

        for(; fIt != fEnd; ++fIt)
        {
            (*fIt)->validate(pEnv);
        }

        GeometryShaderIt gIt  = _mfGeometryShader.begin();
        GeometryShaderIt gEnd = _mfGeometryShader.end  ();
        
        for(; gIt != gEnd; ++gIt)
        {
            (*gIt)->validate(pEnv);
        }
        
        VertexShaderIt vIt  = _mfVertexShader.begin();
        VertexShaderIt vEnd = _mfVertexShader.end  ();
        
        for(; vIt != vEnd; ++vIt)
        {
            (*vIt)->validate(pEnv);
        }
#endif

        UInt32 uiValRes = pWin->validateGLObject(getGLId(), 
                                                 pEnv, 
                                                 KeepProgActive);


        if(uiProgId == 0)
            return;

        if(0x0000 == (uiValRes & ProgActive))
        {
            OSGGETGLFUNC(OSGglUseProgramProc,
                         osgGlUseProgram,
                         ShaderProgram::getFuncIdUseProgram());

            pEnv->setActiveShader(uiProgId);
            osgGlUseProgram      (uiProgId);

            if(_mfAttributes.size() == 0)
            {
                pEnv->addRequiredOGLFeature(HardwareContext::HasAttribAliasing);
            }
        }

        if(_sfPointSize.getValue() == true)
        {
            if(pOld->getPointSize() == false)
            {
                glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
            }
        }
        else
        {
            if(pOld->getPointSize() == true)
            {
                glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
            }
        }

        uiDep = ShaderProcVariable::SHDAll;
    }

    updateProceduralVariables(pEnv, uiDep);
}