mirror of
https://github.com/ZDoom/Raze.git
synced 2024-12-13 22:21:14 +00:00
190 lines
5.2 KiB
GLSL
190 lines
5.2 KiB
GLSL
|
|
layout(location=0) in vec2 TexCoord;
|
|
layout(location=0) out vec4 FragColor;
|
|
|
|
// A node in an AABB binary tree with lines stored in the leaf nodes
|
|
struct GPUNode
|
|
{
|
|
vec2 aabb_min; // Min xy values for the axis-aligned box containing the node and its subtree
|
|
vec2 aabb_max; // Max xy values
|
|
int left; // Left subnode index
|
|
int right; // Right subnode index
|
|
int line_index; // Line index if it is a leaf node, otherwise -1
|
|
int padding; // Unused - maintains 16 byte alignment
|
|
};
|
|
|
|
// 2D line segment, referenced by leaf nodes
|
|
struct GPULine
|
|
{
|
|
vec2 pos; // Line start position
|
|
vec2 delta; // Line end position - line start position
|
|
};
|
|
|
|
layout(std430, binding = 4) buffer LightNodes
|
|
{
|
|
GPUNode nodes[];
|
|
};
|
|
|
|
layout(std430, binding = 5) buffer LightLines
|
|
{
|
|
GPULine lines[];
|
|
};
|
|
|
|
layout(std430, binding = 6) buffer LightList
|
|
{
|
|
vec4 lights[];
|
|
};
|
|
|
|
// Overlap test between line segment and axis-aligned bounding box. Returns true if they overlap.
|
|
bool overlapRayAABB(vec2 ray_start2d, vec2 ray_end2d, vec2 aabb_min2d, vec2 aabb_max2d)
|
|
{
|
|
// To do: simplify test to use a 2D test
|
|
vec3 ray_start = vec3(ray_start2d, 0.0);
|
|
vec3 ray_end = vec3(ray_end2d, 0.0);
|
|
vec3 aabb_min = vec3(aabb_min2d, -1.0);
|
|
vec3 aabb_max = vec3(aabb_max2d, 1.0);
|
|
|
|
vec3 c = (ray_start + ray_end) * 0.5f;
|
|
vec3 w = ray_end - c;
|
|
vec3 h = (aabb_max - aabb_min) * 0.5f; // aabb.extents();
|
|
|
|
c -= (aabb_max + aabb_min) * 0.5f; // aabb.center();
|
|
|
|
vec3 v = abs(w);
|
|
|
|
if (abs(c.x) > v.x + h.x || abs(c.y) > v.y + h.y || abs(c.z) > v.z + h.z)
|
|
return false; // disjoint;
|
|
|
|
if (abs(c.y * w.z - c.z * w.y) > h.y * v.z + h.z * v.y ||
|
|
abs(c.x * w.z - c.z * w.x) > h.x * v.z + h.z * v.x ||
|
|
abs(c.x * w.y - c.y * w.x) > h.x * v.y + h.y * v.x)
|
|
return false; // disjoint;
|
|
|
|
return true; // overlap;
|
|
}
|
|
|
|
// Intersection test between two line segments.
|
|
// Returns the intersection point as a value between 0-1 on the ray line segment. 1.0 if there was no hit.
|
|
float intersectRayLine(vec2 ray_start, vec2 ray_end, int line_index, vec2 raydelta, float rayd, float raydist2)
|
|
{
|
|
const float epsilon = 0.0000001;
|
|
GPULine line = lines[line_index];
|
|
|
|
vec2 raynormal = vec2(raydelta.y, -raydelta.x);
|
|
|
|
float den = dot(raynormal, line.delta);
|
|
if (abs(den) > epsilon)
|
|
{
|
|
float t_line = (rayd - dot(raynormal, line.pos)) / den;
|
|
if (t_line >= 0.0 && t_line <= 1.0)
|
|
{
|
|
vec2 linehitdelta = line.pos + line.delta * t_line - ray_start;
|
|
float t = dot(raydelta, linehitdelta) / raydist2;
|
|
return t > 0.0 ? t : 1.0;
|
|
}
|
|
}
|
|
|
|
return 1.0;
|
|
}
|
|
|
|
// Returns true if an AABB tree node is a leaf node. Leaf nodes contains a line.
|
|
bool isLeaf(int node_index)
|
|
{
|
|
return nodes[node_index].line_index != -1;
|
|
}
|
|
|
|
// Perform ray intersection test between the ray line segment and all the lines in the AABB binary tree.
|
|
// Returns the intersection point as a value between 0-1 on the ray line segment. 1.0 if there was no hit.
|
|
float rayTest(vec2 ray_start, vec2 ray_end)
|
|
{
|
|
vec2 raydelta = ray_end - ray_start;
|
|
float raydist2 = dot(raydelta, raydelta);
|
|
vec2 raynormal = vec2(raydelta.y, -raydelta.x);
|
|
float rayd = dot(raynormal, ray_start);
|
|
if (raydist2 < 1.0)
|
|
return 1.0;
|
|
|
|
float t = 1.0;
|
|
|
|
// Walk the AABB binary tree searching for nodes touching the ray line segment's AABB box.
|
|
// When it reaches a leaf node, use a line segment intersection test to see if we got a hit.
|
|
|
|
int stack[32];
|
|
int stack_pos = 1;
|
|
stack[0] = NodesCount - 1;
|
|
while (stack_pos > 0)
|
|
{
|
|
int node_index = stack[stack_pos - 1];
|
|
|
|
if (!overlapRayAABB(ray_start, ray_end, nodes[node_index].aabb_min, nodes[node_index].aabb_max))
|
|
{
|
|
stack_pos--;
|
|
}
|
|
else if (isLeaf(node_index))
|
|
{
|
|
t = min(intersectRayLine(ray_start, ray_end, nodes[node_index].line_index, raydelta, rayd, raydist2), t);
|
|
stack_pos--;
|
|
}
|
|
else if (stack_pos == 32)
|
|
{
|
|
stack_pos--; // stack overflow
|
|
}
|
|
else
|
|
{
|
|
stack[stack_pos - 1] = nodes[node_index].left;
|
|
stack[stack_pos] = nodes[node_index].right;
|
|
stack_pos++;
|
|
}
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
void main()
|
|
{
|
|
// Find the light that belongs to this texel in the shadowmap texture we output to:
|
|
|
|
int lightIndex = int(gl_FragCoord.y);
|
|
|
|
vec4 light = lights[lightIndex];
|
|
float radius = light.w;
|
|
vec2 lightpos = light.xy;
|
|
|
|
if (radius > 0.0)
|
|
{
|
|
// We found an active light. Calculate the ray direction for the texel.
|
|
//
|
|
// The texels are laid out so that there are four projections:
|
|
//
|
|
// * top-left to top-right
|
|
// * top-right to bottom-right
|
|
// * bottom-right to bottom-left
|
|
// * bottom-left to top-left
|
|
//
|
|
vec2 raydir;
|
|
float u = gl_FragCoord.x / ShadowmapQuality * 4.0;
|
|
switch (int(u))
|
|
{
|
|
case 0: raydir = vec2(u * 2.0 - 1.0, 1.0); break;
|
|
case 1: raydir = vec2(1.0, 1.0 - (u - 1.0) * 2.0); break;
|
|
case 2: raydir = vec2(1.0 - (u - 2.0) * 2.0, -1.0); break;
|
|
case 3: raydir = vec2(-1.0, (u - 3.0) * 2.0 - 1.0); break;
|
|
}
|
|
|
|
// Find the position for the ray starting at the light position and travelling until light contribution is zero:
|
|
vec2 pixelpos = lightpos + raydir * radius;
|
|
|
|
// Check if we hit any line between the light and the end position:
|
|
float t = rayTest(lightpos, pixelpos);
|
|
|
|
// Calculate the square distance for the hit, if any:
|
|
vec2 delta = (pixelpos - lightpos) * t;
|
|
float dist2 = dot(delta, delta);
|
|
|
|
FragColor = vec4(dist2, 0.0, 0.0, 1.0);
|
|
}
|
|
else
|
|
{
|
|
FragColor = vec4(1.0, 0.0, 0.0, 1.0);
|
|
}
|
|
}
|