gKit2 light
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
DrawParam Class Reference

#include <draw.h>

Public Member Functions

 DrawParam ()
 constructeur par defaut. More...
 
DrawParam & model (const Transform &m)
 modifie la transformation model utilisee pour afficher l'objet. More...
 
DrawParam & view (const Transform &m)
 modifie la transformation view utilisee pour afficher l'objet. More...
 
DrawParam & projection (const Transform &m)
 modifie la transformation projection utilisee pour afficher l'objet. More...
 
DrawParam & camera (Orbiter &o)
 utilise les transformations view et projection definies par une camera. More...
 
DrawParam & camera (Orbiter &o, const int width, const int height, const float fov)
 utilise les transformations view et projection definies par une camera. parametres explicites de la projection. More...
 
DrawParam & light (const Point &p, const Color &c=White())
 eclaire l'objet avec une source ponctuelle, de position p et de couleur c. More...
 
DrawParam & texture (const GLuint t)
 plaque une texture opaque a la surface de l'objet. More...
 
DrawParam & alpha_texture (const GLuint t, const float a=0.5f)
 utilise une texture semi transparente, si l'alpha du texel est plus petit que a, le pixel est transparent. desactive aussi les calculs d'eclairage. More...
 
DrawParam & lighting (const bool use_light=true)
 utilise une source de lumire pour eclairer l'objet, ou pas si use_light= false. More...
 
const Point & light () const
 renvoie la position de la lumière. More...
 
DrawParam & debug_normals (const float s=1)
 visualise les normales des sommets des triangles et les normales geometrique des triangles More...
 
DrawParam & debug_texcoords ()
 visualise les coordonnees de textures des sommets des triangles. More...
 
void draw (Mesh &mesh)
 dessine l'objet avec l'ensemble des parametres definis. More...
 
void draw (const TriangleGroup &group, Mesh &mesh)
 

Protected Member Functions

GLuint create_program (const GLenum primitives, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_light, const bool use_alpha_test)
 
GLuint create_debug_normals_program (const GLenum primitives, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_light, const bool use_alpha_test)
 
GLuint create_debug_texcoords_program (const GLenum primitives, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_light, const bool use_alpha_test)
 

Protected Attributes

Transform m_model
 
Transform m_view
 
Transform m_projection
 
bool m_use_light
 
Point m_light
 
Color m_light_color
 
bool m_use_texture
 
GLuint m_texture
 
bool m_use_alpha_test
 
float m_alpha_min
 
bool m_debug_normals
 
float m_normals_scale
 
bool m_debug_texcoords
 

Detailed Description

representation des options / parametres d'un draw. permet de donner tous les parametres d'un draw de maniere flexible.

exemple :

Mesh objet= { ... };
DrawParam param;
param.light(Point(0, 20, 0), Red());
param.camera(orbiter);
param.draw(objet);
DrawParam
Definition: draw.h:67
DrawParam::light
DrawParam & light(const Point &p, const Color &c=White())
eclaire l'objet avec une source ponctuelle, de position p et de couleur c.
Definition: draw.h:90
DrawParam::camera
DrawParam & camera(Orbiter &o)
utilise les transformations view et projection definies par une camera.
Definition: draw.h:86
DrawParam::draw
void draw(Mesh &mesh)
dessine l'objet avec l'ensemble des parametres definis.
Definition: draw.cpp:157
Mesh
representation d'un objet / maillage.
Definition: mesh.h:112
Red
Color Red()
utilitaire. renvoie une couleur rouge.
Definition: color.cpp:41
Point
representation d'un point 3d.
Definition: vec.h:21

ou de maniere encore plus compacte :

DrawParam().light(Point(0, 20, 0), Red()).model(m).camera(orbiter).draw(objet);
DrawParam::DrawParam
DrawParam()
constructeur par defaut.
Definition: draw.h:70

les parametres peuvent etre decrits dans un ordre quelconque, mais DrawParam::draw() doit etre appele en dernier.

Definition at line 66 of file draw.h.

Constructor & Destructor Documentation

◆ DrawParam()

DrawParam::DrawParam ( )
inline

constructeur par defaut.

Definition at line 70 of file draw.h.

70  : m_model(), m_view(), m_projection(),
71  m_use_light(false), m_light(), m_light_color(),
72  m_use_texture(false), m_texture(0),
73  m_use_alpha_test(false), m_alpha_min(0.3f),
74  m_debug_normals(false), m_normals_scale(1),
75  m_debug_texcoords(false)
76  {}

Member Function Documentation

◆ model()

DrawParam& DrawParam::model ( const Transform &  m)
inline

modifie la transformation model utilisee pour afficher l'objet.

Definition at line 79 of file draw.h.

79 { m_model= m; return *this; }

◆ view()

DrawParam& DrawParam::view ( const Transform &  m)
inline

modifie la transformation view utilisee pour afficher l'objet.

Definition at line 81 of file draw.h.

81 { m_view= m; return *this; }

◆ projection()

DrawParam& DrawParam::projection ( const Transform &  m)
inline

modifie la transformation projection utilisee pour afficher l'objet.

Definition at line 83 of file draw.h.

83 { m_projection= m; return *this; }

◆ camera() [1/2]

DrawParam& DrawParam::camera ( Orbiter &  o)
inline

utilise les transformations view et projection definies par une camera.

Definition at line 86 of file draw.h.

86 { m_view= o.view(); m_projection= o.projection(); return *this; }
Orbiter::projection
Transform projection(const int width, const int height, const float fov)
fixe la projection reglee pour une image d'aspect width / height, et une demi ouverture de fov degres...
Definition: orbiter.cpp:47
Orbiter::view
Transform view() const
renvoie la transformation vue.
Definition: orbiter.cpp:40

◆ camera() [2/2]

DrawParam& DrawParam::camera ( Orbiter &  o,
const int  width,
const int  height,
const float  fov 
)
inline

utilise les transformations view et projection definies par une camera. parametres explicites de la projection.

Definition at line 88 of file draw.h.

88 { m_view= o.view(); m_projection= o.projection(width, height, fov); return *this; }

◆ light() [1/2]

DrawParam& DrawParam::light ( const Point &  p,
const Color &  c = White() 
)
inline

eclaire l'objet avec une source ponctuelle, de position p et de couleur c.

Definition at line 90 of file draw.h.

90 { m_use_light= true; m_light= p; m_light_color=c; return *this; }

◆ texture()

DrawParam& DrawParam::texture ( const GLuint  t)
inline

plaque une texture opaque a la surface de l'objet.

Definition at line 92 of file draw.h.

92 { m_use_texture= true; m_texture= t; return *this; }

◆ alpha_texture()

DrawParam& DrawParam::alpha_texture ( const GLuint  t,
const float  a = 0.5f 
)
inline

utilise une texture semi transparente, si l'alpha du texel est plus petit que a, le pixel est transparent. desactive aussi les calculs d'eclairage.

Definition at line 95 of file draw.h.

95 { m_use_alpha_test= (a > 0); m_alpha_min= a; m_use_texture= true; m_texture= t; return *this; }

◆ lighting()

DrawParam& DrawParam::lighting ( const bool  use_light = true)
inline

utilise une source de lumire pour eclairer l'objet, ou pas si use_light= false.

Definition at line 99 of file draw.h.

99 { m_use_light= use_light; return *this; }

◆ light() [2/2]

const Point& DrawParam::light ( ) const
inline

renvoie la position de la lumière.

Definition at line 101 of file draw.h.

101 { return m_light; }

◆ debug_normals()

DrawParam& DrawParam::debug_normals ( const float  s = 1)
inline

visualise les normales des sommets des triangles et les normales geometrique des triangles

Definition at line 105 of file draw.h.

105 { m_debug_normals= true; m_normals_scale= s; return *this;}

◆ debug_texcoords()

DrawParam& DrawParam::debug_texcoords ( )
inline

visualise les coordonnees de textures des sommets des triangles.

Definition at line 107 of file draw.h.

107 { m_debug_texcoords= true; return *this;}

◆ draw()

void DrawParam::draw ( Mesh &  mesh)

dessine l'objet avec l'ensemble des parametres definis.

Definition at line 157 of file draw.cpp.

158 {
159  bool use_texcoord= m_use_texture && m_texture > 0 && mesh.has_texcoord();
160  bool use_normal= mesh.has_normal();
161  bool use_color= mesh.has_color();
162 
163  Transform mv= m_view * m_model;
164  Transform mvp= m_projection * mv;
165 
166  GLuint program= 0;
167  if(m_debug_texcoords)
168  {
169  program= create_debug_texcoords_program(mesh.primitives(), use_texcoord, use_normal, use_color, m_use_light, m_use_alpha_test);
170  m_use_light= false;
171  m_use_texture= false;
172  m_use_alpha_test= false;
173  use_color= false;
174  use_normal= false;
175  use_texcoord= true;
176 
177  glUseProgram(program);
178  //~ program_use_texture(program, "diffuse_color", 0, m_debug_texture);
179  program_uniform(program, "mvpMatrix", mvp);
180  program_uniform(program, "mvMatrix", mv);
181 
182  mesh.draw(program, /* position */ true, use_texcoord, false, false, /* material_index */ false);
183  return;
184  }
185 
186  program= create_program(mesh.primitives(), use_texcoord, use_normal, use_color, m_use_light, m_use_alpha_test);
187 
188  glUseProgram(program);
189  if(!use_color)
190  program_uniform(program, "mesh_color", mesh.default_color());
191 
192  program_uniform(program, "mvpMatrix", mvp);
193  if(use_normal)
194  program_uniform(program, "normalMatrix", mv.normal()); // transforme les normales dans le repere camera.
195  else
196  program_uniform(program, "mvMatrix", mv);
197 
198  // utiliser une texture, elle ne sera visible que si le mesh a des texcoords...
199  if(use_texcoord && m_texture > 0)
200  program_use_texture(program, "diffuse_color", 0, m_texture);
201 
202  if(m_use_light)
203  {
204  program_uniform(program, "light", m_view(m_light)); // transforme la position de la source dans le repere camera, comme les normales
205  program_uniform(program, "light_color", m_light_color);
206  program_uniform(program, "mvMatrix", mv);
207  }
208 
209  if(m_use_alpha_test)
210  program_uniform(program, "alpha_min", m_alpha_min);
211 
212  mesh.draw(program, /* position */ true, use_texcoord, use_normal, use_color, /* material_index */ false);
213 
214  // dessine les normales par dessus...
215  if(m_debug_normals)
216  {
217  program= create_debug_normals_program(mesh.primitives(), use_texcoord, use_normal, use_color, m_use_light, m_use_alpha_test);
218  m_use_light= false;
219  m_use_texture= false;
220  m_use_alpha_test= false;
221  use_color= false;
222  use_normal= true;
223  use_texcoord= false;
224 
225  static float scale= 1;
226  if(key_state('p') || key_state(SDLK_KP_PLUS))
227  scale+= 0.02f;
228  if(key_state('m') || key_state(SDLK_KP_MINUS))
229  scale-= 0.02f;
230  if(scale < 0.1f)
231  scale= 0.1f;
232 
233  glUseProgram(program);
234  program_uniform(program, "mvpMatrix", mvp);
235  program_uniform(program, "normalMatrix", mv.normal()); // transforme les normales dans le repere camera.
236  program_uniform(program, "scale", scale * m_normals_scale);
237 
238  mesh.draw(program, /* position */ true, false, use_normal, false, /* material_index */ false);
239  }
240 }
DrawParam::create_program
GLuint create_program(const GLenum primitives, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_light, const bool use_alpha_test)
Definition: draw.cpp:112
Mesh::default_color
Color default_color() const
renvoie la couleur par defaut du mesh, utilisee si les sommets n'ont pas de couleur associee.
Definition: mesh.h:284
Mesh::draw
void draw(const GLuint program, const bool use_position, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_material_index)
dessine l'objet avec un shader program.
Definition: mesh.cpp:768
Mesh::primitives
GLenum primitives() const
renvoie le type de primitives.
Definition: mesh.h:336
key_state
int key_state(const SDL_Keycode key)
renvoie l'etat d'une touche du clavier. cf la doc SDL2 pour les codes.
Definition: window.cpp:42
program_uniform
void program_uniform(const GLuint program, const char *uniform, const std::vector< unsigned > &v)
affecte un tableau de valeurs a un uniform du shader program.
Definition: uniforms.cpp:94
program_use_texture
void program_use_texture(const GLuint program, const char *uniform, const int unit, const GLuint texture, const GLuint sampler)
configure le pipeline et le shader program pour utiliser une texture, et des parametres de filtrage,...
Definition: uniforms.cpp:198
Transform
representation d'une transformation, une matrice 4x4, organisee par ligne / row major.
Definition: mat.h:21
Transform::normal
Transform normal() const
renvoie la transformation a appliquer aux normales d'un objet transforme par la matrice m.
Definition: mat.cpp:181

◆ create_program()

GLuint DrawParam::create_program ( const GLenum  primitives,
const bool  use_texcoord,
const bool  use_normal,
const bool  use_color,
const bool  use_light,
const bool  use_alpha_test 
)
protected

construit un shader program configure.

Parameters
use_texcoordforce l'utilisation des coordonnees de texture
use_normalforce l'utilisation des normales
use_colorforce l'utilisation des couleurs
use_lightforce l'utilisation d'un source de lumiere
use_alpha_testforce l'utilisation d'un test de transparence, cf utilisation d'une texture avec un canal alpha

Definition at line 112 of file draw.cpp.

113 {
114  std::string definitions;
115 
116  if(use_texcoord)
117  definitions.append("#define USE_TEXCOORD\n");
118  if(use_normal)
119  definitions.append("#define USE_NORMAL\n");
120  if(use_color)
121  definitions.append("#define USE_COLOR\n");
122  if(use_light)
123  definitions.append("#define USE_LIGHT\n");
124  if(use_texcoord && use_alpha_test)
125  definitions.append("#define USE_ALPHATEST\n");
126 
127  //~ printf("--\n%s", definitions.c_str());
128  const char *filename= smart_path("data/shaders/mesh.glsl");
129  bool use_mesh_color= (primitives == GL_POINTS || primitives == GL_LINES || primitives == GL_LINE_STRIP || primitives == GL_LINE_LOOP);
130  if(use_mesh_color)
131  filename= smart_path("data/shaders/mesh_color.glsl");
132 
133  PipelineProgram *program= PipelineCache::manager().find(filename, definitions.c_str());
134  return program->program;
135 }
PipelineCache::manager
static PipelineCache & manager()
access au singleton.
Definition: draw.h:188
PipelineCache::find
PipelineProgram * find(const char *filename, const char *definitions="")
renvoie un shader program compile.
Definition: draw.h:169
PipelineProgram
description d'un shader program compile.
Definition: draw.h:151
smart_path
const char * smart_path(const char *filename)
renvoie le chemin(path) vers le fichier 'filename' apres l'avoir cherche dans un repertoire standard....
Definition: window.cpp:431
The documentation for this class was generated from the following files:
Generated on Fri Dec 1 2023 13:25:53 for gKit2 light by doxygen 1.9.1