214 lines
8.5 KiB
GLSL
Executable file
214 lines
8.5 KiB
GLSL
Executable file
// https://github.com/Friduric/voxel-cone-tracing
|
|
// https://github.com/Cigg/Voxel-Cone-Tracing
|
|
// https://github.com/GreatBlambo/voxel_cone_tracing/
|
|
// http://simonstechblog.blogspot.com/2013/01/implementing-voxel-cone-tracing.html
|
|
// http://leifnode.com/2015/05/voxel-cone-traced-global-illumination/
|
|
// http://www.seas.upenn.edu/%7Epcozzi/OpenGLInsights/OpenGLInsights-SparseVoxelization.pdf
|
|
// https://research.nvidia.com/sites/default/files/publications/GIVoxels-pg2011-authors.pdf
|
|
uniform sampler3D voxels;
|
|
|
|
const float VOXEL_SIZE = 1.0 / voxelgiResolution;
|
|
const float MAX_MIPMAP = 5.4;
|
|
const float VOXEL_RATIO = 128.0 / voxelgiResolution;
|
|
|
|
// vec3 tangent(const vec3 n) {
|
|
// vec3 t1 = cross(n, vec3(0, 0, 1));
|
|
// vec3 t2 = cross(n, vec3(0, 1, 0));
|
|
// if (length(t1) > length(t2)) return normalize(t1);
|
|
// else return normalize(t2);
|
|
// }
|
|
|
|
// uvec3 face_indices(vec3 dir) {
|
|
// uvec3 ret;
|
|
// ret.x = (dir.x < 0.0) ? 0 : 1;
|
|
// ret.y = (dir.y < 0.0) ? 2 : 3;
|
|
// ret.z = (dir.z < 0.0) ? 4 : 5;
|
|
// return ret;
|
|
// }
|
|
|
|
// vec4 sample_voxel(vec3 pos, vec3 dir, uvec3 indices, float lod) {
|
|
// dir = abs(dir);
|
|
// return dir.x * textureLod(voxels[indices.x], pos, lod) +
|
|
// dir.y * textureLod(voxels[indices.y], pos, lod) +
|
|
// dir.z * textureLod(voxels[indices.z], pos, lod);
|
|
// }
|
|
|
|
vec3 orthogonal(const vec3 u) {
|
|
// Pass normalized u
|
|
const vec3 v = vec3(0.99146, 0.11664, 0.05832); // Pick any normalized vector.
|
|
return abs(dot(u, v)) > 0.99999 ? cross(u, vec3(0.0, 1.0, 0.0)) : cross(u, v);
|
|
}
|
|
|
|
// vec4 trace_cone(vec3 origin, vec3 dir, float aperture, float max_dist) {
|
|
// dir = normalize(dir);
|
|
// // uvec3 indices = face_indices(dir);
|
|
// vec4 sample_color = vec4(0.0);
|
|
// float dist = 3 * VOXEL_SIZE;
|
|
// float diam = dist * aperture;
|
|
// vec3 sample_position = dir * dist + origin;
|
|
// // Step until alpha > 1 or out of bounds
|
|
// while (sample_color.a < 1.0 && dist < max_dist) {
|
|
// // Choose mip level based on the diameter of the cone
|
|
// float mip = max(log2(diam * voxelgiResolution), 0);
|
|
// // vec4 mip_sample = sample_voxel(sample_position, dir, indices, mip);
|
|
// vec4 mip_sample = textureLod(voxels, sample_position * 0.5 + vec3(0.5), mip);
|
|
// // Blend mip sample with current sample color
|
|
// sample_color += (1 - sample_color.a) * mip_sample;
|
|
// float step_size = max(diam / 2, VOXEL_SIZE);
|
|
// dist += step_size;
|
|
// diam = dist * aperture;
|
|
// sample_position = dir * dist + origin;
|
|
// }
|
|
// return sample_color;
|
|
// }
|
|
|
|
// vec4 traceDiffuse(vec3 origin, vec3 normal) {
|
|
// const float TAN_22_5 = 0.55785173935;
|
|
// const float MAX_DISTANCE = 1.73205080757;
|
|
// const float angle_mix = 0.5f;
|
|
// const float aperture = TAN_22_5;
|
|
// vec4 result_diffuse = vec4(0.0);
|
|
|
|
// const vec3 o1 = normalize(tangent(normal));
|
|
// const vec3 o2 = normalize(cross(o1, normal));
|
|
|
|
// const vec3 c1 = 0.5f * (o1 + o2);
|
|
// const vec3 c2 = 0.5f * (o1 - o2);
|
|
|
|
// // Normal direction
|
|
// result_diffuse += trace_cone(origin, normal, aperture, MAX_DISTANCE);
|
|
|
|
// // 4 side cones
|
|
// result_diffuse += trace_cone(origin, mix(normal, o1, angle_mix), aperture, MAX_DISTANCE);
|
|
// result_diffuse += trace_cone(origin, mix(normal, -o1, angle_mix), aperture, MAX_DISTANCE);
|
|
// result_diffuse += trace_cone(origin, mix(normal, o2, angle_mix), aperture, MAX_DISTANCE);
|
|
// result_diffuse += trace_cone(origin, mix(normal, -o2, angle_mix), aperture, MAX_DISTANCE);
|
|
|
|
// // 4 corners
|
|
// result_diffuse += trace_cone(origin, mix(normal, c1, angle_mix), aperture, MAX_DISTANCE);
|
|
// result_diffuse += trace_cone(origin, mix(normal, -c1, angle_mix), aperture, MAX_DISTANCE);
|
|
// result_diffuse += trace_cone(origin, mix(normal, c2, angle_mix), aperture, MAX_DISTANCE);
|
|
// result_diffuse += trace_cone(origin, mix(normal, -c2, angle_mix), aperture, MAX_DISTANCE);
|
|
|
|
// return vec4(result_diffuse.rgb / 9, 1.0);
|
|
// }
|
|
|
|
vec4 traceDiffuseVoxelCone(const vec3 from, vec3 direction) {
|
|
direction = normalize(direction);
|
|
const float CONE_SPREAD = 0.325;
|
|
vec4 acc = vec4(0.0);
|
|
// Controls bleeding from close surfaces
|
|
// Low values look rather bad if using shadow cone tracing
|
|
float dist = 0.1953125 / (9.0 * VOXEL_RATIO * voxelgiStep);
|
|
const float SQRT2 = 1.414213 * voxelgiRange;
|
|
while (dist < SQRT2 && acc.a < 1.0) {
|
|
vec3 c = vec3(from + dist * direction) * 0.5 + vec3(0.5);
|
|
float l = (1.0 + CONE_SPREAD * dist / VOXEL_SIZE);
|
|
float level = log2(l);
|
|
float ll = (level + 1.0) * (level + 1.0);
|
|
vec4 voxel = textureLod(voxels, c, min(MAX_MIPMAP, level));
|
|
|
|
#ifdef _Cycles
|
|
voxel.rgb = min(voxel.rgb * 0.9, vec3(0.9)) + max((voxel.rgb - 0.9) * 200.0, 0.0); // Higher range to allow emission
|
|
#endif
|
|
|
|
acc += 0.075 * ll * voxel * pow(1.0 - voxel.a, 2.0);
|
|
dist += ll * VOXEL_SIZE * 2.0;
|
|
}
|
|
return acc;
|
|
}
|
|
|
|
vec4 indirectDiffuseLight(const vec3 wpos, const vec3 normal) {
|
|
const float ANGLE_MIX = 0.5; // Angle mix (1.0f -> orthogonal direction, 0.0f -> direction of normal)
|
|
// Find a base for the side cones with the normal as one of its base vectors
|
|
const vec3 ortho = normalize(orthogonal(normal));
|
|
const vec3 ortho2 = normalize(cross(ortho, normal));
|
|
// Find base vectors for the corner cones
|
|
const vec3 corner = 0.5 * (ortho + ortho2);
|
|
const vec3 corner2 = 0.5 * (ortho - ortho2);
|
|
// Find start position of trace (start with a bit of offset)
|
|
const vec3 origin = wpos + normal * 3.8 * VOXEL_SIZE;
|
|
|
|
// We offset forward in normal direction, and backward in cone direction
|
|
// Backward in cone direction improves GI, and forward direction removes artifacts
|
|
const float CONE_OFFSET = 0.01;
|
|
// Trace front cone
|
|
vec4 acc = traceDiffuseVoxelCone(origin + CONE_OFFSET * normal, normal);
|
|
|
|
// Trace 4 side cones
|
|
const vec3 s1 = mix(normal, ortho, ANGLE_MIX);
|
|
const vec3 s2 = mix(normal, -ortho, ANGLE_MIX);
|
|
const vec3 s3 = mix(normal, ortho2, ANGLE_MIX);
|
|
const vec3 s4 = mix(normal, -ortho2, ANGLE_MIX);
|
|
acc += traceDiffuseVoxelCone(origin + CONE_OFFSET * ortho, s1);
|
|
acc += traceDiffuseVoxelCone(origin - CONE_OFFSET * ortho, s2);
|
|
acc += traceDiffuseVoxelCone(origin + CONE_OFFSET * ortho2, s3);
|
|
acc += traceDiffuseVoxelCone(origin - CONE_OFFSET * ortho2, s4);
|
|
|
|
// Trace 4 corner cones
|
|
const vec3 c1 = mix(normal, corner, ANGLE_MIX);
|
|
const vec3 c2 = mix(normal, -corner, ANGLE_MIX);
|
|
const vec3 c3 = mix(normal, corner2, ANGLE_MIX);
|
|
const vec3 c4 = mix(normal, -corner2, ANGLE_MIX);
|
|
acc += traceDiffuseVoxelCone(origin + CONE_OFFSET * corner, c1);
|
|
acc += traceDiffuseVoxelCone(origin - CONE_OFFSET * corner, c2);
|
|
acc += traceDiffuseVoxelCone(origin + CONE_OFFSET * corner2, c3);
|
|
acc += traceDiffuseVoxelCone(origin - CONE_OFFSET * corner2, c4);
|
|
|
|
return acc;
|
|
}
|
|
|
|
vec3 traceSpecularVoxelCone(vec3 from, vec3 direction, const vec3 normal, const float specularDiffusion) {
|
|
direction = normalize(direction);
|
|
float MAX_DISTANCE = distance(vec3(abs(from)), vec3(-1));
|
|
|
|
const float OFFSET = 8 * VOXEL_SIZE;
|
|
const float STEP = VOXEL_SIZE;
|
|
from += OFFSET * normal;
|
|
|
|
vec4 acc = vec4(0.0);
|
|
float dist = OFFSET;
|
|
|
|
while (dist < MAX_DISTANCE && acc.a < 1.0) {
|
|
vec3 c = from + dist * direction;
|
|
if (!isInsideCube(c)) break;
|
|
c = c * 0.5 + vec3(0.5);
|
|
|
|
float level = 0.1 * specularDiffusion * log2(1.0 + dist / VOXEL_SIZE);
|
|
vec4 voxel = textureLod(voxels, c, min(level, MAX_MIPMAP));
|
|
float f = 1.0 - acc.a;
|
|
acc.rgb += 0.25 * (1.0 + specularDiffusion) * voxel.rgb * voxel.a * f;
|
|
acc.a += 0.25 * voxel.a * f;
|
|
dist += STEP * (1.0 + 0.125 * level);
|
|
}
|
|
return 1.0 * pow(specularDiffusion + 1, 0.8) * acc.rgb;
|
|
}
|
|
|
|
vec3 indirectRefractiveLight(const vec3 v, const vec3 normal, const vec3 specCol, const float opacity, const vec3 wpos) {
|
|
const float refractiveIndex = 1.2;
|
|
vec3 refraction = refract(v, normal, 1.0 / refractiveIndex);
|
|
vec3 cmix = mix(0.5 * (specCol + vec3(1.0)), specCol, opacity);
|
|
return cmix * traceSpecularVoxelCone(wpos, refraction, normal, 0.1);
|
|
}
|
|
|
|
float traceShadowCone(vec3 from, vec3 direction, float targetDistance, vec3 normal) {
|
|
from += normal * 0.0; // Removes artifacts but makes self shadowing for dense meshes meh
|
|
float acc = 0.0;
|
|
float dist = 3 * VOXEL_SIZE;
|
|
// I'm using a pretty big margin here since I use an emissive light ball with a pretty big radius in my demo scenes.
|
|
const float STOP = targetDistance - 16.0 * VOXEL_SIZE;
|
|
|
|
while (dist < STOP && acc < 1.0) {
|
|
vec3 c = from + dist * direction;
|
|
if (!isInsideCube(c)) break;
|
|
c = c * 0.5 + vec3(0.5);
|
|
float l = pow(dist, 2.0); // Experimenting with inverse square falloff for shadows.
|
|
float s1 = 0.062 * textureLod(voxels, c, 1.0 + 0.75 * l).a;
|
|
float s2 = 0.135 * textureLod(voxels, c, 4.5 * l).a;
|
|
float s = s1 + s2;
|
|
acc += (1.0 - acc) * s;
|
|
dist += 0.9 * VOXEL_SIZE * (1.0 + 0.05 * l);
|
|
}
|
|
return 1.0 - pow(smoothstep(0.0, 1.0, acc * 1.4), 1.0 / 1.4);
|
|
}
|