shaderRadiancePerVertex.cpp 5.65 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps  *
* version 0.1                                                                  *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg           *
*                                                                              *
* This library is free software; you can redistribute it and/or modify it      *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your     *
* option) any later version.                                                   *
*                                                                              *
* This library is distributed in the hope that it will be useful, but WITHOUT  *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License  *
* for more details.                                                            *
*                                                                              *
* You should have received a copy of the GNU Lesser General Public License     *
* along with this library; if not, write to the Free Software Foundation,      *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.           *
*                                                                              *
* Web site: http://cgogn.unistra.fr/                                           *
* Contact information: cgogn@unistra.fr                                        *
*                                                                              *
*******************************************************************************/

#include "Utils/Shaders/shaderRadiancePerVertex.h"

namespace CGoGN
{

namespace Utils
{

#include "shaderRadiancePerVertex.vert"
#include "shaderRadiancePerVertex.geom"
#include "shaderRadiancePerVertex.frag"

37 38 39 40 41
#include "shaderRadiancePerVertexInterp.vert"
#include "shaderRadiancePerVertexInterp.geom"
#include "shaderRadiancePerVertexInterp.frag"

ShaderRadiancePerVertex::ShaderRadiancePerVertex(int resolution, bool fraginterp) :
42 43 44 45 46
	m_vboPos(NULL),
	m_vboNorm(NULL),
	m_vboParam(NULL),
	m_tex_ptr(NULL),
	m_tex_unit(-1),
47
	m_resolution(resolution),
48 49
	K_tab(NULL),
	m_fragInterp(fraginterp)
50 51 52
{
	compile();
}
53 54 55 56 57 58 59

ShaderRadiancePerVertex::~ShaderRadiancePerVertex()
{
	if (K_tab != NULL)
		delete[] K_tab ;
}

60
void ShaderRadiancePerVertex::compile()
61
{
62 63 64 65 66 67 68 69 70 71 72 73
	if (m_fragInterp)
	{
		m_nameVS = "ShaderRadiancePerVertexInterp_vs";
		m_nameFS = "ShaderRadiancePerVertexInterp_fs";
		m_nameGS = "ShaderRadiancePerVertexInterp_gs";
	}
	else
	{
		m_nameVS = "ShaderRadiancePerVertex_vs";
		m_nameFS = "ShaderRadiancePerVertex_fs";
		m_nameGS = "ShaderRadiancePerVertex_gs";
	}
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98

	const int nb_coefs = (m_resolution+1)*(m_resolution+1);
	if (m_resolution != -1)
	{
		if (K_tab != NULL)
			delete[] K_tab;
		K_tab = new float[nb_coefs];
		for(int l = 0; l <= m_resolution; l++)
		{
			// recursive computation of the squares
			K_tab[index(l,0)] = (2*l+1) / (4*M_PI);
			for (int m = 1; m <= l; m++)
				K_tab[index(l,m)] = K_tab[index(l,m-1)] / (l-m+1) / (l+m);
			// square root + symmetry
			K_tab[index(l,0)] = sqrt(K_tab[index(l,0)]);
			for (int m = 1; m <= l; m++)
			{
				K_tab[index(l,m)] = sqrt(K_tab[index(l,m)]);
				K_tab[index(l,-m)] = K_tab[index(l,m)];
			}
		}
	}

	std::stringstream s ;
	s << "#define NB_COEFS " << nb_coefs << std::endl ;
99 100 101 102 103 104 105 106 107

	std::string glxvert(*GLSLShader::DEFINES_GL);
	if (!m_fragInterp)
	{
		glxvert.append(s.str()) ;
		glxvert.append(vertexShaderText);
	}
	else
		glxvert.append(vertexShaderInterpText);
108 109

	std::string glxgeom = GLSLShader::defines_Geom("triangles", "triangle_strip", 3) ;
110 111 112 113
	if (!m_fragInterp)
		glxgeom.append(geometryShaderText);
	else
		glxgeom.append(geometryShaderInterpText);
114 115

	std::string glxfrag(*GLSLShader::DEFINES_GL);
116 117 118 119 120 121 122
	if (!m_fragInterp)
		glxfrag.append(fragmentShaderText) ;
	else
	{
		glxfrag.append(s.str()) ;
		glxfrag.append(fragmentShaderInterpText) ;
	}
123

124
	loadShadersFromMemory(glxvert.c_str(), glxfrag.c_str(), glxgeom.c_str(), GL_TRIANGLES, GL_TRIANGLE_STRIP, 3);
125 126 127 128 129 130 131 132 133 134 135 136

	bind();
	*m_uniform_resolution = glGetUniformLocation(this->program_handler(), "resolution");
	*m_uniform_K_tab = glGetUniformLocation(this->program_handler(), "K_tab");
	*m_uniform_cam = glGetUniformLocation(this->program_handler(), "camera");
	*m_uniform_tex = glGetUniformLocation(this->program_handler(), "texture");

	glUniform1i(*m_uniform_resolution, m_resolution);
	glUniform1fv(*m_uniform_K_tab, nb_coefs, K_tab);
	unbind();
}

137
void ShaderRadiancePerVertex::setCamera(Geom::Vec3f& camera)
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
{
	m_camera = camera;
	bind();
	glUniform3fv(*m_uniform_cam, 1, m_camera.data()) ;
	unbind();
}

unsigned int ShaderRadiancePerVertex::setAttributePosition(VBO* vbo)
{
	m_vboPos = vbo;
	bind();
	unsigned int id = bindVA_VBO("VertexPosition", vbo);
	unbind();
	return id;
}

unsigned int ShaderRadiancePerVertex::setAttributeNormal(VBO* vbo)
{
	m_vboNorm = vbo;
	bind();
	unsigned int id = bindVA_VBO("VertexNormal", vbo);
	unbind();
	return id;
}

163 164 165 166 167 168
void ShaderRadiancePerVertex::setFragInterp(bool fraginterp)
{
	m_fragInterp = fraginterp ;
	compile() ;
}

169 170 171 172 173
unsigned int ShaderRadiancePerVertex::setAttributeRadiance(VBO* vbo, Utils::Texture<2, Geom::Vec3f>* texture, GLenum tex_unit)
{
	m_vboParam = vbo;
	m_tex_ptr = texture;
	m_tex_unit = tex_unit - GL_TEXTURE0;
174

175 176 177 178 179 180 181 182 183 184 185 186 187 188
	bind();
	unsigned int id = bindVA_VBO("VertexParam", vbo);
	glUniform1iARB(*m_uniform_tex, m_tex_unit);
	glActiveTexture(tex_unit);
	if (m_tex_ptr)
		m_tex_ptr->bind() ;
	unbind();

	return id;
}

} // namespace Utils

} // namespace CGoGN