include/colmap/lib/SiftGPU/ProgramGLSL.h

////////////////////////////////////////////////////////////////////////////
//	File:		ProgramGLSL.h
//	Author:		Changchang Wu
//	Description : Interface for ProgramGLSL classes
//		ProgramGLSL:	Glsl Program
//		FilterGLSL:		Glsl Gaussian Filters
//		ShaderBag:	    base class of ShaderBagPKSL and ShaderBagGLSL
//
//	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
//
////////////////////////////////////////////////////////////////////////////


#ifndef _PROGRAM_GLSL_H
#define _PROGRAM_GLSL_H


#include "ProgramGPU.h"

class ProgramGLSL:public ProgramGPU
{
	class ShaderObject
	{
		GLuint		_shaderID;
		int			_type;
		int			_compiled;
		static int ReadShaderFile(const char * source,  char *& code);
		void CheckCompileLog();
	public:
		void PrintCompileLog(ostream & os  );
		int inline IsValidShaderObject(){	return _shaderID && _compiled;}
		int IsValidVertexShader();
		int IsValidFragmentShader();
		GLuint GetShaderID(){return _shaderID;}
		~ShaderObject();
		ShaderObject(int shadertype,  const char * source, int filesource =0);
	};

protected:
	int			_linked;
	GLint		_TextureParam0;
	GLuint		_programID;
private:
	void AttachShaderObject(ShaderObject& shader);
	void DetachShaderObject(ShaderObject& shader);

public:
	void ReLink();
	int IsNative();
	int	UseProgram();
	void PrintLinkLog(std::ostream&os);
	int ValidateProgram();
	void CheckLinkLog();
	int LinkProgram();
	operator GLuint (){return _programID;}
    virtual void * GetProgramID() { return (void*) _programID; }
public:
	ProgramGLSL();
	~ProgramGLSL();
	ProgramGLSL(const char* frag_source);
};


class GLTexImage;
class FilterGLSL : public FilterProgram
{
private:
	ProgramGPU* CreateFilterH(float kernel[], int width);
	ProgramGPU* CreateFilterV(float kernel[], int height);
	ProgramGPU* CreateFilterHPK(float kernel[], int width);
	ProgramGPU* CreateFilterVPK(float kernel[], int height);
public:
    void MakeFilterProgram(float kernel[],  int width);
public:
    FilterGLSL(float sigma) ;
};

class SiftParam;

/////////////////////////////////////////////////////////////////////////////////
//class ShaderBag
//desciption:	pure virtual class
//				provides storage and usage interface of all the shaders for SIFT
//				two implementations are  ShaderBagPKSL and ShaderBagGLSL
/////////////////////////////////////////////////////////////////////////////////
class ShaderBag
{
public:
	//shader:	rgb to gray
	ProgramGPU  * s_gray;
	//shader:	copy keypoint to PBO
	ProgramGPU  * s_copy_key;
	//shader:	debug view
	ProgramGPU  * s_debug;
	//shader:	orientation
	//shader:	assign simple orientation to keypoints if hardware is low
	ProgramGPU  * s_orientation;
	//shader:	display gaussian levels
	ProgramGPU  * s_display_gaussian;
	//shader:	display difference of gassian
	ProgramGPU  * s_display_dog;
	//shader:	display  gradient
	ProgramGPU  * s_display_grad;
	//shader:	display keypoints as red(maximum) and blue (minimum)
	ProgramGPU  * s_display_keys;
	//shader:	up/down-sample
	ProgramGPU  * s_sampling;
	//shader:	compute gradient/dog
	ProgramGPU  * s_grad_pass;
	ProgramGPU  * s_dog_pass;
	//shader:   keypoint detection in one pass
	ProgramGPU  * s_keypoint;
	ProgramGPU  * s_seperate_sp;
	//shader:   feature list generations..
	ProgramGPU	* s_genlist_init_tight;
	ProgramGPU	* s_genlist_init_ex;
	ProgramGPU	* s_genlist_histo;
	ProgramGPU	* s_genlist_start;
	ProgramGPU	* s_genlist_step;
	ProgramGPU	* s_genlist_end;
	ProgramGPU	* s_zero_pass;
	//shader:	generate vertex to display SIFT as a square
	ProgramGPU  * s_vertex_list;
	//shader:	descriptor
	ProgramGPU  * s_descriptor_fp;
	//shader:	copy pixels to margin
	ProgramGPU	* s_margin_copy;
public:
	FilterProgram  *         f_gaussian_skip0;
	vector<FilterProgram*>   f_gaussian_skip0_v;
	FilterProgram  *         f_gaussian_skip1;
	FilterProgram  **        f_gaussian_step;
    int                     _gaussian_step_num;
public:
	virtual void SetGenListInitParam(int w, int h){};
	virtual void SetGenListEndParam(int ktex){};
	virtual void SetMarginCopyParam(int xmax, int ymax){};
	virtual void LoadDescriptorShader(){};
	virtual void SetFeatureDescirptorParam(int gtex, int otex, float dwidth, float fwidth, float width, float height, float sigma){};
	virtual void SetFeatureOrientationParam(int gtex, int width, int height, float sigma, int stex, float step){};
	virtual void SetSimpleOrientationInput(int oTex, float sigma, float sigma_step){};
	virtual void LoadOrientationShader() =0;
	virtual void SetGenListStartParam(float width, int tex0) =0;
	virtual void LoadGenListShader(int ndoglev, int nlev)=0;
	virtual void UnloadProgram()=0;
	virtual void LoadKeypointShader(float threshold, float edgeTrheshold) = 0;
	virtual void LoadFixedShaders()=0;
	virtual void LoadDisplayShaders() = 0;
	virtual void SetDogTexParam(int texU, int texD)=0;
	virtual void SetGradPassParam(int texP=0){}
	virtual void SetGenListStepParam(int tex, int tex0) = 0;
	virtual void SetGenVBOParam( float width, float fwidth, float size)=0;
public:
    void CreateGaussianFilters(SiftParam&param);
    void SelectInitialSmoothingFilter(int octave_min, SiftParam&param);
    void LoadDynamicShaders(SiftParam& param);
	ShaderBag();
	virtual ~ShaderBag();
};


class ShaderBagGLSL:public ShaderBag
{
	GLint _param_dog_texu;
	GLint _param_dog_texd;
	GLint _param_ftex_width;
	GLint _param_genlist_start_tex0;
	GLint _param_genlist_step_tex0;
	GLint _param_genvbo_size;
	GLint _param_orientation_gtex;
	GLint _param_orientation_size;
	GLint _param_orientation_stex;
	GLint _param_margin_copy_truncate;
	GLint _param_genlist_init_bbox;
	GLint _param_descriptor_gtex;
	GLint _param_descriptor_size;
	GLint _param_descriptor_dsize;
public:
	virtual void SetMarginCopyParam(int xmax, int ymax);
	void SetSimpleOrientationInput(int oTex, float sigma, float sigma_step);
	void LoadOrientationShader();
	void LoadDescriptorShaderF2();
	virtual void LoadDescriptorShader();
	virtual void SetFeatureOrientationParam(int gtex, int width, int height, float sigma, int stex = 0, float step = 1.0f);
	virtual void SetFeatureDescirptorParam(int gtex, int otex, float dwidth, float fwidth, float width, float height, float sigma);
	static void  WriteOrientationCodeToStream(ostream& out);
	static ProgramGLSL* LoadGenListStepShader(int start, int step);
	virtual void SetGenListInitParam(int w, int h);
	virtual void SetGenListStartParam(float width, int tex0);
	virtual void LoadGenListShader(int ndoglev, int nlev);
	virtual void UnloadProgram();
	virtual void LoadKeypointShader(float threshold, float edgeTrheshold);
	virtual void LoadFixedShaders();
	virtual void LoadDisplayShaders();
	virtual void SetDogTexParam(int texU, int texD);
	virtual void SetGenListStepParam(int tex, int tex0);
	virtual void SetGenVBOParam( float width, float fwidth, float size);
	virtual ~ShaderBagGLSL(){}
};


class ShaderBagPKSL:public ShaderBag
{
private:
	GLint	_param_dog_texu;
	GLint	_param_dog_texd;
	GLint	_param_dog_texi;
	GLint	_param_margin_copy_truncate;
	GLint	_param_grad_pass_texp;
	GLint	_param_genlist_init_bbox;
	GLint	_param_genlist_start_tex0;
	GLint	_param_ftex_width;
	GLint	_param_genlist_step_tex0;
	GLint	_param_genlist_end_ktex;
	GLint	_param_genvbo_size;
	GLint	_param_orientation_gtex;
	GLint	_param_orientation_otex;
	GLint	_param_orientation_size;
	GLint	_param_descriptor_gtex;
	GLint	_param_descriptor_otex;
	GLint	_param_descriptor_size;
	GLint	_param_descriptor_dsize;

    //
    ProgramGLSL* s_rect_description;
public:
    ShaderBagPKSL () {s_rect_description = NULL; }
	virtual ~ShaderBagPKSL() {if(s_rect_description) delete s_rect_description; }
	virtual void LoadFixedShaders();
	virtual void LoadDisplayShaders();
	virtual void LoadOrientationShader() ;
	virtual void SetGenListStartParam(float width, int tex0) ;
	virtual void LoadGenListShader(int ndoglev, int nlev);
	virtual void UnloadProgram();
	virtual void LoadKeypointShader(float threshold, float edgeTrheshold) ;
	virtual void LoadDescriptorShader();
	virtual void LoadDescriptorShaderF2();
    static ProgramGLSL* LoadDescriptorProgramRECT();
	static ProgramGLSL* LoadDescriptorProgramPKSL();
/////////////////
	virtual void SetDogTexParam(int texU, int texD);
	virtual void SetGradPassParam(int texP);
	virtual void SetGenListStepParam(int tex, int tex0);
	virtual void SetGenVBOParam( float width, float fwidth, float size);
	virtual void SetFeatureDescirptorParam(int gtex, int otex, float dwidth, float fwidth, float width, float height, float sigma);
	virtual void SetFeatureOrientationParam(int gtex, int width, int height, float sigma, int stex, float step);
	virtual void SetSimpleOrientationInput(int oTex, float sigma, float sigma_step);
	virtual void SetGenListEndParam(int ktex);
	virtual void SetGenListInitParam(int w, int h);
	virtual void SetMarginCopyParam(int xmax, int ymax);
};


#endif