share/mtrl.c

   1 /*
   2  * Copyright (C) 2014 Neverball authors
   3  *
   4  * NEVERBALL is  free software; you can redistribute  it and/or modify
   5  * it under the  terms of the GNU General  Public License as published
   6  * by the Free  Software Foundation; either version 2  of the License,
   7  * or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT  ANY  WARRANTY;  without   even  the  implied  warranty  of
  11  * MERCHANTABILITY or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
  12  * General Public License for more details.
  13  */
  14
  15 #include <string.h>
  16 #include <stdlib.h>
  17
  18 #include "mtrl.h"
  19 #include "array.h"
  20 #include "common.h"
  21 #include "image.h"
  22 #include "lang.h"
  23
  24 /*
  25  * Material cache.
  26  *
  27  * These routines load materials from SOL files into a common cache
  28  * and create mappings from internal SOL indices to this cache. They
  29  * can also reload materials from material specification files.
  30  *
  31  * Some unresolved stuff:
  32  *
  33  * Duplicates are ignored. SOLs define materials internally, so
  34  * conflicts can arise between different SOLs. Right now materials
  35  * start out with the values from the first cached SOL. If the values
  36  * are bad, every subsequent SOL will use them. On the upside,
  37  * duplicates are uncommon.
  38  *
  39  * Reloading does not reschedule meshes. Mesh counts for each geometry
  40  * pass are tested every frame, but cached at load time. Reloading
  41  * does not update those counts, which results in weird behaviors,
  42  * e.g., opaque materials that are reloaded as transparent becoming
  43  * invisible because they are unaccounted for.
  44  *
  45  * Obviously, features that require geometry recomputation, such as
  46  * "angle" normal smoothing feature, are not handled by the reloader.
  47  */
  48
  49 static Array mtrls;
  50
  51 static struct b_mtrl default_base_mtrl =
  52 {
  53     { 0.8f, 0.8f, 0.8f, 1.0f },
  54     { 0.2f, 0.2f, 0.2f, 1.0f },
  55     { 0.0f, 0.0f, 0.0f, 1.0f },
  56     { 0.0f, 0.0f, 0.0f, 1.0f },
  57     { 0.0f }, 0.0f, 0, ""
  58 };
  59
  60 int default_mtrl;
  61
  62 /*---------------------------------------------------------------------------*/
  63
  64 /*
  65  * Obtain a mtrl ref by name.
  66  */
  67 static int find_mtrl(const char *name)
  68 {
  69     int i, c = array_len(mtrls);
  70
  71     for (i = 0; i < c; i++)
  72     {
  73         struct mtrl *mp = array_get(mtrls, i);
  74
  75         if (mp->refc > 0 && strcmp(name, mp->base.f) == 0)
  76             return i;
  77     }
  78     return -1;
  79 }
  80
  81 /*
  82  * Load a material texture.
  83  */
  84 static GLuint find_texture(const char *name)
  85 {
  86     char path[MAXSTR];
  87     GLuint o;
  88     int i;
  89
  90     for (i = 0; i < ARRAYSIZE(tex_paths); i++)
  91     {
  92         CONCAT_PATH(path, &tex_paths[i], name);
  93
  94         if ((o = make_image_from_file(path, IF_MIPMAP)))
  95             return o;
  96     }
  97     return 0;
  98 }
  99
 100 /*
 101  * Load GL resources of an initialized material.
 102  */
 103 static void load_mtrl_objects(struct mtrl *mp)
 104 {
 105     /* Make sure not to leak an already loaded object. */
 106
 107     if (mp->o)
 108         return;
 109
 110     /* Load the texture. */
 111
 112     if ((mp->o = find_texture(_(mp->base.f))))
 113     {
 114         /* Set the texture to clamp or repeat based on material type. */
 115
 116         if (mp->base.fl & M_CLAMP_S)
 117             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 118         else
 119             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 120
 121         if (mp->base.fl & M_CLAMP_T)
 122             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 123         else
 124             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 125     }
 126 }
 127
 128 /*
 129  * Free GL resources of a material.
 130  */
 131 static void free_mtrl_objects(struct mtrl *mp)
 132 {
 133     if (mp->o)
 134     {
 135         glDeleteTextures(1, &mp->o);
 136
 137         mp->o = 0;
 138     }
 139 }
 140
 141 /*
 142  * Load a material from a base material.
 143  */
 144 static void load_mtrl(struct mtrl *mp, const struct b_mtrl *base)
 145 {
 146     /* Copy the base material. */
 147
 148     memcpy(&mp->base, base, sizeof (struct b_mtrl));
 149
 150     /* Cache the 32-bit material values for quick comparison. */
 151
 152     mp->d = touint(base->d);
 153     mp->a = touint(base->a);
 154     mp->s = touint(base->s);
 155     mp->e = touint(base->e);
 156     mp->h = tobyte(base->h[0]);
 157
 158     /* Load GL resources. */
 159
 160     load_mtrl_objects(mp);
 161 }
 162
 163 /*
 164  * Free a material.
 165  */
 166 static void free_mtrl(struct mtrl *mp)
 167 {
 168     free_mtrl_objects(mp);
 169 }
 170
 171 /*
 172  * Cache a single material.
 173  */
 174 int mtrl_cache(const struct b_mtrl *base)
 175 {
 176     struct mtrl *mp;
 177
 178     int mi = find_mtrl(base->f);
 179
 180     if (mi < 0)
 181     {
 182         int i, c = array_len(mtrls);
 183
 184         /* Find an empty slot. */
 185
 186         for (i = 0; i < c; i++)
 187         {
 188             mp = array_get(mtrls, i);
 189
 190             if (mp->refc == 0)
 191             {
 192                 load_mtrl(mp, base);
 193                 mp->refc++;
 194                 return i;
 195             }
 196         }
 197
 198         /* Allocate a new slot. */
 199
 200         if ((mp = array_add(mtrls)))
 201         {
 202             memset(mp, 0, sizeof (*mp));
 203             load_mtrl(mp, base);
 204             mp->refc++;
 205             return array_len(mtrls) - 1;
 206         }
 207     }
 208     else
 209     {
 210         mp = array_get(mtrls, mi);
 211         mp->refc++;
 212     }
 213
 214     return mi;
 215 }
 216
 217 /*
 218  * Free a cached material.
 219  */
 220 void mtrl_free(int mi)
 221 {
 222     if (mtrls)
 223     {
 224         struct mtrl *mp = array_get(mtrls, mi);
 225
 226         if (mp->refc > 0)
 227         {
 228             mp->refc--;
 229
 230             if (mp->refc == 0)
 231                 free_mtrl(mp);
 232         }
 233     }
 234 }
 235
 236 /*
 237  * Obtain a material pointer.
 238  */
 239 struct mtrl *mtrl_get(int mi)
 240 {
 241     return mtrls ? array_get(mtrls, mi) : NULL;
 242 }
 243
 244 /*
 245  * Cache SOL materials.
 246  */
 247 void mtrl_cache_sol(struct s_base *fp)
 248 {
 249     if (fp->mtrls)
 250     {
 251         free(fp->mtrls);
 252         fp->mtrls = NULL;
 253     }
 254
 255     if ((fp->mtrls = calloc(fp->mc, sizeof (*fp->mtrls))))
 256     {
 257         int mi;
 258
 259         for (mi = 0; mi < fp->mc; mi++)
 260             fp->mtrls[mi] = mtrl_cache(&fp->mv[mi]);
 261     }
 262 }
 263
 264 /*
 265  * Free cached materials.
 266  */
 267 void mtrl_free_sol(struct s_base *fp)
 268 {
 269     if (fp)
 270         if (fp->mtrls)
 271         {
 272             int mi;
 273
 274             for (mi = 0; mi < fp->mc; mi++)
 275                 mtrl_free(fp->mtrls[mi]);
 276
 277             free(fp->mtrls);
 278             fp->mtrls = NULL;
 279         }
 280 }
 281
 282 /*
 283  * Reload materials from material specifications.
 284  */
 285 void mtrl_reload(void)
 286 {
 287     if (mtrls)
 288     {
 289         struct b_mtrl base;
 290
 291         int i, c = array_len(mtrls);
 292
 293         for (i = 0; i < c; i++)
 294         {
 295             struct mtrl *mp = array_get(mtrls, i);
 296
 297             /* Read the material specification. */
 298
 299             if (mp->refc > 0 && mtrl_read(&base, mp->base.f))
 300             {
 301                 free_mtrl(mp);
 302                 load_mtrl(mp, &base);
 303             }
 304         }
 305     }
 306 }
 307
 308 /*
 309  * Load GL resources of all materials.
 310  */
 311 void mtrl_load_objects(void)
 312 {
 313     int i, c = array_len(mtrls);
 314
 315     for (i = 0; i < c; i++)
 316     {
 317         struct mtrl *mp = array_get(mtrls, i);
 318
 319         if (mp->refc > 0)
 320             load_mtrl_objects(mp);
 321     }
 322 }
 323
 324 /*
 325  * Delete GL resources of all materials.
 326  */
 327 void mtrl_free_objects(void)
 328 {
 329     int i, c = array_len(mtrls);
 330
 331     for (i = 0; i < c; i++)
 332     {
 333         struct mtrl *mp = array_get(mtrls, i);
 334
 335         if (mp->refc > 0)
 336             free_mtrl_objects(mp);
 337     }
 338 }
 339
 340 /*
 341  * Initialize material cache.
 342  */
 343 void mtrl_init(void)
 344 {
 345     mtrl_quit();
 346
 347     if ((mtrls = array_new(sizeof (struct mtrl))))
 348     {
 349         /* Cache the default material at index 0. */
 350
 351         default_mtrl = mtrl_cache(&default_base_mtrl);
 352     }
 353 }
 354
 355 /*
 356  * Destroy material cache.
 357  */
 358 void mtrl_quit(void)
 359 {
 360     if (mtrls)
 361     {
 362         int i, c = array_len(mtrls);
 363
 364         for (i = 0; i < c; i++)
 365             free_mtrl(array_get(mtrls, i));
 366
 367         array_free(mtrls);
 368         mtrls = NULL;
 369     }
 370 }
 371 /*---------------------------------------------------------------------------*/
 372
 373 /*
 374  * This has to match up with mtrl_func_names in solid_base.c.
 375  */
 376 static GLenum mtrl_func_syms[8] = {
 377     GL_ALWAYS,
 378     GL_EQUAL,
 379     GL_GEQUAL,
 380     GL_GREATER,
 381     GL_LEQUAL,
 382     GL_LESS,
 383     GL_NEVER,
 384     GL_NOTEQUAL
 385 };
 386
 387 /*
 388  * Convert function index to a GL symbol.
 389  */
 390 GLenum mtrl_func(int i)
 391 {
 392     if (i >= 0 && i < ARRAYSIZE(mtrl_func_syms))
 393         return mtrl_func_syms[i];
 394     else
 395         return GL_ALWAYS;
 396 }
 397
 398 /*---------------------------------------------------------------------------*/