Création d'un compte pour un collaborateur extérieur au laboratoire depuis l'intranet ICube : https://intranet.icube.unistra.fr/fr/labs/member/profile

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