Clay Engine: More Lamp drawing work

5 files changed, 129 insertions, 0 deletions

diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt
index 6ad18f4afd7..5d26d685418 100644
--- a/source/blender/gpu/CMakeLists.txt
+++ b/source/blender/gpu/CMakeLists.txt
@@ -170,6 +170,8 @@ data_to_c_simple(shaders/gpu_shader_instance_screenspace_variying_color_vert.gls
 data_to_c_simple(shaders/gpu_shader_instance_screen_aligned_axis_name_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_instance_camera_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_instance_distance_line_vert.glsl SRC)
+data_to_c_simple(shaders/gpu_shader_instance_edges_variying_color_geom.glsl SRC)
+data_to_c_simple(shaders/gpu_shader_instance_edges_variying_color_vert.glsl SRC)
 
 data_to_c_simple(shaders/gpu_shader_3D_groundline_geom.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_3D_groundpoint_vert.glsl SRC)
diff --git a/source/blender/gpu/GPU_shader.h b/source/blender/gpu/GPU_shader.h
index a974e2ad12f..7408cc764c2 100644
--- a/source/blender/gpu/GPU_shader.h
+++ b/source/blender/gpu/GPU_shader.h
@@ -158,6 +158,7 @@ typedef enum GPUBuiltinShader {
 	/* instance */
 	GPU_SHADER_INSTANCE_UNIFORM_COLOR,
 	GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE,
+	GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR,
 
 	GPU_NUM_BUILTIN_SHADERS /* (not an actual shader) */
 } GPUBuiltinShader;
diff --git a/source/blender/gpu/intern/gpu_shader.c b/source/blender/gpu/intern/gpu_shader.c
index f554d25082d..612a67e3b09 100644
--- a/source/blender/gpu/intern/gpu_shader.c
+++ b/source/blender/gpu/intern/gpu_shader.c
@@ -81,6 +81,8 @@ extern char datatoc_gpu_shader_instance_screenspace_variying_color_vert_glsl[];
 extern char datatoc_gpu_shader_instance_screen_aligned_axis_name_vert_glsl[];
 extern char datatoc_gpu_shader_instance_camera_vert_glsl[];
 extern char datatoc_gpu_shader_instance_distance_line_vert_glsl[];
+extern char datatoc_gpu_shader_instance_edges_variying_color_geom_glsl[];
+extern char datatoc_gpu_shader_instance_edges_variying_color_vert_glsl[];
 
 extern char datatoc_gpu_shader_3D_groundpoint_vert_glsl[];
 extern char datatoc_gpu_shader_3D_groundline_geom_glsl[];
@@ -772,6 +774,9 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
 		[GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE] = 
 		    { datatoc_gpu_shader_instance_variying_size_variying_color_vert_glsl,
 		      datatoc_gpu_shader_flat_color_frag_glsl },
+		[GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR] = { datatoc_gpu_shader_instance_edges_variying_color_vert_glsl,
+		                                               datatoc_gpu_shader_flat_color_frag_glsl,
+		                                               datatoc_gpu_shader_instance_edges_variying_color_geom_glsl},
 	};
 
 	if (builtin_shaders[shader] == NULL) {
diff --git a/source/blender/gpu/shaders/gpu_shader_instance_edges_variying_color_geom.glsl b/source/blender/gpu/shaders/gpu_shader_instance_edges_variying_color_geom.glsl
new file mode 100644
index 00000000000..6f580ef3ff6
--- /dev/null
+++ b/source/blender/gpu/shaders/gpu_shader_instance_edges_variying_color_geom.glsl
@@ -0,0 +1,57 @@
+
+// Draw "fancy" wireframe, displaying front-facing, back-facing and
+// silhouette lines differently.
+// Mike Erwin, April 2015
+
+// After working with this shader a while, convinced we should make
+// separate shaders for perpective & ortho. (Oct 2016)
+
+// Due to perspective, the line segment's endpoints might disagree on
+// whether the adjacent faces are front facing. This geometry shader
+// decides which edge type to use if endpoints disagree.
+
+uniform mat4 ProjectionMatrix;
+
+uniform bool drawFront = true;
+uniform bool drawBack = true;
+uniform bool drawSilhouette = true;
+
+layout(lines) in;
+layout(line_strip, max_vertices = 2) out;
+
+in vec4 MV_pos[];
+in float edgeClass[];
+in vec3 fCol[];
+
+flat out vec4 finalColor;
+
+void emitLine(vec4 color)
+{
+	gl_Position = ProjectionMatrix * MV_pos[0];
+	EmitVertex();
+	gl_Position = ProjectionMatrix * MV_pos[1];
+	finalColor = color;
+	EmitVertex();
+	EndPrimitive();
+}
+
+void main()
+{
+	float finalEdgeClass = max(edgeClass[0], edgeClass[1]);
+
+	if (finalEdgeClass > 0.0f) {
+		// front-facing edge
+		if (drawFront)
+			emitLine(vec4(fCol[0], 0.75));	
+	}
+	else if (finalEdgeClass < 0.0f) {
+		// back-facing edge
+		if (drawBack)
+			emitLine(vec4(fCol[0], 0.5));
+	}
+	else {
+		// exactly one face is front-facing, silhouette edge
+		if (drawSilhouette)
+			emitLine(vec4(fCol[0], 1.0));
+	}
+}
diff --git a/source/blender/gpu/shaders/gpu_shader_instance_edges_variying_color_vert.glsl b/source/blender/gpu/shaders/gpu_shader_instance_edges_variying_color_vert.glsl
new file mode 100644
index 00000000000..5d1e949c1d4
--- /dev/null
+++ b/source/blender/gpu/shaders/gpu_shader_instance_edges_variying_color_vert.glsl
@@ -0,0 +1,64 @@
+
+// Draw "fancy" wireframe, displaying front-facing, back-facing and
+// silhouette lines differently.
+// Mike Erwin, April 2015
+
+// After working with this shader a while, convinced we should make
+// separate shaders for perpective & ortho. (Oct 2016)
+
+// Due to perspective, the line segment's endpoints might disagree on
+// whether the adjacent faces are front facing. We use a geometry
+// shader to resolve this properly.
+
+uniform mat4 ViewMatrix;
+
+in vec3 pos;
+in vec3 N1, N2; // normals of faces this edge joins (object coords)
+
+/* instance attrib */
+in vec3 color;
+in mat4 InstanceModelMatrix;
+
+out vec4 MV_pos;
+out float edgeClass;
+out vec3 fCol;
+
+// TODO: in float angle; // [-pi .. +pi], + peak, 0 flat, - valley
+
+mat3 NormalMatrix;
+
+bool front(vec3 N, vec3 eye)
+{
+	return dot(NormalMatrix * N, eye) > 0.0;
+}
+
+void main()
+{
+	vec3 eye;
+
+	mat4 ModelViewMatrix = ViewMatrix * InstanceModelMatrix;
+
+	MV_pos = ModelViewMatrix * vec4(pos, 1.0);
+
+	NormalMatrix = transpose(inverse(mat3(ModelViewMatrix)));
+
+	/* if persp */
+	if (ViewMatrix[3][3] == 0.0) {
+		eye = normalize(-MV_pos.xyz);
+	}
+	else {
+		eye = vec3(0.0, 0.0, 1.0);
+	}
+
+	bool face_1_front = front(N1, eye);
+	bool face_2_front = front(N2, eye);
+
+	if (face_1_front && face_2_front)
+		edgeClass = 1.0; // front-facing edge
+	else if (face_1_front || face_2_front)
+		edgeClass = 0.0; // exactly one face is front-facing, silhouette edge
+	else
+		edgeClass = -1.0; // back-facing edge
+
+	fCol = color;
+}