#version430 corelayout(location =0) in vec3 aPos;layout(location =1) in vec2 aTexCoord;layout(std140 , binding =0) uniform PV
{
mat4 projection;
mat4 view;};
out vec2 TexCoord;
uniform mat4 model;voidmain(){
gl_Position = projection * view * model *vec4(aPos,1.0);
TexCoord =vec2(aTexCoord.x, aTexCoord.y);}-----------------------#version430 core
out vec4 FragColor;
in vec2 TexCoord;
uniform sampler2D albedoMap;voidmain(){
// linearly interpolate between both textures (80% container, 20% awesomeface)
FragColor =vec4(texture(albedoMap, TexCoord).rgb *0.5,1.0);}
高光
#version420 corelayout(location =0) in vec3 aPos;layout(location =2) in vec3 aNormal;layout(location =1) in vec2 aTexCoord;layout(std140 , binding =0) uniform PV
{
mat4 projection;
mat4 view;};
out vec3 FragPos;
out vec3 Normal;
out vec2 TexCoord;
uniform mat4 model;voidmain(){
gl_Position = projection * view * model *vec4(aPos,1.0);
FragPos =vec3(model *vec4(aPos,1.0));
Normal =mat3(transpose(inverse(model)))* aNormal;
TexCoord =vec2(aTexCoord.x, aTexCoord.y);}-------------#version420 core
out vec4 FragColor;layout(std140 , binding =1) uniform BaseLight
{
vec3 lightDir;
vec3 color;
vec3 ambient;float gloss;};layout(std140 , binding =2) uniform BaseView
{
vec3 viewPos;};
in vec3 FragPos;
in vec3 Normal;
in vec2 TexCoords;
uniform sampler2D albedoMap;voidmain(){
// linearly interpolate between both textures (80% container, 20% awesomeface)//FragColor = vec4(texture(albedoMap, TexCoord).rgb ,1.0);// ambient
vec3 ambient = BaseLight.ambient *texture(albedoMap, TexCoords).rgb;// diffuse
vec3 norm =normalize(Normal);float diff =max(dot(norm, BaseLight.lightDir),0.0);
vec3 diffuse = BaseLight.color * diff *texture(albedoMap, TexCoords).rgb;// specular
vec3 viewDir =normalize(viewPos - FragPos);
vec3 halfDir =normalize(viewDir + BaseLight.lightDir);float spec =pow(max(dot(norm, halfDir),0.0), BaseLight.gloss);
vec3 specular = BaseLight.color * spec *texture(albedoMap, TexCoords).rgb;
vec3 result = ambient + diffuse + specular;// HDR tonemapping
result = result /(result +vec3(1.0));// gamma correct
result =pow(result,vec3(1.0/2.2));
FragColor =vec4(result,1.0);}
高质量
#version430 corelayout(location =0) in vec3 aPos;layout(location =1) in vec3 aNormal;layout(location =2) in vec2 aTexCoords;layout(location =3) in vec3 Tangent;layout(location =4) in vec3 Bitangent;layout(location =5) in ivec4 BoneIDs;layout(location =6) in vec4 Weights;
out vec2 TexCoords;
out vec3 WorldPos;
out vec3 Normal;layout(std140 , binding =0) uniform PV
{
mat4 projection;
mat4 view;};
uniform mat4 model;constint MAX_BONES =100;// Max number of bones
uniform mat4 gBones[MAX_BONES];// Bone transformations voidmain(){
mat4 BoneTransform = gBones[ BoneIDs[0]]* Weights[0];
BoneTransform += gBones[ BoneIDs[1]]* Weights[1];
BoneTransform += gBones[ BoneIDs[2]]* Weights[2];
BoneTransform += gBones[ BoneIDs[3]]* Weights[3];// Transformed vertex position
vec4 tPos = BoneTransform *vec4(aPos,1.0);
TexCoords = aTexCoords;
WorldPos =vec3(model * tPos);
Normal =mat3(model)* aNormal;//gl_Position = projection * view * vec4(WorldPos, 1.0);
gl_Position = projection * view * model * tPos;}------------------------#version430 core
out vec4 FragColor;
in vec2 TexCoords;
in vec3 WorldPos;
in vec3 Normal;// material parameters
uniform sampler2D albedoMap;
uniform sampler2D specularMap;
uniform sampler2D normalMap;
uniform sampler2D heightMap;
uniform sampler2D aoMap;
uniform sampler2D metallicMap;
uniform sampler2D roughnessMap;layout(std140 , binding =1) uniform BaseLight
{
vec3 lightDir;
vec3 color;
vec3 ambient;float gloss;};layout(std140 , binding =2) uniform BaseView
{
vec3 viewPos;};// lights
uniform vec3 lightPositions[1];
uniform vec3 lightColors[1];
uniform vec3 camPos;constfloat PI =3.14159265359;// ----------------------------------------------------------------------------// Easy trick to get tangent-normals to world-space to keep PBR code simplified.// Don't worry if you don't get what's going on; you generally want to do normal // mapping the usual way for performance anways; I do plan make a note of this // technique somewhere later in the normal mapping tutorial.
vec3 getNormalFromMap(){
vec3 tangentNormal =texture(normalMap, TexCoords).xyz *2.0-1.0;
vec3 Q1 =dFdx(WorldPos);
vec3 Q2 =dFdy(WorldPos);
vec2 st1 =dFdx(TexCoords);
vec2 st2 =dFdy(TexCoords);
vec3 N =normalize(Normal);
vec3 T =normalize(Q1*st2.t - Q2*st1.t);
vec3 B =-normalize(cross(N, T));
mat3 TBN =mat3(T, B, N);returnnormalize(TBN * tangentNormal);}// ----------------------------------------------------------------------------floatDistributionGGX(vec3 N, vec3 H,float roughness){
float a = roughness*roughness;float a2 = a*a;float NdotH =max(dot(N, H),0.0);float NdotH2 = NdotH*NdotH;float nom = a2;float denom =(NdotH2 *(a2 -1.0)+1.0);
denom = PI * denom * denom;return nom / denom;}// ----------------------------------------------------------------------------floatGeometrySchlickGGX(float NdotV,float roughness){
float r =(roughness +1.0);float k =(r*r)/8.0;float nom = NdotV;float denom = NdotV *(1.0- k)+ k;return nom / denom;}// ----------------------------------------------------------------------------floatGeometrySmith(vec3 N, vec3 V, vec3 L,float roughness){
float NdotV =max(dot(N, V),0.0);float NdotL =max(dot(N, L),0.0);float ggx2 =GeometrySchlickGGX(NdotV, roughness);float ggx1 =GeometrySchlickGGX(NdotL, roughness);return ggx1 * ggx2;}// ----------------------------------------------------------------------------
vec3 fresnelSchlick(float cosTheta, vec3 F0){
return F0 +(1.0- F0)*pow(clamp(1.0- cosTheta,0.0,1.0),5.0);}// ----------------------------------------------------------------------------voidmain(){
vec3 albedo =pow(texture(albedoMap, TexCoords).rgb,vec3(2.2));float metallic =texture(metallicMap, TexCoords).r;float roughness =texture(roughnessMap, TexCoords).r;float ao =texture(aoMap, TexCoords).r;
vec3 N =getNormalFromMap();
vec3 V =normalize(camPos - WorldPos);// calculate reflectance at normal incidence; if dia-electric (like plastic) use F0 // of 0.04 and if it's a metal, use the albedo color as F0 (metallic workflow)
vec3 F0 =vec3(0.04);
F0 =mix(F0, albedo, metallic);// reflectance equation
vec3 Lo =vec3(0.0);for(int i =0; i <1;++i){
// calculate per-light radiance
vec3 L =normalize(lightPositions[i]- WorldPos);
vec3 H =normalize(V + L);float distance =length(lightPositions[i]- WorldPos);float attenuation =1.0/(distance * distance);
vec3 radiance = lightColors[i]*1;// Cook-Torrance BRDFfloat NDF =DistributionGGX(N, H, roughness);float G =GeometrySmith(N, V, L, roughness);
vec3 F =fresnelSchlick(max(dot(H, V),0.0), F0);
vec3 numerator = NDF * G * F;float denominator =4*max(dot(N, V),0.0)*max(dot(N, L),0.0)+0.0001;// + 0.0001 to prevent divide by zero
vec3 specular = numerator / denominator;// kS is equal to Fresnel
vec3 kS = F;// for energy conservation, the diffuse and specular light can't// be above 1.0 (unless the surface emits light); to preserve this// relationship the diffuse component (kD) should equal 1.0 - kS.
vec3 kD =vec3(1.0)- kS;// multiply kD by the inverse metalness such that only non-metals // have diffuse lighting, or a linear blend if partly metal (pure metals// have no diffuse light).
kD *=1.0- metallic;// scale light by NdotLfloat NdotL =max(dot(N, L),0.0);// add to outgoing radiance Lo
Lo +=(kD * albedo / PI + specular)* radiance * NdotL;// note that we already multiplied the BRDF by the Fresnel (kS) so we won't multiply by kS again}// ambient lighting (note that the next IBL tutorial will replace // this ambient lighting with environment lighting).
vec3 ambient =vec3(0.03)* albedo * ao;
vec3 color = ambient + Lo;// HDR tonemapping
color = color /(color +vec3(1.0));// gamma correct
color =pow(color,vec3(1.0/2.2));
FragColor =vec4(color,1.0);}