source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ShaderProgram.cpp @ 3116

Revision 3116, 12.5 KB checked in by mattausch, 16 years ago (diff)

tree animation works somehow with flow vector

Line 
1#include "ShaderProgram.h"
2#include "Matrix4x4.h"
3#include "Timer/PerfTimer.h"
4#include "Vector3.h"
5#include "Camera.h"
6#include "Light.h"
7#include "SceneEntity.h"
8#include "Transform3.h"
9
10using namespace std;
11
12namespace CHCDemoEngine
13{
14
15//////////
16//-- changing shader parameters
17
18static float sCurrentTimer = 0;
19static float sOldTimer = 0;
20static Matrix4x4 sCurrentViewMatrix = IdentityMatrix();
21static Vector3 sCurrentViewDir = Vector3::UNIT_Y();
22static Vector3 sCurrentLightDir = Vector3::UNIT_Y();
23
24
25
26/*********************************************************/
27/*         GPUProgramParameters implementation           */
28/*********************************************************/
29
30
31GPUProgramParameters::GPUProgramParameters(ShaderProgram *p):
32mProgram(p)
33{
34        Reset();
35}
36
37
38GPUProgramParameters::GPUProgramParameters():
39mProgram(NULL)
40{
41        Reset();
42}
43
44
45void GPUProgramParameters::Reset()
46{
47        mFloats.clear();
48        mTextures.clear();
49        mMatrices.clear();
50        mArrays.clear();
51        mMatrixArrays.clear();
52
53        mTimerParam = -1;
54        mOldTimerParam = -1;
55        mViewDirParam = -1;
56        mLightDirParam = -1;
57        mViewMatrixParam = -1;
58
59        mModelMatrixParam = -1;
60        mOldModelMatrixParam = -1;
61}
62
63
64void GPUProgramParameters::SetValue1f(int idx, float value)
65{
66        if (mFloats.size() < idx + 1)
67                mFloats.resize(idx + 1);
68
69        mFloats[idx] = FloatParam(&value, 1);
70}
71
72
73void GPUProgramParameters::SetValue2f(int idx, float val1, float val2)
74{
75        if (mFloats.size() < idx + 1)
76                mFloats.resize(idx + 1);
77
78        float vals[] = {val1, val2};
79
80        mFloats[idx] = FloatParam(vals, 2);
81}
82
83
84void GPUProgramParameters::SetValue3f(int idx, float val1, float val2, float val3)
85{
86        if (mFloats.size() < idx + 1)
87                mFloats.resize(idx + 1);
88
89        float vals[] = {val1, val2, val3};
90
91        mFloats[idx] = FloatParam(vals, 3);
92}
93
94
95void GPUProgramParameters::SetArray1f(int idx, float *vals, int numElements)
96{
97        if (mArrays.size() < idx + 1)
98                mArrays.resize(idx + 1);
99
100        mArrays[idx] = ArrayParam(vals, 1, numElements);
101}
102
103
104void GPUProgramParameters::SetArray2f(int idx, float *vals, int numElements)
105{
106        if (mArrays.size() < idx + 1)
107                mArrays.resize(idx + 1);
108
109        mArrays[idx] = ArrayParam(vals, 2, numElements);
110}
111
112
113void GPUProgramParameters::SetArray3f(int idx, float *vals, int numElements)
114{
115        if (mArrays.size() < idx + 1)
116                mArrays.resize(idx + 1);
117
118        mArrays[idx] = ArrayParam(vals, 3, numElements);
119}
120
121
122void GPUProgramParameters::SetMatrixArray(int idx, float *mats, int numElements)
123{
124        if (mMatrixArrays.size() < idx + 1)
125                mMatrixArrays.resize(idx + 1);
126
127        mMatrixArrays[idx] = MatrixArrayParam(mats, numElements);
128}
129
130
131void GPUProgramParameters::SetTexture(int idx, unsigned int tex)
132{
133        if (mTextures.size() < idx + 1)
134                mTextures.resize(idx + 1);
135
136        mTextures[idx] = IntParam(tex);
137}
138
139
140void GPUProgramParameters::SetMatrix(int idx, const Matrix4x4 &mat)
141{
142        if (mMatrices.size() < idx + 1)
143                mMatrices.resize(idx + 1);
144
145        mMatrices[idx] = MatrixParam(mat);
146}
147
148
149void GPUProgramParameters::SetTimerParam(int idx)
150{
151        mTimerParam = idx;
152}
153
154
155void GPUProgramParameters::SetOldTimerParam(int idx)
156{
157        mOldTimerParam = idx;
158}
159
160
161void GPUProgramParameters::SetViewMatrixParam(int idx)
162{
163        mViewMatrixParam = idx;
164}
165
166
167void GPUProgramParameters::SetViewDirParam(int idx)
168{
169        mViewDirParam = idx;
170}
171
172
173void GPUProgramParameters::SetLightDirParam(int idx)
174{
175        mLightDirParam = idx;
176}
177
178
179void GPUProgramParameters::SetModelMatrixParam(int idx)
180{
181        mModelMatrixParam = idx;
182}
183
184
185void GPUProgramParameters::SetOldModelMatrixParam(int idx)
186{
187        mOldModelMatrixParam = idx;
188}
189
190
191void GPUProgramParameters::SetValue1f(const string &name, float val)
192{
193        SetValue1f(mProgram->GetParamIdxByName(name), val);
194}
195
196
197void GPUProgramParameters::SetValue2f(const string &name, float val1, float val2)
198{
199        SetValue2f(mProgram->GetParamIdxByName(name), val1, val2);
200}
201
202
203void GPUProgramParameters::SetValue3f(const string &name, float val1, float val2, float val3)
204{
205        SetValue3f(mProgram->GetParamIdxByName(name), val1, val2, val3);
206}
207
208
209void GPUProgramParameters::SetArray1f(const string &name, float *vals, int numElements)
210{
211        SetArray1f(mProgram->GetParamIdxByName(name), vals, numElements);
212}
213
214
215void GPUProgramParameters::SetArray2f(const string &name, float *vals, int numElements)
216{
217        SetArray2f(mProgram->GetParamIdxByName(name), vals, numElements);
218}
219
220
221void GPUProgramParameters::SetArray3f(const string &name, float *vals, int numElements)
222{
223        SetArray3f(mProgram->GetParamIdxByName(name), vals, numElements);
224}
225
226
227void GPUProgramParameters::SetMatrix(const string &name, const Matrix4x4 &mat)
228{
229        SetMatrix(mProgram->GetParamIdxByName(name), mat);
230}
231
232
233void GPUProgramParameters::SetMatrixArray(const string &name, float *mats, int numElements)
234{
235        SetMatrixArray(mProgram->GetParamIdxByName(name), mats, numElements);
236}
237
238
239void GPUProgramParameters::SetTexture(const string &name, unsigned int tex)
240{
241        SetTexture(mProgram->GetParamIdxByName(name), tex);
242}
243
244
245void GPUProgramParameters::UpdateParameters(SceneEntity *ent)
246{
247        if (!mProgram) return;
248
249        for (int i = 0; i < (int)mFloats.size(); ++ i)
250        {
251                const FloatParam &p = mFloats[i];
252
253                if (!p.mValid) continue;
254
255                switch (p.mNumComponents)
256                {
257                case 1:
258                        mProgram->SetValue1f(i, p.mValues[0]);
259                        break;
260                case 2:
261                        mProgram->SetValue2f(i, p.mValues[0], p.mValues[1]);
262                        break;
263                case 3:
264                        mProgram->SetValue3f(i, p.mValues[0], p.mValues[1], p.mValues[2]);
265                        break;
266                default:
267                        mProgram->SetValue1f(i, p.mValues[0]);
268                }
269        }
270
271        for (int i = 0; i < (int)mTextures.size(); ++ i)
272        {
273                const IntParam &p = mTextures[i];
274
275                if (p.mValid)
276                        mProgram->SetTexture(i, p.mValue);
277        }
278
279        for (int i = 0; i < (int)mMatrices.size(); ++ i)
280        {
281                const MatrixParam &p = mMatrices[i];
282
283                if (p.mValid) mProgram->SetMatrix(i, p.mValue);
284        }
285       
286        for (int i = 0; i < (int)mArrays.size(); ++ i)
287        {
288                const ArrayParam &p = mArrays[i];
289
290                if (!p.mValid) continue;
291
292                switch (p.mNumComponents)
293                {
294                case 1:
295                        mProgram->SetArray1f(i, p.mValues, p.mNumEntries);
296                        break;
297                case 2:
298                        mProgram->SetArray2f(i, p.mValues, p.mNumEntries);
299                        break;
300                case 3:
301                        mProgram->SetArray3f(i, p.mValues, p.mNumEntries);
302                        break;
303                default:
304                        mProgram->SetArray1f(i, p.mValues, p.mNumEntries);
305                }
306        }
307
308        for (int i = 0; i < (int)mMatrixArrays.size(); ++ i)
309        {
310                const MatrixArrayParam &p = mMatrixArrays[i];
311
312                if (p.mValid)
313                        mProgram->SetMatrixArray(i, p.mValues, p.mNumEntries);
314        }
315
316        if (mTimerParam >= 0)
317                mProgram->SetValue1f(mTimerParam, sCurrentTimer);
318        if (mOldTimerParam >= 0)
319                mProgram->SetValue1f(mOldTimerParam, sOldTimer);
320        if (mViewDirParam >= 0)
321                mProgram->SetValue3f(mViewDirParam, sCurrentViewDir.x, sCurrentViewDir.y, sCurrentViewDir.z);
322        if (mLightDirParam >= 0)
323                mProgram->SetValue3f(mLightDirParam, sCurrentLightDir.x, sCurrentLightDir.y, sCurrentLightDir.z);
324        if (mViewMatrixParam >= 0)
325                mProgram->SetMatrix(mViewMatrixParam, sCurrentViewMatrix);
326
327        if (ent)
328        {
329                if (mModelMatrixParam >= 0)
330                        mProgram->SetMatrix(mModelMatrixParam, ent->GetTransform()->GetMatrix());
331                if (mOldModelMatrixParam >= 0)
332                        mProgram->SetMatrix(mOldModelMatrixParam, ent->GetTransform()->GetOldMatrix());
333        }
334}
335
336
337void GPUProgramParameters::InitFrame(Camera *cam, DirectionalLight *light)
338{
339        static PerfTimer mytimer;
340        sOldTimer = sCurrentTimer;
341        sCurrentTimer = mytimer.Elapsedms(false) * M_PI / 180.0f;
342
343        cam->GetModelViewMatrix(sCurrentViewMatrix);
344        sCurrentViewDir = cam->GetDirection();
345
346        Matrix4x4 vo;
347        // transform to view space
348        cam->GetViewOrientationMatrix(vo);
349        sCurrentLightDir = vo * -light->GetDirection();
350}
351
352
353
354/********************************************************/
355/*             ShaderProgram implementation             */
356/********************************************************/
357
358
359ShaderProgram::ShaderProgram(CGcontext context,
360                                                         const std::string &filename,
361                                                         CGprofile profile,
362                                                         const std::string &functionName)
363{
364        mProgram = cgCreateProgramFromFile(context,
365                                               CG_SOURCE,
366                                                                           filename.c_str(),
367                                                                           profile,
368                                                                           functionName.c_str(),
369                                                                           NULL);
370
371        if (mProgram) cgGLLoadProgram(mProgram);
372
373        const int maxParams = 64;
374        mParameters.resize(maxParams);
375
376        for (int i = 0; i < maxParams; ++ i)
377                mParameters[i] = NULL;
378}
379
380
381void ShaderProgram::Bind()
382{
383        cgGLBindProgram(mProgram);
384
385        // enable all texture parameters
386        CGParameterArray::const_iterator it, it_end = mTextureParams.end();
387
388        for (it = mTextureParams.begin(); it != it_end; ++ it)
389                cgGLEnableTextureParameter(*it);
390}
391
392
393void ShaderProgram::Release()
394{
395        CGParameterArray::const_iterator it, it_end = mTextureParams.end();
396
397        // disable all texture parameters
398        for (it = mTextureParams.begin(); it != it_end; ++ it)
399                cgGLDisableTextureParameter(*it);
400}
401
402
403CGparameter ShaderProgram::AddParameter(const string &name, int idx)
404{
405        CGparameter p = GetOrCreateParameter(name);
406
407        mParamHash[name] = idx;
408        mParameters[idx] = p;
409
410        return p;
411}
412
413
414void ShaderProgram::AddParameters(std::string params[],
415                                                                  int startIdx,
416                                                                  int numElements)
417{
418        for (int i = 0; i < numElements; ++ i)
419                AddParameter(params[i], startIdx + i);
420}
421
422
423CGparameter ShaderProgram::GetOrCreateParameter(const string &name)
424{
425        CGparameter p;
426        CGParameterMap::const_iterator it = mParamHash.find(name);
427
428        if (it == mParamHash.end())
429                p = cgGetNamedParameter(mProgram, name.c_str());
430        else
431                p = mParameters[(*it).second];
432
433        //cout << "name: " << name << " " << p << " " << mProgram << endl;
434        return p;
435}
436
437
438CGparameter ShaderProgram::GetParameter(int idx) const
439{
440        return mParameters[idx];
441}
442
443
444void ShaderProgram::SetValue1f(int idx, float val)
445{
446        cgGLSetParameter1f(GetParameter(idx), val);
447}
448
449
450void ShaderProgram::SetValue2f(int idx, float val1, float val2)
451{
452        cgGLSetParameter2f(GetParameter(idx), val1, val2);
453}
454
455
456void ShaderProgram::SetValue3f(int idx, float val1, float val2, float val3)
457{
458        cgGLSetParameter3f(GetParameter(idx), val1, val2, val3);
459}
460
461
462void ShaderProgram::SetArray1f(int idx, float *vals, int numElements)
463{
464        cgGLSetParameterArray1f(GetParameter(idx), 0, numElements, (const float *)vals);
465}
466
467
468void ShaderProgram::SetArray2f(int idx, float *vals, int numElements)
469{
470        cgGLSetParameterArray2f(GetParameter(idx), 0, numElements, (const float *)vals);
471}
472
473
474void ShaderProgram::SetArray3f(int idx, float *vals, int numElements)
475{
476        cgGLSetParameterArray3f(GetParameter(idx), 0, numElements, (const float *)vals);
477}
478
479
480void ShaderProgram::SetMatrix(int idx, const Matrix4x4 &mat)
481{
482        cgGLSetMatrixParameterfc(GetParameter(idx), (const float *)mat.x);
483}
484
485
486void ShaderProgram::SetMatrixArray(int idx, float *mats, int numElements)
487{
488        cgGLSetMatrixParameterArrayfc(GetParameter(idx), 0, numElements, (const float *)mats);
489}
490
491
492
493void ShaderProgram::SetTexture(int idx, unsigned int tex)
494{
495        CGparameter p = GetParameter(idx);
496
497        cgGLSetTextureParameter(p, tex);
498        cgGLEnableTextureParameter(p);
499}
500
501
502void ShaderProgram::SetValue1f(const string &name, float val)
503{
504        cgGLSetParameter1f(GetOrCreateParameter(name), val);
505}
506
507
508void ShaderProgram::SetValue2f(const string &name, float val1, float val2)
509{
510        cgGLSetParameter2f(GetOrCreateParameter(name), val1, val2);
511}
512
513
514void ShaderProgram::SetValue3f(const string &name, float val1, float val2, float val3)
515{
516        cgGLSetParameter3f(GetOrCreateParameter(name), val1, val2, val3);
517}
518
519
520void ShaderProgram::SetArray1f(const string &name, float *vals, int numElements)
521{
522        cgGLSetParameterArray1f(GetOrCreateParameter(name), 0, numElements, (const float *)vals);
523}
524
525
526void ShaderProgram::SetArray2f(const string &name, float *vals, int numElements)
527{
528        cgGLSetParameterArray2f(GetOrCreateParameter(name), 0, numElements, (const float *)vals);
529}
530
531
532void ShaderProgram::SetArray3f(const string &name, float *vals, int numElements)
533{
534        cgGLSetParameterArray3f(GetOrCreateParameter(name), 0, numElements, (const float *)vals);
535}
536
537
538void ShaderProgram::SetMatrix(const string &name, const Matrix4x4 &mat)
539{
540        cgGLSetMatrixParameterfc(GetOrCreateParameter(name), (const float *)mat.x);
541}
542
543
544void ShaderProgram::SetTexture(const string &name, unsigned int tex)
545{
546        CGparameter p = GetOrCreateParameter(name);
547
548        cgGLSetTextureParameter(p, tex);
549        cgGLEnableTextureParameter(p);
550
551        mTextureParams.push_back(p);
552}
553
554
555int ShaderProgram::GetParamIdxByName(const std::string &name) const
556{
557        CGParameterMap::const_iterator it = mParamHash.find(name);
558        return (*it).second;
559}
560
561
562} // namespace
Note: See TracBrowser for help on using the repository browser.