src/coin.c

   1 /*
   2  *   Copyright (C) 2003 Robert Kooima
   3  *
   4  *   SUPER EMPTY BALL is free software; you can redistribute it and/or modify
   5  *   it under the terms of the GNU General Public License as published by the
   6  *   Free Software Foundation;  either version 2 of the  License, or (at your
   7  *   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 <math.h>
  16
  17 #include "gl.h"
  18 #include "main.h"
  19 #include "vec3.h"
  20 #include "solid.h"
  21 #include "state.h"
  22 #include "image.h"
  23
  24 #define CR 0.15
  25 #define DZ 0.01
  26 #define PI 3.1415926
  27
  28 /*---------------------------------------------------------------------------*/
  29
  30 #define COIN_S "data/png/coin.png"
  31
  32 static struct image coin_i, *coin_p = &coin_i;
  33
  34 /*---------------------------------------------------------------------------*/
  35
  36 GLuint coin_init(int n)
  37 {
  38     GLuint list = glGenLists(1);
  39
  40     image_load(coin_p, COIN_S);
  41
  42     glNewList(list, GL_COMPILE);
  43     {
  44         double x;
  45         double y;
  46         int i;
  47
  48         image_bind(coin_p);
  49
  50         glBegin(GL_TRIANGLE_FAN);
  51         {
  52             glNormal3d(0.0, 0.0, +1.0);
  53
  54             for (i = 0; i < n; i++)
  55             {
  56                 x = cos(+2.0 * PI * i / n);
  57                 y = sin(+2.0 * PI * i / n);
  58
  59                 glTexCoord2d(-0.5 * x - 0.5, 0.5 * y - 0.5);
  60                 glVertex3d(CR * x, CR * y, +DZ);
  61             }
  62         }
  63         glEnd();
  64
  65         glBegin(GL_TRIANGLE_FAN);
  66         {
  67             glNormal3d(0.0, 0.0, -1.0);
  68
  69             for (i = 0; i < n; i++)
  70             {
  71                 x = cos(-2.0 * PI * i / n);
  72                 y = sin(-2.0 * PI * i / n);
  73
  74                 glTexCoord2d(+0.5 * x - 0.5, 0.5 * y - 0.5);
  75                 glVertex3d(CR * x, CR * y, +DZ);
  76             }
  77         }
  78         glEnd();
  79
  80         glBegin(GL_QUAD_STRIP);
  81         {
  82             for (i = 0; i <= n; i++)
  83             {
  84                 x = cos(+2.0 * PI * i / n);
  85                 y = sin(+2.0 * PI * i / n);
  86
  87                 glNormal3d(x, y, 0.0);
  88                 glVertex3d(CR * x, CR * y, +DZ);
  89                 glVertex3d(CR * x, CR * y, -DZ);
  90             }
  91         }
  92         glEnd();
  93     }
  94     glEndList();
  95
  96     return list;
  97 }
  98
  99 void coin_draw(GLuint list, const struct s_coin *cv, int cc)
 100 {
 101     static const float c1[4] = { 1.0f, 1.0f, 0.0f, 1.0f };
 102     static const float c2[4] = { 1.0f, 0.2f, 0.2f, 1.0f };
 103     static const float c3[4] = { 0.2f, 0.2f, 1.0f, 1.0f };
 104     static const float  s[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
 105
 106     double r = 360.0 * fmod(time_state(), 1.0);
 107     int i;
 108
 109     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, s);
 110
 111     for (i = 0; i < cc; i++)
 112     {
 113         if (0 < cv[i].n && cv[i].n < 5)
 114             glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, c1);
 115
 116         if (4 < cv[i].n && cv[i].n < 10)
 117             glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, c2);
 118
 119         if (9 < cv[i].n)
 120             glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, c3);
 121
 122         if (0 < cv[i].n)
 123         {
 124             glPushMatrix();
 125             {
 126                 glTranslated(cv[i].p[0],
 127                              cv[i].p[1],
 128                              cv[i].p[2]);
 129                 glRotated(r, 0.0, 1.0, 0.0);
 130                 glCallList(list);
 131             }
 132             glPopMatrix();
 133         }
 134     }
 135 }
 136
 137 int coin_test(const struct s_ball *up, struct s_coin *cv, int cc)
 138 {
 139     int i, n = 0;
 140
 141     for (i = 0; i < cc; i++)
 142     {
 143         double r[3];
 144
 145         v_sub(r, up->p, cv[i].p);
 146
 147         if (v_len(r) < CR + up->r)
 148         {
 149             n += cv[i].n;
 150             cv[i].n = 0;
 151         }
 152     }
 153
 154     return n;
 155 }
 156
 157 /*---------------------------------------------------------------------------*/