vcs.maemo.org Git - neverball/blob - share/solid_gl.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 "solid_gl.h"
  28 #include "base_config.h"
  29
  30 /*---------------------------------------------------------------------------*/
  31
  32 static int sol_enum_mtrl(const struct s_file *fp,
  33                          const struct s_body *bp, int mi)
  34 {
  35     int li, gi, c = 0;
  36
  37     /* Count all lump geoms with this material. */
  38
  39     for (li = 0; li < bp->lc; li++)
  40     {
  41         int g0 = fp->lv[bp->l0 + li].g0;
  42         int gc = fp->lv[bp->l0 + li].gc;
  43
  44         for (gi = 0; gi < gc; gi++)
  45             if (fp->gv[fp->iv[g0 + gi]].mi == mi)
  46                 c++;
  47     }
  48
  49     /* Count all body geoms with this material. */
  50
  51     for (gi = 0; gi < bp->gc; gi++)
  52         if (fp->gv[fp->iv[bp->g0 + gi]].mi == mi)
  53             c++;
  54
  55     return c;
  56 }
  57
  58 static int sol_enum_body(const struct s_file *fp,
  59                          const struct s_body *bp, int fl)
  60 {
  61     int mi, c = 0;
  62
  63     /* Count all geoms with this flag. */
  64
  65     for (mi = 0; mi < fp->mc; mi++)
  66         if (fp->mv[mi].fl & fl)
  67             c = c + sol_enum_mtrl(fp, bp, mi);
  68
  69     return c;
  70 }
  71
  72 /*---------------------------------------------------------------------------*/
  73
  74 #define color_cmp(a, b) ((a)[0] == (b)[0] && \
  75                          (a)[1] == (b)[1] && \
  76                          (a)[2] == (b)[2] && \
  77                          (a)[3] == (b)[3])
  78
  79 static struct s_mtrl default_mtrl =
  80 {
  81     { 0.2f, 0.2f, 0.2f, 1.0f },
  82     { 0.8f, 0.8f, 0.8f, 1.0f },
  83     { 0.0f, 0.0f, 0.0f, 1.0f },
  84     { 0.0f, 0.0f, 0.0f, 1.0f },
  85     { 0.0f, }, 0.0f, M_OPAQUE, 0, ""
  86 };
  87
  88 static const struct s_mtrl *sol_draw_mtrl(const struct s_file *fp,
  89                                           const struct s_mtrl *mp,
  90                                           const struct s_mtrl *mq)
  91 {
  92     /* Change material properties only as needed. */
  93
  94     if (!color_cmp(mp->a, mq->a))
  95         glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,   mp->a);
  96     if (!color_cmp(mp->d, mq->d))
  97         glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,   mp->d);
  98     if (!color_cmp(mp->s, mq->s))
  99         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,  mp->s);
 100     if (!color_cmp(mp->e, mq->e))
 101         glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION,  mp->e);
 102     if (mp->h[0] != mq->h[0])
 103         glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mp->h);
 104
 105     /* Bind the texture. */
 106
 107     if (mp->o != mq->o)
 108         glBindTexture(GL_TEXTURE_2D, mp->o);
 109
 110     /* Enable environment mapping. */
 111
 112     if ((mp->fl & M_ENVIRONMENT) && !(mq->fl & M_ENVIRONMENT))
 113     {
 114         glEnable(GL_TEXTURE_GEN_S);
 115         glEnable(GL_TEXTURE_GEN_T);
 116
 117         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
 118         glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
 119     }
 120
 121     /* Disable environment mapping. */
 122
 123     if ((mq->fl & M_ENVIRONMENT) && !(mp->fl & M_ENVIRONMENT))
 124     {
 125         glDisable(GL_TEXTURE_GEN_S);
 126         glDisable(GL_TEXTURE_GEN_T);
 127
 128         glBindTexture(GL_TEXTURE_2D, mp->o);
 129     }
 130
 131     /* Enable additive blending. */
 132
 133     if ((mp->fl & M_ADDITIVE) && !(mq->fl & M_ADDITIVE))
 134         glBlendFunc(GL_ONE, GL_ONE);
 135
 136     /* Enable standard blending. */
 137
 138     if ((mq->fl & M_ADDITIVE) && !(mp->fl & M_ADDITIVE))
 139         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 140
 141     /* Enable decal offset. */
 142
 143     if ((mp->fl & M_DECAL) && !(mq->fl & M_DECAL))
 144     {
 145         glEnable(GL_POLYGON_OFFSET_FILL);
 146         glPolygonOffset(-1.0f, -2.0f);
 147     }
 148
 149     /* Disable decal offset. */
 150
 151     if ((mq->fl & M_DECAL) && !(mp->fl & M_DECAL))
 152         glDisable(GL_POLYGON_OFFSET_FILL);
 153
 154     return mp;
 155 }
 156
 157 static const struct s_mtrl *sol_draw_bill(const struct s_file *fp,
 158                                           const struct s_bill *rp,
 159                                           const struct s_mtrl *mp, float t)
 160 {
 161     float T  = fmodf(t, rp->t) - rp->t / 2;
 162
 163     float w  = rp->w[0] + rp->w[1] * T + rp->w[2] * T * T;
 164     float h  = rp->h[0] + rp->h[1] * T + rp->h[2] * T * T;
 165
 166     if (w > 0 && h > 0)
 167     {
 168         float rx = rp->rx[0] + rp->rx[1] * T + rp->rx[2] * T * T;
 169         float ry = rp->ry[0] + rp->ry[1] * T + rp->ry[2] * T * T;
 170         float rz = rp->rz[0] + rp->rz[1] * T + rp->rz[2] * T * T;
 171
 172         glPushMatrix();
 173         {
 174             float y0 = (rp->fl & B_EDGE) ? 0 : -h / 2;
 175             float y1 = (rp->fl & B_EDGE) ? h : +h / 2;
 176
 177             glRotatef(ry, 0.0f, 1.0f, 0.0f);
 178             glRotatef(rx, 1.0f, 0.0f, 0.0f);
 179             glTranslatef(0.0f, 0.0f, -rp->d);
 180
 181             if (rp->fl & B_FLAT)
 182             {
 183                 glRotatef(-rx - 90.0f, 1.0f, 0.0f, 0.0f);
 184                 glRotatef(-ry,         0.0f, 0.0f, 1.0f);
 185             }
 186             if (rp->fl & B_EDGE)
 187                 glRotatef(-rx,         1.0f, 0.0f, 0.0f);
 188
 189             glRotatef(rz, 0.0f, 0.0f, 1.0f);
 190
 191             mp = sol_draw_mtrl(fp, fp->mv + rp->mi, mp);
 192
 193             glBegin(GL_QUADS);
 194             {
 195                 glTexCoord2f(0.0f, 1.0f); glVertex2f(-w / 2, y0);
 196                 glTexCoord2f(1.0f, 1.0f); glVertex2f(+w / 2, y0);
 197                 glTexCoord2f(1.0f, 0.0f); glVertex2f(+w / 2, y1);
 198                 glTexCoord2f(0.0f, 0.0f); glVertex2f(-w / 2, y1);
 199             }
 200             glEnd();
 201         }
 202         glPopMatrix();
 203     }
 204
 205     return mp;
 206 }
 207
 208 void sol_back(const struct s_file *fp, float n, float f, float t)
 209 {
 210     const struct s_mtrl *mp = &default_mtrl;
 211
 212     int ri;
 213
 214     /* Render all billboards in the given range. */
 215
 216     glDisable(GL_LIGHTING);
 217     glDepthMask(GL_FALSE);
 218     {
 219         for (ri = 0; ri < fp->rc; ri++)
 220             if (n <= fp->rv[ri].d && fp->rv[ri].d < f)
 221                 mp = sol_draw_bill(fp, fp->rv + ri, mp, t);
 222
 223         mp = sol_draw_mtrl(fp, &default_mtrl, mp);
 224     }
 225     glDepthMask(GL_TRUE);
 226     glEnable(GL_LIGHTING);
 227 }
 228
 229 /*---------------------------------------------------------------------------*/
 230 /*
 231  * The  following code  renders a  body in  a  ludicrously inefficient
 232  * manner.  It iterates the materials and scans the data structure for
 233  * geometry using each.  This  has the effect of absolutely minimizing
 234  * material  changes,  texture  bindings,  and  Begin/End  pairs,  but
 235  * maximizing trips through the data.
 236  *
 237  * However, this  is only done once  for each level.   The results are
 238  * stored in display lists.  Thus, it is well worth it.
 239  */
 240
 241 static void sol_draw_geom(const struct s_file *fp,
 242                           const struct s_geom *gp, int mi)
 243 {
 244     if (gp->mi == mi)
 245     {
 246         const float *ui = fp->tv[gp->ti].u;
 247         const float *uj = fp->tv[gp->tj].u;
 248         const float *uk = fp->tv[gp->tk].u;
 249
 250         const float *ni = fp->sv[gp->si].n;
 251         const float *nj = fp->sv[gp->sj].n;
 252         const float *nk = fp->sv[gp->sk].n;
 253
 254         const float *vi = fp->vv[gp->vi].p;
 255         const float *vj = fp->vv[gp->vj].p;
 256         const float *vk = fp->vv[gp->vk].p;
 257
 258         glTexCoord2fv(ui);
 259         glNormal3fv(ni);
 260         glVertex3fv(vi);
 261
 262         glTexCoord2fv(uj);
 263         glNormal3fv(nj);
 264         glVertex3fv(vj);
 265
 266         glTexCoord2fv(uk);
 267         glNormal3fv(nk);
 268         glVertex3fv(vk);
 269     }
 270 }
 271
 272 static void sol_draw_lump(const struct s_file *fp,
 273                           const struct s_lump *lp, int mi)
 274 {
 275     int i;
 276
 277     for (i = 0; i < lp->gc; i++)
 278         sol_draw_geom(fp, fp->gv + fp->iv[lp->g0 + i], mi);
 279 }
 280
 281 static const struct s_mtrl *sol_draw_body(const struct s_file *fp,
 282                                           const struct s_body *bp,
 283                                           const struct s_mtrl *mp, int fl)
 284 {
 285     int mi, li, gi;
 286
 287     /* Iterate all materials of the correct opacity. */
 288
 289     for (mi = 0; mi < fp->mc; mi++)
 290         if ((fp->mv[mi].fl & fl) == fl)
 291         {
 292             if (sol_enum_mtrl(fp, bp, mi))
 293             {
 294                 /* Set the material state. */
 295
 296                 mp = sol_draw_mtrl(fp, fp->mv + mi, mp);
 297
 298                 /* Render all geometry of that material. */
 299
 300                 glBegin(GL_TRIANGLES);
 301                 {
 302                     for (li = 0; li < bp->lc; li++)
 303                         sol_draw_lump(fp, fp->lv + bp->l0 + li, mi);
 304                     for (gi = 0; gi < bp->gc; gi++)
 305                         sol_draw_geom(fp, fp->gv + fp->iv[bp->g0 + gi], mi);
 306                 }
 307                 glEnd();
 308             }
 309         }
 310
 311     return mp;
 312 }
 313
 314 static void sol_draw_list(const struct s_file *fp,
 315                           const struct s_body *bp, GLuint list)
 316 {
 317     float p[3];
 318
 319     sol_body_p(p, fp, bp);
 320
 321     glPushMatrix();
 322     {
 323         /* Translate a moving body. */
 324
 325         glTranslatef(p[0], p[1], p[2]);
 326
 327         /* Draw the body. */
 328
 329         glCallList(list);
 330     }
 331     glPopMatrix();
 332 }
 333
 334 void sol_draw(const struct s_file *fp)
 335 {
 336     int bi;
 337
 338     /* Render all opaque geometry into the color and depth buffers. */
 339
 340     for (bi = 0; bi < fp->bc; bi++)
 341         if (fp->bv[bi].ol)
 342             sol_draw_list(fp, fp->bv + bi, fp->bv[bi].ol);
 343
 344     /* Render all translucent geometry into only the color buffer. */
 345
 346     glDepthMask(GL_FALSE);
 347     {
 348         for (bi = 0; bi < fp->bc; bi++)
 349             if (fp->bv[bi].tl)
 350                 sol_draw_list(fp, fp->bv + bi, fp->bv[bi].tl);
 351     }
 352     glDepthMask(GL_TRUE);
 353 }
 354
 355 void sol_refl(const struct s_file *fp)
 356 {
 357     int bi;
 358
 359     /* Render all reflective geometry into the color and depth buffers. */
 360
 361     for (bi = 0; bi < fp->bc; bi++)
 362         if (fp->bv[bi].rl)
 363             sol_draw_list(fp, fp->bv + bi, fp->bv[bi].rl);
 364 }
 365
 366 /*---------------------------------------------------------------------------*/
 367
 368 static void sol_shad_geom(const struct s_file *fp,
 369                           const struct s_geom *gp, int mi)
 370 {
 371     if (gp->mi == mi)
 372     {
 373         const float *vi = fp->vv[gp->vi].p;
 374         const float *vj = fp->vv[gp->vj].p;
 375         const float *vk = fp->vv[gp->vk].p;
 376
 377         glTexCoord2f(vi[0], vi[2]);
 378         glVertex3fv(vi);
 379
 380         glTexCoord2f(vj[0], vj[2]);
 381         glVertex3fv(vj);
 382
 383         glTexCoord2f(vk[0], vk[2]);
 384         glVertex3fv(vk);
 385     }
 386 }
 387
 388 static void sol_shad_lump(const struct s_file *fp,
 389                           const struct s_lump *lp, int mi)
 390 {
 391     int i;
 392
 393     for (i = 0; i < lp->gc; i++)
 394         sol_shad_geom(fp, fp->gv + fp->iv[lp->g0 + i], mi);
 395 }
 396
 397 static void sol_shad_body(const struct s_file *fp,
 398                           const struct s_body *bp, int fl)
 399 {
 400     int mi, li, gi;
 401
 402     if (fl & M_DECAL)
 403     {
 404         glEnable(GL_POLYGON_OFFSET_FILL);
 405         glPolygonOffset(-1.0f, -2.0f);
 406     }
 407
 408     glBegin(GL_TRIANGLES);
 409     {
 410         for (mi = 0; mi < fp->mc; mi++)
 411             if ((fp->mv[mi].fl & fl) == fl)
 412             {
 413                 for (li = 0; li < bp->lc; li++)
 414                     sol_shad_lump(fp, fp->lv + bp->l0 + li, mi);
 415                 for (gi = 0; gi < bp->gc; gi++)
 416                     sol_shad_geom(fp, fp->gv + fp->iv[bp->g0 + gi], mi);
 417             }
 418     }
 419     glEnd();
 420
 421     if (fl & M_DECAL)
 422         glDisable(GL_POLYGON_OFFSET_FILL);
 423 }
 424
 425 static void sol_shad_list(const struct s_file *fp,
 426                           const struct s_body *bp, GLuint list)
 427 {
 428     float p[3];
 429
 430     sol_body_p(p, fp, bp);
 431
 432     glPushMatrix();
 433     {
 434         /* Translate a moving body. */
 435
 436         glTranslatef(p[0], p[1], p[2]);
 437
 438         /* Translate the shadow on a moving body. */
 439
 440         glMatrixMode(GL_TEXTURE);
 441         {
 442             glPushMatrix();
 443             glTranslatef(p[0], p[2], 0.0f);
 444         }
 445         glMatrixMode(GL_MODELVIEW);
 446
 447         /* Draw the body. */
 448
 449         glCallList(list);
 450
 451         /* Pop the shadow translation. */
 452
 453         glMatrixMode(GL_TEXTURE);
 454         {
 455             glPopMatrix();
 456         }
 457         glMatrixMode(GL_MODELVIEW);
 458     }
 459     glPopMatrix();
 460 }
 461
 462 void sol_shad(const struct s_file *fp)
 463 {
 464     int bi;
 465
 466     /* Render all shadowed geometry. */
 467
 468     glDepthMask(GL_FALSE);
 469     {
 470         for (bi = 0; bi < fp->bc; bi++)
 471             if (fp->bv[bi].sl)
 472                 sol_shad_list(fp, fp->bv + bi, fp->bv[bi].sl);
 473     }
 474     glDepthMask(GL_TRUE);
 475 }
 476
 477 /*---------------------------------------------------------------------------*/
 478
 479 static void sol_load_objects(struct s_file *fp, int s)
 480 {
 481     int i;
 482
 483     /* Here we sort geometry into display lists by material type. */
 484
 485     for (i = 0; i < fp->bc; i++)
 486     {
 487         struct s_body *bp = fp->bv + i;
 488
 489         int on = sol_enum_body(fp, bp, M_OPAQUE);
 490         int tn = sol_enum_body(fp, bp, M_TRANSPARENT);
 491         int rn = sol_enum_body(fp, bp, M_REFLECTIVE);
 492         int dn = sol_enum_body(fp, bp, M_DECAL);
 493
 494         /* Draw all opaque geometry, decals last. */
 495
 496         if (on)
 497         {
 498             fp->bv[i].ol = glGenLists(1);
 499
 500             glNewList(fp->bv[i].ol, GL_COMPILE);
 501             {
 502                 const struct s_mtrl *mp = &default_mtrl;
 503
 504                 mp = sol_draw_body(fp, fp->bv + i, mp, M_OPAQUE);
 505                 mp = sol_draw_body(fp, fp->bv + i, mp, M_OPAQUE | M_DECAL);
 506                 mp = sol_draw_mtrl(fp, &default_mtrl, mp);
 507             }
 508             glEndList();
 509         }
 510         else fp->bv[i].ol = 0;
 511
 512         /* Draw all translucent geometry, decals first. */
 513
 514         if (tn)
 515         {
 516             fp->bv[i].tl = glGenLists(1);
 517
 518             glNewList(fp->bv[i].tl, GL_COMPILE);
 519             {
 520                 const struct s_mtrl *mp = &default_mtrl;
 521
 522                 mp = sol_draw_body(fp, fp->bv + i, mp, M_TRANSPARENT | M_DECAL);
 523                 mp = sol_draw_body(fp, fp->bv + i, mp, M_TRANSPARENT);
 524                 mp = sol_draw_mtrl(fp, &default_mtrl, mp);
 525             }
 526             glEndList();
 527         }
 528         else fp->bv[i].tl = 0;
 529
 530         /* Draw all reflective geometry. */
 531
 532         if (rn)
 533         {
 534             fp->bv[i].rl = glGenLists(1);
 535
 536             glNewList(fp->bv[i].rl, GL_COMPILE);
 537             {
 538                 const struct s_mtrl *mp = &default_mtrl;
 539
 540                 mp = sol_draw_body(fp, fp->bv + i, mp, M_REFLECTIVE);
 541                 mp = sol_draw_mtrl(fp, &default_mtrl, mp);
 542             }
 543             glEndList();
 544         }
 545         else fp->bv[i].rl = 0;
 546
 547         /* Draw all shadowed geometry. */
 548
 549         if (s && (on || rn))
 550         {
 551             fp->bv[i].sl = glGenLists(1);
 552
 553             glNewList(fp->bv[i].sl, GL_COMPILE);
 554             {
 555                 if (on) sol_shad_body(fp, fp->bv + i, M_OPAQUE);
 556                 if (rn) sol_shad_body(fp, fp->bv + i, M_REFLECTIVE);
 557                 if (dn) sol_shad_body(fp, fp->bv + i, M_OPAQUE | M_DECAL);
 558             }
 559             glEndList();
 560         }
 561         else fp->bv[i].sl = 0;
 562     }
 563 }
 564
 565 static GLuint sol_find_texture(const char *name)
 566 {
 567     char png[MAXSTR];
 568     char jpg[MAXSTR];
 569
 570     GLuint o;
 571
 572     /* Prefer a lossless copy of the texture over a lossy compression. */
 573
 574     strncpy(png, name, PATHMAX); strcat(png, ".png");
 575     strncpy(jpg, name, PATHMAX); strcat(jpg, ".jpg");
 576
 577     /* Check for a PNG. */
 578
 579     if ((o = make_image_from_file(png)))
 580         return o;
 581
 582     /* Check for a JPG. */
 583
 584     if ((o = make_image_from_file(jpg)))
 585         return o;
 586
 587     return 0;
 588 }
 589
 590 static void sol_load_textures(struct s_file *fp, int k)
 591 {
 592     int i;
 593
 594     /* Load the image referenced by each material. */
 595
 596     for (i = 0; i < fp->mc; i++)
 597         if ((fp->mv[i].o = sol_find_texture(fp->mv[i].f)))
 598         {
 599             /* Set the texture to clamp or repeat based on material type. */
 600
 601             if (fp->mv[i].fl & M_CLAMPED)
 602             {
 603                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
 604                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 605             }
 606             else
 607             {
 608                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 609                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 610             }
 611         }
 612 }
 613
 614 /*---------------------------------------------------------------------------*/
 615
 616 int sol_load_gl(struct s_file *fp, const char *filename, int k, int s)
 617 {
 618     if (sol_load_only_file(fp, filename))
 619     {
 620         sol_load_textures(fp, k);
 621         sol_load_objects (fp, s);
 622         return 1;
 623     }
 624     return 0;
 625 }
 626
 627 /*---------------------------------------------------------------------------*/
 628
 629 void sol_free_gl(struct s_file *fp)
 630 {
 631     int i;
 632
 633     for (i = 0; i < fp->mc; i++)
 634     {
 635         if (glIsTexture(fp->mv[i].o))
 636             glDeleteTextures(1, &fp->mv[i].o);
 637     }
 638
 639     for (i = 0; i < fp->bc; i++)
 640     {
 641         if (glIsList(fp->bv[i].ol))
 642             glDeleteLists(fp->bv[i].ol, 1);
 643         if (glIsList(fp->bv[i].tl))
 644             glDeleteLists(fp->bv[i].tl, 1);
 645         if (glIsList(fp->bv[i].rl))
 646             glDeleteLists(fp->bv[i].rl, 1);
 647     }
 648
 649     sol_free(fp);
 650 }
 651
 652 /*---------------------------------------------------------------------------*/