Skip to content

GitLab

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

Commit a0dcb145 authored by untereiner's avatar untereiner
Browse files

plop

parent 5a1513c8
Hide whitespace changes
Inline Side-by-side
src/Utils/Shaders/shaderPhong.cpp deleted 100644 → 0
View file @ 5a1513c8
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2011, 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.u-strasbg.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#include <GL/glew.h>
#include "Utils/Shaders/shaderPhong.h"
namespace CGoGN
{
namespace Utils
{
#include "shaderPhong.vert"
#include "shaderPhong.frag"
//std::string ShaderPhong::vertexShaderText =
//"ATTRIBUTE vec3 VertexPosition, VertexNormal;\n"
//"#ifdef WITH_COLOR\n"
//"ATTRIBUTE vec3 VertexColor;\n"
//"#endif\n"
//"uniform mat4 ModelViewProjectionMatrix;\n"
//"uniform mat4 ModelViewMatrix;\n"
//"uniform mat4 NormalMatrix;\n"
//"uniform vec3 lightPosition;\n"
//"VARYING_VERT vec3 EyeVector, Normal, LightDir;\n"
//"#ifdef WITH_COLOR\n"
//"VARYING_VERT vec3 Color;\n"
//"#endif\n"
//"INVARIANT_POS;\n"
//"void main ()\n"
//"{\n"
//" Normal = vec3 (NormalMatrix * vec4 (VertexNormal, 0.0));\n"
//" vec3 Position = vec3 (ModelViewMatrix * vec4 (VertexPosition, 1.0));\n"
//" LightDir = lightPosition - Position;\n"
//" EyeVector = -Position;\n"
//" #ifdef WITH_COLOR\n"
//" Color = VertexColor;\n"
//" #endif\n"
//" gl_Position = ModelViewProjectionMatrix * vec4 (VertexPosition, 1.0);\n"
//"}";
<<<<<<< HEAD
std::string ShaderPhong::fragmentShaderText =
"PRECISON;\n"
"VARYING_FRAG vec3 EyeVector, Normal, LightDir;\n"
"#ifdef WITH_COLOR\n"
"VARYING_FRAG vec3 Color;\n"
"#endif\n"
"uniform vec4 materialDiffuse;\n"
"uniform vec4 materialSpecular;\n"
"uniform vec4 materialAmbient;\n"
"uniform float shininess;\n"
"FRAG_OUT_DEF;\n"
"void main()\n"
"{\n"
" vec3 N = normalize (Normal);\n"
" vec3 L = normalize (LightDir);\n"
" float lambertTerm = dot(N,L);\n"
" vec4 finalColor = materialAmbient;\n"
" #ifdef DOUBLE_SIDED\n"
" if (lambertTerm < 0.0)\n"
" {\n"
" N = -1.0*N;\n"
" lambertTerm = -1.0*lambertTerm;\n"
" }\n"
" #else\n"
" if (lambertTerm > 0.0)\n"
" #endif\n"
" {\n"
" #ifndef WITH_COLOR\n"
" finalColor += materialDiffuse * lambertTerm;\n"
" #else\n"
" finalColor += vec4((Color*lambertTerm),0.0) ;\n"
" #endif\n"
" vec3 E = normalize(EyeVector);\n"
" vec3 R = reflect(-L, N);\n"
" float specular = pow( max(dot(R, E), 0.0), shininess );\n"
" finalColor += materialSpecular * specular;\n"
" }\n"
" gl_FragColor=finalColor;\n"
"}";
=======
//std::string ShaderPhong::fragmentShaderText =
//"PRECISON;\n"
//"VARYING_FRAG vec3 EyeVector, Normal, LightDir;\n"
//"#ifdef WITH_COLOR\n"
//"VARYING_FRAG vec3 Color;\n"
//"#endif\n"
//"uniform vec4 materialDiffuse;\n"
//"uniform vec4 materialSpecular;\n"
//"uniform vec4 materialAmbient;\n"
//"uniform float shininess;\n"
//"FRAG_OUT_DEF;\n"
//"void main()\n"
//"{\n"
//" vec3 N = normalize (Normal);\n"
//" vec3 L = normalize (LightDir);\n"
//" float lambertTerm = dot(N,L);\n"
//
//" vec4 finalColor = materialAmbient;\n"
//" if(lambertTerm > 0.0)\n"
//" {\n"
//" #ifndef WITH_COLOR\n"
//" finalColor += materialDiffuse * lambertTerm;\n"
//" #else\n"
//" finalColor += vec4((Color*lambertTerm),0.0) ;\n"
//" #endif\n"
//" vec3 E = normalize(EyeVector);\n"
//" vec3 R = reflect(-L, N);\n"
//" float specular = pow( max(dot(R, E), 0.0), shininess );\n"
//" finalColor += materialSpecular * specular;\n"
//" }\n"
//" gl_FragColor=finalColor;\n"
//"}";
>>>>>>> 78e96120e96f73c211126e8c46cc2fa99b5eb77f
ShaderPhong::ShaderPhong(bool doubleSided):
m_with_color(false),
m_ambiant(Geom::Vec4f(0.05f,0.05f,0.1f,0.0f)),
m_diffuse(Geom::Vec4f(0.1f,1.0f,0.1f,0.0f)),
m_specular(Geom::Vec4f(1.0f,1.0f,1.0f,0.0f)),
m_shininess(100.0f),
m_lightPos(Geom::Vec3f(10.0f,10.0f,1000.0f)),
m_vboPos(NULL),
m_vboNormal(NULL),
m_vboColor(NULL)
{
m_nameVS = "ShaderPhong_vs";
m_nameFS = "ShaderPhong_fs";
m_nameGS = "ShaderPhong_gs";
// get choose GL defines (2 or 3)
// ans compile shaders
std::string glxvert(*GLSLShader::DEFINES_GL);
glxvert.append(vertexShaderText);
std::string glxfrag(*GLSLShader::DEFINES_GL);
// Use double sided lighting if set
if (doubleSided)
glxfrag.append("#define DOUBLE_SIDED\n");
glxfrag.append(fragmentShaderText);
loadShadersFromMemory(glxvert.c_str(), glxfrag.c_str());
// and get and fill uniforms
bind();
getLocations();
sendParams();
}
void ShaderPhong::getLocations()
{
m_unif_ambiant = glGetUniformLocation(this->program_handler(), "materialAmbient");
m_unif_diffuse = glGetUniformLocation(this->program_handler(), "materialDiffuse");
m_unif_specular = glGetUniformLocation(this->program_handler(), "materialSpecular");
m_unif_shininess = glGetUniformLocation(this->program_handler(), "shininess");
m_unif_lightPos = glGetUniformLocation(this->program_handler(), "lightPosition");
}
void ShaderPhong::sendParams()
{
glUniform4fv(m_unif_ambiant, 1, m_ambiant.data());
glUniform4fv(m_unif_diffuse, 1, m_diffuse.data());
glUniform4fv(m_unif_specular, 1, m_specular.data());
glUniform1f(m_unif_shininess, m_shininess);
glUniform3fv(m_unif_lightPos, 1, m_lightPos.data());
}
void ShaderPhong::setAmbiant(const Geom::Vec4f& ambiant)
{
this->bind();
glUniform4fv(m_unif_ambiant,1, ambiant.data());
m_ambiant = ambiant;
}
void ShaderPhong::setDiffuse(const Geom::Vec4f& diffuse)
{
this->bind();
glUniform4fv(m_unif_diffuse,1, diffuse.data());
m_diffuse = diffuse;
}
void ShaderPhong::setSpecular(const Geom::Vec4f& specular)
{
this->bind();
glUniform4fv(m_unif_specular,1,specular.data());
m_specular = specular;
}
void ShaderPhong::setShininess(float shininess)
{
this->bind();
glUniform1f (m_unif_shininess, shininess);
m_shininess = shininess;
}
void ShaderPhong::setLightPosition( Geom::Vec3f lightPos)
{
this->bind();
glUniform3fv(m_unif_lightPos,1,lightPos.data());
m_lightPos = lightPos;
}
void ShaderPhong::setParams(const Geom::Vec4f& ambiant, const Geom::Vec4f& diffuse, const Geom::Vec4f& specular, float shininess, const Geom::Vec3f& lightPos)
{
m_ambiant = ambiant;
m_diffuse = diffuse;
m_specular = specular;
m_shininess = shininess;
m_lightPos = lightPos;
bind();
sendParams();
}
unsigned int ShaderPhong::setAttributeColor(VBO* vbo)
{
m_vboColor = vbo;
if (!m_with_color)
{
m_with_color=true;
// set the define and recompile shader
std::string gl3vert(*GLSLShader::DEFINES_GL);
gl3vert.append("#define WITH_COLOR 1\n");
gl3vert.append(vertexShaderText);
std::string gl3frag(*GLSLShader::DEFINES_GL);
gl3frag.append("#define WITH_COLOR 1\n");
gl3frag.append(fragmentShaderText);
loadShadersFromMemory(gl3vert.c_str(), gl3frag.c_str());
// and treat uniforms
bind();
getLocations();
sendParams();
}
// bind th VA with WBO
return bindVA_VBO("VertexColor", vbo);
}
void ShaderPhong::unsetAttributeColor()
{
m_vboColor = NULL;
if (m_with_color)
{
m_with_color=false;
// unbind the VA
unbindVA("VertexColor");
// recompile shader
std::string gl3vert(*GLSLShader::DEFINES_GL);
gl3vert.append(vertexShaderText);
std::string gl3frag(*GLSLShader::DEFINES_GL);
gl3frag.append(fragmentShaderText);
loadShadersFromMemory(gl3vert.c_str(), gl3frag.c_str());
// and treat uniforms
bind();
getLocations();
sendParams();
}
}
void ShaderPhong::restoreUniformsAttribs()
{
getLocations();
bind();
sendParams();
bindVA_VBO("VertexPosition", m_vboPos);
bindVA_VBO("VertexNormal", m_vboNormal);
if (m_vboColor)
bindVA_VBO("VertexColor", m_vboColor);
unbind();
}
unsigned int ShaderPhong::setAttributePosition(VBO* vbo)
{
m_vboPos = vbo;
return bindVA_VBO("VertexPosition", vbo);
}
unsigned int ShaderPhong::setAttributeNormal(VBO* vbo)
{
m_vboNormal = vbo;
return bindVA_VBO("VertexNormal", vbo);
}
} // namespace Utils
} // namespace CGoGN
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment