simgear/screen/shader.cpp

   1 /* Shader
   2  *
   3  * Copyright (C) 2003-2005, Alexander Zaprjagaev <frustum@frustum.org>
   4  *                          Roman Grigoriev <grigoriev@gosniias.ru>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include <simgear_config.h>
  23 #endif
  24
  25 #include <simgear/debug/logstream.hxx>
  26 #include "shader.h"
  27 #include <stdio.h>
  28 #include <stdarg.h>
  29
  30
  31 glVertexAttrib1dProc glVertexAttrib1dPtr = NULL;
  32 glVertexAttrib1dvProc glVertexAttrib1dvPtr = NULL;
  33 glVertexAttrib1fProc glVertexAttrib1fPtr = NULL;
  34 glVertexAttrib1fvProc glVertexAttrib1fvPtr = NULL;
  35 glVertexAttrib1sProc glVertexAttrib1sPtr  = NULL;
  36 glVertexAttrib1svProc glVertexAttrib1svPtr  = NULL;
  37 glVertexAttrib2dProc glVertexAttrib2dPtr  = NULL;
  38 glVertexAttrib2dvProc glVertexAttrib2dvPtr  = NULL;
  39 glVertexAttrib2fProc glVertexAttrib2fPtr  = NULL;
  40 glVertexAttrib2fvProc glVertexAttrib2fvPtr  = NULL;
  41 glVertexAttrib2sProc glVertexAttrib2sPtr  = NULL;
  42 glVertexAttrib2svProc glVertexAttrib2svPtr  = NULL;
  43 glVertexAttrib3dProc glVertexAttrib3dPtr  = NULL;
  44 glVertexAttrib3dvProc glVertexAttrib3dvPtr  = NULL;
  45 glVertexAttrib3fProc glVertexAttrib3fPtr  = NULL;
  46 glVertexAttrib3fvProc glVertexAttrib3fvPtr  = NULL;
  47 glVertexAttrib3sProc glVertexAttrib3sPtr  = NULL;
  48 glVertexAttrib3svProc glVertexAttrib3svPtr  = NULL;
  49 glVertexAttrib4NbvProc glVertexAttrib4NbvPtr  = NULL;
  50 glVertexAttrib4NivProc glVertexAttrib4NivPtr  = NULL;
  51 glVertexAttrib4NsvProc glVertexAttrib4NsvPtr  = NULL;
  52 glVertexAttrib4NubProc glVertexAttrib4NubPtr  = NULL;
  53 glVertexAttrib4NubvProc glVertexAttrib4NubvPtr  = NULL;
  54 glVertexAttrib4NuivProc glVertexAttrib4NuivPtr  = NULL;
  55 glVertexAttrib4NusvProc glVertexAttrib4NusvPtr  = NULL;
  56 glVertexAttrib4bvProc glVertexAttrib4bvPtr  = NULL;
  57 glVertexAttrib4dProc glVertexAttrib4dPtr  = NULL;
  58 glVertexAttrib4dvProc glVertexAttrib4dvPtr  = NULL;
  59 glVertexAttrib4fProc glVertexAttrib4fPtr  = NULL;
  60 glVertexAttrib4fvProc glVertexAttrib4fvPtr  = NULL;
  61 glVertexAttrib4ivProc glVertexAttrib4ivPtr  = NULL;
  62 glVertexAttrib4sProc glVertexAttrib4sPtr  = NULL;
  63 glVertexAttrib4svProc glVertexAttrib4svPtr  = NULL;
  64 glVertexAttrib4ubvProc glVertexAttrib4ubvPtr  = NULL;
  65 glVertexAttrib4uivProc glVertexAttrib4uivPtr  = NULL;
  66 glVertexAttrib4usvProc glVertexAttrib4usvPtr  = NULL;
  67 glVertexAttribPointerProc glVertexAttribPointerPtr  = NULL;
  68 glEnableVertexAttribArrayProc glEnableVertexAttribArrayPtr  = NULL;
  69 glDisableVertexAttribArrayProc glDisableVertexAttribArrayPtr  = NULL;
  70 glProgramStringProc glProgramStringPtr  = NULL;
  71 glBindProgramProc glBindProgramPtr  = NULL;
  72 glDeleteProgramsProc glDeleteProgramsPtr  = NULL;
  73 glGenProgramsProc glGenProgramsPtr  = NULL;
  74 glProgramEnvParameter4dProc glProgramEnvParameter4dPtr  = NULL;
  75 glProgramEnvParameter4dvProc glProgramEnvParameter4dvPtr  = NULL;
  76 glProgramEnvParameter4fProc glProgramEnvParameter4fPtr  = NULL;
  77 glProgramEnvParameter4fvProc glProgramEnvParameter4fvPtr  = NULL;
  78 glProgramLocalParameter4dProc glProgramLocalParameter4dPtr  = NULL;
  79 glProgramLocalParameter4dvProc glProgramLocalParameter4dvPtr  = NULL;
  80 glProgramLocalParameter4fProc glProgramLocalParameter4fPtr  = NULL;
  81 glProgramLocalParameter4fvProc glProgramLocalParameter4fvPtr  = NULL;
  82 glGetProgramEnvParameterdvProc glGetProgramEnvParameterdvPtr  = NULL;
  83 glGetProgramEnvParameterfvProc glGetProgramEnvParameterfvPtr  = NULL;
  84 glGetProgramLocalParameterdvProc glGetProgramLocalParameterdvPtr  = NULL;
  85 glGetProgramLocalParameterfvProc glGetProgramLocalParameterfvPtr  = NULL;
  86 glGetProgramivProc glGetProgramivPtr  = NULL;
  87 glGetProgramStringProc glGetProgramStringPtr  = NULL;
  88 glGetVertexAttribdvProc glGetVertexAttribdvPtr  = NULL;
  89 glGetVertexAttribfvProc glGetVertexAttribfvPtr  = NULL;
  90 glGetVertexAttribivProc glGetVertexAttribivPtr  = NULL;
  91 glGetVertexAttribPointervProc glGetVertexAttribPointervPtr  = NULL;
  92 glIsProgramProc glIsProgramPtr  = NULL;
  93
  94 glDeleteObjectProc glDeleteObjectPtr = NULL;
  95 glGetHandleProc glGetHandlePtr = NULL;
  96 glDetachObjectProc glDetachObjectPtr = NULL;
  97 glCreateShaderObjectProc glCreateShaderObjectPtr = NULL;
  98 glShaderSourceProc glShaderSourcePtr = NULL;
  99 glCompileShaderProc glCompileShaderPtr = NULL;
 100 glCreateProgramObjectProc glCreateProgramObjectPtr = NULL;
 101 glAttachObjectProc glAttachObjectPtr = NULL;
 102 glLinkProgramProc glLinkProgramPtr = NULL;
 103 glUseProgramObjectProc glUseProgramObjectPtr = NULL;
 104 glValidateProgramProc glValidateProgramPtr = NULL;
 105 glUniform1fProc glUniform1fPtr = NULL;
 106 glUniform2fProc glUniform2fPtr = NULL;
 107 glUniform3fProc glUniform3fPtr = NULL;
 108 glUniform4fProc glUniform4fPtr = NULL;
 109 glUniform1iProc glUniform1iPtr = NULL;
 110 glUniform2iProc glUniform2iPtr = NULL;
 111 glUniform3iProc glUniform3iPtr = NULL;
 112 glUniform4iProc glUniform4iPtr = NULL;
 113 glUniform1fvProc glUniform1fvPtr = NULL;
 114 glUniform2fvProc glUniform2fvPtr = NULL;
 115 glUniform3fvProc glUniform3fvPtr = NULL;
 116 glUniform4fvProc glUniform4fvPtr = NULL;
 117 glUniform1ivProc glUniform1ivPtr = NULL;
 118 glUniform2ivProc glUniform2ivPtr = NULL;
 119 glUniform3ivProc glUniform3ivPtr = NULL;
 120 glUniform4ivProc glUniform4ivPtr = NULL;
 121 glUniformMatrix2fvProc glUniformMatrix2fvPtr = NULL;
 122 glUniformMatrix3fvProc glUniformMatrix3fvPtr = NULL;
 123 glUniformMatrix4fvProc glUniformMatrix4fvPtr = NULL;
 124 glGetObjectParameterfvProc glGetObjectParameterfvPtr = NULL;
 125 glGetObjectParameterivProc glGetObjectParameterivPtr = NULL;
 126 glGetInfoLogProc glGetInfoLogPtr = NULL;
 127 glGetAttachedObjectsProc glGetAttachedObjectsPtr = NULL;
 128 glGetUniformLocationProc glGetUniformLocationPtr = NULL;
 129 glGetActiveUniformProc glGetActiveUniformPtr = NULL;
 130 glGetUniformfvProc glGetUniformfvPtr = NULL;
 131 glGetUniformivProc glGetUniformivPtr = NULL;
 132 glGetShaderSourceProc glGetShaderSourcePtr = NULL;
 133
 134 glBindAttribLocationProc glBindAttribLocationPtr = NULL;
 135 glGetActiveAttribProc glGetActiveAttribPtr = NULL;
 136 glGetAttribLocationProc glGetAttribLocationPtr = NULL;
 137
 138 glBindProgramNVProc glBindProgramNVPtr = NULL;
 139 glDeleteProgramsNVProc glDeleteProgramsNVPtr = NULL;
 140 glGenProgramsNVProc glGenProgramsNVPtr = NULL;
 141 glLoadProgramNVProc glLoadProgramNVPtr = NULL;
 142 glProgramParameter4fvNVProc glProgramParameter4fvNVPtr = NULL;
 143
 144 bool Shader::VP_supported = false;
 145 bool Shader::FP_supported = false;
 146 bool Shader::GLSL_supported = false;
 147 bool Shader::NVFP_supported = false;
 148 GLint Shader::nb_texture_unit = 0;
 149
 150 Shader::Shader(const char *name,const char *vertex,const char *fragment) {
 151
 152         program = 0;
 153         vertex_target = 0;
 154         vertex_id = 0;
 155         fragment_target = 0;
 156         fragment_id = 0;
 157
 158         char *data;
 159         FILE *file = fopen(name,"rb");
 160         if(!file) {
 161         SG_LOG(SG_GL, SG_ALERT, "Shader::Shader(): can't open '" << name << "' file\n");
 162                 return;
 163         }
 164
 165         fseek(file,0,SEEK_END);
 166         int size = ftell(file);
 167         data = new char[size + 1];
 168         data[size] = '\0';
 169         fseek(file,0,SEEK_SET);
 170         fread(data,1,size,file);
 171         fclose(file);
 172
 173         // skip comments
 174         char *s = data;
 175         char *d = data;
 176         while(*s) {
 177                 if(*s == '/' && *(s + 1) == '/') {
 178                         while(*s && *s != '\n') s++;
 179                         while(*s && *s == '\n') s++;
 180                         *d++ = '\n';
 181                 }
 182                 else if(*s == '/' && *(s + 1) == '*') {
 183                         while(*s && (*s != '*' || *(s + 1) != '/')) s++;
 184                         s += 2;
 185                         while(*s && *s == '\n') s++;
 186                         *d++ = '\n';
 187                 }
 188                 else *d++ = *s++;
 189         }
 190         *d = '\0';
 191
 192         // find shaders
 193         char *vertex_src = NULL;
 194         char *fragment_src = NULL;
 195         s = data;
 196         while(*s) {
 197                 if(*s == '<') {
 198                         char *name = s;
 199                         while(*s) {
 200                                 if(strchr("> \t\n\r",*s)) break;
 201                                 s++;
 202                         }
 203                         if(*s == '>') {         // it`s shader
 204                                 *name++ = '\0';
 205                                 *s++ = '\0';
 206                                 while(*s && strchr(" \t\n\r",*s)) s++;
 207                                 if(vertex == NULL && !strcmp(name,"vertex")) vertex_src = s;
 208                                 if(vertex && !strcmp(name,vertex)) vertex_src = s;
 209                                 if(fragment == NULL && !strcmp(name,"fragment")) fragment_src = s;
 210                                 if(fragment && !strcmp(name,fragment)) fragment_src = s;
 211                         }
 212                 }
 213                 s++;
 214         }
 215
 216         if(vertex_src) {
 217
 218                 // ARB vertex program
 219                 if(VP_supported && !strncmp(vertex_src,"!!ARBvp1.0",10)) {
 220                         vertex_target = GL_VERTEX_PROGRAM_ARB;
 221                         glGenProgramsPtr(1,&vertex_id);
 222                         glBindProgramPtr(GL_VERTEX_PROGRAM_ARB,vertex_id);
 223                         glProgramStringPtr(GL_VERTEX_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,(GLsizei)strlen(vertex_src),vertex_src);
 224                         GLint pos = -1;
 225                         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&pos);
 226                         if(pos != -1) {
 227                                 SG_LOG(SG_GL, SG_ALERT, "Shader::Shader(): vertex program error in " << name << " file\n" << get_error(vertex_src,pos));
 228                                 return;
 229                         }
 230                         char *var = strstr(vertex_src, "#var ");
 231                         while( var ) {
 232                                 char *eol = strchr( var + 1, '#');
 233                                 char *c2, *c3, *c4;
 234                                 c2 = strchr( var + 6, ' ');
 235                                 if( c2 ) {
 236                                         c3 = strchr( c2 + 1, ':');
 237                                         if( c3 ) {
 238                                                 c4 = strchr( c3 + 1, ':');
 239                                                 if( c4 )
 240                                                         c4 = strchr( c4 + 1, '[');
 241                                                 if( c4 && c4 < eol) {
 242                                                         char type[10], name[30];
 243                                                         strncpy( type, var + 5, c2-var-5 );
 244                                                         type[c2-var-5] = 0;
 245                                                         strncpy( name, c2 + 1, c3-c2-2 );
 246                                                         name[c3-c2-2] = 0;
 247                                                         struct Parameter p;
 248                                                         p.location = atoi( c4 + 1);
 249                                                         p.length = 4;
 250                                                         if( ! strcmp(type, "float3") )
 251                                                                 p.length = 3;
 252                                                         else if( ! strcmp(type, "float") )
 253                                                                 p.length = 1;
 254                                                         arb_parameters[ name ] = p;
 255                                                 }
 256                                         }
 257                                 }
 258                                 var = strstr(var + 1, "#var ");
 259                         }
 260                 }
 261                 // ARB vertex shader
 262                 else {
 263
 264                         program = glCreateProgramObjectPtr();
 265
 266                         GLint length = (GLint)strlen(vertex_src);
 267                         GLhandleARB vertex = glCreateShaderObjectPtr(GL_VERTEX_SHADER_ARB);
 268                         glShaderSourcePtr(vertex,1,(const GLcharARB**)&vertex_src,&length);
 269                         glCompileShaderPtr(vertex);
 270                         glAttachObjectPtr(program,vertex);
 271                         glDeleteObjectPtr(vertex);
 272
 273                         glBindAttribLocationPtr(program,0,"s_attribute_0");
 274                         glBindAttribLocationPtr(program,1,"s_attribute_1");
 275                         glBindAttribLocationPtr(program,2,"s_attribute_2");
 276                         glBindAttribLocationPtr(program,3,"s_attribute_3");
 277                         glBindAttribLocationPtr(program,4,"s_attribute_4");
 278                         glBindAttribLocationPtr(program,5,"s_attribute_5");
 279                         glBindAttribLocationPtr(program,6,"s_attribute_6");
 280
 281                         glBindAttribLocationPtr(program,0,"s_xyz");
 282                         glBindAttribLocationPtr(program,1,"s_normal");
 283                         glBindAttribLocationPtr(program,2,"s_tangent");
 284                         glBindAttribLocationPtr(program,3,"s_binormal");
 285                         glBindAttribLocationPtr(program,4,"s_texcoord");
 286                 }
 287         }
 288
 289         if(fragment_src) {
 290
 291                 // ARB fragment program
 292                 if(FP_supported && !strncmp(fragment_src,"!!ARBfp1.0",10)) {
 293                         fragment_target = GL_FRAGMENT_PROGRAM_ARB;
 294                         glGenProgramsPtr(1,&fragment_id);
 295                         glBindProgramPtr(GL_FRAGMENT_PROGRAM_ARB,fragment_id);
 296                         glProgramStringPtr(GL_FRAGMENT_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,(GLsizei)strlen(fragment_src),fragment_src);
 297                         GLint pos = -1;
 298                         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&pos);
 299                         if(pos != -1) {
 300                                 SG_LOG(SG_GL, SG_ALERT, "Shader::Shader(): fragment program error in " << name << " file\n" << get_error(fragment_src,pos));
 301                                 return;
 302                         }
 303                 }
 304
 305                 // NV fragment program
 306                 else if(!strncmp(fragment_src,"!!FP1.0",7)) {
 307                         fragment_target = GL_FRAGMENT_PROGRAM_NV;
 308                         glGenProgramsNVPtr(1,&fragment_id);
 309                         glBindProgramNVPtr(GL_FRAGMENT_PROGRAM_NV,fragment_id);
 310                         glLoadProgramNVPtr(GL_FRAGMENT_PROGRAM_NV,fragment_id,(GLsizei)strlen(fragment_src),(GLubyte*)fragment_src);
 311                         GLint pos = -1;
 312                         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV,&pos);
 313                         if(pos != -1) {
 314                                 SG_LOG(SG_GL, SG_ALERT, "Shader::Shader(): fragment program error in " << name << " file\n" << get_error(fragment_src,pos));
 315                                 return;
 316                         }
 317                 }
 318
 319                 // ARB fragment shader
 320                 else {
 321
 322                         if(!program) program = glCreateProgramObjectPtr();
 323
 324                         GLint length = (GLint)strlen(fragment_src);
 325                         GLhandleARB fragment = glCreateShaderObjectPtr(GL_FRAGMENT_SHADER_ARB);
 326                         glShaderSourcePtr(fragment,1,(const GLcharARB**)&fragment_src,&length);
 327                         glCompileShaderPtr(fragment);
 328                         glAttachObjectPtr(program,fragment);
 329                         glDeleteObjectPtr(fragment);
 330                 }
 331         }
 332
 333         if(program) {
 334
 335                 glLinkProgramPtr(program);
 336                 GLint linked;
 337                 glGetObjectParameterivPtr(program,GL_OBJECT_LINK_STATUS_ARB,&linked);
 338                 if(!linked) {
 339                         SG_LOG(SG_GL, SG_ALERT, "Shader::Shader(): GLSL error in " << name << " file\n" << get_glsl_error());
 340                         return;
 341                 }
 342
 343                 glUseProgramObjectPtr(program);
 344
 345                 for(int i = 0; i < 8; i++) {
 346                         char texture[32];
 347                         sprintf(texture,"s_texture_%d",i);
 348                         GLint location = glGetUniformLocationPtr(program,texture);
 349                         if(location >= 0) glUniform1iPtr(location,i);
 350                 }
 351
 352                 glUseProgramObjectPtr(0);
 353
 354                 glValidateProgramPtr(program);
 355                 GLint validated;
 356                 glGetObjectParameterivPtr(program,GL_OBJECT_VALIDATE_STATUS_ARB,&validated);
 357                 if(!validated) {
 358                         SG_LOG(SG_GL, SG_ALERT, "Shader::Shader(): GLSL error in " << name << " file\n" << get_glsl_error());
 359                         return;
 360                 }
 361         }
 362
 363         delete [] data;
 364 }
 365
 366 Shader::~Shader() {
 367         if(program) glDeleteObjectPtr(program);
 368         if(vertex_target == GL_VERTEX_PROGRAM_ARB) glDeleteProgramsPtr(1,&vertex_id);
 369         if(fragment_target == GL_FRAGMENT_PROGRAM_ARB) glDeleteProgramsPtr(1,&fragment_id);
 370         else if(fragment_target == GL_FRAGMENT_PROGRAM_NV) glDeleteProgramsNVPtr(1,&fragment_id);
 371         parameters.clear();
 372 }
 373
 374 /*
 375  */
 376 const char *Shader::get_error(char *data,int pos) {
 377         char *s = data;
 378         while(*s && pos--) s++;
 379         while(s >= data && *s != '\n') s--;
 380         char *e = ++s;
 381         while(*e != '\0' && *e != '\n') e++;
 382         *e = '\0';
 383         return s;
 384 }
 385
 386 /*
 387  */
 388
 389 const char *Shader::get_glsl_error() {
 390         GLint length;
 391         static char error[4096];
 392         glGetInfoLogPtr(program,sizeof(error),&length,error);
 393         return error;
 394 }
 395
 396 /*
 397  */
 398 void Shader::getParameter(const char *name,Parameter *parameter) {
 399         if( program ) {
 400                 char buf[1024];
 401                 strcpy(buf,name);
 402                 char *s = strchr(buf,':');
 403                 if(s) {
 404                         *s++ = '\0';
 405                         parameter->length = atoi(s);
 406                 } else {
 407                         parameter->length = 4;
 408                 }
 409                 parameter->location = glGetUniformLocationPtr(program,buf);
 410         } else if( vertex_id ) {
 411                 arb_parameter_list::iterator iParam = arb_parameters.find(name);
 412                 if( iParam != arb_parameters.end() )
 413                         parameter->location = iParam->second.location;
 414                 else
 415                         parameter->location = 90;
 416                 parameter->length = 4;
 417         }
 418 }
 419
 420 /*
 421  */
 422 void Shader::bindNames(const char *name,...) {
 423         Parameter parameter;
 424         getParameter(name,&parameter);
 425         parameters.push_back(parameter);
 426         va_list args;
 427         va_start(args,name);
 428         while(1) {
 429                 const char *name = va_arg(args,const char*);
 430                 if(name == NULL) break;
 431                 getParameter(name,&parameter);
 432                 parameters.push_back(parameter);
 433         }
 434         va_end(args);
 435 }
 436
 437 /*****************************************************************************/
 438 /*                                                                           */
 439 /* enable/disable/bind                                                       */
 440 /*                                                                           */
 441 /*****************************************************************************/
 442
 443 /*
 444  */
 445 void Shader::enable() {
 446         if(vertex_id) glEnable(vertex_target);
 447         if(fragment_id) glEnable(fragment_target);
 448 }
 449
 450 /*
 451  */
 452 void Shader::disable() {
 453         if(program) glUseProgramObjectPtr(0);
 454         if(vertex_id) glDisable(vertex_target);
 455         if(fragment_id) glDisable(fragment_target);
 456 }
 457
 458 /*
 459  */
 460 void Shader::bind() {
 461         if(program) glUseProgramObjectPtr(program);
 462         if(vertex_id) {
 463                 if(vertex_target == GL_VERTEX_PROGRAM_ARB) glBindProgramPtr(vertex_target,vertex_id);
 464         }
 465         if(fragment_id) {
 466                 if(fragment_target == GL_FRAGMENT_PROGRAM_ARB) glBindProgramPtr(fragment_target,fragment_id);
 467                 else if(fragment_target == GL_FRAGMENT_PROGRAM_NV) glBindProgramNVPtr(fragment_target,fragment_id);
 468         }
 469 }
 470
 471 /*
 472  */
 473 void Shader::bind(const float *v,...) {
 474         if(fragment_id) {
 475                 if(fragment_target == GL_FRAGMENT_PROGRAM_ARB) glBindProgramPtr(fragment_target,fragment_id);
 476                 else if(fragment_target == GL_FRAGMENT_PROGRAM_NV) glBindProgramNVPtr(fragment_target,fragment_id);
 477     } else {
 478             if(program == 0) {
 479                     SG_LOG(SG_GL, SG_ALERT, "Shader::bind(): error GLSL shader isn't loaded\n");
 480                     return;
 481             }
 482             glUseProgramObjectPtr(program);
 483     }
 484         const float *value = v;
 485         va_list args;
 486         va_start(args,v);
 487         for(int i = 0; i < (int)parameters.size(); i++) {
 488                 if( vertex_target ) {
 489                         glProgramLocalParameter4fvPtr( vertex_target, parameters[i].location, value);
 490                 } else if( program ) {
 491                         if(parameters[i].length == 1) glUniform1fvPtr(parameters[i].location,1,value);
 492                         else if(parameters[i].length == 2) glUniform2fvPtr(parameters[i].location,1,value);
 493                         else if(parameters[i].length == 3) glUniform3fvPtr(parameters[i].location,1,value);
 494                         else if(parameters[i].length == 4) glUniform4fvPtr(parameters[i].location,1,value);
 495                         else if(parameters[i].length == 9) glUniformMatrix3fvPtr(parameters[i].location,1,false,value);
 496                         else if(parameters[i].length == 16) glUniformMatrix4fvPtr(parameters[i].location,1,false,value);
 497                 }
 498                 value = va_arg(args,const float*);
 499                 if(!value) break;
 500         }
 501         va_end(args);
 502 }
 503
 504 /*****************************************************************************/
 505 /*                                                                           */
 506 /* set parameters                                                            */
 507 /*                                                                           */
 508 /*****************************************************************************/
 509
 510 void Shader::setLocalParameter(int location,const float *value) {
 511         if(vertex_target == 0) {
 512                 SG_LOG(SG_GL, SG_ALERT, "Shader::setLocalParameter(): error vertex program isn't loaded\n");
 513                 return;
 514         }
 515         glProgramLocalParameter4fvPtr(vertex_target,location,value);
 516 }
 517
 518 void Shader::setEnvParameter(int location,const float *value) {
 519         if(vertex_target == 0) {
 520                 SG_LOG(SG_GL, SG_ALERT, "Shader::setEnvParameter(): error vertex program isn't loaded\n");
 521                 return;
 522         }
 523         glProgramEnvParameter4fvPtr(vertex_target,location,value);
 524 }
 525
 526 /*
 527  */
 528 void Shader::setParameter(const char *name,const float *value) {
 529         Parameter parameter;
 530         getParameter(name,&parameter);
 531         if( vertex_target ) {
 532                 glProgramLocalParameter4fvPtr( vertex_target, parameter.location, value);
 533                 return;
 534         }
 535         if(program == 0) {
 536                 SG_LOG(SG_GL, SG_ALERT, "Shader::setLocalParameter(): error GLSL shader isn't loaded\n");
 537                 return;
 538         }
 539         if(parameter.length == 1) glUniform1fvPtr(parameter.location,1,value);
 540         else if(parameter.length == 2) glUniform2fvPtr(parameter.location,1,value);
 541         else if(parameter.length == 3) glUniform3fvPtr(parameter.location,1,value);
 542         else if(parameter.length == 4) glUniform4fvPtr(parameter.location,1,value);
 543         else if(parameter.length == 9) glUniformMatrix3fvPtr(parameter.location,1,false,value);
 544         else if(parameter.length == 16) glUniformMatrix4fvPtr(parameter.location,1,false,value);
 545 }
 546
 547 /*
 548  */
 549 void Shader::setParameters(const float *v,...) {
 550         const float *value = v;
 551         va_list args;
 552         va_start(args,v);
 553         for(int i = 0; i < (int)parameters.size(); i++) {
 554                 if( vertex_target ) {
 555                         glProgramLocalParameter4fvPtr( vertex_target, parameters[i].location, value);
 556                 } else if( program ) {
 557                         if(parameters[i].length == 1) glUniform1fvPtr(parameters[i].location,1,value);
 558                         else if(parameters[i].length == 2) glUniform2fvPtr(parameters[i].location,1,value);
 559                         else if(parameters[i].length == 3) glUniform3fvPtr(parameters[i].location,1,value);
 560                         else if(parameters[i].length == 4) glUniform4fvPtr(parameters[i].location,1,value);
 561                         else if(parameters[i].length == 9) glUniformMatrix3fvPtr(parameters[i].location,1,false,value);
 562                         else if(parameters[i].length == 16) glUniformMatrix4fvPtr(parameters[i].location,1,false,value);
 563                 }
 564                 value = va_arg(args,const float*);
 565                 if(!value) break;
 566         }
 567         va_end(args);
 568 }
 569
 570 #ifndef CONCAT
 571 #define CONCAT(a,b) a##b
 572 #endif
 573 #define mystringify(a) CONCAT(ST,R)(a)
 574 #define STR(x) #x
 575 #define LOAD_EXT(fn) CONCAT(fn,Ptr) = (CONCAT(fn,Proc)) SGLookupFunction( mystringify(CONCAT(fn,ARB)) )
 576
 577 void Shader::Init(void) {
 578         if( SGIsOpenGLExtensionSupported("GL_ARB_multitexture") )
 579                 glGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &nb_texture_unit );
 580         VP_supported = SGIsOpenGLExtensionSupported("GL_ARB_vertex_program");
 581         FP_supported = SGIsOpenGLExtensionSupported("GL_ARB_fragment_program");
 582         // check that
 583         GLSL_supported = SGIsOpenGLExtensionSupported("GL_ARB_shading_language_100") &&
 584                 SGIsOpenGLExtensionSupported("GL_ARB_fragment_shader") &&
 585                 SGIsOpenGLExtensionSupported("GL_ARB_vertex_shader") &&
 586                 SGIsOpenGLExtensionSupported("GL_ARB_shader_objects");
 587     NVFP_supported = SGIsOpenGLExtensionSupported("GL_NV_fragment_program");
 588
 589         if( VP_supported || FP_supported ) {
 590                 /* All ARB_fragment_program entry points are shared with ARB_vertex_program. */
 591         LOAD_EXT(glVertexAttrib1d);
 592         LOAD_EXT( glVertexAttrib1dv );
 593         LOAD_EXT( glVertexAttrib1f );
 594         LOAD_EXT( glVertexAttrib1fv );
 595         LOAD_EXT( glVertexAttrib1s );
 596         LOAD_EXT( glVertexAttrib1sv );
 597         LOAD_EXT( glVertexAttrib2d );
 598         LOAD_EXT( glVertexAttrib2dv );
 599         LOAD_EXT( glVertexAttrib2f );
 600         LOAD_EXT( glVertexAttrib2fv );
 601         LOAD_EXT( glVertexAttrib2s );
 602         LOAD_EXT( glVertexAttrib2sv );
 603         LOAD_EXT( glVertexAttrib3d );
 604         LOAD_EXT( glVertexAttrib3dv );
 605         LOAD_EXT( glVertexAttrib3f );
 606         LOAD_EXT( glVertexAttrib3fv );
 607         LOAD_EXT( glVertexAttrib3s );
 608         LOAD_EXT( glVertexAttrib3sv );
 609         LOAD_EXT( glVertexAttrib4Nbv );
 610         LOAD_EXT( glVertexAttrib4Niv );
 611         LOAD_EXT( glVertexAttrib4Nsv );
 612         LOAD_EXT( glVertexAttrib4Nub );
 613         LOAD_EXT( glVertexAttrib4Nubv );
 614         LOAD_EXT( glVertexAttrib4Nuiv );
 615         LOAD_EXT( glVertexAttrib4Nusv );
 616         LOAD_EXT( glVertexAttrib4bv );
 617         LOAD_EXT( glVertexAttrib4d );
 618         LOAD_EXT( glVertexAttrib4dv );
 619         LOAD_EXT( glVertexAttrib4f );
 620         LOAD_EXT( glVertexAttrib4fv );
 621         LOAD_EXT( glVertexAttrib4iv );
 622         LOAD_EXT( glVertexAttrib4s );
 623         LOAD_EXT( glVertexAttrib4sv );
 624         LOAD_EXT( glVertexAttrib4ubv );
 625         LOAD_EXT( glVertexAttrib4uiv );
 626         LOAD_EXT( glVertexAttrib4usv );
 627         LOAD_EXT( glVertexAttribPointer );
 628         LOAD_EXT( glEnableVertexAttribArray );
 629         LOAD_EXT( glDisableVertexAttribArray );
 630         LOAD_EXT( glProgramString );
 631         LOAD_EXT( glBindProgram );
 632         LOAD_EXT( glDeletePrograms );
 633         LOAD_EXT( glGenPrograms );
 634         LOAD_EXT( glProgramEnvParameter4d );
 635         LOAD_EXT( glProgramEnvParameter4dv );
 636         LOAD_EXT( glProgramEnvParameter4f );
 637         LOAD_EXT( glProgramEnvParameter4fv );
 638         LOAD_EXT( glProgramLocalParameter4d );
 639         LOAD_EXT( glProgramLocalParameter4dv );
 640         LOAD_EXT( glProgramLocalParameter4f );
 641         LOAD_EXT( glProgramLocalParameter4fv );
 642         LOAD_EXT( glGetProgramEnvParameterdv );
 643         LOAD_EXT( glGetProgramEnvParameterfv );
 644         LOAD_EXT( glGetProgramLocalParameterdv );
 645         LOAD_EXT( glGetProgramLocalParameterfv );
 646         LOAD_EXT( glGetProgramiv );
 647         LOAD_EXT( glGetProgramString );
 648         LOAD_EXT( glGetVertexAttribdv );
 649         LOAD_EXT( glGetVertexAttribfv );
 650         LOAD_EXT( glGetVertexAttribiv );
 651         LOAD_EXT( glGetVertexAttribPointerv );
 652         LOAD_EXT( glIsProgram );
 653         }
 654         if( GLSL_supported ) {
 655         LOAD_EXT( glDeleteObject );
 656         LOAD_EXT( glGetHandle );
 657         LOAD_EXT( glDetachObject );
 658         LOAD_EXT( glCreateShaderObject );
 659         LOAD_EXT( glShaderSource );
 660         LOAD_EXT( glCompileShader );
 661         LOAD_EXT( glCreateProgramObject );
 662         LOAD_EXT( glAttachObject );
 663         LOAD_EXT( glLinkProgram );
 664         LOAD_EXT( glUseProgramObject );
 665         LOAD_EXT( glValidateProgram );
 666         LOAD_EXT( glUniform1f );
 667         LOAD_EXT( glUniform2f );
 668         LOAD_EXT( glUniform3f );
 669         LOAD_EXT( glUniform4f );
 670         LOAD_EXT( glUniform1i );
 671         LOAD_EXT( glUniform2i );
 672         LOAD_EXT( glUniform3i );
 673         LOAD_EXT( glUniform4i );
 674         LOAD_EXT( glUniform1fv );
 675         LOAD_EXT( glUniform2fv );
 676         LOAD_EXT( glUniform3fv );
 677         LOAD_EXT( glUniform4fv );
 678         LOAD_EXT( glUniform1iv );
 679         LOAD_EXT( glUniform2iv );
 680         LOAD_EXT( glUniform3iv );
 681         LOAD_EXT( glUniform4iv );
 682         LOAD_EXT( glUniformMatrix2fv );
 683         LOAD_EXT( glUniformMatrix3fv );
 684         LOAD_EXT( glUniformMatrix4fv );
 685         LOAD_EXT( glGetObjectParameterfv );
 686         LOAD_EXT( glGetObjectParameteriv );
 687         LOAD_EXT( glGetInfoLog );
 688         LOAD_EXT( glGetAttachedObjects );
 689         LOAD_EXT( glGetUniformLocation );
 690         LOAD_EXT( glGetActiveUniform );
 691         LOAD_EXT( glGetUniformfv );
 692         LOAD_EXT( glGetUniformiv );
 693         LOAD_EXT( glGetShaderSource );
 694
 695         LOAD_EXT( glBindAttribLocation );
 696         LOAD_EXT( glGetActiveAttrib );
 697         LOAD_EXT( glGetAttribLocation );
 698
 699         }
 700     if( NVFP_supported ) {
 701         glBindProgramNVPtr = (glBindProgramNVProc) SGLookupFunction( "glBindProgramNV" );
 702         glDeleteProgramsNVPtr = (glDeleteProgramsNVProc) SGLookupFunction( "glDeleteProgramsNV" );
 703         glGenProgramsNVPtr = (glGenProgramsNVProc) SGLookupFunction( "glGenProgramsNV" );
 704         glLoadProgramNVPtr = (glLoadProgramNVProc) SGLookupFunction( "glLoadProgramNV" );
 705         glProgramParameter4fvNVPtr = (glProgramParameter4fvNVProc) SGLookupFunction( "glProgramParameter4fvNV" );
 706     }
 707 }