← Back to branch summary

~ubuntu-branches/ubuntu/maverick/blender/maverick

« back to all changes in this revision

Viewing changes to source/gameengine/Ketsji/BL_Shader.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Khashayar Naderehvandi, Khashayar Naderehvandi, Alessio Treglia
  • Date: 2009-01-22 16:53:59 UTC
  • mfrom: (14.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20090122165359-v0996tn7fbit64ni
Tags: 2.48a+dfsg-1ubuntu1
https://launchpad.net/bugs/320045
[ Khashayar Naderehvandi ]
* Merge from debian experimental (LP: #320045), Ubuntu remaining changes:
  - Add patch correcting header file locations.
  - Add libvorbis-dev and libgsm1-dev to Build-Depends.
  - Use avcodec_decode_audio2() in source/blender/src/hddaudio.c

[ Alessio Treglia ]
* Add missing previous changelog entries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/gameengine/Ketsji/BL_Shader.cpp
1
1
 
2
 
 
3
 
#ifdef WIN32
4
 
#include <windows.h>
5
 
#endif // WIN32
6
 
#ifdef __APPLE__
7
 
#define GL_GLEXT_LEGACY 1
8
 
#include <OpenGL/gl.h>
9
 
#include <OpenGL/glu.h>
10
 
#else
11
 
#include <GL/gl.h>
12
 
/* #if defined(__sun__) && !defined(__sparc__)
13
 
#include <mesa/glu.h>
14
 
#else
15
 
*/
16
 
#include <GL/glu.h>
17
 
/* #endif */
18
 
#endif
 
2
#include "GL/glew.h"
19
3
 
20
4
#include <iostream>
21
5
#include "BL_Shader.h"
31
15
#include "RAS_MeshObject.h"
32
16
#include "RAS_IRasterizer.h"
33
17
 
34
 
//using namespace bgl;
35
18
#define spit(x) std::cout << x << std::endl;
36
19
 
37
20
#define SORT_UNIFORMS 1
46
29
        mDataLen(data_size)
47
30
{
48
31
#ifdef SORT_UNIFORMS
49
 
        MT_assert(mDataLen <= UNIFORM_MAX_LEN);
 
32
        MT_assert((int)mDataLen <= UNIFORM_MAX_LEN);
50
33
        mData = (void*)MEM_mallocN(mDataLen, "shader-uniform-alloc");
51
34
#endif
52
35
}
63
46
 
64
47
void BL_Uniform::Apply(class BL_Shader *shader)
65
48
{
66
 
#ifdef GL_ARB_shader_objects
67
49
#ifdef SORT_UNIFORMS
68
50
        MT_assert(mType > UNI_NONE && mType < UNI_MAX && mData);
69
51
 
74
56
        {
75
57
        case UNI_FLOAT: {
76
58
                        float *f = (float*)mData;
77
 
                        bgl::blUniform1fARB(mLoc,(GLfloat)*f);
 
59
                        glUniform1fARB(mLoc,(GLfloat)*f);
78
60
                }break;
79
61
        case UNI_INT: {
80
62
                        int *f = (int*)mData;
81
 
                        bgl::blUniform1iARB(mLoc, (GLint)*f);
 
63
                        glUniform1iARB(mLoc, (GLint)*f);
82
64
                }break;
83
65
        case UNI_FLOAT2: {
84
66
                        float *f = (float*)mData;
85
 
                        bgl::blUniform2fvARB(mLoc,1, (GLfloat*)f);
 
67
                        glUniform2fvARB(mLoc,1, (GLfloat*)f);
86
68
                }break;
87
69
        case UNI_FLOAT3: {
88
70
                        float *f = (float*)mData;
89
 
                        bgl::blUniform3fvARB(mLoc,1,(GLfloat*)f);
 
71
                        glUniform3fvARB(mLoc,1,(GLfloat*)f);
90
72
                }break;
91
73
        case UNI_FLOAT4: {
92
74
                        float *f = (float*)mData;
93
 
                        bgl::blUniform4fvARB(mLoc,1,(GLfloat*)f);
 
75
                        glUniform4fvARB(mLoc,1,(GLfloat*)f);
94
76
                }break;
95
77
        case UNI_INT2: {
96
78
                        int *f = (int*)mData;
97
 
                        bgl::blUniform2ivARB(mLoc,1,(GLint*)f);
 
79
                        glUniform2ivARB(mLoc,1,(GLint*)f);
98
80
                }break; 
99
81
        case UNI_INT3: {
100
82
                        int *f = (int*)mData;
101
 
                        bgl::blUniform3ivARB(mLoc,1,(GLint*)f);
 
83
                        glUniform3ivARB(mLoc,1,(GLint*)f);
102
84
                }break; 
103
85
        case UNI_INT4: {
104
86
                        int *f = (int*)mData;
105
 
                        bgl::blUniform4ivARB(mLoc,1,(GLint*)f);
 
87
                        glUniform4ivARB(mLoc,1,(GLint*)f);
106
88
                }break;
107
89
        case UNI_MAT4: {
108
90
                        float *f = (float*)mData;
109
 
                        bgl::blUniformMatrix4fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
 
91
                        glUniformMatrix4fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
110
92
                }break;
111
93
        case UNI_MAT3: {
112
94
                        float *f = (float*)mData;
113
 
                        bgl::blUniformMatrix3fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
 
95
                        glUniformMatrix3fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
114
96
                }break;
115
97
        }
116
98
        mDirty = false;
117
99
#endif
118
 
#endif
119
100
}
120
101
 
121
102
void BL_Uniform::SetData(int location, int type,bool transpose)
144
125
        mError(0),
145
126
        mDirty(true)
146
127
{
147
 
        // if !RAS_EXT_support._ARB_shader_objects this class will not be used
 
128
        // if !GLEW_ARB_shader_objects this class will not be used
148
129
        //for (int i=0; i<MAXTEX; i++) {
149
130
        //      mSampler[i] = BL_Sampler();
150
131
        //}
151
132
}
152
133
 
153
 
using namespace bgl;
154
 
 
155
134
BL_Shader::~BL_Shader()
156
135
{
157
 
#ifdef GL_ARB_shader_objects
158
136
        //for (int i=0; i<MAXTEX; i++){
159
137
        //      if(mSampler[i].mOwn) {
160
138
        //              if(mSampler[i].mTexture)
164
142
        ClearUniforms();
165
143
 
166
144
        if( mShader ) {
167
 
                bgl::blDeleteObjectARB(mShader);
 
145
                glDeleteObjectARB(mShader);
168
146
                mShader = 0;
169
147
        }
170
148
        vertProg        = 0;
171
149
        fragProg        = 0;
172
150
        mOk                     = 0;
173
 
        bgl::blUseProgramObjectARB(0);
174
 
#endif//GL_ARB_shader_objects
 
151
        glUseProgramObjectARB(0);
175
152
}
176
153
 
177
154
void BL_Shader::ClearUniforms()
266
243
 
267
244
bool BL_Shader::LinkProgram()
268
245
{
269
 
#ifdef GL_ARB_shader_objects
270
 
 
271
246
        int vertlen = 0, fraglen=0, proglen=0;
272
247
        int vertstatus=0, fragstatus=0, progstatus=0;
273
248
        unsigned int tmpVert=0, tmpFrag=0, tmpProg=0;
281
256
                spit("Invalid GLSL sources");
282
257
                return false;
283
258
        }
284
 
        if( !RAS_EXT_support._ARB_fragment_shader) {
 
259
        if( !GLEW_ARB_fragment_shader) {
285
260
                spit("Fragment shaders not supported");
286
261
                return false;
287
262
        }
288
 
        if( !RAS_EXT_support._ARB_vertex_shader) {
 
263
        if( !GLEW_ARB_vertex_shader) {
289
264
                spit("Vertex shaders not supported");
290
265
                return false;
291
266
        }
292
267
        
293
268
        // -- vertex shader ------------------
294
 
        tmpVert = bgl::blCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
295
 
        bgl::blShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
296
 
        bgl::blCompileShaderARB(tmpVert);
297
 
        bgl::blGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLint*) &vertlen);
 
269
        tmpVert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
 
270
        glShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
 
271
        glCompileShaderARB(tmpVert);
 
272
        glGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLint*) &vertlen);
298
273
        
299
274
        // print info if any
300
275
        if( vertlen > 0 && vertlen < MAX_LOG_LEN){
301
276
                logInf = (char*)MEM_mallocN(vertlen, "vert-log");
302
 
                bgl::blGetInfoLogARB(tmpVert, vertlen, (GLsizei*)&char_len, logInf);
 
277
                glGetInfoLogARB(tmpVert, vertlen, (GLsizei*)&char_len, logInf);
303
278
                if(char_len >0) {
304
279
                        spit("---- Vertex Shader Error ----");
305
280
                        spit(logInf);
308
283
                logInf=0;
309
284
        }
310
285
        // check for compile errors
311
 
        bgl::blGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB,(GLint*)&vertstatus);
 
286
        glGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB,(GLint*)&vertstatus);
312
287
        if(!vertstatus) {
313
288
                spit("---- Vertex shader failed to compile ----");
314
289
                goto programError;
315
290
        }
316
291
 
317
292
        // -- fragment shader ----------------
318
 
        tmpFrag = bgl::blCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
319
 
        bgl::blShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
320
 
        bgl::blCompileShaderARB(tmpFrag);
321
 
        bgl::blGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &fraglen);
 
293
        tmpFrag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
 
294
        glShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
 
295
        glCompileShaderARB(tmpFrag);
 
296
        glGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &fraglen);
322
297
        if(fraglen >0 && fraglen < MAX_LOG_LEN){
323
298
                logInf = (char*)MEM_mallocN(fraglen, "frag-log");
324
 
                bgl::blGetInfoLogARB(tmpFrag, fraglen,(GLsizei*) &char_len, logInf);
 
299
                glGetInfoLogARB(tmpFrag, fraglen,(GLsizei*) &char_len, logInf);
325
300
                if(char_len >0) {
326
301
                        spit("---- Fragment Shader Error ----");
327
302
                        spit(logInf);
330
305
                logInf=0;
331
306
        }
332
307
 
333
 
        bgl::blGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, (GLint*) &fragstatus);
 
308
        glGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, (GLint*) &fragstatus);
334
309
        if(!fragstatus){
335
310
                spit("---- Fragment shader failed to compile ----");
336
311
                goto programError;
339
314
        
340
315
        // -- program ------------------------
341
316
        //  set compiled vert/frag shader & link
342
 
        tmpProg = bgl::blCreateProgramObjectARB();
343
 
        bgl::blAttachObjectARB(tmpProg, tmpVert);
344
 
        bgl::blAttachObjectARB(tmpProg, tmpFrag);
345
 
        bgl::blLinkProgramARB(tmpProg);
346
 
        bgl::blGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &proglen);
347
 
        bgl::blGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &progstatus);
 
317
        tmpProg = glCreateProgramObjectARB();
 
318
        glAttachObjectARB(tmpProg, tmpVert);
 
319
        glAttachObjectARB(tmpProg, tmpFrag);
 
320
        glLinkProgramARB(tmpProg);
 
321
        glGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &proglen);
 
322
        glGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &progstatus);
348
323
        
349
324
 
350
325
        if(proglen > 0 && proglen < MAX_LOG_LEN) {
351
326
                logInf = (char*)MEM_mallocN(proglen, "prog-log");
352
 
                bgl::blGetInfoLogARB(tmpProg, proglen, (GLsizei*)&char_len, logInf);
 
327
                glGetInfoLogARB(tmpProg, proglen, (GLsizei*)&char_len, logInf);
353
328
                if(char_len >0) {
354
329
                        spit("---- GLSL Program ----");
355
330
                        spit(logInf);
365
340
 
366
341
        // set
367
342
        mShader = tmpProg;
368
 
        bgl::blDeleteObjectARB(tmpVert);
369
 
        bgl::blDeleteObjectARB(tmpFrag);
 
343
        glDeleteObjectARB(tmpVert);
 
344
        glDeleteObjectARB(tmpFrag);
370
345
        mOk             = 1;
371
346
        mError = 0;
372
347
        return true;
373
348
 
374
349
programError:
375
350
        if(tmpVert) {
376
 
                bgl::blDeleteObjectARB(tmpVert);
 
351
                glDeleteObjectARB(tmpVert);
377
352
                tmpVert=0;
378
353
        }
379
354
        if(tmpFrag) {
380
 
                bgl::blDeleteObjectARB(tmpFrag);
 
355
                glDeleteObjectARB(tmpFrag);
381
356
                tmpFrag=0;
382
357
        }
383
358
 
384
359
        if(tmpProg) {
385
 
                bgl::blDeleteObjectARB(tmpProg);
 
360
                glDeleteObjectARB(tmpProg);
386
361
                tmpProg=0;
387
362
        }
388
363
 
390
365
        mUse    = 0;
391
366
        mError  = 1;
392
367
        return false;
393
 
#else
394
 
        return false;
395
 
#endif//GL_ARB_shader_objects
396
368
}
397
369
 
398
370
const char *BL_Shader::GetVertPtr()
428
400
 
429
401
void BL_Shader::SetSampler(int loc, int unit)
430
402
{
431
 
#ifdef GL_ARB_shader_objects
432
 
        if( RAS_EXT_support._ARB_fragment_shader &&
433
 
                RAS_EXT_support._ARB_vertex_shader &&
434
 
                RAS_EXT_support._ARB_shader_objects 
 
403
        if( GLEW_ARB_fragment_shader &&
 
404
                GLEW_ARB_vertex_shader &&
 
405
                GLEW_ARB_shader_objects 
435
406
                )
436
407
        {
437
 
                bgl::blUniform1iARB(loc, unit);
 
408
                glUniform1iARB(loc, unit);
438
409
        }
439
 
#endif
440
410
}
441
411
//
442
412
//void BL_Shader::InitializeSampler(int unit, BL_Texture* texture)
449
419
 
450
420
void BL_Shader::SetProg(bool enable)
451
421
{
452
 
#ifdef GL_ARB_shader_objects
453
 
        if( RAS_EXT_support._ARB_fragment_shader &&
454
 
                RAS_EXT_support._ARB_vertex_shader &&
455
 
                RAS_EXT_support._ARB_shader_objects 
 
422
        if( GLEW_ARB_fragment_shader &&
 
423
                GLEW_ARB_vertex_shader &&
 
424
                GLEW_ARB_shader_objects 
456
425
                )
457
426
        {
458
427
                if(     mShader != 0 && mOk && enable) {
459
 
                        bgl::blUseProgramObjectARB(mShader);
 
428
                        glUseProgramObjectARB(mShader);
460
429
                }
461
430
                else {
462
 
                        bgl::blUseProgramObjectARB(0);  
 
431
                        glUseProgramObjectARB(0);       
463
432
                }
464
433
        }
465
 
#endif
466
434
}
467
435
 
468
 
void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
 
436
void BL_Shader::Update( const RAS_MeshSlot & ms, RAS_IRasterizer* rasty )
469
437
{
470
 
#ifdef GL_ARB_shader_objects
471
438
        if(!Ok() || !mPreDef.size()) 
472
439
                return;
473
440
 
474
 
        if( RAS_EXT_support._ARB_fragment_shader &&
475
 
                RAS_EXT_support._ARB_vertex_shader &&
476
 
                RAS_EXT_support._ARB_shader_objects 
 
441
        if( GLEW_ARB_fragment_shader &&
 
442
                GLEW_ARB_vertex_shader &&
 
443
                GLEW_ARB_shader_objects 
477
444
                )
478
445
        {
479
446
                MT_Matrix4x4 model;
480
447
                model.setValue(ms.m_OpenGLMatrix);
481
 
                MT_Matrix4x4 view;
482
 
                rasty->GetViewMatrix(view);
 
448
                const MT_Matrix4x4& view = rasty->GetViewMatrix();
483
449
 
484
450
                if(mAttr==SHD_TANGENT)
485
451
                         ms.m_mesh->SetMeshModified(true);
558
524
                                        }
559
525
                                case VIEWMATRIX_INVERSE:
560
526
                                        {
561
 
                                                view.invert();
 
527
                                                MT_Matrix4x4 viewinv = view;
 
528
                                                viewinv.invert();
562
529
                                                SetUniform(uni->mLoc, view);
563
530
                                                break;
564
531
                                        }
565
532
                                case VIEWMATRIX_INVERSETRANSPOSE:
566
533
                                        {
567
 
                                                view.invert();
 
534
                                                MT_Matrix4x4 viewinv = view;
 
535
                                                viewinv.invert();
568
536
                                                SetUniform(uni->mLoc, view, true);
569
537
                                                break;
570
538
                                        }
578
546
                        }
579
547
                }
580
548
        }
581
 
#endif
582
549
}
583
550
 
584
551
 
585
552
int BL_Shader::GetAttribLocation(const STR_String& name)
586
553
{
587
 
#ifdef GL_ARB_shader_objects
588
 
        if( RAS_EXT_support._ARB_fragment_shader &&
589
 
                RAS_EXT_support._ARB_vertex_shader &&
590
 
                RAS_EXT_support._ARB_shader_objects 
 
554
        if( GLEW_ARB_fragment_shader &&
 
555
                GLEW_ARB_vertex_shader &&
 
556
                GLEW_ARB_shader_objects 
591
557
                )
592
558
        {
593
 
                return bgl::blGetAttribLocationARB(mShader, name.ReadPtr());
 
559
                return glGetAttribLocationARB(mShader, name.ReadPtr());
594
560
        }
595
 
#endif
 
561
 
596
562
        return -1;
597
563
}
598
564
 
599
565
void BL_Shader::BindAttribute(const STR_String& attr, int loc)
600
566
{
601
 
#ifdef GL_ARB_shader_objects
602
 
        if( RAS_EXT_support._ARB_fragment_shader &&
603
 
                RAS_EXT_support._ARB_vertex_shader &&
604
 
                RAS_EXT_support._ARB_shader_objects 
 
567
        if( GLEW_ARB_fragment_shader &&
 
568
                GLEW_ARB_vertex_shader &&
 
569
                GLEW_ARB_shader_objects 
605
570
                )
606
571
        {
607
 
                bgl::blBindAttribLocationARB(mShader, loc, attr.ReadPtr());
 
572
                glBindAttribLocationARB(mShader, loc, attr.ReadPtr());
608
573
        }
609
 
#endif
610
574
}
611
575
 
612
576
int BL_Shader::GetUniformLocation(const STR_String& name)
613
577
{
614
 
#ifdef GL_ARB_shader_objects
615
 
        if( RAS_EXT_support._ARB_fragment_shader &&
616
 
                RAS_EXT_support._ARB_vertex_shader &&
617
 
                RAS_EXT_support._ARB_shader_objects 
 
578
        if( GLEW_ARB_fragment_shader &&
 
579
                GLEW_ARB_vertex_shader &&
 
580
                GLEW_ARB_shader_objects 
618
581
                )
619
582
        {
620
583
                MT_assert(mShader!=0);
621
 
                int location = bgl::blGetUniformLocationARB(mShader, name.ReadPtr());
 
584
                int location = glGetUniformLocationARB(mShader, name.ReadPtr());
622
585
                if(location == -1)
623
586
                        spit("Invalid uniform value: " << name.ReadPtr() << ".");
624
587
                return location;
625
588
        }
626
 
#endif
 
589
 
627
590
        return -1;
628
591
}
629
592
 
630
593
void BL_Shader::SetUniform(int uniform, const MT_Tuple2& vec)
631
594
{
632
 
#ifdef GL_ARB_shader_objects
633
 
        if( RAS_EXT_support._ARB_fragment_shader &&
634
 
                RAS_EXT_support._ARB_vertex_shader &&
635
 
                RAS_EXT_support._ARB_shader_objects 
 
595
        if( GLEW_ARB_fragment_shader &&
 
596
                GLEW_ARB_vertex_shader &&
 
597
                GLEW_ARB_shader_objects 
636
598
                )
637
599
        {
638
600
                float value[2];
639
601
                vec.getValue(value);
640
 
                bgl::blUniform2fvARB(uniform, 1, value);
 
602
                glUniform2fvARB(uniform, 1, value);
641
603
        }
642
 
#endif
643
604
 
644
605
}
645
606
 
646
607
void BL_Shader::SetUniform(int uniform, const MT_Tuple3& vec)
647
608
{
648
 
#ifdef GL_ARB_shader_objects
649
 
        if( RAS_EXT_support._ARB_fragment_shader &&
650
 
                RAS_EXT_support._ARB_vertex_shader &&
651
 
                RAS_EXT_support._ARB_shader_objects 
 
609
        if( GLEW_ARB_fragment_shader &&
 
610
                GLEW_ARB_vertex_shader &&
 
611
                GLEW_ARB_shader_objects 
652
612
                )
653
613
        {       
654
614
                float value[3];
655
615
                vec.getValue(value);
656
 
                bgl::blUniform3fvARB(uniform, 1, value);
 
616
                glUniform3fvARB(uniform, 1, value);
657
617
        }
658
 
#endif
659
618
}
660
619
 
661
620
void BL_Shader::SetUniform(int uniform, const MT_Tuple4& vec)
662
621
{
663
 
#ifdef GL_ARB_shader_objects
664
 
        if( RAS_EXT_support._ARB_fragment_shader &&
665
 
                RAS_EXT_support._ARB_vertex_shader &&
666
 
                RAS_EXT_support._ARB_shader_objects 
 
622
        if( GLEW_ARB_fragment_shader &&
 
623
                GLEW_ARB_vertex_shader &&
 
624
                GLEW_ARB_shader_objects 
667
625
                )
668
626
        {
669
627
                float value[4];
670
628
                vec.getValue(value);
671
 
                bgl::blUniform4fvARB(uniform, 1, value);
 
629
                glUniform4fvARB(uniform, 1, value);
672
630
        }
673
 
#endif
674
631
}
675
632
 
676
633
void BL_Shader::SetUniform(int uniform, const unsigned int& val)
677
634
{
678
 
#ifdef GL_ARB_shader_objects
679
 
        if( RAS_EXT_support._ARB_fragment_shader &&
680
 
                RAS_EXT_support._ARB_vertex_shader &&
681
 
                RAS_EXT_support._ARB_shader_objects 
 
635
        if( GLEW_ARB_fragment_shader &&
 
636
                GLEW_ARB_vertex_shader &&
 
637
                GLEW_ARB_shader_objects 
682
638
                )
683
639
        {
684
 
                bgl::blUniform1iARB(uniform, val);
 
640
                glUniform1iARB(uniform, val);
685
641
        }
686
 
#endif
687
642
}
688
643
 
689
644
void BL_Shader::SetUniform(int uniform, const int val)
690
645
{
691
 
#ifdef GL_ARB_shader_objects
692
 
        if( RAS_EXT_support._ARB_fragment_shader &&
693
 
                RAS_EXT_support._ARB_vertex_shader &&
694
 
                RAS_EXT_support._ARB_shader_objects 
 
646
        if( GLEW_ARB_fragment_shader &&
 
647
                GLEW_ARB_vertex_shader &&
 
648
                GLEW_ARB_shader_objects 
695
649
                )
696
650
        {
697
 
                bgl::blUniform1iARB(uniform, val);
 
651
                glUniform1iARB(uniform, val);
698
652
        }
699
 
#endif
700
653
}
701
654
 
702
655
void BL_Shader::SetUniform(int uniform, const float& val)
703
656
{
704
 
#ifdef GL_ARB_shader_objects
705
 
        if( RAS_EXT_support._ARB_fragment_shader &&
706
 
                RAS_EXT_support._ARB_vertex_shader &&
707
 
                RAS_EXT_support._ARB_shader_objects 
 
657
        if( GLEW_ARB_fragment_shader &&
 
658
                GLEW_ARB_vertex_shader &&
 
659
                GLEW_ARB_shader_objects 
708
660
                )
709
661
        {
710
 
                bgl::blUniform1fARB(uniform, val);
 
662
                glUniform1fARB(uniform, val);
711
663
        }
712
 
#endif
713
664
}
714
665
 
715
666
void BL_Shader::SetUniform(int uniform, const MT_Matrix4x4& vec, bool transpose)
716
667
{
717
 
#ifdef GL_ARB_shader_objects
718
 
        if( RAS_EXT_support._ARB_fragment_shader &&
719
 
                RAS_EXT_support._ARB_vertex_shader &&
720
 
                RAS_EXT_support._ARB_shader_objects 
 
668
        if( GLEW_ARB_fragment_shader &&
 
669
                GLEW_ARB_vertex_shader &&
 
670
                GLEW_ARB_shader_objects 
721
671
                )
722
672
        {
723
673
                float value[16];
 
674
                // note: getValue gives back column major as needed by OpenGL
724
675
                vec.getValue(value);
725
 
                bgl::blUniformMatrix4fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
 
676
                glUniformMatrix4fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
726
677
        }
727
 
#endif
728
678
}
729
679
 
730
680
void BL_Shader::SetUniform(int uniform, const MT_Matrix3x3& vec, bool transpose)
731
681
{
732
 
#ifdef GL_ARB_shader_objects
733
 
        if( RAS_EXT_support._ARB_fragment_shader &&
734
 
                RAS_EXT_support._ARB_vertex_shader &&
735
 
                RAS_EXT_support._ARB_shader_objects 
 
682
        if( GLEW_ARB_fragment_shader &&
 
683
                GLEW_ARB_vertex_shader &&
 
684
                GLEW_ARB_shader_objects 
736
685
                )
737
686
        {
738
687
                float value[9];
739
688
                value[0] = (float)vec[0][0]; value[1] = (float)vec[1][0]; value[2] = (float)vec[2][0]; 
740
689
                value[3] = (float)vec[0][1]; value[4] = (float)vec[1][1]; value[5] = (float)vec[2][1]; 
741
690
                value[6] = (float)vec[0][2]; value[7] = (float)vec[1][2]; value[7] = (float)vec[2][2]; 
742
 
                bgl::blUniformMatrix3fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
 
691
                glUniformMatrix3fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
743
692
        }
744
 
#endif
745
693
}
746
694
 
747
695
void BL_Shader::SetUniform(int uniform, const float* val, int len)
748
696
{
749
 
#ifdef GL_ARB_shader_objects
750
 
        if( RAS_EXT_support._ARB_fragment_shader &&
751
 
                RAS_EXT_support._ARB_vertex_shader &&
752
 
                RAS_EXT_support._ARB_shader_objects 
 
697
        if( GLEW_ARB_fragment_shader &&
 
698
                GLEW_ARB_vertex_shader &&
 
699
                GLEW_ARB_shader_objects 
753
700
                )
754
701
        {
755
702
                if(len == 2) 
756
 
                        bgl::blUniform2fvARB(uniform, 1,(GLfloat*)val);
 
703
                        glUniform2fvARB(uniform, 1,(GLfloat*)val);
757
704
                else if (len == 3)
758
 
                        bgl::blUniform3fvARB(uniform, 1,(GLfloat*)val);
 
705
                        glUniform3fvARB(uniform, 1,(GLfloat*)val);
759
706
                else if (len == 4)
760
 
                        bgl::blUniform4fvARB(uniform, 1,(GLfloat*)val);
 
707
                        glUniform4fvARB(uniform, 1,(GLfloat*)val);
761
708
                else
762
709
                        MT_assert(0);
763
710
        }
764
 
#endif
765
711
}
766
712
 
767
713
void BL_Shader::SetUniform(int uniform, const int* val, int len)
768
714
{
769
 
#ifdef GL_ARB_shader_objects
770
 
        if( RAS_EXT_support._ARB_fragment_shader &&
771
 
                RAS_EXT_support._ARB_vertex_shader &&
772
 
                RAS_EXT_support._ARB_shader_objects 
 
715
        if( GLEW_ARB_fragment_shader &&
 
716
                GLEW_ARB_vertex_shader &&
 
717
                GLEW_ARB_shader_objects 
773
718
                )
774
719
        {
775
720
                if(len == 2) 
776
 
                        bgl::blUniform2ivARB(uniform, 1, (GLint*)val);
 
721
                        glUniform2ivARB(uniform, 1, (GLint*)val);
777
722
                else if (len == 3)
778
 
                        bgl::blUniform3ivARB(uniform, 1, (GLint*)val);
 
723
                        glUniform3ivARB(uniform, 1, (GLint*)val);
779
724
                else if (len == 4)
780
 
                        bgl::blUniform4ivARB(uniform, 1, (GLint*)val);
 
725
                        glUniform4ivARB(uniform, 1, (GLint*)val);
781
726
                else
782
727
                        MT_assert(0);
783
728
        }
784
 
#endif
785
729
}
786
730
 
787
731
 
849
793
 
850
794
KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProgram)" )
851
795
{
852
 
#ifdef GL_ARB_shader_objects
853
796
        if(mShader !=0 && mOk  )
854
797
        {
855
798
                // already set...
862
805
                vertProg = v;
863
806
                fragProg = f;
864
807
                if( LinkProgram() ) {
865
 
                        bgl::blUseProgramObjectARB( mShader );
 
808
                        glUseProgramObjectARB( mShader );
866
809
                        mUse = apply!=0;
867
810
                        Py_Return;
868
811
                }
872
815
                Py_Return;
873
816
        }
874
817
        return NULL;
875
 
#else
876
 
        Py_Return;
877
 
#endif
878
818
}
879
819
 
880
820
 
881
821
KX_PYMETHODDEF_DOC( BL_Shader, delSource, "delSource( )" )
882
822
{
883
 
#ifdef GL_ARB_shader_objects
884
823
        ClearUniforms();
885
 
        bgl::blUseProgramObjectARB(0);
 
824
        glUseProgramObjectARB(0);
886
825
 
887
 
        bgl::blDeleteObjectARB(mShader);
 
826
        glDeleteObjectARB(mShader);
888
827
        mShader         = 0;
889
828
        mOk                     = 0;
890
829
        mUse            = 0;
891
 
#endif
892
830
        Py_Return;
893
831
}
894
832
 
909
847
 
910
848
KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
911
849
{
912
 
#ifdef GL_ARB_shader_objects
913
850
        if(mError) {
914
 
                Py_INCREF(Py_None);
915
 
                return Py_None;
 
851
                Py_RETURN_NONE;
916
852
        }
917
853
        if(mShader==0) {
918
854
                PyErr_Format(PyExc_TypeError, "invalid shader object");
919
855
                return NULL;
920
856
        }
921
857
        int stat = 0;
922
 
        bgl::blValidateProgramARB(mShader);
923
 
        bgl::blGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB,(GLint*) &stat);
 
858
        glValidateProgramARB(mShader);
 
859
        glGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB,(GLint*) &stat);
924
860
 
925
861
 
926
862
        if(stat > 0 && stat < MAX_LOG_LEN) {
927
863
                int char_len=0;
928
864
                char *logInf = (char*)MEM_mallocN(stat, "validate-log");
929
865
 
930
 
                bgl::blGetInfoLogARB(mShader, stat,(GLsizei*) &char_len, logInf);
 
866
                glGetInfoLogARB(mShader, stat,(GLsizei*) &char_len, logInf);
931
867
                if(char_len >0) {
932
868
                        spit("---- GLSL Validation ----");
933
869
                        spit(logInf);
935
871
                MEM_freeN(logInf);
936
872
                logInf=0;
937
873
        }
938
 
#endif//GL_ARB_shader_objects
939
874
        Py_Return;
940
875
}
941
876
 
943
878
KX_PYMETHODDEF_DOC( BL_Shader, setSampler, "setSampler(name, index)" )
944
879
{
945
880
        if(mError) {
946
 
                Py_INCREF(Py_None);
947
 
                return Py_None;
 
881
                Py_RETURN_NONE;
948
882
        }
949
883
 
950
 
        char *uniform="";
 
884
        const char *uniform="";
951
885
        int index=-1;
952
886
        if(PyArg_ParseTuple(args, "si", &uniform, &index)) 
953
887
        {
966
900
                        //else
967
901
                        //      spit("Invalid texture sample index: " << index);
968
902
                }
969
 
                Py_Return;
 
903
                Py_RETURN_NONE;
970
904
        }
971
905
        return NULL;
972
906
}
985
919
KX_PYMETHODDEF_DOC( BL_Shader, setUniform1f, "setUniform1f(name, fx)" )
986
920
{
987
921
        if(mError) {
988
 
                Py_INCREF(Py_None);
989
 
                return Py_None;
 
922
                Py_RETURN_NONE;
990
923
        }
991
924
 
992
 
        char *uniform="";
 
925
        const char *uniform="";
993
926
        float value=0;
994
927
        if(PyArg_ParseTuple(args, "sf", &uniform, &value ))
995
928
        {
1011
944
KX_PYMETHODDEF_DOC( BL_Shader, setUniform2f , "setUniform2f(name, fx, fy)")
1012
945
{
1013
946
        if(mError) {
1014
 
                Py_INCREF(Py_None);
1015
 
                return Py_None;
 
947
                Py_RETURN_NONE;
1016
948
        }
1017
 
        char *uniform="";
 
949
        const char *uniform="";
1018
950
        float array[2]={ 0,0 };
1019
951
        if(PyArg_ParseTuple(args, "sff", &uniform, &array[0],&array[1] ))
1020
952
        {
1036
968
KX_PYMETHODDEF_DOC( BL_Shader, setUniform3f, "setUniform3f(name, fx,fy,fz) ")
1037
969
{
1038
970
        if(mError) {
1039
 
                Py_INCREF(Py_None);
1040
 
                return Py_None;
 
971
                Py_RETURN_NONE;
1041
972
        }
1042
 
        char *uniform="";
 
973
        const char *uniform="";
1043
974
        float array[3]={0,0,0};
1044
975
        if(PyArg_ParseTuple(args, "sfff", &uniform, &array[0],&array[1],&array[2]))
1045
976
        {
1062
993
KX_PYMETHODDEF_DOC( BL_Shader, setUniform4f, "setUniform4f(name, fx,fy,fz, fw) ")
1063
994
{
1064
995
        if(mError) {
1065
 
                Py_INCREF(Py_None);
1066
 
                return Py_None;
 
996
                Py_RETURN_NONE;
1067
997
        }
1068
 
        char *uniform="";
 
998
        const char *uniform="";
1069
999
        float array[4]={0,0,0,0};
1070
1000
        if(PyArg_ParseTuple(args, "sffff", &uniform, &array[0],&array[1],&array[2], &array[3]))
1071
1001
        {
1087
1017
KX_PYMETHODDEF_DOC( BL_Shader, setUniform1i, "setUniform1i(name, ix)" )
1088
1018
{
1089
1019
        if(mError) {
1090
 
                Py_INCREF(Py_None);
1091
 
                return Py_None;
 
1020
                Py_RETURN_NONE;
1092
1021
        }
1093
 
        char *uniform="";
 
1022
        const char *uniform="";
1094
1023
        int value=0;
1095
1024
        if(PyArg_ParseTuple(args, "si", &uniform, &value ))
1096
1025
        {
1112
1041
KX_PYMETHODDEF_DOC( BL_Shader, setUniform2i , "setUniform2i(name, ix, iy)")
1113
1042
{
1114
1043
        if(mError) {
1115
 
                Py_INCREF(Py_None);
1116
 
                return Py_None;
 
1044
                Py_RETURN_NONE;
1117
1045
        }
1118
 
        char *uniform="";
 
1046
        const char *uniform="";
1119
1047
        int array[2]={ 0,0 };
1120
1048
        if(PyArg_ParseTuple(args, "sii", &uniform, &array[0],&array[1] ))
1121
1049
        {
1137
1065
KX_PYMETHODDEF_DOC( BL_Shader, setUniform3i, "setUniform3i(name, ix,iy,iz) ")
1138
1066
{
1139
1067
        if(mError) {
1140
 
                Py_INCREF(Py_None);
1141
 
                return Py_None;
 
1068
                Py_RETURN_NONE;
1142
1069
        }
1143
1070
 
1144
 
        char *uniform="";
 
1071
        const char *uniform="";
1145
1072
        int array[3]={0,0,0};
1146
1073
        if(PyArg_ParseTuple(args, "siii", &uniform, &array[0],&array[1],&array[2]))
1147
1074
        {
1162
1089
KX_PYMETHODDEF_DOC( BL_Shader, setUniform4i, "setUniform4i(name, ix,iy,iz, iw) ")
1163
1090
{
1164
1091
        if(mError) {
1165
 
                Py_INCREF(Py_None);
1166
 
                return Py_None;
 
1092
                Py_RETURN_NONE;
1167
1093
        }
1168
 
        char *uniform="";
 
1094
        const char *uniform="";
1169
1095
        int array[4]={0,0,0, 0};
1170
1096
        if(PyArg_ParseTuple(args, "siiii", &uniform, &array[0],&array[1],&array[2], &array[3] ))
1171
1097
        {
1186
1112
KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or list3 or list4) )")
1187
1113
{
1188
1114
        if(mError) {
1189
 
                Py_INCREF(Py_None);
1190
 
                return Py_None;
 
1115
                Py_RETURN_NONE;
1191
1116
        }
1192
 
        char*uniform = "";
 
1117
        const char *uniform = "";
1193
1118
        PyObject *listPtr =0;
1194
1119
        float array_data[4] = {0.f,0.f,0.f,0.f};
1195
1120
 
1256
1181
KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3 or list4) )")
1257
1182
{
1258
1183
        if(mError) {
1259
 
                Py_INCREF(Py_None);
1260
 
                return Py_None;
 
1184
                Py_RETURN_NONE;
1261
1185
        }
1262
 
        char*uniform = "";
 
1186
        const char *uniform = "";
1263
1187
        PyObject *listPtr =0;
1264
1188
        int array_data[4] = {0,0,0,0};
1265
1189
 
1329
1253
"setUniformMatrix4(uniform-name, mat-4x4, transpose(row-major=true, col-major=false)" )
1330
1254
{
1331
1255
        if(mError) {
1332
 
                Py_INCREF(Py_None);
1333
 
                return Py_None;
 
1256
                Py_RETURN_NONE;
1334
1257
        }
1335
1258
 
1336
1259
        float matr[16] = {
1340
1263
                0,0,0,1
1341
1264
        };
1342
1265
 
1343
 
        char *uniform="";
 
1266
        const char *uniform="";
1344
1267
        PyObject *matrix=0;
1345
1268
        int transp=1; // MT_ is row major so transpose by default....
1346
1269
        if(PyArg_ParseTuple(args, "sO|i",&uniform, &matrix,&transp))
1372
1295
"setUniformMatrix3(uniform-name, list[3x3], transpose(row-major=true, col-major=false)" )
1373
1296
{
1374
1297
        if(mError) {
1375
 
                Py_INCREF(Py_None);
1376
 
                return Py_None;
 
1298
                Py_RETURN_NONE;
1377
1299
        }
1378
1300
 
1379
1301
        float matr[9] = {
1382
1304
                0,0,1,
1383
1305
        };
1384
1306
 
1385
 
        char *uniform="";
 
1307
        const char *uniform="";
1386
1308
        PyObject *matrix=0;
1387
1309
        int transp=1; // MT_ is row major so transpose by default....
1388
1310
        if(PyArg_ParseTuple(args, "sO|i",&uniform, &matrix,&transp))
1412
1334
 
1413
1335
KX_PYMETHODDEF_DOC( BL_Shader, setAttrib, "setAttrib(enum)" )
1414
1336
{
1415
 
#ifdef GL_ARB_shader_objects
1416
1337
        if(mError) {
1417
 
                Py_INCREF(Py_None);
1418
 
                return Py_None;
 
1338
                Py_RETURN_NONE;
1419
1339
        }
1420
1340
        int attr=0;
1421
1341
        if(PyArg_ParseTuple(args, "i", &attr )) {
1424
1344
                        return NULL;
1425
1345
                }
1426
1346
                mAttr=SHD_TANGENT;
1427
 
                bgl::blUseProgramObjectARB(mShader);
1428
 
                bgl::blBindAttribLocationARB(mShader, mAttr, "Tangent");
 
1347
                glUseProgramObjectARB(mShader);
 
1348
                glBindAttribLocationARB(mShader, mAttr, "Tangent");
1429
1349
                Py_Return;
1430
1350
        }
1431
 
#endif
1432
1351
        return NULL;
1433
1352
}
1434
1353
 
1436
1355
KX_PYMETHODDEF_DOC( BL_Shader, setUniformDef, "setUniformDef(name, enum)" )
1437
1356
{
1438
1357
        if(mError) {
1439
 
                Py_INCREF(Py_None);
1440
 
                return Py_None;
 
1358
                Py_RETURN_NONE;
1441
1359
        }
1442
1360
 
1443
 
        char *uniform="";
 
1361
        const char *uniform="";
1444
1362
        int nloc=0;
1445
1363
        if(PyArg_ParseTuple(args, "si",&uniform, &nloc))
1446
1364
        {