src/light.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "light.h"
  21 #include <math.h>
  22 #include "util/numeric.h"
  23
  24 #ifndef SERVER
  25
  26 // Length of LIGHT_MAX+1 means LIGHT_MAX is the last value.
  27 // LIGHT_SUN is read as LIGHT_MAX from here.
  28
  29 u8 light_LUT[LIGHT_MAX+1];
  30
  31 // the const ref to light_LUT is what is actually used in the code.
  32 const u8 *light_decode_table = light_LUT;
  33
  34 /** Initialize or update the light value tables using the specified \p gamma.
  35  *  If \p gamma == 1.0 then the light table is linear.  Typically values for
  36  *  gamma range between 1.8 and 2.2.
  37  *
  38  *  @note The value for gamma will be restricted to the range 1.1 <= gamma <= 3.0.
  39  *
  40  *  @note This function is not, currently, a simple linear to gamma encoding
  41  *        because adjustments are made so that a gamma of 1.8 gives the same
  42  *        results as those hardcoded for use by the server.
  43  */
  44 void set_light_table(float gamma)
  45 {
  46         static const float brightness_step = 255.0f / (LIGHT_MAX + 1);
  47
  48         // this table is pure arbitrary values, made so that
  49         // at gamma 2.2 the game looks not too dark at light=1,
  50         // and mostly linear for the rest of the scale.
  51         // we could try to inverse the gamma power function, but this
  52         // is simpler and quicker.
  53         static const int adjustments[LIGHT_MAX + 1] = {
  54                 -67,
  55                 -91,
  56                 -125,
  57                 -115,
  58                 -104,
  59                 -85,
  60                 -70,
  61                 -63,
  62                 -56,
  63                 -49,
  64                 -42,
  65                 -35,
  66                 -28,
  67                 -22,
  68                 0
  69         };
  70
  71         gamma = rangelim(gamma, 1.0, 3.0);
  72
  73         float brightness = brightness_step;
  74
  75         for (size_t i = 0; i < LIGHT_MAX; i++) {
  76                 light_LUT[i] = (u8)(255 * powf(brightness / 255.0f, 1.0 / gamma));
  77                 light_LUT[i] = rangelim(light_LUT[i] + adjustments[i], 0, 255);
  78                 if (i > 1 && light_LUT[i] < light_LUT[i - 1])
  79                         light_LUT[i] = light_LUT[i - 1] + 1;
  80                 brightness += brightness_step;
  81         }
  82         light_LUT[LIGHT_MAX] = 255;
  83 }
  84 #endif
  85