Reorganize shaders to respective folders
This commit is contained in:
raysan5
parent
e977915577
commit
c4922c9e88
8 changed files with 249 additions and 29 deletions
|
|
@ -1,26 +0,0 @@
|
|||
#version 330
|
||||
|
||||
// Input vertex attributes
|
||||
in vec3 vertexPosition;
|
||||
in vec2 vertexTexCoord;
|
||||
in vec3 vertexNormal;
|
||||
in vec4 vertexColor;
|
||||
|
||||
// Input uniform values
|
||||
uniform mat4 mvpMatrix;
|
||||
|
||||
// Output vertex attributes (to fragment shader)
|
||||
out vec2 fragTexCoord;
|
||||
out vec4 fragColor;
|
||||
|
||||
// NOTE: Add here your custom variables
|
||||
|
||||
void main()
|
||||
{
|
||||
// Send vertex attributes to fragment shader
|
||||
fragTexCoord = vertexTexCoord;
|
||||
fragColor = vertexColor;
|
||||
|
||||
// Calculate final vertex position
|
||||
gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
|
||||
}
|
||||
68
examples/resources/shaders/glsl100/distortion.fs
Normal file
68
examples/resources/shaders/glsl100/distortion.fs
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
#version 100
|
||||
|
||||
precision mediump float;
|
||||
|
||||
// Input vertex attributes (from vertex shader)
|
||||
varying vec2 fragTexCoord;
|
||||
|
||||
// Input uniform values
|
||||
uniform sampler2D texture0;
|
||||
|
||||
// NOTE: Add here your custom variables
|
||||
const vec2 LeftLensCenter = vec2(0.2863248, 0.5);
|
||||
const vec2 RightLensCenter = vec2(0.7136753, 0.5);
|
||||
const vec2 LeftScreenCenter = vec2(0.25, 0.5);
|
||||
const vec2 RightScreenCenter = vec2(0.75, 0.5);
|
||||
const vec2 Scale = vec2(0.25, 0.45); //vec2(0.1469278, 0.2350845);
|
||||
const vec2 ScaleIn = vec2(4, 2.2222);
|
||||
const vec4 HmdWarpParam = vec4(1, 0.22, 0.24, 0);
|
||||
|
||||
/*
|
||||
// Another set of default values
|
||||
ChromaAbCorrection = {1.0, 0.0, 1.0, 0}
|
||||
DistortionK = {1.0, 0.22, 0.24, 0}
|
||||
Scale = {0.25, 0.5*AspectRatio, 0, 0}
|
||||
ScaleIn = {4.0, 2/AspectRatio, 0, 0}
|
||||
Left Screen Center = {0.25, 0.5, 0, 0}
|
||||
Left Lens Center = {0.287994117, 0.5, 0, 0}
|
||||
Right Screen Center = {0.75, 0.5, 0, 0}
|
||||
Right Lens Center = {0.712005913, 0.5, 0, 0}
|
||||
*/
|
||||
|
||||
// Scales input texture coordinates for distortion.
|
||||
vec2 HmdWarp(vec2 in01, vec2 LensCenter)
|
||||
{
|
||||
vec2 theta = (in01 - LensCenter)*ScaleIn; // Scales to [-1, 1]
|
||||
float rSq = theta.x*theta.x + theta.y*theta.y;
|
||||
vec2 rvector = theta*(HmdWarpParam.x + HmdWarpParam.y*rSq + HmdWarpParam.z*rSq*rSq + HmdWarpParam.w*rSq*rSq*rSq);
|
||||
|
||||
return LensCenter + Scale*rvector;
|
||||
}
|
||||
|
||||
void main()
|
||||
{
|
||||
// SOURCE: http://www.mtbs3d.com/phpbb/viewtopic.php?f=140&t=17081
|
||||
|
||||
// The following two variables need to be set per eye
|
||||
vec2 LensCenter = fragTexCoord.x < 540 ? LeftLensCenter : RightLensCenter;
|
||||
vec2 ScreenCenter = fragTexCoord.x < 540 ? LeftScreenCenter : RightScreenCenter;
|
||||
|
||||
vec2 tc = HmdWarp(fragTexCoord, LensCenter);
|
||||
|
||||
if (any(bvec2(clamp(tc,ScreenCenter-vec2(0.25,0.5), ScreenCenter+vec2(0.25,0.5)) - tc))) gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
else
|
||||
{
|
||||
//tc.x = gl_FragCoord.x < 640 ? (2.0 * tc.x) : (2.0 * (tc.x - 0.5));
|
||||
gl_FragColor = texture2D(texture0, tc);
|
||||
}
|
||||
|
||||
/*
|
||||
// Chromatic aberration is caused when a lens can't focus every color to the same focal point.
|
||||
// A simple way to fake this effect, and render it as a quick full-screen post-process,
|
||||
// is to apply an offset to each color channel in a fragment shader.
|
||||
vec4 rValue = texture2D(texture0, fragTexCoord - rOffset);
|
||||
vec4 gValue = texture2D(texture0, fragTexCoord - gOffset);
|
||||
vec4 bValue = texture2D(texture0, fragTexCoord - bOffset);
|
||||
finalColor = vec4(rValue.r, gValue.g, bValue.b, 1.0);
|
||||
*/
|
||||
}
|
||||
|
|
@ -45,8 +45,8 @@ void main()
|
|||
// SOURCE: http://www.mtbs3d.com/phpbb/viewtopic.php?f=140&t=17081
|
||||
|
||||
// The following two variables need to be set per eye
|
||||
vec2 LensCenter = gl_FragCoord.x < 540 ? LeftLensCenter : RightLensCenter;
|
||||
vec2 ScreenCenter = gl_FragCoord.x < 540 ? LeftScreenCenter : RightScreenCenter;
|
||||
vec2 LensCenter = fragTexCoord.x < 540 ? LeftLensCenter : RightLensCenter;
|
||||
vec2 ScreenCenter = fragTexCoord.x < 540 ? LeftScreenCenter : RightScreenCenter;
|
||||
|
||||
vec2 tc = HmdWarp(fragTexCoord, LensCenter);
|
||||
|
||||
|
|
@ -1,155 +0,0 @@
|
|||
#version 330
|
||||
|
||||
in vec3 fragPosition;
|
||||
in vec2 fragTexCoord;
|
||||
in vec4 fragColor;
|
||||
in vec3 fragNormal;
|
||||
|
||||
out vec4 finalColor;
|
||||
|
||||
uniform sampler2D texture0;
|
||||
uniform sampler2D texture1;
|
||||
uniform sampler2D texture2;
|
||||
|
||||
uniform vec4 colAmbient;
|
||||
uniform vec4 colDiffuse;
|
||||
uniform vec4 colSpecular;
|
||||
uniform float glossiness;
|
||||
|
||||
uniform int useNormal;
|
||||
uniform int useSpecular;
|
||||
|
||||
uniform mat4 modelMatrix;
|
||||
uniform vec3 viewDir;
|
||||
|
||||
struct Light {
|
||||
int enabled;
|
||||
int type;
|
||||
vec3 position;
|
||||
vec3 direction;
|
||||
vec4 diffuse;
|
||||
float intensity;
|
||||
float radius;
|
||||
float coneAngle;
|
||||
};
|
||||
|
||||
const int maxLights = 8;
|
||||
uniform int lightsCount;
|
||||
uniform Light lights[maxLights];
|
||||
|
||||
vec3 CalcPointLight(Light l, vec3 n, vec3 v, float s)
|
||||
{
|
||||
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
|
||||
vec3 surfaceToLight = l.position - surfacePos;
|
||||
|
||||
// Diffuse shading
|
||||
float brightness = clamp(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n)), 0, 1);
|
||||
float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
|
||||
|
||||
// Specular shading
|
||||
float spec = 0.0;
|
||||
if (diff > 0.0)
|
||||
{
|
||||
vec3 h = normalize(-l.direction + v);
|
||||
spec = pow(dot(n, h), 3 + glossiness)*s;
|
||||
}
|
||||
|
||||
return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
|
||||
}
|
||||
|
||||
vec3 CalcDirectionalLight(Light l, vec3 n, vec3 v, float s)
|
||||
{
|
||||
vec3 lightDir = normalize(-l.direction);
|
||||
|
||||
// Diffuse shading
|
||||
float diff = clamp(dot(n, lightDir), 0.0, 1.0)*l.intensity;
|
||||
|
||||
// Specular shading
|
||||
float spec = 0.0;
|
||||
if (diff > 0.0)
|
||||
{
|
||||
vec3 h = normalize(lightDir + v);
|
||||
spec = pow(dot(n, h), 3 + glossiness)*s;
|
||||
}
|
||||
|
||||
// Combine results
|
||||
return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
|
||||
}
|
||||
|
||||
vec3 CalcSpotLight(Light l, vec3 n, vec3 v, float s)
|
||||
{
|
||||
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
|
||||
vec3 lightToSurface = normalize(surfacePos - l.position);
|
||||
vec3 lightDir = normalize(-l.direction);
|
||||
|
||||
// Diffuse shading
|
||||
float diff = clamp(dot(n, lightDir), 0.0, 1.0)*l.intensity;
|
||||
|
||||
// Spot attenuation
|
||||
float attenuation = clamp(dot(n, lightToSurface), 0.0, 1.0);
|
||||
attenuation = dot(lightToSurface, -lightDir);
|
||||
|
||||
float lightToSurfaceAngle = degrees(acos(attenuation));
|
||||
if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
|
||||
|
||||
float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
|
||||
|
||||
// Combine diffuse and attenuation
|
||||
float diffAttenuation = diff*attenuation;
|
||||
|
||||
// Specular shading
|
||||
float spec = 0.0;
|
||||
if (diffAttenuation > 0.0)
|
||||
{
|
||||
vec3 h = normalize(lightDir + v);
|
||||
spec = pow(dot(n, h), 3 + glossiness)*s;
|
||||
}
|
||||
|
||||
return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
|
||||
}
|
||||
|
||||
void main()
|
||||
{
|
||||
// Calculate fragment normal in screen space
|
||||
// NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
|
||||
mat3 normalMatrix = transpose(inverse(mat3(modelMatrix)));
|
||||
vec3 normal = normalize(normalMatrix*fragNormal);
|
||||
|
||||
// Normalize normal and view direction vectors
|
||||
vec3 n = normalize(normal);
|
||||
vec3 v = normalize(viewDir);
|
||||
|
||||
// Calculate diffuse texture color fetching
|
||||
vec4 texelColor = texture(texture0, fragTexCoord);
|
||||
vec3 lighting = colAmbient.rgb;
|
||||
|
||||
// Calculate normal texture color fetching or set to maximum normal value by default
|
||||
if (useNormal == 1)
|
||||
{
|
||||
n *= texture(texture1, fragTexCoord).rgb;
|
||||
n = normalize(n);
|
||||
}
|
||||
|
||||
// Calculate specular texture color fetching or set to maximum specular value by default
|
||||
float spec = 1.0;
|
||||
if (useSpecular == 1) spec *= normalize(texture(texture2, fragTexCoord).r);
|
||||
|
||||
for (int i = 0; i < lightsCount; i++)
|
||||
{
|
||||
// Check if light is enabled
|
||||
if (lights[i].enabled == 1)
|
||||
{
|
||||
// Calculate lighting based on light type
|
||||
switch (lights[i].type)
|
||||
{
|
||||
case 0: lighting += CalcPointLight(lights[i], n, v, spec); break;
|
||||
case 1: lighting += CalcDirectionalLight(lights[i], n, v, spec); break;
|
||||
case 2: lighting += CalcSpotLight(lights[i], n, v, spec); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate final fragment color
|
||||
finalColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
|
||||
}
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
#version 330
|
||||
|
||||
in vec3 vertexPosition;
|
||||
in vec3 vertexNormal;
|
||||
in vec2 vertexTexCoord;
|
||||
in vec4 vertexColor;
|
||||
|
||||
out vec3 fragPosition;
|
||||
out vec2 fragTexCoord;
|
||||
out vec4 fragColor;
|
||||
out vec3 fragNormal;
|
||||
|
||||
uniform mat4 mvpMatrix;
|
||||
|
||||
void main()
|
||||
{
|
||||
fragPosition = vertexPosition;
|
||||
fragTexCoord = vertexTexCoord;
|
||||
fragColor = vertexColor;
|
||||
fragNormal = vertexNormal;
|
||||
|
||||
gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue