git.maemo.org Git - neverball/blob - share/solid_draw.c

   1 /*
   2  * Copyright (C) 2003 Robert Kooima
   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 <SDL.h>
  16 #include <SDL_rwops.h>
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <math.h>
  22
  23 #include "glext.h"
  24 #include "vec3.h"
  25 #include "image.h"
  26 #include "base_image.h"
  27 #include "base_config.h"
  28 #include "lang.h"
  29
  30 #include "solid_draw.h"
  31 #include "solid_all.h"
  32
  33 /*---------------------------------------------------------------------------*/
  34
  35 static int sol_enum_mtrl(const struct s_base *base,
  36                          const struct b_body *bp, int mi)
  37 {
  38     int li, gi, c = 0;
  39
  40     /* Count all lump geoms with this material. */
  41
  42     for (li = 0; li < bp->lc; li++)
  43     {
  44         int g0 = base->lv[bp->l0 + li].g0;
  45         int gc = base->lv[bp->l0 + li].gc;
  46
  47         for (gi = 0; gi < gc; gi++)
  48             if (base->gv[base->iv[g0 + gi]].mi == mi)
  49                 c++;
  50     }
  51
  52     /* Count all body geoms with this material. */
  53
  54     for (gi = 0; gi < bp->gc; gi++)
  55         if (base->gv[base->iv[bp->g0 + gi]].mi == mi)
  56             c++;
  57
  58     return c;
  59 }
  60
  61 static int sol_enum_body(const struct s_base *base,
  62                          const struct b_body *bp, int fl)
  63 {
  64     int mi, c = 0;
  65
  66     /* Count all geoms with this flag. */
  67
  68     for (mi = 0; mi < base->mc; mi++)
  69         if (base->mv[mi].fl & fl)
  70             c = c + sol_enum_mtrl(base, bp, mi);
  71
  72     return c;
  73 }
  74
  75 /*---------------------------------------------------------------------------*/
  76
  77 #define tobyte(f) ((GLubyte) (f * 255.0f))
  78
  79 #define color_cmp(a, b) (tobyte((a)[0]) == tobyte((b)[0]) && \
  80                          tobyte((a)[1]) == tobyte((b)[1]) && \
  81                          tobyte((a)[2]) == tobyte((b)[2]) && \
  82                          tobyte((a)[3]) == tobyte((b)[3]))
  83
  84 static struct b_mtrl default_base_mtrl =
  85 {
  86     { 0.8f, 0.8f, 0.8f, 1.0f },
  87     { 0.2f, 0.2f, 0.2f, 1.0f },
  88     { 0.0f, 0.0f, 0.0f, 1.0f },
  89     { 0.0f, 0.0f, 0.0f, 1.0f },
  90     { 0.0f }, 0.0f, M_OPAQUE, ""
  91 };
  92
  93 static struct d_mtrl default_draw_mtrl =
  94 {
  95     &default_base_mtrl, 0
  96 };
  97
  98 static const struct d_mtrl *sol_draw_mtrl(const struct s_draw *draw,
  99                                           const struct d_mtrl *mp_draw,
 100                                           const struct d_mtrl *mq_draw)
 101 {
 102     const struct b_mtrl *mp_base = mp_draw->base;
 103     const struct b_mtrl *mq_base = mq_draw->base;
 104
 105     /* Change material properties only as needed. */
 106
 107     if (!color_cmp(mp_base->a, mq_base->a))
 108         glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,   mp_base->a);
 109     if (!color_cmp(mp_base->d, mq_base->d))
 110         glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,   mp_base->d);
 111     if (!color_cmp(mp_base->s, mq_base->s))
 112         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,  mp_base->s);
 113     if (!color_cmp(mp_base->e, mq_base->e))
 114         glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION,  mp_base->e);
 115     if (tobyte(mp_base->h[0]) != tobyte(mq_base->h[0]))
 116         glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mp_base->h);
 117
 118     /* Bind the texture. */
 119
 120     if (mp_draw->o != mq_draw->o)
 121         glBindTexture(GL_TEXTURE_2D, mp_draw->o);
 122
 123     /* Enable environment mapping. */
 124
 125     if ((mp_base->fl & M_ENVIRONMENT) && !(mq_base->fl & M_ENVIRONMENT))
 126     {
 127         glEnable(GL_TEXTURE_GEN_S);
 128         glEnable(GL_TEXTURE_GEN_T);
 129
 130         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
 131         glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
 132     }
 133
 134     /* Disable environment mapping. */
 135
 136     if ((mq_base->fl & M_ENVIRONMENT) && !(mp_base->fl & M_ENVIRONMENT))
 137     {
 138         glDisable(GL_TEXTURE_GEN_S);
 139         glDisable(GL_TEXTURE_GEN_T);
 140     }
 141
 142     /* Enable additive blending. */
 143
 144     if ((mp_base->fl & M_ADDITIVE) && !(mq_base->fl & M_ADDITIVE))
 145         glBlendFunc(GL_ONE, GL_ONE);
 146
 147     /* Enable standard blending. */
 148
 149     if ((mq_base->fl & M_ADDITIVE) && !(mp_base->fl & M_ADDITIVE))
 150         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 151
 152     /* Enable visibility-from-behind. */
 153
 154     if ((mp_base->fl & M_TWO_SIDED) && !(mq_base->fl & M_TWO_SIDED))
 155     {
 156         glDisable(GL_CULL_FACE);
 157         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
 158     }
 159
 160     /* Disable visibility-from-behind. */
 161
 162     if ((mq_base->fl & M_TWO_SIDED) && !(mp_base->fl & M_TWO_SIDED))
 163     {
 164         glEnable(GL_CULL_FACE);
 165         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
 166     }
 167
 168     /* Enable decal offset. */
 169
 170     if ((mp_base->fl & M_DECAL) && !(mq_base->fl & M_DECAL))
 171     {
 172         glEnable(GL_POLYGON_OFFSET_FILL);
 173         glPolygonOffset(-1.0f, -2.0f);
 174     }
 175
 176     /* Disable decal offset. */
 177
 178     if ((mq_base->fl & M_DECAL) && !(mp_base->fl & M_DECAL))
 179         glDisable(GL_POLYGON_OFFSET_FILL);
 180
 181     return mp_draw;
 182 }
 183
 184 static const struct d_mtrl *sol_back_bill(const struct s_draw *draw,
 185                                            const struct b_bill *rp,
 186                                            const struct d_mtrl *mp,
 187                                            float t)
 188 {
 189     float T = (rp->t > 0.0f) ? (fmodf(t, rp->t) - rp->t / 2) : 0.0f;
 190
 191     float w = rp->w[0] + rp->w[1] * T + rp->w[2] * T * T;
 192     float h = rp->h[0] + rp->h[1] * T + rp->h[2] * T * T;
 193
 194     if (w > 0 && h > 0)
 195     {
 196         float rx = rp->rx[0] + rp->rx[1] * T + rp->rx[2] * T * T;
 197         float ry = rp->ry[0] + rp->ry[1] * T + rp->ry[2] * T * T;
 198         float rz = rp->rz[0] + rp->rz[1] * T + rp->rz[2] * T * T;
 199
 200         glPushMatrix();
 201         {
 202             float y0 = (rp->fl & B_EDGE) ? 0 : -h / 2;
 203             float y1 = (rp->fl & B_EDGE) ? h : +h / 2;
 204
 205             glRotatef(ry, 0.0f, 1.0f, 0.0f);
 206             glRotatef(rx, 1.0f, 0.0f, 0.0f);
 207             glTranslatef(0.0f, 0.0f, -rp->d);
 208
 209             if (rp->fl & B_FLAT)
 210             {
 211                 glRotatef(-rx - 90.0f, 1.0f, 0.0f, 0.0f);
 212                 glRotatef(-ry,         0.0f, 0.0f, 1.0f);
 213             }
 214             if (rp->fl & B_EDGE)
 215                 glRotatef(-rx,         1.0f, 0.0f, 0.0f);
 216
 217             glRotatef(rz, 0.0f, 0.0f, 1.0f);
 218
 219             mp = sol_draw_mtrl(draw, draw->mv + rp->mi, mp);
 220
 221             glBegin(GL_QUADS);
 222             {
 223                 glTexCoord2f(0.0f, 0.0f); glVertex2f(-w / 2, y0);
 224                 glTexCoord2f(1.0f, 0.0f); glVertex2f(+w / 2, y0);
 225                 glTexCoord2f(1.0f, 1.0f); glVertex2f(+w / 2, y1);
 226                 glTexCoord2f(0.0f, 1.0f); glVertex2f(-w / 2, y1);
 227             }
 228             glEnd();
 229         }
 230         glPopMatrix();
 231     }
 232
 233     return mp;
 234 }
 235
 236 /*---------------------------------------------------------------------------*/
 237
 238 void sol_back(const struct s_draw *draw, float n, float f, float t)
 239 {
 240     const struct d_mtrl *mp = &default_draw_mtrl;
 241
 242     int ri;
 243
 244     /* Render all billboards in the given range. */
 245
 246     glDisable(GL_LIGHTING);
 247     glDepthMask(GL_FALSE);
 248     {
 249         for (ri = 0; ri < draw->base->rc; ri++)
 250             if (n <= draw->base->rv[ri].d && draw->base->rv[ri].d < f)
 251                 mp = sol_back_bill(draw, draw->base->rv + ri, mp, t);
 252
 253         mp = sol_draw_mtrl(draw, &default_draw_mtrl, mp);
 254     }
 255     glDepthMask(GL_TRUE);
 256     glEnable(GL_LIGHTING);
 257 }
 258
 259 /*---------------------------------------------------------------------------*/
 260 /*
 261  * The  following code  renders a  body in  a  ludicrously inefficient
 262  * manner.  It iterates the materials and scans the data structure for
 263  * geometry using each.  This  has the effect of absolutely minimizing
 264  * material  changes,  texture  bindings,  and  Begin/End  pairs,  but
 265  * maximizing trips through the data.
 266  *
 267  * However, this  is only done once  for each level.   The results are
 268  * stored in display lists.  Thus, it is well worth it.
 269  */
 270
 271 static void sol_draw_geom(const struct s_base *base,
 272                           const struct b_geom *gp, int mi)
 273 {
 274     if (gp->mi == mi)
 275     {
 276         const float *ui = base->tv[gp->ti].u;
 277         const float *uj = base->tv[gp->tj].u;
 278         const float *uk = base->tv[gp->tk].u;
 279
 280         const float *ni = base->sv[gp->si].n;
 281         const float *nj = base->sv[gp->sj].n;
 282         const float *nk = base->sv[gp->sk].n;
 283
 284         const float *vi = base->vv[gp->vi].p;
 285         const float *vj = base->vv[gp->vj].p;
 286         const float *vk = base->vv[gp->vk].p;
 287
 288         glTexCoord2fv(ui);
 289         glNormal3fv(ni);
 290         glVertex3fv(vi);
 291
 292         glTexCoord2fv(uj);
 293         glNormal3fv(nj);
 294         glVertex3fv(vj);
 295
 296         glTexCoord2fv(uk);
 297         glNormal3fv(nk);
 298         glVertex3fv(vk);
 299     }
 300 }
 301
 302 static void sol_draw_lump(const struct s_base *base,
 303                           const struct b_lump *lp, int mi)
 304 {
 305     int i;
 306
 307     for (i = 0; i < lp->gc; i++)
 308         sol_draw_geom(base, base->gv + base->iv[lp->g0 + i], mi);
 309 }
 310
 311 static const struct d_mtrl *sol_draw_body(const struct s_draw *draw,
 312                                           const struct b_body *bp,
 313                                           const struct d_mtrl *mp,
 314                                           int fl, int decal)
 315 {
 316     const struct s_base *base = draw->base;
 317
 318     int mi, li, gi;
 319
 320     /* Iterate all materials of the correct opacity. */
 321
 322     for (mi = 0; mi < draw->mc; mi++)
 323     {
 324         struct d_mtrl *mq = draw->mv + mi;
 325
 326         if ((mq->base->fl & fl) && (mq->base->fl & M_DECAL) == decal)
 327         {
 328             if (sol_enum_mtrl(draw->base, bp, mi))
 329             {
 330                 /* Set the material state. */
 331
 332                 mp = sol_draw_mtrl(draw, mq, mp);
 333
 334                 /* Render all geometry of that material. */
 335
 336                 glBegin(GL_TRIANGLES);
 337                 {
 338                     for (li = 0; li < bp->lc; li++)
 339                         sol_draw_lump(draw->base,
 340                                       base->lv + bp->l0 + li,
 341                                       mi);
 342                     for (gi = 0; gi < bp->gc; gi++)
 343                         sol_draw_geom(draw->base,
 344                                       base->gv + base->iv[bp->g0 + gi],
 345                                       mi);
 346                 }
 347                 glEnd();
 348             }
 349         }
 350     }
 351
 352     return mp;
 353 }
 354
 355 static void sol_draw_list(const struct s_vary *vary,
 356                           const struct v_body *bp, GLuint list)
 357 {
 358     float p[3], e[4], u[3], a;
 359
 360     sol_body_p(p, vary, bp->pi, bp->t);
 361     sol_body_e(e, vary, bp, 0);
 362
 363     q_as_axisangle(e, u, &a);
 364     a = V_DEG(a);
 365
 366     glPushMatrix();
 367     {
 368         /* Translate and rotate a moving body. */
 369
 370         glTranslatef(p[0], p[1], p[2]);
 371         glRotatef(a, u[0], u[1], u[2]);
 372
 373         /* Draw the body. */
 374
 375         glCallList(list);
 376     }
 377     glPopMatrix();
 378 }
 379
 380 void sol_draw(const struct s_draw *draw, int depthmask, int depthtest)
 381 {
 382     int bi;
 383
 384     /* Render all opaque geometry into the color and depth buffers. */
 385
 386     for (bi = 0; bi < draw->bc; bi++)
 387         if (draw->bv[bi].ol)
 388             sol_draw_list(draw->vary, draw->vary->bv + bi, draw->bv[bi].ol);
 389
 390     /* Render all translucent geometry into only the color buffer. */
 391
 392     if (depthtest == 0) glDisable(GL_DEPTH_TEST);
 393     if (depthmask == 0) glDepthMask(GL_FALSE);
 394     {
 395         for (bi = 0; bi < draw->bc; bi++)
 396             if (draw->bv[bi].tl)
 397                 sol_draw_list(draw->vary, draw->vary->bv + bi, draw->bv[bi].tl);
 398     }
 399     if (depthmask == 0) glDepthMask(GL_TRUE);
 400     if (depthtest == 0) glEnable(GL_DEPTH_TEST);
 401 }
 402
 403 void sol_bill(const struct s_draw *draw, const float *M, float t)
 404 {
 405     const struct d_mtrl *mp = &default_draw_mtrl;
 406
 407     int ri;
 408
 409     for (ri = 0; ri < draw->base->rc; ++ri)
 410     {
 411         const struct b_bill *rp = draw->base->rv + ri;
 412
 413         float T = rp->t * t;
 414         float S = fsinf(T);
 415
 416         float w  = rp->w [0] + rp->w [1] * T + rp->w [2] * S;
 417         float h  = rp->h [0] + rp->h [1] * T + rp->h [2] * S;
 418         float rx = rp->rx[0] + rp->rx[1] * T + rp->rx[2] * S;
 419         float ry = rp->ry[0] + rp->ry[1] * T + rp->ry[2] * S;
 420         float rz = rp->rz[0] + rp->rz[1] * T + rp->rz[2] * S;
 421
 422         mp = sol_draw_mtrl(draw, draw->mv + rp->mi, mp);
 423
 424         glPushMatrix();
 425         {
 426             glTranslatef(rp->p[0], rp->p[1], rp->p[2]);
 427
 428             if (M && ((rp->fl & B_NOFACE) == 0)) glMultMatrixf(M);
 429
 430             if (fabsf(rx) > 0.0f) glRotatef(rx, 1.0f, 0.0f, 0.0f);
 431             if (fabsf(ry) > 0.0f) glRotatef(ry, 0.0f, 1.0f, 0.0f);
 432             if (fabsf(rz) > 0.0f) glRotatef(rz, 0.0f, 0.0f, 1.0f);
 433
 434             glBegin(GL_QUADS);
 435             {
 436                 glTexCoord2f(0.0f, 0.0f); glVertex2f(-w / 2, -h / 2);
 437                 glTexCoord2f(1.0f, 0.0f); glVertex2f(+w / 2, -h / 2);
 438                 glTexCoord2f(1.0f, 1.0f); glVertex2f(+w / 2, +h / 2);
 439                 glTexCoord2f(0.0f, 1.0f); glVertex2f(-w / 2, +h / 2);
 440             }
 441             glEnd();
 442         }
 443         glPopMatrix();
 444     }
 445
 446     mp = sol_draw_mtrl(draw, &default_draw_mtrl, mp);
 447 }
 448
 449 void sol_refl(const struct s_draw *draw)
 450 {
 451     int bi;
 452
 453     /* Render all reflective geometry into the color and depth buffers. */
 454
 455     for (bi = 0; bi < draw->bc; bi++)
 456         if (draw->bv[bi].rl)
 457             sol_draw_list(draw->vary, draw->vary->bv + bi, draw->bv[bi].rl);
 458 }
 459
 460 /*---------------------------------------------------------------------------*/
 461
 462 static void sol_shad_geom(const struct s_base *base,
 463                           const struct b_geom *gp, int mi)
 464 {
 465     if (gp->mi == mi)
 466     {
 467         const float *vi = base->vv[gp->vi].p;
 468         const float *vj = base->vv[gp->vj].p;
 469         const float *vk = base->vv[gp->vk].p;
 470
 471         glTexCoord2f(vi[0], vi[2]);
 472         glVertex3fv(vi);
 473
 474         glTexCoord2f(vj[0], vj[2]);
 475         glVertex3fv(vj);
 476
 477         glTexCoord2f(vk[0], vk[2]);
 478         glVertex3fv(vk);
 479     }
 480 }
 481
 482 static void sol_shad_lump(const struct s_base *base,
 483                           const struct b_lump *lp, int mi)
 484 {
 485     int i;
 486
 487     for (i = 0; i < lp->gc; i++)
 488         sol_shad_geom(base, base->gv + base->iv[lp->g0 + i], mi);
 489 }
 490
 491 static void sol_shad_body(const struct s_base *base,
 492                           const struct b_body *bp,
 493                           int fl, int decal)
 494 {
 495     int mi, li, gi;
 496
 497     if (decal)
 498     {
 499         glEnable(GL_POLYGON_OFFSET_FILL);
 500         glPolygonOffset(-1.0f, -2.0f);
 501     }
 502
 503     glBegin(GL_TRIANGLES);
 504     {
 505         for (mi = 0; mi < base->mc; mi++)
 506         {
 507             struct b_mtrl *mp = base->mv + mi;
 508
 509             if ((mp->fl & fl) && (mp->fl & M_DECAL) == decal)
 510             {
 511                 for (li = 0; li < bp->lc; li++)
 512                     sol_shad_lump(base, base->lv + bp->l0 + li, mi);
 513                 for (gi = 0; gi < bp->gc; gi++)
 514                     sol_shad_geom(base, base->gv + base->iv[bp->g0 + gi], mi);
 515             }
 516         }
 517     }
 518     glEnd();
 519
 520     if (decal)
 521         glDisable(GL_POLYGON_OFFSET_FILL);
 522 }
 523
 524 static void sol_shad_list(const struct s_vary *vary,
 525                           const struct v_body *bp, GLuint list)
 526 {
 527     float p[3], e[4], u[3], a;
 528
 529     sol_body_p(p, vary, bp->pi, bp->t);
 530     sol_body_e(e, vary, bp, 0);
 531
 532     q_as_axisangle(e, u, &a);
 533     a = V_DEG(a);
 534
 535     glPushMatrix();
 536     {
 537         /* Translate and rotate a moving body. */
 538
 539         glTranslatef(p[0], p[1], p[2]);
 540         glRotatef(a, u[0], u[1], u[2]);
 541
 542         /* Translate the shadow on a moving body. */
 543
 544         glMatrixMode(GL_TEXTURE);
 545         {
 546             glPushMatrix();
 547             glTranslatef(p[0], p[2], 0.0f);
 548             glRotatef(-a, u[0], u[2], u[1]);
 549         }
 550         glMatrixMode(GL_MODELVIEW);
 551
 552         /* Draw the body. */
 553
 554         glCallList(list);
 555
 556         /* Pop the shadow translation. */
 557
 558         glMatrixMode(GL_TEXTURE);
 559         {
 560             glPopMatrix();
 561         }
 562         glMatrixMode(GL_MODELVIEW);
 563     }
 564     glPopMatrix();
 565 }
 566
 567 void sol_shad(const struct s_draw *draw)
 568 {
 569     int bi;
 570
 571     /* Render all shadowed geometry. */
 572
 573     glDepthMask(GL_FALSE);
 574     {
 575         for (bi = 0; bi < draw->bc; bi++)
 576             if (draw->bv[bi].sl)
 577                 sol_shad_list(draw->vary, draw->vary->bv + bi, draw->bv[bi].sl);
 578     }
 579     glDepthMask(GL_TRUE);
 580 }
 581
 582 /*---------------------------------------------------------------------------*/
 583
 584 static void sol_load_objects(struct s_draw *draw, int s)
 585 {
 586     int i;
 587
 588     /* Here we sort geometry into display lists by material type. */
 589
 590     for (i = 0; i < draw->bc; i++)
 591     {
 592         struct d_body *bp = draw->bv + i;
 593
 594         int on = sol_enum_body(draw->base, bp->base, M_OPAQUE);
 595         int tn = sol_enum_body(draw->base, bp->base, M_TRANSPARENT);
 596         int rn = sol_enum_body(draw->base, bp->base, M_REFLECTIVE);
 597         int dn = sol_enum_body(draw->base, bp->base, M_DECAL);
 598         int sn = sol_enum_body(draw->base, bp->base, M_SHADOWED);
 599
 600         /* Draw all opaque geometry, decals last. */
 601
 602         if (on)
 603         {
 604             bp->ol = glGenLists(1);
 605
 606             glNewList(bp->ol, GL_COMPILE);
 607             {
 608                 const struct d_mtrl *mp = &default_draw_mtrl;
 609
 610                 mp = sol_draw_body(draw, bp->base, mp, M_OPAQUE, 0);
 611                 mp = sol_draw_body(draw, bp->base, mp, M_OPAQUE, M_DECAL);
 612                 mp = sol_draw_mtrl(draw, &default_draw_mtrl, mp);
 613             }
 614             glEndList();
 615         }
 616         else bp->ol = 0;
 617
 618         /* Draw all translucent geometry, decals first. */
 619
 620         if (tn)
 621         {
 622             bp->tl = glGenLists(1);
 623
 624             glNewList(bp->tl, GL_COMPILE);
 625             {
 626                 const struct d_mtrl *mp = &default_draw_mtrl;
 627
 628                 mp = sol_draw_body(draw, bp->base, mp, M_TRANSPARENT, M_DECAL);
 629                 mp = sol_draw_body(draw, bp->base, mp, M_TRANSPARENT, 0);
 630                 mp = sol_draw_mtrl(draw, &default_draw_mtrl, mp);
 631             }
 632             glEndList();
 633         }
 634         else bp->tl = 0;
 635
 636         /* Draw all reflective geometry. */
 637
 638         if (rn)
 639         {
 640             bp->rl = glGenLists(1);
 641
 642             glNewList(bp->rl, GL_COMPILE);
 643             {
 644                 const struct d_mtrl *mp = &default_draw_mtrl;
 645
 646                 mp = sol_draw_body(draw, bp->base, mp, M_REFLECTIVE, 0);
 647                 mp = sol_draw_mtrl(draw, &default_draw_mtrl, mp);
 648             }
 649             glEndList();
 650
 651             draw->reflective = 1;
 652         }
 653         else bp->rl = 0;
 654
 655         /* Draw all shadowed geometry. */
 656
 657         if (s && (on || rn || sn))
 658         {
 659             bp->sl = glGenLists(1);
 660
 661             glNewList(bp->sl, GL_COMPILE);
 662             {
 663                 if (on) sol_shad_body(draw->base, bp->base, M_OPAQUE, 0);
 664                 if (rn) sol_shad_body(draw->base, bp->base, M_REFLECTIVE, 0);
 665                 if (dn) sol_shad_body(draw->base, bp->base, M_OPAQUE, M_DECAL);
 666                 if (sn)
 667                 {
 668                     /* Transparent shadowed geometry hack. */
 669
 670                     if (dn)
 671                         sol_shad_body(draw->base, bp->base, M_SHADOWED, M_DECAL);
 672
 673                     sol_shad_body(draw->base, bp->base, M_SHADOWED, 0);
 674                 }
 675             }
 676             glEndList();
 677         }
 678         else bp->sl = 0;
 679     }
 680 }
 681
 682 static GLuint sol_find_texture(const char *name)
 683 {
 684     char png[MAXSTR];
 685     char jpg[MAXSTR];
 686
 687     GLuint o;
 688
 689     /* Prefer a lossless copy of the texture over a lossy compression. */
 690
 691     strncpy(png, name, PATHMAX); strcat(png, ".png");
 692     strncpy(jpg, name, PATHMAX); strcat(jpg, ".jpg");
 693
 694     /* Check for a PNG. */
 695
 696     if ((o = make_image_from_file(png)))
 697         return o;
 698
 699     /* Check for a JPG. */
 700
 701     if ((o = make_image_from_file(jpg)))
 702         return o;
 703
 704     return 0;
 705 }
 706
 707 static void sol_load_textures(struct s_draw *draw)
 708 {
 709     int i;
 710
 711     /* Load the image referenced by each material. */
 712
 713     for (i = 0; i < draw->mc; i++)
 714     {
 715         struct d_mtrl *mp = draw->mv + i;
 716
 717         if ((mp->o = sol_find_texture(_(mp->base->f))))
 718         {
 719             /* Set the texture to clamp or repeat based on material type. */
 720
 721             if (mp->base->fl & M_CLAMPED)
 722             {
 723                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
 724                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 725             }
 726             else
 727             {
 728                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 729                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 730             }
 731         }
 732     }
 733 }
 734
 735 /*---------------------------------------------------------------------------*/
 736
 737 int sol_load_draw(struct s_draw *draw, const struct s_vary *vary, int s)
 738 {
 739     int i;
 740
 741     memset(draw, 0, sizeof (*draw));
 742
 743     draw->vary = vary;
 744     draw->base = draw->vary->base;
 745
 746     if (draw->base->mc)
 747     {
 748         draw->mv = calloc(draw->base->mc, sizeof (*draw->mv));
 749         draw->mc = draw->base->mc;
 750
 751         for (i = 0; i < draw->base->mc; i++)
 752         {
 753             struct d_mtrl *mp = draw->mv + i;
 754             struct b_mtrl *mq = draw->base->mv + i;
 755
 756             mp->base = mq;
 757         }
 758     }
 759
 760     if (draw->base->bc)
 761     {
 762         draw->bv = calloc(draw->base->bc, sizeof (*draw->bv));
 763         draw->bc = draw->base->bc;
 764
 765         for (i = 0; i < draw->base->bc; i++)
 766         {
 767             struct d_body *bp = draw->bv + i;
 768             struct b_body *bq = draw->base->bv + i;
 769
 770             bp->base = bq;
 771         }
 772     }
 773
 774     sol_load_textures(draw);
 775     sol_load_objects (draw, s);
 776
 777     return 1;
 778 }
 779
 780 void sol_free_draw(struct s_draw *draw)
 781 {
 782     int i;
 783
 784     for (i = 0; i < draw->mc; i++)
 785     {
 786         if (glIsTexture(draw->mv[i].o))
 787             glDeleteTextures(1, &draw->mv[i].o);
 788     }
 789
 790     for (i = 0; i < draw->bc; i++)
 791     {
 792         if (glIsList(draw->bv[i].ol))
 793             glDeleteLists(draw->bv[i].ol, 1);
 794         if (glIsList(draw->bv[i].tl))
 795             glDeleteLists(draw->bv[i].tl, 1);
 796         if (glIsList(draw->bv[i].rl))
 797             glDeleteLists(draw->bv[i].rl, 1);
 798         if (glIsList(draw->bv[i].sl))
 799             glDeleteLists(draw->bv[i].sl, 1);
 800     }
 801
 802     free(draw->mv);
 803     free(draw->bv);
 804
 805     memset(draw, 0, sizeof (*draw));
 806 }
 807
 808 /*---------------------------------------------------------------------------*/
 809
 810 int sol_load_full(struct s_full *full, const char *filename, int s)
 811 {
 812     if (sol_load_base(&full->base, filename))
 813     {
 814         sol_load_vary(&full->vary, &full->base);
 815         sol_load_draw(&full->draw, &full->vary, s);
 816
 817         return 1;
 818     }
 819
 820     return 0;
 821 }
 822
 823 void sol_free_full(struct s_full *full)
 824 {
 825     sol_free_draw(&full->draw);
 826     sol_free_vary(&full->vary);
 827     sol_free_base(&full->base);
 828 }
 829
 830 /*---------------------------------------------------------------------------*/