X-Git-Url: https://thelambdalab.xyz/gitweb/index.cgi?a=blobdiff_plain;f=Textures.lua;h=ad805a6888971b357a351d4816f56c0784bfce2d;hb=a813887de43a672975cec78d56632f5b80b5addb;hp=b1d1cb308dda091f93cf2e59a9009c099eb04013;hpb=c86e8c7637a7368950add912b9bce244bbf9e689;p=raymarcher.git diff --git a/Textures.lua b/Textures.lua index b1d1cb3..ad805a6 100644 --- a/Textures.lua +++ b/Textures.lua @@ -1,27 +1,178 @@ -- Textures for raymarcher + require "Vector" local V = Vector -local function make_phong(lights, colour, amb, spec, shiny) - return function (location, ray_dir, normal, count) - local thiscol = {0, 0, 0} - local reflected_ray = V.normalize(normal*(ray_dir*normal*2) - ray_dir) +local function make_phong_texture(lights, mapped_pigment, amb, diff, spec, shiny) + local normalize = V.normalize + + local eps = 0.0001 + local function light_visibility(location, light_dir, pos, dest, res, sdf) + local p = sdf(location) + if pos + p.dist > dest then + return res + elseif p.dist < eps then + return 0.0 + else + return light_visibility(location + light_dir*p.dist, light_dir, pos+p.dist, + dest, math.min(res, 30*p.dist/(pos+p.dist)), sdf) + end + end + + return function (location, ray_dir, normal, count, sdf) + local colour = mapped_pigment(location) + local thiscol = {colour[1]*amb, colour[2]*amb, colour[3]*amb} + + local reflected_ray = ray_dir - normal*(ray_dir*normal*2) for _,light in ipairs(lights) do - local light_dir = V.normalize(light-location) - local Iamb = math.max(normal*light_dir, 0) + local light_dist = V.norm(light-location) + local light_dir = (light-location)/light_dist + + local vis = light_visibility(location + light_dir*eps, light_dir, eps, light_dist, 1, sdf) + -- local vis = 1.0 + + local Idiff = math.max(normal*light_dir, 0) local Ispec = math.pow(math.max(light_dir*reflected_ray,0),shiny) - thiscol[1] = thiscol[1] + colour[1]*Iamb*amb + Ispec*spec - thiscol[2] = thiscol[2] + colour[2]*Iamb*amb + Ispec*spec - thiscol[3] = thiscol[3] + colour[3]*Iamb*amb + Ispec*spec + thiscol[1] = thiscol[1] + vis*(colour[1]*Idiff*diff + Ispec*spec) + thiscol[2] = thiscol[2] + vis*(colour[2]*Idiff*diff + Ispec*spec) + thiscol[3] = thiscol[3] + vis*(colour[3]*Idiff*diff + Ispec*spec) end return thiscol end end + +local function make_count_texture(scale) + return function (location, ray_dir, normal, count, sdf) + return {count*scale, count*scale, count*scale} + end +end + +local function make_flat_texture(mapped_pigment) + return function (location, ray_dir, normal, count, sdf) + return mapped_pigment(location) + end +end + + +-- Pigments + +local function make_solid_pigment(colour) + return function(x,y) + return colour + end +end + +local function make_checkered_pigment(pigment1, pigment2) + return function(x,y) + if (x%1 < 0.5 and y%1 < 0.5) or (x%1 > 0.5 and y%1 > 0.5) then + return pigment1(x,y) + else + return pigment2(x,y) + end + end +end + +local function make_image_pigment(filename,scale) + + print("Loading image pigmant from '" .. filename .. "'...") + + local f = assert(io.open(filename, "rb")) + local data = f:read("*all") + f:close() + + local start,_,wstr,hstr,dstr,raster = + string.find(data, "^P6[%s%c]+(%d+)[%s%c]+(%d+)[%s%c]+(%d+)[%s%c](.*)$") + + if start ~= 1 then + error("Error reading image. Is it in PPM(P6) format?") + end + + if dstr ~= "255" then + error("Only images with a depth of 255 are supported.") + end + + local width = tonumber(wstr) + local height = tonumber(hstr) + local depth = tonumber(dstr) + + local pixels = {} + local i = 1 + for triple in string.gmatch(raster, "...") do + local _,_,r,g,b = string.find(triple, "(.)(.)(.)") + pixels[i] = {string.byte(r)/depth, string.byte(g)/depth, string.byte(b)/depth} + i = i + 1 + end + + print("done.") + print("(Read " .. tostring(#pixels) .. " pixels.)") + + local pixels_per_unit = math.max(width,height) + + return function(x,y) + local xi = math.floor(((x+0.5)*pixels_per_unit/scale)%width) + 1 + local yi = math.floor(((y+0.5)*pixels_per_unit/scale)%height) + 1 + local i = width*(yi-1) + xi + if pixels[i] == nil then + error("Pixel not found at xi=" .. tostring(xi) .. " yi=" .. tostring(yi)) + end + return pixels[i] + end +end + +local function make_mandelbrot_pigment(set_pigment, nonset_pigment, max_iter) + + local function get_col(x,y,cx,cy,iter) + if iter == 0 then + return set_pigment(cx, cy) + elseif x^2 + y^2 > 4 then + return nonset_pigment(cx, cy) + else + return get_col(x^2 - y^2 + cx, + 2*x*y + cy, + cx, cy, iter-1) + end + end + + return function (x,y) + return get_col(0,0,x,y,max_iter) + end +end + +-- Mapping functions + +-- These functions define mappings from 3D world coordinates to 2D +-- texture/pigment coordinates + +local function map_rectangular(pigment, xvec, yvec) + return function(location) + return pigment(location*xvec, location*yvec) + end +end + +local function map_spherical(pigment, centre, scale_theta, scale_phi) + return function(location) + local r = location-centre + local rnorm = V.norm(r) + + local phi = math.acos((V.z*r)/rnorm) + local theta = math.acos((V.x*r)/V.norm(V.cross(V.z,r))) + + return pigment(theta*scale_theta/math.pi, phi*scale_phi/math.pi) + end +end Textures = { - make_phong = make_phong + make_phong_texture = make_phong_texture, + make_flat_texture = make_flat_texture, + make_count_texture = make_count_texture, + make_solid_pigment = make_solid_pigment, + make_checkered_pigment = make_checkered_pigment, + make_image_pigment = make_image_pigment, + make_mandelbrot_pigment = make_mandelbrot_pigment, + map_rectangular = map_rectangular, + map_spherical = map_spherical } return Textures