mesh_linespace.glsl

#ifndef INCLUDE_PATHTRACER_LINESPACE_GLSL
#define INCLUDE_PATHTRACER_LINESPACE_GLSL

#include <util/scene/mesh.glsl>
#include <util/tracing/intersections.glsl>
#include <util/tracing/linespace.glsl>
#include <util/tracing/tracing.glsl>

uint configurationID(uint in_face, uint out_face)
{
	return uint((((-0.5f * float(in_face)) + 4.5f)*float(in_face))) - 1u + out_face;
}

uint linesBetweenFaces(const in Linespace linespace, uint inface, uint outface)
{
	uint axis_in_width = linespace.resolution[face_width_axis[inface % 3]];
	uint axis_in_height = linespace.resolution[face_height_axis[inface % 3]];

	uint axis_out_width = linespace.resolution[face_width_axis[outface % 3]];
	uint axis_out_height = linespace.resolution[face_height_axis[outface % 3]];

	return axis_in_width * axis_in_height * axis_out_width * axis_out_height;
}

uint offsetOf(const in Linespace linespace, uint inface, uint outface)
{
	uint offset = 0;

	// Caution! Fallthrough switch. Seemed to perform much better than a for-loop, usually even being faster than precalculated offsets in release builds.
	switch (configurationID(inface, outface))
	{
	case 15:
		offset += linesBetweenFaces(linespace, 4, 5);
	case 14:
		offset += linesBetweenFaces(linespace, 3, 5);
	case 13:
		offset += linesBetweenFaces(linespace, 3, 4);
	case 12:
		offset += linesBetweenFaces(linespace, 2, 5);
	case 11:
		offset += linesBetweenFaces(linespace, 2, 4);
	case 10:
		offset += linesBetweenFaces(linespace, 2, 3);
	case 9:
		offset += linesBetweenFaces(linespace, 1, 5);
	case 8:
		offset += linesBetweenFaces(linespace, 1, 4);
	case 7:
		offset += linesBetweenFaces(linespace, 1, 3);
	case 6:
		offset += linesBetweenFaces(linespace, 1, 2);
	case 5:
		offset += linesBetweenFaces(linespace, 0, 5);
	case 4:
		offset += linesBetweenFaces(linespace, 0, 4);
	case 3:
		offset += linesBetweenFaces(linespace, 0, 3);
	case 2:
		offset += linesBetweenFaces(linespace, 0, 2);
	case 1:
		offset += linesBetweenFaces(linespace, 0, 1);
	case 0:
	default:
		break;
	}

	return offset;
}

uvec2 getPatch(const in Mesh mesh, vec3 at_position, int axis, int face){
	bool flip_indices = face != axis;
	return !flip_indices
		?	uvec2(at_position[face_width_axis[axis]] / mesh.linespace.patch_size, at_position[face_height_axis[axis]] / mesh.linespace.patch_size)
		:	uvec2(mesh.linespace.resolution[face_width_axis[axis]], mesh.linespace.resolution[face_height_axis[axis]]) -
			uvec2(at_position[face_width_axis[axis]] / mesh.linespace.patch_size, at_position[face_height_axis[axis]] / mesh.linespace.patch_size)- 1;
}

struct PatchInfo
{
	int face;
	int axis;
	uvec2 patch_index;
	vec3 position;
	float t;
};

uint lineIndex(const in Ray ray, const in Mesh mesh, float tmin, float tmax, int face_in, int face_out, inout bool direction_swapped)
{
	Linespace linespace = mesh.linespace;

	PatchInfo entry_info;
	PatchInfo exit_info;

	// face_in > face_out is an unsupported configuration for reasons of generation performance and memory conservation.
	// If that happens, flip tmin, tmax and the two faces accordingly and mark it as flipped to we can take the farthest intersection in the shaft instead of the nearest.
	direction_swapped = face_in > face_out;
	// -------- t values -------------
	entry_info.t = direction_swapped ? tmax : tmin;
	exit_info.t = direction_swapped ? tmin : tmax;
	// -------- faces ----------------
	entry_info.face = direction_swapped ? face_out : face_in;
	exit_info.face = direction_swapped ? face_in : face_out;
	/////////////////////////////////////////////////////////////

	//calculate entry and exit points on the minimum-normalized bounding box
	//(so that bounds.min is at (0,0,0) and bounds.max is at the former bounding box's size)
	entry_info.position = ray.origin + entry_info.t * ray.direction - linespace.bounds.min.xyz;
	exit_info.position = ray.origin + exit_info.t * ray.direction - linespace.bounds.min.xyz;

	entry_info.axis = entry_info.face % 3;
	exit_info.axis = exit_info.face % 3;

	// getPatch mirrors the patches on the negative axises per definition.
	entry_info.patch_index = getPatch(mesh, entry_info.position, entry_info.axis, entry_info.face);
	exit_info.patch_index = getPatch(mesh, exit_info.position, exit_info.axis, exit_info.face);

	//Now with all that information, we can retrieve the line index.
	uint offset = offsetOf(linespace, entry_info.face, exit_info.face);

	uint start_height = linespace.resolution[face_height_axis[entry_info.axis]];
	uint end_width = linespace.resolution[face_width_axis[exit_info.axis]];
	uint end_height = linespace.resolution[face_height_axis[exit_info.axis]];

	uint start = (entry_info.patch_index.y + entry_info.patch_index.x * start_height) * end_width * end_height;
	uint end = (exit_info.patch_index.y + exit_info.patch_index.x * end_height);

	return offset + start + end;
}

bool traverseLineSpace(const in Mesh mesh, const in Ray local_ray, const in bool use_first, const in float max_distance, inout Hit hit, inout float t_min)
{
	float tmin;
	float tmax;
	int face_tmin;
	int face_tmax;

	float offset = mesh.linespace.patch_size;//1;//e-2;//1000;//mesh.linespace.patch_size;

	Ray offset_ray = local_ray;
	offset_ray.origin += local_ray.direction * offset;

	if(!offset_ray.intersectsBounds(mesh.linespace.bounds, tmin, tmax, face_tmin, face_tmax) || t_min <= tmin-offset || tmin-offset > max_distance)
	{
		return false;
	}

	bool swapped = false;
	uint line_id = lineIndex(offset_ray, mesh, tmin, tmax, face_tmin, face_tmax, swapped);
	Line line = mesh.linespace.lines[line_id];

	int near_data = swapped ? line.farthest : line.nearest;
	Hit nearer;
	float t;

	if(near_data != -1)
	{
		nearer.triangle = near_data;
		nearer.mesh = mesh.id;
		if(local_ray.intersectsTrianglePlane(near_data, mesh, t, nearer.barycentric.x, nearer.barycentric.y))
		{
			float nearest_distance = t-offset;
			if(nearest_distance > 0 && max_distance > nearest_distance){
				hit = nearer;
				t_min = t;
				//Found an intersected shaft. But we don't yet know whether it contains geometry, so look it up as a last step.
				return true;
			}
		}
	}

	near_data = swapped ? line.nearest : line.farthest;
	if(near_data != -1)
	{
		nearer.triangle = near_data;
		nearer.mesh = mesh.id;
		if(local_ray.intersectsTrianglePlane(near_data, mesh, t, nearer.barycentric.x, nearer.barycentric.y))
		{
			float farthest_distance = t-offset;

			if(farthest_distance > 0 && max_distance > farthest_distance){
				hit = nearer;
				t_min = t;
				//Found an intersected shaft. But we don't yet know whether it contains geometry, so look it up as a last step.
				return true;
			}
		}
	}

	return false;

}

#endif //INCLUDE_PATHTRACER_LINESPACE_GLSL