diff --git a/.gitmodules b/.gitmodules
index aab1040..4efe3c6 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -4,3 +4,6 @@
 [submodule "external/glm"]
 	path = external/glm
 	url = https://github.com/g-truc/glm
+[submodule "external/stb"]
+	path = external/stb
+	url = https://github.com/nothings/stb
diff --git a/prefilter/genie.lua b/prefilter/genie.lua
new file mode 100644
index 0000000..1763444
--- /dev/null
+++ b/prefilter/genie.lua
@@ -0,0 +1,27 @@
+solution "prefilter"
+   configurations { "Debug", "Release" }
+
+   project "prefilter"
+      kind "ConsoleApp"
+      language "C++"
+      files { "**.h", "**.cpp", "**.c" }
+
+      includedirs {
+         "../external/CImg",
+         "../external/glm",
+         "../external/stb"
+      }
+
+      defines { 
+         "cimg_display=0"
+      }
+
+      configuration "Debug"
+         targetdir "bin"
+         defines { "DEBUG" }
+         flags { "Symbols" }
+
+      configuration "Release"
+         targetdir "bin"
+         defines { "NDEBUG" }
+         flags { "Optimize" }
diff --git a/prefilter/prefilterAreaLight.cpp b/prefilter/prefilterAreaLight.cpp
new file mode 100644
index 0000000..4bf660e
--- /dev/null
+++ b/prefilter/prefilterAreaLight.cpp
@@ -0,0 +1,264 @@
+#include <cmath>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <iomanip>
+#include <cstdint>
+using namespace std;
+
+#include "CImg.h"
+using namespace cimg_library;
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+
+void filter(CImg<float>& imageInput, CImg<float>& imageOutput, const int level, const int Nlevels)
+{
+    // distance to texture plane
+    // in shader: LOD = log(powf(2.0f, Nlevels - 1.0f) * dist) / log(3)
+    const float dist = powf(3.0f, level) / powf(2.0f, Nlevels - 1.0f);
+
+    // filter size
+    // at distance 1 ~= Gaussian of std 0.75
+    const float filterStd = 0.75f * dist * imageInput.width();
+
+    cout << "level " << level << endl;
+    cout << "distance to texture plane = " << dist << endl;
+    cout << "filterStd = " << filterStd << endl << endl;
+
+    CImg<float> tmp(imageInput.width(), imageInput.height(), 1, 4);
+
+    for (int j = 0; j < imageInput.height(); ++j)
+    for (int i = 0; i < imageInput.width();  ++i)
+    {
+        tmp(i, j, 0, 0) = imageInput(i, j, 0, 0);
+        tmp(i, j, 0, 1) = imageInput(i, j, 0, 1);
+        tmp(i, j, 0, 2) = imageInput(i, j, 0, 2);
+        tmp(i, j, 0, 3) = 1.0f;
+    }
+
+    tmp.blur(filterStd, filterStd, filterStd, false);
+
+    // renormalise based on alpha
+    for (int j = 0; j < imageInput.height(); ++j)
+    for (int i = 0; i < imageInput.width();  ++i)
+    {
+        float alpha = tmp(i, j, 0, 3);
+        for (int k = 0; k < tmp.spectrum(); ++k)
+          tmp(i, j, 0, k) /= alpha;
+    }
+
+    // rescale image
+    imageOutput = tmp.resize(imageOutput, 5); // 5 = cubic interpolation
+}
+
+// Adapted from https://www.khronos.org/registry/OpenGL/extensions/EXT/EXT_texture_shared_exponent.txt
+////////
+#define RGB9E5_EXPONENT_BITS          5
+#define RGB9E5_MANTISSA_BITS          9
+#define RGB9E5_EXP_BIAS               15
+#define RGB9E5_MAX_VALID_BIASED_EXP   31
+
+#define MAX_RGB9E5_EXP               (RGB9E5_MAX_VALID_BIASED_EXP - RGB9E5_EXP_BIAS)
+#define RGB9E5_MANTISSA_VALUES       (1<<RGB9E5_MANTISSA_BITS)
+#define MAX_RGB9E5_MANTISSA          (RGB9E5_MANTISSA_VALUES-1)
+#define MAX_RGB9E5                   (((float)MAX_RGB9E5_MANTISSA)/RGB9E5_MANTISSA_VALUES * (1<<MAX_RGB9E5_EXP))
+#define EPSILON_RGB9E5               ((1.0/RGB9E5_MANTISSA_VALUES) / (1<<RGB9E5_EXP_BIAS))
+
+typedef struct
+{
+  uint32_t mantissa : 23;
+  uint32_t biasedexponent : 8;
+  uint32_t negative : 1;
+} BitsOfIEEE754;
+
+typedef union
+{
+  uint32_t raw;
+  float value;
+  BitsOfIEEE754 field;
+} float754;
+
+typedef struct
+{
+    uint32_t r : RGB9E5_MANTISSA_BITS;
+    uint32_t g : RGB9E5_MANTISSA_BITS;
+    uint32_t b : RGB9E5_MANTISSA_BITS;
+    uint32_t biasedexponent : RGB9E5_EXPONENT_BITS;
+} BitsOfRGB9E5;
+
+typedef union
+{
+    uint32_t raw;
+    BitsOfRGB9E5 field;
+} rgb9e5;
+
+float ClampRange_for_rgb9e5(float x)
+{
+    if (x > 0.0)
+    {
+        if (x >= MAX_RGB9E5)
+            return MAX_RGB9E5;
+    }
+    else
+    {
+        /* NaN gets here too since comparisons with NaN always fail! */
+        return 0.0f;
+    }
+
+    return x;
+}
+
+float Max(float a, float b)
+{
+    return a >= b ? a : b;
+}
+
+float MaxOf3(float x, float y, float z)
+{
+    return Max(Max(x, y), z);
+}
+
+/* Ok, FloorLog2 is not correct for the denorm and zero values, but we
+   are going to do a max of this value with the minimum rgb9e5 exponent
+   that will hide these problem cases. */
+int FloorLog2(float x)
+{
+  float754 f;
+
+  f.value = x;
+  return (f.field.biasedexponent - 127);
+}
+
+int Max(int x, int y)
+{
+  if (x > y) {
+    return x;
+  } else {
+    return y;
+  }
+}
+
+rgb9e5 float3_to_rgb9e5(const float r, const float g, const float b)
+{
+  rgb9e5 retval;
+  float maxrgb;
+  int rm, gm, bm;
+  float rc, gc, bc;
+  int exp_shared;
+  double denom;
+
+  rc = ClampRange_for_rgb9e5(r);
+  gc = ClampRange_for_rgb9e5(g);
+  bc = ClampRange_for_rgb9e5(b);
+
+  maxrgb = MaxOf3(rc, gc, bc);
+  exp_shared = Max(-RGB9E5_EXP_BIAS-1, FloorLog2(maxrgb)) + 1 + RGB9E5_EXP_BIAS;
+  assert(exp_shared <= RGB9E5_MAX_VALID_BIASED_EXP);
+  assert(exp_shared >= 0);
+  /* This pow function could be replaced by a table. */
+  denom = pow(2, exp_shared - RGB9E5_EXP_BIAS - RGB9E5_MANTISSA_BITS);
+
+  int maxm = (int) floor(maxrgb / denom + 0.5f);
+  if (maxm == MAX_RGB9E5_MANTISSA+1) {
+    denom *= 2;
+    exp_shared += 1;
+    assert(exp_shared <= RGB9E5_MAX_VALID_BIASED_EXP);
+  } else {
+    assert(maxm <= MAX_RGB9E5_MANTISSA);
+  }
+
+  rm = (int) floor(rc / denom + 0.5);
+  gm = (int) floor(gc / denom + 0.5);
+  bm = (int) floor(bc / denom + 0.5);
+
+  assert(rm <= MAX_RGB9E5_MANTISSA);
+  assert(gm <= MAX_RGB9E5_MANTISSA);
+  assert(bm <= MAX_RGB9E5_MANTISSA);
+  assert(rm >= 0);
+  assert(gm >= 0);
+  assert(bm >= 0);
+
+  retval.field.r = rm;
+  retval.field.g = gm;
+  retval.field.b = bm;
+  retval.field.biasedexponent = exp_shared;
+
+  return retval;
+}
+////////
+
+int main(int argc, char* argv[])
+{
+    // Skip executable argument
+    argc--;
+    argv++;
+
+    if (argc < 1)
+    {
+        printf("Syntax: <input file>\n");
+        return 0;
+    }
+
+    string filenameInput(argv[0]);
+    size_t pos = filenameInput.find_last_of(".");
+    string filename  = filenameInput.substr(0, pos);
+    string extension = filenameInput.substr(pos + 1, string::npos);
+
+    // input image
+    int x, y, n;
+    float* data = stbi_loadf(filenameInput.c_str(), &x, &y, &n, 3);
+
+    int offset = 0;
+    CImg<float> imageInput(x, y, 1, 3);
+    for (int j = 0; j < y; ++j)
+    for (int i = 0; i < x; ++i)
+    {
+        for (int k = 0; k < imageInput.spectrum(); ++k)
+            imageInput(i, j, 0, k) = data[offset++];
+    }
+
+    // filtered levels
+    //unsigned int Nlevels;
+    //for (Nlevels = 1; (imageInput.width() >> Nlevels) > 0; ++Nlevels);
+
+    // Beyond 8 levels, the result is ~= a constant colour
+    // so pretend we have 12 levels, but truncate at 8
+    const unsigned int Nlevels = 12;
+    const unsigned int maxLevels = 8;
+
+    uint32_t* dataOut = new uint32_t[x * y];
+
+    // borders
+    for (unsigned int level = 0; level < maxLevels; ++level)
+    {
+        stringstream filenameOutput(stringstream::in | stringstream::out);
+        filenameOutput << filename << "_" << level << ".png";
+
+        cout << "processing file " << filenameOutput.str() << endl;
+
+        CImg<float> imageOutput(x, y, 1, 4);
+        filter(imageInput, imageOutput, level, Nlevels);
+
+        offset = 0;
+        for (int j = 0; j < y; ++j)
+        for (int i = 0; i < x; ++i)
+        {
+            float r = imageOutput(i, j, 0, 0);
+            float g = imageOutput(i, j, 0, 1);
+            float b = imageOutput(i, j, 0, 2);
+
+            rgb9e5 value = float3_to_rgb9e5(r, g, b);
+            dataOut[offset++] = value.raw;
+        }
+
+        stbi_write_png(filenameOutput.str().c_str(), x, y, 4, dataOut, 0);
+    }
+
+    delete[] dataOut;
+
+    return 0;
+}
diff --git a/webgl/images/stained_glass_0.png b/webgl/images/stained_glass_0.png
new file mode 100644
index 0000000..3203879
Binary files /dev/null and b/webgl/images/stained_glass_0.png differ
diff --git a/webgl/images/stained_glass_1.png b/webgl/images/stained_glass_1.png
new file mode 100644
index 0000000..c792274
Binary files /dev/null and b/webgl/images/stained_glass_1.png differ
diff --git a/webgl/images/stained_glass_2.png b/webgl/images/stained_glass_2.png
new file mode 100644
index 0000000..a32c28c
Binary files /dev/null and b/webgl/images/stained_glass_2.png differ
diff --git a/webgl/images/stained_glass_3.png b/webgl/images/stained_glass_3.png
new file mode 100644
index 0000000..d558070
Binary files /dev/null and b/webgl/images/stained_glass_3.png differ
diff --git a/webgl/images/stained_glass_4.png b/webgl/images/stained_glass_4.png
new file mode 100644
index 0000000..968c986
Binary files /dev/null and b/webgl/images/stained_glass_4.png differ
diff --git a/webgl/images/stained_glass_5.png b/webgl/images/stained_glass_5.png
new file mode 100644
index 0000000..5636279
Binary files /dev/null and b/webgl/images/stained_glass_5.png differ
diff --git a/webgl/images/stained_glass_6.png b/webgl/images/stained_glass_6.png
new file mode 100644
index 0000000..6f9d1cd
Binary files /dev/null and b/webgl/images/stained_glass_6.png differ
diff --git a/webgl/images/stained_glass_7.png b/webgl/images/stained_glass_7.png
new file mode 100644
index 0000000..5fda949
Binary files /dev/null and b/webgl/images/stained_glass_7.png differ
diff --git a/webgl/ltc_quad.html b/webgl/ltc_quad.html
index fb9f254..1029143 100644
--- a/webgl/ltc_quad.html
+++ b/webgl/ltc_quad.html
@@ -64,7 +64,6 @@
 
 <script src="../fit/results/ltc.js" type="text/javascript"></script>
 
-
 <script>
 var g_vshader = null;
 
@@ -187,6 +186,8 @@
 var ltc_texture_1 = null;
 var ltc_texture_2 = null;
 
+var color_texture = null;
+
 var rttFramebuffer = null;
 var rttTexture = null;
 
@@ -216,6 +217,76 @@
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
 }
 
+function SetClampedMIPTextureState()
+{
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+}
+
+// See: https://www.khronos.org/registry/OpenGL/extensions/EXT/EXT_texture_shared_exponent.txt
+function rgb9_e5ToFloat(buffer, res) {
+    var l = buffer.byteLength >> 2, res = res || new Float32Array(l*3);
+    for (var i = 0; i < l; i++) {
+        var v = buffer[i];
+        var exponent = ((v >>> 27) & 31) - 24;
+        var scale = Math.pow(2, exponent);
+        res[i*3 + 0] = ((v >>>  0) & 511) * scale;
+        res[i*3 + 1] = ((v >>>  9) & 511) * scale;
+        res[i*3 + 2] = ((v >>> 18) & 511) * scale;
+    }
+    return res;
+}
+
+var g_array_slices_to_load = 0;
+var g_array_data = null;
+
+function LoadTextureLevel(gl, src, level, dest) {
+    var image = new Image();
+    image.onload = function() {
+        var x = image.width;
+        var y = image.height;
+
+        var texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+
+        var fb = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+
+        var res = new Uint8Array(x * y * 4);
+        gl.readPixels(0, 0, x, y, gl.RGBA,gl.UNSIGNED_BYTE,res);
+
+        gl.deleteTexture(texture);
+        gl.deleteFramebuffer(fb);
+
+        var dataU32 = new Uint32Array(res.buffer);
+        var dataF32 = rgb9_e5ToFloat(dataU32);
+
+        g_array_data.set(dataF32, 512 * 512 * 3 * level);
+
+        g_array_slices_to_load--;
+
+        if (g_array_slices_to_load == 0)
+        {
+            color_texture = gl.createTexture();
+            gl.bindTexture(gl.TEXTURE_2D_ARRAY, color_texture);
+            gl.texImage3D(gl.TEXTURE_2D_ARRAY, 0, gl.R11F_G11F_B10F, 512, 512, 10, 0, gl.RGB, gl.FLOAT, g_array_data);
+            gl.generateMipmap(gl.TEXTURE_2D_ARRAY);
+
+            gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S,     gl.CLAMP_TO_EDGE);
+            gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T,     gl.CLAMP_TO_EDGE);
+        }
+    }
+
+    image.src = src;
+}
+
+
 function init() {
     vertex_shader   = FetchFile("shaders/ltc/ltc.vs", false);
     fragment_shader = FetchFile("shaders/ltc/ltc_quad.fs", false);
@@ -331,6 +402,14 @@
     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, 64, 64, 0, gl.RGBA, gl.FLOAT, new Float32Array(g_ltc_2));
     SetClampedTextureState();
 
+    // TODO: remove hardcoding
+    g_array_slices_to_load = 8;
+    g_array_data = new Float32Array(512 * 512 * 3 * 10);
+
+    for (var i = 0; i < g_array_slices_to_load; i++) {
+        LoadTextureLevel(gl, "images/stained_glass_" + i + ".png", i, color_texture);
+    }
+
     // Fetch media and kick off the main program once everything has loaded
     $(function() {
         $(document).ajaxStop(function() {
@@ -385,7 +464,7 @@
 
 
 function createProgram(vertex, fragment) {
-    var header = "#version 300 es\nprecision highp float;\n#line 0\n";
+    var header = "#version 300 es\nprecision highp float;\nprecision highp sampler2DArray;\n#line 0\n";
     vertex   = header + vertex;
     fragment = header + fragment;
 
@@ -653,6 +732,10 @@
     gl.bindTexture(gl.TEXTURE_2D, ltc_texture_2);
     gl.uniform1i(gl.getUniformLocation(currentProgram, "ltc_2"), 1);
 
+    gl.activeTexture(gl.TEXTURE2);
+    gl.bindTexture(gl.TEXTURE_2D_ARRAY, color_texture);
+    gl.uniform1i(gl.getUniformLocation(currentProgram, "tex"), 2);
+
     checkGLError();
 
     gl.bindFramebuffer(gl.FRAMEBUFFER, rttFramebuffer);
diff --git a/webgl/shaders/ltc/ltc_quad.fs b/webgl/shaders/ltc/ltc_quad.fs
index 68621ca..6a6e59a 100644
--- a/webgl/shaders/ltc/ltc_quad.fs
+++ b/webgl/shaders/ltc/ltc_quad.fs
@@ -8,6 +8,7 @@
 // bind rotz        {label:"Rotation Z", default: 0, min:0, max:1, step:0.001}
 // bind twoSided    {label:"Two-sided", default:false}
 // bind clipless    {label:"Clipless Approximation", default:false}
+// bind textured    {label:"Textured", default:false}
 
 uniform float roughness;
 uniform vec3  dcolor;
@@ -21,10 +22,13 @@ uniform float rotz;
 
 uniform bool twoSided;
 uniform bool clipless;
+uniform bool textured;
 
 uniform sampler2D ltc_1;
 uniform sampler2D ltc_2;
 
+uniform sampler2DArray tex;
+
 uniform mat4  view;
 uniform vec2  resolution;
 uniform int   sampleCount;
@@ -79,6 +83,18 @@ bool RayRectIntersect(Ray ray, Rect rect, out float t)
     return intersect;
 }
 
+vec2 RectUVs(vec3 pos, Rect rect)
+{
+    vec3 lpos = pos - rect.center;
+
+    float x = dot(lpos, rect.dirx);
+    float y = dot(lpos, rect.diry);
+
+    return vec2(
+        0.5*x/rect.halfx + 0.5,
+        0.5*y/rect.halfy + 0.5);
+}
+
 // Camera functions
 ///////////////////
 
@@ -270,6 +286,59 @@ void ClipQuadToHorizon(inout vec3 L[5], out int n)
         L[4] = L[0];
 }
 
+vec3 FetchColorTexture(vec2 uv, float lod)
+{
+    if (!textured)
+        return vec3(1, 1, 1);
+    return texture(tex, vec3(uv, lod)).rgb;
+}
+
+vec3 FetchDiffuseFilteredTexture(vec3 p1, vec3 p2, vec3 p3, vec3 p4, vec3 dir)
+{
+    if (textured == false)
+        return vec3(1, 1, 1);
+    
+    // area light plane basis
+    vec3 V1 = p2 - p1;
+    vec3 V2 = p4 - p1;
+    vec3 planeOrtho = cross(V1, V2);
+    float planeAreaSquared = dot(planeOrtho, planeOrtho);
+
+    Ray ray;
+    ray.origin = vec3(0, 0, 0);
+    ray.dir = dir;
+    vec4 plane = vec4(planeOrtho, -dot(planeOrtho, p1));
+    float planeDist;
+    RayPlaneIntersect(ray, plane, planeDist);
+ 
+    vec3 P = planeDist*ray.dir - p1;
+ 
+    // find tex coords of P
+    float dot_V1_V2 = dot(V1, V2);
+    float inv_dot_V1_V1 = 1.0 / dot(V1, V1);
+    vec3 V2_ = V2 - V1 * dot_V1_V2 * inv_dot_V1_V1;
+    vec2 Puv;
+    Puv.y = dot(V2_, P) / dot(V2_, V2_);
+    Puv.x = dot(V1, P)*inv_dot_V1_V1 - dot_V1_V2*inv_dot_V1_V1*Puv.y;
+
+    // LOD
+    float d = abs(planeDist) / pow(planeAreaSquared, 0.25);
+    
+    // Flip texture to match OpenGL conventions
+    Puv = Puv*vec2(1, -1) + vec2(0, 1);
+    
+    float lod = log(2048.0*d)/log(3.0);
+    lod = min(lod, 7.0);
+    
+    float lodA = floor(lod);
+    float lodB = ceil(lod);
+    float t = lod - lodA;
+    
+    vec3 a = FetchColorTexture(Puv, lodA);
+    vec3 b = FetchColorTexture(Puv, lodB);
+
+    return mix(a, b, t);
+}
 
 vec3 LTC_Evaluate(
     vec3 N, vec3 V, vec3 P, mat3 Minv, vec3 points[4], bool twoSided)
@@ -281,6 +350,8 @@ vec3 LTC_Evaluate(
 
     // rotate area light in (T1, T2, N) basis
     Minv = mul(Minv, transpose(mat3(T1, T2, N)));
+    
+    mat3 MM = mat3(1);
 
     // polygon (allocate 5 vertices for clipping)
     vec3 L[5];
@@ -288,9 +359,16 @@ vec3 LTC_Evaluate(
     L[1] = mul(Minv, points[1] - P);
     L[2] = mul(Minv, points[2] - P);
     L[3] = mul(Minv, points[3] - P);
+    
+    vec3 LL[4];
+    LL[0] = L[0];
+    LL[1] = L[1];
+    LL[2] = L[2];
+    LL[3] = L[3];
 
     // integrate
     float sum = 0.0;
+    vec3 colorMap;
 
     if (clipless)
     {
@@ -325,6 +403,9 @@ vec3 LTC_Evaluate(
 
         if (behind && !twoSided)
             sum = 0.0;
+
+        vec3 fetchDir = vsum/len;
+        colorMap = FetchDiffuseFilteredTexture(LL[0], LL[1], LL[2], LL[3], fetchDir);
     }
     else
     {
@@ -333,26 +414,32 @@ vec3 LTC_Evaluate(
 
         if (n == 0)
             return vec3(0, 0, 0);
+
         // project onto sphere
         L[0] = normalize(L[0]);
         L[1] = normalize(L[1]);
         L[2] = normalize(L[2]);
         L[3] = normalize(L[3]);
         L[4] = normalize(L[4]);
+        
+        vec3 vsum;
 
         // integrate
-        sum += IntegrateEdge(L[0], L[1]);
-        sum += IntegrateEdge(L[1], L[2]);
-        sum += IntegrateEdge(L[2], L[3]);
+        vsum  = IntegrateEdgeVec(L[0], L[1]);
+        vsum += IntegrateEdgeVec(L[1], L[2]);
+        vsum += IntegrateEdgeVec(L[2], L[3]);
         if (n >= 4)
-            sum += IntegrateEdge(L[3], L[4]);
+            vsum += IntegrateEdgeVec(L[3], L[4]);
         if (n == 5)
-            sum += IntegrateEdge(L[4], L[0]);
+            vsum += IntegrateEdgeVec(L[4], L[0]);
+
+        sum = twoSided ? abs(vsum.z) : max(0.0, vsum.z);
 
-        sum = twoSided ? abs(sum) : max(0.0, sum);
+        vec3 fetchDir = normalize(vsum);
+        colorMap = FetchDiffuseFilteredTexture(LL[0], LL[1], LL[2], LL[3], fetchDir);
     }
 
-    vec3 Lo_i = vec3(sum, sum, sum);
+    vec3 Lo_i = sum * colorMap;
 
     return Lo_i;
 }
@@ -453,8 +540,17 @@ void main()
 
     float distToRect;
     if (RayRectIntersect(ray, rect, distToRect))
+    {
         if ((distToRect < distToFloor) || !hitFloor)
-            col = lcol;
+        {
+            vec3 pos = ray.origin + ray.dir*distToRect;
+            vec2 uv  = RectUVs(pos, rect);
+            uv = uv*vec2(1, -1) + vec2(0, 1);
+            col = lcol*texture(tex, vec3(uv, 0.0)).rgb;
+            if (!textured)
+                col = lcol;
+        }
+    }
 
     FragColor = vec4(col, 1.0);
 }
\ No newline at end of file