TDT4230_final_project/res/shaders/simple.frag

160 lines
5.1 KiB
GLSL
Raw Normal View History

2019-02-04 18:32:08 +01:00
#version 430 core
2019-03-16 20:12:35 +01:00
in layout(location = 0) vec3 vertex;
in layout(location = 1) vec3 normal;
2019-03-14 12:43:41 +01:00
in layout(location = 2) vec2 UV;
2019-03-18 11:48:11 +01:00
in layout(location = 3) vec4 color;
in layout(location = 4) vec3 tangent;
in layout(location = 5) vec3 bitangent;
2019-03-15 16:26:31 +01:00
2019-03-14 12:43:41 +01:00
layout(binding = 0) uniform sampler2D diffuseTexture;
layout(binding = 1) uniform sampler2D normalTexture;
2019-03-16 20:12:35 +01:00
layout(binding = 2) uniform sampler2D displacementTexture;
2019-03-19 20:15:13 +01:00
layout(binding = 3) uniform sampler2D reflectionTexture;
2019-03-16 20:12:35 +01:00
uniform float displacementCoefficient;
2019-03-14 12:43:41 +01:00
2019-03-15 16:26:31 +01:00
uniform mat4 MVP;
uniform mat4 MV;
uniform mat4 MVnormal;
// material
uniform float opacity;
2019-03-18 11:48:11 +01:00
uniform float shininess;
2019-03-28 09:35:22 +01:00
uniform float backlight_strength;
2019-03-19 20:15:13 +01:00
uniform float reflexiveness;
uniform vec3 diffuse_color;
uniform vec3 specular_color;
uniform vec3 emissive_color;
2019-03-28 09:35:22 +01:00
uniform vec3 backlight_color;
2019-03-16 20:12:35 +01:00
2019-03-14 12:43:41 +01:00
uniform bool isIlluminated;
uniform bool isTextured;
uniform bool isVertexColored;
2019-03-14 12:43:41 +01:00
uniform bool isNormalMapped;
2019-03-16 20:12:35 +01:00
uniform bool isDisplacementMapped;
2019-03-19 20:15:13 +01:00
uniform bool isReflectionMapped;
2019-03-14 12:43:41 +01:00
uniform bool isInverted;
// lights
2019-03-16 20:12:35 +01:00
struct Light { // point lights, coordinates in MV space
2019-02-19 16:16:13 +01:00
vec3 position;
2019-03-16 20:12:35 +01:00
vec3 attenuation; // 1 / (x + y*l + z*l*l)
vec3 color;
2019-03-16 20:12:35 +01:00
bool is_spot; // false means point light
vec3 spot_direction;
float spot_cuttof_cos;
2019-02-19 16:16:13 +01:00
};
2019-03-20 00:21:51 +01:00
#define N_LIGHTS 3
2019-02-19 16:16:13 +01:00
uniform Light light[N_LIGHTS];
2019-02-04 18:32:08 +01:00
2019-03-18 11:48:11 +01:00
out vec4 color_out;
2019-02-19 16:16:13 +01:00
2019-03-19 20:15:13 +01:00
vec3 reflection(vec3 basecolor, vec3 nnormal) {
vec3 up = normalize(vec3(MVnormal * vec4(vec3(0.0, 0.0, 1.0), 1.0)));
vec3 north = normalize(vec3(MVnormal * vec4(vec3(1.0, 0.0, 0.0), 1.0)));
float u = acos(dot(reflect(normalize(vertex), nnormal), north)) / -3.141592;
float v = acos(dot(reflect(normalize(vertex), nnormal), up )) / -3.141592;
vec3 reflection = texture(reflectionTexture, vec2(u, v)).rgb;
return (reflexiveness < 0)
? basecolor * mix(vec3(0.0), reflection, -reflexiveness)
: mix(basecolor, reflection, reflexiveness);
}
vec3 get_nnormal() {
2019-03-14 12:43:41 +01:00
if (isNormalMapped) {
mat3 TBN;
if (isDisplacementMapped) {
float o = texture(displacementTexture, UV).r * 2.0 - 1.0;
float u = (texture(displacementTexture, UV + vec2(0.0001, 0.0)).r*2.0-1.0 - o) / 0.0004; // magic numbers are great
float v = (texture(displacementTexture, UV + vec2(0.0, 0.0001)).r*2.0-1.0 - o) / 0.0004; // magic numbers are great
TBN = mat3(
normalize(tangent + normal*u),
normalize(bitangent + normal*v),
normalize(cross(tangent + normal*u, bitangent + normal*v))
);
}
else {
TBN = mat3(
normalize(tangent),
normalize(bitangent),
normalize(normal)
);
}
return TBN * normalize(texture(normalTexture, UV).rgb * 2.0 - 1.0);
2019-03-16 20:12:35 +01:00
}
else {
if (isDisplacementMapped) {
float o = texture(displacementTexture, UV).r * 2.0 - 1.0;
float u = (texture(displacementTexture, UV + vec2(0.00001, 0.0)).r*2.0-1.0 - o) / 0.00004;
float v = (texture(displacementTexture, UV + vec2(0.0, 0.00001)).r*2.0-1.0 - o) / 0.00004;
return normalize(cross(tangent + normal*u, bitangent + normal*v));
}
else {
return normalize(normal);
}
2019-03-14 12:43:41 +01:00
}
}
2019-03-28 09:35:22 +01:00
vec3 phong(vec3 basecolor, vec3 nnormal) {
vec3 diffuse_component = vec3(0.0);
vec3 specular_component = vec3(0.0);
2019-02-19 16:16:13 +01:00
2019-03-16 20:12:35 +01:00
for (int i = 0; i<N_LIGHTS; i++) {
vec3 L = light[i].position - vertex;
2019-03-14 12:43:41 +01:00
float l = length(L);
2019-02-19 16:16:13 +01:00
L = normalize(L);
if (light[i].is_spot) {
if (dot(light[i].spot_direction, -L) < light[i].spot_cuttof_cos) {
2019-02-19 16:16:13 +01:00
continue;
}
}
2019-03-16 20:12:35 +01:00
float attenuation = clamp(1 / (
light[i].attenuation.x +
light[i].attenuation.y * l +
light[i].attenuation.z * l * l
), 0.0, 1.25);
2019-02-19 16:16:13 +01:00
2019-03-16 20:12:35 +01:00
float diffuse_i = dot(nnormal, L);
float specular_i = dot(reflect(-L, nnormal), -normalize(vertex));
specular_i = (specular_i>0)
2019-03-18 11:48:11 +01:00
? pow(specular_i, shininess)
: 0;
2019-02-19 16:16:13 +01:00
specular_component += light[i].color * specular_i * attenuation;
if (diffuse_i>0) diffuse_component += light[i].color * diffuse_i * attenuation;
2019-02-19 16:16:13 +01:00
}
basecolor *= (emissive_color*light[0].color + diffuse_color *diffuse_component);
2019-03-19 20:15:13 +01:00
if (isReflectionMapped)
basecolor = reflection(basecolor, nnormal);
return basecolor + specular_color * specular_component;
2019-03-14 12:43:41 +01:00
}
void main() {
2019-03-28 09:35:22 +01:00
vec3 nnormal = get_nnormal(); // normalized normal
vec4 c = vec4(vec3(1.0), opacity);
if (isVertexColored) c *= color;
if (isTextured) c *= texture(diffuseTexture, UV);
if (isInverted) c.rgb = 1 - c.rgb;
2019-03-28 09:35:22 +01:00
if (isIlluminated) c.rgb = phong(c.rgb, nnormal);
else {
2019-03-19 20:15:13 +01:00
c.rgb *= diffuse_color;
if (isReflectionMapped)
c.rgb = reflection(c.rgb, normalize(normal));
}
2019-03-28 09:35:22 +01:00
if (backlight_strength > 0.05)
c.rgb += backlight_color * clamp((dot(normalize(vertex), nnormal) + backlight_strength) / backlight_strength, 0, 1);
//c.rgb = diffuse_color;
//c.rgb = emissive_color;
//c.rgb = specular_color;
2019-03-18 11:48:11 +01:00
color_out = c;
2019-02-04 18:32:08 +01:00
}