ShaderMan.cpp

Go to the documentation of this file.

//  File:       ShaderMan.cpp
//  Author:     Changchang Wu
//  Description :   implementation of the ShaderMan class.
//              A Shader Manager that calls different implementation of shaders
//
//
//  Copyright (c) 2007 University of North Carolina at Chapel Hill
//  All Rights Reserved
//
//  Permission to use, copy, modify and distribute this software and its
//  documentation for educational, research and non-profit purposes, without
//  fee, and without a written agreement is hereby granted, provided that the
//  above copyright notice and the following paragraph appear in all copies.
//  
//  The University of North Carolina at Chapel Hill make no representations
//  about the suitability of this software for any purpose. It is provided
//  'as is' without express or implied warranty. 
//
//  Please send BUG REPORTS to ccwu@cs.unc.edu
//
 
 
#include "GL/glew.h"
#include <vector>
#include <iostream>
#include <stdlib.h>
#include <math.h>
using std::vector;
using std::ostream;
using std::endl;
 
 
#include "ProgramGLSL.h"
#include "GlobalUtil.h"
#include "GLTexImage.h"
#include "SiftGPU.h"
#include "ShaderMan.h"
 
ShaderBag   * ShaderMan::s_bag = NULL;
 
// Construction/Destruction
 
void ShaderMan::InitShaderMan(SiftParam&param)
{
    if(s_bag) return;
 
    if(GlobalUtil::_usePackedTex )  s_bag = new ShaderBagPKSL;
    else                            s_bag =new ShaderBagGLSL;   
 
    GlobalUtil::StartTimer("Load Programs");
    s_bag->LoadFixedShaders();
    s_bag->LoadDynamicShaders(param);
    if(GlobalUtil::_UseSiftGPUEX)   s_bag->LoadDisplayShaders();
    GlobalUtil::StopTimer();
 
    GlobalUtil::CheckErrorsGL("InitShaderMan");
}
 
 
void ShaderMan::DestroyShaders()
{
    if(s_bag) delete s_bag;
    s_bag   =   NULL; 
}
 
void ShaderMan::UnloadProgram()
{
    if(s_bag) s_bag->UnloadProgram();
}
 
void ShaderMan::FilterImage(FilterProgram* filter, GLTexImage *dst, GLTexImage *src, GLTexImage*tmp)
{
    if(filter == NULL) return; 
 
    src->FillMargin(filter->_size, 0);
 
    //output parameter
    if(tmp) tmp->AttachToFBO(0);
    else dst->AttachToFBO(0);
 
 
    //input parameter
    src->BindTex();
    dst->FitTexViewPort();
 
    //horizontal filter
    filter->s_shader_h->UseProgram();
    dst->DrawQuad();
 
    //parameters
    if(tmp)
    {
        // fill margin for out-of-boundary lookup
        tmp->DetachFBO(0);
        tmp->AttachToFBO(0);
        tmp->FillMargin(0, filter->_size);
        tmp->DetachFBO(0);
        dst->AttachToFBO(0);
        tmp->BindTex();
    }
    else
    {
        glFinish();
        // fill margin for out-of-boundary lookup
        dst->FillMargin(0, filter->_size);
        dst->BindTex();
    }
 
    //vertical filter
    filter->s_shader_v->UseProgram();
    dst->DrawQuad();
 
 
    //clean up
    dst->UnbindTex();
    dst->DetachFBO(0);
 
    //
    ShaderMan::UnloadProgram();
}
 
 
void ShaderMan::FilterInitialImage(GLTexImage* tex, GLTexImage* buf)
{
    if(s_bag->f_gaussian_skip0) FilterImage(s_bag->f_gaussian_skip0, tex, tex, buf);
}
 
void ShaderMan::FilterSampledImage(GLTexImage* tex, GLTexImage* buf)
{
    if(s_bag->f_gaussian_skip1) FilterImage(s_bag->f_gaussian_skip1, tex, tex, buf);
}
 
void ShaderMan::TextureCopy(GLTexImage*dst, GLTexImage*src)
{
 
    dst->AttachToFBO(0);
 
    src->BindTex();
 
    dst->FitTexViewPort();
 
    dst->DrawQuad();
 
    dst->UnbindTex();
//  ShaderMan::UnloadProgram();
    dst->DetachFBO(0);
    return;
}
void ShaderMan::TextureDownSample(GLTexImage *dst, GLTexImage *src, int scale)
{
    //output parameter
    
    dst->AttachToFBO(0);
 
    //input parameter
    src->BindTex();
 
    //
    dst->FitTexViewPort();
 
    s_bag->s_sampling->UseProgram();
 
    dst->DrawQuadDS(scale);
    src->UnbindTex();
 
    UnloadProgram();
 
    dst->DetachFBO(0); 
}
 
void ShaderMan::TextureUpSample(GLTexImage *dst, GLTexImage *src, int scale)
{
 
    //output parameter
    dst->AttachToFBO(0);
    //input parameter
    src->BindTex();
 
    dst->FitTexViewPort();
 
    GlobalUtil::SetTextureParameterUS();
 
    if(GlobalUtil::_usePackedTex)
    {
        s_bag->s_sampling->UseProgram();
    }
 
    dst->DrawQuadUS(scale);
    src->UnbindTex();
 
    UnloadProgram();
 
    dst->DetachFBO(0);
 
    GlobalUtil::SetTextureParameter();
}
 
 
 
void ShaderMan::UseShaderDisplayGaussian()
{
    if(s_bag && s_bag->s_display_gaussian) s_bag->s_display_gaussian->UseProgram();
}
 
void ShaderMan::UseShaderDisplayDOG()
{
    if(s_bag && s_bag->s_display_dog) s_bag->s_display_dog->UseProgram();
}
 
 
 
void ShaderMan::UseShaderRGB2Gray()
{
    if(s_bag && s_bag->s_gray)s_bag->s_gray->UseProgram();
}
 
 
void ShaderMan::UseShaderDisplayGrad()
{
    if(s_bag && s_bag->s_display_grad) s_bag->s_display_grad->UseProgram();
}
 
 
void ShaderMan::UseShaderDisplayKeypoints()
{
    if(s_bag && s_bag->s_display_keys) s_bag->s_display_keys->UseProgram();
}
 
 
 
 
 
void ShaderMan::UseShaderGradientPass(int texP)
{
    s_bag->s_grad_pass->UseProgram();
    s_bag->SetGradPassParam(texP);  
}
 
 
void ShaderMan::UseShaderKeypoint(int texU, int texD)
{
    s_bag->s_keypoint->UseProgram();
    s_bag->SetDogTexParam(texU, texD);
}
 
 
 
void ShaderMan::UseShaderGenListInit(int w, int h, int tight)
{
    if(tight)
    {
        s_bag->s_genlist_init_tight->UseProgram();
    }else
    {
        s_bag->s_genlist_init_ex->UseProgram();
        s_bag->SetGenListInitParam(w, h);
    }
}
 
void ShaderMan::UseShaderGenListHisto()
{
    s_bag->s_genlist_histo->UseProgram();
 
}
 
 
 
 
void ShaderMan::UseShaderGenListStart(float fw, int tex0)
{
    s_bag->s_genlist_start->UseProgram();
    s_bag->SetGenListStartParam(fw, tex0);
}
 
void ShaderMan::UseShaderGenListStep(int tex, int tex0)
{
    s_bag->s_genlist_step->UseProgram();
    s_bag->SetGenListStepParam( tex,  tex0);
}
 
void ShaderMan::UseShaderGenListEnd(int ktex)
{
    s_bag->s_genlist_end->UseProgram();
    s_bag->SetGenListEndParam(ktex);
}
 
void ShaderMan::UseShaderDebug()
{
    if(s_bag->s_debug)  s_bag->s_debug->UseProgram();
}
 
void ShaderMan::UseShaderZeroPass()
{
    if(s_bag->s_zero_pass) s_bag->s_zero_pass->UseProgram();
}
 
void ShaderMan::UseShaderGenVBO( float width, float fwidth, float size)
{
    s_bag->s_vertex_list->UseProgram();
    s_bag->SetGenVBOParam(width, fwidth, size);
}
void ShaderMan::UseShaderMarginCopy(int xmax, int ymax)
{
    s_bag->s_margin_copy->UseProgram();
    s_bag->SetMarginCopyParam(xmax, ymax);
    
}
void ShaderMan::UseShaderCopyKeypoint()
{
    s_bag->s_copy_key->UseProgram();
}
 
void ShaderMan::UseShaderSimpleOrientation(int oTex, float sigma, float sigma_step)
{
    s_bag->s_orientation->UseProgram();
    s_bag->SetSimpleOrientationInput(oTex, sigma, sigma_step);
}
 
 
 
void ShaderMan::UseShaderOrientation(int gtex, int width, int height, float sigma, int auxtex, float step, int keypoint_list)
{
    s_bag->s_orientation->UseProgram();
 
    //changes in v345. 
    //set sigma to 0 to identify keypoit list mode
    //set sigma to negative to identify fixed_orientation
    if(keypoint_list) sigma = 0.0f;
    else if(GlobalUtil::_FixedOrientation) sigma = - sigma;
 
    s_bag->SetFeatureOrientationParam(gtex, width, height, sigma, auxtex, step);
}
 
void ShaderMan::UseShaderDescriptor(int gtex, int otex, int dwidth, int fwidth,  int width, int height, float sigma)
{
    s_bag->s_descriptor_fp->UseProgram();
    s_bag->SetFeatureDescirptorParam(gtex, otex, (float)dwidth,  (float)fwidth, (float)width, (float)height, sigma);
}
 
void ShaderMan::SelectInitialSmoothingFilter(int octave_min, SiftParam&param)
{
    s_bag->SelectInitialSmoothingFilter(octave_min, param);
}