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
|
//#pragma sokol @ctype mat4 hmm_mat4
#pragma sokol @vs vs
uniform vs_params {
mat4 u_MVMatrix; // A constant representing the combined model/view matrix.
mat4 u_MVPMatrix; // A constant representing the combined model/view/projection matrix.
mat4 u_NMatrix; // A constant representing the Normal Matrix
};
in vec4 a_Position; // Per-vertex position information we will pass in.
in vec3 a_Normal; // Per-vertex normal information we will pass in.
in vec4 a_Color; // Per-vertex color information we will pass in.
in vec2 a_Texcoord0;
out vec3 v_Position; // This will be passed into the fragment shader.
out vec4 v_Color; // This will be passed into the fragment shader.
out vec3 v_Normal; // This will be passed into the fragment shader.
out vec3 v_Normal1;
out vec2 uv; // This will be passed into the fragment shader.
// The entry point for our vertex shader.
void main()
{
// Transform the vertex into eye space.
v_Position = vec3(u_MVMatrix * a_Position);
// Pass through the color.
v_Color = a_Color;
// calc eye space normal
v_Normal = vec3(u_NMatrix * vec4(a_Normal, 1.0));
// texture coord
uv = a_Texcoord0;
v_Normal1 = normalize(vec3(u_MVMatrix * vec4(a_Normal, 1.0)));
// gl_Position is a special variable used to store the final position.
// Multiply the vertex by the matrix to get the final point in normalized screen coordinates.
gl_Position = u_MVPMatrix * a_Position;
}
#pragma sokol @end
#pragma sokol @fs fs
//precision mediump float; // Set the default precision to medium. We don't need as high of a precision in the fragment shader
uniform sampler2D tex;
uniform fs_params {
vec4 u_LightPos; // The position of the light in eye space.
vec4 ambientColor;
vec4 diffuseColor;
vec4 specularColor;
};
in vec3 v_Position; // Interpolated position for this fragment.
in vec4 v_Color; // This is the color from the vertex shader interpolated across the triangle per fragment.
in vec3 v_Normal; // Interpolated normal for this fragment.
in vec3 v_Normal1;
in vec2 uv;
out vec4 frag_color;
vec3 lightDirection = -u_LightPos.xyz;// vec3(0.0, -0.5, 0.5);
//const vec4 ambientColor = vec4(0.094, 0.0, 0.0, 1.0);
//const vec4 diffuseColor = vec4(0.5, 0.0, 0.0, 1.0);
//const vec4 specularColor = vec4(1.0, 1.0, 1.0, 1.0);
//const float shininess = 10.0;
const vec4 lightColor = vec4(1.0, 1.0, 1.0, 1.0);
vec3 phongBRDF(vec3 lightDir, vec3 viewDir, vec3 normal, vec3 phongDiffuseCol, vec3 phongSpecularCol, float phongShininess) {
vec3 color = phongDiffuseCol;
vec3 reflectDir = reflect(-lightDir, normal);
float specDot = max(dot(reflectDir, viewDir), 0.0);
color += pow(specDot, phongShininess) * phongSpecularCol;
return color;
}
vec4 getPhong(in vec4 diffuseColor) {
vec3 lightDir = normalize(-lightDirection);
vec3 viewDir = normalize(-v_Position);
vec3 n = normalize(v_Normal);
vec3 luminance = ambientColor.rgb * 0.5;
float illuminance = dot(lightDir, n);
if(illuminance > 0.0) {
// we save specular shiness in specularColor.a
vec3 brdf = phongBRDF(lightDir, viewDir, n, diffuseColor.rgb, specularColor.rgb, specularColor.a * 1000);
luminance += brdf * illuminance * lightColor.rgb;
}
vec4 outColor = vec4(luminance,1.0);
return outColor;
}
// The entry point for our fragment shader.
void main()
{
vec4 txt = texture(tex, uv);
// Directional light
float directional = dot(normalize(v_Normal1), normalize(vec3(0,0.5,1))) ;
directional = directional * 0.15;
// Multiply the color by the diffuse illumination level to get final output color.
frag_color = vec4(clamp(directional + txt.rgb * getPhong(diffuseColor).rgb,0,1), txt.a * diffuseColor.a);
}
#pragma sokol @end
#pragma sokol @program gouraud vs fs
|
