pixelColorCode = [ ` struct Ray { vec3 origin; vec3 direction; float tMin, tMax; }; `, ` vec3 pointOnRay(in Ray ray,float t){ return (ray.origin+t*ray.direction); } `, ` struct AABB{ vec3 minP; vec3 maxP; }; `, ` const float EPSILON = 1e-5; const float INFINITY = 1e5; uniform vec3 Background; uniform vec2 resolution; uniform vec3 cameraU; uniform vec3 cameraV; uniform vec3 cameraW; uniform vec3 cameraEye; uniform float fov; uniform float time; uniform vec3 lightPosMin; uniform vec3 lightPosMax; uniform int numDivs; uniform int numSmpDiv; uniform float shadowStrength; uniform mat4 mtFloor; uniform mat4 mtRoof; uniform mat4 mtWallBack; uniform mat4 mtWallLeft; uniform mat4 mtWallRight; uniform mat4 mtBig; uniform mat4 mtSmall; `, ` Ray getRay(vec2 pixel){ Ray ray; ray.origin = cameraEye; float height = 2.*tan(fov/2.); float aspect = resolution.x/resolution.y; float width = height*aspect; vec2 windowDim = vec2(width,height); vec2 pixelSize = windowDim/resolution; vec2 delta = -0.5*windowDim + pixel*pixelSize; ray.direction = normalize(-cameraW + cameraV*delta.y + cameraU*delta.x); ray.tMin = 0.; ray.tMax = INFINITY; return ray; } `, ` bool insersectsRayAABB(inout Ray ray, AABB aabb) { vec3 tMin = (aabb.minP.xyz - ray.origin) / ray.direction; vec3 tMax = (aabb.maxP.xyz - ray.origin) / ray.direction; vec3 t1 = min(tMin, tMax); vec3 t2 = max(tMin, tMax); //float tNear = max(max(max(t1.x, t1.y), t1.z),ray.tMin); //float tFar = min(min(min(t2.x, t2.y), t2.z),ray.tMax); float tNear = max(max(t1.x, t1.y), t1.z); float tFar = min(min(t2.x, t2.y), t2.z); if (tNear < tFar){ ray.tMin = tNear; ray.tMax = tFar; return true; } return false; } `, ` vec3 getNormal(AABB aabb,vec3 p){ vec3 c = (aabb.minP+aabb.maxP)/2.; vec3 d = p-c; vec3 v = abs(d); int i = v.y > v.x ? ( v.z > v.y ? 2 : 1 ) : ( v.z > v.x ? 2 : 0 ); // Which Sign of the axis: The sign of the component selects the positive or negative direction. return (i == 0) ? ((p.x>=0.)?vec3(1,0,0):vec3(-1,0,0)) : (i == 1) ? ((p.y>=0.)?vec3(0,1,0):vec3(0,-1,0)) : ((p.z>=0.)?vec3(0,0,1):vec3(0,0,-1)); } vec3 getNormalColor(AABB aabb,vec3 p, vec3 c1, vec3 c2, vec3 c3, vec3 c4, vec3 c5, vec3 c6){ vec3 c = (aabb.minP+aabb.maxP)/2.; vec3 d = p-c; vec3 v = abs(d); int i = v.y > v.x ? ( v.z > v.y ? 2 : 1 ) : ( v.z > v.x ? 2 : 0 ); // Which Sign of the axis: The sign of the component selects the positive or negative direction. return (i == 0) ? ((p.x>=0.)?c1:c2) : (i == 1) ? ((p.y>=0.)?c3:c4) : ((p.z>=0.)?c5:c6); } bool insersectsRayCannonicalAABB(inout Ray ray) { AABB aabb; aabb.minP = vec3(-0.5); aabb.maxP = vec3(0.5); return insersectsRayAABB(ray, aabb); } bool checkRayVsSphereCollision( vec3 origin, vec3 dir, vec3 center, float radius, inout float out_t){ vec3 O_C = origin - center; float A = dot(dir,dir); float B = 2.0 * dot( dir, O_C); float D = dot(O_C, O_C) - (radius * radius); if ((B * B - 4.0 * A * D) < 0.0){ return false; // not hitting Sphere } float det = sqrt(B * B - 4.0 * A * D); // Far contact: float t1 = (0.0 - B + det) / (2.0 * A); // Output the Near contact: out_t = (0.0 - B - det) / (2.0 * A); return true; // hitting the Sphere } // Gold Noise ©2015 dcerisano@standard3d.com // - based on the Golden Ratio // - uniform normalized distribution // - fastest static noise generator function (also runs at low precision) float PHI = 1.61803398874989484820459; // Φ = Golden Ratio float gold_noise(in vec2 xy, in float seed){ return fract(tan(distance(xy*PHI, xy)*seed)*xy.x); } vec3 pixelColor(vec2 pixel){ vec3 color = Background; Ray ray = getRay(pixel); AABB aabb; aabb.minP = vec3(-0.5); aabb.maxP = vec3(0.5); mat4 allTransforms[7]; allTransforms[0] = mtFloor; allTransforms[1] = mtRoof; allTransforms[2] = mtWallBack; allTransforms[3] = mtWallLeft; allTransforms[4] = mtWallRight; allTransforms[5] = mtBig; allTransforms[6] = mtSmall; vec3 matCols[7]; matCols[0] = vec3(0.9,0.9,0.9); matCols[1] = vec3(0.9,0.9,0.9); matCols[2] = vec3(0.9,0.9,0.9); matCols[3] = vec3(0.9,0.1,0.1); matCols[4] = vec3(0.1,0.9,0.1); matCols[5] = vec3(0.9,0.9,0.9); matCols[6] = vec3(0.9,0.9,0.9); float tmin = INFINITY; int matchID = -1; for(int i=0; i < 7; i++){ Ray invRay = ray; // get original ray mat4 mt = allTransforms[i]; // inverse transform mat4 imt = inverse(mt); // inverse transform // apply transform to ray vec4 transformedRayOrigin = imt * vec4(invRay.origin, 1.0); vec4 transformedRayDir = imt * vec4(invRay.direction, 0.0); invRay.origin = transformedRayOrigin.xyz; invRay.direction = transformedRayDir.xyz; // compute tmin if (insersectsRayCannonicalAABB(invRay)){ if(invRay.tMin < tmin){ matchID = i; tmin = invRay.tMin; } } } if(matchID > -1){ Ray invRay = ray; // get original ray mat4 mt = allTransforms[matchID]; mat4 imt = inverse(mt); vec4 transformedRayOrigin = imt * vec4(invRay.origin, 1.0); vec4 transformedRayDir = imt * vec4(invRay.direction, 0.0); invRay.origin = vec3(transformedRayOrigin[0], transformedRayOrigin[1], transformedRayOrigin[2]); invRay.direction = vec3(transformedRayDir[0],transformedRayDir[1],transformedRayDir[2]); vec3 q = pointOnRay(invRay,tmin); vec3 p = pointOnRay(ray,tmin); // hitpoint on real scene vec3 N = getNormal(aabb, q);// normal on cannonical aabb vec4 realN4 = mt * vec4(N,0.0); vec3 realN = normalize(vec3(realN4[0], realN4[1], realN4[2])); // light square grid vec3 colSum = vec3(0.0); float numSamples = 0.0; int numDivisions = numDivs; // per direction int numSamplesPerDiv = numSmpDiv; vec3 squareSize = (lightPosMax - lightPosMin) / float(numDivisions); for(int cols = 0; cols < numDivisions; cols++){ for(int rows = 0; rows < numDivisions; rows++){ vec3 minPoint = lightPosMin + vec3(squareSize.x * float(cols), 0.0, squareSize.z * float(rows)); vec3 maxPoint = minPoint + squareSize; // multiple light samples for(int s=0; s < numSamplesPerDiv; s++){ numSamples += 1.0; float u = gold_noise(pixel, fract(time)+ numSamples + 1.0); float v = gold_noise(pixel, fract(time)+ numSamples + 2.0); // p0 = minPoint vec3 p1 = vec3(maxPoint.x, minPoint.y, minPoint.z); // p2 = maxPoint vec3 p3 = vec3(minPoint.x, maxPoint.y, maxPoint.z); vec3 this_lightpos = (1.0 - v) * ( (1.0 - u) * minPoint + u * p1 ) + v * ( (1.0 - u) * p3 + u * maxPoint ); // diffuse color computation vec3 lightNormal = vec3(0.0, -1.0, 0.0); vec3 this_color = clamp( matCols[matchID] * dot(realN, normalize(this_lightpos - p)) * dot(lightNormal, normalize(p - this_lightpos)) , 0.0, 1.0); // shadow computation for bigbox and small box vec3 shadowRayDir = normalize(this_lightpos - p); float tmin_base; float tmin_boxes = INFINITY; // calc tmin_base checkRayVsSphereCollision(p, shadowRayDir, this_lightpos, 0.0001, tmin_base); // compute tmin_boxes for(int i=5; i < 7; i++){ if(matchID != i) { Ray shadowRay; shadowRay.origin = p; shadowRay.direction = shadowRayDir; shadowRay.tMin = 0.; shadowRay.tMax = INFINITY; mat4 shmt = allTransforms[i]; // inverse transform mat4 ishmt = inverse(shmt); // inverse transform // apply transform to ray vec4 transformedShadowRayOrigin = ishmt * vec4(shadowRay.origin, 1.0); vec4 transformedShadowRayDir = ishmt * vec4(shadowRay.direction, 0.0); shadowRay.origin = transformedShadowRayOrigin.xyz; shadowRay.direction = transformedShadowRayDir.xyz; // compute tmin_boxes if (insersectsRayCannonicalAABB(shadowRay)){ if(shadowRay.tMin < tmin_boxes){ tmin_boxes = shadowRay.tMin; } } } } if(tmin_boxes < tmin_base){ this_color *= shadowStrength; } colSum += this_color; } } } return clamp( colSum / numSamples , 0.0, 1.0); } //return vec3(gold_noise(pixel, fract(time)+1.0),gold_noise(pixel, fract(time)+2.0),gold_noise(pixel, fract(time)+3.0)); return Background; } ` ]