r_sky.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // r_sky.c
  21
  22 #include "quakedef.h"
  23 #include "r_local.h"
  24 #include "d_local.h"
  25
  26
  27 int             iskyspeed = 8;
  28 int             iskyspeed2 = 2;
  29 float   skyspeed, skyspeed2;
  30
  31 float           skytime;
  32
  33 byte            *r_skysource;
  34
  35 int r_skymade;
  36 int r_skydirect;                // not used?
  37
  38
  39 // TODO: clean up these routines
  40
  41 byte    bottomsky[128*131];
  42 byte    bottommask[128*131];
  43 byte    newsky[128*256];        // newsky and topsky both pack in here, 128 bytes
  44                                                         //  of newsky on the left of each scan, 128 bytes
  45                                                         //  of topsky on the right, because the low-level
  46                                                         //  drawers need 256-byte scan widths
  47
  48
  49 /*
  50 =============
  51 R_InitSky
  52
  53 A sky texture is 256*128, with the right side being a masked overlay
  54 ==============
  55 */
  56 void R_InitSky (texture_t *mt)
  57 {
  58         int                     i, j;
  59         byte            *src;
  60
  61         src = (byte *)mt + mt->offsets[0];
  62
  63         for (i=0 ; i<128 ; i++)
  64         {
  65                 for (j=0 ; j<128 ; j++)
  66                 {
  67                         newsky[(i*256) + j + 128] = src[i*256 + j + 128];
  68                 }
  69         }
  70
  71         for (i=0 ; i<128 ; i++)
  72         {
  73                 for (j=0 ; j<131 ; j++)
  74                 {
  75                         if (src[i*256 + (j & 0x7F)])
  76                         {
  77                                 bottomsky[(i*131) + j] = src[i*256 + (j & 0x7F)];
  78                                 bottommask[(i*131) + j] = 0;
  79                         }
  80                         else
  81                         {
  82                                 bottomsky[(i*131) + j] = 0;
  83                                 bottommask[(i*131) + j] = 0xff;
  84                         }
  85                 }
  86         }
  87
  88         r_skysource = newsky;
  89 }
  90
  91
  92 /*
  93 =================
  94 R_MakeSky
  95 =================
  96 */
  97 void R_MakeSky (void)
  98 {
  99         int                     x, y;
 100         int                     ofs, baseofs;
 101         int                     xshift, yshift;
 102         unsigned        *pnewsky;
 103         static int      xlast = -1, ylast = -1;
 104
 105         xshift = skytime*skyspeed;
 106         yshift = skytime*skyspeed;
 107
 108         if ((xshift == xlast) && (yshift == ylast))
 109                 return;
 110
 111         xlast = xshift;
 112         ylast = yshift;
 113
 114         pnewsky = (unsigned *)&newsky[0];
 115
 116         for (y=0 ; y<SKYSIZE ; y++)
 117         {
 118                 baseofs = ((y+yshift) & SKYMASK) * 131;
 119
 120 // FIXME: clean this up
 121 #if UNALIGNED_OK
 122                 for (x=0 ; x<SKYSIZE ; x += 4)
 123                 {
 124                         ofs = baseofs + ((x+xshift) & SKYMASK);
 125
 126                 // PORT: unaligned dword access to bottommask and bottomsky
 127                         *pnewsky = (*(pnewsky + (128 / sizeof (unsigned))) &
 128                                                 *(unsigned *)&bottommask[ofs]) |
 129                                                 *(unsigned *)&bottomsky[ofs];
 130                         pnewsky++;
 131                 }
 132 #else
 133                 for (x=0 ; x<SKYSIZE ; x++)
 134                 {
 135                         ofs = baseofs + ((x+xshift) & SKYMASK);
 136
 137                         *(byte *)pnewsky = (*((byte *)pnewsky + 128) &
 138                                                 *(byte *)&bottommask[ofs]) |
 139                                                 *(byte *)&bottomsky[ofs];
 140                         pnewsky = (unsigned *)((byte *)pnewsky + 1);
 141                 }
 142 #endif
 143
 144                 pnewsky += 128 / sizeof (unsigned);
 145         }
 146
 147         r_skymade = 1;
 148 }
 149
 150
 151 /*
 152 =================
 153 R_GenSkyTile
 154 =================
 155 */
 156 void R_GenSkyTile (void *pdest)
 157 {
 158         int                     x, y;
 159         int                     ofs, baseofs;
 160         int                     xshift, yshift;
 161         unsigned        *pnewsky;
 162         unsigned        *pd;
 163
 164         xshift = skytime*skyspeed;
 165         yshift = skytime*skyspeed;
 166
 167         pnewsky = (unsigned *)&newsky[0];
 168         pd = (unsigned *)pdest;
 169
 170         for (y=0 ; y<SKYSIZE ; y++)
 171         {
 172                 baseofs = ((y+yshift) & SKYMASK) * 131;
 173
 174 // FIXME: clean this up
 175 #if UNALIGNED_OK
 176
 177                 for (x=0 ; x<SKYSIZE ; x += 4)
 178                 {
 179                         ofs = baseofs + ((x+xshift) & SKYMASK);
 180
 181                 // PORT: unaligned dword access to bottommask and bottomsky
 182
 183                         *pd = (*(pnewsky + (128 / sizeof (unsigned))) &
 184                                    *(unsigned *)&bottommask[ofs]) |
 185                                    *(unsigned *)&bottomsky[ofs];
 186                         pnewsky++;
 187                         pd++;
 188                 }
 189
 190 #else
 191
 192                 for (x=0 ; x<SKYSIZE ; x++)
 193                 {
 194                         ofs = baseofs + ((x+xshift) & SKYMASK);
 195
 196                         *(byte *)pd = (*((byte *)pnewsky + 128) &
 197                                                 *(byte *)&bottommask[ofs]) |
 198                                                 *(byte *)&bottomsky[ofs];
 199                         pnewsky = (unsigned *)((byte *)pnewsky + 1);
 200                         pd = (unsigned *)((byte *)pd + 1);
 201                 }
 202
 203 #endif
 204
 205                 pnewsky += 128 / sizeof (unsigned);
 206         }
 207 }
 208
 209
 210 /*
 211 =================
 212 R_GenSkyTile16
 213 =================
 214 */
 215 void R_GenSkyTile16 (void *pdest)
 216 {
 217         int                             x, y;
 218         int                             ofs, baseofs;
 219         int                             xshift, yshift;
 220         byte                    *pnewsky;
 221         unsigned short  *pd;
 222
 223         xshift = skytime * skyspeed;
 224         yshift = skytime * skyspeed;
 225
 226         pnewsky = (byte *)&newsky[0];
 227         pd = (unsigned short *)pdest;
 228
 229         for (y=0 ; y<SKYSIZE ; y++)
 230         {
 231                 baseofs = ((y+yshift) & SKYMASK) * 131;
 232
 233 // FIXME: clean this up
 234 // FIXME: do faster unaligned version?
 235                 for (x=0 ; x<SKYSIZE ; x++)
 236                 {
 237                         ofs = baseofs + ((x+xshift) & SKYMASK);
 238
 239                         *pd = d_8to16table[(*(pnewsky + 128) &
 240                                         *(byte *)&bottommask[ofs]) |
 241                                         *(byte *)&bottomsky[ofs]];
 242                         pnewsky++;
 243                         pd++;
 244                 }
 245
 246                 pnewsky += TILE_SIZE;
 247         }
 248 }
 249
 250
 251 /*
 252 =============
 253 R_SetSkyFrame
 254 ==============
 255 */
 256 void R_SetSkyFrame (void)
 257 {
 258         int             g, s1, s2;
 259         float   temp;
 260
 261         skyspeed = iskyspeed;
 262         skyspeed2 = iskyspeed2;
 263
 264         g = GreatestCommonDivisor (iskyspeed, iskyspeed2);
 265         s1 = iskyspeed / g;
 266         s2 = iskyspeed2 / g;
 267         temp = SKYSIZE * s1 * s2;
 268
 269         skytime = cl.time - ((int)(cl.time / temp) * temp);
 270
 271
 272         r_skymade = 0;
 273 }