Implement cross-section vertex shader

Author: HenryWConklin

render/cross_section/cross_section_shader.glsl

@@ -1,6 +1,6 @@
 shader_type spatial;
 render_mode skip_vertex_transform;
-render_mode unshaded;
+// render_mode unshaded;
 
 // World space
 // Not allowed to pass matrices through instance uniforms, so have to unpack into vectors.
@@ -10,17 +10,114 @@ instance uniform vec4 modelview_basis_y;
 instance uniform vec4 modelview_basis_z;
 instance uniform vec4 modelview_basis_w;
 
-uniform vec4 albedo: source_color; 
+uniform vec4 albedo : source_color;
+uniform float grid_size;
+
+varying vec3 uvw;
+
+// Maps from an arbitrary edge index to the indices of the vertices in a tetrahedron [a,b,c,d].
+const int TETRAHEDRON_EDGE_TO_VERTEX_MAP[] = {
+	0, 1,
+	0, 2,
+	0, 3,
+	1, 2,
+	1, 3,
+	2, 3
+};
+// Nonsense abstract lookup table for different cases of vertices above and below the cross-section plane. Derived by
+// sketching out 3D tetrahedra and hoping it also worked for 4D (it does).
+// 16 cases for number of vertices above and below the cross-section plane, each case leads to at most two triangles for 6 vertices.
+// Each triangle in the cross-section is made up of vertices that are interpolated along the edges of the tetrahedron,
+// falling where the edge intersetcs the cross-section plane. So this table is 16x6, 16 cases, 6 possible verts,
+// each value maps to an edge in the TETRAHEDRON_EDGE_TO_VERTEX_MAP. -1 indicates the vertex is unused for that case.
+// General pattern: one vertex above and three below is one triangle on the edges between the one vertex above and the rest,
+// one vertex below and three above is same but the winding order is flipped, two above and two below is two triangles in some awful pattern.
+// Flipping the bit pattern (i.e. flipping the tetrahedron) reverses the winding order of both triangles.
+const int CROSS_SECTION_LOOKUP[] = {
+	-1, -1, -1, -1, -1, -1, // 0000
+	0, 1, 2, -1, -1, -1, // 0001
+	0, 4, 3, -1, -1, -1, // 0010
+	2, 4, 1, 3, 1, 4, // 0011
+	1, 3, 5, -1, -1, -1, // 0100
+	0, 3, 2, 5, 2, 3, // 0101
+	1, 0, 5, 4, 5, 0, // 0110
+	2, 4, 5, -1, -1, -1, // 0111
+	2, 5, 4, -1, -1, -1, // 1000
+	1, 5, 0, 4, 0, 5, // 1001
+	0, 2, 3, 3, 2, 5, // 1010
+	1, 5, 3, -1, -1, -1, // 1011
+	2, 1, 4, 4, 1, 3, // 1100
+	0, 3, 4, -1, -1, -1, // 1101
+	0, 2, 1, -1, -1, -1, // 1110
+	-1, -1, -1, -1, -1, -1 // 1111
+};
+
+int get_face_lookup_index(float w1, float w2, float w3, float w4, int vertex_id) {
+	// Bitwise ops limit compatibility so summing instead.
+	int negative1 = w1 < 0.0 ? 1 : 0;
+	int negative2 = w2 < 0.0 ? 2 : 0;
+	int negative3 = w3 < 0.0 ? 4 : 0;
+	int negative4 = w4 < 0.0 ? 8 : 0;
+	int lookup_index = negative1 + negative2 + negative3 + negative4;
+
+	// First index in the group of three that the indicated vertex belongs to.
+	return (lookup_index * 6) + vertex_id - (vertex_id % 3);
+}
+
+vec3 slice_edge(vec4 v1, vec4 v2) {
+	float mix_weight = v1.w / (v1.w - v2.w);
+	return mix(v1, v2, mix_weight).xyz;
+}
 
 void vertex() {
-    mat4 modelview_basis = mat4(modelview_basis_x, modelview_basis_y, modelview_basis_z, modelview_basis_w);
-    // Make an arbitrary triangle from the cell so there's something on the screen.
-    vec4 position = (VERTEX.x == 1.0 ? CUSTOM0 : (VERTEX.y == 1.0 ? CUSTOM1 : CUSTOM2));
-    position = (modelview_basis * position) + modelview_origin;
-    POSITION = PROJECTION_MATRIX * vec4(position.xyz, 1.0);
-    // TODO actual cross-sectioning
+	mat4 modelview_basis = mat4(modelview_basis_x, modelview_basis_y, modelview_basis_z, modelview_basis_w);
+
+	vec4 verts[] = { CUSTOM0, CUSTOM1, CUSTOM2, CUSTOM3 };
+	verts[0] = (modelview_basis * verts[0]) + modelview_origin;
+	verts[1] = (modelview_basis * verts[1]) + modelview_origin;
+	verts[2] = (modelview_basis * verts[2]) + modelview_origin;
+	verts[3] = (modelview_basis * verts[3]) + modelview_origin;
+
+	vec3 uvws[] = { vec3(UV, COLOR.a), vec3(UV2, VERTEX.y), NORMAL, COLOR.rgb };
+
+	int vertex_id = int(VERTEX.x);
+	int face = get_face_lookup_index(verts[0].w, verts[1].w, verts[2].w, verts[3].w, vertex_id);
+	if (CROSS_SECTION_LOOKUP[face] == -1) {
+		// This vertex is unused, cull
+		POSITION = vec4(0.0, 0.0, CLIP_SPACE_FAR, 1.0);
+	} else {
+		int position_edge = CROSS_SECTION_LOOKUP[face + (vertex_id % 3)];
+		int edge_vert1 = TETRAHEDRON_EDGE_TO_VERTEX_MAP[position_edge * 2];
+		int edge_vert2 = TETRAHEDRON_EDGE_TO_VERTEX_MAP[(position_edge * 2) + 1];
+		vec4 position1 = verts[edge_vert1];
+		vec4 position2 = verts[edge_vert2];
+		float mix_weight = position1.w / (position1.w - position2.w);
+		vec4 position = mix(position1, position2, mix_weight);
+		// Vertex is view space and used for lighting, position is clip space and used for rasterizing.
+		VERTEX = position.xyz;
+		POSITION = PROJECTION_MATRIX * vec4(position.xyz, 1.0);
+
+		uvw = mix(uvws[edge_vert1], uvws[edge_vert2], mix_weight);
+
+		// Compute flat normals.
+		int face_v1_edge = CROSS_SECTION_LOOKUP[face];
+		int face_v2_edge = CROSS_SECTION_LOOKUP[face + 1];
+		int face_v3_edge = CROSS_SECTION_LOOKUP[face + 2];
+		vec3 face_v1 = slice_edge(verts[TETRAHEDRON_EDGE_TO_VERTEX_MAP[face_v1_edge * 2]], verts[TETRAHEDRON_EDGE_TO_VERTEX_MAP[face_v1_edge * 2 + 1]]);
+		vec3 face_v2 = slice_edge(verts[TETRAHEDRON_EDGE_TO_VERTEX_MAP[face_v2_edge * 2]], verts[TETRAHEDRON_EDGE_TO_VERTEX_MAP[face_v2_edge * 2 + 1]]);
+		vec3 face_v3 = slice_edge(verts[TETRAHEDRON_EDGE_TO_VERTEX_MAP[face_v3_edge * 2]], verts[TETRAHEDRON_EDGE_TO_VERTEX_MAP[face_v3_edge * 2 + 1]]);
+		vec3 normal = normalize(cross(face_v2 - face_v1, face_v3 - face_v1));
+		vec3 tangent = normalize(face_v2 - face_v1);
+		vec3 binormal = normalize(cross(normal, tangent));
+		NORMAL = normal;
+		TANGENT = tangent;
+		BINORMAL = binormal;
+	}
 }
 
 void fragment() {
-    ALBEDO = albedo.rgb;
+	vec3 uvw_scaled = uvw * 10.0;
+	int cell = (int(uvw_scaled.x) + int(uvw_scaled.y) + int(uvw_scaled.z)) % 2;
+	ALBEDO = cell == 0 ? vec3(0.0) : albedo.rgb;
+	NORMAL = normalize(NORMAL);
 }