1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
#version 450
layout(location = 0) in vec3 worldPosition;
layout(location = 1) in vec3 worldNormal;
layout(location = 2) in vec4 color;
layout(location = 0) out vec4 fragColor;
layout(std140, binding = 0) uniform qt3d_render_view_uniforms {
mat4 viewMatrix;
mat4 projectionMatrix;
mat4 uncorrectedProjectionMatrix;
mat4 clipCorrectionMatrix;
mat4 viewProjectionMatrix;
mat4 inverseViewMatrix;
mat4 inverseProjectionMatrix;
mat4 inverseViewProjectionMatrix;
mat4 viewportMatrix;
mat4 inverseViewportMatrix;
vec4 textureTransformMatrix;
vec3 eyePosition;
float aspectRatio;
float gamma;
float exposure;
float time;
};
layout(std140, binding = 1) uniform qt3d_command_uniforms {
mat4 modelMatrix;
mat4 inverseModelMatrix;
mat4 modelViewMatrix;
mat3 modelNormalMatrix;
mat4 inverseModelViewMatrix;
mat4 mvp;
mat4 inverseModelViewProjectionMatrix;
};
const int MAX_LIGHTS = 8;
const int TYPE_POINT = 0;
const int TYPE_DIRECTIONAL = 1;
const int TYPE_SPOT = 2;
struct Light {
int type;
vec3 position;
vec3 color;
float intensity;
vec3 direction;
float constantAttenuation;
float linearAttenuation;
float quadraticAttenuation;
float cutOffAngle;
};
layout(std140, binding = 2) uniform qt3d_light_uniforms {
uniform Light lights[MAX_LIGHTS];
uniform int lightCount;
uniform int envLightCount;
};
void adsModel(const in vec3 worldPos,
const in vec3 worldNormal,
const in vec3 worldView,
const in float shininess,
out vec3 diffuseColor,
out vec3 specularColor)
{
diffuseColor = vec3(0.0);
specularColor = vec3(0.0);
// We perform all work in world space
vec3 n = normalize(worldNormal);
vec3 s = vec3(0.0);
for (int i = 0; i < lightCount; ++i) {
float att = 1.0;
float sDotN = 0.0;
if (lights[i].type != TYPE_DIRECTIONAL) {
// Point and Spot lights
// Light position is already in world space
vec3 sUnnormalized = lights[i].position - worldPos;
s = normalize(sUnnormalized); // Light direction
// Calculate the attenuation factor
sDotN = dot(s, n);
if (sDotN > 0.0) {
if (lights[i].constantAttenuation != 0.0
|| lights[i].linearAttenuation != 0.0
|| lights[i].quadraticAttenuation != 0.0) {
float dist = length(sUnnormalized);
att = 1.0 / (lights[i].constantAttenuation +
lights[i].linearAttenuation * dist +
lights[i].quadraticAttenuation * dist * dist);
}
// The light direction is in world space already
if (lights[i].type == TYPE_SPOT) {
// Check if fragment is inside or outside of the spot light cone
if (degrees(acos(dot(-s, lights[i].direction))) > lights[i].cutOffAngle)
sDotN = 0.0;
}
}
} else {
// Directional lights
// The light direction is in world space already
s = normalize(-lights[i].direction);
sDotN = dot(s, n);
}
// Calculate the diffuse factor
float diffuse = max(sDotN, 0.0);
// Calculate the specular factor
float specular = 0.0;
if (diffuse > 0.0 && shininess > 0.0) {
float normFactor = (shininess + 2.0) / 2.0;
vec3 r = reflect(-s, n); // Reflection direction in world space
specular = normFactor * pow(max(dot(r, worldView), 0.0), shininess);
}
// Accumulate the diffuse and specular contributions
diffuseColor += att * lights[i].intensity * diffuse * lights[i].color;
specularColor += att * lights[i].intensity * specular * lights[i].color;
}
}
vec4 phongFunction(const in vec4 ambient,
const in vec4 diffuse,
const in vec4 specular,
const in float shininess,
const in vec3 worldPosition,
const in vec3 worldView,
const in vec3 worldNormal)
{
// Calculate the lighting model, keeping the specular component separate
vec3 diffuseColor, specularColor;
adsModel(worldPosition, worldNormal, worldView, shininess, diffuseColor, specularColor);
// Combine spec with ambient+diffuse for final fragment color
vec3 color = (ambient.rgb + diffuseColor) * diffuse.rgb
+ specularColor * specular.rgb;
return vec4(color, diffuse.a);
}
void main()
{
vec3 worldView = normalize(eyePosition - worldPosition);
fragColor = phongFunction(color, color, vec4(0.0), 0.0, worldPosition, worldView, worldNormal);
}
|
