The Ecere SDK - sdk/blob - ecere/src/gfx/drivers/gl3/defaultShader.ec

   1 import "shaders"
   2
   3 #include "gl123es.h"
   4
   5 namespace gfx::drivers;
   6
   7 // **********   Default Shader   **********
   8 public enum LightMode { off, dir, pos, posAtt, posSpot, posSpotAtt };
   9 public enum SwizzleMode { off, alpha, red };
  10
  11 public class DefaultShaderBits : uint64
  12 {
  13 public:
  14    bool lighting:1;
  15    bool nonLocalViewer:1;
  16    bool twoSided:1;
  17    bool specular:1;
  18    bool separateSpecular:1;
  19    bool blinnSpecular:1;
  20    uint lightBits:24;
  21    bool perVertexColor:1;
  22    SwizzleMode swizzle:2;
  23    bool textureMatrix:1;
  24    bool texturing:1;
  25    bool cubeMap:1;
  26    bool modelView:1;
  27    bool fog:1;
  28    bool normalsMapping:1;
  29    bool specularMapping:1;
  30    bool environmentMapping:1;
  31    bool reflection:1;
  32    bool reflectionMap:1;
  33    bool refraction:1;
  34    bool debugging:1;
  35 };
  36
  37 public class CompiledDefaultShader : CompiledShader
  38 {
  39 public:
  40    // Uniforms
  41    int uPrjMatrix;
  42    int uMVMatrix;
  43    int uTextureMatrix;
  44    int uNormalsMatrix;
  45    int uFogDensity;
  46    int uFogColor;
  47    int uGlobalAmbient;
  48    int uNearPlane;
  49    int uLightsPos[8];
  50    int uLightsDiffuse[8];
  51    int uLightsAmbient[8];
  52    int uLightsSpecular[8];
  53    int uLightsAtt[8];
  54    int uLightsSpotDir[8];
  55    int uLightsSpotCutOffCos[8];
  56    int uLightsSpotExp[8];
  57    int uMatDiffuse;
  58    int uMatAmbient;
  59    int uMatSpecular;
  60    int uMatEmissive;
  61    int uMatPower;
  62    int uMatOpacity;
  63    int uDiffuseTex;
  64    int uBumpTex;
  65    int uSpecularTex;
  66    int uEnvTex;
  67    int uReflectTex;
  68    int uRefractionETA;
  69    int uMatReflectivity;
  70    int uCubeMapMatrix;
  71
  72    void registerUniforms(int program, DefaultShaderBits state)
  73    {
  74 #if ENABLE_GL_SHADERS
  75       uPrjMatrix        = glGetUniformLocation(program, "projection_matrix");
  76       uMatDiffuse       = glGetUniformLocation(program, "matDiffuse");
  77
  78       if(state.modelView)
  79          uMVMatrix         = glGetUniformLocation(program, "modelview_matrix");
  80
  81       if(state.lighting)
  82       {
  83          int i;
  84
  85          for(i = 0; i < 8; i++)
  86          {
  87             char name[100];
  88
  89             sprintf(name, "lightsPos[%d]", i);
  90             uLightsPos[i] = glGetUniformLocation(program, name);
  91
  92             sprintf(name, "lightsDiffuse[%d]", i);
  93             uLightsDiffuse[i] = glGetUniformLocation(program, name);
  94
  95             sprintf(name, "lightsAmbient[%d]", i);
  96             uLightsAmbient[i] = glGetUniformLocation(program, name);
  97
  98             sprintf(name, "lightsSpecular[%d]", i);
  99             uLightsSpecular[i] = glGetUniformLocation(program, name);
 100
 101             sprintf(name, "lightsAtt[%d]", i);
 102             uLightsAtt[i] = glGetUniformLocation(program, name);
 103
 104             sprintf(name, "lightsSpotDir[%d]", i);
 105             uLightsSpotDir[i] = glGetUniformLocation(program, name);
 106
 107             sprintf(name, "lightsSpotCutOffCos[%d]", i);
 108             uLightsSpotCutOffCos[i] = glGetUniformLocation(program, name);
 109
 110             sprintf(name, "lightsSpotExp[%d]", i);
 111             uLightsSpotExp[i] = glGetUniformLocation(program, name);
 112          }
 113
 114          uNearPlane        = glGetUniformLocation(program, "nearPlane");
 115          uNormalsMatrix    = glGetUniformLocation(program, "normals_matrix");
 116          uGlobalAmbient    = glGetUniformLocation(program, "globalAmbient");
 117          uMatAmbient       = glGetUniformLocation(program, "matAmbient");
 118          uMatEmissive      = glGetUniformLocation(program, "matEmissive");
 119          if(state.specular)
 120          {
 121             uMatSpecular      = glGetUniformLocation(program, "matSpecular");
 122             uMatPower         = glGetUniformLocation(program, "matPower");
 123          }
 124       }
 125
 126       if((state.specularMapping || state.normalsMapping || state.texturing || state.reflectionMap || state.cubeMap) && state.textureMatrix)
 127          uTextureMatrix    = glGetUniformLocation(program, "texture_matrix");
 128       if(state.texturing || state.cubeMap)
 129          uDiffuseTex    = glGetUniformLocation(program, "diffuseTex");
 130       if(state.normalsMapping)
 131          uBumpTex       = glGetUniformLocation(program, "bumpTex");
 132       if(state.specularMapping)
 133          uSpecularTex   = glGetUniformLocation(program, "specularTex");
 134       if(state.environmentMapping)
 135       {
 136          uEnvTex = glGetUniformLocation(program, "envTex");
 137          uCubeMapMatrix = glGetUniformLocation(program, "cubemap_matrix");
 138
 139          if(state.refraction)
 140             uRefractionETA = glGetUniformLocation(program, "matRefractionETA");
 141          if(state.reflection)
 142             uMatReflectivity = glGetUniformLocation(program, "matReflectivity");
 143          if(state.reflectionMap)
 144             uReflectTex  = glGetUniformLocation(program, "reflectTex");
 145       }
 146
 147       if(state.fog)
 148       {
 149          uFogDensity       = glGetUniformLocation(program, "fogDensity");
 150          uFogColor         = glGetUniformLocation(program, "fogColor");
 151       }
 152 #endif
 153    }
 154 };
 155
 156 public class DefaultShader : Shader
 157 {
 158    vertexShaderFile   = "<:ecere>shaders/default.vert";
 159    fragmentShaderFile = "<:ecere>shaders/default.frag";
 160
 161 public:
 162    float modelView[16];
 163    float projection[16];
 164    float matTexture[16];
 165    float cubemap_matrix[9];
 166
 167    float normalsMatrix[9];
 168    float nearPlane;
 169    float globalAmbient[3];
 170
 171    // Lights
 172    float lDiffuse [8][4];
 173    float lAmbient [8][3];
 174    float lSpecular[8][3];
 175    float lPosition[8][3];
 176    float lAtt[8][3];
 177    float lCutOffCos[8];
 178    float lSpotDir[8][3];
 179    float lSpotExp[8];
 180
 181    // Material
 182    float diffuse[4];
 183    float ambient[3];
 184    float specular[3];
 185    float emissive[3];
 186    float power;
 187    float refractionETA, reflectivity;
 188
 189    bool fogOn;
 190    uint lightBits;
 191    float fogDensity;
 192    float fogColor[3];
 193
 194    float color[4];
 195
 196    DefaultShader()
 197    {
 198       color[0] = 1, color[1] = 1, color[2] = 1, color[3] = 1;
 199       diffuse[0] = 1, diffuse[1] = 1, diffuse[2] = 1, diffuse[3] = 1;
 200       ambient[0] = 1, ambient[1] = 1, ambient[2] = 1;
 201
 202       // state = DefaultShaderBits { blinnSpecular = true };
 203    }
 204
 205    void bindAttribs(int program)
 206    {
 207 #if ENABLE_GL_SHADERS
 208       DefaultShaderBits state = this.state;
 209       glBindAttribLocation(program, GLBufferContents::vertex,    "vertex");
 210       if(state.perVertexColor)
 211          glBindAttribLocation(program, GLBufferContents::color,     "color");
 212       if(state.texturing || state.normalsMapping || state.specularMapping || state.reflectionMap)
 213          glBindAttribLocation(program, GLBufferContents::texCoord,  "texCoord");
 214       if(state.lighting)
 215          glBindAttribLocation(program, GLBufferContents::normal,    "normal");
 216       if(state.normalsMapping)
 217       {
 218          glBindAttribLocation(program, GLBufferContents::tangent1,  "tangent1");
 219          glBindAttribLocation(program, GLBufferContents::tangent2,  "tangent2");
 220       }
 221 #endif
 222    }
 223
 224    CompiledDefaultShader registerShader(int program, uint64 state)
 225    {
 226       CompiledDefaultShader shader { };
 227       shader.registerUniforms(program, state);
 228       return shader;
 229    }
 230
 231    ZString getDefinitions(uint64 _state)
 232    {
 233       DefaultShaderBits state = _state;
 234       ZString defs { allocType = heap, minSize = 5000 };
 235       int i;
 236
 237 #ifdef _DEBUG
 238        //PrintLn("Compiling shader for state: ", state);
 239 #endif
 240
 241 #if defined(__EMSCRIPTEN__)
 242       defs.concatf("#version 100\n");
 243 #else
 244       defs.concatf("#version 110\n");
 245 #endif
 246       defs.concatf("\n#define NUM_LIGHTS %d",               8);
 247       defs.concatf("\n#define MODELVIEW %d",                state.modelView          ? 1 : 0);
 248       defs.concatf("\n#define PER_VERTEX_COLOR %d",         state.perVertexColor     ? 1 : 0);
 249       defs.concatf("\n#define LIGHTING_ON %d",              state.lighting           ? 1 : 0);
 250       defs.concatf("\n#define NON_LOCAL_VIEWER %d",         state.nonLocalViewer     ? 1 : 0);
 251       defs.concatf("\n#define MAT_TWOSIDED %d",             state.twoSided           ? 1 : 0);
 252       defs.concatf("\n#define MAT_SPECULAR %d",             state.specular           ? 1 : 0);
 253       defs.concatf("\n#define MAT_SEPARATE_SPECULAR %d",    state.separateSpecular   ? 1 : 0);
 254       defs.concatf("\n#define SPECULAR_MAPPING %d",         state.specularMapping    ? 1 : 0);
 255       defs.concatf("\n#define ENVIRONMENT_MAPPING %d",      state.environmentMapping ? 1 : 0);
 256       defs.concatf("\n#define ENVIRONMENT_REFLECTION %d",   state.reflection         ? 1 : 0);
 257       defs.concatf("\n#define ENVIRONMENT_REFRACTION %d",   state.refraction         ? 1 : 0);
 258       defs.concatf("\n#define REFLECTION_MAP %d",           state.reflectionMap      ? 1 : 0);
 259       defs.concatf("\n#define NORMALS_MAPPING %d",          state.normalsMapping     ? 1 : 0);
 260       defs.concatf("\n#define CUBEMAP_ON %d",               state.cubeMap            ? 1 : 0);
 261       defs.concatf("\n#define LIGHTING_SPECULAR_BLINN %d",  state.blinnSpecular      ? 1 : 0);
 262       defs.concatf("\n#define TEXTURE_ON %d",               state.texturing          ? 1 : 0);
 263       defs.concatf("\n#define TEXTURE_MATRIX %d",           state.textureMatrix      ? 1 : 0);
 264       defs.concatf("\n#define SWIZZLE_ALPHA %d",            state.swizzle == alpha   ? 1 : 0);
 265       defs.concatf("\n#define SWIZZLE_RED %d",              state.swizzle == red     ? 1 : 0);
 266       defs.concatf("\n#define FOG_ON %d\n",                 state.fog                ? 1 : 0);
 267       defs.concatf("\n#define DEBUGGING %d\n",              state.debugging          ? 1 : 0);
 268       for(i = 0; i < 8; i++)
 269       {
 270          LightMode mode = (LightMode)((state.lightBits & (0x7 << (3*i))) >> (3*i));
 271          defs.concatf("\n#define LIGHT%d_ON %d",         i, mode                                 ? 1 : 0);
 272          defs.concatf("\n#define LIGHT%d_POSITIONAL %d", i, mode >= pos                          ? 1 : 0);
 273          defs.concatf("\n#define LIGHT%d_SPOT %d",       i, mode >= posSpot                      ? 1 : 0);
 274          defs.concatf("\n#define LIGHT%d_ATT %d\n",      i, mode == posAtt || mode == posSpotAtt ? 1 : 0);
 275       }
 276       defs.concatf("\n\n#line 0\n");
 277
 278 #ifdef _DEBUG
 279       //puts((String)defs._string);
 280 #endif
 281       return defs;
 282    }
 283
 284    void uploadUniforms(CompiledDefaultShader shader)
 285    {
 286 #if ENABLE_GL_SHADERS
 287       DefaultShaderBits state = this.state;
 288
 289       // Upload Uniforms
 290
 291 /*
 292       if(prjViewModified)
 293       {
 294          Matrix * mv = &mvMatrix;
 295          Matrix * prj = &prjMatrix;
 296          Matrix mat;
 297          mat.Multiply(mv, prj);
 298          {
 299             float m[16] =
 300             {
 301                (float)mat.m[0][0], (float)mat.m[0][1], (float)mat.m[0][2], (float)mat.m[0][3],
 302                (float)mat.m[1][0], (float)mat.m[1][1], (float)mat.m[1][2], (float)mat.m[1][3],
 303                (float)mat.m[2][0], (float)mat.m[2][1], (float)mat.m[2][2], (float)mat.m[2][3],
 304                (float)mat.m[3][0], (float)mat.m[3][1], (float)mat.m[3][2], (float)mat.m[3][3]
 305             };
 306             float mvz[4] = { (float)mv->m[0][2], (float)mv->m[1][2], (float)mv->m[2][2], (float)mv->m[3][2] };
 307             glUniformMatrix4fv(shader.uPrjMatrix, 1, GL_FALSE, m);
 308             if(mvModified)
 309                glUniform3fv(uMVZ, 1, mvz);
 310          }
 311       }
 312 */
 313
 314       glUniformMatrix4fv(shader.uPrjMatrix, 1, GL_FALSE, projection);
 315
 316       if(state.modelView)
 317          glUniformMatrix4fv(shader.uMVMatrix, 1, GL_FALSE, modelView);
 318
 319       if(state.lighting)
 320       {
 321          // Lights
 322          int i;
 323          for(i = 0; i < 8; i++)
 324          {
 325             LightMode mode = (LightMode)((state.lightBits & (0x7 << (3*i))) >> (3*i));
 326             if(mode)
 327             {
 328                if(mode == posSpot || mode == posSpotAtt)
 329                {
 330                   glUniform3fv(shader.uLightsSpotDir[i], 1, lSpotDir[i]);
 331                   glUniform1f(shader.uLightsSpotCutOffCos[i], lCutOffCos[i]);
 332                   glUniform1f(shader.uLightsSpotExp[i], lSpotExp[i]);
 333                }
 334                if(mode == posAtt || mode == posSpotAtt)
 335                   glUniform3fv(shader.uLightsAtt[i], 1, lAtt[i]);
 336                if(state.specular)
 337                   glUniform3fv(shader.uLightsSpecular[i], 1, lSpecular[i]);
 338                glUniform3fv(shader.uLightsPos[i], 1, lPosition[i]);
 339                glUniform3fv(shader.uLightsDiffuse[i], 1, lDiffuse[i]);
 340                glUniform3fv(shader.uLightsAmbient[i], 1, lAmbient[i]);
 341             }
 342          }
 343
 344          // Material
 345          glUniform4fv(shader.uMatDiffuse,  1, diffuse);
 346          glUniform3fv(shader.uMatAmbient,  1, ambient);
 347          glUniform3fv(shader.uMatEmissive, 1, emissive);
 348          if(state.specular)
 349          {
 350             glUniform3fv(shader.uMatSpecular, 1, specular);
 351             glUniform1f(shader.uMatPower, state.blinnSpecular ? power : power / 4.0f);
 352          }
 353
 354          glUniform1f(shader.uNearPlane, nearPlane);
 355          glUniform3fv(shader.uGlobalAmbient, 1, globalAmbient);
 356
 357          glUniformMatrix3fv(shader.uNormalsMatrix, 1, GL_FALSE, normalsMatrix);
 358
 359          if(state.normalsMapping)
 360             glUniform1i(shader.uBumpTex, 1);
 361
 362          if(state.specularMapping)
 363             glUniform1i(shader.uSpecularTex, 2);
 364       }
 365       else
 366          glUniform4fv(shader.uMatDiffuse, 1, color);
 367
 368       if(state.environmentMapping)
 369       {
 370          glUniform1i(shader.uEnvTex, 3);
 371          glUniformMatrix3fv(shader.uCubeMapMatrix, 1, GL_FALSE, cubemap_matrix);
 372          if(state.reflection)
 373             glUniform1f(shader.uMatReflectivity, reflectivity);
 374          if(state.refraction)
 375             glUniform1f(shader.uRefractionETA, refractionETA);
 376          if(state.reflectionMap)
 377             glUniform1i(shader.uReflectTex, 4);
 378       }
 379
 380       if(state.texturing || state.cubeMap)
 381          glUniform1i(shader.uDiffuseTex, 0);
 382       if((state.texturing || state.normalsMapping || state.specularMapping || state.reflectionMap || state.cubeMap) && state.textureMatrix)
 383          glUniformMatrix4fv(shader.uTextureMatrix, 1, GL_FALSE, matTexture);
 384
 385       if(state.fog)
 386       {
 387          glUniform1f(shader.uFogDensity, fogDensity);
 388          glUniform3fv(shader.uFogColor, 1, fogColor);
 389       }
 390 #endif
 391    }
 392
 393    void setCamera(Camera camera)
 394    {
 395       double * c = camera.inverseTranspose.array;
 396       float m[9] =
 397       {
 398          (float) c[0], (float) c[1], (float)-c[2],
 399          (float)-c[4], (float) c[5], (float) c[6],
 400          (float)-c[8], (float) c[9], (float) c[10]
 401       };
 402       memcpy(cubemap_matrix, m, 9 * sizeof(float));
 403       uniformsModified = true;
 404    }
 405
 406    void updateMatrix(MatrixMode mode, Matrix matrix, bool isIdentity)
 407    {
 408       float m[16] =
 409       {
 410          (float)matrix.m[0][0], (float)matrix.m[0][1], (float)matrix.m[0][2], (float)matrix.m[0][3],
 411          (float)matrix.m[1][0], (float)matrix.m[1][1], (float)matrix.m[1][2], (float)matrix.m[1][3],
 412          (float)matrix.m[2][0], (float)matrix.m[2][1], (float)matrix.m[2][2], (float)matrix.m[2][3],
 413          (float)matrix.m[3][0], (float)matrix.m[3][1], (float)matrix.m[3][2], (float)matrix.m[3][3]
 414       };
 415       if(mode == projection)
 416       {
 417          memcpy(projection, m, 16 * sizeof(float));
 418          nearPlane = (float)::nearPlane;
 419          uniformsModified = true;
 420       }
 421       else if(mode == modelView)
 422       {
 423          Matrix t, inv;
 424          double * i = inv.array;
 425
 426          memcpy(modelView, m, 16 * sizeof(float));
 427          ((DefaultShaderBits)state).modelView = !isIdentity;
 428
 429          //mvModified = true;
 430          //prjViewModified = true;
 431
 432          inv = matrix;
 433          inv.Scale(1, -1, 1);
 434          t.Transpose(inv);
 435          inv.Inverse(t);
 436          {
 437             float m[9] =
 438             {
 439                (float)i[0],(float)i[1],(float)i[2],
 440                (float)i[4],(float)i[5],(float)i[6],
 441                (float)i[8],(float)i[9],(float)i[10]
 442             };
 443             memcpy(normalsMatrix, m, 9 * sizeof(float));
 444          }
 445
 446          uniformsModified = true;
 447       }
 448       else if(mode == texture)
 449       {
 450          memcpy(matTexture, m, 16 * sizeof(float));
 451          ((DefaultShaderBits)state).textureMatrix = !isIdentity;
 452          if(((DefaultShaderBits)state).texturing || ((DefaultShaderBits)state).normalsMapping || ((DefaultShaderBits)state).specularMapping ||
 453             ((DefaultShaderBits)state).reflectionMap || ((DefaultShaderBits)state).cubeMap)
 454             uniformsModified = true;
 455       }
 456    }
 457
 458    void setGlobalAmbient(float r, float g, float b, float a)
 459    {
 460       globalAmbient[0] = r, globalAmbient[1] = g, globalAmbient[2] = b;
 461       if(((DefaultShaderBits)state).lighting)
 462          uniformsModified = true;
 463    }
 464
 465    void setColor(float r, float g, float b, float a)
 466    {
 467       color[0] = r, color[1] = g, color[2] = b, color[3] = a;
 468       uniformsModified = true;
 469    }
 470
 471    void lighting(bool on)
 472    {
 473       if(((DefaultShaderBits)state).lighting != on)
 474       {
 475          ((DefaultShaderBits)state).lighting = on;
 476          uniformsModified = true;
 477          if(!on)
 478             state &= ~DefaultShaderBits
 479             {
 480                nonLocalViewer = true;
 481                twoSided = true;
 482                specular = true;
 483                separateSpecular = true;
 484                blinnSpecular = true;
 485                lightBits = 0xFFFFFF;
 486             };
 487          else
 488             state |= DefaultShaderBits { separateSpecular = true };
 489       }
 490    }
 491
 492    void fog(bool on)
 493    {
 494       if(fogOn != on)
 495       {
 496          fogOn = on;
 497          ((DefaultShaderBits)state).fog = fogOn && fogDensity;
 498          uniformsModified = true;
 499       }
 500    }
 501
 502    void setFogDensity(float density)
 503    {
 504       if(fogDensity != density)
 505       {
 506          fogDensity = density;
 507          ((DefaultShaderBits)state).fog = fogOn && fogDensity;
 508          if(fogOn)
 509             uniformsModified = true;
 510       }
 511    }
 512
 513    void setFogColor(float r, float g, float b)
 514    {
 515       fogColor[0] = r, fogColor[1] = g, fogColor[2] = b;
 516       if(fogOn)
 517          uniformsModified = true;
 518    }
 519
 520    void texturing(bool on)
 521    {
 522       if(((DefaultShaderBits)state).texturing != on)
 523       {
 524          ((DefaultShaderBits)state).texturing = on;
 525          if(!on)
 526             state &= ~DefaultShaderBits { swizzle = (SwizzleMode)0x3 };
 527          if(!on && !((DefaultShaderBits)state).normalsMapping && !((DefaultShaderBits)state).specularMapping && !((DefaultShaderBits)state).reflectionMap && !((DefaultShaderBits)state).cubeMap)
 528             state &= ~DefaultShaderBits { textureMatrix = true };
 529          uniformsModified = true;
 530       }
 531    }
 532
 533    void debugging(bool on)
 534    {
 535       if(((DefaultShaderBits)state).debugging != on)
 536       {
 537          ((DefaultShaderBits)state).debugging = on;
 538          uniformsModified = true;
 539       }
 540    }
 541
 542    void swizzle(SwizzleMode swizzle)
 543    {
 544 #ifdef _DEBUG
 545       if(swizzle && !((DefaultShaderBits)state).texturing && !((DefaultShaderBits)state).cubeMap)
 546          printf("swizzle() with texturing off\n");
 547 #endif
 548       if(((DefaultShaderBits)state).swizzle != swizzle)
 549       {
 550          ((DefaultShaderBits)state).swizzle = swizzle;
 551          if(((DefaultShaderBits)state).texturing || ((DefaultShaderBits)state).cubeMap)
 552             uniformsModified = true;
 553       }
 554    }
 555
 556    void setSimpleMaterial(ColorAlpha color, bool twoSided)
 557    {
 558       float r = color.color.r / 255.0f;
 559       float g = color.color.g / 255.0f;
 560       float b = color.color.b / 255.0f;
 561 #ifdef _DEBUG
 562       if(!((DefaultShaderBits)state).lighting)
 563          printf("setSimpleMaterial() with lighting off\n");
 564 #endif
 565       diffuse[0] = r, diffuse[1] = g, diffuse[2] = b, diffuse[3] = color.a / 255.0f;
 566       ambient[0] = r, ambient[1] = g, ambient[2] = b;
 567       emissive[0] = 0, emissive[1] = 0, emissive[2] = 0;
 568       ((DefaultShaderBits)state).perVertexColor = false;
 569       ((DefaultShaderBits)state).normalsMapping = false;
 570       ((DefaultShaderBits)state).environmentMapping = false;
 571       ((DefaultShaderBits)state).reflectionMap = false;
 572       ((DefaultShaderBits)state).specularMapping = false;
 573       ((DefaultShaderBits)state).reflection = false;
 574       ((DefaultShaderBits)state).refraction = false;
 575       ((DefaultShaderBits)state).texturing = false;
 576       ((DefaultShaderBits)state).cubeMap = false;
 577       ((DefaultShaderBits)state).specular = false;
 578       ((DefaultShaderBits)state).twoSided = twoSided;
 579       uniformsModified = true;
 580    }
 581
 582    void setPerVertexColor(bool perVertexColor)
 583    {
 584       if(((DefaultShaderBits)state).perVertexColor != perVertexColor)
 585       {
 586          ((DefaultShaderBits)state).perVertexColor = perVertexColor;
 587          uniformsModified = true;
 588       }
 589    }
 590
 591    #if !defined(ECERE_NO3D)
 592    void setMaterial(Material material, MeshFeatures flags)
 593    {
 594 #if ENABLE_GL_SHADERS
 595       if(material)
 596       {
 597          ((DefaultShaderBits)state).specular = material.power && (material.specular.r || material.specular.g || material.specular.b);
 598          ((DefaultShaderBits)state).perVertexColor = flags.colors;
 599          ((DefaultShaderBits)state).separateSpecular = ((DefaultShaderBits)state).specular && material.flags.separateSpecular;
 600          ((DefaultShaderBits)state).cubeMap = material && material.flags.cubeMap && material.baseMap;
 601          ((DefaultShaderBits)state).twoSided = material.flags.doubleSided && !material.flags.singleSideLight;
 602          ((DefaultShaderBits)state).lightBits = material.flags.noLighting ? 0 : lightBits;
 603          ((DefaultShaderBits)state).lighting = (!material.flags.noLighting && lightBits) ? true : false;
 604          color[0] = 1, color[1] = 1, color[2] = 1, color[3] = material.opacity;
 605          diffuse[0]  = material.diffuse.r,  diffuse[1]  = material.diffuse.g,  diffuse[2]  = material.diffuse.b, diffuse[3] = material.opacity;
 606          ambient[0]  = material.ambient.r,  ambient[1]  = material.ambient.g,  ambient[2]  = material.ambient.b;
 607          specular[0] = material.specular.r, specular[1] = material.specular.g, specular[2] = material.specular.b;
 608          emissive[0] = material.emissive.r, emissive[1] = material.emissive.g, emissive[2] = material.emissive.b;
 609          power = material.power;
 610       }
 611       else
 612       {
 613          ((DefaultShaderBits)state).cubeMap = false;
 614          ((DefaultShaderBits)state).perVertexColor = false;
 615          ((DefaultShaderBits)state).separateSpecular = false;
 616          ((DefaultShaderBits)state).twoSided = false;
 617          ((DefaultShaderBits)state).textureMatrix = false;
 618       }
 619
 620       if(material && material.bumpMap && flags.tangents)
 621       {
 622          glActiveTexture(GL_TEXTURE1);
 623          glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)material.bumpMap.driverData);
 624          if(material.flags.tile)
 625          {
 626             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 627             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 628          }
 629          else
 630          {
 631             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 632             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 633          }
 634
 635          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, material.bumpMap.mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
 636          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 637          glActiveTexture(GL_TEXTURE0);
 638          ((DefaultShaderBits)state).normalsMapping = true;
 639       }
 640       else
 641          ((DefaultShaderBits)state).normalsMapping = false;
 642
 643       if(material && material.envMap && (material.refractiveIndex || material.refractiveIndexContainer || material.reflectivity || material.reflectMap))
 644       {
 645          CubeMap cube = material.envMap;
 646          glActiveTexture(GL_TEXTURE3);
 647          glBindTexture(GL_TEXTURE_CUBE_MAP, (GLuint)(uintptr)cube.driverData);
 648          glActiveTexture(GL_TEXTURE0);
 649          ((DefaultShaderBits)state).environmentMapping = true;
 650
 651          if(material.refractiveIndex || material.refractiveIndexContainer)
 652          {
 653             refractionETA =
 654                (material.refractiveIndexContainer ? material.refractiveIndexContainer : 1.0) /
 655                (material.refractiveIndex ? material.refractiveIndex : 1.0);
 656
 657             ((DefaultShaderBits)state).refraction = true;
 658          }
 659
 660          if(material.reflectivity || material.reflectMap)
 661          {
 662             reflectivity = material.reflectivity;
 663             if(!reflectivity && material.reflectMap) reflectivity = 1.0;
 664
 665             if(material.reflectMap)
 666             {
 667                glActiveTexture(GL_TEXTURE4);
 668                glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)material.reflectMap.driverData);
 669                if(material.flags.tile)
 670                {
 671                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 672                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 673                }
 674                else
 675                {
 676                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 677                   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 678                }
 679
 680                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, material.reflectMap.mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
 681                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 682                glActiveTexture(GL_TEXTURE0);
 683
 684                ((DefaultShaderBits)state).reflectionMap = true;
 685             }
 686             else
 687                ((DefaultShaderBits)state).reflectionMap = false;
 688             ((DefaultShaderBits)state).reflection = true;
 689          }
 690       }
 691       else
 692       {
 693          ((DefaultShaderBits)state).environmentMapping = false;
 694          ((DefaultShaderBits)state).refraction = false;
 695          ((DefaultShaderBits)state).reflection = false;
 696          ((DefaultShaderBits)state).reflectionMap = false;
 697       }
 698
 699       if(material && material.specularMap)
 700       {
 701          glActiveTexture(GL_TEXTURE2);
 702          glBindTexture(GL_TEXTURE_2D, (GLuint)(uintptr)material.specularMap.driverData);
 703          if(material.flags.tile)
 704          {
 705             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 706             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 707          }
 708          else
 709          {
 710             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 711             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 712          }
 713
 714          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, material.specularMap.mipMaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
 715          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 716          glActiveTexture(GL_TEXTURE0);
 717          ((DefaultShaderBits)state).specularMapping = true;
 718       }
 719       else
 720          ((DefaultShaderBits)state).specularMapping = false;
 721
 722       uniformsModified = true;
 723 #endif
 724    }
 725
 726    void setLight(Display display, uint id, Light light)
 727    {
 728       int lShift = 3*id;
 729       bool lightOn = light && !light.flags.off;
 730       LightMode mode = (LightMode)((((DefaultShaderBits)state).lightBits & (0x7 << lShift)) >> lShift);
 731
 732       if(lightOn && !((DefaultShaderBits)state).lighting)
 733          ((DefaultShaderBits)state).lighting = true;
 734
 735       if(lightOn || (lightOn != (mode != off)))
 736          uniformsModified = true;
 737
 738       if(lightOn)
 739       {
 740          Object lightObject = light.lightObject;
 741          float multiplier = light.multiplier;
 742          Matrix m = matrixStack[0][matrixIndex[0]];
 743          Vector3D l;
 744          m.Scale(::nearPlane, ::nearPlane, ::nearPlane);
 745
 746          if(!multiplier) multiplier = 1.0f;
 747
 748          lDiffuse[id][0] = light.diffuse.r * multiplier;
 749          lDiffuse[id][1] = light.diffuse.g * multiplier;
 750          lDiffuse[id][2] = light.diffuse.b * multiplier;
 751
 752          lAmbient[id][0] = light.ambient.r * multiplier;
 753          lAmbient[id][1] = light.ambient.g * multiplier;
 754          lAmbient[id][2] = light.ambient.b * multiplier;
 755
 756          lSpecular[id][0] = light.specular.r * multiplier;
 757          lSpecular[id][1] = light.specular.g * multiplier;
 758          lSpecular[id][2] = light.specular.b * multiplier;
 759
 760          if(lightObject)
 761          {
 762             // Positional Lights (Including Spot Lights and Omni with flags.spot not set)
 763             Matrix * mat = &lightObject.matrix;
 764             Vector3D positionVector { mat->m[3][0], mat->m[3][1], mat->m[3][2] };
 765             if(display.display3D.camera)
 766                positionVector.Subtract(positionVector, display.display3D.camera.cPosition);
 767
 768             l.MultMatrix(positionVector, m);
 769             lPosition[id][0] = (float)l.x, lPosition[id][1] = (float)-l.y, lPosition[id][2] = (float)l.z;
 770
 771             // Display Light Position
 772             /*
 773             GLSetupLighting(false);
 774             glDisable(GL_DEPTH_TEST);
 775             GLColor3f(
 776                light.diffuse.r * multiplier,
 777                light.diffuse.g * multiplier,
 778                light.diffuse.b * multiplier);
 779             glPointSize(10);
 780             GLBegin(GL_POINTS);
 781             GLVertex3dv((double *)&positionVector);
 782             GLEnd();
 783             glEnable(GL_DEPTH_TEST);
 784             GLSetupLighting(true);
 785             */
 786
 787             // Display Target
 788             /*
 789             if(light.target)
 790             {
 791                Vector3D positionVector;
 792                if(lightObject.flags.root || !lightObject.parent)
 793                {
 794                   positionVector = light.target.transform.position;
 795                   positionVector.Subtract(positionVector, display.camera.cPosition);
 796                }
 797                else
 798                {
 799                   positionVector.MultMatrix(light.target.transform.position,
 800                      lightObject.light.target.parent.matrix);
 801                   positionVector.Subtract(positionVector, display.camera.cPosition);
 802                }
 803                GLSetupLighting(false);
 804                glDisable(GL_DEPTH_TEST);
 805                GLColor3f(1,1,0);
 806                glPointSize(10);
 807                GLBegin(GL_POINTS);
 808                GLVertex3dv((double *)&positionVector);
 809                GLEnd();
 810                glEnable(GL_DEPTH_TEST);
 811                GLSetupLighting(false);
 812             }
 813             */
 814
 815             if(light.flags.attenuation)
 816             {
 817                lAtt[id][0] = light.Kc;
 818                lAtt[id][1] = light.Kl;
 819                lAtt[id][2] = light.Kq;
 820             }
 821
 822             if((light.flags.spot && light.fallOff < 360) || (lightObject && (light.direction.x || light.direction.y || light.direction.z)))
 823             {
 824                #define MAXLIGHT  0.9
 825                // Figure out exponent out of the hot spot
 826                float exponent = light.flags.spot ? (float)(log(MAXLIGHT) / log(cos(light.hotSpot / 2))) : 1;
 827                Degrees cutOff = light.flags.spot ? light.fallOff/2 : 90;
 828                Vector3D l, n;
 829                l.MultMatrix(light.direction, m);
 830                n.Normalize(l);
 831                n.Scale(n, -1);
 832
 833                lSpotDir[id][0] = (float)n.x, lSpotDir[id][1] = (float)-n.y, lSpotDir[id][2] = (float)n.z;
 834                lCutOffCos[id] = (float)cos(Degrees { cutOff });
 835                lSpotExp[id] = exponent;
 836
 837                mode = light.flags.attenuation ? posSpotAtt : posSpot;
 838             }
 839             else
 840                mode = light.flags.attenuation ? posAtt : pos;
 841          }
 842          else
 843          {
 844             // Directional Light
 845             Vector3D vector { 0,0,-1 };
 846             Vector3D direction, v;
 847             Matrix mat;
 848             mat.RotationQuaternion(light.orientation);
 849             direction.MultMatrix(vector, mat);
 850             v.Normalize(direction);
 851             l.MultMatrix(v, m);
 852
 853             lPosition[id][0] = (float)l.x, lPosition[id][1] = (float)-l.y, lPosition[id][2] = (float)l.z;
 854             mode = dir;
 855          }
 856       }
 857       else
 858          mode = off;
 859       lightBits = (lightBits & ~(0x7 << lShift)) | (mode << lShift);
 860       ((DefaultShaderBits)state).lightBits = lightBits;
 861    }
 862    #endif
 863
 864    DefaultShader ::shader() { return defaultShader; }
 865 }
 866
 867 DefaultShader defaultShader { };