plugins/shaders/shaders.cpp

   1 /*
   2 Copyright (c) 2001, Loki software, inc.
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without modification,
   6 are permitted provided that the following conditions are met:
   7
   8 Redistributions of source code must retain the above copyright notice, this list
   9 of conditions and the following disclaimer.
  10
  11 Redistributions in binary form must reproduce the above copyright notice, this
  12 list of conditions and the following disclaimer in the documentation and/or
  13 other materials provided with the distribution.
  14
  15 Neither the name of Loki software nor the names of its contributors may be used
  16 to endorse or promote products derived from this software without specific prior
  17 written permission.
  18
  19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
  20 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22 DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
  23 DIRECT,INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  26 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  28 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 //
  32 // Shaders Manager Plugin
  33 //
  34 // Leonardo Zide (leo@lokigames.com)
  35 //
  36
  37 // standard headers
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include "plugin.h"
  41 #include "mathlib.h"
  42 #include "missing.h" //++timo FIXME: this one is intended to go away some day, it's MFC compatibility classes
  43 #include "shaders.h"
  44
  45 // some forward declarations
  46 IShader *WINAPI QERApp_Shader_ForName (const char *name);
  47 qtexture_t *WINAPI QERApp_Try_Texture_ForName (const char *name);
  48 qtexture_t *WINAPI QERApp_Texture_ForName2 (const char *filename);
  49 IShader *WINAPI QERApp_ColorShader_ForName (const char *name);
  50 void WINAPI QERApp_LoadShaderFile (const char *filename);
  51
  52 //++timo TODO: use stl::map !! (I tried having a look to CMap but it obviously sucks)
  53 CShaderArray g_Shaders;
  54 // whenever a shader gets activated / deactivated this list is updated
  55 // NOTE: make sure you don't add a shader that's already in
  56 // NOTE: all shaders in this array are in the main g_Shaders
  57 CShaderArray g_ActiveShaders;
  58
  59 // clean a texture name to the qtexture_t name format we use internally
  60 // NOTE: there are so many cases .. this may need to get updated to cover all of them
  61 // we expect a "textures/" path on top, except if bAddTexture is set to true .. in case we add in needed
  62 // NOTE: case sensitivity: the engine is case sensitive. we store the shader name with case information and save with case
  63 // information as well. but we assume there won't be any case conflict and so when doing lookups based on shader name,
  64 // we compare as case insensitive. That is Radiant is case insensitive, but knows that the engine is case sensitive.
  65 //++timo FIXME: we need to put code somewhere to detect when two shaders that are case insensitive equal are present
  66 const char *WINAPI QERApp_CleanTextureName (const char *name, bool bAddTexture = false)
  67 {
  68   static char stdName[QER_MAX_NAMELEN];
  69 #ifdef _DEBUG
  70   if (strlen(name)>QER_MAX_NAMELEN)
  71     g_FuncTable.m_pfnSysFPrintf(SYS_WRN, "WARNING: name exceeds QER_MAX_NAMELEN in CleanTextureName\n");
  72 #endif
  73
  74   strcpy (stdName, name);
  75   g_FuncTable.m_pfnQE_ConvertDOSToUnixName (stdName, stdName);
  76   if (stdName[strlen (name) - 4] == '.')
  77     // strip extension
  78     stdName[strlen (stdName) - 4] = '\0';
  79
  80         if (bAddTexture)
  81   {
  82     char aux[QER_MAX_NAMELEN];
  83     sprintf (aux, "textures/%s", stdName);
  84     strcpy (stdName, aux);
  85         }
  86   return stdName;
  87 }
  88
  89 int WINAPI QERApp_GetActiveShaderCount ()
  90 {
  91   return g_ActiveShaders.GetSize ();
  92 }
  93
  94 IShader *WINAPI QERApp_ActiveShader_ForIndex (int i)
  95 {
  96   return static_cast < CShader * >(g_ActiveShaders.GetAt (i));
  97 }
  98
  99 void CShaderArray::SortShaders ()
 100 {
 101   CPtrArray aux;
 102   int i, icount;
 103   int j, jcount;
 104   CShader *pSort;
 105   const char *sSort;
 106   // dumb sort .. would it ever grow big enough so we would have to do something clever? noooo
 107   icount = CPtrArray::GetSize ();
 108   for (i = 0; i < icount; i++)
 109   {
 110     pSort = static_cast < CShader * >(GetAt (i));
 111     sSort = pSort->getName ();
 112     jcount = aux.GetSize ();
 113     for (j = 0; j < jcount; j++)
 114     {
 115       if (strcmp (sSort, static_cast < CShader * >(aux.GetAt (j))->getName ()) < 0)
 116         break;
 117     }
 118     aux.InsertAt (j, pSort);
 119   }
 120   CPtrArray::RemoveAll ();
 121   CPtrArray::InsertAt (0, &aux);
 122 }
 123
 124 // will sort the active shaders list by name
 125 // NOTE: it would be easier if the thing would stay sorted by using a map<name,CShader> thing
 126 //++timo FIXME: would need to export that to allow external override?
 127 void WINAPI QERApp_SortActiveShaders ()
 128 {
 129   g_ActiveShaders.SortShaders ();
 130 }
 131
 132 // NOTE: case sensitivity
 133 // although we store shader names with case information, Radiant does case insensitive searches
 134 // (we assume there's no case conflict with the names)
 135 CShader *CShaderArray::Shader_ForName (const char *name) const
 136 {
 137   int i;
 138   for (i = 0; i < CPtrArray::GetSize (); i++)
 139   {
 140     CShader *pShader = static_cast < CShader * >(CPtrArray::GetAt (i));
 141     if (stricmp (pShader->getName (), name) == 0)
 142       return pShader;
 143   }
 144   return NULL;
 145 }
 146
 147 void CShader::CreateDefault (const char *name)
 148 {
 149   const char *stdName = QERApp_CleanTextureName (name);
 150   m_strTextureName = stdName;
 151   setName (name);
 152 }
 153
 154 CShader *CShaderArray::Shader_ForTextureName (const char *name) const
 155 {
 156 #ifdef _DEBUG
 157   // check we were given a texture name that fits the qtexture_t naming conventions
 158   if (strcmp (name, QERApp_CleanTextureName (name)) != 0)
 159     Sys_Printf
 160       ("WARNING: texture name %s doesn't fit qtexture_t conventions in CShaderArray::Shader_ForTextureName\n",
 161        name);
 162 #endif
 163   int i;
 164   for (i = 0; i < CPtrArray::GetSize (); i++)
 165   {
 166     CShader *pShader = static_cast < CShader * >(CPtrArray::GetAt (i));
 167     if (strcmp (name, QERApp_CleanTextureName (pShader->getTextureName ())) == 0)
 168       return pShader;
 169   }
 170   return NULL;
 171 }
 172
 173 IShader *WINAPI QERApp_ActiveShader_ForTextureName (char *name)
 174 {
 175   return g_ActiveShaders.Shader_ForTextureName (name);
 176 }
 177
 178 void CShaderArray::AddSingle (void *lp)
 179 {
 180   int i;
 181   for (i = 0; i < CPtrArray::GetSize (); i++)
 182   {
 183     if (CPtrArray::GetAt (i) == lp)
 184       return;
 185   }
 186   CPtrArray::Add (lp);
 187   static_cast < CShader * >(CPtrArray::GetAt (i))->IncRef();
 188 }
 189
 190 void CShaderArray::operator = (const class CShaderArray & src)
 191 {
 192   int i;
 193
 194 #ifdef _DEBUG
 195   if (CPtrArray::GetSize () != 0)
 196     Sys_Printf ("WARNING: CShaderArray::operator = expects an empty array\n");
 197 #endif
 198   Copy (src);
 199   // now go through and IncRef
 200   for (i = 0; i < CPtrArray::GetSize (); i++)
 201     static_cast < IShader * >(CPtrArray::GetAt (i))->IncRef ();
 202 }
 203
 204 //++timo NOTE: for debugging we may need to keep track and tell wether everything has been properly unloaded
 205 void CShaderArray::ReleaseAll ()
 206 {
 207   int i;
 208   int count = CPtrArray::GetSize ();
 209   // decref
 210   for (i = 0; i < count; i++)
 211     static_cast < IShader * >(CPtrArray::GetAt (i))->DecRef ();
 212   // get rid
 213   CPtrArray::RemoveAll ();
 214 }
 215
 216 // NOTE TTimo:
 217 // this was hacked to work a long time ago
 218 // in Loki's fenris tracker as bug #104655
 219 // since that info is no longer available, and the hack has been there for so long, it's part of the code now
 220 // don't remember the details, but basically across a flush and reload for the shaders
 221 // we have to keep track of the patches texture names in a seperate entry
 222 // not sure why anymore, but I know that doesn't happen with brushes
 223 typedef struct patchEntry_s
 224 {
 225   char name[QER_MAX_NAMELEN];
 226   patchMesh_t *p;
 227 } patchEntry_t;
 228
 229 CPtrArray PatchShaders;
 230
 231 void PushPatch (patchMesh_t * patch)
 232 {
 233   patchEntry_t *pEntry = new patchEntry_s;
 234   pEntry->p = patch;
 235   strcpy (pEntry->name, patch->pShader->getName ());
 236   PatchShaders.Add (pEntry);
 237 }
 238
 239 char *ShaderNameLookup (patchMesh_t * patch)
 240 {
 241   int i;
 242   int count = PatchShaders.GetSize ();
 243   for (i = 0; i < count; i++)
 244   {
 245     if (static_cast < patchEntry_t * >(PatchShaders.GetAt (i))->p == patch)
 246       return static_cast < patchEntry_t * >(PatchShaders.GetAt (i))->name;
 247   }
 248   Sys_Printf ("ERROR: failed to lookup name in ShaderNameLookup??\n");
 249   return SHADER_NOT_FOUND;
 250 }
 251 //++timo end clean
 252
 253 // will free all GL binded qtextures and shaders
 254 // NOTE: doesn't make much sense out of Radiant exit or called during a reload
 255 void WINAPI QERApp_FreeShaders ()
 256 {
 257   int i;
 258   brush_t *b;
 259   brush_t *active_brushes;
 260   brush_t *selected_brushes;
 261   brush_t *filtered_brushes;
 262   qtexture_t **d_qtextures;
 263
 264   active_brushes = g_DataTable.m_pfnActiveBrushes ();
 265   selected_brushes = g_DataTable.m_pfnSelectedBrushes ();
 266   filtered_brushes = g_DataTable.m_pfnFilteredBrushes ();
 267   d_qtextures = g_ShadersTable.m_pfnQTextures ();
 268
 269   // store the shader names used by the patches
 270   for (i = 0; i < PatchShaders.GetSize (); i++)
 271     delete static_cast < patchMesh_t * >(PatchShaders.GetAt (i));
 272   PatchShaders.RemoveAll ();
 273
 274   for (b = active_brushes->next; b != NULL && b != active_brushes; b = b->next)
 275   {
 276     if (b->patchBrush)
 277       PushPatch (b->pPatch);
 278   }
 279   for (b = selected_brushes->next; b != NULL && b != selected_brushes; b = b->next)
 280   {
 281     if (b->patchBrush)
 282       PushPatch (b->pPatch);
 283   }
 284   for (b = filtered_brushes->next; b != NULL && b != filtered_brushes; b = b->next)
 285   {
 286     if (b->patchBrush)
 287       PushPatch (b->pPatch);
 288   }
 289
 290   // reload shaders
 291   // empty the actives shaders list
 292   g_ActiveShaders.ReleaseAll ();
 293   g_Shaders.ReleaseAll ();
 294   // empty the main g_qeglobals.d_qtextures list
 295   // FIXME: when we reload later on, we need to have the shader names
 296   // for brushes it's stored in the texdef
 297   // but patches don't have texdef
 298   // see bug 104655 for details
 299   // so the solution, build an array of patchMesh_t* and their shader names
 300 #ifdef _DEBUG
 301   Sys_Printf ("FIXME: patch shader reload workaround (old fenris? bug 104655)\n");
 302 #endif
 303
 304   //GtkWidget *widget = g_QglTable.m_pfn_GetQeglobalsGLWidget ();
 305   GHashTable *texmap = g_ShadersTable.m_pfnQTexmap ();
 306
 307   // NOTE: maybe before we'd like to set all qtexture_t in the shaders list to notex?
 308   // NOTE: maybe there are some qtexture_t we don't want to erase? For plain color faces maybe?
 309   while (*d_qtextures)
 310   {
 311     qtexture_t *pTex = *d_qtextures;
 312     qtexture_t *pNextTex = pTex->next;
 313
 314     //if (widget != NULL)
 315     g_QglTable.m_pfn_qglDeleteTextures (1, &pTex->texture_number);
 316
 317     g_hash_table_remove (texmap, pTex->name);
 318
 319     // all qtexture_t should be manipulated with the glib alloc handlers for now
 320     g_free (pTex);
 321     *d_qtextures = pNextTex;
 322   }
 323
 324   g_QglTable.m_pfn_QE_CheckOpenGLForErrors ();
 325 }
 326
 327 // those functions are only used during a shader reload phase
 328 // the patch one relies on ShaderNameLookup, a table that is being built only when a flush is performed
 329 // so it's not something we want to expose publicly
 330
 331 void SetShader (patchMesh_t * patch)
 332 {
 333   // unhook current shader
 334   patch->pShader->DecRef();
 335   // don't access this one! it has been deleted .. it's DEAD
 336   patch->d_texture = NULL;
 337   // hook the new one, increment the refcount
 338   // NOTE TTimo this function increments the refcount, don't incref ourselves
 339   patch->pShader = QERApp_Shader_ForName (ShaderNameLookup (patch));
 340   patch->d_texture = patch->pShader->getTexture ();
 341 }
 342
 343 void SetShader (face_t * f)
 344 {
 345   // unhook current shader
 346   f->pShader->DecRef();
 347   // don't access the texdef! it's DEAD
 348   f->d_texture = NULL;
 349   // hook
 350   // NOTE TTimo this function increments the refcount, don't incref ourselves
 351   f->pShader = QERApp_Shader_ForName (f->texdef.GetName());
 352   f->d_texture = f->pShader->getTexture ();
 353 }
 354
 355 void Brush_RefreshShader(brush_t *b)
 356 {
 357   if (b->patchBrush)
 358     SetShader(b->pPatch);
 359   else if (b->owner->eclass->fixedsize)
 360   {
 361     /*eclass_t *eclass = HasModel(b);
 362     if (eclass)
 363     {
 364       for(entitymodel *model = eclass->model; model!=NULL; model=model->pNext)
 365         if(model && model->strSkin)
 366           model->nTextureBind = g_FuncTable.m_pfnTexture_LoadSkin(((GString *)model->strSkin)->str, &model->nSkinWidth, &model->nSkinHeight);
 367     }*/
 368   }
 369   else
 370                 for (face_t *f=b->brush_faces ; f ; f=f->next)
 371                         SetShader(f);
 372 }
 373
 374 void WINAPI QERApp_ReloadShaders ()
 375 {
 376   brush_t *b;
 377   brush_t *active_brushes;
 378   brush_t *selected_brushes;
 379   brush_t *filtered_brushes;
 380
 381   QERApp_FreeShaders ();
 382
 383   g_DataTable.m_pfnLstSkinCache()->RemoveAll(); //md3 skins
 384
 385   active_brushes = g_DataTable.m_pfnActiveBrushes ();
 386   selected_brushes = g_DataTable.m_pfnSelectedBrushes ();
 387   filtered_brushes = g_DataTable.m_pfnFilteredBrushes ();
 388
 389   // now we must reload the shader information from shaderfiles
 390   g_ShadersTable.m_pfnBuildShaderList();
 391   g_ShadersTable.m_pfnPreloadShaders();
 392
 393   // refresh the map visuals: replace our old shader objects by the new ones
 394   // on brush faces we have the shader name in texdef.name
 395   // on patches we have the shader name in PatchShaders
 396   // while we walk through the map data, we DecRef the old shaders and push the new ones in
 397   // if all goes well, most of our old shaders will get deleted on the way
 398
 399   // FIXME: bug 104655, when we come accross a patch, we use the above array since the d_texture is lost
 400   // NOTE: both face_t and patchMesh_t store pointers to the shader and qtexture_t
 401   // in an ideal world they would only store shader and access the qtexture_t through it
 402   // reassign all current shaders
 403   for (b = active_brushes->next; b != NULL && b != active_brushes; b = b->next)
 404     Brush_RefreshShader(b);
 405   for (b = selected_brushes->next; b != NULL && b != selected_brushes; b = b->next)
 406     Brush_RefreshShader(b);
 407   // do that to the filtered brushes as well (we might have some region compiling going on)
 408   for (b = filtered_brushes->next; b != NULL && b != filtered_brushes; b = b->next)
 409     Brush_RefreshShader(b);
 410 }
 411
 412 int WINAPI QERApp_LoadShadersFromDir (const char *path)
 413 {
 414   int count = 0;
 415   // scan g_Shaders, and call QERApp_Shader_ForName for each in the given path
 416   // this will load the texture if needed and will set it in use..
 417   int nSize = g_Shaders.GetSize ();
 418   for (int i = 0; i < nSize; i++)
 419   {
 420     CShader *pShader = reinterpret_cast < CShader * >(g_Shaders[i]);
 421     if (strstr (pShader->getShaderFileName (), path) || strstr (pShader->getName (), path))
 422     {
 423       count++;
 424       // request the shader, this will load the texture if needed and set "inuse"
 425       //++timo FIXME: should we put an Activate member on CShader?
 426       // this QERApp_Shader_ForName call is a kind of hack
 427       IShader *pFoo = QERApp_Shader_ForName (pShader->getName ());
 428 #ifdef _DEBUG
 429       // check we activated the right shader
 430       // NOTE: if there was something else loaded, the size of g_Shaders may have changed and strange behaviours are to be expected
 431       if (pFoo != pShader)
 432         Sys_Printf ("WARNING: unexpected pFoo != pShader in QERApp_LoadShadersFromDir\n");
 433 #else
 434       pFoo = NULL;              // leo: shut up the compiler
 435 #endif
 436     }
 437   }
 438   return count;
 439 }
 440
 441 bool CShader::Parse ()
 442 {
 443   char *token = g_ScripLibTable.m_pfnToken ();
 444
 445   // the parsing needs to be taken out in another module
 446 //  Sys_Printf("TODO: CShader::Parse\n");
 447
 448   // token is shader name (full path with a "textures\")
 449   // we remove the "textures\" part
 450   //setName ((char *) &token[9]));
 451         // no we don't
 452         setName (token);
 453   // name of the qtexture_t we'll use to represent this shader (this one has the "textures\" before)
 454   const char *stdName = QERApp_CleanTextureName (token);
 455   m_strTextureName = stdName; // FIXME: BC reports stdName is uninitialised?
 456   g_ScripLibTable.m_pfnGetToken (true);
 457   if (strcmp (token, "{"))
 458     return false;
 459   else
 460   {
 461     // we need to read until we hit a balanced }
 462     int nMatch = 1;
 463     while (nMatch > 0 && g_ScripLibTable.m_pfnGetToken (true))
 464     {
 465       if (strcmp (token, "{") == 0)
 466       {
 467         nMatch++;
 468         continue;
 469       }
 470       else if (strcmp (token, "}") == 0)
 471       {
 472         nMatch--;
 473         continue;
 474       }
 475       if (nMatch > 1) continue; // ignore layers for now
 476       if (strcmpi (token, "qer_nocarve") == 0)
 477       {
 478         m_nFlags |= QER_NOCARVE;
 479       }
 480       else if (strcmpi (token, "qer_trans") == 0)
 481       {
 482               if (g_ScripLibTable.m_pfnGetToken (true))
 483               {
 484                 m_fTrans = (float) atof (token);
 485               }
 486               m_nFlags |= QER_TRANS;
 487       }
 488       else if (strcmpi (token, "qer_editorimage") == 0)
 489       {
 490               if (g_ScripLibTable.m_pfnGetToken (true))
 491               {
 492           // bAddTexture changed to false to allow editorimages in other locations than "textures/"
 493                 m_strTextureName = QERApp_CleanTextureName (token, false);
 494               }
 495       }
 496       else if (strcmpi (token, "qer_alphafunc") == 0)
 497       {
 498               if (g_ScripLibTable.m_pfnGetToken (true))
 499               {
 500
 501           if(stricmp( token, "greater" ) == 0 )
 502           {
 503                   m_nAlphaFunc = GL_GREATER;
 504           }
 505           else if(stricmp( token, "less" ) == 0 )
 506           {
 507             m_nAlphaFunc = GL_LESS;
 508           }
 509           else if(stricmp( token, "gequal" ) == 0 )
 510           {
 511             m_nAlphaFunc = GL_GEQUAL;
 512           }
 513
 514           if( m_nAlphaFunc )
 515             m_nFlags |= QER_ALPHAFUNC;
 516               }
 517         if (g_ScripLibTable.m_pfnGetToken (true))
 518               {
 519                 m_fAlphaRef = (float) atof (token);
 520               }
 521       }
 522       else if (strcmpi (token, "cull") == 0)
 523       {
 524         if (g_ScripLibTable.m_pfnGetToken (true))
 525               {
 526           if( stricmp( token, "none" ) == 0 || stricmp( token, "twosided" ) == 0 || stricmp( token, "disable" ) == 0 )
 527           {
 528                   m_nCull = 2;
 529           }
 530           else if( stricmp( token, "back" ) == 0 || stricmp( token, "backside" ) == 0 || stricmp( token, "backsided" ) == 0 )
 531           {
 532                   m_nCull = 1;
 533           }
 534
 535           if( m_nCull )
 536              m_nFlags |= QER_CULL;
 537         }
 538       }
 539       else if (strcmpi (token, "surfaceparm") == 0)
 540       {
 541               if (g_ScripLibTable.m_pfnGetToken (true))
 542               {
 543                 if (strcmpi (token, "fog") == 0)
 544                 {
 545             m_nFlags |= QER_FOG;
 546                   if (m_fTrans == 1.0f) // has not been explicitly set by qer_trans
 547                   {
 548                     m_fTrans = 0.35f;
 549                   }
 550                 }
 551           else if (strcmpi (token, "nodraw") == 0)
 552           {
 553             m_nFlags |= QER_NODRAW;
 554           }
 555           else if (strcmpi (token, "nonsolid") == 0)
 556           {
 557             m_nFlags |= QER_NONSOLID;
 558           }
 559           else if (strcmpi (token, "water") == 0)
 560           {
 561             m_nFlags |= QER_WATER;
 562           }
 563           else if (strcmpi (token, "lava") == 0)
 564           {
 565             m_nFlags |= QER_LAVA;
 566           }
 567               }
 568       }
 569     }
 570     if (nMatch != 0)
 571       return false;
 572   }
 573   return true;
 574 }
 575
 576 void CShader::RegisterActivate ()
 577 {
 578   // fill the qtexture_t with shader information
 579   //++timo FIXME: a lot of that won't be necessary, will be stored at IShader* level
 580 //  strcpy (m_pTexture->shadername, m_Name);
 581   // this flag is set only if we have a shaderfile name
 582 //  if (m_ShaderFileName[0] != '\0')
 583 //    m_pTexture->bFromShader = true;
 584 //  else
 585 //    m_pTexture->bFromShader = false;
 586   //++timo FIXME: what do we do with that?
 587   //m_pTexture->fTrans = pInfo->m_fTransValue;
 588 //  m_pTexture->fTrans = 1.0f;  // if != 1.0 it's ot getting drawn in Cam_Draw
 589 //  m_pTexture->nShaderFlags = m_nFlags;
 590   // store in the active shaders list (if necessary)
 591   g_ActiveShaders.AddSingle (this);
 592   // when you activate a shader, it gets displayed in the texture browser
 593   m_bDisplayed = true;
 594   IncRef ();
 595 }
 596
 597 void CShader::Try_Activate ()
 598 {
 599   m_pTexture = QERApp_Try_Texture_ForName (m_strTextureName.GetBuffer());
 600   if (m_pTexture)
 601     RegisterActivate ();
 602 }
 603
 604 // Hydra: now returns false if the ORIGINAL shader could not be activated
 605 // (missing texture, or incorrect shader script), true otherwise
 606 // the shader is still activated in all cases.
 607 bool CShader::Activate ()
 608 {
 609   Try_Activate ();
 610   if (!m_pTexture)
 611   {
 612     m_pTexture = QERApp_Texture_ForName2 (SHADER_NOTEX);
 613     RegisterActivate ();
 614     return false;
 615   }
 616   return true;
 617 }
 618
 619 void WINAPI QERApp_LoadShaderFile (const char *filename)
 620 {
 621   char *pBuff;
 622   int nSize = vfsLoadFile (filename, reinterpret_cast < void **>(&pBuff), 0);
 623   if (nSize > 0)
 624   {
 625     Sys_Printf ("Parsing shaderfile %s\n", filename);
 626     g_ScripLibTable.m_pfnStartTokenParsing (pBuff);
 627     while (g_ScripLibTable.m_pfnGetToken (true))
 628     {
 629       // first token should be the path + name.. (from base)
 630       CShader *pShader = new CShader ();
 631       // we want the relative filename only, it's easier for later lookup .. see QERApp_ReloadShaderFile
 632       char cTmp[1024];
 633       g_FuncTable.m_pfnQE_ConvertDOSToUnixName (cTmp, filename);
 634       // given the vfs, we should not store the full path
 635       //pShader->setShaderFileName( filename + strlen(ValueForKey(g_qeglobals.d_project_entity, "basepath")));
 636       pShader->setShaderFileName (filename);
 637       if (pShader->Parse ())
 638       {
 639               // do we already have this shader?
 640               //++timo NOTE: this may a bit slow, we may need to use a map instead of a dumb list
 641               if (g_Shaders.Shader_ForName (pShader->getName ()) != NULL)
 642               {
 643 #ifdef _DEBUG
 644                 Sys_Printf ("WARNING: shader %s is already in memory, definition in %s ignored.\n",
 645                             pShader->getName (), filename);
 646 #endif
 647                 delete pShader;
 648               }
 649               else
 650               {
 651                 pShader->IncRef ();
 652
 653                 g_Shaders.Add ((void *) pShader);
 654               }
 655       }
 656       else
 657       {
 658               Sys_Printf ("Error parsing shader %s\n", pShader->getName ());
 659               delete pShader;
 660       }
 661     }
 662     vfsFreeFile (pBuff);
 663   }
 664   else
 665   {
 666     Sys_Printf ("Unable to read shaderfile %s\n", filename);
 667   }
 668 }
 669
 670 IShader *WINAPI QERApp_Try_Shader_ForName (const char *name)
 671 {
 672   // look for the shader
 673   CShader *pShader = g_Shaders.Shader_ForName (name);
 674   if (!pShader)
 675     // not found
 676     return NULL;
 677   // we may need to load the texture or use the "shader without texture" one
 678   pShader->Activate ();
 679   pShader->SetDisplayed (true);
 680   return pShader;
 681 }
 682
 683 IShader *WINAPI QERApp_CreateShader_ForTextureName (const char *name)
 684 {
 685   CShader *pShader;
 686   pShader = new CShader;
 687   // CreateDefault expects a texture / shader name relative to the "textures" directory
 688   // (cause shader names are reletive to "textures/")
 689   pShader->CreateDefault (name);
 690   // hook it into the shader list
 691   g_Shaders.Add ((void *) pShader);
 692   pShader->IncRef ();
 693   // if it can't find the texture, SHADER_NOT_FOUND will be used
 694   // Hydra: display an error message, so the user can quickly find a list of missing
 695   // textures by looking at the console.
 696   if (!pShader->Activate ())
 697   {
 698     Sys_Printf ("WARNING: Activate shader failed for %s\n",pShader->getName());
 699   }
 700   pShader->SetDisplayed (true);
 701
 702   return pShader;
 703 }
 704
 705 IShader *WINAPI QERApp_Shader_ForName (const char *name)
 706 {
 707   if (name == NULL || strlen (name) == 0)
 708   {
 709     // Hydra: This error can occur if the user loaded a map with/dropped an entity that
 710     // did not set a texture name "(r g b)" - check the entity definition loader
 711
 712     g_FuncTable.m_pfnSysFPrintf (SYS_ERR, "FIXME: name == NULL || strlen(name) == 0 in QERApp_Shader_ForName\n");
 713     return QERApp_Shader_ForName (SHADER_NOT_FOUND);
 714   }
 715   // entities that should be represented with plain colors instead of textures
 716   // request a texture name with (r g b) (it's stored in their class_t)
 717   if (name[0] == '(')
 718   {
 719     return QERApp_ColorShader_ForName (name);
 720   }
 721
 722   CShader *pShader = static_cast < CShader * >(QERApp_Try_Shader_ForName (name));
 723   if (pShader)
 724   {
 725     pShader->SetDisplayed (true);
 726     return pShader;
 727   }
 728   return QERApp_CreateShader_ForTextureName (name);
 729 }
 730
 731 qtexture_t *WINAPI QERApp_Try_Texture_ForName (const char *name)
 732 {
 733   qtexture_t *q;
 734 //  char f1[1024], f2[1024];
 735   unsigned char *pPixels = NULL;
 736   int nWidth, nHeight;
 737
 738   // convert the texture name to the standard format we use in qtexture_t
 739   const char *stdName = QERApp_CleanTextureName (name);
 740
 741   // use the hash table
 742   q = (qtexture_t*)g_hash_table_lookup (g_ShadersTable.m_pfnQTexmap (), stdName);
 743   if (q)
 744     return q;
 745
 746 #ifdef QTEXMAP_DEBUG
 747   for (q = g_qeglobals.d_qtextures; q; q = q->next)
 748   {
 749     if (!strcmp (stdName, q->name))
 750     {
 751       Sys_Printf ("ERROR: %s is not in texture map, but was found in texture list\n");
 752       return q;
 753     }
 754   }
 755 #endif
 756
 757   g_FuncTable.m_pfnLoadImage (name, &pPixels, &nWidth, &nHeight);
 758
 759   if (!pPixels)
 760     return NULL; // we failed
 761   else
 762     Sys_Printf ("LOADED: %s\n", name);
 763
 764   // instanciate a new qtexture_t
 765   // NOTE: when called by a plugin we must make sure we have set Radiant's GL context before binding the texture
 766
 767   // we'll be binding the GL texture now
 768   // need to check we are using a right GL context
 769   // with GL plugins that have their own window, the GL context may be the plugin's, in which case loading textures will bug
 770   //  g_QglTable.m_pfn_glwidget_make_current (g_QglTable.m_pfn_GetQeglobalsGLWidget ());
 771   q = g_FuncTable.m_pfnLoadTextureRGBA (pPixels, nWidth, nHeight);
 772   if (!q)
 773     return NULL;
 774   g_free (pPixels);
 775
 776   strcpy (q->name, name);
 777   // only strip extension if extension there is!
 778   if (q->name[strlen (q->name) - 4] == '.')
 779     q->name[strlen (q->name) - 4] = '\0';
 780   // hook into the main qtexture_t list
 781   qtexture_t **d_qtextures = g_ShadersTable.m_pfnQTextures ();
 782   q->next = *d_qtextures;
 783   *d_qtextures = q;
 784   // push it in the map
 785   g_hash_table_insert (g_ShadersTable.m_pfnQTexmap (), q->name, q);
 786   return q;
 787 }
 788
 789 int WINAPI QERApp_HasShader (const char *pName)
 790 {
 791   //  mickey check the global shader array for existense of pName
 792   CShader *pShader = g_Shaders.Shader_ForName (pName);
 793   if (pShader)
 794     return 1;
 795   return 0;
 796 }
 797
 798 IShader *WINAPI QERApp_Shader_ForName_NoLoad (const char *pName)
 799 {
 800   CShader *pShader = g_Shaders.Shader_ForName (pName);
 801   return pShader;
 802 }
 803
 804 /*!
 805 This should NEVER return NULL, it is the last-chance call in the load cascade
 806 */
 807 qtexture_t *WINAPI QERApp_Texture_ForName2 (const char *filename)
 808 {
 809   qtexture_t *q;
 810   q = QERApp_Try_Texture_ForName (filename);
 811   if (q)
 812     return q;
 813   // not found? use "texture not found"
 814   q = QERApp_Try_Texture_ForName (SHADER_NOT_FOUND);
 815   if (q)
 816     return q;
 817
 818   // still not found? this is a fatal error
 819   g_FuncTable.m_pfnError("Failed to load " SHADER_NOT_FOUND ". Looks like your installation is broken / missing some essential elements.");
 820   return NULL;
 821 }
 822
 823 void CShader::CreateColor (const char *name)
 824 {
 825   // parse
 826   sscanf (name, "(%g %g %g)", m_vColor, m_vColor + 1, m_vColor + 2);
 827   m_strTextureName = name;
 828   setName ("color");
 829   // create the qtexture_t
 830   qtexture_t *q1 = QERApp_Texture_ForName2 (SHADER_NOT_FOUND);
 831   // copy this one
 832   qtexture_t *q2 = new qtexture_t;
 833   memcpy (q2, q1, sizeof (qtexture_t));
 834   strcpy (q2->name, m_strTextureName.GetBuffer ());
 835   VectorCopy (m_vColor, q2->color);
 836   m_pTexture = q2;
 837 }
 838
 839 IShader *WINAPI QERApp_ColorShader_ForName (const char *name)
 840 {
 841   CShader *pShader = new CShader ();
 842   pShader->CreateColor (name);
 843   // hook it into the shader list
 844   pShader->IncRef ();
 845   g_Shaders.Add ((void *) pShader);
 846   return pShader;
 847 }
 848
 849 void CShaderArray::ReleaseForShaderFile (const char *name)
 850 {
 851   int i;
 852   // decref
 853   for (i = 0; i < CPtrArray::GetSize (); i++)
 854   {
 855     IShader *pShader = static_cast < IShader * >(CPtrArray::GetAt (i));
 856     if (!strcmp (name, pShader->getShaderFileName ()))
 857     {
 858       pShader->DecRef ();
 859       CPtrArray::RemoveAt (i);
 860       i--;                      // get ready for next loop
 861     }
 862   }
 863 }
 864
 865 void WINAPI QERApp_ReloadShaderFile (const char *name)
 866 {
 867   brush_t *b;
 868   face_t *f;
 869   brush_t *active_brushes;
 870   brush_t *selected_brushes;
 871   brush_t *filtered_brushes;
 872
 873 //  Sys_Printf("TODO: QERApp_ReloadShaderFile\n");
 874
 875   active_brushes = g_DataTable.m_pfnActiveBrushes ();
 876   selected_brushes = g_DataTable.m_pfnSelectedBrushes ();
 877   filtered_brushes = g_DataTable.m_pfnFilteredBrushes ();
 878
 879 #ifdef _DEBUG
 880   // check the shader name is a reletive path
 881   // I hacked together a few quick tests to make sure :-)
 882   if (strstr (name, ":\\") || !strstr (name, "scripts"))
 883     Sys_Printf ("WARNING: is %s a reletive path to a shader file? (QERApp_ReloadShaderFile\n");
 884 #endif
 885
 886   // in the actives and global shaders lists, decref and unhook the shaders
 887   //++timo NOTE: maybe we'd like to keep track of the shaders we are unhooking?
 888   g_ActiveShaders.ReleaseForShaderFile (name);
 889   g_Shaders.ReleaseForShaderFile (name);
 890   // go through a reload of the shader file
 891   QERApp_LoadShaderFile (name);
 892   // scan all the brushes, replace all the old ones by refs to their new equivalents
 893   for (b = active_brushes->next; b != NULL && b != active_brushes; b = b->next)
 894   {
 895     if (b->patchBrush && !strcmp (b->pPatch->pShader->getShaderFileName (), name))
 896       SetShader (b->pPatch);
 897     else
 898       for (f = b->brush_faces; f; f = f->next)
 899         if (!strcmp (f->pShader->getShaderFileName (), name))
 900           SetShader (f);
 901   }
 902   for (b = selected_brushes->next; b != NULL && b != selected_brushes; b = b->next)
 903   {
 904     if (b->patchBrush && !strcmp (b->pPatch->pShader->getShaderFileName (), name))
 905       SetShader (b->pPatch);
 906     else
 907       for (f = b->brush_faces; f; f = f->next)
 908         if (!strcmp (f->pShader->getShaderFileName (), name))
 909           SetShader (f);
 910   }
 911   // do that to the filtered brushes as well (we might have some region compiling going on)
 912   for (b = filtered_brushes->next; b != NULL && b != filtered_brushes; b = b->next)
 913   {
 914     if (b->patchBrush && !strcmp (b->pPatch->pShader->getShaderFileName (), name))
 915       SetShader (b->pPatch);
 916     else
 917       for (f = b->brush_faces; f; f = f->next)
 918         if (!strcmp (f->pShader->getShaderFileName (), name))
 919           SetShader (f);
 920   }
 921   // call Texture_ShowInUse to clean and display only what's required
 922   g_ShadersTable.m_pfnTexture_ShowInuse ();
 923   QERApp_SortActiveShaders ();
 924   g_FuncTable.m_pfnSysUpdateWindows (W_TEXTURE);
 925 }
 926
 927 void CShaderArray::SetDisplayed (bool b)
 928 {
 929   int i, count;
 930   count = CPtrArray::GetSize ();
 931   for (i = 0; i < count; i++)
 932     static_cast < IShader * >(CPtrArray::GetAt (i))->SetDisplayed (b);
 933 }
 934
 935 void CShaderArray::SetInUse (bool b)
 936 {
 937   int i, count;
 938   count = CPtrArray::GetSize ();
 939   for (i = 0; i < count; i++)
 940     static_cast < IShader * >(CPtrArray::GetAt (i))->SetInUse (b);
 941 }
 942
 943 // Set the IsDisplayed flag on all active shaders
 944 void WINAPI QERApp_ActiveShaders_SetDisplayed (bool b)
 945 {
 946   g_ActiveShaders.SetDisplayed (b);
 947 }
 948
 949 void WINAPI QERApp_ActiveShaders_SetInUse (bool b)
 950 {
 951   g_ActiveShaders.SetInUse (b);
 952 }
 953
 954 // =============================================================================
 955 // SYNAPSE
 956
 957 bool CSynapseClientShaders::RequestAPI(APIDescriptor_t *pAPI)
 958 {
 959   if (!strcmp(pAPI->major_name, SHADERS_MAJOR))
 960   {
 961     _QERShadersTable* pTable= static_cast<_QERShadersTable*>(pAPI->mpTable);
 962
 963     pTable->m_pfnFreeShaders = QERApp_FreeShaders;
 964     pTable->m_pfnReloadShaders = QERApp_ReloadShaders;
 965     pTable->m_pfnLoadShadersFromDir = QERApp_LoadShadersFromDir;
 966     pTable->m_pfnReloadShaderFile = QERApp_ReloadShaderFile;
 967     pTable->m_pfnLoadShaderFile = QERApp_LoadShaderFile;
 968     pTable->m_pfnHasShader = QERApp_HasShader;
 969     pTable->m_pfnTry_Shader_ForName = QERApp_Try_Shader_ForName;
 970     pTable->m_pfnShader_ForName = QERApp_Shader_ForName;
 971     pTable->m_pfnTry_Texture_ForName = QERApp_Try_Texture_ForName;
 972     pTable->m_pfnTexture_ForName = QERApp_Texture_ForName2;
 973     pTable->m_pfnGetActiveShaderCount = QERApp_GetActiveShaderCount;
 974     pTable->m_pfnColorShader_ForName = QERApp_ColorShader_ForName;
 975     pTable->m_pfnShader_ForName_NoLoad = QERApp_Shader_ForName_NoLoad;
 976     pTable->m_pfnActiveShaders_SetInUse = QERApp_ActiveShaders_SetInUse;
 977     pTable->m_pfnSortActiveShaders = QERApp_SortActiveShaders;
 978     pTable->m_pfnActiveShader_ForTextureName = QERApp_ActiveShader_ForTextureName;
 979     pTable->m_pfnCreateShader_ForTextureName = QERApp_CreateShader_ForTextureName;
 980     pTable->m_pfnActiveShaders_SetDisplayed = QERApp_ActiveShaders_SetDisplayed;
 981     pTable->m_pfnActiveShader_ForIndex = QERApp_ActiveShader_ForIndex;
 982     pTable->m_pfnCleanTextureName = QERApp_CleanTextureName;
 983
 984     return true;
 985   }
 986
 987   Syn_Printf("ERROR: RequestAPI( '%s' ) not found in '%s'\n", pAPI->major_name, GetInfo());
 988   return false;
 989 }