libmoldeo (Moldeo 1.0 Core)  1.0
libmoldeo is the group of objects and functions that executes the basic operations of Moldeo 1.0 Platform.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
moTextureFilter.cpp
Go to the documentation of this file.
1 /*******************************************************************************
2 
3  moTextureFilter.cpp
4 
5  ****************************************************************************
6  * *
7  * This source is free software; you can redistribute it and/or modify *
8  * it under the terms of the GNU General Public License as published by *
9  * the Free Software Foundation; either version 2 of the License, or *
10  * (at your option) any later version. *
11  * *
12  * This code is distributed in the hope that it will be useful, but *
13  * WITHOUT ANY WARRANTY; without even the implied warranty of *
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
15  * General Public License for more details. *
16  * *
17  * A copy of the GNU General Public License is available on the World *
18  * Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also *
19  * obtain it by writing to the Free Software Foundation, *
20  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
21  * *
22  ****************************************************************************
23 
24  Copyright(C) 2006 Fabricio Costa
25 
26  Authors:
27  Fabricio Costa
28 
29 
30 *******************************************************************************/
31 
32 #include "moTextureFilter.h"
33 #include "moEffect.h"
34 #include "moArray.h"
35 moDefineDynamicArray(moTextureFilterArray)
36 
37 moColorMatrix::moColorMatrix()
38 {
39  ZeroMatrix();
40 }
41 
42 moColorMatrix::~moColorMatrix()
43 {
44  Finish();
45 }
46 
47 void moColorMatrix::Init()
48 {
49 }
50 
51 void moColorMatrix::Finish()
52 {
53 }
54 
55 void moColorMatrix::Copy(moColorMatrix& p_mat)
56 {
57  int i, j;
58  for (j = 0; j < 4; j++)
59  for (i = 0; i < 4; i++)
60  m_Matrix[MatIdx(i, j)] = p_mat.m_Matrix[MatIdx(i, j)];
61 }
62 
63 void moColorMatrix::Multiply(moColorMatrix& p_mat)
64 {
65  int i, j;
66  for (j = 0; j < 4; j++)
67  for (i = 0; i < 4; i++)
68  m_MatrixChg[MatIdx(i, j)] = p_mat.m_Matrix[MatIdx(i, j)];
69 
70  ApplyChgMatrix();
71 }
72 
73 void moColorMatrix::ZeroMatrix()
74 {
75  for (int j = 0; j < 4; j++)
76  for (int i = 0; i < 4; i++)
77  m_Matrix[MatIdx(i, j)] = 0.0;
78 }
79 
80 void moColorMatrix::IdentityMatrix()
81 {
82  for (int j = 0; j < 4; j++)
83  for (int i = 0; i < 4; i++)
84  m_Matrix[MatIdx(i, j)] = i == j;
85 }
86 
87 void moColorMatrix::SetXRotateMatrix(float rs, float rc)
88 {
89  m_MatrixChg[MatIdx(0, 0)] = 1.0;
90  m_MatrixChg[MatIdx(0, 1)] = 0.0;
91  m_MatrixChg[MatIdx(0, 2)] = 0.0;
92  m_MatrixChg[MatIdx(0, 3)] = 0.0;
93 
94  m_MatrixChg[MatIdx(1, 0)] = 0.0;
95  m_MatrixChg[MatIdx(1, 1)] = rc;
96  m_MatrixChg[MatIdx(1, 2)] = rs;
97  m_MatrixChg[MatIdx(1, 3)] = 0.0;
98 
99  m_MatrixChg[MatIdx(2, 0)] = 0.0;
100  m_MatrixChg[MatIdx(2, 1)] = -rs;
101  m_MatrixChg[MatIdx(2, 2)] = rc;
102  m_MatrixChg[MatIdx(2, 3)] = 0.0;
103 
104  m_MatrixChg[MatIdx(3, 0)] = 0.0;
105  m_MatrixChg[MatIdx(3, 1)] = 0.0;
106  m_MatrixChg[MatIdx(3, 2)] = 0.0;
107  m_MatrixChg[MatIdx(3, 3)] = 1.0;
108 }
109 
110 void moColorMatrix::SetYRotateMatrix(float rs, float rc)
111 {
112  m_MatrixChg[MatIdx(0, 0)] = rc;
113  m_MatrixChg[MatIdx(0, 1)] = 0.0;
114  m_MatrixChg[MatIdx(0, 2)] = -rs;
115  m_MatrixChg[MatIdx(0, 3)] = 0.0;
116 
117  m_MatrixChg[MatIdx(1, 0)] = 0.0;
118  m_MatrixChg[MatIdx(1, 1)] = 1.0;
119  m_MatrixChg[MatIdx(1, 2)] = 0.0;
120  m_MatrixChg[MatIdx(1, 3)] = 0.0;
121 
122  m_MatrixChg[MatIdx(2, 0)] = rs;
123  m_MatrixChg[MatIdx(2, 1)] = 0.0;
124  m_MatrixChg[MatIdx(2, 2)] = rc;
125  m_MatrixChg[MatIdx(2, 3)] = 0.0;
126 
127  m_MatrixChg[MatIdx(3, 0)] = 0.0;
128  m_MatrixChg[MatIdx(3, 1)] = 0.0;
129  m_MatrixChg[MatIdx(3, 2)] = 0.0;
130  m_MatrixChg[MatIdx(3, 3)] = 1.0;
131 }
132 
133 void moColorMatrix::SetZRotateMatrix(float rs, float rc)
134 {
135  m_MatrixChg[MatIdx(0, 0)] = rc;
136  m_MatrixChg[MatIdx(0, 1)] = rs;
137  m_MatrixChg[MatIdx(0, 2)] = 0.0;
138  m_MatrixChg[MatIdx(0, 3)] = 0.0;
139 
140  m_MatrixChg[MatIdx(1, 0)] = -rs;
141  m_MatrixChg[MatIdx(1, 1)] = rc;
142  m_MatrixChg[MatIdx(1, 2)] = 0.0;
143  m_MatrixChg[MatIdx(1, 3)] = 0.0;
144 
145  m_MatrixChg[MatIdx(2, 0)] = 0.0;
146  m_MatrixChg[MatIdx(2, 1)] = 0.0;
147  m_MatrixChg[MatIdx(2, 2)] = 1.0;
148  m_MatrixChg[MatIdx(2, 3)] = 0.0;
149 
150  m_MatrixChg[MatIdx(3, 0)] = 0.0;
151  m_MatrixChg[MatIdx(3, 1)] = 0.0;
152  m_MatrixChg[MatIdx(3, 2)] = 0.0;
153  m_MatrixChg[MatIdx(3, 3)] = 1.0;
154 }
155 
156 void moColorMatrix::SetZShearMatrix(float dx, float dy)
157 {
158  m_MatrixChg[MatIdx(0, 0)] = 1.0;
159  m_MatrixChg[MatIdx(0, 1)] = 0.0;
160  m_MatrixChg[MatIdx(0, 2)] = dx;
161  m_MatrixChg[MatIdx(0, 3)] = 0.0;
162 
163  m_MatrixChg[MatIdx(1, 0)] = 0.0;
164  m_MatrixChg[MatIdx(1, 1)] = 1.0;
165  m_MatrixChg[MatIdx(1, 2)] = dy;
166  m_MatrixChg[MatIdx(1, 3)] = 0.0;
167 
168  m_MatrixChg[MatIdx(2, 0)] = 0.0;
169  m_MatrixChg[MatIdx(2, 1)] = 0.0;
170  m_MatrixChg[MatIdx(2, 2)] = 1.0;
171  m_MatrixChg[MatIdx(2, 3)] = 0.0;
172 
173  m_MatrixChg[MatIdx(3, 0)] = 0.0;
174  m_MatrixChg[MatIdx(3, 1)] = 0.0;
175  m_MatrixChg[MatIdx(3, 2)] = 0.0;
176  m_MatrixChg[MatIdx(3, 3)] = 1.0;
177 }
178 
179 void moColorMatrix::XFormPoint(float &tx, float &ty, float &tz)
180 {
181  float x = RLUM;
182  float y = GLUM;
183  float z = BLUM;
184 
185  tx = x * m_Matrix[MatIdx(0, 0)] + y * m_Matrix[MatIdx(1, 0)] + z * m_Matrix[MatIdx(2, 0)] + m_Matrix[MatIdx(3, 0)];
186  ty = x * m_Matrix[MatIdx(0, 1)] + y * m_Matrix[MatIdx(1, 1)] + z * m_Matrix[MatIdx(2, 1)] + m_Matrix[MatIdx(3, 1)];
187  tz = x * m_Matrix[MatIdx(0, 2)] + y * m_Matrix[MatIdx(1, 2)] + z * m_Matrix[MatIdx(2, 2)] + m_Matrix[MatIdx(3, 2)];
188 }
189 
190 void moColorMatrix::ApplyChgMatrix()
191 {
192  int i, j, k;
193 
194  for (j = 0; j < 4; j++)
195  for (i = 0; i < 4; i++)
196  {
197  m_MatrixTemp[MatIdx(i, j)] = 0.0;
198  for (k = 0; k < 4; k++)
199  m_MatrixTemp[MatIdx(i, j)] += m_Matrix[MatIdx(i, k)]* m_MatrixChg[MatIdx(k, j)];
200  }
201 
202  for (j = 0; j < 4; j++)
203  for (i = 0; i < 4; i++)
204  m_Matrix[MatIdx(i, j)] = m_MatrixTemp[MatIdx(i, j)];
205 }
206 
207 moHueSatIntMatrix::moHueSatIntMatrix() : moColorMatrix()
208 {
209 
210  m_PreserveLuminance = true;
211 }
212 
213 moHueSatIntMatrix::~moHueSatIntMatrix()
214 {
215  Finish();
216 }
217 
218 void moHueSatIntMatrix::Init(MOboolean p_PreserveLuminance,
219  MOfloat p_min_int, MOfloat p_max_int,
220  MOfloat p_min_sat, MOfloat p_max_sat,
221  MOfloat p_min_hue, MOfloat p_max_hue)
222 {
223  moColorMatrix::Init();
224 
225  m_PreserveLuminance = p_PreserveLuminance;
226 
227  m_min_int = p_min_int;
228  m_max_int = p_max_int;
229 
230  m_min_sat = p_min_sat;
231  m_max_sat = p_max_sat;
232 
233  m_min_hue = p_min_hue;
234  m_max_hue = p_max_hue;
235 }
236 
237 void moHueSatIntMatrix::Finish()
238 {
239  moColorMatrix::Finish();
240 }
241 
242 void moHueSatIntMatrix::Update(MOfloat p_int, MOfloat p_sat, MOfloat p_hue)
243 {
244  m_int = m_min_int + p_int * (m_max_int - m_min_int);
245  m_sat = m_min_sat + p_sat * (m_max_sat - m_min_sat);
246  m_hue = m_min_hue + p_hue * (m_max_hue - m_min_hue);
247 
248  m_int = momax(1e-3, m_int);
249 
250  IdentityMatrix();
251  IntensityMatrix();
252  SaturateMatrix();
253  if (m_PreserveLuminance) HueRotateMatrix();
254  else SimpleHueRotateMatrix();
255 }
256 
257 void moHueSatIntMatrix::IntensityMatrix()
258 {
259  m_MatrixChg[MatIdx(0, 0)] = m_int;
260  m_MatrixChg[MatIdx(0, 1)] = 0.0;
261  m_MatrixChg[MatIdx(0, 2)] = 0.0;
262  m_MatrixChg[MatIdx(0, 3)] = 0.0;
263 
264  m_MatrixChg[MatIdx(1, 0)] = 0.0;
265  m_MatrixChg[MatIdx(1, 1)] = m_int;
266  m_MatrixChg[MatIdx(1, 2)] = 0.0;
267  m_MatrixChg[MatIdx(1, 3)] = 0.0;
268 
269  m_MatrixChg[MatIdx(2, 0)] = 0.0;
270  m_MatrixChg[MatIdx(2, 1)] = 0.0;
271  m_MatrixChg[MatIdx(2, 2)] = m_int;
272  m_MatrixChg[MatIdx(2, 3)] = 0.0;
273 
274  m_MatrixChg[MatIdx(3, 0)] = 0.0;
275  m_MatrixChg[MatIdx(3, 1)] = 0.0;
276  m_MatrixChg[MatIdx(3, 2)] = 0.0;
277  m_MatrixChg[MatIdx(3, 3)] = 1.0;
278 
279  ApplyChgMatrix();
280 }
281 
282 void moHueSatIntMatrix::SaturateMatrix()
283 {
284  MOfloat a, b, c, d, e, f, g, h, i;
285  MOfloat rs = (1.0 - m_sat);
286 
287  a = (rs * RLUM + m_sat);
288  b = (rs * RLUM);
289  c = (rs * RLUM);
290  d = (rs * GLUM);
291  e = (rs * GLUM + m_sat);
292  f = (rs * GLUM);
293  g = (rs * BLUM);
294  h = (rs * BLUM);
295  i = (rs * BLUM + m_sat);
296 
297  m_MatrixChg[MatIdx(0, 0)] = a;
298  m_MatrixChg[MatIdx(0, 1)] = b;
299  m_MatrixChg[MatIdx(0, 2)] = c;
300  m_MatrixChg[MatIdx(0, 3)] = 0.0;
301 
302  m_MatrixChg[MatIdx(1, 0)] = d;
303  m_MatrixChg[MatIdx(1, 1)] = e;
304  m_MatrixChg[MatIdx(1, 2)] = f;
305  m_MatrixChg[MatIdx(1, 3)] = 0.0;
306 
307  m_MatrixChg[MatIdx(2, 0)] = g;
308  m_MatrixChg[MatIdx(2, 1)] = h;
309  m_MatrixChg[MatIdx(2, 2)] = i;
310  m_MatrixChg[MatIdx(2, 3)] = 0.0;
311 
312  m_MatrixChg[MatIdx(3, 0)] = 0.0;
313  m_MatrixChg[MatIdx(3, 1)] = 0.0;
314  m_MatrixChg[MatIdx(3, 2)] = 0.0;
315  m_MatrixChg[MatIdx(3, 3)] = 1.0;
316 
317  ApplyChgMatrix();
318 }
319 
320 // Hue rotation that preserves luminance.
321 void moHueSatIntMatrix::HueRotateMatrix()
322 {
323  float mag;
324  float lx, ly, lz;
325  float xrs, xrc;
326  float yrs, yrc;
327  float zrs, zrc;
328  float zsx, zsy;
329 
330  // rotate the grey vector into positive Z.
331  mag = sqrt(2.0);
332  xrs = 1.0 / mag;
333  xrc = 1.0 / mag;
334  SetXRotateMatrix(xrs, xrc);
335  ApplyChgMatrix();
336 
337  mag = sqrt(3.0);
338  yrs = -1.0 / mag;
339  yrc = sqrt(2.0) / mag;
340  SetYRotateMatrix(yrs, yrc);
341  ApplyChgMatrix();
342 
343  // shear the space to make the luminance plane horizontal.
344  XFormPoint(lx, ly, lz);
345  zsx = lx / lz;
346  zsy = ly / lz;
347  SetZShearMatrix(zsx, zsy);
348  ApplyChgMatrix();
349 
350  // rotate the hue.
351  zrs = sin(m_hue);
352  zrc = cos(m_hue);
353  SetZRotateMatrix(zrs, zrc);
354  ApplyChgMatrix();
355 
356  // unshear the space to put the luminance plane back.
357  SetZShearMatrix(-zsx, -zsy);
358  ApplyChgMatrix();
359 
360  // rotate the grey vector back into place.
361  SetYRotateMatrix(-yrs, yrc);
362  ApplyChgMatrix();
363  SetXRotateMatrix(-xrs,xrc);
364  ApplyChgMatrix();
365 }
366 
367 void moHueSatIntMatrix::SimpleHueRotateMatrix()
368 {
369  MOfloat mag;
370  MOfloat xrs, xrc;
371  MOfloat yrs, yrc;
372  MOfloat zrs, zrc;
373 
374  // rotate the grey vector into positive Z.
375  mag = sqrt(2.0);
376  xrs = 1.0/mag;
377  xrc = 1.0/mag;
378  SetXRotateMatrix(xrs, xrc);
379  ApplyChgMatrix();
380 
381  mag = sqrt(3.0);
382  yrs = -1.0/mag;
383  yrc = sqrt(2.0)/mag;
384  SetYRotateMatrix(yrs, yrc);
385  ApplyChgMatrix();
386 
387  // rotate the hue
388  zrs = sin(m_hue);
389  zrc = cos(m_hue);
390  SetZRotateMatrix(zrs, zrc);
391  ApplyChgMatrix();
392 
393  // rotate the grey vector back into place.
394  SetYRotateMatrix(-yrs, yrc);
395  ApplyChgMatrix();
396  SetXRotateMatrix(-xrs, xrc);
397  ApplyChgMatrix();
398 }
399 
400 moBrightContMatrix::moBrightContMatrix() : moColorMatrix()
401 {
402 }
403 
404 moBrightContMatrix::~moBrightContMatrix()
405 {
406  Finish();
407 }
408 
409 void moBrightContMatrix::Init(MOfloat p_min_bright, MOfloat p_max_bright,
410  MOfloat p_min_cont, MOfloat p_max_cont)
411 {
412  moColorMatrix::Init();
413 
414  m_min_bright = p_min_bright;
415  m_max_bright = p_max_bright;
416 
417  m_min_cont = p_min_cont;
418  m_max_cont = p_max_cont;
419 }
420 
421 void moBrightContMatrix::Finish()
422 {
423  moColorMatrix::Finish();
424 }
425 
426 void moBrightContMatrix::Update(MOfloat p_bright, MOfloat p_cont)
427 {
428  m_bright = m_min_bright + p_bright * (m_max_bright - m_min_bright);
429  m_cont = m_min_cont + p_cont * (m_max_cont - m_min_cont);
430 
431  IdentityMatrix();
432  BrightnessMatrix();
433  ContrastMatrix();
434 }
435 
436 void moBrightContMatrix::BrightnessMatrix()
437 {
438  m_MatrixChg[MatIdx(0, 0)] = 1.0;
439  m_MatrixChg[MatIdx(0, 1)] = 0.0;
440  m_MatrixChg[MatIdx(0, 2)] = 0.0;
441  m_MatrixChg[MatIdx(0, 3)] = 0.0;
442 
443  m_MatrixChg[MatIdx(1, 0)] = 0.0;
444  m_MatrixChg[MatIdx(1, 1)] = 1.0;
445  m_MatrixChg[MatIdx(1, 2)] = 0.0;
446  m_MatrixChg[MatIdx(1, 3)] = 0.0;
447 
448  m_MatrixChg[MatIdx(2, 0)] = 0.0;
449  m_MatrixChg[MatIdx(2, 1)] = 0.0;
450  m_MatrixChg[MatIdx(2, 2)] = 1.0;
451  m_MatrixChg[MatIdx(2, 3)] = 0.0;
452 
453  m_MatrixChg[MatIdx(3, 0)] = m_bright;
454  m_MatrixChg[MatIdx(3, 1)] = m_bright;
455  m_MatrixChg[MatIdx(3, 2)] = m_bright;
456  m_MatrixChg[MatIdx(3, 3)] = 1.0;
457 
458  ApplyChgMatrix();
459 }
460 
461 void moBrightContMatrix::ContrastMatrix()
462 {
463  m_MatrixChg[MatIdx(0, 0)] = m_cont;
464  m_MatrixChg[MatIdx(0, 1)] = 0.0;
465  m_MatrixChg[MatIdx(0, 2)] = 0.0;
466  m_MatrixChg[MatIdx(0, 3)] = 0.0;
467 
468  m_MatrixChg[MatIdx(1, 0)] = 0.0;
469  m_MatrixChg[MatIdx(1, 1)] = m_cont;
470  m_MatrixChg[MatIdx(1, 2)] = 0.0;
471  m_MatrixChg[MatIdx(1, 3)] = 0.0;
472 
473  m_MatrixChg[MatIdx(2, 0)] = 0.0;
474  m_MatrixChg[MatIdx(2, 1)] = 0.0;
475  m_MatrixChg[MatIdx(2, 2)] = m_cont;
476  m_MatrixChg[MatIdx(2, 3)] = 0.0;
477 
478  m_MatrixChg[MatIdx(3, 0)] = (1.0 - m_cont) * 0.5;
479  m_MatrixChg[MatIdx(3, 1)] = (1.0 - m_cont) * 0.5;
480  m_MatrixChg[MatIdx(3, 2)] = (1.0 - m_cont) * 0.5;
481  m_MatrixChg[MatIdx(3, 3)] = 1.0;
482 
483  ApplyChgMatrix();
484 }
485 
486 //===========================================
487 //
488 // moTextureFilter
489 //
490 //===========================================
491 
492 
493 moTextureFilter::moTextureFilter() {
494  m_glman = NULL;
495  m_renderman = NULL;
496  m_shader = NULL;
497  m_TextureFilterLabelName = "";
498  m_uniform_idx = -1;
499 }
500 
501 
502 MOboolean moTextureFilter::Init(moGLManager* p_glman, moRenderManager* p_renderman, moTextureArray &p_src_tex, moTextureArray &p_dest_tex, moShader *p_shader, const moTextFilterParam& p_params)
503 {
504  MOuint i;
505  moText uname;
506 
507  m_glman = p_glman;
508  m_renderman = p_renderman;
509 
510  if (p_shader) {
511 
512  }
513 
514  m_use_screen_tex = false;
515  for (i = 0; i < p_src_tex.Count(); i++)
516  {
517  m_src_tex.Add(p_src_tex[i]);
518  if (p_src_tex[i]->GetName() == moText("screen_texture")) m_use_screen_tex = true;
519  }
520  for (i = 0; i < p_dest_tex.Count(); i++) {
521  m_dest_tex.Add(p_dest_tex[i]);
522  }
523  CheckDestTexAttachStatus();
524 
525  m_shader = p_shader;
526  moShaderGLSL* pglsl = NULL;
527 
528 #ifdef SHADER_CG
529  moShaderCG* pcg = NULL;
530 #endif
531 
532  if (m_shader->GetType()==MO_SHADER_CG) {
533 #ifdef SHADER_CG
534  pcg = (moShaderCG*)m_shader;
535 #endif
536  } else {
537  pglsl = (moShaderGLSL*)m_shader;
538  }
539 
540 
541  if (pglsl) {
542  pglsl->PrintVertShaderLog();
543  pglsl->PrintFragShaderLog();
544  }
545 
546  // Gettting uniform parameters.
547  for (i = 0; i < m_src_tex.Count(); i++)
548  {
549  uname = moText("src_tex_unit") + IntToStr(i);
550 
551  if (pglsl) m_src_tex_unit[i] = pglsl->GetUniformID(uname);
552 
553  uname = moText("src_tex_offset") + IntToStr(i);
554 
555  if (pglsl) m_src_tex_offset[i] = pglsl->GetUniformID(uname);
556 
557  }
558 
559  uname = moText("tempo_angle");
560  if (pglsl) m_tempo_angle = pglsl->GetUniformID(uname);
561 
562  uname = moText("dest_tex_size");
563  if (pglsl) m_dest_tex_size = pglsl->GetUniformID(uname);
564 
565  uname = moText("fade_const");
566  if (pglsl) m_fade_const = pglsl->GetUniformID(uname);
567 
568  uname = moText("tempo_dt");
569  if (pglsl) m_tempo_dt = pglsl->GetUniformID(uname);
570 
571  uname = moText("tempo_delta");
572  if (pglsl) m_tempo_delta = pglsl->GetUniformID(uname);
573 
574  uname = moText("tempo_syncro");
575  if (pglsl) m_tempo_syncro = pglsl->GetUniformID(uname);
576 
577  uname = moText("tempo_ticks");
578  if (pglsl) m_tempo_ticks = pglsl->GetUniformID(uname);
579 
580  uname = moText("dest_tex_size");
581  if (pglsl) m_dest_tex_size = pglsl->GetUniformID(uname);
582 
583  uname = moText("fade_const");
584  if (pglsl) m_fade_const = pglsl->GetUniformID(uname);
585 
586  uname = moText("random_uniform");
587  if (pglsl) m_random_uniform = pglsl->GetUniformID(uname);
588  //MODebug2->Message("moTextureFilter::Init >"+uname+" idx:"+IntToStr(m_random_uniform));
589 
590  m_uniform_idx = -1;
591  for(int u=0; u<MAX_UNIFORM_VARS; u++ ) {
592  m_uniform_variables_idx[u] = -1;
593  }
594 
595  if (m_shader) {
596  //do something
597  //p_src_object = NULL;
598  if (m_uniform_idx==-1) {
599  m_uniform_idx = m_shader->m_Config.GetParamIndex( "uniform" );
600  //MODebug2->Message("moTextureFilter::Init > founded uniform param in: m_uniform_idx:"+IntToStr(m_uniform_idx));
601  }
602 
603  if (m_uniform_idx>-1) {
604  for( int u=0; u<m_shader->m_Config.GetParam(m_uniform_idx).GetValuesCount(); u++ ) {
605  moValue vb = m_shader->m_Config.GetParam(m_uniform_idx).GetValues().Get(u);
606  moText uniform_var_name = vb.GetSubValue(0).GetData()->Text();
607  moText uniform_var_type = vb.GetSubValue(1).GetData()->Text();
608  uname = uniform_var_name;
609  if (m_uniform_variables_idx[u]==-1 && pglsl) {
610  m_uniform_variables_idx[u] = pglsl->GetUniformID(uname);
611  //MODebug2->Message("moTextureFilter::Init > setting uniform id for ("+uname+","+uniform_var_type+") in:"+IntToStr(m_uniform_variables_idx[u]));
612  }
613  }
614  }
615  }
616 
617 
618  m_DefParams = p_params;
619  if (pglsl) {
620  m_DefParams.getParamIDs(pglsl);
621  }
622 
623 
624 
625  return true;
626 }
627 
628 MOboolean moTextureFilter::Finish()
629 {
630  //if (m_DefParams != NULL)
631  //{
632  // delete m_DefParams;
633  // m_DefParams = NULL;
634  //}
635  return true;
636 }
637 
638 void moTextureFilter::Apply( MOuint p_i) {
639  moTextFilterParam p_params;
640  Apply( p_i, 1.0, p_params);
641 }
642 
643 void moTextureFilter::Apply( MOuint p_i, MOfloat p_fade, const moTextFilterParam& p_params)
644 {
645  MOint w = m_dest_tex[0]->GetWidth();
646  MOint h = m_dest_tex[0]->GetHeight();
647  SetGLConf(w, h);
648 // moShaderGLSL* pglsl = (moShaderGLSL*)m_shader;
649 
650  if (m_use_screen_tex) m_renderman->SaveScreen();
651 
652  BindDestFBO();
653 
654  m_shader->StartShader();
655  SetupShader(w, h, NULL, p_fade, p_params);
656 
657  BindSrcTex(p_i);
658  m_shader->DrawGrid(w, h, m_src_tex.Count());
659  UnbindSrcTex();
660 
661  m_shader->StopShader();
662 
663  UnbindDestFBO();
664 
665  RestoreGLConf();
666 }
667 
668 
669 void moTextureFilter::Apply(MOfloat p_cycle) {
670  moTextFilterParam p_params;
671  Apply( p_cycle, 1.0, p_params);
672 }
673 
674 void moTextureFilter::Apply(MOfloat p_cycle, MOfloat p_fade, const moTextFilterParam& p_params)
675 {
676  MOint w = m_dest_tex[0]->GetWidth();
677  MOint h = m_dest_tex[0]->GetHeight();
678  SetGLConf(w, h);
679 // moShaderGLSL* pglsl = (moShaderGLSL*)m_shader;
680 
681 
682  if (m_use_screen_tex) m_renderman->SaveScreen();
683 
684  BindDestFBO();
685 
686  m_shader->StartShader();
687  SetupShader(w, h, NULL, p_fade, p_params);
688 
689  BindSrcTex(p_cycle);
690  m_shader->DrawGrid(w, h, m_src_tex.Count());
691  UnbindSrcTex();
692 
693  m_shader->StopShader();
694 
695  UnbindDestFBO();
696 
697  RestoreGLConf();
698 }
699 
700 void moTextureFilter::Apply(moTempo *p_tempo) {
701  moTextFilterParam p_params;
702  Apply( p_tempo, 1.0, p_params);
703 }
704 
705 void moTextureFilter::Apply(moTempo *p_tempo, MOfloat p_fade, const moTextFilterParam& p_params)
706 {
707  MOint w = m_dest_tex[0]->GetWidth();
708  MOint h = m_dest_tex[0]->GetHeight();
709  SetGLConf(w, h);
710 // moShaderGLSL* pglsl = (moShaderGLSL*)m_shader;
711 
712  if (m_use_screen_tex) m_renderman->SaveScreen();
713 
714  BindDestFBO();
715 
716  m_shader->StartShader();
717  SetupShader(w, h, p_tempo, p_fade, p_params);
718 
719  BindSrcTex(p_tempo);
720  m_shader->DrawGrid(w, h, m_src_tex.Count());
721  UnbindSrcTex();
722 
723  m_shader->StopShader();
724 
725  UnbindDestFBO();
726 
727  RestoreGLConf();
728 }
729 
730 void moTextureFilter::Apply(moMoldeoObject *p_src_mob) {
731  moTextFilterParam p_params;
732  Apply( p_src_mob, 1.0, p_params);
733 }
734 
735 void moTextureFilter::Apply( moMoldeoObject *p_src_mob, moTempo *p_tempo, MOfloat p_fade, const moTextFilterParam& p_params ) {
736  if (p_src_mob==NULL) return;
737  if (m_shader==NULL) return;
738 
739  MOint w = m_dest_tex[0]->GetWidth();
740  MOint h = m_dest_tex[0]->GetHeight();
741  SetGLConf(w, h);
742 
743  if (m_use_screen_tex) m_renderman->SaveScreen();
744 
745  BindDestFBO();
746 
747  m_shader->StartShader();
748  SetupShader(w, h, p_tempo, p_fade, p_params, p_src_mob);
749 
750  BindSrcTex( p_src_mob );
751  m_shader->DrawGrid(w, h, m_src_tex.Count());
752  UnbindSrcTex();
753 
754  m_shader->StopShader();
755 
756  UnbindDestFBO();
757 
758  RestoreGLConf();
759 }
760 
761 
762 void moTextureFilter::Apply( moMoldeoObject *p_src_mob, MOfloat p_fade, const moTextFilterParam& p_params ) {
763 
764  Apply( p_src_mob, NULL, p_fade, p_params );
765 
766 }
767 
768 
769 void moTextureFilter::SetupShader(MOint w, MOint h, moTempo *p_tempo, MOfloat p_fade, const moTextFilterParam& p_params, moMoldeoObject* p_src_object)
770 {
771  for (MOuint i = 0; i < m_src_tex.Count(); i++)
772  {
773  if (-1 < m_src_tex_unit[i]) {
774  if ( m_shader && m_shader->GetType() == (MOuint)MO_SHADER_GLSL ) {
775  glUniform1iARB(m_src_tex_unit[i], i);
776  }
777  }
778  if (-1 < m_src_tex_offset[i]) {
779  if (m_glman->RectTexture(m_src_tex[i]->GetTexTarget())) glUniform2fARB(m_src_tex_offset[i], 1.0, 1.0);
780  else glUniform2fARB(m_src_tex_offset[i], 1.0 / float(m_src_tex[i]->GetWidth()), 1.0 / float(m_src_tex[i]->GetHeight()));
781  }
782  }
783 
784 
785  if (p_tempo != NULL)
786  {
787 
788  if (-1 < m_tempo_angle) {
789  float a = p_tempo->ang;
790  float f = fmod(float(a), float(2.0 * moMathf::PI)) / (2.0 * moMathf::PI);
791 
792  glUniform2fARB(m_tempo_angle, a, f);
793  }
794 
795  if (-1<m_tempo_dt) {
796  glUniform1fARB(m_tempo_dt, p_tempo->dt );
797  }
798  if (-1<m_tempo_syncro) {
799  glUniform1fARB(m_tempo_syncro, p_tempo->syncro );
800  }
801  if (-1<m_tempo_delta) {
802  glUniform1fARB(m_tempo_delta, p_tempo->delta );
803  }
804  if (-1<m_tempo_ticks) {
805  glUniform1fARB(m_tempo_ticks, (float)p_tempo->ticks );
806  }
807  //moDebugManager::Push("m_tempo_angle:" + FloatToStr(a));
808  //(m_shader->GetType() == (MOuint)MO_SHADER_GLSL) ? glUniform2fARB(m_tempo_angle, a, f) : m_tempo_angle=0;/*cgGLSetParameter2f( (CGparameter)m_tempo_angle, a, f)*/
809  }
810  else {
811  glUniform2fARB(m_tempo_angle, 0.0, 0.0);
812  glUniform1fARB(m_tempo_dt, 0.0);
813  //(m_shader->GetType() == (MOuint)MO_SHADER_GLSL) ? glUniform2fARB(m_tempo_angle, 0.0, 0.0) : m_tempo_angle=0;/*cgGLSetParameter2f( (CGparameter)m_tempo_angle, 0.0, 0.0 )*/
814  }
815  if (-1 < m_dest_tex_size) {
816  glUniform2fARB(m_dest_tex_size, w, h);
817 
818  }
819 
820  if (-1 < m_fade_const) {
821  glUniform1fARB(m_fade_const, p_fade);
822  }
823 
825  if (p_src_object) {
826  //do something
827  p_src_object = NULL;
828  }
829 
830  if (-1 < m_random_uniform) {
831  float seed = 0.0f;
832  float r = moMathf::UnitRandom(seed);
833 
834  glUniform2fARB(m_random_uniform, r, seed);
835  }
836 
837 
839  if (p_src_object && m_shader) {
840 
841  moShaderGLSL* pglsl = (moShaderGLSL*)m_shader;
842  //do something
843  //p_src_object = NULL;
844  if (m_uniform_idx>-1) {
845  for( int u=0; u<m_shader->m_Config.GetParam(m_uniform_idx).GetValuesCount(); u++ ) {
846  moValue vb = m_shader->m_Config.GetParam(m_uniform_idx).GetValues().Get(u);
847  moText uniform_var_name = vb.GetSubValue(0).GetData()->Text();
848  moText uniform_var_type = vb.GetSubValue(1).GetData()->Text();
849 
850  if (m_uniform_variables_idx[u]>-1) {
851  int paramidx = p_src_object->GetConfig()->GetParamIndex(uniform_var_name);
852  if (uniform_var_type=="FLOAT") {
853  if (paramidx>-1) {
854  float p_float = p_src_object->GetConfig()->Eval( uniform_var_name );
855  glUniform1fARB( m_uniform_variables_idx[u], p_float );
856  } else {
857  int inletidx = p_src_object->GetInletIndex(uniform_var_name);
858  if (inletidx>-1) {
859  float p_float = p_src_object->GetInlets()->Get(inletidx)->GetData()->Float();
860  glUniform1fARB( m_uniform_variables_idx[u], p_float );
861  }
862  }
863  } else
864  if (uniform_var_type=="INT") {
865  if (paramidx>-1) {
866  int p_int = p_src_object->GetConfig()->Int( uniform_var_name );
867  glUniform1iARB( m_uniform_variables_idx[u], p_int );
868  } else {
869  int inletidx = p_src_object->GetInletIndex(uniform_var_name);
870  if (inletidx>-1) {
871  int p_int = p_src_object->GetInlets()->Get(inletidx)->GetData()->Int();
872  glUniform1iARB( m_uniform_variables_idx[u], p_int );
873  }
874  }
875  }
906  }
907  }
908 
909 
910 
911  }
912  }
913 
914  m_DefParams = p_params;
915  m_DefParams.setParamValues();
916  MODebug2->Message( moText("setParamValues > m_par_flt1: ") + IntToStr(m_DefParams.m_par_flt1) );
917 
918 }
919 
920 void moTextureFilter::SetGLConf(MOint w, MOint h)
921 {
922  m_blend_on = glIsEnabled(GL_BLEND);
923 #ifndef OPENGLESV2
924  glGetIntegerv(GL_POLYGON_MODE, &m_poly_mode);
925 #endif
926  glDisable(GL_BLEND);
927 #ifndef OPENGLESV2
928  glPolygonMode(GL_FRONT, GL_FILL);
929 #endif
930  m_glman->SaveView();
931  m_glman->SetOrthographicView(w, h, 0.0, w, 0.0, h);
932 }
933 
934 void moTextureFilter::RestoreGLConf()
935 {
936  m_glman->RestoreView();
937 
938  if (m_blend_on) glEnable(GL_BLEND);
939 #ifndef OPENGLESV2
940  glPolygonMode(GL_FRONT, m_poly_mode);
941 #endif
942 }
943 
944 void moTextureFilter::BindDestFBO()
945 {
946  moFBO* fbo = m_dest_tex[0]->GetFBO();
947  if (fbo != NULL)
948  {
949  // Attach destination textures to attachements points of fbo (0, 1, 2, etc)...
950  moTexture* ptex;
951 
952  fbo->Bind();
953 
954  if (m_reattach_dest_tex) fbo->ClearAttachements();
955 
956  GLsizei n = m_dest_tex.Count();
957  int i, j;
958  for (i = 0; i < n; i++)
959  {
960  ptex = m_dest_tex[i];
961  if (m_reattach_dest_tex)
962  {
963  fbo->AttachTexture(ptex->GetWidth(), ptex->GetHeight(), ptex->GetTexParam(), ptex->GetGLId(), i);
964  m_draw_buffers[i] = fbo->GetColorAttachPoint(i);
965  }
966  else
967  {
968  j = ptex->GetFBOAttachPoint();
969  m_draw_buffers[i] = fbo->GetColorAttachPoint(j);
970  }
971  }
972 #ifndef OPENGLESV2
973  glDrawBuffers(n, m_draw_buffers);
974 #endif
975  }
976 }
977 
978 void moTextureFilter::UnbindDestFBO()
979 {
980  moFBO* fbo = m_dest_tex[0]->GetFBO();
981  if (fbo != NULL) fbo->Unbind();
982 }
983 
984 void moTextureFilter::BindSrcTex(MOuint p_i)
985 {
986  //if (m_shader->GetType()==MO_SHADER_GLSL)
987  for (MOuint i = 0; i < m_src_tex.Count(); i++)
988  {
989  glActiveTextureARB(GL_TEXTURE0_ARB + i);
990  glBindTexture(m_src_tex[i]->GetTexTarget(), m_src_tex.GetGLId(i, (GLint)p_i));
991  }
992 }
993 
994 void moTextureFilter::BindSrcTex(MOfloat p_cycle)
995 {
996  //if (m_shader->GetType()==MO_SHADER_GLSL)
997  for (MOuint i = 0; i < m_src_tex.Count(); i++)
998  {
999  glActiveTextureARB(GL_TEXTURE0_ARB + i);
1000  glBindTexture(m_src_tex[i]->GetTexTarget(), m_src_tex.GetGLId(i, p_cycle));
1001  }
1002 }
1003 
1004 void moTextureFilter::BindSrcTex(moTempo *p_tempo)
1005 {
1006  //if (m_shader->GetType()==MO_SHADER_GLSL)
1007  for (MOuint i = 0; i < m_src_tex.Count(); i++)
1008  {
1009  glActiveTextureARB(GL_TEXTURE0_ARB + i);
1010  glBindTexture(m_src_tex[i]->GetTexTarget(), m_src_tex.GetGLId(i, p_tempo));
1011  }
1012 }
1013 
1014 void moTextureFilter::BindSrcTex( moMoldeoObject* p_mob ) {
1015 
1016  if (p_mob==NULL) return;
1017 
1018  moTempo* src_tempo = NULL;
1019  moEffectState fs;
1020 
1021  if ( p_mob->GetType()==MO_OBJECT_EFFECT
1022  || p_mob->GetType()==MO_OBJECT_PREEFFECT
1023  || p_mob->GetType()==MO_OBJECT_POSTEFFECT
1024  || p_mob->GetType()==MO_OBJECT_MASTEREFFECT ) {
1025 
1026  moEffect* pFx = (moEffect*) p_mob;
1027 
1028  if (pFx) {
1029  fs = pFx->GetEffectState();
1030  src_tempo = &fs.tempo;
1031  }
1032 
1033  }
1034 
1035  for (MOuint i = 0; i < m_src_tex.Count(); i++)
1036  {
1037  glActiveTextureARB(GL_TEXTURE0_ARB + i);
1038  //glBindTexture(m_src_tex[i]->GetTexTarget(), m_src_tex.GetGLId(i, p_mob));
1039  glBindTexture(m_src_tex[i]->GetTexTarget(), m_src_tex.GetGLId(i, src_tempo));
1040  }
1041 }
1042 
1043 
1044 void moTextureFilter::UnbindSrcTex()
1045 {
1046  for (MOuint i = m_src_tex.Count(); 0 < i; i--)
1047  {
1048  glActiveTextureARB(GL_TEXTURE0_ARB + i - 1);
1049  glBindTexture(m_src_tex[i-1]->GetTexTarget(), 0);
1050  }
1051 }
1052 
1053 void moTextureFilter::CheckDestTexAttachStatus()
1054 {
1055  m_reattach_dest_tex = false;
1056  for (MOuint i = 0; i < m_dest_tex.Count(); i++)
1057  if ((int)m_dest_tex[i]->GetFBOAttachPoint() == MO_UNDEFINED)
1058  {
1059  m_reattach_dest_tex = true;
1060  break;
1061  }
1062 }
1063 
moTextureFilter::m_glman
moGLManager * m_glman
Definition: moTextureFilter.h:251
BLUM
#define BLUM
Definition: moTextureFilter.h:50
moValue
Valor de un Parámetro.
Definition: moValue.h:501
moColorMatrix::MatIdx
int MatIdx(int i, int j)
Definition: moTextureFilter.h:77
RLUM
#define RLUM
Definition: moTextureFilter.h:48
moTextureFilter::m_reattach_dest_tex
MOboolean m_reattach_dest_tex
Definition: moTextureFilter.h:283
moTempo
Tempo, beat, ritmo.
Definition: moTempo.h:44
moShader::m_Config
moConfig m_Config
Definition: moShader.h:286
moValue::GetSubValue
moValueBase & GetSubValue(MOint p_indexsubvalue=0)
Definition: moValue.h:539
moConfig::Eval
MOdouble Eval(moParamReference p_paramreference, double x,...)
Acceso rápido a evaluar la función
Definition: moConfig.cpp:1125
MAX_UNIFORM_VARS
#define MAX_UNIFORM_VARS
Definition: moTextureFilter.h:54
moColorMatrix::~moColorMatrix
virtual ~moColorMatrix()
Definition: moTextureFilter.cpp:42
moColorMatrix::m_MatrixChg
MOfloat m_MatrixChg[16]
Definition: moTextureFilter.h:74
moFBO::ClearAttachements
void ClearAttachements()
Definition: moFBO.cpp:260
moTextureFilter::m_dest_tex
moTextureIndex m_dest_tex
Definition: moTextureFilter.h:276
MO_UNDEFINED
#define MO_UNDEFINED
Definition: moTypes.h:379
MOboolean
#define MOboolean
Definition: moTypes.h:385
moColorMatrix::SetZShearMatrix
void SetZShearMatrix(float dx, float dy)
Definition: moTextureFilter.cpp:156
moTextureFilter::BindSrcTex
void BindSrcTex(MOuint p_i)
Definition: moTextureFilter.cpp:984
moGLManager::SaveView
void SaveView()
Definition: moGLManager.cpp:661
moConfig::GetParamIndex
int GetParamIndex(moText p_paramname)
Devuelve el índice correspondiente al parámetro por nombre.
Definition: moConfig.cpp:1008
moShader::GetType
MOuint GetType()
Definition: moShader.h:249
moColorMatrix::SetXRotateMatrix
void SetXRotateMatrix(float rs, float rc)
Definition: moTextureFilter.cpp:87
moConfig::Int
MOint Int(moParamReference p_paramreference)
Acceso rápido a un valor entero.
Definition: moConfig.cpp:1042
moColorMatrix::SetYRotateMatrix
void SetYRotateMatrix(float rs, float rc)
Definition: moTextureFilter.cpp:110
moFBO::AttachTexture
MOuint AttachTexture(MOuint p_width, MOuint p_height, const moTexParam &p_param, MOuint p_glid, MOuint p_attach_point)
Definition: moFBO.cpp:218
moGLManager::RectTexture
MOboolean RectTexture(GLenum p_target) const
Definition: moGLManager.cpp:765
moMoldeoObject::GetInlets
moInlets * GetInlets()
Definition: moMoldeoObject.cpp:1089
moTextureFilter::m_src_tex
moTextureIndex m_src_tex
Definition: moTextureFilter.h:275
moShaderGLSL::PrintVertShaderLog
void PrintVertShaderLog()
Definition: moShaderGLSL.cpp:135
moAbstract::Init
virtual MOboolean Init()
Inicializa el objeto.
Definition: moAbstract.cpp:141
MO_OBJECT_EFFECT
Objeto indefinido.
Definition: moTypes.h:527
moShaderGLSL::GetUniformID
GLint GetUniformID(const moText &uName)
Definition: moShaderGLSL.cpp:145
moTempo::syncro
MOdouble syncro
Syncronización o factor fraccionario, 1.0 predeterminado, sino KX donde K puede ser fraccional (un núme...
Definition: moTempo.h:79
moTextureFilter::Apply
void Apply(MOuint p_i, MOfloat p_fade, const moTextFilterParam &p_params)
Definition: moTextureFilter.cpp:643
moTextureFilter::SetGLConf
void SetGLConf(MOint w, MOint h)
Definition: moTextureFilter.cpp:920
moTextFilterParam::setParamValues
void setParamValues()
Definition: moTextFilterParam.cpp:27
moColorMatrix::m_Matrix
MOfloat m_Matrix[16]
Definition: moTextureFilter.h:73
moShader::StartShader
virtual void StartShader()
Definition: moShader.cpp:228
moBrightContMatrix::Update
void Update(MOfloat p_bright, MOfloat p_cont)
Definition: moTextureFilter.cpp:426
MOfloat
#define MOfloat
Definition: moTypes.h:403
moTempo::delta
MOdouble delta
variacion de frecuencia entre 0X y 2X, delta es real
Definition: moTempo.h:69
moColorMatrix::m_MatrixTemp
MOfloat m_MatrixTemp[16]
Definition: moTextureFilter.h:75
moGLManager::RestoreView
void RestoreView()
Definition: moGLManager.cpp:697
moFBO
Definition: moFBO.h:60
moText0
clase de para manejar textos
Definition: moText.h:75
moColorMatrix::Multiply
void Multiply(moColorMatrix &p_mat)
Definition: moTextureFilter.cpp:63
moEffect::GetEffectState
virtual const moEffectState & GetEffectState()
Definition: moEffect.cpp:59
moHueSatIntMatrix::m_PreserveLuminance
MOboolean m_PreserveLuminance
Definition: moTextureFilter.h:113
moFBO::Unbind
void Unbind()
Definition: moFBO.cpp:120
moText
moText0 moText
Definition: moText.h:291
moTextureIndex::GetGLId
MOuint GetGLId(MOuint p_idx)
Definition: moTextureIndex.cpp:57
moTextureFilter::m_TextureFilterLabelName
moText m_TextureFilterLabelName
Definition: moTextureFilter.h:253
moTextFilterParam::m_par_flt1
GLint m_par_flt1
Definition: moTextFilterParam.h:96
MOint
#define MOint
Definition: moTypes.h:388
moMoldeoObject
Clase Base para Objetos Moldeo ( moEffect, moIODevice, moResource, moConsole )
Definition: moMoldeoObject.h:409
moTexture::GetGLId
MOuint GetGLId() const
Definition: moTexture.h:224
moShader::StopShader
virtual void StopShader()
Definition: moShader.cpp:233
MO_OBJECT_POSTEFFECT
Objeto dibujable, pre-efecto ( primeros efectos en el orden de dibujado )
Definition: moTypes.h:529
moTexture
clase base para el manejo de una textura
Definition: moTexture.h:78
moTextureFilter::m_draw_buffers
GLenum m_draw_buffers[MO_MAX_COLOR_ATTACHMENTS_EXT]
Definition: moTextureFilter.h:280
moTextureFilter::m_renderman
moRenderManager * m_renderman
Definition: moTextureFilter.h:250
moMath::PI
const MOlong PI
Definition: moMath.cpp:44
MO_OBJECT_PREEFFECT
Objeto dibujable, efecto ( efectos en el orden de dibujado )
Definition: moTypes.h:528
moFBO::GetColorAttachPoint
MOint GetColorAttachPoint(MOuint p_attach_point)
Definition: moFBO.cpp:153
moTextureFilter::SetupShader
void SetupShader(MOint w, MOint h, moTempo *p_tempo, MOfloat p_fade, const moTextFilterParam &p_params, moMoldeoObject *p_src_object=NULL)
Definition: moTextureFilter.cpp:769
moGLManager
manejador de operaciones comunes de Open GL
Definition: moGLManager.h:154
moAbstract::MODebug2
static moDebug * MODebug2
Clase de impresión de errores para depuración
Definition: moAbstract.h:225
moMoldeoObject::GetConfig
moConfig * GetConfig()
Definition: moMoldeoObject.h:536
GLUM
#define GLUM
Definition: moTextureFilter.h:49
moMoldeoObject::GetType
moMoldeoObjectType GetType() const
Definition: moMoldeoObject.cpp:976
moTextureFilter::m_shader
moShader * m_shader
Definition: moTextureFilter.h:249
moData::Text
moText Text()
Definition: moValue.cpp:539
moParam::GetValues
moValues & GetValues()
Definition: moParam.cpp:1060
moTextureIndex::Add
MOint Add(moText p_name, moTextureManager *p_tex_man)
Definition: moTextureIndex.cpp:36
moDefineDynamicArray
moDefineDynamicArray(moTextureFilterArray) moColorMatrix
Definition: moTextureFilter.cpp:35
moTexture::GetHeight
MOuint GetHeight() const
Definition: moTexture.h:261
moTexture::GetFBOAttachPoint
MOuint GetFBOAttachPoint() const
Definition: moTexture.h:213
moColorMatrix::XFormPoint
void XFormPoint(float &tx, float &ty, float &tz)
Definition: moTextureFilter.cpp:179
moConfig::GetParam
moParam & GetParam(MOint p_paramindex=-1)
Devuelve el parámetro por índice.
Definition: moConfig.cpp:984
moTempo::ticks
MOulong ticks
tiempo en milisegundos (obsoleto) se usa moTimer ahora.
Definition: moTempo.h:60
moTempo::dt
MOdouble dt
incremento diferencial de tiempo
Definition: moTempo.h:73
moTextureFilter::m_src_tex_unit
GLint m_src_tex_unit[MO_MAX_TEXTURE_UNITS]
Definition: moTextureFilter.h:256
moColorMatrix::SetZRotateMatrix
void SetZRotateMatrix(float rs, float rc)
Definition: moTextureFilter.cpp:133
moTextureFilter::Finish
virtual MOboolean Finish()
Definition: moTextureFilter.cpp:628
moColorMatrix::Finish
virtual void Finish()
Definition: moTextureFilter.cpp:51
moMoldeoObject::GetInletIndex
MOint GetInletIndex(moText p_connector_name) const
Definition: moMoldeoObject.cpp:1094
moHueSatIntMatrix::Update
void Update(MOfloat p_int, MOfloat p_sat, MOfloat p_hue)
Definition: moTextureFilter.cpp:242
MOuint
#define MOuint
Definition: moTypes.h:387
IntToStr
LIBMOLDEO_API moText0 IntToStr(int a)
Definition: moText.cpp:1070
moData::GetData
moData * GetData()
Definition: moValue.cpp:945
moTextFilterParam::getParamIDs
void getParamIDs(void *p_shader)
Definition: moTextFilterParam.cpp:6
moEffect
clase base para objetos dibujables
Definition: moEffect.h:82
moColorMatrix::Init
virtual void Init()
Definition: moTextureFilter.cpp:47
MO_OBJECT_MASTEREFFECT
Objeto dibujable, post-efecto ( últímos efectos en el orden de dibujado )
Definition: moTypes.h:530
moTextureFilter::m_uniform_variables_idx
int m_uniform_variables_idx[MAX_UNIFORM_VARS]
idx of uniform parameters variables in moMoldeoObject
Definition: moTextureFilter.h:269
moTextureFilter::m_DefParams
moTextFilterParam m_DefParams
idx of uniform variables in shader code moShader
Definition: moTextureFilter.h:272
moTextureFilter::m_src_tex_offset
GLint m_src_tex_offset[MO_MAX_TEXTURE_UNITS]
Definition: moTextureFilter.h:257
moShader::DrawGrid
void DrawGrid(MOint w, MOint h, MOint l)
Definition: moShader.h:283
moShaderGLSL::PrintFragShaderLog
void PrintFragShaderLog()
Definition: moShaderGLSL.cpp:140
moColorMatrix::Copy
void Copy(moColorMatrix &p_mat)
Definition: moTextureFilter.cpp:55
moTextFilterParam
Definition: moTextFilterParam.h:12
moParam::GetValuesCount
MOuint GetValuesCount() const
Definition: moParam.cpp:1065
moTempo::ang
MOdouble ang
Definition: moTempo.h:81
moTexture::GetWidth
MOuint GetWidth() const
Definition: moTexture.h:256
moDebug::Message
void Message(moText p_text)
Anuncia un mensaje al usuario además de guardarlo en el log de texto.
Definition: moAbstract.cpp:114
moGLManager::SetOrthographicView
void SetOrthographicView(MOint p_width=0, MOint p_height=0, float left=0.0, float right=1.0, float bottom=0.0, float top=1.0, float znear=-1.0, float zfar=1.0)
Definition: moGLManager.cpp:509
moTextureFilter::m_blend_on
GLboolean m_blend_on
Definition: moTextureFilter.h:278
moTextureFilter::m_use_screen_tex
MOboolean m_use_screen_tex
Definition: moTextureFilter.h:282
moMath::UnitRandom
static Real UnitRandom(unsigned int uiSeed=0)
Definition: moMath.h:380
moFBO::Bind
void Bind()
Definition: moFBO.cpp:114
moTexture::GetTexParam
moTexParam GetTexParam() const
Definition: moTexture.h:307