├── HosekDataXYZ.h
├── LICENSE.md
├── README.md
├── SunSky.cpp
├── SunSky.h
├── SunSkyTool.cpp
├── VL234f.h
├── gen-images.sh
├── images
    ├── hosek-1.png
    ├── hosek-2.png
    ├── hosek-3.png
    ├── hosek-4.png
    ├── hosek-5.png
    ├── hosek-6.png
    ├── hosek-7.png
    ├── hosek-oc-1.png
    ├── hosek-oc-2.png
    ├── hosek-oc-3.png
    ├── hosek-oc-4.png
    ├── hosek-oc-5.png
    ├── hosek-oc-6.png
    ├── hosek-oc-7.png
    ├── hosek-ocd-1.png
    ├── hosek-ocd-2.png
    ├── hosek-ocd-3.png
    ├── hosek-ocd-4.png
    ├── hosek-ocd-5.png
    ├── hosek-ocd-6.png
    ├── hosek-ocd-7.png
    ├── hosekBRDF-rd-1.png
    ├── hosekBRDF-rd-2.png
    ├── hosekBRDF-rd-3.png
    ├── hosekBRDF-rd-4.png
    ├── hosekBRDF-rd-5.png
    ├── hosekBRDF-rd-6.png
    ├── hosekBRDF-rd-7.png
    ├── hosekBRDF-rs-1.png
    ├── hosekBRDF-rs-2.png
    ├── hosekBRDF-rs-3.png
    ├── hosekBRDF-rs-4.png
    ├── hosekBRDF-rs-5.png
    ├── hosekBRDF-rs-6.png
    ├── hosekBRDF-rs-7.png
    ├── preetham-1.png
    ├── preetham-2.png
    ├── preetham-3.png
    ├── preetham-4.png
    ├── preetham-5.png
    ├── preetham-6.png
    ├── preetham-7.png
    ├── preetham-oc-1.png
    ├── preetham-oc-2.png
    ├── preetham-oc-3.png
    ├── preetham-oc-4.png
    ├── preetham-oc-5.png
    ├── preetham-oc-6.png
    ├── preetham-oc-7.png
    ├── preetham-ocd-1.png
    ├── preetham-ocd-2.png
    ├── preetham-ocd-3.png
    ├── preetham-ocd-4.png
    ├── preetham-ocd-5.png
    ├── preetham-ocd-6.png
    ├── preetham-ocd-7.png
    ├── preethamBRDF-rd-1.png
    ├── preethamBRDF-rd-2.png
    ├── preethamBRDF-rd-3.png
    ├── preethamBRDF-rd-4.png
    ├── preethamBRDF-rd-5.png
    ├── preethamBRDF-rd-6.png
    ├── preethamBRDF-rd-7.png
    ├── preethamBRDF-rs-1.png
    ├── preethamBRDF-rs-2.png
    ├── preethamBRDF-rs-3.png
    ├── preethamBRDF-rs-4.png
    ├── preethamBRDF-rs-5.png
    ├── preethamBRDF-rs-6.png
    └── preethamBRDF-rs-7.png
└── stb_image_mini.h


/LICENSE.md:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <http://unlicense.org>
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Overview
  2 | ========
  3 | 
  4 | The code in SunSky.* is an implementation of several sky models:
  5 | 
  6 | * The Preetham Clear Sky model. (From ["A Practical Analytic Model for
  7 |   Daylight"](https://www.cs.utah.edu/~shirley/papers/sunsky/), Preetham, Shirley
  8 |   & Smits.)
  9 | 
 10 | * The Hosek Clear Sky model. (From ["An Analytic Model for Full Spectral Sky-Dome
 11 |   Radiance"](https://cgg.mff.cuni.cz/projects/SkylightModelling/), Hosek &
 12 |   Wilkie.)
 13 | 
 14 | * Various luminance-only CIE models:
 15 |   * The Clear Sky model
 16 |   * The Overcast Sky model
 17 |   * The Partly(!) Cloudy Sky model
 18 |   * The more recent fifteen CIE sky models from, e.g., "CIE general sky standard
 19 |     defining luminance distributions", Darula & Kittler. (There are many variants
 20 |     of this paper!)
 21 | 
 22 | * The sun model from Preetham (also used by Hosek), and helpers for converting
 23 |   from time and place to local sun direction.
 24 | 
 25 | In addition, for the Preetham and Hosek models, I have added:
 26 | 
 27 | * Table-driven versions for fast evaluation on the GPU (or indeed CPU) via
 28 |   64 x 2 lookup table.
 29 | 
 30 | * Extended table-driven versions that use zonal harmonics to produce approximate
 31 |   mirror-to-diffuse BRDF power convolutions. These use 64 x 8 or 64 x 16
 32 |   tables.
 33 | 
 34 | * Proper handling of night transitions. The original models assume the sun
 35 |   is above the horizon. The supplied code transitions to a dark blue sky as
 36 |   the sun fully sets, and then to black towards the end of twilight.
 37 | 
 38 | * An extension to allow mixing the clear sky models with an overcast sky
 39 |   via a simple linear 'overcast' factor. Generally it's best to use this
 40 |   to simulate high cloud, while low-lying clouds are represented explicitly
 41 |   in the shader. However, when used for shading rather than skybox display,
 42 |   it can also represent low-lying cloud cover.
 43 | 
 44 | The Preetham code is a trusty standby, and has been shipped in several games.
 45 | 
 46 | The Hosek code is new, it is a re-implementation of the Hosek paper using
 47 | floats, with some minor optimisations, and an attempt to make the structure a
 48 | bit more obvious. The CPU-only and table variants are solid, as is the night
 49 | transition. The overcast functionality and BRDF convolution might need a bit
 50 | more tweaking.
 51 | 
 52 | I would like to provide some sample shaders, but for now look at FillTexture*,
 53 | and the Table::SkyRGB() routines.
 54 | 
 55 | 
 56 | Results
 57 | =======
 58 | 
 59 | Preetham
 60 | --------
 61 | 
 62 | Clear Sky:
 63 | 
 64 | ![](images/preetham-1.png)
 65 | ![](images/preetham-2.png)
 66 | ![](images/preetham-3.png)
 67 | ![](images/preetham-4.png)
 68 | ![](images/preetham-5.png)
 69 | ![](images/preetham-6.png)
 70 | ![](images/preetham-7.png)
 71 | 
 72 | Overcast 50%/Day
 73 | 
 74 | ![](images/preetham-oc-1.png)
 75 | ![](images/preetham-oc-2.png)
 76 | ![](images/preetham-oc-3.png)
 77 | ![](images/preetham-oc-4.png)
 78 | ![](images/preetham-oc-5.png)
 79 | ![](images/preetham-oc-6.png)
 80 | ![](images/preetham-oc-7.png)
 81 | <br>
 82 | ![](images/preetham-ocd-1.png)
 83 | ![](images/preetham-ocd-2.png)
 84 | ![](images/preetham-ocd-3.png)
 85 | ![](images/preetham-ocd-4.png)
 86 | ![](images/preetham-ocd-5.png)
 87 | ![](images/preetham-ocd-6.png)
 88 | ![](images/preetham-ocd-7.png)
 89 | 
 90 | BRDF Day/Sunset:
 91 | 
 92 | ![](images/preethamBRDF-rd-1.png)
 93 | ![](images/preethamBRDF-rd-2.png)
 94 | ![](images/preethamBRDF-rd-3.png)
 95 | ![](images/preethamBRDF-rd-4.png)
 96 | ![](images/preethamBRDF-rd-5.png)
 97 | ![](images/preethamBRDF-rd-6.png)
 98 | ![](images/preethamBRDF-rd-7.png)
 99 | <br>
100 | ![](images/preethamBRDF-rs-1.png)
101 | ![](images/preethamBRDF-rs-2.png)
102 | ![](images/preethamBRDF-rs-3.png)
103 | ![](images/preethamBRDF-rs-4.png)
104 | ![](images/preethamBRDF-rs-5.png)
105 | ![](images/preethamBRDF-rs-6.png)
106 | ![](images/preethamBRDF-rs-7.png)
107 | 
108 | Hosek
109 | -----
110 | 
111 | Clear Sky:
112 | 
113 | ![](images/hosek-1.png)
114 | ![](images/hosek-2.png)
115 | ![](images/hosek-3.png)
116 | ![](images/hosek-4.png)
117 | ![](images/hosek-5.png)
118 | ![](images/hosek-6.png)
119 | ![](images/hosek-7.png)
120 | 
121 | Overcast 50%/Day:
122 | 
123 | ![](images/hosek-oc-1.png)
124 | ![](images/hosek-oc-2.png)
125 | ![](images/hosek-oc-3.png)
126 | ![](images/hosek-oc-4.png)
127 | ![](images/hosek-oc-5.png)
128 | ![](images/hosek-oc-6.png)
129 | ![](images/hosek-oc-7.png)
130 | <br>
131 | ![](images/hosek-ocd-1.png)
132 | ![](images/hosek-ocd-2.png)
133 | ![](images/hosek-ocd-3.png)
134 | ![](images/hosek-ocd-4.png)
135 | ![](images/hosek-ocd-5.png)
136 | ![](images/hosek-ocd-6.png)
137 | ![](images/hosek-ocd-7.png)
138 | 
139 | BRDF Day/Sunset:
140 | 
141 | ![](images/hosekBRDF-rd-1.png)
142 | ![](images/hosekBRDF-rd-2.png)
143 | ![](images/hosekBRDF-rd-3.png)
144 | ![](images/hosekBRDF-rd-4.png)
145 | ![](images/hosekBRDF-rd-5.png)
146 | ![](images/hosekBRDF-rd-6.png)
147 | ![](images/hosekBRDF-rd-7.png)
148 | <br>
149 | ![](images/hosekBRDF-rs-1.png)
150 | ![](images/hosekBRDF-rs-2.png)
151 | ![](images/hosekBRDF-rs-3.png)
152 | ![](images/hosekBRDF-rs-4.png)
153 | ![](images/hosekBRDF-rs-5.png)
154 | ![](images/hosekBRDF-rs-6.png)
155 | ![](images/hosekBRDF-rs-7.png)
156 | 
157 | 
158 | SunSky Tool
159 | ===========
160 | 
161 | Included in SunSkyTool.cpp is a tool exercising most of the sky model
162 | functionality. Current options are below. It can be used to generate top-down
163 | 'hemisphere' views with or without fisheye projection, panoramic views, and
164 | cube maps, with various forms of tonemapping. Both LDR (png) and HDR (pfm)
165 | versions are output.
166 | 
167 | Building
168 | --------
169 | 
170 | To build this tool, use
171 | 
172 |     c++ --std=c++11 -O3 SunSky.cpp SunSkyTool.cpp -o sunsky
173 | 
174 | Or add those files to your favourite IDE.
175 | 
176 | Options
177 | -------
178 | 
179 |         sunsky <options>
180 | 
181 |         Options:
182 |           -h : this help
183 |           -t <time>          : 0 - 24
184 |           -d <day of year>   : 0 - 365
185 |           -b <tubidity>      : 2 - 30
186 |           -x <ground_bounce> : 0 - 1
187 |           -l <latitude> <longitude>
188 |           -w <normalisation weight>
189 |           -g <gamma>
190 |           -e <tonemapType> : use given tonemap operator (default: linear)
191 |           -a : autoscale intensity
192 |           -i : invert hemisphere
193 |           -f : fisheye rather than cos projection
194 |           -c : output cubemap instead
195 |           -p : output panorama instead
196 |           -m : output movie, record day as sky.mp4, requires ffmpeg
197 |           -v : verbose
198 |           -s <skyType> : use given sky type
199 |           -r <roughness:float> : specify roughness for PreethamBRDF
200 | 
201 |         skyType:
202 |           Preetham         (pt)
203 |           PreethamTable    (ptt)
204 |           PreethamBRDF     (ptb)
205 |           Hosek            (hk)
206 |           HosekTable       (hkt)
207 |           HosekBRDF        (hkb)
208 |           cieClear         (cc)
209 |           cieOvercast      (co)
210 |           ciePartlyCloudy  (cp)
211 | 
212 |         toneMapType:
213 |           linear           (l)
214 |           exponential      (ex)
215 |           reinhard         (rh)
216 | 
217 | Examples
218 | --------
219 | 
220 | Show noon sky for the current time of year using Preetham:
221 | 
222 |         sunsky -t 12
223 | 
224 | Glossy version of the same sky:
225 | 
226 |         sunsky -t 12 -s preethamBRDF -r 0.3
227 | 
228 | Hosek sky at 4pm with greenish albedo, high turbidity, and exponential tone
229 | mapping, saved to a cube map:
230 | 
231 |         sunsky -t 16 -s hosek -x 0.2 0.5 0.2 -b 6 -e ex -c
232 | 
233 | 


--------------------------------------------------------------------------------
/SunSky.cpp:
--------------------------------------------------------------------------------
   1 | //
   2 | //  File:       SunSky.cpp
   3 | //
   4 | //  Function:   Implements SunSky.h
   5 | //
   6 | //  Author:     Andrew Willmott, Preetham sun/sky based on code by Brian Smits,
   7 | //              Hosek code used L. Hosek & A. Wilkie code Version 1.4a as reference
   8 | //
   9 | //  Copyright:  Andrew Willmott, see HosekDataXYZ.h for Hosek data copyright
  10 | //
  11 | 
  12 | #include "VL234f.h"
  13 | 
  14 | #include "SunSky.h"
  15 | 
  16 | #include "HosekDataXYZ.h"
  17 | 
  18 | #include <stdint.h>
  19 | #include <float.h>
  20 | #include <assert.h>
  21 | 
  22 | using namespace SSLib;
  23 | 
  24 | // #define SIM_CLAMP                // emulate normalised integer texture, for CPU-side checking
  25 | // #define SUPPORT_OVERCAST_CLAMP   // support overcast functionality via tables. (Without overcast, the theta table is within 0-1 anyway.)
  26 | // #define HOSEK_G_FIX              // experimental fix for hue ringing in rare sunset occasions with BRDF version of Hosek
  27 | // #define HOSEK_BRDF_ANALYTIC_H    // for A/B'ing H/FH tables vs. direct ZH evaluation
  28 | // #define LOCAL_DEBUG              // dump debug/tuning info
  29 | 
  30 | #ifdef LOCAL_DEBUG
  31 |     #include <stdio.h>
  32 | #endif
  33 | 
  34 | namespace
  35 | {
  36 |     // XYZ/RGB for sRGB primaries
  37 |     const Vec3f kXYZToR( 3.2404542f, -1.5371385f, -0.4985314f);
  38 |     const Vec3f kXYZToG(-0.9692660f,  1.8760108f,  0.0415560f);
  39 |     const Vec3f kXYZToB( 0.0556434f, -0.2040259f,  1.0572252f);
  40 | 
  41 |     const Vec3f kRGBToX(0.4124564f,  0.3575761f,  0.1804375f);
  42 |     const Vec3f kRGBToY(0.2126729f,  0.7151522f,  0.0721750f);
  43 |     const Vec3f kRGBToZ(0.0193339f,  0.1191920f,  0.9503041f);
  44 | 
  45 |     const Vec2f kClearChroma       (2.0f / 3.0f, 1.0f / 3.0f);
  46 |     const Vec2f kOvercastChroma    (1.0f / 3.0f, 1.0f / 3.0f);
  47 |     const Vec2f kPartlyCloudyChroma(1.0f / 3.0f, 1.0f / 3.0f);
  48 | 
  49 |     inline Vec3f xyYToXYZ(const Vec3f& c)
  50 |     {
  51 |         return Vec3f(c.x, c.y, 1.0f - c.x - c.y) * c.z / c.y;
  52 |     }
  53 | 
  54 |     inline Vec3f xyYToRGB(const Vec3f& xyY)
  55 |     {
  56 |         Vec3f XYZ = xyYToXYZ(xyY);
  57 | 
  58 |         return Vec3f
  59 |         (
  60 |             dot(kXYZToR, XYZ),
  61 |             dot(kXYZToG, XYZ),
  62 |             dot(kXYZToB, XYZ)
  63 |         );
  64 |     }
  65 | 
  66 |     inline Vec3f XYZToRGB(const Vec3f& XYZ)
  67 |     {
  68 |         return Vec3f
  69 |         (
  70 |             dot(kXYZToR, XYZ),
  71 |             dot(kXYZToG, XYZ),
  72 |             dot(kXYZToB, XYZ)
  73 |         );
  74 |     }
  75 | 
  76 |     inline Vec3f RGBToXYZ(const Vec3f& rgb)
  77 |     {
  78 |         return Vec3f
  79 |         (
  80 |             dot(kRGBToX, rgb),
  81 |             dot(kRGBToY, rgb),
  82 |             dot(kRGBToZ, rgb)
  83 |         );
  84 |     }
  85 | 
  86 |     inline float ClampUnit(float s)
  87 |     {
  88 |         if (s <= 0.0f)
  89 |             return 0.0f;
  90 |         if (s >= 1.0f)
  91 |             return 1.0f;
  92 |         return s;
  93 |     }
  94 | 
  95 |     inline float ClampPositive(float s)
  96 |     {
  97 |         if (s <= 0.0f)
  98 |             return 0.0f;
  99 |         return s;
 100 |     }
 101 |     inline Vec3f ClampPositive(Vec3f v)
 102 |     {
 103 |         return { ClampPositive(v.x), ClampPositive(v.y), ClampPositive(v.z) };
 104 |     }
 105 | 
 106 | #ifdef SIM_CLAMP
 107 |     inline Vec3f ClampUnit(Vec3f v)
 108 |     {
 109 |         return { ClampUnit(v.x), ClampUnit(v.y), ClampUnit(v.z) };
 110 |     }
 111 | #endif
 112 | 
 113 |     const float    kFToIBiasF32 = (float)(uint32_t(3) << 22);
 114 |     const int32_t  kFToIBiasS32 = 0x4B400000;
 115 | 
 116 |     inline int32_t FloorToInt32(float s) // force int 'fast' version of this
 117 |     {
 118 |         union
 119 |         {
 120 |             float f;
 121 |             int32_t i;
 122 |         } fi;
 123 | 
 124 |         fi.f = floorf(s) + kFToIBiasF32;
 125 |         return fi.i - kFToIBiasS32;
 126 |     }
 127 | 
 128 |     inline float LerpClamp(float s)
 129 |     {
 130 |         if (s <= 0.0f)         return 0.0f;
 131 |         if (s >= 1.0f - 1e-6f) return 1.0f - 1e-6f;
 132 |         return s;
 133 |     }
 134 | 
 135 |     template<class T_V> T_V Lerp(float s, int n, const T_V c[])
 136 |     {
 137 |         s = LerpClamp(s);
 138 |         assert(s >= 0.0f && s < 1.0f);
 139 | 
 140 |         s *= n - 1;
 141 | 
 142 |         int si0 = FloorToInt32(s);
 143 |         int si1 = (si0 + 1);
 144 | 
 145 |         float sf = s - si0;
 146 | 
 147 |         return c[si0] * (1 - sf)
 148 |              + c[si1] *    sf   ;
 149 |     }
 150 | 
 151 |     template<class T_V> T_V BiLerp(float s, float t, int w, int h, const T_V c[])
 152 |     {
 153 |         s = LerpClamp(s);
 154 |         t = LerpClamp(t);
 155 |         assert(s >= 0.0f && t >= 0.0f);
 156 |         assert(s  < 1.0f && t  < 1.0f);
 157 | 
 158 |         s *= w - 1;
 159 |         t *= h - 1;
 160 | 
 161 |         int si0 = FloorToInt32(s);
 162 |         int ti0 = FloorToInt32(t);
 163 | 
 164 |         int si1 = (si0 + 1);
 165 |         int ti1 = (ti0 + 1);
 166 | 
 167 |         float sf = s - si0;
 168 |         float tf = t - ti0;
 169 | 
 170 |         ti0 *= w;
 171 |         ti1 *= w;
 172 | 
 173 |         return c[si0 + ti0] * (1 - sf) * (1 - tf)
 174 |              + c[si1 + ti0] *    sf    * (1 - tf)
 175 |              + c[si0 + ti1] * (1 - sf) *    tf
 176 |              + c[si1 + ti1] *    sf    *    tf;
 177 |     }
 178 | 
 179 |     inline float DegreesToRadians(float d)
 180 |     {
 181 |         return d * (vl_twoPi / 360.0f);
 182 |     }
 183 | }
 184 | 
 185 | Vec3f SSLib::SunDirection(float timeOfDay, float timeZone, int julianDay, float latitude, float longitude)
 186 | {
 187 |     float solarTime = timeOfDay
 188 |         +  (0.170f * sinf(4 * vl_pi * (julianDay - 80) / 373)
 189 |           - 0.129f * sinf(2 * vl_pi * (julianDay -  8) / 355))
 190 |         + (longitude / 15 - timeZone);
 191 | 
 192 |     float solarDeclination = (0.4093f * sinf(2 * vl_pi * (julianDay - 81) / 368));
 193 | 
 194 |     float latRads = DegreesToRadians(latitude);
 195 | 
 196 |     float sx = cosf(solarDeclination)                 * sinf(vl_pi * solarTime / 12);
 197 |     float sy = cosf(latRads) * sinf(solarDeclination)
 198 |              + sinf(latRads) * cosf(solarDeclination) * cosf(vl_pi * solarTime / 12);
 199 |     float sz = sinf(latRads) * sinf(solarDeclination)
 200 |              - cosf(latRads) * cosf(solarDeclination) * cosf(vl_pi * solarTime / 12);
 201 | 
 202 |     return Vec3f(sx, sy, sz);
 203 | }
 204 | 
 205 | const float SSLib::kSunDiameter   = 1.392f;
 206 | const float SSLib::kSunDistance   = 149.6f;
 207 | const float SSLib::kSunCosAngle   = sqrtf(1.0f - sqr(0.5f * kSunDiameter / kSunDistance));   // = 0.999989
 208 | const float SSLib::kSunSolidAngle = vl_twoPi * (1.0f - kSunCosAngle);  // = 6.79998e-05 steradians
 209 | 
 210 | 
 211 | //------------------------------------------------------------------------------
 212 | // Preetham sun model
 213 | //------------------------------------------------------------------------------
 214 | 
 215 | namespace
 216 | {
 217 |     // From Preetham. Was used by Hosek as sun source, so can be used in conjunction
 218 |     // with either.
 219 |     const float kSunRadiance[16][16][3] =
 220 |     {
 221 |         { {39.4028, 1.98004, 5.96046e-08}, {68821.4, 29221.3, 3969.28}, {189745, 116333, 43283.4}, {284101, 199843, 103207}, {351488, 265139, 161944}, {400584, 315075, 213163}, {437555, 353806, 256435}, {466261, 384480, 292823}, {489140, 409270, 323569}, {507776, 429675, 349757}, {523235, 446739, 372260}, {536260, 461207, 391767}, {547379, 473621, 408815}, {556978, 484385, 423827}, {565348, 493805, 437137}, {572701, 502106, 449002} },
 222 |         { {34.9717, 0.0775114, 0}, {33531, 11971.9, 875.627}, {127295, 71095, 22201.3}, {216301, 142827, 66113.9}, {285954, 205687, 115900}, {339388, 256990, 163080}, {380973, 298478, 205124}, {414008, 332299, 241816}, {440780, 360220, 273675}, {462869, 383578, 301382}, {481379, 403364, 325586}, {497102, 420314, 346848}, {510615, 434983, 365635}, {522348, 447795, 382333}, {532628, 459074, 397255}, {541698, 469067, 410647} },
 223 |         { {10.0422, 0, 0.318865}, {16312.8, 4886.47, 84.98}, {85310.4, 43421.5, 11226.2}, {164586, 102046, 42200.5}, {232559, 159531, 82822.4}, {287476, 209581, 124663}, {331656, 251771, 163999}, {367569, 287173, 199628}, {397168, 317025, 231420}, {421906, 342405, 259652}, {442848, 364181, 284724}, {460784, 383030, 307045}, {476303, 399483, 326987}, {489856, 413955, 344876}, {501789, 426774, 360988}, {512360, 438191, 375548} },
 224 |         { {2.3477, 5.96046e-08, 0.129991}, {117.185, 30.0648, 0}, {57123.3, 26502.1, 5565.4}, {125170, 72886.2, 26819.8}, {189071, 123708, 59081.9}, {243452, 170892, 95209.2}, {288680, 212350, 131047}, {326303, 248153, 164740}, {357842, 278989, 195638}, {384544, 305634, 223657}, {407381, 328788, 248954}, {427101, 349038, 271779}, {444282, 366866, 292397}, {459372, 382660, 311064}, {472723, 396734, 328012}, {484602, 409337, 343430} },
 225 |         { {0.383395, 0, 0.027703}, {58.0534, 12.8383, 0}, {38221.6, 16163.6, 2681.55}, {95147.4, 52043, 16954.8}, {153669, 95910.9, 42062}, {206127, 139327, 72640.8}, {251236, 179082, 104653}, {289639, 214417, 135896}, {322383, 245500, 165343}, {350467, 272796, 192613}, {374734, 296820, 217644}, {395864, 318050, 240533}, {414400, 336900, 261440}, {430773, 353719, 280544}, {445330, 368800, 298027}, {458337, 382374, 314041} },
 226 |         { {0.0560895, 0, 0.00474608}, {44.0061, 8.32402, 0}, {25559, 9849.99, 1237.01}, {72294.8, 37148.7, 10649}, {124859, 74345.6, 29875.8}, {174489, 113576, 55359.1}, {218617, 151011, 83520.3}, {257067, 185252, 112054}, {290413, 216016, 139698}, {319390, 243473, 165842}, {344686, 267948, 190241}, {366896, 289801, 212852}, {386513, 309371, 233736}, {403942, 326957, 252998}, {419513, 342823, 270764}, {433487, 357178, 287149} },
 227 |         { {0.00811136, 0, 0.000761211}, {38.0318, 6.09287, 0}, {17083.4, 5996.83, 530.476}, {54909.7, 26508.7, 6634.5}, {101423, 57618.7, 21163.3}, {147679, 92573, 42135.2}, {190207, 127327, 66606.4}, {228134, 160042, 92352.6}, {261593, 190061, 117993}, {291049, 217290, 142758}, {317031, 241874, 166258}, {340033, 264051, 188331}, {360490, 284081, 208945}, {378771, 302212, 228135}, {395184, 318667, 245976}, {409974, 333634, 262543} },
 228 |         { {0.00118321, 0, 0.000119328}, {34.5228, 4.62524, 0}, {11414.1, 3646.94, 196.889}, {41690.9, 18909.8, 4091.39}, {82364.6, 44646.9, 14944.8}, {124966, 75444.4, 32024.3}, {165467, 107347, 53075.4}, {202437, 138252, 76076.7}, {235615, 167214, 99627}, {265208, 193912, 122858}, {291580, 218327, 145272}, {315124, 240580, 166611}, {336208, 260851, 186761}, {355158, 279331, 205696}, {372256, 296206, 223440}, {387729, 311636, 240030} },
 229 |         { {0.000174701, 0, 1.84774e-05}, {31.4054, 3.4608, 0}, {7624.24, 2215.02, 48.0059}, {31644.8, 13484.4, 2490.1}, {66872.4, 34589.1, 10515}, {105728, 61477.4, 24300.5}, {143926, 90494.6, 42256.1}, {179617, 119420, 62635.3}, {212200, 147105, 84088.4}, {241645, 173041, 105704}, {268159, 197064, 126911}, {292028, 219187, 147374}, {313550, 239512, 166913}, {333008, 258175, 185447}, {350650, 275321, 202953}, {366683, 291081, 219433} },
 230 |         { {2.61664e-05, 0, 2.86102e-06}, {27.3995, 2.42835, 5.96046e-08}, {391.889, 104.066, 0}, {24013.1, 9611.97, 1489.37}, {54282.4, 26792.1, 7366.53}, {89437, 50090, 18406.3}, {125174, 76280.7, 33609.8}, {159354, 103145, 51538.2}, {191098, 129407, 70945.4}, {220163, 154409, 90919.4}, {246607, 177864, 110847}, {270613, 199690, 130337}, {292410, 219912, 149156}, {312229, 238614, 167173}, {330289, 255902, 184328}, {346771, 271876, 200589} },
 231 |         { {3.93391e-06, 0, 4.76837e-07}, {21.8815, 1.51091, 0}, {106.645, 26.2423, 0}, {18217.8, 6848.77, 869.811}, {44054, 20748.7, 5134.5}, {75644.5, 40807, 13913.2}, {108852, 64293.6, 26704.2}, {141364, 89082.8, 42380.1}, {172081, 113831, 59831.4}, {200579, 137777, 78179.7}, {226776, 160529, 96794.7}, {250759, 181920, 115250}, {272686, 201910, 133270}, {292739, 220530, 150685}, {311103, 237847, 167398}, {327934, 253933, 183349} },
 232 |         { {6.55651e-07, 0, 1.19209e-07}, {15.4347, 0.791314, 0}, {67.98, 15.4685, 0}, {13818.5, 4877.71, 490.832}, {35746.5, 16065.3, 3556.94}, {63969.8, 33240.3, 10492.5}, {94648, 54185.5, 21192.5}, {125394, 76932.4, 34825.1}, {154946, 100125, 50435.6}, {182726, 122930, 67203.7}, {208530, 144877, 84504.4}, {232352, 165726, 101891}, {254283, 185376, 119059}, {274458, 203811, 135807}, {293024, 221062, 152009}, {310113, 237169, 167579} },
 233 |         { {5.96046e-08, 0, 0}, {9.57723, 0.336247, 0}, {52.9113, 11.1074, 0}, {10479.8, 3472.19, 262.637}, {29000.9, 12436.5, 2445.87}, {54089.5, 27073.4, 7891.84}, {82288.3, 45662.7, 16796.5}, {111218, 66434.7, 28595.3}, {139508, 88064, 42494.5}, {166453, 109678, 57749.2}, {191743, 130747, 73756.6}, {215288, 150968, 90064.3}, {237114, 170191, 106348}, {257311, 188355, 122384}, {275989, 205455, 138022}, {293255, 221507, 153152} },
 234 |         { {0, 0, 0}, {5.37425, 0.109694, 0}, {44.9811, 8.68891, 5.96046e-08}, {7946.76, 2470.32, 128.128}, {23524.7, 9625.27, 1666.58}, {45729.5, 22047.9, 5917.85}, {71535.2, 38477.1, 13293.2}, {98636.4, 57365.7, 23460.6}, {125598, 77452, 35785}, {151620, 97851, 49607}, {176299, 117990, 64359}, {199469, 137520, 79594.4}, {221098, 156245, 94979.6}, {241228, 174066, 110274}, {259937, 190947, 125309}, {277307, 206875, 139956} },
 235 |         { {0, 0, 0}, {2.83079, 0.0199037, 0}, {40.0718, 7.10214, 0}, {6025.35, 1756.45, 51.1916}, {19080.1, 7447.79, 1122.67}, {38657, 17952.9, 4422.16}, {62181.1, 32419.5, 10503.8}, {87471.2, 49531.4, 19230.6}, {113069, 68115.1, 30117.9}, {138102, 87295.1, 42596.4}, {162092, 106474, 56143.2}, {184805, 125266, 70327.1}, {206156, 143438, 84812.9}, {226144, 160857, 99349.8}, {244814, 177459, 113755}, {262220, 193206, 127887} },
 236 |         { {0, 0, 0}, {1.43779, 0, 0.00738072}, {36.6245, 5.93644, 0}, {4568.17, 1248.02, 9.13028}, {15473.4, 5761.51, 745.266}, {32674.7, 14616.6, 3291.16}, {54045.1, 27313.1, 8284.85}, {77563.8, 42764.4, 15747.9}, {101783, 59900.8, 25332.8}, {125782, 77874.7, 36561.6}, {149022, 96078.4, 48962}, {171213, 114101, 62125.3}, {192218, 131678, 75721.7}, {211998, 148648, 89495.8}, {230564, 164920, 103255}, {247950, 180437, 116847}}
 237 |     };
 238 | }
 239 | 
 240 | Vec3f SSLib::SunRGB(float cosTheta, float turbidity)
 241 | {
 242 |     if (cosTheta < 0.0f)
 243 |         return vl_0;
 244 | 
 245 |     float s = cosTheta;
 246 |     float t = (turbidity - 2.0f) / 10.0f; // useful range is 2-12
 247 |     Vec3f sun = BiLerp(s, t, 16, 16, (const Vec3f*) kSunRadiance);
 248 | 
 249 |     // 683 converts from watts to candela at 540e12 hz. Really, we should be weighting by luminous efficiency curve rather than CIE_Y
 250 |     sun *=  683.0f;
 251 |     sun *= kSunSolidAngle;
 252 | 
 253 |     return sun;
 254 | }
 255 | 
 256 | 
 257 | //------------------------------------------------------------------------------
 258 | // CIE models
 259 | //------------------------------------------------------------------------------
 260 | 
 261 | float SSLib::CIEOvercastSkyLuminance(const Vec3f& v, float Lz)
 262 | {
 263 |     float cosTheta = v.z;
 264 | 
 265 |     return Lz * (1.0f + 2.0f * cosTheta) / 3.0f;
 266 | }
 267 | 
 268 | float SSLib::CIEClearSkyLuminance(const Vec3f& v, const Vec3f& toSun, float Lz)
 269 | {
 270 |     float cosThetaV = v.z;
 271 | 
 272 |     if (cosThetaV < 0.0f)
 273 |         cosThetaV = 0.0f;
 274 | 
 275 |     float cosThetaS = toSun.z;
 276 |     float thetaS    = acosf(cosThetaS);
 277 | 
 278 |     float cosGamma = dot(toSun, v);
 279 |     float gamma    = acosf(cosGamma);
 280 | 
 281 |     float top1 = 0.91f + 10 * expf(-3 * gamma ) + 0.45f * sqr(cosGamma);
 282 |     float bot1 = 0.91f + 10 * expf(-3 * thetaS) + 0.45f * sqr(cosThetaS);
 283 | 
 284 |     float top2 = 1 - expf(-0.32f / (cosThetaV + 1e-6f));
 285 |     float bot2 = 1 - expf(-0.32f);
 286 | 
 287 |     return Lz * (top1 * top2) / (bot1 * bot2);
 288 | }
 289 | 
 290 | float SSLib::CIEPartlyCloudySkyLuminance(const Vec3f& v, const Vec3f& toSun, float Lz)
 291 | {
 292 |     float cosThetaV = v.z;
 293 | 
 294 |     float cosThetaS = toSun.z;
 295 |     float thetaS    = acosf(cosThetaS);
 296 | 
 297 |     float cosGamma = dot(toSun, v);
 298 |     float gamma    = acosf(cosGamma);
 299 | 
 300 |     float top1 = 0.526f + 5 * expf(-1.5f * gamma);
 301 |     float bot1 = 0.526f + 5 * expf(-1.5f * thetaS);
 302 | 
 303 |     float top2 = 1 - expf(-0.8f / (cosThetaV + 1e-6f));
 304 |     float bot2 = 1 - expf(-0.8f);
 305 | 
 306 |     return Lz * (top1 * top2) / (bot1 * bot2);
 307 | }
 308 | 
 309 | // More modern setup, see Darula & Kittler 2002
 310 | namespace
 311 | {
 312 |     const float kCIEStandardSkyCoeffs[15][5] =
 313 |     {
 314 |         4.0, -0.70,  0, -1.0, 0,        // Overcast. When normalised this is a fit of the older (1 + 2cos(theta)) / 3 formula found in CIEOvercastSkyLuminance.
 315 |         4.0, -0.70,  2, -1.5, 0.15,     // Overcast, with steep luminance gradation and slight brightening towards the sun
 316 | 
 317 |         1.1, -0.80,  0, -1.0, 0,        // Overcast, moderately graded with azimuthal uniformity
 318 |         1.1, -0.80,  2, -1.5, 0.15,     // Overcast, moderately graded and slight brightening towards the sun
 319 | 
 320 |         0.0, -1.00,  0, -1.0, 0,        // Sky of uniform luminance
 321 |         0.0, -1.00,  2, -1.5, 0.15,     // Partly cloudy sky, no gradation towards zenith, slight brightening towards the sun
 322 |         0.0, -1.00,  5, -2.5, 0.30,     // Partly cloudy sky, no gradation towards zenith, brighter circumsolar region
 323 |         0.0, -1.00, 10, -3.0, 0.45,     // Partly cloudy sky, no gradation towards zenith, distinct solar corona
 324 | 
 325 |        -1.0, -0.55,  2, -1.5, 0.15,     // Partly cloudy, with the obscured sun
 326 |        -1.0, -0.55,  5, -2.5, 0.30,     // Partly cloudy, with brighter circumsolar region
 327 |        -1.0, -0.55, 10, -3.0, 0.45,     // White-blue sky with distinct solar corona
 328 | 
 329 |        -1.0, -0.32, 10, -3.0, 0.45,     // CIE Standard Clear Sky, low illuminance turbidity. T <= 2.45
 330 |        -1.0, -0.32, 16, -3.0, 0.30,     // CIE Standard Clear Sky, polluted atmosphere
 331 | 
 332 |        -1.0, -0.15, 16, -3.0, 0.30,     // Cloudless turbid sky with broad solar corona
 333 |        -1.0, -0.15, 24, -2.8, 0.15,     // White-blue turbid sky with broad solar corona
 334 |     };
 335 | 
 336 |     inline float CIELumRatio(const Vec3f& v, const Vec3f& toSun, float a, float b, float c, float d, float e)
 337 |     {
 338 |         float cosThetaV = v.z;
 339 | 
 340 |         float cosThetaS = toSun.z;
 341 |         float thetaS    = acosf(cosThetaS);
 342 | 
 343 |         float cosGamma = dot(toSun, v);
 344 |         float gamma    = acosf(cosGamma);
 345 | 
 346 |         float top1 = 1.0f + a * expf(b / (cosThetaV + 1e-6f));
 347 |         float bot1 = 1.0f + a * expf(b);
 348 | 
 349 |         float top2 = 1.0f + c * expf(d * gamma ) + e * sqr(cosGamma);
 350 |         float bot2 = 1.0f + c * expf(d * thetaS) + e * sqr(cosThetaS);
 351 | 
 352 |         return (top1 * top2) / (bot1 * bot2);
 353 |     }
 354 | }
 355 | 
 356 | float SSLib::CIEStandardSky(int type, const Vec3f& v, const Vec3f& toSun, float Lz)
 357 | {
 358 |     const float* c = kCIEStandardSkyCoeffs[type];
 359 |     return CIELumRatio(v, toSun, c[0], c[1], c[2], c[3], c[4]) * Lz;
 360 | }
 361 | 
 362 | float SSLib::ZenithLuminance(float thetaS, float T)
 363 | {
 364 |     float chi = (4.0f / 9.0f - T / 120.0f) * (vl_pi - 2.0f * thetaS);
 365 |     float Lz = (4.0453f * T - 4.9710f) * tanf(chi) - 0.2155f * T + 2.4192f;
 366 |     Lz *= 1000.0;   // conversion from kcd/m^2 to cd/m^2
 367 |     return Lz;
 368 | }
 369 | 
 370 | 
 371 | 
 372 | 
 373 | 
 374 | //------------------------------------------------------------------------------
 375 | // - Preetham
 376 | //------------------------------------------------------------------------------
 377 | 
 378 | namespace
 379 | {
 380 |     //
 381 |     // The Perez function is as follows:
 382 |     //
 383 |     //    P(t, g) =  (1 + A e ^ (B / cos(t))) (1 + C e ^ (D g)  + E cos(g)  ^ 2)
 384 |     //               --------------------------------------------------------
 385 |     //               (1 + A e ^ B)            (1 + C e ^ (D ts) + E cos(ts) ^ 2)
 386 |     //
 387 | 
 388 |     // A: sky
 389 |     // B: sky tightness
 390 |     // C: sun
 391 |     // D: sun tightness, higher = tighter
 392 |     // E: rosy hue around sun
 393 | 
 394 |     inline float PerezUpper(const float* lambdas, float cosTheta, float gamma, float cosGamma)
 395 |     {
 396 |         return  (1.0f + lambdas[0] * expf(lambdas[1] / (cosTheta + 1e-6f)))
 397 |               * (1.0f + lambdas[2] * expf(lambdas[3] * gamma) + lambdas[4] * sqr(cosGamma));
 398 |     }
 399 | 
 400 |     inline float PerezLower(const float* lambdas, float cosThetaS, float thetaS)
 401 |     {
 402 |         return  (1.0f + lambdas[0] * expf(lambdas[1]))
 403 |               * (1.0f + lambdas[2] * expf(lambdas[3] * thetaS) + lambdas[4] * sqr(cosThetaS));
 404 |     }
 405 | }
 406 | 
 407 | cSunSkyPreetham::cSunSkyPreetham() :
 408 |     mToSun(vl_z),
 409 | 
 410 |     // mPerez_x[5] = {}
 411 |     // mPerez_y[5] = {}
 412 |     // mPerez_Y[5] = {}
 413 |     mZenith(vl_0),
 414 |     mPerezInvDen(vl_1)
 415 | {
 416 | }
 417 | 
 418 | void cSunSkyPreetham::Update(const Vec3f& sun, float turbidity, float overcast, float horizCrush)
 419 | {
 420 |     mToSun = sun;
 421 | 
 422 |     float   T = turbidity;
 423 | 
 424 |     mPerez_Y[0] =  0.17872f * T - 1.46303f;
 425 |     mPerez_Y[1] = -0.35540f * T + 0.42749f;
 426 |     mPerez_Y[2] = -0.02266f * T + 5.32505f;
 427 |     mPerez_Y[3] =  0.12064f * T - 2.57705f;
 428 |     mPerez_Y[4] = -0.06696f * T + 0.37027f;
 429 | 
 430 |     mPerez_x[0] = -0.01925f * T - 0.25922f;
 431 |     mPerez_x[1] = -0.06651f * T + 0.00081f;
 432 |     mPerez_x[2] = -0.00041f * T + 0.21247f;
 433 |     mPerez_x[3] = -0.06409f * T - 0.89887f;
 434 |     mPerez_x[4] = -0.00325f * T + 0.04517f;
 435 | 
 436 |     mPerez_y[0] = -0.01669f * T - 0.26078f;
 437 |     mPerez_y[1] = -0.09495f * T + 0.00921f;
 438 |     mPerez_y[2] = -0.00792f * T + 0.21023f;
 439 |     mPerez_y[3] = -0.04405f * T - 1.65369f;
 440 |     mPerez_y[4] = -0.01092f * T + 0.05291f;
 441 | 
 442 |     float cosTheta = mToSun.z;
 443 |     float theta  = acosf(cosTheta);    // angle from zenith rather than horizon
 444 |     float theta2 = sqr(theta);
 445 |     float theta3 = theta2 * theta;
 446 |     float T2 = sqr(T);
 447 | 
 448 |     // mZenith stored as xyY
 449 |     mZenith.z = ZenithLuminance(theta, T);
 450 | 
 451 |     mZenith.x =
 452 |         ( 0.00165f * theta3 - 0.00374f * theta2 + 0.00208f * theta + 0.00000f) * T2 +
 453 |         (-0.02902f * theta3 + 0.06377f * theta2 - 0.03202f * theta + 0.00394f) * T  +
 454 |         ( 0.11693f * theta3 - 0.21196f * theta2 + 0.06052f * theta + 0.25885f);
 455 | 
 456 |     mZenith.y =
 457 |         ( 0.00275f * theta3 - 0.00610f * theta2 + 0.00316f * theta + 0.00000f) * T2 +
 458 |         (-0.04214f * theta3 + 0.08970f * theta2 - 0.04153f * theta + 0.00515f) * T  +
 459 |         ( 0.15346f * theta3 - 0.26756f * theta2 + 0.06669f * theta + 0.26688f);
 460 | 
 461 |     // Adjustments (extensions)
 462 | 
 463 |     if (cosTheta < 0.0f)    // Handle sun going below the horizon
 464 |     {
 465 |         float s = ClampUnit(1.0f + cosTheta * 50.0f);   // goes from 1 to 0 as the sun sets
 466 | 
 467 |         // Take C/E which control sun term to zero
 468 |         mPerez_x[2] *= s;
 469 |         mPerez_y[2] *= s;
 470 |         mPerez_Y[2] *= s;
 471 |         mPerez_x[4] *= s;
 472 |         mPerez_y[4] *= s;
 473 |         mPerez_Y[4] *= s;
 474 |     }
 475 | 
 476 |     if (overcast != 0.0f)      // Handle overcast term
 477 |     {
 478 |         float invOvercast = 1.0f - overcast;
 479 | 
 480 |         // lerp back towards unity
 481 |         mPerez_x[0] *= invOvercast;  // main sky chroma -> base
 482 |         mPerez_y[0] *= invOvercast;
 483 | 
 484 |         // sun flare -> 0 strength/base chroma
 485 |         mPerez_x[2] *= invOvercast;
 486 |         mPerez_y[2] *= invOvercast;
 487 |         mPerez_Y[2] *= invOvercast;
 488 |         mPerez_x[4] *= invOvercast;
 489 |         mPerez_y[4] *= invOvercast;
 490 |         mPerez_Y[4] *= invOvercast;
 491 | 
 492 |         // lerp towards a fit of the CIE cloudy sky model: 4, -0.7
 493 |         mPerez_Y[0] = lerp(mPerez_Y[0],  4.0f, overcast);
 494 |         mPerez_Y[1] = lerp(mPerez_Y[1], -0.7f, overcast);
 495 | 
 496 |         // lerp base colour towards white point
 497 |         mZenith.x = mZenith.x * invOvercast + 0.333f * overcast;
 498 |         mZenith.y = mZenith.y * invOvercast + 0.333f * overcast;
 499 |     }
 500 | 
 501 |     if (horizCrush != 0.0f)
 502 |     {
 503 |         // The Preetham sky model has a "muddy" horizon, which can be objectionable in
 504 |         // typical game views. We allow artistic control over it.
 505 |         mPerez_Y[1] *= horizCrush;
 506 |         mPerez_x[1] *= horizCrush;
 507 |         mPerez_y[1] *= horizCrush;
 508 |     }
 509 | 
 510 |     // initialize sun-constant parts of the Perez functions
 511 | 
 512 |     Vec3f perezLower    // denominator terms are dependent on sun angle only
 513 |     (
 514 |         PerezLower(mPerez_x, cosTheta, theta),
 515 |         PerezLower(mPerez_y, cosTheta, theta),
 516 |         PerezLower(mPerez_Y, cosTheta, theta)
 517 |     );
 518 | 
 519 |     mPerezInvDen = mZenith / perezLower;
 520 | }
 521 | 
 522 | Vec3f cSunSkyPreetham::SkyRGB(const Vec3f& v) const
 523 | {
 524 |     float cosTheta = v.z;
 525 |     float cosGamma = dot(mToSun, v);
 526 |     float gamma    = acosf(cosGamma);
 527 | 
 528 |     if (cosTheta < 0.0f)
 529 |         cosTheta = 0.0f;
 530 | 
 531 |     Vec3f xyY
 532 |     (
 533 |         PerezUpper(mPerez_x, cosTheta, gamma, cosGamma),
 534 |         PerezUpper(mPerez_y, cosTheta, gamma, cosGamma),
 535 |         PerezUpper(mPerez_Y, cosTheta, gamma, cosGamma)
 536 |     );
 537 | 
 538 |     xyY *= mPerezInvDen;
 539 | 
 540 |     return xyYToRGB(xyY);
 541 | }
 542 | 
 543 | float cSunSkyPreetham::SkyLuminance(const Vec3f& v) const
 544 | {
 545 |     float cosTheta = v.z;
 546 |     float cosGamma = dot(mToSun, v);
 547 |     float gamma    = acosf(cosGamma);
 548 | 
 549 |     if (cosTheta < 0.0f)
 550 |         cosTheta = 0.0f;
 551 | 
 552 |     return PerezUpper(mPerez_Y, cosTheta, gamma, cosGamma) * mPerezInvDen.z;
 553 | }
 554 | 
 555 | Vec2f cSunSkyPreetham::SkyChroma(const Vec3f& v) const
 556 | {
 557 |     float cosTheta = v.z;
 558 |     float cosGamma = dot(mToSun, v);
 559 |     float gamma    = acosf(cosGamma);
 560 | 
 561 |     if (cosTheta < 0.0f)
 562 |         cosTheta = 0.0f;
 563 | 
 564 |     return Vec2f
 565 |     (
 566 |         PerezUpper(mPerez_x, cosTheta, gamma, cosGamma) * mPerezInvDen.x,
 567 |         PerezUpper(mPerez_y, cosTheta, gamma, cosGamma) * mPerezInvDen.y
 568 |     );
 569 | }
 570 | 
 571 | 
 572 | //------------------------------------------------------------------------------
 573 | // cSunSkyHosek
 574 | //------------------------------------------------------------------------------
 575 | 
 576 | namespace
 577 | {
 578 |     inline float EvalQuintic(const float w[6], const float data[6])
 579 |     {
 580 |         return    w[0] * data[0]
 581 |                 + w[1] * data[1]
 582 |                 + w[2] * data[2]
 583 |                 + w[3] * data[3]
 584 |                 + w[4] * data[4]
 585 |                 + w[5] * data[5];
 586 |     }
 587 | 
 588 |     inline void EvalQuintic(const float w[6], const float data[6][9], float coeffs[9])
 589 |     {
 590 |         for (int i = 0; i < 9; i++)
 591 |         {
 592 |             coeffs[i] =   w[0] * data[0][i]
 593 |                         + w[1] * data[1][i]
 594 |                         + w[2] * data[2][i]
 595 |                         + w[3] * data[3][i]
 596 |                         + w[4] * data[4][i]
 597 |                         + w[5] * data[5][i];
 598 |         }
 599 |     }
 600 | 
 601 |     inline void FindQuinticWeights(float s, float w[6])
 602 |     {
 603 |         float s1 = s;
 604 |         float s2 = s1 * s1;
 605 |         float s3 = s1 * s2;
 606 |         float s4 = s2 * s2;
 607 |         float s5 = s2 * s3;
 608 | 
 609 |         float is1 = 1.0f - s1;
 610 |         float is2 = is1 * is1;
 611 |         float is3 = is1 * is2;
 612 |         float is4 = is2 * is2;
 613 |         float is5 = is2 * is3;
 614 | 
 615 |         w[0] = is5;
 616 |         w[1] = is4 * s1 *  5.0f;
 617 |         w[2] = is3 * s2 * 10.0f;
 618 |         w[3] = is2 * s3 * 10.0f;
 619 |         w[4] = is1 * s4 *  5.0f;
 620 |         w[5] =       s5;
 621 |     }
 622 | 
 623 | 
 624 |     float FindHosekCoeffs
 625 |     (
 626 |         const float   dataset9[2][10][6][9],    // albedo x 2, turbidity x 10, quintics x 6, weights x 9
 627 |         const float   datasetR[2][10][6],       // albedo x 2, turbidity x 10, quintics x 6
 628 |         float         turbidity,
 629 |         float         albedo,
 630 |         float         solarElevation,
 631 |         float         coeffs[9]
 632 |     )
 633 |     {
 634 |         int tbi = int(floorf(turbidity));
 635 | 
 636 |         if (tbi < 1)
 637 |             tbi = 1;
 638 |         else if (tbi > 9)
 639 |             tbi = 9;
 640 | 
 641 |         float tbf = turbidity - tbi;
 642 | 
 643 |         const float s = powf(solarElevation / vl_halfPi, (1.0f / 3.0f));
 644 | 
 645 |         float quinticWeights[6];
 646 |         FindQuinticWeights(s, quinticWeights);
 647 | 
 648 |         float ic[4][9];
 649 | 
 650 |         EvalQuintic(quinticWeights, dataset9[0][tbi - 1], ic[0]);
 651 |         EvalQuintic(quinticWeights, dataset9[1][tbi - 1], ic[1]);
 652 |         EvalQuintic(quinticWeights, dataset9[0][tbi    ], ic[2]);
 653 |         EvalQuintic(quinticWeights, dataset9[1][tbi    ], ic[3]);
 654 | 
 655 |         float ir[4] =
 656 |         {
 657 |             EvalQuintic(quinticWeights, datasetR[0][tbi - 1]),
 658 |             EvalQuintic(quinticWeights, datasetR[1][tbi - 1]),
 659 |             EvalQuintic(quinticWeights, datasetR[0][tbi    ]),
 660 |             EvalQuintic(quinticWeights, datasetR[1][tbi    ]),
 661 |         };
 662 | 
 663 |         float cw[4] =
 664 |         {
 665 |             (1.0f - albedo) * (1.0f - tbf),
 666 |             albedo          * (1.0f - tbf),
 667 |             (1.0f - albedo) * tbf,
 668 |             albedo          * tbf,
 669 |         };
 670 | 
 671 |         for (int i = 0; i < 9; i++)
 672 |             coeffs[i] = cw[0] * ic[0][i]
 673 |                       + cw[1] * ic[1][i]
 674 |                       + cw[2] * ic[2][i]
 675 |                       + cw[3] * ic[3][i];
 676 | 
 677 |         return cw[0] * ir[0] + cw[1] * ir[1] + cw[2] * ir[2] + cw[3] * ir[3];
 678 |     }
 679 | 
 680 |     // Hosek:
 681 |     // (1 + A e ^ (B / cos(t))) (1 + C e ^ (D g) + E cos(g) ^ 2   + F mieM(g, G)  + H cos(t)^1/2 + (I - 1))
 682 |     //
 683 |     // These bits are the same as Preetham, but do different jobs in some cases
 684 |     // A: sky gradient, carries white -> blue gradient
 685 |     // B: sky tightness
 686 |     // C: sun, carries most of sun-centred blue term
 687 |     // D: sun tightness, higher = tighter
 688 |     // E: rosy hue around sun
 689 |     //
 690 |     // Hosek-specific:
 691 |     // F: mie term, does most of the heavy lifting for sunset glow
 692 |     // G: mie tuning
 693 |     // H: zenith gradient
 694 |     // I: constant term balanced with H
 695 | 
 696 |     // Notes:
 697 |     // A/B still carries some of the "blue" base of sky, but much comes from C/D
 698 |     // C/E minimal effect in sunset situations, carry bulk of sun halo in sun-overhead
 699 |     // F/G sunset glow, but also takes sun halo from yellowish to white overhead
 700 | 
 701 |     float EvalHosekCoeffs(const float coeffs[9], float cosTheta, float gamma, float cosGamma)
 702 |     {
 703 |         // Current coeffs ordering is AB I CDEF HG
 704 |         //                            01 2 3456 78
 705 |         const float expM   = expf(coeffs[4] * gamma);   // D g
 706 |         const float rayM   = cosGamma * cosGamma;       // Rayleigh scattering
 707 |         const float mieM   = (1.0f + rayM) / powf((1.0f + coeffs[8] * coeffs[8] - 2.0f * coeffs[8] * cosGamma), 1.5f);  // G
 708 |         const float zenith = sqrtf(cosTheta);           // vertical zenith gradient
 709 | 
 710 |         return (1.0f
 711 |                      + coeffs[0] * expf(coeffs[1] / (cosTheta + 0.01f))     // A, B
 712 |                )
 713 |              * (1.0f
 714 |                      + coeffs[3] * expM     // C
 715 |                      + coeffs[5] * rayM     // E
 716 |                      + coeffs[6] * mieM     // F
 717 |                      + coeffs[7] * zenith   // H
 718 |                      + (coeffs[2] - 1.0f)   // I
 719 |                );
 720 |     }
 721 | }
 722 | 
 723 | 
 724 | cSunSkyHosek::cSunSkyHosek() :
 725 |     mToSun(vl_z)
 726 | {
 727 | }
 728 | 
 729 | void cSunSkyHosek::Update(const Vec3f& sun, float turbidity, Vec3f rgbAlbedo, float overcast)
 730 | {
 731 |     mToSun = sun;
 732 | 
 733 |     float solarElevation = mToSun.z > 0.0f ? asinf(mToSun.z) : 0.0f;    // altitude rather than zenith, so sin rather than cos
 734 | 
 735 |     Vec3f albedo = RGBToXYZ(rgbAlbedo);
 736 | 
 737 |     // Note that the hosek coefficients change with time of day, vs. Preetham where the 'upper' coefficients stay the same,
 738 |     // and only the scaler mPerezInvDen, consisting of time-dependent normalisation and zenith luminnce factors, changes.
 739 |     mRadXYZ[0] = FindHosekCoeffs(kHosekCoeffsX, kHosekRadX, turbidity, albedo.x, solarElevation, mCoeffsXYZ[0]);
 740 |     mRadXYZ[1] = FindHosekCoeffs(kHosekCoeffsY, kHosekRadY, turbidity, albedo.y, solarElevation, mCoeffsXYZ[1]);
 741 |     mRadXYZ[2] = FindHosekCoeffs(kHosekCoeffsZ, kHosekRadZ, turbidity, albedo.z, solarElevation, mCoeffsXYZ[2]);
 742 | 
 743 |     mRadXYZ *= 683; // convert to luminance in lumens
 744 | 
 745 |     if (mToSun.z < 0.0f)   // sun below horizon?
 746 |     {
 747 |         float s = ClampUnit(1.0f + mToSun.z * 50.0f);   // goes from 1 to 0 as the sun sets
 748 |         float is = 1.0f - s;
 749 | 
 750 |         // Emulate Preetham's zenith darkening
 751 |         float darken = ZenithLuminance(acosf(mToSun.z), turbidity) / ZenithLuminance(vl_halfPi, turbidity);
 752 | 
 753 |         // Take C/E/F which control sun term to zero
 754 |         for (int j = 0; j < 3; j++)
 755 |         {
 756 |             mCoeffsXYZ[j][3] *= s;
 757 |             mCoeffsXYZ[j][5] *= s;
 758 |             mCoeffsXYZ[j][6] *= s;
 759 | 
 760 |             // Take horizon term H to zero, as it's an orange glow at this point
 761 |             mCoeffsXYZ[j][7] *= s;
 762 | 
 763 |             // Take I term back to 1
 764 |             mCoeffsXYZ[j][2] *= s;
 765 |             mCoeffsXYZ[j][2] += is;
 766 |         }
 767 | 
 768 |         mRadXYZ *= darken;
 769 |     }
 770 | 
 771 |     if (overcast != 0.0f)      // Handle overcast term
 772 |     {
 773 |         float is = overcast;
 774 |         float s = 1.0f - overcast;     // goes to 0 as we go to overcast
 775 | 
 776 |         // Hosek isn't self-normalising, unlike Preetham/CIE, which divides by PreethamLower().
 777 |         // Thus when we lerp to the CIE overcast model, we get some non-linearities.
 778 |         // We deal with this by using ratios of normalisation terms to balance.
 779 |         // Another difference is that Hosek is relative to the average radiance,
 780 |         // whereas CIE is the zenith radiance, so rather than taking the zenith
 781 |         // as normalising as in CIE, we average over the zenith and two horizon
 782 |         // points.
 783 |         float cosGammaZ = mToSun.z;
 784 |         float gammaZ    = acosf(cosGammaZ);
 785 |         float cosGammaH = mToSun.y;
 786 |         float gammaHP   = acosf(+mToSun.y);
 787 |         float gammaHN   = vl_pi - gammaHP;
 788 | 
 789 |         float sc0 = EvalHosekCoeffs(mCoeffsXYZ[1], 1.0f, gammaZ, cosGammaZ) * 2.0f
 790 |                   + EvalHosekCoeffs(mCoeffsXYZ[1], 0.0f, gammaHP, +cosGammaH)
 791 |                   + EvalHosekCoeffs(mCoeffsXYZ[1], 0.0f, gammaHN, -cosGammaH);
 792 | 
 793 |         for (int j = 0; j < 3; j++)
 794 |         {
 795 |             // sun flare -> 0 strength/base chroma
 796 |             // Take C/E/F which control sun term to zero
 797 |             mCoeffsXYZ[j][3] *= s;
 798 |             mCoeffsXYZ[j][5] *= s;
 799 |             mCoeffsXYZ[j][6] *= s;
 800 | 
 801 |             // Take H back to 0
 802 |             mCoeffsXYZ[j][7] *= s;
 803 | 
 804 |             // Take I term back to 1
 805 |             mCoeffsXYZ[j][2] *= s;
 806 |             mCoeffsXYZ[j][2] += is;
 807 | 
 808 |             // Take A/B to  CIE cloudy sky model: 4, -0.7
 809 |             mCoeffsXYZ[j][0] = lerp(mCoeffsXYZ[j][0],  4.0f, is);
 810 |             mCoeffsXYZ[j][1] = lerp(mCoeffsXYZ[j][1], -0.7f, is);
 811 |         }
 812 | 
 813 |         float sc1 = EvalHosekCoeffs(mCoeffsXYZ[1], 1.0f, gammaZ, cosGammaZ) * 2.0f
 814 |                   + EvalHosekCoeffs(mCoeffsXYZ[1], 0.0f, gammaHP, +cosGammaH)
 815 |                   + EvalHosekCoeffs(mCoeffsXYZ[1], 0.0f, gammaHN, -cosGammaH);
 816 | 
 817 |         float rescale = sc0 / sc1;
 818 |         mRadXYZ *= rescale;
 819 | 
 820 |         // move back to white point
 821 |         mRadXYZ.x = lerp(mRadXYZ.x, mRadXYZ.y, is);
 822 |         mRadXYZ.z = lerp(mRadXYZ.z, mRadXYZ.y, is);
 823 |     }
 824 | 
 825 | #ifdef LOCAL_DEBUG
 826 |     for (int j = 0; j < 3; j++)
 827 |     {
 828 |         printf("%c: Rad = %8.2f, C[9] = ", 'X' + j, mRadXYZ[j]);
 829 |         for (int i = 0; i < 9; i++)
 830 |             printf("%5.2f ", mCoeffsXYZ[j][i]);
 831 |         printf("\n");
 832 |     }
 833 | #endif
 834 | }
 835 | 
 836 | float cSunSkyHosek::SkyLuminance(const Vec3f& v) const
 837 | {
 838 |     float cosTheta = v.z;
 839 |     float cosGamma = dot(mToSun, v);
 840 |     float gamma    = acosf(cosGamma);
 841 | 
 842 |     if (cosTheta < 0.0f)
 843 |         cosTheta = 0.0f;
 844 | 
 845 |     return EvalHosekCoeffs(mCoeffsXYZ[1], cosTheta, gamma, cosGamma) * mRadXYZ.y;
 846 | }
 847 | 
 848 | Vec3f cSunSkyHosek::SkyXYZ(const Vec3f& v) const
 849 | {
 850 |     float cosTheta = v.z;
 851 |     float cosGamma = dot(mToSun, v);
 852 |     float gamma    = acosf(cosGamma);
 853 | 
 854 |     if (cosTheta < 0.0f)
 855 |         cosTheta = 0.0f;
 856 | 
 857 |     Vec3f XYZ =
 858 |     {
 859 |         EvalHosekCoeffs(mCoeffsXYZ[0], cosTheta, gamma, cosGamma),
 860 |         EvalHosekCoeffs(mCoeffsXYZ[1], cosTheta, gamma, cosGamma),
 861 |         EvalHosekCoeffs(mCoeffsXYZ[2], cosTheta, gamma, cosGamma)
 862 |     };
 863 | 
 864 |     XYZ *= mRadXYZ;
 865 | 
 866 |     return XYZ;
 867 | }
 868 | 
 869 | Vec3f cSunSkyHosek::SkyRGB(const Vec3f& v) const
 870 | {
 871 |     return XYZToRGB(SkyXYZ(v));
 872 | }
 873 | 
 874 | 
 875 | //------------------------------------------------------------------------------
 876 | // cSunSkyTable
 877 | //------------------------------------------------------------------------------
 878 | 
 879 | // Pre-calculated table version, particularly useful for shader use
 880 | 
 881 | namespace
 882 | {
 883 |     // remap cosGamma to concentrate table around the sun location
 884 |     inline float MapGamma(float g)
 885 |     {
 886 |         return sqrtf(0.5f * (1.0f - g));
 887 |     }
 888 |     inline float UnmapGamma(float g)
 889 |     {
 890 |         return 1 - 2 * sqr(g);
 891 |     }
 892 | }
 893 | 
 894 | void cSunSkyTable::FindThetaGammaTables(const cSunSkyPreetham& pt)
 895 | {
 896 |     float dt = 1.0f / (kTableSize - 1);
 897 |     float t = dt * 1e-6f;    // epsilon to avoid divide by 0, which can lead to NaN when m_perez_[1] = 0
 898 | 
 899 |     for (int i = 0; i < kTableSize; i++)
 900 |     {
 901 |         float cosTheta = t;
 902 | 
 903 |         mThetaTable[i][0] =  -pt.mPerez_x[0] * expf(pt.mPerez_x[1] / cosTheta);
 904 |         mThetaTable[i][1] =  -pt.mPerez_y[0] * expf(pt.mPerez_y[1] / cosTheta);
 905 |         mThetaTable[i][2] =  -pt.mPerez_Y[0] * expf(pt.mPerez_Y[1] / cosTheta);
 906 | 
 907 |         mMaxTheta = mMaxTheta >= mThetaTable[i][2] ? mMaxTheta : mThetaTable[i][2];
 908 | 
 909 |         float cosGamma = UnmapGamma(t);
 910 |         float gamma = acosf(cosGamma);
 911 | 
 912 |         mGammaTable[i][0] =  pt.mPerez_x[2] * expf(pt.mPerez_x[3] * gamma) + pt.mPerez_x[4] * sqr(cosGamma);
 913 |         mGammaTable[i][1] =  pt.mPerez_y[2] * expf(pt.mPerez_y[3] * gamma) + pt.mPerez_y[4] * sqr(cosGamma);
 914 |         mGammaTable[i][2] =  pt.mPerez_Y[2] * expf(pt.mPerez_Y[3] * gamma) + pt.mPerez_Y[4] * sqr(cosGamma);
 915 | 
 916 |         mMaxGamma = mMaxGamma >= mGammaTable[i][2] ? mMaxGamma : mGammaTable[i][2];
 917 | 
 918 |         t += dt;
 919 |     }
 920 | 
 921 |     mXYZ = false;
 922 | 
 923 | #ifdef SUPPORT_OVERCAST_CLAMP
 924 |     mMaxTheta = -pt.mPerez_Y[0] * expf(pt.mPerez_Y[1]);
 925 | #endif
 926 | 
 927 | #ifdef SIM_CLAMP
 928 |     for (int i = 0; i < kTableSize; i++)
 929 |     {
 930 |         mThetaTable[i].z /= mMaxTheta;
 931 |         mGammaTable[i].z /= mMaxGamma;
 932 |         mThetaTable[i] = ClampUnit(mThetaTable[i]);
 933 |         mGammaTable[i] = ClampUnit(mGammaTable[i]);
 934 |     }
 935 | #endif
 936 | 
 937 | #ifdef LOCAL_DEBUG
 938 |     printf("PTx: ");
 939 |     for (int i = 0; i < kTableSize; i+= 4)
 940 |         printf("%5.2f ", mThetaTable[i].x);
 941 |     printf("\n");
 942 |     printf("PTy: ");
 943 |     for (int i = 0; i < kTableSize; i+= 4)
 944 |         printf("%5.2f ", mThetaTable[i].y);
 945 |     printf("\n");
 946 |     printf("PTY: ");
 947 |     for (int i = 0; i < kTableSize; i+= 4)
 948 |         printf("%5.2f ", mThetaTable[i].z);
 949 |     printf("\n");
 950 | 
 951 |     printf("PGx: ");
 952 |     for (int i = 0; i < kTableSize; i+= 4)
 953 |         printf("%5.2f ", mGammaTable[i].x);
 954 |     printf("\n");
 955 |     printf("PGy: ");
 956 |     for (int i = 0; i < kTableSize; i+= 4)
 957 |         printf("%5.2f ", mGammaTable[i].y);
 958 |     printf("\n");
 959 |     printf("PGY: ");
 960 |     for (int i = 0; i < kTableSize; i+= 4)
 961 |         printf("%5.2f ", mGammaTable[i].z);
 962 |     printf("\n");
 963 | #endif
 964 | }
 965 | 
 966 | void cSunSkyTable::FindThetaGammaTables(const cSunSkyHosek& hk)
 967 | {
 968 |     float dt = 1.0f / (kTableSize - 1);
 969 |     float t = 0.0f;
 970 | 
 971 |     const float (&coeffsXYZ)[3][9] = hk.mCoeffsXYZ;
 972 | 
 973 |     mMaxGamma = 1.0f;
 974 | 
 975 |     for (int i = 0; i < kTableSize; i++)
 976 |     {
 977 |         float cosTheta = t;
 978 |         float cosGamma = UnmapGamma(t);
 979 |         float gamma = acosf(cosGamma);
 980 | 
 981 |         float rayM = cosGamma * cosGamma;
 982 | 
 983 |         for (int j = 0; j < 3; j++)
 984 |         {
 985 |             const float (&coeffs)[9] = coeffsXYZ[j];
 986 | 
 987 |             mThetaTable[i][j] = -coeffs[0] * expf(coeffs[1] / (cosTheta + 0.01f));
 988 | 
 989 |             float expM   = expf(coeffs[4] * gamma);
 990 |             float mieM   = (1.0f + rayM) / powf((1.0f + coeffs[8] * coeffs[8] - 2.0f * coeffs[8] * cosGamma), 1.5f);
 991 | 
 992 |             mGammaTable[i][j] = coeffs[3] * expM + coeffs[5] * rayM + coeffs[6] * mieM;
 993 | 
 994 |             mMaxGamma = mMaxGamma >= mGammaTable[i][j] ? mMaxGamma : mGammaTable[i][j];
 995 |         }
 996 | 
 997 |         t += dt;
 998 |     }
 999 | 
1000 |     mXYZ = true;
1001 | 
1002 | #ifdef SUPPORT_OVERCAST_CLAMP
1003 |     mMaxTheta = -coeffsXYZ[1][0] * expf(coeffsXYZ[1][1]);
1004 | #endif
1005 | 
1006 | #ifdef SIM_CLAMP
1007 |     for (int i = 0; i < kTableSize; i++)
1008 |     {
1009 |         mThetaTable[i] = ClampUnit(mThetaTable[i] / mMaxTheta);
1010 |         mGammaTable[i] = ClampUnit(mGammaTable[i] / mMaxGamma);
1011 |     }
1012 | #endif
1013 | 
1014 | #ifdef LOCAL_DEBUG
1015 |     printf("HTY: ");
1016 |     for (int i = 0; i < kTableSize; i+= 4)
1017 |         printf("%5.2f ", mThetaTable[i].x);
1018 |     printf("\n");
1019 |     printf("HTY: ");
1020 |     for (int i = 0; i < kTableSize; i+= 4)
1021 |         printf("%5.2f ", mThetaTable[i].y);
1022 |     printf("\n");
1023 |     printf("HTY: ");
1024 |     for (int i = 0; i < kTableSize; i+= 4)
1025 |         printf("%5.2f ", mThetaTable[i].z);
1026 |     printf("\n");
1027 | 
1028 |     printf("HGX: ");
1029 |     for (int i = 0; i < kTableSize; i+= 4)
1030 |         printf("%5.2f ", mGammaTable[i].x);
1031 |     printf("\n");
1032 |     printf("HGY: ");
1033 |     for (int i = 0; i < kTableSize; i+= 4)
1034 |         printf("%5.2f ", mGammaTable[i].y);
1035 |     printf("\n");
1036 |     printf("HGZ: ");
1037 |     for (int i = 0; i < kTableSize; i+= 4)
1038 |         printf("%5.2f ", mGammaTable[i].z);
1039 |     printf("\n");
1040 | #endif
1041 | }
1042 | 
1043 | Vec3f cSunSkyTable::SkyRGB(const cSunSkyPreetham& pt, const Vec3f& v) const
1044 | {
1045 |     float cosTheta = v.z;
1046 |     float cosGamma = dot(pt.mToSun, v);
1047 | 
1048 |     if (cosTheta < 0.0f)
1049 |         cosTheta = 0.0f;
1050 | 
1051 |     float t = cosTheta;
1052 |     float g = MapGamma(cosGamma);
1053 | 
1054 |     Vec3f F = Lerp(t, kTableSize, mThetaTable);
1055 |     Vec3f G = Lerp(g, kTableSize, mGammaTable);
1056 | 
1057 | #ifdef SIM_CLAMP
1058 |     F.z *= mMaxTheta;
1059 |     G.z *= mMaxGamma;
1060 | #endif
1061 | 
1062 |     Vec3f xyY = (Vec3f(vl_1) - F) * (Vec3f(vl_1) + G);
1063 | 
1064 |     xyY *= pt.mPerezInvDen;
1065 | 
1066 |     return xyYToRGB(xyY);
1067 | }
1068 | 
1069 | Vec3f cSunSkyTable::SkyRGB(const cSunSkyHosek& hk, const Vec3f& v) const
1070 | {
1071 |     float cosTheta = v.z;
1072 |     float cosGamma = dot(hk.mToSun, v);
1073 | 
1074 |     if (cosTheta < 0.0f)
1075 |         cosTheta = 0.0f;
1076 | 
1077 |     float t = cosTheta;
1078 |     float g = MapGamma(cosGamma);
1079 | 
1080 |     Vec3f F = Lerp(t, kTableSize, mThetaTable);
1081 |     Vec3f G = Lerp(g, kTableSize, mGammaTable);
1082 | 
1083 |     const float zenith = sqrtf(cosTheta);
1084 |     Vec3f H
1085 |     (
1086 |         hk.mCoeffsXYZ[0][7] * zenith + (hk.mCoeffsXYZ[0][2] - 1.0f),
1087 |         hk.mCoeffsXYZ[1][7] * zenith + (hk.mCoeffsXYZ[1][2] - 1.0f),
1088 |         hk.mCoeffsXYZ[2][7] * zenith + (hk.mCoeffsXYZ[2][2] - 1.0f)
1089 |     );
1090 | 
1091 | #ifdef SIM_CLAMP
1092 |     F *= mMaxTheta;
1093 |     G *= mMaxGamma;
1094 | #endif
1095 | 
1096 |     // (1 - F(theta)) * (1 + G(phi) + H(theta))
1097 |     Vec3f XYZ = (Vec3f(vl_1) - F) * (Vec3f(vl_1) + G + H);
1098 | 
1099 |     XYZ *= hk.mRadXYZ;
1100 | 
1101 |     return XYZToRGB(XYZ);
1102 | }
1103 | 
1104 | namespace
1105 | {
1106 |     inline uint8_t ToU8(float f)
1107 |     {
1108 |         if (f <= 0.0f)
1109 |             return 0;
1110 |         if (f >= 1.0f)
1111 |             return 255;
1112 | 
1113 |         return uint8_t(f * 255.0f + 0.5f);
1114 |     }
1115 | }
1116 | 
1117 | void cSunSkyTable::FillTexture(int width, int height, uint8_t image[][4]) const
1118 | {
1119 |     CL_ASSERT(width == kTableSize);
1120 |     CL_ASSERT(height == 2);
1121 | 
1122 |     (void) width;
1123 |     (void) height;
1124 | 
1125 |     for (int i = 0; i < width; i++)
1126 |     {
1127 |         Vec3f c = mThetaTable[i];
1128 | 
1129 |         if (mXYZ)
1130 |             c /= mMaxTheta;
1131 |         else
1132 |             c.z /= mMaxTheta;
1133 | 
1134 |         image[i][2] = ToU8(c.x);
1135 |         image[i][1] = ToU8(c.y);
1136 |         image[i][0] = ToU8(c.z);
1137 |         image[i][3] = 255;
1138 |     }
1139 | 
1140 |     image += width;
1141 | 
1142 |     for (int i = 0; i < width; i++)
1143 |     {
1144 |         Vec3f c = mGammaTable[i];
1145 | 
1146 |         if (mXYZ)
1147 |             c /= mMaxGamma;
1148 |         else
1149 |             c.z /= mMaxGamma;
1150 | 
1151 |         image[i][2] = ToU8(c.x);
1152 |         image[i][1] = ToU8(c.y);
1153 |         image[i][0] = ToU8(c.z);
1154 |         image[i][3] = 255;
1155 |     }
1156 | }
1157 | 
1158 | void cSunSkyTable::FillTexture(int width, int height, float image[][4]) const
1159 | {
1160 |     CL_ASSERT(width == kTableSize);
1161 |     CL_ASSERT(height == 2);
1162 | 
1163 |     (void) width;
1164 |     (void) height;
1165 | 
1166 |     for (int i = 0; i < width; i++)
1167 |         *(Vec4f*) image[i] = Vec4f(mThetaTable[i], 1.0f);
1168 | 
1169 |     image += width;
1170 | 
1171 |     for (int i = 0; i < width; i++)
1172 |         *(Vec4f*) image[i] = Vec4f(mGammaTable[i], 1.0f);
1173 | }
1174 | 
1175 | //------------------------------------------------------------------------------
1176 | // cSunSkyBRDF
1177 | //------------------------------------------------------------------------------
1178 | 
1179 | // Extended version that enables lerping between perfect mirror and fully
1180 | // diffuse.
1181 | 
1182 | namespace
1183 | {
1184 |     // ZH routines from SHLib
1185 |     const float kZH_Y_0 = sqrtf( 1 / (   4 * vl_pi));  //         1
1186 |     const float kZH_Y_1 = sqrtf( 3 / (   4 * vl_pi));  //         z
1187 |     const float kZH_Y_2 = sqrtf( 5 / (  16 * vl_pi));  // 1/2     (3 z^2 - 1)
1188 |     const float kZH_Y_3 = sqrtf( 7 / (  16 * vl_pi));  // 1/2     (5 z^3 - 3 z)
1189 |     const float kZH_Y_4 = sqrtf( 9 / ( 256 * vl_pi));  // 1/8     (35 z^4 - 30 z^2 + 3)
1190 |     const float kZH_Y_5 = sqrtf(11 / ( 256 * vl_pi));  // 1/8     (63 z^5 - 70 z^3 + 15 z)
1191 |     const float kZH_Y_6 = sqrtf(13 / (1024 * vl_pi));  // 1/16    (231 z^6 - 315 z^4 + 105 z^2 - 5)
1192 | 
1193 |     void CalcCosPowerSatZH7(float n, float zcoeffs[7])
1194 |     {
1195 |         zcoeffs[0] =   1.0f / (n + 1);
1196 |         zcoeffs[1] =   1.0f / (n + 2);
1197 |         zcoeffs[2] =   3.0f / (n + 3) -   1.0f / (n + 1);
1198 |         zcoeffs[3] =   5.0f / (n + 4) -   3.0f / (n + 2);
1199 |         zcoeffs[4] =  35.0f / (n + 5) -  30.0f / (n + 3) +   3.0f / (n + 1);
1200 |         zcoeffs[5] =  63.0f / (n + 6) -  70.0f / (n + 4) +  15.0f / (n + 2);
1201 |         zcoeffs[6] = 231.0f / (n + 7) - 315.0f / (n + 5) + 105.0f / (n + 3) - 5.0f / (n + 1);
1202 | 
1203 |         // apply norm constants
1204 |         zcoeffs[0] *= vl_twoPi * kZH_Y_0;
1205 |         zcoeffs[1] *= vl_twoPi * kZH_Y_1;
1206 |         zcoeffs[2] *= vl_twoPi * kZH_Y_2;
1207 |         zcoeffs[3] *= vl_twoPi * kZH_Y_3;
1208 |         zcoeffs[4] *= vl_twoPi * kZH_Y_4;
1209 |         zcoeffs[5] *= vl_twoPi * kZH_Y_5;
1210 |         zcoeffs[6] *= vl_twoPi * kZH_Y_6;
1211 | 
1212 |         // [0]: 2pi sqrtf( 1 / (   4 * vl_pi)) / 1
1213 |         // we'll multiply by alpha = sqrtf(4.0f * vl_pi / (2 * i + 1)) in convolution, leaving 2pi.
1214 |     }
1215 | 
1216 |     template<class T> void ConvolveZH7WithZH7Norm(const float brdfCoeffs[7], const T zhCoeffsIn[7], T zhCoeffsOut[7])
1217 |     {
1218 |         zhCoeffsOut[0] = zhCoeffsIn[0];
1219 | 
1220 |         for (int i = 1; i < 7; i++)
1221 |         {
1222 |             float invAlpha = sqrtf(2.0f * i + 1);
1223 | 
1224 |             zhCoeffsOut[i] = zhCoeffsIn[i] * (brdfCoeffs[i] / (invAlpha * brdfCoeffs[0]));
1225 |         }
1226 |     }
1227 | 
1228 |     template<class T> void AddZH7Sample(float z, T c, T zhCoeffs[7])
1229 |     {
1230 |         float z2 = z * z;
1231 |         float z3 = z2 * z;
1232 |         float z4 = z2 * z2;
1233 |         float z5 = z2 * z3;
1234 |         float z6 = z3 * z3;
1235 | 
1236 |         zhCoeffs[0] += c * kZH_Y_0;
1237 |         zhCoeffs[1] += c * kZH_Y_1 * z;
1238 |         zhCoeffs[2] += c * kZH_Y_2 * (3 * z2 - 1);
1239 |         zhCoeffs[3] += c * kZH_Y_3 * (5 * z3 - 3 * z);
1240 |         zhCoeffs[4] += c * kZH_Y_4 * (35 * z4 - 30 * z2 + 3);
1241 |         zhCoeffs[5] += c * kZH_Y_5 * (63 * z5 - 70 * z3 + 15 * z);
1242 |         zhCoeffs[6] += c * kZH_Y_6 * (231 * z6 - 315 * z4 + 105 * z2 - 5);
1243 |     }
1244 | 
1245 |     template<class T> T EvalZH7(float z, const T zhCoeffs[7])
1246 |     {
1247 |         float z2 = z * z;
1248 |         float z3 = z2 * z;
1249 |         float z4 = z2 * z2;
1250 |         float z5 = z2 * z3;
1251 |         float z6 = z3 * z3;
1252 | 
1253 |         T c;
1254 | 
1255 |         c  = zhCoeffs[0] * kZH_Y_0;
1256 |         c += zhCoeffs[1] * kZH_Y_1 * z;
1257 |         c += zhCoeffs[2] * kZH_Y_2 * (3 * z * z - 1);
1258 |         c += zhCoeffs[3] * kZH_Y_3 * (5 * z3 - 3 * z);
1259 |         c += zhCoeffs[4] * kZH_Y_4 * (35 * z4 - 30 * z2 + 3);
1260 |         c += zhCoeffs[5] * kZH_Y_5 * (63 * z5 - 70 * z3 + 15 * z);
1261 |         c += zhCoeffs[6] * kZH_Y_6 * (231 * z6 - 315 * z4 + 105 * z2 - 5);
1262 | 
1263 |         return c;
1264 |     }
1265 | 
1266 |     // Windowing a la Peter-Pike Sloan
1267 |     inline float WindowScale(int n, float gamma)
1268 |     {
1269 |         float nt = float(n * (n + 1));
1270 |         return 1.0f / (1.0f + gamma * nt * nt);
1271 |     }
1272 | 
1273 |     template<class T> void ApplyZH7Windowing(float gamma, T coeffs[7])
1274 |     {
1275 |         for (int i = 0; i < 7; i++)
1276 |             coeffs[i] *= WindowScale(i, gamma);
1277 |     }
1278 |     // End
1279 | 
1280 |     inline Vec3f Bias_xyY(Vec3f c)  // effectively make delta lum proportional to real lum, and scale xy by lum
1281 |     {
1282 |         c.z += 1.0f;
1283 |         c.x *= c.z;
1284 |         c.y *= c.z;
1285 |         return c;
1286 |     }
1287 | 
1288 |     inline Vec3f Unbias_xyY(Vec3f c)  // Return to delta xyY form
1289 |     {
1290 |         float y = c.z;
1291 |         if (y < 1e-2f)
1292 |             y = 1e-2f;
1293 | 
1294 |         c.x /= y;
1295 |         c.y /= y;
1296 |         c.z -= 1.0f;
1297 |         return c;
1298 |     }
1299 | 
1300 |     template<class T> void FindZH7FromThetaTable(int tableSize, const T table[], T zhCoeffs[7])
1301 |     {
1302 |         float dt = 1.0f / (tableSize - 1);
1303 |         float t = 0.0f;
1304 | 
1305 |         float w = vl_twoPi * 2 * dt; // 2pi dz = 2pi 2 dt
1306 | 
1307 |         for (int i = 0; i < 7; i++)
1308 |             zhCoeffs[i] = vl_0;
1309 | 
1310 |         for (int i = 0; i < tableSize; i++)
1311 |         {
1312 |             AddZH7Sample(2 * t - 1, table[i] * w, zhCoeffs);
1313 |             t += dt;
1314 |         }
1315 |     }
1316 | 
1317 |     template<class T> void GenerateThetaTableFromZH7(const T zhCoeffs[7], int tableSize, T table[])
1318 |     {
1319 |         float dt = 1.0f / (tableSize - 1);
1320 |         float t = 0.0f;
1321 | 
1322 |         for (int i = 0; i < tableSize; i++)
1323 |         {
1324 |             table[i] = EvalZH7(2 * t - 1, zhCoeffs);
1325 |             t += dt;
1326 |         }
1327 |     }
1328 | 
1329 |     template<class T> void FindZH7FromGammaTable(int tableSize, const T table[], T zhCoeffs[7])
1330 |     {
1331 |         float dg = 1.0f / (tableSize - 1);
1332 |         float g = 0.0f;
1333 | 
1334 |         float w = vl_twoPi * 4 * dg; // 2pi dz = 2pi -4 g dg
1335 | 
1336 |         for (int i = 0; i < 7; i++)
1337 |             zhCoeffs[i] = vl_0;
1338 | 
1339 |         for (int i = 0; i < tableSize; i++)
1340 |         {
1341 |             AddZH7Sample(UnmapGamma(g), table[i] * w * g, zhCoeffs);
1342 |             g += dg;
1343 |         }
1344 |     }
1345 | 
1346 |     template<class T> void GenerateGammaTableFromZH7(T zhCoeffs[7], int tableSize, T table[])
1347 |     {
1348 |         float dg = 1.0f / (tableSize - 1);
1349 |         float g = 0.0f;
1350 | 
1351 |         for (int i = 0; i < tableSize; i++)
1352 |         {
1353 |             table[i] = EvalZH7(UnmapGamma(g), zhCoeffs);
1354 |             g += dg;
1355 |         }
1356 |     }
1357 | 
1358 |     const float kThetaW = 0.01f;    // windowing gamma to use for theta table
1359 |     const float kGammaW = 0.002f;   // windowing gamma to use for gamma table
1360 | 
1361 |     const float kThetaWHosek = 0.05f;   // windowing gamma to use for Hosek theta table
1362 |     const float kGammaWHosek = 0.005f;  // windowing gamma to use for gamma table
1363 | 
1364 | #ifdef COMPACT_BRDF_TABLE
1365 |     const float kRowPowers[cSunSkyBRDF::kBRDFSamples - 1] = { 1.0f, 8.0f, 256.0f };
1366 | #else
1367 |     const float kRowPowers[cSunSkyBRDF::kBRDFSamples - 1] = { 1.0f, 2.0f, 4.0f, 8.0f, 16.0f, 32.0f, 96.0f };
1368 | #endif
1369 | }
1370 | 
1371 | void cSunSkyBRDF::FindBRDFTables(const cSunSkyTable& table, const cSunSkyPreetham&)
1372 | {
1373 |     // The BRDF tables cover the entire sphere, so we must resample theta from the Perez/Hosek tables which cover a hemisphere.
1374 |     Vec3f thetaTable[cSunSkyTable::kTableSize];
1375 |     const Vec3f* gammaTable = table.mGammaTable;
1376 | 
1377 |     // Fill top hemisphere of table
1378 |     for (int i = 0; i < kTableSize / 2; i++)
1379 |         thetaTable[kTableSize / 2 + i] = table.mThetaTable[2 * i];
1380 | 
1381 |     // Fill lower hemisphere with term that evaluates close to 0, to avoid below-ground luminance leaking in.
1382 |     // TODO: modify this using ground albedo
1383 |     Vec3f lowerHemi = Vec3f(0.0f, 0.0f, 0.999f);  // 0.999 as theta table is used as (1 - F)
1384 | 
1385 |     for (int i = 0; i < kTableSize / 2; i++)
1386 |         thetaTable[i] = lowerHemi;
1387 | 
1388 |     // Project tables into ZH coefficients
1389 |     Vec3f zhCoeffsTheta[7];
1390 |     Vec3f zhCoeffsGamma[7];
1391 | 
1392 |     // theta table works better if we operate on something proportional to real luminance
1393 |     Vec3f biasedThetaTable[kTableSize];
1394 |     for (int i = 0; i < kTableSize; i++)
1395 |         biasedThetaTable[i] = Bias_xyY(thetaTable[i]);
1396 | 
1397 |     FindZH7FromThetaTable(kTableSize, biasedThetaTable, zhCoeffsTheta);
1398 |     FindZH7FromGammaTable(kTableSize,       gammaTable, zhCoeffsGamma);
1399 | 
1400 |     // row 0 is the original unconvolved signal
1401 | 
1402 |     // Firstly, fill -ve z with reflected +ve z, ramped to 0 at z = -1. This avoids discontinuities at the horizon.
1403 |     for (int i = 0; i < kTableSize / 2; i++)
1404 |     {
1405 |         thetaTable[i] = table.mThetaTable[kTableSize - 1 - 2 * i];
1406 | 
1407 |         // Ramp luminance down
1408 |         float s = (i + 0.5f) / (kTableSize / 2);
1409 |         s = sqrtf(s);
1410 | 
1411 |         thetaTable[i].z = thetaTable[i].z * s + (1 - s);
1412 |     }
1413 | 
1414 |     for (int i = 0; i < kTableSize; i++)
1415 |     {
1416 |         mBRDFThetaTable[0][i] = thetaTable[i];
1417 |         mBRDFGammaTable[0][i] = gammaTable[i];
1418 |     }
1419 | 
1420 |     // rows 1..n-1 are successive convolutions
1421 |     Vec3f zhCoeffsThetaConv[7];
1422 |     Vec3f zhCoeffsGammaConv[7];
1423 | 
1424 |     for (int r = 1; r < kBRDFSamples; r++)
1425 |     {
1426 |         int rs = kBRDFSamples - r - 1;
1427 |         float s = kRowPowers[rs];
1428 | 
1429 |         float csCoeffs[7];
1430 |         CalcCosPowerSatZH7(s, csCoeffs);
1431 | 
1432 |         ConvolveZH7WithZH7Norm(csCoeffs, zhCoeffsTheta, zhCoeffsThetaConv);
1433 |         ConvolveZH7WithZH7Norm(csCoeffs, zhCoeffsGamma, zhCoeffsGammaConv);
1434 | 
1435 |         // Scale up to full windowing at full spec power...
1436 |         float rw = sqrtf(rs / float(kBRDFSamples - 2));
1437 | 
1438 |         ApplyZH7Windowing(kThetaW * rw, zhCoeffsThetaConv);
1439 |         ApplyZH7Windowing(kGammaW * rw, zhCoeffsGammaConv);
1440 | 
1441 |         GenerateThetaTableFromZH7(zhCoeffsThetaConv, kTableSize, mBRDFThetaTable[r]);
1442 |         GenerateGammaTableFromZH7(zhCoeffsGammaConv, kTableSize, mBRDFGammaTable[r]);
1443 | 
1444 |         for (int i = 0; i < kTableSize; i++)
1445 |             mBRDFThetaTable[r][i] = Unbias_xyY(mBRDFThetaTable[r][i]);
1446 |     }
1447 | 
1448 |     mMaxTheta = table.mMaxTheta;
1449 |     mMaxGamma = table.mMaxGamma;
1450 |     mXYZ = false;
1451 |     mHasHTerm = false;
1452 | 
1453 | #ifdef SIM_CLAMP
1454 |     for (int r = 1; r < kBRDFSamples; r++)
1455 |         for (int i = 0; i < kTableSize; i++)
1456 |         {
1457 |             mBRDFThetaTable  [r][i] = ClampUnit(mBRDFThetaTable  [r][i]);
1458 |             mBRDFGammaTable  [r][i] = ClampUnit(mBRDFGammaTable  [r][i]);
1459 |             mBRDFThetaTableH [r][i] = ClampUnit(mBRDFThetaTableH [r][i]);
1460 |             mBRDFThetaTableFH[r][i] = ClampUnit(mBRDFThetaTableFH[r][i]);
1461 |         }
1462 | #endif
1463 | }
1464 | 
1465 | void cSunSkyBRDF::FindBRDFTables(const cSunSkyTable& table, const cSunSkyHosek& )
1466 | {
1467 |     // The BRDF tables cover the entire sphere, so we must resample theta from the Perez/Hosek tables which cover a hemisphere.
1468 |     Vec3f thetaTable[cSunSkyTable::kTableSize];
1469 |     const Vec3f* gammaTable = table.mGammaTable;
1470 | 
1471 |     // Fill top hemisphere of table
1472 |     for (int i = 0; i < kTableSize / 2; i++)
1473 |         thetaTable[kTableSize / 2 + i] = table.mThetaTable[2 * i];
1474 | 
1475 |     // Fill lower hemisphere with term that evaluates close to 0, to avoid below-ground luminance leaking in.
1476 |     // TODO: modify this using ground albedo
1477 |     Vec3f lowerHemi = Vec3f(0.999f);  // 0.999 as theta table is used as (1 - F)
1478 | 
1479 |     for (int i = 0; i < kTableSize / 2; i++)
1480 |         thetaTable[i] = lowerHemi;
1481 | 
1482 |     // Project tables into ZH coefficients
1483 |     Vec3f zhCoeffsTheta[7];
1484 |     Vec3f zhCoeffsGamma[7];
1485 | 
1486 |     // theta table works better if we operate on something proportional to real luminance
1487 |     Vec3f biasedThetaTable[kTableSize];
1488 | 
1489 |     for (int i = 0; i < kTableSize; i++)
1490 |         biasedThetaTable[i] = thetaTable[i] + vl_one;
1491 | 
1492 |     FindZH7FromThetaTable(kTableSize, biasedThetaTable, zhCoeffsTheta);
1493 |     FindZH7FromGammaTable(kTableSize,       gammaTable, zhCoeffsGamma);
1494 | 
1495 |     // row 0 is the original unconvolved signal
1496 | 
1497 |     // Firstly, fill -ve z with reflected +ve z, ramped to 0 at z = -1. This avoids discontinuities at the horizon.
1498 |     for (int i = 0; i < kTableSize / 2; i++)
1499 |     {
1500 |         thetaTable[i] = table.mThetaTable[kTableSize - 1 - 2 * i];
1501 | 
1502 |         // Ramp luminance down
1503 |         float s = (i + 0.5f) / (kTableSize / 2);
1504 |         s = sqrtf(s);
1505 | 
1506 |         thetaTable[i] = thetaTable[i] * s + Vec3f(1 - s);
1507 |     }
1508 | 
1509 |     for (int i = 0; i < kTableSize; i++)
1510 |     {
1511 |         mBRDFThetaTable[0][i] = thetaTable[i];
1512 |         mBRDFGammaTable[0][i] = gammaTable[i];
1513 |     }
1514 | 
1515 |     // Construct H term table -- just the zenith part as we can potentially store as 4th component
1516 |     for (int i = 0; i < kTableSize / 2; i++)
1517 |         mBRDFThetaTableH[0][i] = vl_0;
1518 | 
1519 |     for (int i = 0; i < kTableSize / 2; i++)
1520 |     {
1521 |         float cosTheta = i / float(kTableSize / 2 - 1); // XXX
1522 |         float zenith = sqrtf(cosTheta);
1523 | 
1524 |         mBRDFThetaTableH[0][kTableSize / 2 + i] = zenith;
1525 |     }
1526 | 
1527 |     // Calculate FH as we get slightly better results convolving the full term
1528 |     // rather than approximating, at the cost of an extra table
1529 |     for (int i = 0; i < kTableSize; i++)
1530 |         mBRDFThetaTableFH[0][i] = mBRDFThetaTableH[0][i] * thetaTable[i];
1531 | 
1532 |     float zhCoeffsH[7];
1533 |     FindZH7FromThetaTable(kTableSize, mBRDFThetaTableH [0], zhCoeffsH);
1534 | 
1535 |     Vec3f zhCoeffsFH[7];
1536 |     FindZH7FromThetaTable(kTableSize, mBRDFThetaTableFH[0], zhCoeffsFH);
1537 | 
1538 |     // rows 1..n-1 are successive convolutions
1539 | 
1540 |     for (int r = 1; r < kBRDFSamples; r++)
1541 |     {
1542 |         int rs = kBRDFSamples - r - 1;
1543 |         float s = kRowPowers[rs];
1544 | 
1545 |         float csCoeffs[7];
1546 |         CalcCosPowerSatZH7(s, csCoeffs);
1547 | 
1548 |         Vec3f zhCoeffsThetaConv[7];
1549 |         ConvolveZH7WithZH7Norm(csCoeffs, zhCoeffsTheta, zhCoeffsThetaConv);
1550 |         Vec3f zhCoeffsGammaConv[7];
1551 |         ConvolveZH7WithZH7Norm(csCoeffs, zhCoeffsGamma, zhCoeffsGammaConv);
1552 | 
1553 |         float zhCoeffsThetaConvH [7];
1554 |         ConvolveZH7WithZH7Norm(csCoeffs, zhCoeffsH , zhCoeffsThetaConvH);
1555 |         Vec3f zhCoeffsThetaConvFH[7];
1556 |         ConvolveZH7WithZH7Norm(csCoeffs, zhCoeffsFH, zhCoeffsThetaConvFH);
1557 | 
1558 |         // Scale up to full windowing at full spec power...
1559 |         float rw = sqrtf(rs / float(kBRDFSamples - 2));
1560 | 
1561 |         ApplyZH7Windowing(kThetaWHosek * rw, zhCoeffsThetaConv);
1562 |         ApplyZH7Windowing(kGammaWHosek * rw, zhCoeffsGammaConv);
1563 |         ApplyZH7Windowing(kThetaWHosek * rw, zhCoeffsThetaConvH);
1564 |         ApplyZH7Windowing(kThetaWHosek * rw, zhCoeffsThetaConvFH);
1565 | 
1566 |         // Generate convolved tables from ZH
1567 |         GenerateThetaTableFromZH7(zhCoeffsThetaConv,   kTableSize, mBRDFThetaTable  [r]);
1568 |         GenerateGammaTableFromZH7(zhCoeffsGammaConv,   kTableSize, mBRDFGammaTable  [r]);
1569 |         GenerateThetaTableFromZH7(zhCoeffsThetaConvH,  kTableSize, mBRDFThetaTableH [r]);
1570 |         GenerateThetaTableFromZH7(zhCoeffsThetaConvFH, kTableSize, mBRDFThetaTableFH[r]);
1571 | 
1572 |         for (int i = 0; i < kTableSize; i++)
1573 |         {
1574 |             mBRDFThetaTable[r][i] -= vl_one;
1575 | 
1576 |         #ifdef HOSEK_G_FIX
1577 |             // Ringing on the Hosek G term leads to blue spots opposite the sun
1578 |             // in sunset situatons. Trying to solve this completely via windowing
1579 |             // leads to excessive blurring, so we also compensate by scaling down
1580 |             // the far pole in this situation.
1581 |             // TODO: investigate further, not sure this is worth it.
1582 |             float g = i / float(kTableSize - 1);
1583 |             float cosGamma = UnmapGamma(g);
1584 |             if (cosGamma < -0.6f)
1585 |                 mBRDFGammaTable[r][i] *= ClampUnit(1.0f - sqr(-0.6f - cosGamma) * 1.5f * rw);
1586 |         #endif
1587 |         }
1588 |     }
1589 | 
1590 |     mMaxTheta = table.mMaxTheta;
1591 |     mMaxGamma = table.mMaxGamma;
1592 |     mXYZ = true;
1593 |     mHasHTerm = true;
1594 | 
1595 | #ifdef SIM_CLAMP
1596 |     for (int r = 1; r < kBRDFSamples; r++)
1597 |         for (int i = 0; i < kTableSize; i++)
1598 |         {
1599 |             mBRDFThetaTable  [r][i] = ClampUnit(mBRDFThetaTable  [r][i]);
1600 |             mBRDFGammaTable  [r][i] = ClampUnit(mBRDFGammaTable  [r][i]);
1601 |             mBRDFThetaTableH [r][i] = ClampUnit(mBRDFThetaTableH [r][i]);
1602 |             mBRDFThetaTableFH[r][i] = ClampUnit(mBRDFThetaTableFH[r][i]);
1603 |         }
1604 | #endif
1605 | }
1606 | 
1607 | Vec3f cSunSkyBRDF::ConvolvedSkyRGB(const cSunSkyPreetham& pt, const Vec3f& v, float r) const
1608 | {
1609 |     CL_ASSERT(!mXYZ);
1610 | 
1611 |     float cosTheta = v.z;
1612 |     float cosGamma = dot(pt.mToSun, v);
1613 | 
1614 |     float t = 0.5f * (cosTheta + 1);
1615 |     float g = MapGamma(cosGamma);
1616 | 
1617 |     Vec3f F = BiLerp(t, r, kTableSize, kBRDFSamples, mBRDFThetaTable[0]);
1618 |     Vec3f G = BiLerp(g, r, kTableSize, kBRDFSamples, mBRDFGammaTable[0]);
1619 | 
1620 | #ifdef SIM_CLAMP
1621 |     F.z *= mMaxTheta;
1622 |     G.z *= mMaxGamma;
1623 | #endif
1624 | 
1625 |     // (1 - F(theta)) * (1 + G(phi))
1626 |     Vec3f xyY = (Vec3f(vl_1) - F) * (Vec3f(vl_1) + G);
1627 | 
1628 |     xyY *= pt.mPerezInvDen;
1629 | 
1630 |     return xyYToRGB(xyY);
1631 | }
1632 | 
1633 | Vec3f cSunSkyBRDF::ConvolvedSkyRGB(const cSunSkyHosek& hk, const Vec3f& v, float r) const
1634 | {
1635 |     CL_ASSERT(mXYZ);
1636 | 
1637 |     float cosTheta = v.z;
1638 |     float cosGamma = dot(hk.mToSun, v);
1639 | 
1640 |     float t = 0.5f * (cosTheta + 1);
1641 |     float g = MapGamma(cosGamma);
1642 | 
1643 |     Vec3f F = BiLerp(t, r, kTableSize, kBRDFSamples, mBRDFThetaTable[0]);
1644 |     Vec3f G = BiLerp(g, r, kTableSize, kBRDFSamples, mBRDFGammaTable[0]);
1645 | 
1646 | #ifdef SIM_CLAMP
1647 |     F *= mMaxTheta;
1648 |     G *= mMaxGamma;
1649 | #endif
1650 | 
1651 | #ifdef HOSEK_BRDF_ANALYTIC_H
1652 |     // Evaluate H term on the fly, for cross-checking.
1653 |     // This could be done in shader to avoid the additional table lookup,
1654 |     // but it's a fair bit of math, and using the table variant ensures better
1655 |     // consistency with the F/G parts.
1656 |     float zhZ[7];
1657 |     CalcCosPowerSatZH7(0.5f, zhZ);
1658 | 
1659 |     float zhR[7];
1660 |     CalcCosPowerSatZH7(1.0f / (r + 0.001f), zhR);
1661 | 
1662 |     float zhZR[7];
1663 |     ConvolveZH7WithZH7Norm(zhR, zhZ, zhZR);
1664 | 
1665 |     float zenith = EvalZH7(cosTheta, zhZR);
1666 | 
1667 |     Vec3f H
1668 |     (
1669 |         hk.mCoeffsXYZ[0][7] * zenith + (hk.mCoeffsXYZ[0][2] - 1.0f),
1670 |         hk.mCoeffsXYZ[1][7] * zenith + (hk.mCoeffsXYZ[1][2] - 1.0f),
1671 |         hk.mCoeffsXYZ[2][7] * zenith + (hk.mCoeffsXYZ[2][2] - 1.0f)
1672 |     );
1673 |     Vec3f FH = F * H;
1674 | #else
1675 |     Vec3f cH(hk.mCoeffsXYZ[0][7], hk.mCoeffsXYZ[1][7], hk.mCoeffsXYZ[2][7]);
1676 |     Vec3f cI(hk.mCoeffsXYZ[0][2] - 1.0f, hk.mCoeffsXYZ[1][2] - 1.0f, hk.mCoeffsXYZ[2][2] - 1.0f);
1677 | 
1678 |     Vec3f H  = BiLerp(t, r, kTableSize, kBRDFSamples, mBRDFThetaTableH [0]) * cH;
1679 |     Vec3f FH = BiLerp(t, r, kTableSize, kBRDFSamples, mBRDFThetaTableFH[0]) * cH;
1680 | 
1681 | #ifdef SIM_CLAMP
1682 |     FH *= mMaxTheta;
1683 | #endif
1684 | 
1685 |     H  +=     cI;
1686 |     FH += F * cI;
1687 | #endif
1688 | 
1689 |     // (1 - F(theta)) * (1 + G(phi) + H(theta))
1690 |     Vec3f XYZ = (Vec3f(vl_1) - F) * (Vec3f(vl_1) + G) + H - FH;
1691 | 
1692 |     XYZ = ClampPositive(XYZ);
1693 |     XYZ *= hk.mRadXYZ;
1694 | 
1695 |     return XYZToRGB(XYZ);
1696 | }
1697 | 
1698 | void cSunSkyBRDF::FillBRDFTexture(int width, int height, uint8_t image[][4]) const
1699 | {
1700 |     CL_ASSERT(width == kTableSize);
1701 |     CL_ASSERT((height == 2 * kBRDFSamples) || (mHasHTerm && height == 4 * kBRDFSamples));
1702 | 
1703 |     (void) width;
1704 |     (void) height;
1705 | 
1706 |     for (int j = 0; j < kBRDFSamples; j++)
1707 |     {
1708 |         for (int i = 0; i < width; i++)
1709 |         {
1710 |             Vec3f c = mBRDFThetaTable[j][i];
1711 | 
1712 |             if (mXYZ)
1713 |                 c /= mMaxTheta;
1714 |             else
1715 |                 c.z /= mMaxTheta;
1716 | 
1717 |             image[i][2] = ToU8(c.x);
1718 |             image[i][1] = ToU8(c.y);
1719 |             image[i][0] = ToU8(c.z);
1720 | 
1721 |             if (mHasHTerm)
1722 |                 image[i][3] = ToU8(mBRDFThetaTableH[j][i]);
1723 |             else
1724 |                 image[i][3] = 255;
1725 |         }
1726 | 
1727 |         image += width;
1728 |     }
1729 | 
1730 |     for (int j = 0; j < kBRDFSamples; j++)
1731 |     {
1732 |         for (int i = 0; i < width; i++)
1733 |         {
1734 |             Vec3f c = mBRDFGammaTable[j][i];
1735 | 
1736 |             if (mXYZ)
1737 |                 c /= mMaxGamma;
1738 |             else
1739 |                 c.z /= mMaxGamma;
1740 | 
1741 |             image[i][2] = ToU8(c.x);
1742 |             image[i][1] = ToU8(c.y);
1743 |             image[i][0] = ToU8(c.z);
1744 |             image[i][3] = 255;
1745 |         }
1746 | 
1747 |         image += width;
1748 |     }
1749 | 
1750 |     if (height <= 2)
1751 |         return;
1752 | 
1753 |     for (int j = 0; j < kBRDFSamples; j++)
1754 |     {
1755 |         for (int i = 0; i < width; i++)
1756 |         {
1757 |             Vec3f c = mBRDFThetaTableFH[j][i];
1758 | 
1759 |             c /= mMaxTheta;
1760 | 
1761 |             image[i][2] = ToU8(c.x);
1762 |             image[i][1] = ToU8(c.y);
1763 |             image[i][0] = ToU8(c.z);
1764 |             image[i][3] = ToU8(mBRDFThetaTableH[j][i]);
1765 |         }
1766 | 
1767 |         image += width;
1768 |     }
1769 | }
1770 | 
1771 | void cSunSkyBRDF::FillBRDFTexture(int width, int height, float image[][4]) const
1772 | {
1773 |     CL_ASSERT(width == kTableSize);
1774 |     CL_ASSERT(height == 2 * kBRDFSamples);
1775 | 
1776 |     (void) width;
1777 |     (void) height;
1778 | 
1779 |     for (int j = 0; j < kBRDFSamples; j++)
1780 |     {
1781 |         for (int i = 0; i < width; i++)
1782 |             *(Vec4f*) image[i] = Vec4f(mBRDFThetaTable[j][i], mHasHTerm ? mBRDFThetaTableH[j][i] : 1.0f);
1783 | 
1784 |         image += width;
1785 |     }
1786 | 
1787 |     for (int j = 0; j < kBRDFSamples; j++)
1788 |     {
1789 |         for (int i = 0; i < width; i++)
1790 |             *(Vec4f*) image[i] = Vec4f(mBRDFGammaTable[j][i], 1.0f);
1791 | 
1792 |         image += width;
1793 |     }
1794 | 
1795 |     if (height <= 2)
1796 |         return;
1797 | 
1798 |     for (int j = 0; j < kBRDFSamples; j++)
1799 |     {
1800 |         for (int i = 0; i < width; i++)
1801 |             *(Vec4f*) image[i] = Vec4f(mBRDFThetaTableFH[j][i], mBRDFThetaTableH[j][i]);
1802 | 
1803 |         image += width;
1804 |     }
1805 | }
1806 | 
1807 | 
1808 | //------------------------------------------------------------------------------
1809 | // cSunSky -- composite class for easier comparison
1810 | //------------------------------------------------------------------------------
1811 | 
1812 | cSunSky::cSunSky() :
1813 |     mSkyType(kPreetham),
1814 |     mToSun(vl_0),
1815 |     mTurbidity(2.5f),
1816 |     mAlbedo(vl_0),
1817 |     mOvercast(0.0f),
1818 |     mRoughness(0.0f),
1819 |     mZenithY(0.0f)
1820 | {
1821 | }
1822 | 
1823 | void cSunSky::SetSkyType(tSkyType skyType)
1824 | {
1825 |     mSkyType = skyType;
1826 | }
1827 | 
1828 | tSkyType cSunSky::SkyType() const
1829 | {
1830 |     return mSkyType;
1831 | }
1832 | 
1833 | void cSunSky::SetSunDir(const Vec3f& v)
1834 | {
1835 |     mToSun = v;
1836 | }
1837 | 
1838 | void cSunSky::SetTurbidity(float turbidity)
1839 | {
1840 |     mTurbidity = turbidity;
1841 | }
1842 | 
1843 | void cSunSky::SetAlbedo(Vec3f rgb)
1844 | {
1845 |     mAlbedo = rgb;
1846 | }
1847 | 
1848 | void cSunSky::SetOvercast(float overcast)
1849 | {
1850 |     mOvercast = overcast;
1851 | }
1852 | 
1853 | void cSunSky::SetRoughness(float roughness)
1854 | {
1855 |     mRoughness = roughness;
1856 | }
1857 | 
1858 | void cSunSky::Update()
1859 | {
1860 |     mZenithY = ZenithLuminance(acosf(mToSun.z), mTurbidity);
1861 |     
1862 |     mPreetham.Update(mToSun, mTurbidity, mOvercast);
1863 |     mHosek   .Update(mToSun, mTurbidity, mAlbedo, mOvercast);
1864 | 
1865 |     if (mSkyType == kPreethamTable || mSkyType == kPreethamBRDF)
1866 |         mTable.FindThetaGammaTables(mPreetham);
1867 |     else if (mSkyType == kHosekTable || mSkyType == kHosekBRDF)
1868 |         mTable.FindThetaGammaTables(mHosek);
1869 | 
1870 |     if (mSkyType == kPreethamBRDF)
1871 |         mBRDF.FindBRDFTables(mTable, mPreetham);
1872 |     if (mSkyType == kHosekBRDF)
1873 |         mBRDF.FindBRDFTables(mTable, mHosek);
1874 | }
1875 | 
1876 | Vec3f cSunSky::SkyRGB(const Vec3f& v) const
1877 | {
1878 |     switch (mSkyType)
1879 |     {
1880 |     case kPreetham:
1881 |         return mPreetham.SkyRGB(v);
1882 | 
1883 |     case kPreethamTable:
1884 |         return mTable.SkyRGB(mPreetham, v);
1885 |     case kPreethamBRDF:
1886 |         return mBRDF.ConvolvedSkyRGB(mPreetham, v, mRoughness);
1887 | 
1888 |     case kHosek:
1889 |         return mHosek.SkyRGB(v);
1890 |     case kHosekTable:
1891 |         return mTable.SkyRGB(mHosek, v);
1892 |     case kHosekBRDF:
1893 |         return mBRDF.ConvolvedSkyRGB(mHosek, v, mRoughness);
1894 | 
1895 |     case kCIEClear:
1896 |         return Vec3f(CIEClearSkyLuminance       (v, mToSun, mZenithY));
1897 |     case kCIEOvercast:
1898 |         return Vec3f(CIEOvercastSkyLuminance    (v,         mZenithY));
1899 |     case kCIEPartlyCloudy:
1900 |         return Vec3f(CIEPartlyCloudySkyLuminance(v, mToSun, mZenithY));
1901 | 
1902 |     default:
1903 |         return vl_0;
1904 |     }
1905 | }
1906 | 
1907 | float cSunSky::SkyLuminance(const Vec3f& v) const
1908 | {
1909 |     if (v.z < 0.0)
1910 |         return 0.0;
1911 | 
1912 |     switch (mSkyType)
1913 |     {
1914 |     case kPreetham:
1915 |         return mPreetham.SkyLuminance(v);
1916 |     case kCIEClear:
1917 |         return CIEClearSkyLuminance       (v, mToSun, mZenithY);
1918 |     case kCIEOvercast:
1919 |         return CIEOvercastSkyLuminance    (v,         mZenithY);
1920 |     case kCIEPartlyCloudy:
1921 |         return CIEPartlyCloudySkyLuminance(v, mToSun, mZenithY);
1922 |     case kHosek:
1923 |         return mHosek.SkyLuminance(v);
1924 |     default:
1925 |         return 0;
1926 |     }
1927 | }
1928 | 
1929 | Vec2f cSunSky::SkyChroma(const Vec3f& v) const
1930 | {
1931 |     if (v.z < 0.0)
1932 |         return Vec2f(0, 0);
1933 | 
1934 |     switch (mSkyType)
1935 |     {
1936 |     case kPreetham:
1937 |         return mPreetham.SkyChroma(v);
1938 |     case kCIEClear:
1939 |         return kClearChroma;
1940 |     case kCIEOvercast:
1941 |         return kOvercastChroma;
1942 |     case kCIEPartlyCloudy:
1943 |         return kPartlyCloudyChroma;
1944 |     case kHosek:
1945 |         {
1946 |             Vec3f xyz = mHosek.SkyXYZ(v);
1947 |             return Vec2f(xyz.x / xyz.z, xyz.y / xyz.z);
1948 |         }
1949 |     default:
1950 |         return kOvercastChroma;
1951 |     }
1952 | }
1953 | 
1954 | float cSunSky::AverageLuminance() const
1955 | {
1956 |     switch (mSkyType)
1957 |     {
1958 |     case kPreetham:
1959 |     case kPreethamTable:
1960 |     case kPreethamBRDF:
1961 |         return mPreetham.mPerezInvDen.z;
1962 | 
1963 |     case kCIEClear:
1964 |         return CIEClearSkyLuminance(vl_0, mToSun, mZenithY);
1965 |     case kCIEOvercast:
1966 |         return mZenithY;
1967 |     case kCIEPartlyCloudy:
1968 |         return CIEPartlyCloudySkyLuminance(Vec3f(0.0f, 0.0f, 0.0f), mToSun, mZenithY);
1969 | 
1970 |     case kHosek:
1971 |     case kHosekTable:
1972 |     case kHosekBRDF:
1973 |         return mHosek.mRadXYZ.y;
1974 | 
1975 |     default:
1976 |         return 1.0f;
1977 |     }
1978 | }
1979 | 
1980 | 


--------------------------------------------------------------------------------
/SunSky.h:
--------------------------------------------------------------------------------
  1 | //
  2 | //  File:       SunSky.h
  3 | //
  4 | //  Function:   Implements various sky models -- Preetham, Hosek, CIE* -- as
  5 | //              well as a separable table-based model for fast BRDF convolutions
  6 | //
  7 | //  Author:     Andrew Willmott, Preetham sun/sky based on code by Brian Smits,
  8 | //              Hosek code used L. Hosek & A. Wilkie code Version 1.4a as reference
  9 | //
 10 | //  Copyright:  Andrew Willmott, see HosekDataXYZ.h for Hosek data copyright
 11 | //
 12 | 
 13 | #ifndef SUNSKY_H
 14 | #define SUNSKY_H
 15 | 
 16 | #include "VL234f.h"
 17 | 
 18 | namespace SSLib
 19 | {
 20 |     extern const float kSunDiameter;
 21 |     extern const float kSunDistance;
 22 |     extern const float kSunCosAngle;
 23 |     extern const float kSunSolidAngle;
 24 | 
 25 |     Vec3f SunDirection
 26 |     (
 27 |         float       timeOfDay,         // 24-hour, decimal: 0.0-23.99
 28 |         float       timeZone,          // relative to UTC: west -ve, east +ve
 29 |         int         julianDay,         // day of year: 1-365
 30 |         float       latitude,          // Degrees: north is positive
 31 |         float       longitude          // Degrees: east is positive
 32 |     );
 33 |     // Returns the local sun direction at the given time/location. +Y = north, +X = east, +Z = up.
 34 | 
 35 |     // Utilities
 36 |     Vec3f SunRGB(float cosTheta, float turbidity = 3.0f);   // Returns RGB for given sun elevation
 37 |     float ZenithLuminance(float thetaS, float T);           // Returns luminance estimate for given solar altitude and turbidity
 38 | 
 39 |     float CIEOvercastSkyLuminance    (const Vec3f& v, float Lz);                        // CIE standard overcast sky
 40 |     float CIEClearSkyLuminance       (const Vec3f& v, const Vec3f& toSun, float Lz);    // CIE standard clear sky
 41 |     float CIEPartlyCloudySkyLuminance(const Vec3f& v, const Vec3f& toSun, float Lz);    // CIE standard partly cloudy sky
 42 |     float CIEStandardSky   (int type, const Vec3f& v, const Vec3f& toSun, float Lz);    // Returns one of 15 standard skies: type = 0-14. See kCIEStandardSkyCoeffs
 43 | 
 44 | 
 45 |     //--------------------------------------------------------------------------
 46 |     // cSunSkyPreetham
 47 |     //--------------------------------------------------------------------------
 48 | 
 49 |     class cSunSkyPreetham
 50 |     {
 51 |     public:
 52 |         cSunSkyPreetham();
 53 | 
 54 |         void        Update(const Vec3f& sun, float turbidity, float overcast = 0.0f, float hCrush = 0.0f); // update model with given settings
 55 | 
 56 |         Vec3f       SkyRGB      (const Vec3f &v) const;     // Returns luminance/chroma converted to RGB
 57 |         float       SkyLuminance(const Vec3f &v) const;     // Returns the luminance of the sky in direction v. v must be normalized. Luminance is in Nits = cd/m^2 = lumens/sr/m^2 */
 58 |         Vec2f       SkyChroma   (const Vec3f &v) const;     // Returns the chroma of the sky in direction v. v must be normalized.
 59 | 
 60 |         // Data
 61 |         Vec3f       mToSun;
 62 | 
 63 |         float       mPerez_x[5];
 64 |         float       mPerez_y[5];
 65 |         float       mPerez_Y[5];
 66 | 
 67 |         Vec3f       mZenith;
 68 |         Vec3f       mPerezInvDen;
 69 |     };
 70 | 
 71 | 
 72 |     //--------------------------------------------------------------------------
 73 |     // cSunSkyHosek
 74 |     //--------------------------------------------------------------------------
 75 | 
 76 |     class cSunSkyHosek
 77 |     {
 78 |     public:
 79 |         cSunSkyHosek();
 80 | 
 81 |         void        Update(const Vec3f& sun, float turbidity, Vec3f albedo = vl_0, float overcast = 0.0f); // update model with given settings
 82 | 
 83 |         Vec3f       SkyXYZ      (const Vec3f &v) const;     // Returns CIE XYZ
 84 |         Vec3f       SkyRGB      (const Vec3f &v) const;     // Returns luminance/chroma converted to RGB
 85 |         float       SkyLuminance(const Vec3f &v) const;     // Returns CIE XYZ
 86 | 
 87 |         // Data
 88 |         Vec3f       mToSun;
 89 |         float       mCoeffsXYZ[3][9];   // Hosek 9-term distribution coefficients
 90 |         Vec3f       mRadXYZ;            // Overall average radiance
 91 |     };
 92 | 
 93 | 
 94 |     //--------------------------------------------------------------------------
 95 |     // cSunSkyTable
 96 |     //--------------------------------------------------------------------------
 97 | 
 98 |     class cSunSkyTable
 99 |     {
100 |     public:
101 |         // Table-based version - faster than per-sample Perez/Hosek function evaluation, suitable for shader use via 64 x 2 texture
102 |         // For a fixed time, Preetham can be expressed in the form
103 |         //   K (1 + F(theta))(1 + G(gamma))
104 |         // where theta is the zenith angle of v, and gamma the angle between v and the sun direction.
105 |         // Hosek can be expressed in the form
106 |         //   K (1 + F(theta))(1 + G(gamma) + H(theta))
107 |         // where H is trivial to evaluate in a shader, involving a constant term and sqrt(v.z).
108 |         // Note: the F term is generally negative, so we use F' = -F in the tables.
109 | 
110 |         void        FindThetaGammaTables(const cSunSkyPreetham& pt);
111 |         void        FindThetaGammaTables(const cSunSkyHosek& pt);
112 | 
113 |         Vec3f       SkyRGB(const cSunSkyPreetham& pt, const Vec3f& v) const;  // Use precalculated table to return fast sky colour on CPU
114 |         Vec3f       SkyRGB(const cSunSkyHosek& hk,    const Vec3f& v) const;  // Use precalculated table to return fast sky colour on CPU
115 | 
116 |         void        FillTexture(int width, int height, uint8_t image[][4]) const;  // Fill kTableSize x 2 BGRA8 texture with tables
117 |         void        FillTexture(int width, int height, float   image[][4]) const;  // Fill kTableSize x 2 RGBAF32 texture with tables
118 | 
119 |         // Table acceleration
120 |         enum { kTableSize = 64 };
121 |         Vec3f       mThetaTable[kTableSize];
122 |         Vec3f       mGammaTable[kTableSize];
123 |         float       mMaxTheta = 1.0f;       // To avoid clipping when using non-float textures. Currently only necessary if overcast is being used.
124 |         float       mMaxGamma = 1.0f;       // To avoid clipping when using non-float textures.
125 |         bool        mXYZ      = false;      // Whether tables are storing xyY (Preetham) or XYZ (Hosek)
126 |     };
127 | 
128 | 
129 |     //--------------------------------------------------------------------------
130 |     // cSunSkyBRDF
131 |     //--------------------------------------------------------------------------
132 | 
133 |     // #define COMPACT_BRDF_TABLE   // enable for smaller half-size table
134 | 
135 |     class cSunSkyBRDF
136 |     {
137 |     public:
138 |         // Extended version of cSunSkyTable that uses zonal harmonics to produce table rows
139 |         // convolved with increasing cosine powers. This is an approximation, because
140 |         // conv(AB) != conv(A) conv(B), but, because the Perez-form evaluation is
141 |         // (1 + F(theta)) (1 + G(gamma)), the approximation is only for the small
142 |         // order-2 FG term.
143 |         void        FindBRDFTables(const cSunSkyTable& table, const cSunSkyPreetham& pt);
144 |         void        FindBRDFTables(const cSunSkyTable& table, const cSunSkyHosek& hk);
145 | 
146 |         Vec3f       ConvolvedSkyRGB(const cSunSkyPreetham& pt, const Vec3f& v, float roughness) const; // return sky term convolved with roughness, 1 = fully diffuse
147 |         Vec3f       ConvolvedSkyRGB(const cSunSkyHosek& pt,    const Vec3f& v, float roughness) const; // return sky term convolved with roughness, 1 = fully diffuse
148 | 
149 |         void        FillBRDFTexture(int width, int height, uint8_t image[][4]) const; // Fill kTableSize x (kBRDFSamples x 2|4) BGRA8 texture with tables
150 |         void        FillBRDFTexture(int width, int height, float   image[][4]) const; // Fill kTableSize x (kBRDFSamples x 2|4) RGBAF32 texture with tables
151 |                     // Note: for Hosek, the H term will be in the 'w' component of the theta section, and if a kBRDFSamples x 4 size texture is supplied,
152 |                     // the two additional sections will contain the FH term table. (Using this improves accuracy but can be skipped.)
153 | 
154 |         enum { kTableSize = cSunSkyTable::kTableSize };
155 |     #ifdef COMPACT_BRDF_TABLE
156 |         enum { kBRDFSamples = 4 };
157 |     #else
158 |         enum { kBRDFSamples = 8 };
159 |     #endif
160 |         Vec3f       mBRDFThetaTable[kBRDFSamples][kTableSize];
161 |         Vec3f       mBRDFGammaTable[kBRDFSamples][kTableSize];
162 | 
163 |         // Additional tables for 'H' term in Hosek.
164 |         float       mBRDFThetaTableH [kBRDFSamples][kTableSize];
165 |         Vec3f       mBRDFThetaTableFH[kBRDFSamples][kTableSize];
166 |         bool        mHasHTerm = false;
167 | 
168 |         float       mMaxTheta = 1.0f;       // To avoid clipping when using non-float textures. Currently only necessary if overcast is being used.
169 |         float       mMaxGamma = 1.0f;       // To avoid clipping when using non-float textures.
170 |         bool        mXYZ      = false;      // Whether tables are storing xyY (Preetham) or XYZ (Hosek)
171 |     };
172 | 
173 | 
174 |     //--------------------------------------------------------------------------
175 |     // cSunSky
176 |     // Composite sun/sky model for easy comparisons
177 |     //--------------------------------------------------------------------------
178 | 
179 |     enum tSkyType
180 |     {
181 |         kPreetham,
182 |         kPreethamTable, // Table accelerated version, for sanity checking -- really designed for texture/shader use
183 |         kPreethamBRDF,  // Sky model convolved with roughness (sat(cos^n) brdf)
184 |         kHosek,
185 |         kHosekTable,
186 |         kHosekBRDF,
187 |         kCIEClear,
188 |         kCIEOvercast,
189 |         kCIEPartlyCloudy,
190 |         kNumSkyTypes
191 |     };
192 | 
193 |     class cSunSky
194 |     {
195 |     public:
196 |         cSunSky();
197 | 
198 |         void        SetSkyType(tSkyType skyType);
199 |         tSkyType    SkyType() const;
200 | 
201 |         void        SetSunDir   (const Vec3f& sun);
202 |         void        SetTurbidity(float turbidity);
203 |         void        SetAlbedo   (Vec3f rgb);  // Set ground-bounce factor
204 |         void        SetOvercast (float overcast);   // 0 = clear, 1 = completely overcast
205 |         void        SetRoughness(float roughness);  // Set roughness for BRDF tables
206 | 
207 |         void        Update();                       // update model given above settings
208 | 
209 |         float       SkyLuminance(const Vec3f &v) const;     // Returns the luminance of the sky in direction v. v must be normalized. Luminance is in Nits = cd/m^2 = lumens/sr/m^2 */
210 |         Vec2f       SkyChroma   (const Vec3f &v) const;     // Returns the chroma of the sky in direction v. v must be normalized.
211 |         Vec3f       SkyRGB      (const Vec3f &v) const;     // Returns luminance/chroma converted to RGB
212 | 
213 |         float       AverageLuminance() const;
214 | 
215 |     protected:
216 |         // Data
217 |         tSkyType    mSkyType;
218 | 
219 |         Vec3f       mToSun;
220 |         float       mTurbidity;
221 |         Vec3f       mAlbedo;
222 |         float       mOvercast;
223 |         float       mRoughness;
224 | 
225 |         // Various models
226 |         float           mZenithY;   // for CIE functions
227 | 
228 |         cSunSkyPreetham mPreetham;
229 |         cSunSkyHosek    mHosek;
230 |         cSunSkyTable    mTable;
231 |         cSunSkyBRDF     mBRDF;
232 |     };
233 | }
234 | 
235 | #endif 
236 | 


--------------------------------------------------------------------------------
/SunSkyTool.cpp:
--------------------------------------------------------------------------------
   1 | //
   2 | //  File:       SunSkyTool.cpp
   3 | //
   4 | //  Function:   Test tool for SunSky.*
   5 | //
   6 | //  Copyright:  Andrew Willmott
   7 | //
   8 | 
   9 | #define  _CRT_SECURE_NO_WARNINGS
  10 | #define _USE_MATH_DEFINES
  11 | 
  12 | #include "SunSky.h"
  13 | 
  14 | #include <math.h>
  15 | #include <time.h>
  16 | #include <stdio.h>
  17 | #include <stdlib.h>
  18 | #ifndef _MSC_VER
  19 |     #include <unistd.h>
  20 |     #include <strings.h>
  21 | #else
  22 |     #include <string.h>
  23 |     #define strcasecmp _stricmp
  24 | #endif
  25 | 
  26 | #include "stb_image_mini.h"
  27 | 
  28 | // #define EDGE_FILL
  29 | 
  30 | using namespace SSLib;
  31 | 
  32 | //------------------------------------------------------------------------------
  33 | // Utilities
  34 | //------------------------------------------------------------------------------
  35 | 
  36 | namespace
  37 | {
  38 |     // latitude, longitude
  39 |     const Vec2f kLondon       (+51.5f,  0.0f);
  40 |     const Vec2f kAuckland     (-37.0f,  174.8f);
  41 |     const Vec2f kPittsburgh   ( 40.5f, -80.22f);
  42 |     const Vec2f kOakland      ( 37.8f, -122.2f);
  43 |     const Vec2f kSanFrancisco ( 37.8f, -122.4f);
  44 |     const Vec2f kJakarta      (-6.21f,  106.85f);
  45 | 
  46 |     inline float saturate(float s)
  47 |     {
  48 |         if (s < 0.0f)
  49 |             return 0.0f;
  50 |         if (s >= 1.0f)
  51 |             return 1.0f;
  52 |         return s;
  53 |     }
  54 | 
  55 |     inline float Max(float a, float b)
  56 |     {
  57 |         return b < a ? a : b;
  58 |     }
  59 | 
  60 |     inline Vec3f MaxElts(const Vec3f& a, const Vec3f& b)
  61 |     {
  62 |         return Vec3f
  63 |         (
  64 |             Max(a.x, b.x),
  65 |             Max(a.y, b.y),
  66 |             Max(a.z, b.z)
  67 |         );
  68 |     }
  69 | 
  70 |     inline uint32_t RGBFToU32(Vec3f rgb)
  71 |     {
  72 |         return
  73 |               0xFF000000
  74 |             | (int) lrintf(saturate(rgb.x) * 255.0f) <<  0
  75 |             | (int) lrintf(saturate(rgb.y) * 255.0f) <<  8
  76 |             | (int) lrintf(saturate(rgb.z) * 255.0f) << 16;
  77 |     }
  78 | 
  79 |     bool ArgCountError(const char* opt, int expected, int argc)
  80 |     {
  81 |         if (argc < expected)
  82 |         {
  83 |             fprintf(stderr, "Not enough arguments for %s: expected %d, have %d\n", opt, expected, argc);
  84 |             return true;
  85 |         }
  86 | 
  87 |         return false;
  88 |     }
  89 | 
  90 |     inline int HemiInset(float y2, int width)
  91 |     {
  92 |         float maxX2 = 1.0f - y2;
  93 |         float maxX = sqrtf(maxX2);
  94 | 
  95 |         return (int) lrintf(ceil((1.0f - maxX) * width / 2.0f));
  96 |     }
  97 | 
  98 |     Vec3f pow(Vec3f v, float n)
  99 |     {
 100 |         return Vec3f(powf(v.x, n), powf(v.y, n), powf(v.z, n));
 101 |     }
 102 | 
 103 |     Vec3f toneMapLinear(Vec3f c, float weight)
 104 |     {
 105 |         return c * weight;
 106 |     }
 107 | 
 108 |     Vec3f toneMapExp(Vec3f c, float weight)
 109 |     {
 110 |         return Vec3f(vl_one) - Vec3f(exp(-weight * c.x), exp(-weight * c.y), exp(-weight * c.z));
 111 |     }
 112 | 
 113 |     Vec3f toneMapReinhard(Vec3f c, float weight)
 114 |     {
 115 |         c *= weight;
 116 |         return c / (Vec3f(vl_one) + c);
 117 |     }
 118 | 
 119 |     typedef Vec3f ToneMapFunc(Vec3f c, float weight);
 120 | 
 121 |     enum kToneMapType
 122 |     {
 123 |         kToneMapLinear,
 124 |         kToneMapExponential,
 125 |         kToneMapReinhard,
 126 |         kNumToneMapTypes
 127 |     };
 128 | 
 129 |     ToneMapFunc* kToneMapFuncs[kNumToneMapTypes + 1] =
 130 |     {
 131 |         toneMapLinear,
 132 |         toneMapExp,
 133 |         toneMapReinhard,
 134 |         nullptr
 135 |     };
 136 | 
 137 |     struct cMapInfo
 138 |     {
 139 |         float weight    = 5e-5f;
 140 |         float gamma     = 2.2f;
 141 |         float hemiSign  = 1.0f;
 142 |         bool  fisheye   = false;
 143 | 
 144 |         ToneMapFunc* toneMap = toneMapLinear;
 145 |     };
 146 | 
 147 |     bool PFMWrite(const char* filename, int width, int height, Vec3f* image)
 148 |     {
 149 |         FILE* f = fopen(filename, "w");
 150 | 
 151 |         if (!f)
 152 |             return false;
 153 | 
 154 |         fprintf(f, "PF\n");
 155 |         fprintf(f, "%d %d\n", width, height);
 156 |         fprintf(f, "-1.0\n");   // -ve = little endian
 157 | 
 158 |         image += width * height;
 159 | 
 160 |         for (int i = 0; i < height; i++)
 161 |         {
 162 |             image -= width;
 163 |             fwrite(image, sizeof(float) * 3, width, f);
 164 |         }
 165 | 
 166 |         fclose(f);
 167 | 
 168 |         return true;
 169 |     }
 170 | }
 171 | 
 172 | 
 173 | //------------------------------------------------------------------------------
 174 | // Projected (or fisheye) hemisphere in LDR (png) and HDR (pfm)
 175 | //------------------------------------------------------------------------------
 176 | 
 177 | namespace
 178 | {
 179 |     /// Fill top-down projection of upper or lower hemisphere
 180 |     void SkyToHemisphere(const cSunSky& sunSky, int width, int height, uint8_t* data, int stride, const cMapInfo& mi)
 181 |     {
 182 |         float invGamma = 1.0;
 183 | 
 184 |         if (mi.gamma > 0.0)
 185 |             invGamma = 1.0f / mi.gamma;
 186 | 
 187 |         data += (height - 1) * stride;
 188 | 
 189 |         for (int i = 0; i < height; i++)
 190 |         {
 191 |             uint32_t* row = (uint32_t*) data;
 192 | 
 193 |             float y = 2.0f * (i + 0.5f) / height - 1.0f;
 194 |             float y2 = y * y;
 195 | 
 196 |             int sw = HemiInset(y2, width);
 197 | 
 198 |             for (int j = sw; j < width - sw; j++)
 199 |             {
 200 |                 float x = 2.0f * (j + 0.5f) / width - 1.0f;
 201 |                 float x2 = x * x;
 202 |                 float h2 = x2 + y2;
 203 | 
 204 |                 Vec3f v;
 205 | 
 206 |                 if (mi.fisheye)
 207 |                 {
 208 |                     float theta = vl_halfPi - vl_halfPi * sqrtf(h2);
 209 |                     float phi = atan2f(y, x);
 210 |                     v = Vec3f(cos(phi) * cos(theta), sin(phi) * cos(theta), sin(theta));
 211 |                 }
 212 |                 else
 213 |                     v = Vec3f(x, y, mi.hemiSign * sqrtf(1.0f - h2));
 214 | 
 215 |                 Vec3f c = sunSky.SkyRGB(v);
 216 | 
 217 |                 c = mi.toneMap(c, mi.weight);
 218 |                 c = pow(c, invGamma);
 219 | 
 220 |                 row[j] = RGBFToU32(c);
 221 |             }
 222 | 
 223 |             // fill in surrounds
 224 |         #ifdef EDGE_FILL
 225 |             for (int j = 0; j < sw; j++)
 226 |                 row[j] = row[sw];
 227 |             for (int j = width - sw; j < width; j++)
 228 |                 row[j] = row[width - sw - 1];
 229 |         #else
 230 |             for (int j = 0; j < sw; j++)
 231 |                 row[j] = 0xFF000000;
 232 |             for (int j = width - sw; j < width; j++)
 233 |                 row[j] = 0xFF000000;
 234 |         #endif
 235 | 
 236 |             data -= stride;
 237 |         }
 238 |     }
 239 | 
 240 |     struct cStats
 241 |     {
 242 |         Vec3f avg;
 243 |         Vec3f max;
 244 |         Vec3f dev;
 245 |     };
 246 | 
 247 |     void SkyToHemisphere(const cSunSky& sunSky, int width, int height, Vec3f* data, const cMapInfo& mi, cStats* stats)
 248 |     {
 249 |         Vec3f maxElts(vl_0);
 250 |         Vec3f sumElts(vl_0);
 251 |         Vec3f varElts(vl_0);
 252 |         int samples = 0;
 253 |         int stride = width;
 254 | 
 255 |         data += (height - 1) * stride;
 256 | 
 257 |         for (int i = 0; i < height; i++)
 258 |         {
 259 |             Vec3f* row = data;
 260 | 
 261 |             float y = 2.0f * (i + 0.5f) / height - 1.0f;
 262 |             float y2 = y * y;
 263 | 
 264 |             int sw = HemiInset(y2, width);
 265 | 
 266 |             for (int j = sw; j < width - sw; j++)
 267 |             {
 268 |                 float x = 2.0f * (j + 0.5f) / width - 1.0f;
 269 |                 float x2 = x * x;
 270 |                 float h2 = x2 + y2;
 271 | 
 272 |                 Vec3f v(x, y, mi.hemiSign * sqrtf(1.0f - h2));
 273 | 
 274 |                 Vec3f c = sunSky.SkyRGB(v);
 275 | 
 276 |                 if (stats)
 277 |                 {
 278 |                     maxElts = MaxElts(maxElts, c);
 279 |                     sumElts += c;
 280 |                     varElts += c * c;
 281 |                     samples++;
 282 |                 }
 283 | 
 284 |                 c *= mi.weight;
 285 | 
 286 |                 row[j] = c;
 287 |             }
 288 | 
 289 |         #ifdef EDGE_FILL
 290 |             // fill in surrounds by replicating edge texels
 291 |             for (int j = 0; j < sw; j++)
 292 |                 row[j] = row[sw];
 293 |             for (int j = width - sw; j < width; j++)
 294 |                 row[j] = row[width - sw - 1];
 295 |         #else
 296 |             // fill in surrounds by replicating edge texels
 297 |             for (int j = 0; j < sw; j++)
 298 |                 row[j] = vl_0;
 299 |             for (int j = width - sw; j < width; j++)
 300 |                 row[j] = vl_0;
 301 |         #endif
 302 | 
 303 |             data -= stride;
 304 |         }
 305 | 
 306 |         if (stats)
 307 |         {
 308 |             stats->avg = sumElts / float(samples);
 309 |             stats->max = maxElts;
 310 |             varElts = varElts / float(samples) - sqr(stats->avg);
 311 |             stats->dev = Vec3f(sqrtf(varElts.x), sqrtf(varElts.y), sqrtf(varElts.z));
 312 |         }
 313 |     }
 314 | }
 315 | 
 316 | 
 317 | //------------------------------------------------------------------------------
 318 | // Cubemap generation in LDR (png) and HDR (pfm)
 319 | //------------------------------------------------------------------------------
 320 | 
 321 | namespace
 322 | {
 323 |     const int kFaceIndices[6][3] =
 324 |     {
 325 |         0, 2, 1,
 326 |         2, 0, 1,
 327 |         0, 2, 1,
 328 |         2, 0, 1,
 329 |         0, 1, 2,
 330 |         0, 1, 2,
 331 |     };
 332 |     const float kFaceSigns[6][3] =
 333 |     {
 334 |         +1.0f, +1.0f, +1.0f,
 335 |         +1.0f, -1.0f, +1.0f,
 336 |         -1.0f, -1.0f, +1.0f,
 337 |         -1.0f, +1.0f, +1.0f,
 338 |         +1.0f, -1.0f, +1.0f,
 339 |         +1.0f, +1.0f, -1.0f,
 340 |     };
 341 | 
 342 |     void SkyToCubeFace(const cSunSky& sunSky, int face, int width, int height, uint8_t* data, int stride, const cMapInfo& mi)
 343 |     {
 344 |         float invGamma = 1.0;
 345 | 
 346 |         if (mi.gamma > 0.0)
 347 |             invGamma = 1.0f / mi.gamma;
 348 | 
 349 |         const float* signs   = kFaceSigns  [face];
 350 |         const int*   indices = kFaceIndices[face];
 351 | 
 352 |         data += (height - 1) * stride;
 353 | 
 354 |         for (int i = 0; i < height; i++)
 355 |         {
 356 |             uint32_t* row = (uint32_t*) data;
 357 | 
 358 |             for (int j = 0; j < width; j++)
 359 |             {
 360 |                 Vec3f facePos(2 * (j + 0.5f) / width - 1, 2 * (i + 0.5f) / height - 1, 1.0f);
 361 | 
 362 |                 Vec3f faceDir
 363 |                 (
 364 |                     signs[0] * facePos[indices[0]],
 365 |                     signs[1] * facePos[indices[1]],
 366 |                     signs[2] * facePos[indices[2]]
 367 |                 );
 368 | 
 369 |                 faceDir = norm(faceDir);
 370 |                 Vec3f faceColour = sunSky.SkyRGB(faceDir);
 371 | 
 372 |                 faceColour = mi.toneMap(faceColour, mi.weight);
 373 |                 faceColour = pow(faceColour, invGamma);
 374 | 
 375 |                 row[j] = RGBFToU32(faceColour);
 376 |             }
 377 | 
 378 |             data -= stride;
 379 |         }
 380 |     }
 381 | 
 382 |     void SkyToCubeFace(const cSunSky& sunSky, int face, int width, int height, Vec3f* data, const cMapInfo& mi)
 383 |     {
 384 |         const float* signs   = kFaceSigns  [face];
 385 |         const int*   indices = kFaceIndices[face];
 386 | 
 387 |         int stride = width;
 388 |         data += (height - 1) * stride;
 389 | 
 390 |         for (int i = 0; i < height; i++)
 391 |         {
 392 |             Vec3f* row = data;
 393 | 
 394 |             for (int j = 0; j < width; j++)
 395 |             {
 396 |                 Vec3f facePos(2 * (j + 0.5f) / width - 1, 2 * (i + 0.5f) / height - 1, 1.0f);
 397 | 
 398 |                 Vec3f faceDir
 399 |                 (
 400 |                     signs[0] * facePos[indices[0]],
 401 |                     signs[1] * facePos[indices[1]],
 402 |                     signs[2] * facePos[indices[2]]
 403 |                 );
 404 | 
 405 |                 faceDir = norm(faceDir);
 406 | 
 407 |                 row[j] = sunSky.SkyRGB(faceDir) * mi.weight;
 408 |             }
 409 | 
 410 |             data -= stride;
 411 |         }
 412 |     }
 413 | }
 414 | 
 415 | 
 416 | //------------------------------------------------------------------------------
 417 | // Panorama generation in LDR (png) and HDR (pfm)
 418 | //------------------------------------------------------------------------------
 419 | 
 420 | namespace
 421 | {
 422 |     void SkyToPanoramic(const cSunSky& sunSky, int height, uint8_t* data, int stride, const cMapInfo& mi)
 423 |     {
 424 |         float invGamma = 1.0;
 425 | 
 426 |         if (mi.gamma > 0.0)
 427 |             invGamma = 1.0f / mi.gamma;
 428 | 
 429 |         int width = 2 * height;
 430 |         if (stride == 0)
 431 |             stride = 4 * width;
 432 | 
 433 |         float da = vl_pi / height;
 434 |         float phi = vl_pi - 0.5f * da;
 435 | 
 436 |         data += (height - 1) * stride;
 437 | 
 438 |         for (int i = 0; i < height; i++)
 439 |         {
 440 |             uint32_t* row = (uint32_t*) data;
 441 | 
 442 |             float theta = 0.5f * da;
 443 |             float sp = sinf(phi);
 444 |             float cp = cosf(phi);
 445 | 
 446 |             for (int j = 0; j < width; j++)
 447 |             {
 448 |                 float st = sinf(theta);
 449 |                 float ct = cosf(theta);
 450 | 
 451 |                 // middle of image is north, east to right, west to left, edges are south
 452 |                 Vec3f dir(-st * sp, -ct * sp, cp);
 453 | 
 454 |                 Vec3f c = sunSky.SkyRGB(dir);
 455 | 
 456 |                 c = mi.toneMap(c, mi.weight);
 457 |                 c = pow(c, invGamma);
 458 | 
 459 |                 row[j] = RGBFToU32(c);
 460 |                 theta += da;
 461 |             }
 462 | 
 463 |             data -= stride;
 464 |             phi -= da;
 465 |         }
 466 |     }
 467 | 
 468 |     void SkyToPanoramic(const cSunSky& sunSky, int height, Vec3f* data, const cMapInfo& mi)
 469 |     {
 470 |         int width = 2 * height;
 471 |         int stride = width;
 472 | 
 473 |         float da = vl_pi / height;
 474 |         float phi = vl_pi - 0.5f * da;
 475 | 
 476 |         data += (height - 1) * stride;
 477 | 
 478 |         for (int i = 0; i < height; i++)
 479 |         {
 480 |             Vec3f* row = data;
 481 | 
 482 |             float theta = 0.5f * da;
 483 |             float sp = sinf(phi);
 484 |             float cp = cosf(phi);
 485 | 
 486 |             for (int j = 0; j < width; j++)
 487 |             {
 488 |                 float st = sinf(theta);
 489 |                 float ct = cosf(theta);
 490 | 
 491 |                 // middle of image is north, east to right, west to left, edges are south
 492 |                 Vec3f dir(-st * sp, -ct * sp, cp);
 493 | 
 494 |                 row[j] = sunSky.SkyRGB(dir) * mi.weight;
 495 |                 theta += da;
 496 |             }
 497 | 
 498 |             data -= stride;
 499 |             phi -= da;
 500 |         }
 501 |     }
 502 | 
 503 |     const float kMinAutoLum    = 2000.0f;
 504 |     const float kAutoLumTarget = 0.4f;
 505 | }
 506 | 
 507 | 
 508 | 
 509 | //------------------------------------------------------------------------------
 510 | // Main program
 511 | //------------------------------------------------------------------------------
 512 | 
 513 | namespace
 514 | {
 515 |     struct cEnumInfo
 516 |     {
 517 |         const char* mName;
 518 |         const char* mShort;
 519 |         int         mValue;
 520 |     };
 521 | 
 522 |     cEnumInfo kSkyTypeEnum[] =
 523 |     {
 524 |         "Preetham",         "pt",   kPreetham,
 525 |         "PreethamTable",    "ptt",  kPreethamTable,
 526 |         "PreethamBRDF",     "ptb",  kPreethamBRDF,
 527 |         "Hosek",            "hk",   kHosek,
 528 |         "HosekTable",       "hkt",  kHosekTable,
 529 |         "HosekBRDF",        "hkb",  kHosekBRDF,
 530 |         "cieClear",         "cc",   kCIEClear,
 531 |         "cieOvercast",      "co",   kCIEOvercast,
 532 |         "ciePartlyCloudy",  "cp",   kCIEPartlyCloudy,
 533 |         nullptr, nullptr, 0
 534 |     };
 535 | 
 536 |     cEnumInfo kToneMapTypeEnum[] =
 537 |     {
 538 |         "linear",       "l",   kToneMapLinear,
 539 |         "exponential",  "ex",  kToneMapExponential,
 540 |         "reinhard",     "rh",  kToneMapReinhard,
 541 |         nullptr, nullptr, 0
 542 |     };
 543 | 
 544 |     int ArgEnum(const cEnumInfo info[], const char* name, int defaultValue = -1)
 545 |     {
 546 |         for ( ; info->mName; info++)
 547 |             if (strcasecmp(info->mName, name) == 0 || strcasecmp(info->mShort, name) == 0)
 548 |             {
 549 |                 return info->mValue;
 550 |                 break;
 551 |             }
 552 | 
 553 |         return defaultValue;
 554 |     }
 555 | 
 556 |     int Help(const char* command)
 557 |     {
 558 |         printf
 559 |         (
 560 |             "%s <options>\n"
 561 |             "\n"
 562 |             "Options:\n"
 563 |             "  -h : this help\n"
 564 |             "  -s <skyType> : use given sky type (default: Preetham.)\n"
 565 |             "  -t <time>          : 0 - 24\n"
 566 |             "  -d <day of year>   : 0 - 365\n"
 567 |             "  -b <turbidity>     : 2 - 12\n"
 568 |             "  -x <l>|<r g b>     : 0 - 1, specify ground albedo for Hosek\n"
 569 |             "  -r <roughness>     : 0 - 1, specify roughness for BRDF types\n"
 570 |             "  -l <latitude> <longitude>\n"
 571 |             "  -w <luminance scale>\n"
 572 |             "  -g <gamma>\n"
 573 |             "  -e <tonemapType> : use given tonemap operator (default: linear)\n"
 574 |             "  -a : autoscale intensity\n"
 575 |             "  -i : invert hemisphere\n"
 576 |             "  -f : fisheye rather than cos projection\n"
 577 |             "  -c : output cubemap instead\n"
 578 |             "  -p : output panorama instead\n"
 579 |             "  -m : output movie, record day as sky.mp4, requires ffmpeg\n"
 580 |             "  -v : verbose\n"
 581 |             , command
 582 |         );
 583 | 
 584 |         printf("\n" "skyType:\n");
 585 |         for (const cEnumInfo* info = kSkyTypeEnum; info->mName; info++)
 586 |             printf("  %-16s (%s)\n", info->mName, info->mShort);
 587 | 
 588 |         printf("\n" "toneMapType:\n");
 589 |         for (const cEnumInfo* info = kToneMapTypeEnum; info->mName; info++)
 590 |             printf("  %-16s (%s)\n", info->mName, info->mShort);
 591 | 
 592 |         return 0;
 593 |     }
 594 | }
 595 | 
 596 | int main(int argc, const char* argv[])
 597 | {
 598 |     const char* command = argv[0];
 599 |     argv++; argc--; // chomp
 600 | 
 601 |     if (argc == 0)
 602 |         return Help(command);
 603 | 
 604 |     // Set up defaults
 605 |     time_t unixTime;
 606 |     ::time(&unixTime);
 607 | 
 608 |     struct tm* theTime = localtime(&unixTime);
 609 | 
 610 |     int julianDay = theTime->tm_yday;
 611 | 
 612 |     float localTime = theTime->tm_hour + theTime->tm_min / 60.0f + theTime->tm_sec / 3600.0f;
 613 |     bool dst = (theTime->tm_isdst != 0);
 614 |     Vec2f latLong   = kLondon;
 615 |     float turbidity = 2.5;
 616 |     Vec3f albedo    = vl_0;
 617 |     float overcast  = 0.0f;
 618 | 
 619 |     cMapInfo mi;
 620 |     mi.weight = -1.0f;
 621 | 
 622 |     float roughness = -1.0f;
 623 |     bool autoscale  = false;
 624 |     bool cubeMap    = false;
 625 |     bool panoramic  = false;
 626 |     bool movie      = false;
 627 |     bool verbose    = false;
 628 |     tSkyType skyType = kPreetham;
 629 | 
 630 |     // Options
 631 |     while (argc > 0 && argv[0][0] == '-')
 632 |     {
 633 |         const char* option = argv[0] + 1;
 634 |         argv++; argc--;
 635 | 
 636 |         switch (option[0])
 637 |         {
 638 |         case 'h':
 639 |         case '?':
 640 |             return Help(command);
 641 | 
 642 |         case 't':
 643 |             if (ArgCountError(option, 1, argc))
 644 |                 return -1;
 645 |             localTime = (float) atof(argv[0]);
 646 |             argv++; argc--;
 647 |             break;
 648 | 
 649 |         case 'd':
 650 |             if (ArgCountError(option, 1, argc))
 651 |                 return -1;
 652 |             julianDay = atoi(argv[0]);
 653 |             argv++; argc--;
 654 |             break;
 655 | 
 656 |         case 'b':
 657 |             if (ArgCountError(option, 1, argc))
 658 |                 return -1;
 659 |             turbidity = (float) atof(argv[0]);
 660 |             argv++; argc--;
 661 |             break;
 662 | 
 663 |         case 'o':
 664 |             overcast = (float) atof(argv[0]);
 665 |             argv++; argc--;
 666 |             break;
 667 | 
 668 |         case 'x':
 669 |             if (ArgCountError(option, 1, argc))
 670 |                 return -1;
 671 |             albedo.x = (float) atof(argv[0]);
 672 |             argv++; argc--;
 673 | 
 674 |             if (argc >= 1 && argv[0][0] != '-')
 675 |             {
 676 |                 albedo.y = (float) atof(argv[0]);
 677 |                 argv++; argc--;
 678 |             }
 679 |             else
 680 |                 albedo.y = albedo.x;
 681 | 
 682 |             if (argc >= 1 && argv[0][0] != '-')
 683 |             {
 684 |                 albedo.z = (float) atof(argv[0]);
 685 |                 argv++; argc--;
 686 |             }
 687 |             else
 688 |                 albedo.z = albedo.y;
 689 | 
 690 |             break;
 691 | 
 692 |         case 'l':
 693 |             if (ArgCountError(option, 2, argc))
 694 |                 return -1;
 695 |             latLong[0] = (float) atof(argv[0]);
 696 |             argv++; argc--;
 697 |             latLong[1] = (float) atof(argv[0]);
 698 |             argv++; argc--;
 699 | 
 700 |             dst = false;    // don't take dst from local time info
 701 |             break;
 702 | 
 703 |         case 'w':
 704 |             if (ArgCountError(option, 1, argc))
 705 |                 return -1;
 706 |             mi.weight = (float) atof(argv[0]);
 707 |             argv++; argc--;
 708 | 
 709 |             break;
 710 | 
 711 |         case 'g':
 712 |             if (ArgCountError(option, 1, argc))
 713 |                 return -1;
 714 |             mi.gamma = (float) atof(argv[0]);
 715 |             argv++; argc--;
 716 |             break;
 717 | 
 718 |         case 'a':
 719 |             autoscale = !autoscale;
 720 |             break;
 721 |         case 'c':
 722 |             cubeMap = !cubeMap;
 723 |             break;
 724 |         case 'p':
 725 |             panoramic = !panoramic;
 726 |             break;
 727 |         case 'm':
 728 |             movie = !movie;
 729 |             break;
 730 |         case 'i':
 731 |             mi.hemiSign = -mi.hemiSign;
 732 |             break;
 733 |         case 'f':
 734 |             mi.fisheye = !mi.fisheye;
 735 |             break;
 736 |         case 'v':
 737 |             verbose = !verbose;
 738 |             break;
 739 | 
 740 |         case 's':
 741 |             {
 742 |                 if (ArgCountError(option, 1, argc))
 743 |                     return -1;
 744 | 
 745 |                 const char* typeName = argv[0];
 746 |                 argv++; argc--;
 747 | 
 748 |                 skyType = (tSkyType) ArgEnum(kSkyTypeEnum, typeName, kNumSkyTypes);
 749 | 
 750 |                 if (skyType == kNumSkyTypes)
 751 |                 {
 752 |                     fprintf(stderr, "Unknown sky type: %s\n", typeName);
 753 |                     return -1;
 754 |                 }
 755 |             }
 756 |             break;
 757 | 
 758 |         case 'e':
 759 |             {
 760 |                 if (ArgCountError(option, 1, argc))
 761 |                     return -1;
 762 | 
 763 |                 const char* typeName = argv[0];
 764 |                 argv++; argc--;
 765 | 
 766 |                 mi.toneMap = kToneMapFuncs[ArgEnum(kToneMapTypeEnum, typeName, kNumToneMapTypes)];
 767 | 
 768 |                 if (!mi.toneMap)
 769 |                 {
 770 |                     fprintf(stderr, "Unknown tone map type: %s\n", typeName);
 771 |                     return -1;
 772 |                 }
 773 |             }
 774 |             break;
 775 | 
 776 |         case 'r':
 777 |             if (ArgCountError(option, 1, argc))
 778 |                 return -1;
 779 |             roughness = saturate((float) atof(argv[0]));
 780 |             argv++; argc--;
 781 |             break;
 782 | 
 783 | 
 784 |         default:
 785 |             fprintf(stderr, "Unrecognised option: %s\n", option);
 786 |             return -1;
 787 |         }
 788 |     }
 789 | 
 790 |     if (argc > 0)
 791 |     {
 792 |         fprintf(stderr, "Unrecognised arguments starting with %s\n", argv[0]);
 793 |         return -1;
 794 |     }
 795 | 
 796 |     float timeZone = rintf(latLong[1] / 15.0f);    // estimate for now
 797 | 
 798 |     if (dst)
 799 |         timeZone += 1.0;
 800 | 
 801 |     Vec3f sunDir = SunDirection(localTime, timeZone, julianDay, latLong[0], latLong[1]);
 802 | 
 803 |     cSunSky sunSky;
 804 |     sunSky.SetSkyType(skyType);
 805 | 
 806 |     sunSky.SetSunDir(sunDir);
 807 |     sunSky.SetTurbidity(turbidity);
 808 |     sunSky.SetAlbedo(albedo);
 809 |     sunSky.SetOvercast(overcast);
 810 | 
 811 |     if (roughness >= 0.0f)
 812 |         sunSky.SetRoughness(roughness);
 813 | 
 814 |     sunSky.Update();
 815 | 
 816 |     if (verbose)
 817 |     {
 818 |         printf("Time: %g, time zone: %g, day: %d, latitude: %g, longitude: %g, turbidity: %g, albedo: %g\n", localTime, timeZone, julianDay, latLong[0], latLong[1], turbidity, albedo.y);
 819 | 
 820 |         float theta = asinf (sunDir.z);
 821 |         float phi   = atan2f(sunDir.y, sunDir.x);
 822 | 
 823 |         theta *= 180.0f / vl_pi;
 824 |         phi   *= 180.0f / vl_pi;
 825 | 
 826 |         phi   = 90.0f - phi;    // make relative to North rather than East, and clockwise.
 827 | 
 828 |         if (phi < 0.0f)
 829 |             phi += 360.0f;
 830 | 
 831 |         printf("Sun elevation      : %g\n", theta);
 832 |         printf("Sun compass heading: %g\n", phi  );
 833 |     }
 834 | 
 835 |     if (mi.weight < 0.0f)
 836 |         switch (skyType)
 837 |         {
 838 |         case kHosek:
 839 |         case kHosekTable:
 840 |         case kHosekBRDF:
 841 |             mi.weight = 8e-5f;
 842 |             break;
 843 |         default:
 844 |             mi.weight = 5e-5f;
 845 |         }
 846 | 
 847 |     if (!movie && autoscale)
 848 |     {
 849 |         float avgLum = sunSky.AverageLuminance();
 850 | 
 851 |         if (verbose)
 852 |             printf("Average luminance: %g\n", avgLum);
 853 | 
 854 |         // Once we get dark enough (sun below horizon), stop auto-scaling, so we don't snap to black
 855 |         if (avgLum < kMinAutoLum)
 856 |             avgLum = kMinAutoLum;
 857 | 
 858 |         float lumScale = kAutoLumTarget / avgLum;
 859 | 
 860 |         if (verbose)
 861 |             printf("Autoscaling luminance by: %g\n", lumScale);
 862 | 
 863 |         mi.weight = lumScale;
 864 |     }
 865 | 
 866 |     if (verbose)
 867 |         printf("Ouput: weight = %g, gamma = %g\n", mi.weight, mi.gamma);
 868 | 
 869 |     char fileName[32];
 870 | 
 871 |     if (panoramic)
 872 |     {
 873 |         uint32_t image   [256][512];
 874 |         Vec3f    imageHDR[256][512];
 875 | 
 876 |         SkyToPanoramic(sunSky, 256, (uint8_t*) image, 0, mi);
 877 | 
 878 |         snprintf(fileName, 32, "sky-panoramic.png");
 879 | 
 880 |         if (stbi_write_png(fileName, 512, 256, 4, image[0], 0) != 0)
 881 |             printf("wrote %s\n", fileName);
 882 |         else
 883 |             printf("failed to write %s\n", fileName);
 884 | 
 885 |         SkyToPanoramic(sunSky, 256, imageHDR[0], mi);
 886 | 
 887 |         snprintf(fileName, 32, "sky-panoramic.pfm");
 888 | 
 889 |         if (PFMWrite(fileName, 512, 256, imageHDR[0]))
 890 |             printf("wrote %s\n", fileName);
 891 |         else
 892 |             printf("failed to write %s\n", fileName);
 893 |     }
 894 |     else if (cubeMap)
 895 |     {
 896 |         uint32_t image   [256][256];
 897 |         Vec3f    imageHDR[256][256];
 898 | 
 899 |         for (int i = 0; i < 6; i++)
 900 |         {
 901 |             SkyToCubeFace(sunSky, i, 256, 256, (uint8_t*) image, 4 * 256, mi);
 902 | 
 903 |             snprintf(fileName, 32, "sky-cube-%d.png", i);
 904 | 
 905 |             if (stbi_write_png(fileName, 256, 256, 4, image[0], 0) != 0)
 906 |                 printf("wrote %s\n", fileName);
 907 |             else
 908 |                 printf("failed to write %s\n", fileName);
 909 | 
 910 |             SkyToCubeFace(sunSky, i, 256, 256, imageHDR[0], mi);
 911 | 
 912 |             snprintf(fileName, 32, "sky-cube-%d.pfm", i);
 913 | 
 914 |             if (PFMWrite(fileName, 256, 256, imageHDR[0]))
 915 |                 printf("wrote %s\n", fileName);
 916 |             else
 917 |                 printf("failed to write %s\n", fileName);
 918 |         }
 919 |     }
 920 | #ifndef _MSC_VER
 921 |     else if (movie)
 922 |     {
 923 |         uint32_t image[256][256];
 924 | 
 925 |         // crf = constant rate factor, 0 - 51, 0 is lossless, 51 worst
 926 |         // -preset = veryfast/faster/fast/medium/slow/slower/veryslow
 927 |         const char* cmd = "/usr/local/bin/ffmpeg -r 60 -f rawvideo -pix_fmt rgba -s 256x256 -i - -threads 0 -preset medium -y -pix_fmt yuv420p -crf 10 sky.mp4";
 928 | 
 929 |         // open pipe to ffmpeg's stdin in binary write mode
 930 |         FILE* ffmpeg = popen(cmd, "w");
 931 | 
 932 |         if (!ffmpeg)
 933 |         {
 934 |             perror("cmd");
 935 |             return -1;
 936 |         }
 937 | 
 938 |         for (float time = 6.0f; time <= 21.0f; time += 0.1f)
 939 |         {
 940 |             sunSky.SetSunDir(SunDirection(time, timeZone, julianDay, latLong[0], latLong[1]));
 941 |             sunSky.Update();
 942 | 
 943 |             if (autoscale)
 944 |             {
 945 |                 float avgLum = sunSky.AverageLuminance();
 946 | 
 947 |                 if (verbose)
 948 |                     printf("Average luminance: %g\n", avgLum);
 949 | 
 950 |                 // Once we get dark enough (sun below horizon), stop auto-scaling, so we don't snap to black
 951 |                 if (avgLum < kMinAutoLum)
 952 |                     avgLum = kMinAutoLum;
 953 | 
 954 |                 float lumScale = kAutoLumTarget / avgLum;
 955 | 
 956 |                 if (verbose)
 957 |                     printf("Autoscaling luminance by: %g\n", lumScale);
 958 | 
 959 |                 mi.weight = lumScale;
 960 |             }
 961 | 
 962 |             SkyToHemisphere(sunSky, 256, 256, (uint8_t*) image, 1024, mi);
 963 | 
 964 |             fwrite(image, sizeof(image), 1, ffmpeg);
 965 |         }
 966 | 
 967 |         if (pclose(ffmpeg) == 0)
 968 |             printf("wrote sky.mp4\n");
 969 |         else
 970 |             printf("failed to write sky.mp4\n");
 971 |     }
 972 | #endif
 973 |     else
 974 |     {
 975 |         uint32_t image   [256][256];
 976 |         Vec3f    imageHDR[256][256];
 977 | 
 978 |         SkyToHemisphere(sunSky, 256, 256, (uint8_t*) image, 1024, mi);
 979 | 
 980 |         snprintf(fileName, 32, "sky-hemi.png");
 981 | 
 982 |         if (stbi_write_png(fileName, 256, 256, 4, image[0], 0) != 0)
 983 |             printf("wrote %s\n", fileName);
 984 |         else
 985 |             printf("failed to write %s\n", fileName);
 986 | 
 987 |         cStats stats;
 988 |         SkyToHemisphere(sunSky, 256, 256, imageHDR[0], mi, verbose ? &stats : nullptr);
 989 | 
 990 |         snprintf(fileName, 32, "sky-hemi.pfm");
 991 | 
 992 |         if (PFMWrite(fileName, 256, 256, imageHDR[0]))
 993 |             printf("wrote %s\n", fileName);
 994 |         else
 995 |             printf("failed to write %s\n", fileName);
 996 | 
 997 |         if (verbose)
 998 |         {
 999 |             printf("avg: %8.2f, %8.2f, %8.2f\n", stats.avg.x, stats.avg.y, stats.avg.z);
1000 |             printf("max: %8.2f, %8.2f, %8.2f\n", stats.max.x, stats.max.y, stats.max.z);
1001 |             printf("dev: %8.2f, %8.2f, %8.2f\n", stats.dev.x, stats.dev.y, stats.dev.z);
1002 |         }
1003 |     }
1004 | 
1005 |     return 0;
1006 | }
1007 | 


--------------------------------------------------------------------------------
/VL234f.h:
--------------------------------------------------------------------------------
   1 | // VL234 monolithic header
   2 | 
   3 | 
   4 | typedef float Real;
   5 | 
   6 | #ifdef VL_DEBUG
   7 |     #include <assert.h>
   8 | 
   9 |     #define CL_ASSERT(M_X) assert(M_X);
  10 |     #define CL_ASSERT_MSG(M_X, M_MSG) assert(M_X);
  11 |     #define CL_ERROR(M_MSG) assert(false);
  12 |     #define CL_WARNING(M_X)
  13 |     #define CL_WARNING_MSG(M_X, M_MSG)
  14 |     #define CL_EXPECT(M_X) assert(M_X)
  15 |     #define CL_EXPECT_MSG(M_X, M_MSG) assert(M_X)
  16 |     #define CL_RANGE(M_X, M_0, M_1) assert((M_X) >= M_0 && (M_X) < M_1)
  17 |     #define CL_RANGE_MSG(M_X, M_0, M_1, M_MSG) assert((M_X) >= M_0 && (M_X) < M_1)
  18 |     #define CL_INDEX(M_X, M_N) assert((M_X) >= 0 && (M_X) < M_N)
  19 |     #define CL_INDEX_MSG(M_X, M_N, M_MSG) assert((M_X) >= 0 && (M_X) < M_N)
  20 | #else
  21 |     #define CL_ASSERT(M_X)
  22 | 
  23 |     #define CL_ASSERT_MSG(M_X, M_MSG)
  24 | 
  25 |     #define CL_ERROR(M_X)
  26 | 
  27 |     #define CL_WARNING(M_X)
  28 |     #define CL_WARNING_MSG(M_X, M_MSG)
  29 |     #define CL_EXPECT(M_X) (void) (M_X)
  30 |     #define CL_EXPECT_MSG(M_X, M_MSG) (void) (M_X)
  31 | 
  32 |     #define CL_RANGE(M_X, M_0, M_1)
  33 | 
  34 |     #define CL_RANGE_MSG(M_X, M_0, M_1, M_MSG)
  35 |     #define CL_INDEX(M_X, M_N)
  36 |     #define CL_INDEX_MSG(M_X, M_N, M_MSG)
  37 | #endif
  38 | 
  39 | 
  40 | #ifndef VL_NEW
  41 |     #define VL_NEW new
  42 | 
  43 |     #define VL_DELETE delete
  44 | 
  45 | #endif
  46 | #ifndef VL_RESTRICT
  47 |     #define VL_RESTRICT
  48 | #endif
  49 | 
  50 | /*
  51 |     File:       VLConstants.h
  52 | 
  53 |     Function:   Contains various constants for VL.
  54 | 
  55 |     Copyright:  Andrew Willmott
  56 | */
  57 | 
  58 | #ifndef VLConstants_H
  59 | #define VLConstants_H
  60 | 
  61 | #include <cmath>
  62 | #include <cstdint>
  63 | 
  64 | 
  65 | // --- Mathematical constants -------------------------------------------------
  66 | 
  67 | const Real          vl_pi        = Real(3.14159265358979323846);
  68 | const Real          vl_halfPi    = Real(vl_pi / 2.0);
  69 | const Real          vl_quarterPi = Real(vl_pi / 4.0);
  70 | const Real          vl_twoPi     = Real(2.0 * vl_pi);
  71 | 
  72 | #ifdef HUGE_VAL
  73 |     const Real vl_inf = Real(HUGE_VAL);
  74 | #endif
  75 | 
  76 | enum    ZeroOrOne   { vl_zero = 0, vl_0 = 0, vl_one = 1, vl_I = 1, vl_1 = 1 };
  77 | enum    Block       { vl_Z = 0, vl_B = 1, vl_block = 1 };
  78 | enum    Axis        { vl_x, vl_y, vl_z, vl_w };
  79 | typedef Axis        vl_axis;
  80 | 
  81 | const uint32_t      VL_REF_FLAG = uint32_t(1) << (sizeof(uint32_t) * 8 - 1);
  82 | const uint32_t      VL_REF_MASK = (~VL_REF_FLAG);
  83 | enum                { VL_SV_END = -1 };
  84 | const uint32_t      VL_SV_MAX_INDEX = (1 << 30);
  85 | const int           VL_MAX_STEPS = 10000;
  86 | 
  87 | #endif
  88 | /*
  89 |     File:           VLMath.h
  90 | 
  91 |     Function:       Various math definitions for VL
  92 |                     
  93 |     Copyright:      Andrew Willmott
  94 |  */
  95 | 
  96 | #ifndef VL_MATH_H
  97 | #define VL_MATH_H
  98 | 
  99 | #include <stdlib.h>
 100 | 
 101 | // --- Inlines ----------------------------------------------------------------
 102 | 
 103 | // additions to arithmetic functions
 104 | 
 105 | #ifdef VL_HAS_IEEEFP
 106 |     #include <ieeefp.h>
 107 |     #define vl_is_finite(X) finite(X)
 108 | #elif defined (__GNUC__) && defined(VL_USE_MISC)
 109 |     #define vl_is_finite(X) finite(X)
 110 | #else
 111 |     #define vl_is_finite(X) (1)
 112 | #endif
 113 | 
 114 | #ifdef VL_HAS_DRAND
 115 |     inline double vl_rand()
 116 |     { return drand48()); }
 117 |     inline double vl_srand(Uint seed)
 118 |     { srand48(seed); }
 119 | #else
 120 |     inline double vl_rand()
 121 |     { return rand() / (RAND_MAX + 1.0); }
 122 |     inline void vl_srand(uint32_t seed)
 123 |     { srand(seed); }
 124 | #endif
 125 | 
 126 | inline float len(float x)
 127 | { return (fabsf(x)); }
 128 | inline double len(double x)
 129 | { return (fabs(x)); }
 130 | 
 131 | template<class T_Value> inline T_Value sqr(T_Value x)
 132 | { return x * x; }
 133 | 
 134 | template<class T_Value> inline T_Value cube(T_Value x)
 135 | { return x * x * x; }
 136 | 
 137 | inline float sqrlen(float r)
 138 | { return sqr(r); }
 139 | inline double sqrlen(double r)
 140 | { return sqr(r); }
 141 | 
 142 | inline float lerp(float a, float b, float s)
 143 | { return (1.0f - s) * a + s * b; }
 144 | inline double lerp(double a, double b, double s)
 145 | { return (1.0 - s) * a + s * b; }
 146 | 
 147 | template<class T_Value> inline T_Value lerp(T_Value x, T_Value y, Real s)
 148 | { return x + (y - x) * s; }
 149 |     
 150 | template<> inline float lerp<float>(float x, float y, Real s)
 151 | { return float(x + (y - x) * s); }
 152 | 
 153 | template<class T> inline T vl_min(T a, T b)
 154 | {
 155 |     return a < b ? a : b;
 156 | }
 157 | 
 158 | template<class T> inline T vl_max(T a, T b)
 159 | {
 160 |     return a > b ? a : b;
 161 | }
 162 | 
 163 | inline double sign(double d)
 164 | {
 165 |     if (d < 0)
 166 |         return -1.0;
 167 |     else
 168 |         return +1.0;
 169 | }
 170 | 
 171 | inline double sinc(double x) 
 172 | {
 173 |     if (fabs(x) < 1.0e-6) 
 174 |         return 1.0;
 175 |     else 
 176 |         return sin(x) / x;
 177 | }
 178 | 
 179 | inline float sincf(float x) 
 180 | {
 181 |     if (fabsf(x) < 1.0e-6f) 
 182 |         return 1.0f;
 183 |     else 
 184 |         return sinf(x) / x;
 185 | }
 186 | 
 187 | #ifndef VL_HAVE_SINCOS
 188 |     inline void sincosf(double phi, double* sinv, double* cosv)
 189 |     {
 190 |         *sinv = sin(phi);
 191 |         *cosv = cos(phi);
 192 |     }
 193 |     inline void sincosf(float phi, float* sinv, float* cosv)
 194 |     {
 195 |         *sinv = sinf(phi);
 196 |         *cosv = cosf(phi);
 197 |     }
 198 | #endif
 199 | 
 200 | template<class T_Value> inline T_Value clip(T_Value x, T_Value min, T_Value max)
 201 | {
 202 |     if (x <= min)
 203 |         return min;
 204 |     else if (x >= max)
 205 |         return max;
 206 |     else
 207 |         return x;
 208 | }
 209 | 
 210 | // useful routines
 211 | 
 212 | inline void SetReal(float& a, double b)
 213 | { a = float(b); }
 214 | inline void SetReal(double& a, double b)
 215 | { a = b; }
 216 | 
 217 | template <class S, class T> inline void ConvertVec(const S& u, T& v)
 218 | {
 219 |     for (int i = 0; i < u.Elts(); i++)
 220 |         v[i] = u[i];
 221 | }
 222 | 
 223 | template <class T> inline void ConvertVec(const T& u, T& v)
 224 | { v = u; }
 225 | 
 226 | template <class S, class T> inline void ConvertMat(const S& m, T& n)
 227 | {
 228 |     for (int i = 0; i < m.Rows(); i++)
 229 |         ConvertVec(m[i], n[i]);
 230 | }
 231 | 
 232 | template <class T> inline void ConvertMat(const T& m, T& n)
 233 | { n = m; }
 234 | 
 235 | 
 236 | #endif
 237 | 
 238 | /*
 239 |     File:           VLVec2.h
 240 | 
 241 |     Function:       Defines a length-2 vector.
 242 |                     
 243 |     Copyright:      Andrew Willmott
 244 |  */
 245 | 
 246 | #ifndef VL_Vec2_H
 247 | #define VL_Vec2_H
 248 | 
 249 | 
 250 | 
 251 | 
 252 | // --- Vec2 Class -------------------------------------------------------------
 253 | 
 254 | 
 255 | class Vec2f
 256 | {
 257 | public:
 258 | 
 259 |     // Constructors
 260 |     Vec2f();
 261 |     Vec2f(float x, float y);      // (x, y)
 262 |     Vec2f(const Vec2f& v);          // Copy constructor
 263 |     Vec2f(ZeroOrOne k);             // v[i] = vl_zero
 264 |     Vec2f(Axis k);                  // v[k] = 1
 265 |     explicit Vec2f(float s);
 266 |     explicit Vec2f(const float v[]);
 267 | 
 268 |     // Accessor functions
 269 |     int           Elts() const { return 2; };   // Element count
 270 | 
 271 |     float&       operator [] (int i);          // Indexing by row
 272 |     const float& operator [] (int i) const;    // Indexing by row
 273 | 
 274 |     float*       Ref();                        // Return pointer to data
 275 |     const float* Ref() const;                  // Return pointer to data
 276 | 
 277 |     // Assignment operators
 278 |     Vec2f&    operator =  (const Vec2f& a);                      
 279 |     Vec2f&    operator =  (ZeroOrOne k);                     
 280 |     Vec2f&    operator =  (Axis k);                      
 281 |     
 282 |     Vec2f&    operator += (const Vec2f& a);
 283 |     Vec2f&    operator -= (const Vec2f& a);
 284 |     Vec2f&    operator *= (const Vec2f& a);
 285 |     Vec2f&    operator *= (float s);
 286 |     Vec2f&    operator /= (const Vec2f& a);
 287 |     Vec2f&    operator /= (float s);
 288 | 
 289 |     // Comparison operators
 290 |     bool     operator == (const Vec2f& a) const; // v == a?
 291 |     bool     operator != (const Vec2f& a) const; // v != a?
 292 | 
 293 |     // Arithmetic operators
 294 |     Vec2f    operator + (const Vec2f& a) const;  // v + a
 295 |     Vec2f    operator - (const Vec2f& a) const;  // v - a
 296 |     Vec2f    operator - () const;                // -v
 297 |     Vec2f    operator * (const Vec2f& a) const;  // v * a (vx * ax, ...)
 298 |     Vec2f    operator * (float s) const;        // v * s
 299 |     Vec2f    operator / (const Vec2f& a) const;  // v / a (vx / ax, ...)
 300 |     Vec2f    operator / (float s) const;        // v / s
 301 | 
 302 |     // Initialisers
 303 |     Vec2f&    MakeZero();                        // Zero vector
 304 |     Vec2f&    MakeUnit(int i, float k = vl_one);// I[i]
 305 |     Vec2f&    MakeBlock(float k = vl_one);      // All-k vector
 306 |     
 307 |     Vec2f&    Normalize();                       // normalize vector
 308 | 
 309 |     // Data
 310 |     float  x;
 311 |     float  y;
 312 | };
 313 | 
 314 | 
 315 | // --- Vec operators ----------------------------------------------------------
 316 | 
 317 | Vec2f    operator * (float s, const Vec2f& v);// s * v
 318 | 
 319 | float   dot      (const Vec2f& a, const Vec2f& b); // v . a
 320 | float   len      (const Vec2f& v);                 // || v ||
 321 | float   sqrlen   (const Vec2f& v);                 // v . v
 322 | Vec2f    norm     (const Vec2f& v);                 // v / || v ||
 323 | Vec2f    norm_safe(const Vec2f& v);                 // v / || v ||, handles || v || = 0
 324 | Vec2f    cross    (const Vec2f& v);                 // cross prod.
 325 | Vec2f    inv      (const Vec2f& v);                 // inverse: 1 / v
 326 | Vec2f    abs      (const Vec2f& v);                 // abs(v_i)
 327 | 
 328 |     
 329 | // --- Inlines ----------------------------------------------------------------
 330 | 
 331 | 
 332 | inline float& Vec2f::operator [] (int i)
 333 | {
 334 |     CL_RANGE_MSG(i, 0, 2, "(Vec2::[i]) index out of range");
 335 |     return (&x)[i];
 336 | }
 337 | 
 338 | inline const float& Vec2f::operator [] (int i) const
 339 | {
 340 |     CL_RANGE_MSG(i, 0, 2, "(Vec2::[i]) index out of range");
 341 |     return (&x)[i];
 342 | }
 343 | 
 344 | inline Vec2f::Vec2f()
 345 | {
 346 | }
 347 | 
 348 | inline Vec2f::Vec2f(float x_in, float y_in) :
 349 |     x(x_in),
 350 |     y(y_in)
 351 | {}
 352 | 
 353 | inline Vec2f::Vec2f(const Vec2f& v) :
 354 |     x(v.x),
 355 |     y(v.y)
 356 | {}
 357 | 
 358 | inline Vec2f::Vec2f(float s) :
 359 |     x(s),
 360 |     y(s)
 361 | {
 362 | }
 363 | 
 364 | inline Vec2f::Vec2f(const float v[]) :
 365 |     x(v[0]),
 366 |     y(v[1])
 367 | {
 368 | }
 369 | 
 370 | inline float* Vec2f::Ref()
 371 | {
 372 |     return &x;
 373 | }
 374 | 
 375 | inline const float* Vec2f::Ref() const
 376 | {
 377 |     return &x;
 378 | }
 379 | 
 380 | inline Vec2f& Vec2f::operator = (const Vec2f& v)
 381 | {
 382 |     x = v.x;
 383 |     y = v.y;
 384 |     
 385 |     return *this;
 386 | }
 387 | 
 388 | inline Vec2f& Vec2f::operator += (const Vec2f& v)
 389 | {
 390 |     x += v.x;
 391 |     y += v.y;
 392 |     
 393 |     return *this;
 394 | }
 395 | 
 396 | inline Vec2f& Vec2f::operator -= (const Vec2f& v)
 397 | {
 398 |     x -= v.x;
 399 |     y -= v.y;
 400 |     
 401 |     return *this;
 402 | }
 403 | 
 404 | inline Vec2f& Vec2f::operator *= (const Vec2f& v)
 405 | {
 406 |     x *= v.x;
 407 |     y *= v.y;
 408 |     
 409 |     return *this;
 410 | }
 411 | 
 412 | inline Vec2f& Vec2f::operator *= (float s)
 413 | {
 414 |     x *= s;
 415 |     y *= s;
 416 |     
 417 |     return *this;
 418 | }
 419 | 
 420 | inline Vec2f& Vec2f::operator /= (const Vec2f& v)
 421 | {
 422 |     x /= v.x;
 423 |     y /= v.y;
 424 |     
 425 |     return *this;
 426 | }
 427 | 
 428 | inline Vec2f& Vec2f::operator /= (float s)
 429 | {
 430 |     x /= s;
 431 |     y /= s;
 432 |     
 433 |     return *this;
 434 | }
 435 | 
 436 | inline Vec2f Vec2f::operator + (const Vec2f& a) const
 437 | {
 438 |     Vec2f result;
 439 |     
 440 |     result.x = x + a.x;
 441 |     result.y = y + a.y;
 442 |     
 443 |     return result;
 444 | }
 445 | 
 446 | inline Vec2f Vec2f::operator - (const Vec2f& a) const
 447 | {
 448 |     Vec2f result;
 449 |     
 450 |     result.x = x - a.x;
 451 |     result.y = y - a.y;
 452 |     
 453 |     return result;
 454 | }
 455 | 
 456 | inline Vec2f Vec2f::operator - () const
 457 | {
 458 |     Vec2f result;
 459 |     
 460 |     result.x = -x;
 461 |     result.y = -y;
 462 |     
 463 |     return result;
 464 | }
 465 | 
 466 | inline Vec2f Vec2f::operator * (const Vec2f& a) const           
 467 | {
 468 |     Vec2f result;
 469 |     
 470 |     result.x = x * a.x;
 471 |     result.y = y * a.y;
 472 |     
 473 |     return result;
 474 | }
 475 | 
 476 | inline Vec2f Vec2f::operator * (float s) const
 477 | {
 478 |     Vec2f result;
 479 |     
 480 |     result.x = x * s;
 481 |     result.y = y * s;
 482 |     
 483 |     return result;
 484 | }
 485 | 
 486 | inline Vec2f operator * (float s, const Vec2f& v)
 487 | {
 488 |     return v * s;
 489 | }
 490 | 
 491 | inline Vec2f Vec2f::operator / (const Vec2f& a) const
 492 | {
 493 |     Vec2f result;
 494 |     
 495 |     result.x = x / a.x;
 496 |     result.y = y / a.y;
 497 |     
 498 |     return result;
 499 | }
 500 | 
 501 | inline Vec2f Vec2f::operator / (float s) const
 502 | {
 503 |     Vec2f result;
 504 |     
 505 |     result.x = x / s;
 506 |     result.y = y / s;
 507 |     
 508 |     return result;
 509 | }
 510 | 
 511 | inline float dot(const Vec2f& a, const Vec2f& b)
 512 | {
 513 |     return a.x * b.x + a.y * b.y;
 514 | }
 515 | 
 516 | inline Vec2f cross(const Vec2f& a)
 517 | {
 518 |     Vec2f result;
 519 |     
 520 |     result.x = -a.y;
 521 |     result.y =  a.x;
 522 |     
 523 |     return result;
 524 | }
 525 | 
 526 | inline float len(const Vec2f& v)
 527 | {
 528 |     return sqrt(dot(v, v));
 529 | }
 530 | 
 531 | inline float sqrlen(const Vec2f& v)
 532 | {
 533 |     return dot(v, v);
 534 | }
 535 | 
 536 | inline Vec2f norm(const Vec2f& v)   
 537 | {
 538 |     CL_ASSERT_MSG(sqrlen(v) > float(vl_zero), "normalising length-zero vector");
 539 |     return v / len(v);
 540 | }
 541 | 
 542 | inline Vec2f norm_safe(const Vec2f& v)   
 543 | {
 544 |     return v / (len(v) + float(1e-8));
 545 | }
 546 | 
 547 | inline Vec2f inv(const Vec2f& v)
 548 | {
 549 |     return Vec2f(float(1) / v.x, float(1) / v.y);
 550 | }
 551 | 
 552 | inline Vec2f abs(const Vec2f& v) 
 553 | {
 554 |     return Vec2f(abs(v.x), abs(v.y));
 555 | }
 556 | 
 557 | inline Vec2f& Vec2f::MakeUnit(int i, float k)
 558 | {
 559 |     if (i == 0)
 560 |     { x = k; y = vl_zero; }
 561 |     else if (i == 1)
 562 |     { x = vl_zero; y = k; }
 563 |     else 
 564 |         CL_ERROR("(Vec2::Unit) illegal unit vector");
 565 | 
 566 |     return *this;
 567 | }
 568 | 
 569 | inline Vec2f& Vec2f::MakeZero()
 570 | {
 571 |     x = vl_zero; y = vl_zero;
 572 |     return *this;
 573 | }
 574 | 
 575 | inline Vec2f& Vec2f::MakeBlock(float k)
 576 | {
 577 |     x = k; y = k;
 578 |     return *this;
 579 | }
 580 | 
 581 | inline Vec2f& Vec2f::Normalize()
 582 | {
 583 |     CL_ASSERT_MSG(sqrlen(*this) > float(vl_zero), "normalising length-zero vector");
 584 |     *this /= len(*this);
 585 |     return *this;
 586 | }
 587 | 
 588 | 
 589 | inline Vec2f::Vec2f(ZeroOrOne k) 
 590 | {
 591 |     x = float(k);
 592 |     y = float(k);
 593 | }
 594 | 
 595 | inline Vec2f::Vec2f(Axis k) 
 596 | {
 597 |     MakeUnit(k, vl_one);
 598 | }
 599 | 
 600 | inline Vec2f& Vec2f::operator = (ZeroOrOne k)
 601 | {
 602 |     x = float(k); y = float(k);
 603 |     
 604 |     return *this;
 605 | }
 606 | 
 607 | inline Vec2f& Vec2f::operator = (Axis k)
 608 | {
 609 |     MakeUnit(k, vl_1);
 610 |     
 611 |     return *this;
 612 | }
 613 | 
 614 | inline bool Vec2f::operator == (const Vec2f& a) const
 615 | {
 616 |     return x == a.x && y == a.y;
 617 | }
 618 | 
 619 | inline bool Vec2f::operator != (const Vec2f& a) const
 620 | {
 621 |     return x != a.x || y != a.y;
 622 | }
 623 | 
 624 | #endif
 625 | 
 626 | /*
 627 |     File:           VLVec3.h
 628 | 
 629 |     Function:       Defines a length-3 vector.
 630 |                     
 631 |     Copyright:      Andrew Willmott
 632 |  */
 633 | 
 634 | #ifndef VL_Vec3_H
 635 | #define VL_Vec3_H
 636 | 
 637 | 
 638 |  
 639 |  
 640 | // --- Vec3 Class -------------------------------------------------------------
 641 | 
 642 | 
 643 | class Vec2f;
 644 | 
 645 | class Vec3f
 646 | {
 647 | public:
 648 |     // Constructors
 649 |     Vec3f();
 650 |     Vec3f(float x, float y, float z);// [x, y, z]
 651 |     Vec3f(const Vec3f& v);              // Copy constructor
 652 |     Vec3f(const Vec2f& v, float w);    // Hom. 2D vector
 653 |     Vec3f(ZeroOrOne k);
 654 |     Vec3f(Axis a);
 655 |     explicit Vec3f(float s);
 656 |     explicit Vec3f(const float v[]);
 657 |     
 658 |     // Accessor functions
 659 |     int           Elts() const { return 3; };   // Element count
 660 | 
 661 |     float&       operator [] (int i);          // Indexing by row
 662 |     const float& operator [] (int i) const;    // Indexing by row
 663 | 
 664 |     float*       Ref();                        // Return pointer to data
 665 |     const float* Ref() const;                  // Return pointer to data
 666 | 
 667 |     // Assignment operators
 668 |     Vec3f&    operator =  (const Vec3f& a);
 669 |     Vec3f&    operator =  (ZeroOrOne k);
 670 |     Vec3f&    operator += (const Vec3f& a);
 671 |     Vec3f&    operator -= (const Vec3f& a);
 672 |     Vec3f&    operator *= (const Vec3f& a);
 673 |     Vec3f&    operator *= (float s);
 674 |     Vec3f&    operator /= (const Vec3f& a);
 675 |     Vec3f&    operator /= (float s);
 676 |     
 677 |     // Comparison operators
 678 |     bool      operator == (const Vec3f& a) const; // v == a?
 679 |     bool      operator != (const Vec3f& a) const; // v != a?
 680 |     bool      operator <  (const Vec3f& a) const; // v <  a?
 681 |     bool      operator >= (const Vec3f& a) const; // v >= a?
 682 | 
 683 |     // Arithmetic operators
 684 |     Vec3f     operator + (const Vec3f& a) const;  // v + a
 685 |     Vec3f     operator - (const Vec3f& a) const;  // v - a
 686 |     Vec3f     operator - () const;                // -v
 687 |     Vec3f     operator * (const Vec3f& a) const;  // v * a (vx * ax, ...)
 688 |     Vec3f     operator * (float s) const;        // v * s
 689 |     Vec3f     operator / (const Vec3f& a) const;  // v / a (vx / ax, ...)
 690 |     Vec3f     operator / (float s) const;        // v / s    
 691 | 
 692 |     // Initialisers
 693 |     Vec3f&    MakeZero();                        // Zero vector
 694 |     Vec3f&    MakeUnit(int i, float k = vl_one);// I[i]
 695 |     Vec3f&    MakeBlock(float k = vl_one);      // All-k vector
 696 | 
 697 |     Vec3f&    Normalize();                       // normalize vector
 698 | 
 699 |     // Conversion
 700 |     Vec2f&          AsVec2();
 701 |     const Vec2f&    AsVec2() const;
 702 | 
 703 |     // Data
 704 |     float x;
 705 |     float y;
 706 |     float z;
 707 | };
 708 | 
 709 | 
 710 | // --- Vec operators ----------------------------------------------------------
 711 | 
 712 | Vec3f    operator * (float s, const Vec3f& v); // s * v
 713 | float   dot(const Vec3f& a, const Vec3f& b);   // v . a
 714 | 
 715 | float   len      (const Vec3f& v);             // || v ||
 716 | float   sqrlen   (const Vec3f& v);             // v . v
 717 | Vec3f    norm     (const Vec3f& v);             // v / || v ||
 718 | Vec3f    norm_safe(const Vec3f& v);             // v / || v ||, handles || v || = 0
 719 | Vec3f    cross    (const Vec3f& a, const Vec3f& b); // a x b
 720 | Vec3f    cross_x  (const Vec3f& v);             // v x e_x
 721 | Vec3f    cross_y  (const Vec3f& v);             // v x e_y
 722 | Vec3f    cross_z  (const Vec3f& v);             // v x e_z
 723 | Vec3f    inv      (const Vec3f& v);             // inverse: 1 / v
 724 | Vec2f    proj     (const Vec3f& v);             // homogeneous projection
 725 | Vec3f    abs      (const Vec3f& v);             // abs(v_i)
 726 | 
 727 | 
 728 | // --- Inlines ----------------------------------------------------------------
 729 | 
 730 | 
 731 | 
 732 | inline float& Vec3f::operator [] (int i)
 733 | {
 734 |     CL_RANGE_MSG(i, 0, 3, "(Vec3::[i]) index out of range");
 735 |     return (&x)[i];
 736 | }
 737 | 
 738 | inline const float& Vec3f::operator [] (int i) const
 739 | {
 740 |     CL_RANGE_MSG(i, 0, 3, "(Vec3::[i]) index out of range");
 741 |     return (&x)[i];
 742 | }
 743 | 
 744 | inline Vec3f::Vec3f()
 745 | {
 746 | }
 747 | 
 748 | inline Vec3f::Vec3f(float x_in, float y_in, float z_in) :
 749 |     x(x_in),
 750 |     y(y_in),
 751 |     z(z_in)
 752 | {}
 753 | 
 754 | inline Vec3f::Vec3f(const Vec3f& v)  :
 755 |     x(v.x),
 756 |     y(v.y),
 757 |     z(v.z)
 758 | {}
 759 | 
 760 | inline Vec3f::Vec3f(const Vec2f& v, float z_in) :
 761 |     x(v.x),
 762 |     y(v.y),
 763 |     z(z_in)
 764 | {}
 765 | 
 766 | inline Vec3f::Vec3f(float s) :
 767 |     x(s),
 768 |     y(s),
 769 |     z(s)
 770 | {}
 771 | 
 772 | inline Vec3f::Vec3f(const float v[]) :
 773 |     x(v[0]),
 774 |     y(v[1]),
 775 |     z(v[2])
 776 | {}
 777 | 
 778 | inline float* Vec3f::Ref()
 779 | {
 780 |     return &x;
 781 | }
 782 | 
 783 | inline const float* Vec3f::Ref() const
 784 | {
 785 |     return &x;
 786 | }
 787 | 
 788 | inline Vec3f& Vec3f::operator = (const Vec3f& v)
 789 | {
 790 |     x = v.x;
 791 |     y = v.y;
 792 |     z = v.z;
 793 |     
 794 |     return *this;
 795 | }
 796 | 
 797 | inline Vec3f& Vec3f::operator += (const Vec3f& v)
 798 | {
 799 |     x += v.x;
 800 |     y += v.y;
 801 |     z += v.z;
 802 |     
 803 |     return *this;
 804 | }
 805 | 
 806 | inline Vec3f& Vec3f::operator -= (const Vec3f& v)
 807 | {
 808 |     x -= v.x;
 809 |     y -= v.y;
 810 |     z -= v.z;
 811 |     
 812 |     return *this;
 813 | }
 814 | 
 815 | inline Vec3f& Vec3f::operator *= (const Vec3f& a)
 816 | {
 817 |     x *= a.x;
 818 |     y *= a.y;
 819 |     z *= a.z;
 820 |     
 821 |     return *this;
 822 | }
 823 | 
 824 | inline Vec3f& Vec3f::operator *= (float s)
 825 | {
 826 |     x *= s;
 827 |     y *= s;
 828 |     z *= s;
 829 |     
 830 |     return *this;
 831 | }
 832 | 
 833 | inline Vec3f& Vec3f::operator /= (const Vec3f& a)
 834 | {
 835 |     x /= a.x;
 836 |     y /= a.y;
 837 |     z /= a.z;
 838 |     
 839 |     return *this;
 840 | }
 841 | 
 842 | inline Vec3f& Vec3f::operator /= (float s)
 843 | {
 844 |     x /= s;
 845 |     y /= s;
 846 |     z /= s;
 847 |     
 848 |     return *this;
 849 | }
 850 | 
 851 | inline Vec3f Vec3f::operator + (const Vec3f& a) const
 852 | {
 853 |     Vec3f result;
 854 |     
 855 |     result.x = x + a.x;
 856 |     result.y = y + a.y;
 857 |     result.z = z + a.z;
 858 |     
 859 |     return result;
 860 | }
 861 | 
 862 | inline Vec3f Vec3f::operator - (const Vec3f& a) const
 863 | {
 864 |     Vec3f result;
 865 |     
 866 |     result.x = x - a.x;
 867 |     result.y = y - a.y;
 868 |     result.z = z - a.z;
 869 |     
 870 |     return result;
 871 | }
 872 | 
 873 | inline Vec3f Vec3f::operator - () const
 874 | {
 875 |     Vec3f result;
 876 |     
 877 |     result.x = -x;
 878 |     result.y = -y;
 879 |     result.z = -z;
 880 |     
 881 |     return result;
 882 | }
 883 | 
 884 | inline Vec3f Vec3f::operator * (const Vec3f& a) const
 885 | {
 886 |     Vec3f result;
 887 |     
 888 |     result.x = x * a.x;
 889 |     result.y = y * a.y;
 890 |     result.z = z * a.z;
 891 |     
 892 |     return result;
 893 | }
 894 | 
 895 | inline Vec3f Vec3f::operator * (float s) const
 896 | {
 897 |     Vec3f result;
 898 |     
 899 |     result.x = x * s;
 900 |     result.y = y * s;
 901 |     result.z = z * s;
 902 |     
 903 |     return result;
 904 | }
 905 | 
 906 | inline Vec3f Vec3f::operator / (const Vec3f& a) const
 907 | {
 908 |     Vec3f result;
 909 |     
 910 |     result.x = x / a.x;
 911 |     result.y = y / a.y;
 912 |     result.z = z / a.z;
 913 |     
 914 |     return result;
 915 | }
 916 | 
 917 | inline Vec3f Vec3f::operator / (float s) const
 918 | {
 919 |     Vec3f result;
 920 |     
 921 |     result.x = x / s;
 922 |     result.y = y / s;
 923 |     result.z = z / s;
 924 |     
 925 |     return result;
 926 | }
 927 | 
 928 | inline Vec3f operator * (float s, const Vec3f& v)
 929 | {
 930 |     return v * s;
 931 | }
 932 | 
 933 | inline Vec3f& Vec3f::MakeUnit(int n, float k)
 934 | {
 935 |     switch (n)
 936 |     {
 937 |     case 0:
 938 |         { x = k; y = vl_zero; z = vl_zero; } break;
 939 |     case 1:
 940 |         { x = vl_zero; y = k; z = vl_zero; } break;
 941 |     case 2:
 942 |         { x = vl_zero; y = vl_zero; z = k; } break;
 943 |     default:
 944 |         CL_ERROR("(Vec3::Unit) illegal unit vector");
 945 |     }
 946 | 
 947 |     return *this;
 948 | }
 949 | 
 950 | inline Vec3f& Vec3f::MakeZero()
 951 | {
 952 |     x = vl_zero; y = vl_zero; z = vl_zero;
 953 |     return *this;
 954 | }
 955 | 
 956 | inline Vec3f& Vec3f::MakeBlock(float k)
 957 | {
 958 |     x = k; y = k; z = k;
 959 |     return *this;
 960 | }
 961 | 
 962 | inline Vec3f& Vec3f::Normalize()
 963 | {
 964 |     CL_ASSERT_MSG(sqrlen(*this) > vl_zero, "normalising length-zero vector");
 965 |     *this /= len(*this);
 966 |     return *this;
 967 | }
 968 | 
 969 | 
 970 | inline Vec3f::Vec3f(ZeroOrOne k) 
 971 | {
 972 |     x = float(k); y = float(k); z = float(k);
 973 | }
 974 | 
 975 | inline Vec3f& Vec3f::operator = (ZeroOrOne k)
 976 | {
 977 |     x = float(k); y = float(k); z = float(k);
 978 |     
 979 |     return *this;
 980 | }
 981 | 
 982 | inline Vec3f::Vec3f(Axis a)
 983 | {
 984 |     MakeUnit(a, vl_one);
 985 | }
 986 | 
 987 | 
 988 | inline bool Vec3f::operator == (const Vec3f& a) const
 989 | {
 990 |     return x == a.x && y == a.y && z == a.z;
 991 | }
 992 | 
 993 | inline bool Vec3f::operator != (const Vec3f& a) const
 994 | {
 995 |     return x != a.x || y != a.y || z != a.z;
 996 | }
 997 | 
 998 | inline bool Vec3f::operator < (const Vec3f& a) const
 999 | {
1000 |     return x < a.x && y < a.y && z < a.z;
1001 | }
1002 | 
1003 | inline bool Vec3f::operator >= (const Vec3f& a) const
1004 | {
1005 |     return x >= a.x && y >= a.y && z >= a.z;
1006 | }
1007 | 
1008 | inline Vec2f& Vec3f::AsVec2()
1009 | {
1010 |     return (Vec2f&) *this;
1011 | }
1012 | 
1013 | inline const Vec2f& Vec3f::AsVec2() const
1014 | {
1015 |     return (const Vec2f&) *this;
1016 | }
1017 | 
1018 | 
1019 | inline float dot(const Vec3f& a, const Vec3f& b)
1020 | {
1021 |     return a.x * b.x + a.y * b.y + a.z * b.z;
1022 | }
1023 | 
1024 | inline float len(const Vec3f& v)
1025 | {
1026 |     return sqrt(dot(v, v));
1027 | }
1028 | 
1029 | inline float sqrlen(const Vec3f& v)
1030 | {
1031 |     return dot(v, v);
1032 | }
1033 | 
1034 | inline Vec3f norm(const Vec3f& v)   
1035 | {
1036 |     CL_ASSERT_MSG(sqrlen(v) > float(vl_zero), "normalising length-zero vector");
1037 |     return v / len(v);
1038 | }
1039 | 
1040 | inline Vec3f norm_safe(const Vec3f& v)
1041 | {
1042 |     return v / (len(v) + float(1e-8));
1043 | }
1044 | 
1045 | inline Vec3f cross(const Vec3f& a, const Vec3f& b)
1046 | {
1047 |     Vec3f result;
1048 | 
1049 |     result.x = a.y * b.z - a.z * b.y;
1050 |     result.y = a.z * b.x - a.x * b.z;
1051 |     result.z = a.x * b.y - a.y * b.x;
1052 | 
1053 |     return result;
1054 | }
1055 | 
1056 | inline Vec3f cross_x(const Vec3f& v)
1057 | { return Vec3f(float(vl_zero), v.z, -v.y); }
1058 | 
1059 | inline Vec3f cross_y(const Vec3f& v)
1060 | { return Vec3f(-v.z, float(vl_zero), v.x); }
1061 | 
1062 | inline Vec3f cross_z(const Vec3f& v)
1063 | { return Vec3f(v.y, -v.x, float(vl_zero)); }
1064 | 
1065 | inline Vec3f inv(const Vec3f& v)
1066 | {
1067 |     return Vec3f(float(1) / v.x, float(1) / v.y, float(1) / v.z);
1068 | }
1069 | 
1070 | inline Vec2f proj(const Vec3f& v) 
1071 | {
1072 |     Vec2f result;
1073 |     
1074 |     CL_ASSERT_MSG(v.z != float(vl_zero), "(Vec3/proj) last elt. is zero");
1075 |     
1076 |     result.x = v.x / v.z;
1077 |     result.y = v.y / v.z;
1078 |     
1079 |     return result;
1080 | }
1081 | 
1082 | inline Vec3f abs(const Vec3f& v) 
1083 | {
1084 |     return Vec3f(abs(v.x), abs(v.y), abs(v.z));
1085 | }
1086 | 
1087 | #endif
1088 | 
1089 | /*
1090 |     File:           VLVec4.h
1091 | 
1092 |     Function:       Defines a length-4 vector.
1093 |                     
1094 |     Copyright:      Andrew Willmott
1095 |  */
1096 | 
1097 | #ifndef VL_Vec4_H
1098 | #define VL_Vec4_H
1099 | 
1100 | 
1101 | 
1102 | 
1103 | // --- Vec4 Class -------------------------------------------------------------
1104 | 
1105 | 
1106 | class Vec2f;
1107 | class Vec3f;
1108 | 
1109 | class Vec4f
1110 | {
1111 | public:
1112 |     // Constructors
1113 |     Vec4f();
1114 |     Vec4f(float x, float y, float z, float w);  // [x, y, z, w]
1115 |     Vec4f(const Vec4f& v);                      // Copy constructor
1116 |     Vec4f(const Vec3f& v, float w);            // Hom. 3D vector
1117 |     Vec4f(ZeroOrOne k);
1118 |     Vec4f(Axis k);
1119 |     explicit Vec4f(float s);
1120 |     explicit Vec4f(const float v[]);
1121 |     
1122 |     // Accessor functions
1123 |     int           Elts() const { return 4; };   // Element count
1124 | 
1125 |     float&       operator [] (int i);          // Indexing by row
1126 |     const float& operator [] (int i) const;    // Indexing by row
1127 | 
1128 |     float*       Ref();                        // Return pointer to data
1129 |     const float* Ref() const;                  // Return pointer to data
1130 | 
1131 |     // Assignment operators
1132 |     Vec4f&        operator =  (const Vec4f& a);  
1133 |     Vec4f&        operator =  (ZeroOrOne k);
1134 |     Vec4f&        operator =  (Axis k);
1135 |     Vec4f&        operator += (const Vec4f& a);
1136 |     Vec4f&        operator -= (const Vec4f& a);
1137 |     Vec4f&        operator *= (const Vec4f& a);
1138 |     Vec4f&        operator *= (float s);
1139 |     Vec4f&        operator /= (const Vec4f& a);
1140 |     Vec4f&        operator /= (float s);
1141 |     
1142 |     // Comparison operators
1143 |     bool          operator == (const Vec4f& a) const; // v == a ?
1144 |     bool          operator != (const Vec4f& a) const; // v != a ?
1145 | 
1146 |     // Arithmetic operators
1147 |     Vec4f         operator + (const Vec4f& a) const;  // v + a
1148 |     Vec4f         operator - (const Vec4f& a) const;  // v - a
1149 |     Vec4f         operator - () const;                // -v
1150 |     Vec4f         operator * (const Vec4f& a) const;  // v * a (vx * ax, ...)
1151 |     Vec4f         operator * (float s) const;        // v * s
1152 |     Vec4f         operator / (const Vec4f& a) const;  // v / a (vx / ax, ...)
1153 |     Vec4f         operator / (float s) const;        // v / s
1154 | 
1155 |     // Initialisers
1156 |     Vec4f&        MakeZero();                        // Zero vector
1157 |     Vec4f&        MakeUnit(int i, float k = vl_one);// kI[i]
1158 |     Vec4f&        MakeBlock(float k = vl_one);      // All-k vector
1159 | 
1160 |     Vec4f&        Normalize();                       // normalize vector
1161 | 
1162 |     // Conversion
1163 |     Vec2f&          AsVec2();
1164 |     const Vec2f&    AsVec2() const;
1165 |     Vec3f&          AsVec3();
1166 |     const Vec3f&    AsVec3() const;
1167 | 
1168 |     // Data
1169 |     float x;
1170 |     float y;
1171 |     float z;
1172 |     float w;
1173 | };
1174 | 
1175 | 
1176 | // --- Vec operators ----------------------------------------------------------
1177 | 
1178 | Vec4f   operator * (float s, const Vec4f& v);  // Left mult. by s
1179 | float  dot  (const Vec4f& a, const Vec4f& b);  // v . a
1180 | Vec4f   cross(const Vec4f& a, const Vec4f& b, const Vec4f& c); // 4D cross prod.
1181 | 
1182 | float  len      (const Vec4f& v);              // || v ||
1183 | float  sqrlen   (const Vec4f& v);              // v . v
1184 | Vec4f   norm     (const Vec4f& v);              // v / || v ||
1185 | Vec4f   norm_safe(const Vec4f& v);              // v / || v ||, handles || v || = 0
1186 | Vec4f   inv      (const Vec4f& v);              // 1 / v
1187 | Vec3f   proj     (const Vec4f& v);              // hom. projection
1188 | Vec4f   abs      (const Vec4f& v);              // abs(v_i)
1189 | 
1190 | void    normalize(Vec4f& v);                    // v = norm(v)
1191 | 
1192 | 
1193 | // --- Inlines ----------------------------------------------------------------
1194 | 
1195 | 
1196 | 
1197 | inline float& Vec4f::operator [] (int i)
1198 | {
1199 |     CL_RANGE_MSG(i, 0, 4, "(Vec4::[i]) index out of range");
1200 |     return (&x)[i];
1201 | }
1202 | 
1203 | inline const float& Vec4f::operator [] (int i) const
1204 | {
1205 |     CL_RANGE_MSG(i, 0, 4, "(Vec4::[i]) index out of range");
1206 |     return (&x)[i];
1207 | }
1208 | 
1209 | 
1210 | inline Vec4f::Vec4f()
1211 | {
1212 | }
1213 | 
1214 | inline Vec4f::Vec4f(float x_in, float y_in, float z_in, float w_in) :
1215 |     x(x_in),
1216 |     y(y_in),
1217 |     z(z_in),
1218 |     w(w_in)
1219 | {}
1220 | 
1221 | inline Vec4f::Vec4f(const Vec4f& v) :
1222 |     x(v.x),
1223 |     y(v.y),
1224 |     z(v.z),
1225 |     w(v.w)
1226 | {}
1227 | 
1228 | inline Vec4f::Vec4f(const Vec3f& v, float w_in) :
1229 |     x(v.x),
1230 |     y(v.y),
1231 |     z(v.z),
1232 |     w(w_in)
1233 | {
1234 | }
1235 | 
1236 | inline Vec4f::Vec4f(float s) :
1237 |     x(s),
1238 |     y(s),
1239 |     z(s),
1240 |     w(s)
1241 | {}
1242 | 
1243 | inline Vec4f::Vec4f(const float v[]) :
1244 |     x(v[0]),
1245 |     y(v[1]),
1246 |     z(v[2]),
1247 |     w(v[3])
1248 | {
1249 | }
1250 | 
1251 | inline float* Vec4f::Ref()
1252 | {
1253 |     return &x;
1254 | }
1255 | 
1256 | inline const float* Vec4f::Ref() const
1257 | {
1258 |     return &x;
1259 | }
1260 | 
1261 | inline Vec4f& Vec4f::operator = (const Vec4f& v)
1262 | {
1263 |     x = v.x;
1264 |     y = v.y;
1265 |     z = v.z;
1266 |     w = v.w;
1267 |     
1268 |     return *this;
1269 | }
1270 | 
1271 | inline Vec4f& Vec4f::operator += (const Vec4f& v)
1272 | {
1273 |     x += v.x;
1274 |     y += v.y;
1275 |     z += v.z;
1276 |     w += v.w;
1277 |     
1278 |     return *this;
1279 | }
1280 | 
1281 | inline Vec4f& Vec4f::operator -= (const Vec4f& v)
1282 | {
1283 |     x -= v.x;
1284 |     y -= v.y;
1285 |     z -= v.z;
1286 |     w -= v.w;
1287 |     
1288 |     return *this;
1289 | }
1290 | 
1291 | inline Vec4f& Vec4f::operator *= (const Vec4f& v)
1292 | {
1293 |     x *= v.x;
1294 |     y *= v.y;
1295 |     z *= v.z;
1296 |     w *= v.w;
1297 |     
1298 |     return *this;
1299 | }
1300 | 
1301 | inline Vec4f& Vec4f::operator *= (float s)
1302 | {
1303 |     x *= s;
1304 |     y *= s;
1305 |     z *= s;
1306 |     w *= s;
1307 |     
1308 |     return *this;
1309 | }
1310 | 
1311 | inline Vec4f& Vec4f::operator /= (const Vec4f& v)
1312 | {
1313 |     x /= v.x;
1314 |     y /= v.y;
1315 |     z /= v.z;
1316 |     w /= v.w;
1317 |     
1318 |     return *this;
1319 | }
1320 | 
1321 | inline Vec4f& Vec4f::operator /= (float s)
1322 | {
1323 |     x /= s;
1324 |     y /= s;
1325 |     z /= s;
1326 |     w /= s;
1327 |     
1328 |     return *this;
1329 | }
1330 | 
1331 | 
1332 | inline Vec4f Vec4f::operator + (const Vec4f& a) const
1333 | {
1334 |     Vec4f result;
1335 |     
1336 |     result.x = x + a.x;
1337 |     result.y = y + a.y;
1338 |     result.z = z + a.z;
1339 |     result.w = w + a.w;
1340 |     
1341 |     return result;
1342 | }
1343 | 
1344 | inline Vec4f Vec4f::operator - (const Vec4f& a) const
1345 | {
1346 |     Vec4f result;
1347 |     
1348 |     result.x = x - a.x;
1349 |     result.y = y - a.y;
1350 |     result.z = z - a.z;
1351 |     result.w = w - a.w;
1352 |     
1353 |     return result;
1354 | }
1355 | 
1356 | inline Vec4f Vec4f::operator - () const
1357 | {
1358 |     Vec4f result;
1359 |     
1360 |     result.x = -x;
1361 |     result.y = -y;
1362 |     result.z = -z;
1363 |     result.w = -w;
1364 |     
1365 |     return result;
1366 | }
1367 | 
1368 | inline Vec4f Vec4f::operator * (const Vec4f& a) const           
1369 | {
1370 |     Vec4f result;
1371 | 
1372 |     result.x = x * a.x;
1373 |     result.y = y * a.y;
1374 |     result.z = z * a.z;
1375 |     result.w = w * a.w;
1376 |     
1377 |     return result;
1378 | }
1379 | 
1380 | inline Vec4f Vec4f::operator * (float s) const
1381 | {
1382 |     Vec4f result;
1383 |     
1384 |     result.x = x * s;
1385 |     result.y = y * s;
1386 |     result.z = z * s;
1387 |     result.w = w * s;
1388 |     
1389 |     return result;
1390 | }
1391 | 
1392 | inline Vec4f Vec4f::operator / (const Vec4f& a) const
1393 | {
1394 |     Vec4f result;
1395 |     
1396 |     result.x = x / a.x;
1397 |     result.y = y / a.y;
1398 |     result.z = z / a.z;
1399 |     result.w = w / a.w;
1400 |     
1401 |     return result;
1402 | }
1403 | 
1404 | inline Vec4f Vec4f::operator / (float s) const
1405 | {
1406 |     Vec4f result;
1407 |     
1408 |     result.x = x / s;
1409 |     result.y = y / s;
1410 |     result.z = z / s;
1411 |     result.w = w / s;
1412 |     
1413 |     return result;
1414 | }
1415 | 
1416 | inline Vec4f operator * (float s, const Vec4f& v)
1417 | {
1418 |     return v * s;
1419 | }
1420 | 
1421 | inline Vec4f& Vec4f::MakeZero()
1422 | {
1423 |     x = vl_zero; y = vl_zero; z = vl_zero; w = vl_zero;
1424 |     return *this;
1425 | }
1426 | 
1427 | inline Vec4f& Vec4f::MakeBlock(float k)
1428 | {
1429 |     x = k; y = k; z = k; w = k;
1430 |     return *this;
1431 | }
1432 | 
1433 | inline Vec4f& Vec4f::Normalize()
1434 | {
1435 |     CL_ASSERT_MSG(sqrlen(*this) > vl_zero, "normalising length-zero vector");
1436 |     *this /= len(*this);
1437 |     return *this;
1438 | }
1439 | 
1440 | inline Vec4f::Vec4f(ZeroOrOne k)    
1441 | {
1442 |     MakeBlock(float(k));
1443 | }
1444 | 
1445 | inline Vec4f::Vec4f(Axis k)     
1446 | {
1447 |     MakeUnit(k, vl_1);
1448 | }
1449 | 
1450 | inline Vec4f& Vec4f::operator = (ZeroOrOne k)
1451 | {
1452 |     MakeBlock(float(k));
1453 |     
1454 |     return *this;
1455 | }
1456 | 
1457 | inline Vec4f& Vec4f::operator = (Axis k)
1458 | {
1459 |     MakeUnit(k, vl_1);
1460 |     
1461 |     return *this;
1462 | }
1463 | 
1464 | inline Vec2f& Vec4f::AsVec2()
1465 | {
1466 |     return (Vec2f&) *this;
1467 | }
1468 | 
1469 | inline const Vec2f& Vec4f::AsVec2() const
1470 | {
1471 |     return (const Vec2f&) *this;
1472 | }
1473 | 
1474 | inline Vec3f& Vec4f::AsVec3()
1475 | {
1476 |     return (Vec3f&) *this;
1477 | }
1478 | 
1479 | inline const Vec3f& Vec4f::AsVec3() const
1480 | {
1481 |     return (const Vec3f&) *this;
1482 | }
1483 | 
1484 | 
1485 | 
1486 | inline float dot(const Vec4f& a, const Vec4f& b)
1487 | {
1488 |     return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
1489 | }
1490 | 
1491 | inline float len(const Vec4f& v)
1492 | {
1493 |     return sqrt(dot(v, v));
1494 | }
1495 | 
1496 | inline float sqrlen(const Vec4f& v)
1497 | {
1498 |     return dot(v, v);
1499 | }
1500 | 
1501 | inline Vec4f norm(const Vec4f& v)   
1502 | {
1503 |     CL_ASSERT_MSG(sqrlen(v) > vl_zero, "normalising length-zero vector");
1504 |     return v / len(v);
1505 | }
1506 | 
1507 | inline Vec4f norm_safe(const Vec4f& v)   
1508 | {
1509 |     return v / (len(v) + float(1e-8));
1510 | }
1511 | 
1512 | inline Vec4f inv(const Vec4f& v)
1513 | {
1514 |     return Vec4f(float(1) / v.x, float(1) / v.y, float(1) / v.z, float(1) / v.w);
1515 | }
1516 | 
1517 | inline Vec4f abs(const Vec4f& v)
1518 | {
1519 |     return Vec4f(abs(v.x), abs(v.y), abs(v.z), abs(v.w));
1520 | }
1521 | 
1522 | 
1523 | #endif
1524 | 
1525 | /*
1526 |     File:           VLMat2.h
1527 | 
1528 |     Function:       Defines a 2 x 2 matrix.
1529 |                     
1530 |     Copyright:      Andrew Willmott
1531 |  */
1532 | 
1533 | #ifndef VL_Mat2_H
1534 | #define VL_Mat2_H
1535 | 
1536 | 
1537 | 
1538 | 
1539 | 
1540 | // --- Mat2 Class -------------------------------------------------------------
1541 | 
1542 | class Mat2f 
1543 | {
1544 | public:
1545 |     // Constructors
1546 |     Mat2f();
1547 |     Mat2f(float a, float b, float c, float d);
1548 |     Mat2f(const Mat2f& m);
1549 |     Mat2f(const Vec2f& v0, const Vec2f& v1);
1550 |     Mat2f(ZeroOrOne k);
1551 |     Mat2f(Block k);
1552 |     
1553 |     // Accessor functions
1554 |     int           Elts() const { return 4; };
1555 |     int           Rows() const { return 2; };
1556 |     int           Cols() const { return 2; };
1557 |         
1558 |     Vec2f&       operator [] (int i);
1559 |     const Vec2f& operator [] (int i) const;
1560 | 
1561 |     float&       operator () (int i, int j);
1562 |     float        operator () (int i, int j) const;
1563 |     
1564 |     float*       Ref();
1565 |     const float* Ref() const;
1566 | 
1567 |     // Assignment operators
1568 |     Mat2f&        operator =  (const Mat2f& m); 
1569 |     Mat2f&        operator =  (ZeroOrOne k); 
1570 |     Mat2f&        operator =  (Block k); 
1571 |     Mat2f&        operator += (const Mat2f& m);     
1572 |     Mat2f&        operator -= (const Mat2f& m);      
1573 |     Mat2f&        operator *= (const Mat2f& m);      
1574 |     Mat2f&        operator *= (float s);                
1575 |     Mat2f&        operator /= (float s);                
1576 |     
1577 |     // Comparison operators    
1578 |     bool          operator == (const Mat2f& m) const; // M == N?
1579 |     bool          operator != (const Mat2f& m) const; // M != N?
1580 |     
1581 |     // Arithmetic operators    
1582 |     Mat2f         operator + (const Mat2f& m) const;  // M + N
1583 |     Mat2f         operator - (const Mat2f& m) const;  // M - N
1584 |     Mat2f         operator - () const;                // -M
1585 |     Mat2f         operator * (const Mat2f& m) const;  // M * N
1586 |     Mat2f         operator * (float s) const;        // M * s
1587 |     Mat2f         operator / (float s) const;        // M / s
1588 |     
1589 |     // Initialisers
1590 |     void          MakeZero();                         // Zero matrix
1591 |     void          MakeIdentity();                     // Identity matrix
1592 |     void          MakeDiag(float k = vl_one);        // I
1593 |     void          MakeBlock(float k = vl_one);       // all elts=k
1594 |     
1595 |     // Vector Transformations
1596 |     Mat2f&        MakeRot(Real theta);
1597 |     Mat2f&        MakeScale(const Vec2f& s);
1598 | 
1599 |     // Data
1600 |     Vec2f x;
1601 |     Vec2f y;
1602 | };
1603 | 
1604 | 
1605 | // --- Matrix operators -------------------------------------------------------
1606 | 
1607 | 
1608 | Vec2f&  operator *= (Vec2f& v, const Mat2f& m);       // v *= m
1609 | Vec2f   operator *  (const Mat2f& m, const Vec2f& v); // m * v
1610 | Vec2f   operator *  (const Vec2f& v, const Mat2f& m); // v * m
1611 | Mat2f    operator *  (float s, const Mat2f& m);        // s * m
1612 | 
1613 | Mat2f    trans(const Mat2f& m);              // Transpose
1614 | float   trace(const Mat2f& m);              // Trace
1615 | Mat2f    adj  (const Mat2f& m);              // Adjoint
1616 | float   det  (const Mat2f& m);              // Determinant
1617 | Mat2f    inv  (const Mat2f& m);              // Inverse
1618 | Mat2f    abs  (const Mat2f& m);              // abs(m_ij)
1619 | Mat2f    oprod(const Vec2f& a, const Vec2f& b); // Outer product
1620 | 
1621 | // The xform functions help avoid dependence on whether row or column
1622 | // vectors are used to represent points and vectors.
1623 | Vec2f    xform(const Mat2f& m, const Vec2f& v); // Transform of v by m
1624 | Mat2f    xform(const Mat2f& m, const Mat2f& n); // Xform v -> m(n(v))
1625 | 
1626 | 
1627 | // --- Inlines ----------------------------------------------------------------
1628 | 
1629 | 
1630 | inline Mat2f::Mat2f()
1631 | {
1632 | }
1633 | 
1634 | inline Mat2f::Mat2f(float a, float b, float c, float d)
1635 | {
1636 |     x.x = a;  x.y = b;
1637 |     y.x = c;  y.y = d;
1638 | }
1639 | 
1640 | inline Mat2f::Mat2f(const Mat2f& m)
1641 | {
1642 |     x = m.x;
1643 |     y = m.y;
1644 | }
1645 | 
1646 | inline Mat2f::Mat2f(const Vec2f& v0, const Vec2f& v1)
1647 | {
1648 |     x = v0;
1649 |     y = v1;
1650 | }
1651 | 
1652 | inline Vec2f& Mat2f::operator [] (int i)
1653 | {
1654 |     CL_RANGE_MSG(i, 0, 2, "(Mat2::[i]) index out of range");
1655 |     return (&x)[i];
1656 | }
1657 | 
1658 | inline const Vec2f& Mat2f::operator [] (int i) const
1659 | {
1660 |     CL_RANGE_MSG(i, 0, 2, "(Mat2::[i]) index out of range");
1661 |     return (&x)[i];
1662 | }
1663 | 
1664 | inline float& Mat2f::operator () (int i, int j)
1665 | {
1666 |     CL_RANGE_MSG(i, 0, 2, "(Mat2::(i,j)) index out of range");
1667 |     CL_RANGE_MSG(j, 0, 2, "(Mat2::(i,j)) index out of range");
1668 |     
1669 |     return (&x)[i][j];
1670 | }
1671 | 
1672 | inline float Mat2f::operator () (int i, int j) const
1673 | {
1674 |     CL_RANGE_MSG(i, 0, 2, "(Mat2::(i,j)) index out of range");
1675 |     CL_RANGE_MSG(j, 0, 2, "(Mat2::(i,j)) index out of range");
1676 |     
1677 |     return (&x)[i][j];
1678 | }
1679 | 
1680 | inline float* Mat2f::Ref()
1681 | {
1682 |     return &x.x;
1683 | }
1684 | 
1685 | inline const float* Mat2f::Ref() const
1686 | {
1687 |     return &x.x;
1688 | }
1689 | 
1690 | inline void Mat2f::MakeZero()
1691 | {
1692 |     x.x = vl_zero; x.y = vl_zero;
1693 |     y.x = vl_zero; y.y = vl_zero;
1694 | }
1695 | 
1696 | inline void Mat2f::MakeDiag(float k)
1697 | {
1698 |     x.x = k;          x.y = vl_zero;
1699 |     y.x = vl_zero;    y.y = k;
1700 | }
1701 | 
1702 | inline void Mat2f::MakeIdentity()
1703 | {
1704 |     x.x = vl_one;     x.y = vl_zero;
1705 |     y.x = vl_zero;    y.y = vl_one;
1706 | }
1707 | 
1708 | inline void Mat2f::MakeBlock(float k)
1709 | {
1710 |     x.x = k; x.y = k;
1711 |     y.x = k; y.y = k;
1712 | }
1713 | 
1714 | inline Mat2f::Mat2f(ZeroOrOne k)
1715 | {
1716 |     MakeDiag(float(k));
1717 | }
1718 | 
1719 | inline Mat2f::Mat2f(Block k)
1720 | {
1721 |     MakeBlock(float(k));
1722 | }
1723 | 
1724 | inline Mat2f& Mat2f::operator = (ZeroOrOne k)
1725 | {
1726 |     MakeDiag(float(k));
1727 | 
1728 |     return *this;
1729 | }
1730 |       
1731 | inline Mat2f& Mat2f::operator = (Block k)
1732 | {
1733 |     MakeBlock(float(k));
1734 | 
1735 |     return *this;
1736 | }
1737 |       
1738 | inline Mat2f& Mat2f::operator = (const Mat2f& m)
1739 | {
1740 |     x = m.x;
1741 |     y = m.y;
1742 |     
1743 |     return *this;
1744 | }
1745 |       
1746 | inline Mat2f& Mat2f::operator += (const Mat2f& m)
1747 | {
1748 |     x += m.x;
1749 |     y += m.y;
1750 |     
1751 |     return *this;
1752 | }
1753 | 
1754 | inline Mat2f& Mat2f::operator -= (const Mat2f& m)
1755 | {
1756 |     x -= m.x;
1757 |     y -= m.y;
1758 | 
1759 |     return *this;
1760 | }
1761 | 
1762 | inline Mat2f& Mat2f::operator *= (const Mat2f& m)
1763 | {
1764 |     Vec2f t;
1765 |  
1766 |     t = x.x * m.x + x.y * m.y;
1767 |     y = y.x * m.x + y.y * m.y;
1768 |     x = t;
1769 | 
1770 |     return *this;
1771 | }
1772 | 
1773 | inline Mat2f& Mat2f::operator *= (float s)
1774 | {
1775 |     x *= s;
1776 |     y *= s;
1777 | 
1778 |     return *this;
1779 | }
1780 | 
1781 | inline Mat2f& Mat2f::operator /= (float s)
1782 | {
1783 |     x /= s;
1784 |     y /= s;
1785 | 
1786 |     return *this;
1787 | }
1788 | 
1789 | 
1790 | inline Mat2f Mat2f::operator + (const Mat2f& m) const
1791 | {
1792 |     Mat2f result;
1793 |     
1794 |     result.x = x + m.x;
1795 |     result.y = y + m.y;
1796 | 
1797 |     return result; 
1798 | }
1799 | 
1800 | inline Mat2f Mat2f::operator - (const Mat2f& m) const
1801 | {
1802 |     Mat2f result;
1803 |     
1804 |     result.x = x - m.x;
1805 |     result.y = y - m.y;
1806 | 
1807 |     return result; 
1808 | }
1809 | 
1810 | inline Mat2f Mat2f::operator - () const
1811 | {
1812 |     Mat2f result;
1813 |     
1814 |     result.x = -x;
1815 |     result.y = -y;
1816 | 
1817 |     return result; 
1818 | }
1819 | 
1820 | inline Mat2f Mat2f::operator * (const Mat2f& m) const
1821 | {
1822 |     Mat2f result;
1823 | 
1824 |     result.x.x = x.x * m.x.x + x.y * m.y.x;
1825 |     result.x.y = x.x * m.x.y + x.y * m.y.y;
1826 |     result.y.x = y.x * m.x.x + y.y * m.y.x;
1827 |     result.y.y = y.x * m.x.y + y.y * m.y.y;
1828 |     
1829 |     return result;
1830 | }
1831 | 
1832 | inline Mat2f Mat2f::operator * (float s) const
1833 | {
1834 |     Mat2f result;
1835 |     
1836 |     result.x = x * s;
1837 |     result.y = y * s;
1838 | 
1839 |     return result; 
1840 | }
1841 | 
1842 | inline Mat2f Mat2f::operator / (float s) const
1843 | {
1844 |     Mat2f result;
1845 |     
1846 |     result.x = x / s;
1847 |     result.y = y / s;
1848 | 
1849 |     return result; 
1850 | }
1851 | 
1852 | inline Mat2f  operator *  (float s, const Mat2f& m)
1853 | {
1854 |     return m * s;
1855 | }
1856 | 
1857 | inline Vec2f operator * (const Mat2f& m, const Vec2f& v)
1858 | {
1859 |     Vec2f result;
1860 | 
1861 |     result.x = m.x.x * v.x + m.x.y * v.y;
1862 |     result.y = m.y.x * v.x + m.y.y * v.y;
1863 | 
1864 |     return result;
1865 | }
1866 | 
1867 | inline Vec2f operator * (const Vec2f& v, const Mat2f& m)          
1868 | {
1869 |     Vec2f result;
1870 | 
1871 |     result.x = v.x * m.x.x + v.y * m.y.x;
1872 |     result.y = v.x * m.x.y + v.y * m.y.y;
1873 | 
1874 |     return result;
1875 | }
1876 | 
1877 | inline Vec2f& operator *= (Vec2f& v, const Mat2f& m)      
1878 | {
1879 |     float t;
1880 |     
1881 |     t   = v.x * m.x.x + v.y * m.y.x;
1882 |     v.y = v.x * m.x.y + v.y * m.y.y;
1883 |     v.x = t;
1884 | 
1885 |     return v;
1886 | }
1887 | 
1888 | 
1889 | inline Mat2f trans(const Mat2f& m)
1890 | {
1891 |     Mat2f result;
1892 | 
1893 |     result.x.x = m.x.x; result.x.y = m.y.x; 
1894 |     result.y.x = m.x.y; result.y.y = m.y.y; 
1895 |         
1896 |     return result;
1897 | }
1898 | 
1899 | inline float trace(const Mat2f& m)
1900 | {
1901 |     return m.x.x + m.y.y;
1902 | }
1903 |             
1904 | inline Mat2f adj(const Mat2f& m)            
1905 | {
1906 |     Mat2f result;
1907 | 
1908 |     result.x = -cross(m.y);
1909 |     result.y =  cross(m.x);
1910 |             
1911 |     return result;
1912 | }
1913 | 
1914 | #ifdef VL_ROW_ORIENT
1915 | inline Vec2f xform(const Mat2f& m, const Vec2f& v)
1916 | { return v * m; }
1917 | inline Mat2f xform(const Mat2f& m, const Mat2f& n)
1918 | { return n * m; }
1919 | #else
1920 | inline Vec2f xform(const Mat2f& m, const Vec2f& v)
1921 | { return m * v; }
1922 | inline Mat2f xform(const Mat2f& m, const Mat2f& n)
1923 | { return m * n; }
1924 | #endif
1925 | 
1926 | #endif
1927 | 
1928 | /*
1929 |     File:           VLMat3.h
1930 | 
1931 |     Function:       Defines a 3 x 3 matrix.
1932 |                     
1933 |     Copyright:      Andrew Willmott
1934 | */
1935 | 
1936 | #ifndef VL_Mat3_H
1937 | #define VL_Mat3_H
1938 | 
1939 | 
1940 | 
1941 | 
1942 | 
1943 | // --- Mat3 Class -------------------------------------------------------------
1944 | 
1945 | 
1946 | class Vec4f;
1947 | 
1948 | class Mat3f 
1949 | {
1950 | public:
1951 |     // Constructors
1952 |     Mat3f();
1953 |     Mat3f(float a, float b, float c,
1954 |           float d, float e, float f,
1955 |           float g, float h, float i);
1956 |     Mat3f(const Vec3f& v0, const Vec3f& v1, const Vec3f& v2);
1957 |     Mat3f(const Mat3f& m);
1958 |     explicit Mat3f(const Mat2f& m, float scale = float(vl_1));
1959 |     Mat3f(ZeroOrOne k);
1960 |     Mat3f(Block k);
1961 | 
1962 |     // Accessor functions
1963 |     int           Elts() const { return 9; };
1964 |     int           Rows() const { return 3; };
1965 |     int           Cols() const { return 3; };
1966 | 
1967 |     Vec3f&       operator [] (int i);   
1968 |     const Vec3f& operator [] (int i) const;
1969 | 
1970 |     float&       operator () (int i, int j);
1971 |     float        operator () (int i, int j) const;
1972 |     
1973 |     float*       Ref();
1974 |     const float* Ref() const;
1975 | 
1976 |     // Assignment operators
1977 |     Mat3f&        operator =  (const Mat3f& m);      
1978 |     Mat3f&        operator =  (ZeroOrOne k);     
1979 |     Mat3f&        operator =  (Block k);     
1980 |     Mat3f&        operator += (const Mat3f& m);      
1981 |     Mat3f&        operator -= (const Mat3f& m);     
1982 |     Mat3f&        operator *= (const Mat3f& m);     
1983 |     Mat3f&        operator *= (float s);                
1984 |     Mat3f&        operator /= (float s);       
1985 |     
1986 |     // Comparison operators
1987 |     bool         operator == (const Mat3f& m) const; // M == N?
1988 |     bool         operator != (const Mat3f& m) const; // M != N?
1989 |     
1990 |     // Arithmetic operators
1991 |     Mat3f         operator + (const Mat3f& m) const;  // M + N
1992 |     Mat3f         operator - (const Mat3f& m) const;  // M - N
1993 |     Mat3f         operator - () const;                // -M
1994 |     Mat3f         operator * (const Mat3f& m) const;  // M * N
1995 |     Mat3f         operator * (float s) const;        // M * s
1996 |     Mat3f         operator / (float s) const;        // M / s
1997 | 
1998 |     // Initialisers
1999 |     void          MakeZero();                         // Zero matrix
2000 |     void          MakeIdentity();                     // Identity matrix
2001 |     void          MakeDiag(float k = vl_one);        // I
2002 |     void          MakeBlock(float k = vl_one);       // all elts = k
2003 | 
2004 |     // Vector Transforms
2005 |     Mat3f&        MakeRot(const Vec3f& axis, Real theta);
2006 |     Mat3f&        MakeRot(const Vec4f& q);           // Rotate by quaternion
2007 |     Mat3f&        MakeScale(const Vec3f& s);
2008 | 
2009 |     // Homogeneous Transforms
2010 |     Mat3f&        MakeHRot(Real theta);           // Rotate by theta rads
2011 |     Mat3f&        MakeHScale(const Vec2f& s);    // Scale by s
2012 |     Mat3f&        MakeHTrans(const Vec2f& t);    // Translation by t
2013 |     
2014 |     // Data
2015 |     Vec3f x; 
2016 |     Vec3f y; 
2017 |     Vec3f z; 
2018 | };
2019 | 
2020 | 
2021 | // --- Matrix operators -------------------------------------------------------
2022 | 
2023 | Vec3f&  operator *= (Vec3f& v, const Mat3f& m);        // v *= m
2024 | Vec3f   operator * (const Mat3f& m, const Vec3f& v);   // m * v
2025 | Vec3f   operator * (const Vec3f& v, const Mat3f& m);   // v * m
2026 | Mat3f    operator * (const float s, const Mat3f& m);    // s * m
2027 | 
2028 | Mat3f    trans(const Mat3f& m);                   // Transpose            
2029 | float   trace(const Mat3f& m);                   // Trace
2030 | Mat3f    adj  (const Mat3f& m);                   // Adjoint
2031 | float   det  (const Mat3f& m);                   // Determinant
2032 | Mat3f    inv  (const Mat3f& m);                   // Inverse
2033 | Mat3f    abs  (const Mat3f& m);                   // abs(m_ij)
2034 | Mat3f    oprod(const Vec3f& a, const Vec3f& b); // Outer product
2035 | 
2036 | // The xform functions help avoid dependence on whether row or column
2037 | // vectors are used to represent points and vectors.
2038 | Vec3f    xform(const Mat3f& m, const Vec3f& v); // Transform of v by m
2039 | Vec2f    xform(const Mat3f& m, const Vec2f& v); // Hom. xform of v by m
2040 | Mat3f    xform(const Mat3f& m, const Mat3f& n); // Xform v -> m(n(v))
2041 | 
2042 | 
2043 | // --- Inlines ----------------------------------------------------------------
2044 | 
2045 | inline Mat3f::Mat3f()
2046 | {
2047 | }
2048 | 
2049 | inline Mat3f::Mat3f(const Vec3f& v0, const Vec3f& v1, const Vec3f& v2)
2050 | {
2051 |     x = v0;
2052 |     y = v1;
2053 |     z = v2;
2054 | }
2055 | 
2056 | inline Mat3f::Mat3f(const Mat3f& m)
2057 | {
2058 |     x = m.x;
2059 |     y = m.y;
2060 |     z = m.z;
2061 | }
2062 | 
2063 | inline Vec3f& Mat3f::operator [] (int i)
2064 | {
2065 |     CL_RANGE_MSG(i, 0, 3, "(Mat3::[i]) index out of range");
2066 |     return (&x)[i];
2067 | }
2068 | 
2069 | inline const Vec3f& Mat3f::operator [] (int i) const
2070 | {
2071 |     CL_RANGE_MSG(i, 0, 3, "(Mat3::[i]) index out of range");
2072 |     return (&x)[i];
2073 | }
2074 | 
2075 | inline float& Mat3f::operator () (int i, int j)
2076 | {
2077 |     CL_RANGE_MSG(i, 0, 3, "(Mat2::(i,j)) index out of range");
2078 |     CL_RANGE_MSG(j, 0, 3, "(Mat2::(i,j)) index out of range");
2079 |     
2080 |     return (&x)[i][j];
2081 | }
2082 | 
2083 | inline float Mat3f::operator () (int i, int j) const
2084 | {
2085 |     CL_RANGE_MSG(i, 0, 3, "(Mat2::(i,j)) index out of range");
2086 |     CL_RANGE_MSG(j, 0, 3, "(Mat2::(i,j)) index out of range");
2087 |     
2088 |     return (&x)[i][j];
2089 | }
2090 | 
2091 | inline float* Mat3f::Ref()
2092 | {
2093 |     return &x.x;
2094 | }
2095 | 
2096 | inline const float* Mat3f::Ref() const
2097 | {
2098 |     return &x.x;
2099 | }
2100 | 
2101 | inline void Mat3f::MakeZero()
2102 | {
2103 |     x.x = vl_zero; x.y = vl_zero; x.z = vl_zero;
2104 |     y.x = vl_zero; y.y = vl_zero; y.z = vl_zero;
2105 |     z.x = vl_zero; z.y = vl_zero; z.z = vl_zero;
2106 | }
2107 | 
2108 | inline void Mat3f::MakeDiag(float k)
2109 | {
2110 |     x.x = k;          x.y = vl_zero;    x.z = vl_zero;
2111 |     y.x = vl_zero;    y.y = k;          y.z = vl_zero;
2112 |     z.x = vl_zero;    z.y = vl_zero;    z.z = k;
2113 | }
2114 | 
2115 | inline void Mat3f::MakeIdentity()
2116 | {
2117 |     x.x = vl_one;     x.y = vl_zero;    x.z = vl_zero;
2118 |     y.x = vl_zero;    y.y = vl_one;     y.z = vl_zero;
2119 |     z.x = vl_zero;    z.y = vl_zero;    z.z = vl_one;
2120 | }
2121 | 
2122 | inline void Mat3f::MakeBlock(float k)
2123 | {
2124 |     x.x = k; x.y = k; x.z = k;
2125 |     y.x = k; y.y = k; y.z = k;
2126 |     z.x = k; z.y = k; z.z = k;
2127 | }
2128 | 
2129 | 
2130 | inline Mat3f::Mat3f(ZeroOrOne k)
2131 | {
2132 |     MakeDiag(float(k));
2133 | }
2134 | 
2135 | inline Mat3f::Mat3f(Block k)
2136 | {
2137 |     MakeBlock(float(k));
2138 | }
2139 | 
2140 | inline Mat3f& Mat3f::operator = (ZeroOrOne k)
2141 | {
2142 |     MakeDiag(float(k));
2143 | 
2144 |     return *this;
2145 | }
2146 |     
2147 | inline Mat3f& Mat3f::operator = (Block k)
2148 | {
2149 |     MakeBlock(float(k));
2150 | 
2151 |     return *this;
2152 | }
2153 |     
2154 | inline Mat3f operator *  (const float s, const Mat3f& m)
2155 | {
2156 |     return m * s;
2157 | }
2158 | 
2159 | inline Vec3f operator * (const Mat3f& m, const Vec3f& v)
2160 | {
2161 |     Vec3f result;
2162 |     
2163 |     result.x = v.x * m.x.x + v.y * m.x.y + v.z * m.x.z;
2164 |     result.y = v.x * m.y.x + v.y * m.y.y + v.z * m.y.z;
2165 |     result.z = v.x * m.z.x + v.y * m.z.y + v.z * m.z.z;
2166 |     
2167 |     return result;
2168 | }
2169 | 
2170 | inline Vec3f operator * (const Vec3f& v, const Mat3f& m)  
2171 | {
2172 |     Vec3f result;
2173 |     
2174 |     result.x = v.x * m.x.x + v.y * m.y.x + v.z * m.z.x;
2175 |     result.y = v.x * m.x.y + v.y * m.y.y + v.z * m.z.y;
2176 |     result.z = v.x * m.x.z + v.y * m.y.z + v.z * m.z.z;
2177 |     
2178 |     return result;
2179 | }
2180 | 
2181 | inline Vec3f& operator *= (Vec3f& v, const Mat3f& m)          
2182 | {   
2183 |     float t0, t1;
2184 |     
2185 |     t0  = v.x * m.x.x + v.y * m.y.x + v.z * m.z.x;
2186 |     t1  = v.x * m.x.y + v.y * m.y.y + v.z * m.z.y;
2187 |     v.z = v.x * m.x.z + v.y * m.y.z + v.z * m.z.z;
2188 |     v.x = t0;
2189 |     v.y = t1;
2190 | 
2191 |     return v;
2192 | }
2193 | 
2194 | #ifdef VL_ROW_ORIENT
2195 | inline Vec2f xform(const Mat3f& m, const Vec2f& v)
2196 | { return proj(Vec3f(v, 1.0) * m); }
2197 | inline Vec3f xform(const Mat3f& m, const Vec3f& v)
2198 | { return v * m; }
2199 | inline Mat3f xform(const Mat3f& m, const Mat3f& n)
2200 | { return n * m; }
2201 | #else
2202 | inline Vec2f xform(const Mat3f& m, const Vec2f& v)
2203 | { return proj(m * Vec3f(v, 1.0)); }
2204 | inline Vec3f xform(const Mat3f& m, const Vec3f& v)
2205 | { return m * v; }
2206 | inline Mat3f xform(const Mat3f& m, const Mat3f& n)
2207 | { return m * n; }
2208 | #endif
2209 | 
2210 | #endif
2211 | 
2212 | 
2213 | /*
2214 |     File:           VLMat4.h
2215 | 
2216 |     Function:       Defines a 4 x 4 matrix.
2217 |                     
2218 |     Copyright:      Andrew Willmott
2219 |  */
2220 | 
2221 | #ifndef VL_Mat4_H
2222 | #define VL_Mat4_H
2223 | 
2224 | 
2225 | 
2226 | 
2227 | 
2228 | // --- Mat4 Class -------------------------------------------------------------
2229 | 
2230 | class Vec3f;
2231 | 
2232 | class Mat4f 
2233 | {
2234 | public:
2235 |     
2236 |     // Constructors
2237 |     
2238 |     Mat4f();
2239 |     Mat4f(float a, float b, float c, float d,
2240 |           float e, float f, float g, float h,
2241 |           float i, float j, float k, float l,
2242 |           float m, float n, float o, float p);
2243 |     Mat4f(const Vec4f& v0, const Vec4f& v1, const Vec4f& v2, const Vec4f& v3);
2244 |     Mat4f(const Mat4f& m);
2245 |     explicit Mat4f(const Mat3f& m, float scale = float(vl_1));
2246 |     Mat4f(ZeroOrOne k);
2247 |     Mat4f(Block k);
2248 |                     
2249 |     // Accessor functions   
2250 |     int           Elts() const { return 16; };
2251 |     int           Rows() const { return  4; };
2252 |     int           Cols() const { return  4; };
2253 |     
2254 |     Vec4f&       operator [] (int i);
2255 |     const Vec4f& operator [] (int i) const;
2256 | 
2257 |     float&       operator () (int i, int j);
2258 |     float        operator () (int i, int j) const;
2259 |     
2260 |     float*       Ref();
2261 |     const float* Ref() const;
2262 | 
2263 |     // Assignment operators 
2264 |     Mat4f&       operator =  (const Mat4f& m);
2265 |     Mat4f&       operator =  (ZeroOrOne k);
2266 |     Mat4f&       operator =  (Block k);
2267 |     Mat4f&       operator += (const Mat4f& m);
2268 |     Mat4f&       operator -= (const Mat4f& m);
2269 |     Mat4f&       operator *= (const Mat4f& m);
2270 |     Mat4f&       operator *= (float s);
2271 |     Mat4f&       operator /= (float s);
2272 | 
2273 |     // Comparison operators 
2274 |     bool         operator == (const Mat4f& m) const; // M == N?
2275 |     bool         operator != (const Mat4f& m) const; // M != N?
2276 |     
2277 |     // Arithmetic operators 
2278 |     Mat4f        operator + (const Mat4f& m) const;  // M + N
2279 |     Mat4f        operator - (const Mat4f& m) const;  // M - N
2280 |     Mat4f        operator - () const;                // -M
2281 |     Mat4f        operator * (const Mat4f& m) const;  // M * N
2282 |     Mat4f        operator * (float s) const;        // M * s
2283 |     Mat4f        operator / (float s) const;        // M / s
2284 | 
2285 |     // Initialisers 
2286 |     void        MakeZero();                         // Zero matrix
2287 |     void        MakeIdentity();                     // Identity matrix
2288 |     void        MakeDiag(float k = vl_one);        // I
2289 |     void        MakeBlock(float k = vl_one);       // All elts = k
2290 | 
2291 |     // Homogeneous Transforms   
2292 |     Mat4f&      MakeHRot(const Vec3f& axis, Real theta); // Rotate by theta radians about axis   
2293 |     Mat4f&      MakeHRot(const Vec4f& q); // Rotate by quaternion   
2294 |     Mat4f&      MakeHScale(const Vec3f& s);    // Scale by components of s
2295 | 
2296 |     Mat4f&      MakeHTrans(const Vec3f& t);    // Translation by t
2297 | 
2298 |     Mat4f&      Transpose();                    // transpose in place
2299 |     Mat4f&      AddShift(const Vec3f& t);      // concat shift
2300 |     
2301 |     // Data
2302 |     Vec4f x;
2303 |     Vec4f y;
2304 |     Vec4f z;
2305 |     Vec4f w;
2306 | };
2307 | 
2308 | 
2309 | // --- Matrix operators -------------------------------------------------------
2310 | 
2311 | Vec4f   operator *  (const Mat4f& m, const Vec4f& v); // m * v
2312 | Vec4f   operator *  (const Vec4f& v, const Mat4f& m); // v * m
2313 | Vec4f&  operator *= (Vec4f& a, const Mat4f& m);       // v *= m
2314 | Mat4f    operator *  (float s, const Mat4f& m);        // s * m
2315 | 
2316 | Mat4f    trans(const Mat4f& m);              // Transpose            
2317 | float   trace(const Mat4f& m);              // Trace
2318 | Mat4f    adj  (const Mat4f& m);              // Adjoint
2319 | float   det  (const Mat4f& m);              // Determinant
2320 | Mat4f    inv  (const Mat4f& m);              // Inverse
2321 | Mat4f    oprod(const Vec4f& a, const Vec4f& b); // Outer product
2322 | Mat4f    abs  (const Mat4f& m);              // abs(m_ij)
2323 | 
2324 | // The xform functions help avoid dependence on whether row or column
2325 | // vectors are used to represent points and vectors.
2326 | Vec4f    xform(const Mat4f& m, const Vec4f& v); // Transform of v by m
2327 | Vec3f    xform(const Mat4f& m, const Vec3f& v); // Hom. xform of v by m
2328 | Mat4f    xform(const Mat4f& m, const Mat4f& n); // Xform v -> m(n(v))
2329 |     
2330 | 
2331 | // --- Inlines ----------------------------------------------------------------
2332 | 
2333 | inline Mat4f::Mat4f()
2334 | {
2335 | }
2336 | 
2337 | inline Mat4f::Mat4f(const Vec4f& v0, const Vec4f& v1, const Vec4f& v2, const Vec4f& v3)
2338 | {
2339 |     x = v0;
2340 |     y = v1;
2341 |     z = v2;
2342 |     w = v3;
2343 | }
2344 | 
2345 | inline Mat4f::Mat4f(const Mat4f& m)
2346 | {
2347 |     x = m.x;
2348 |     y = m.y;
2349 |     z = m.z;
2350 |     w = m.w;
2351 | }
2352 | 
2353 | inline Vec4f& Mat4f::operator [] (int i)
2354 | {
2355 |     CL_RANGE_MSG(i, 0, 4, "(Mat4::[i]) index out of range");
2356 |     return (&x)[i];
2357 | }
2358 | 
2359 | inline const Vec4f& Mat4f::operator [] (int i) const
2360 | {
2361 |     CL_RANGE_MSG(i, 0, 4, "(Mat4::[i]) index out of range");
2362 |     return (&x)[i];
2363 | }
2364 | 
2365 | inline float& Mat4f::operator () (int i, int j)
2366 | {
2367 |     CL_RANGE_MSG(i, 0, 4, "(Mat2::(i,j)) index out of range");
2368 |     CL_RANGE_MSG(j, 0, 4, "(Mat2::(i,j)) index out of range");
2369 |     
2370 |     return (&x)[i][j];
2371 | }
2372 | 
2373 | inline float Mat4f::operator () (int i, int j) const
2374 | {
2375 |     CL_RANGE_MSG(i, 0, 4, "(Mat2::(i,j)) index out of range");
2376 |     CL_RANGE_MSG(j, 0, 4, "(Mat2::(i,j)) index out of range");
2377 |     
2378 |     return (&x)[i][j];
2379 | }
2380 | 
2381 | inline float* Mat4f::Ref()
2382 | {
2383 |     return &x.x;
2384 | }
2385 | 
2386 | inline const float* Mat4f::Ref() const
2387 | {
2388 |     return &x.x;
2389 | }
2390 | 
2391 | inline Mat4f::Mat4f(ZeroOrOne k)
2392 | {
2393 |     MakeDiag(float(k));
2394 | }
2395 | 
2396 | inline Mat4f::Mat4f(Block k)
2397 | {
2398 |     MakeBlock(float(k));
2399 | }
2400 | 
2401 | inline Mat4f& Mat4f::operator = (ZeroOrOne k)
2402 | {
2403 |     MakeDiag(float(k));
2404 | 
2405 |     return *this;
2406 | }
2407 | 
2408 | inline Mat4f& Mat4f::operator = (Block k)
2409 | {
2410 |     MakeBlock(float(k));
2411 | 
2412 |     return *this;
2413 | }
2414 | 
2415 | inline Mat4f operator * (float s, const Mat4f& m)
2416 | {
2417 |     return m * s;
2418 | }
2419 | 
2420 | #ifdef VL_ROW_ORIENT
2421 | inline Vec3f xform(const Mat4f& m, const Vec3f& v)
2422 | { return proj(Vec4f(v, 1.0) * m); }
2423 | inline Vec4f xform(const Mat4f& m, const Vec4f& v)
2424 | { return v * m; }
2425 | inline Mat4f xform(const Mat4f& m, const Mat4f& n)
2426 | { return n * m; }
2427 | #else
2428 | inline Vec3f xform(const Mat4f& m, const Vec3f& v)
2429 | { return proj(m * Vec4f(v, 1.0)); }
2430 | inline Vec4f xform(const Mat4f& m, const Vec4f& v)
2431 | { return m * v; }
2432 | inline Mat4f xform(const Mat4f& m, const Mat4f& n)
2433 | { return m * n; }
2434 | #endif
2435 | 
2436 | #endif
2437 | 


--------------------------------------------------------------------------------
/gen-images.sh:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | mkdir -p images
 4 | 
 5 | SUNSKY="./sunsky -f -v -l 30 0 -d 58 -b 3"
 6 | OPTS=
 7 | 
 8 | TIMES="12.5 13.5 14.5 15.5 16.5 17.5 18.5"
 9 | 
10 | for type in hosek preetham; do
11 |     echo $type ":"
12 |     i=1
13 |     for time in $TIMES; do
14 |         $SUNSKY $OPTS -s $type -t $time && mv -f sky-hemi.png images/${type}-${i}.png
15 |         let "i++"
16 |     done
17 | done
18 | 
19 | OPTS="-o 0.5"
20 | 
21 | for type in hosek preetham; do
22 |     echo $type ":"
23 |     i=1
24 |     for time in $TIMES; do
25 |         $SUNSKY $OPTS -s $type -t $time && mv -f sky-hemi.png images/${type}-oc-${i}.png
26 |         let "i++"
27 |     done
28 | done
29 | 
30 | OPTS=""
31 | 
32 | for type in hosek preetham; do
33 |     echo $type ":"
34 |     i=1
35 |     for o in 0 0.166 0.333 0.5 0.666 0.833 1; do
36 |         $SUNSKY $OPTS -s $type -t 14 -o $o && mv -f sky-hemi.png images/${type}-ocd-${i}.png
37 |         # $SUNSKY $OPTS -s $type -t 07 -o $o && mv -f sky-hemi.png images/${type}-ocs-${i}.png
38 |         let "i++"
39 |     done
40 | done
41 | 
42 | OPTS=""
43 | 
44 | for type in hosekBRDF preethamBRDF; do
45 |     echo $type ":"
46 |     i=1
47 |     for r in 0 0.166 0.333 0.5 0.666 0.833 1; do
48 |         $SUNSKY $OPTS -s $type -t 14 -r $r && mv -f sky-hemi.png images/${type}-rd-${i}.png
49 |         $SUNSKY $OPTS -s $type -t 07 -r $r && mv -f sky-hemi.png images/${type}-rs-${i}.png
50 |         let "i++"
51 |     done
52 | done
53 | 
54 | mogrify -resize 120x120 images/*
55 | 


--------------------------------------------------------------------------------
/images/hosek-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-1.png


--------------------------------------------------------------------------------
/images/hosek-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-2.png


--------------------------------------------------------------------------------
/images/hosek-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-3.png


--------------------------------------------------------------------------------
/images/hosek-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-4.png


--------------------------------------------------------------------------------
/images/hosek-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-5.png


--------------------------------------------------------------------------------
/images/hosek-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-6.png


--------------------------------------------------------------------------------
/images/hosek-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-7.png


--------------------------------------------------------------------------------
/images/hosek-oc-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-oc-1.png


--------------------------------------------------------------------------------
/images/hosek-oc-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-oc-2.png


--------------------------------------------------------------------------------
/images/hosek-oc-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-oc-3.png


--------------------------------------------------------------------------------
/images/hosek-oc-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-oc-4.png


--------------------------------------------------------------------------------
/images/hosek-oc-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-oc-5.png


--------------------------------------------------------------------------------
/images/hosek-oc-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-oc-6.png


--------------------------------------------------------------------------------
/images/hosek-oc-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-oc-7.png


--------------------------------------------------------------------------------
/images/hosek-ocd-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-ocd-1.png


--------------------------------------------------------------------------------
/images/hosek-ocd-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-ocd-2.png


--------------------------------------------------------------------------------
/images/hosek-ocd-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-ocd-3.png


--------------------------------------------------------------------------------
/images/hosek-ocd-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-ocd-4.png


--------------------------------------------------------------------------------
/images/hosek-ocd-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-ocd-5.png


--------------------------------------------------------------------------------
/images/hosek-ocd-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-ocd-6.png


--------------------------------------------------------------------------------
/images/hosek-ocd-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosek-ocd-7.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rd-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rd-1.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rd-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rd-2.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rd-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rd-3.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rd-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rd-4.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rd-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rd-5.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rd-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rd-6.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rd-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rd-7.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rs-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rs-1.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rs-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rs-2.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rs-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rs-3.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rs-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rs-4.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rs-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rs-5.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rs-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rs-6.png


--------------------------------------------------------------------------------
/images/hosekBRDF-rs-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/hosekBRDF-rs-7.png


--------------------------------------------------------------------------------
/images/preetham-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-1.png


--------------------------------------------------------------------------------
/images/preetham-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-2.png


--------------------------------------------------------------------------------
/images/preetham-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-3.png


--------------------------------------------------------------------------------
/images/preetham-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-4.png


--------------------------------------------------------------------------------
/images/preetham-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-5.png


--------------------------------------------------------------------------------
/images/preetham-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-6.png


--------------------------------------------------------------------------------
/images/preetham-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-7.png


--------------------------------------------------------------------------------
/images/preetham-oc-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-oc-1.png


--------------------------------------------------------------------------------
/images/preetham-oc-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-oc-2.png


--------------------------------------------------------------------------------
/images/preetham-oc-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-oc-3.png


--------------------------------------------------------------------------------
/images/preetham-oc-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-oc-4.png


--------------------------------------------------------------------------------
/images/preetham-oc-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-oc-5.png


--------------------------------------------------------------------------------
/images/preetham-oc-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-oc-6.png


--------------------------------------------------------------------------------
/images/preetham-oc-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-oc-7.png


--------------------------------------------------------------------------------
/images/preetham-ocd-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-ocd-1.png


--------------------------------------------------------------------------------
/images/preetham-ocd-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-ocd-2.png


--------------------------------------------------------------------------------
/images/preetham-ocd-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-ocd-3.png


--------------------------------------------------------------------------------
/images/preetham-ocd-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-ocd-4.png


--------------------------------------------------------------------------------
/images/preetham-ocd-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-ocd-5.png


--------------------------------------------------------------------------------
/images/preetham-ocd-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-ocd-6.png


--------------------------------------------------------------------------------
/images/preetham-ocd-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preetham-ocd-7.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rd-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rd-1.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rd-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rd-2.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rd-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rd-3.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rd-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rd-4.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rd-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rd-5.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rd-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rd-6.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rd-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rd-7.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rs-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rs-1.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rs-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rs-2.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rs-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rs-3.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rs-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rs-4.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rs-5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rs-5.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rs-6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rs-6.png


--------------------------------------------------------------------------------
/images/preethamBRDF-rs-7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andrewwillmott/sun-sky/c9466ffdb256a4967f338bba7d0097056e18ec9b/images/preethamBRDF-rs-7.png


--------------------------------------------------------------------------------