shaderlib/phong.glsl

   1 import msp_interface;
   2 import common;
   3 import lighting;
   4 import shadow;
   5 import environment;
   6
   7 struct BasicMaterialParameters
   8 {
   9         vec4 diffuse;
  10         vec4 specular;
  11         vec4 emission;
  12         float shininess;
  13         float reflectivity;
  14 };
  15
  16 layout(set=1) uniform BasicMaterial
  17 {
  18         BasicMaterialParameters basic_material;
  19         AlphaCutoffParams alpha_cutoff;
  20 };
  21
  22 layout(set=1) uniform sampler2D diffuse_map;
  23 layout(set=1) uniform sampler2D specular_map;
  24 layout(set=1) uniform sampler2D shininess_map;
  25 layout(set=1) uniform sampler2D emission_map;
  26 layout(set=1) uniform sampler2D reflectivity_map;
  27
  28 layout(constant_id=auto) const bool use_diffuse_map = false;
  29 layout(constant_id=auto) const bool use_specular = false;
  30 layout(constant_id=auto) const bool use_specular_map = false;
  31 layout(constant_id=auto) const bool use_shininess_map = false;
  32 layout(constant_id=auto) const bool use_emission = false;
  33 layout(constant_id=auto) const bool use_emission_map = false;
  34 layout(constant_id=auto) const bool use_reflectivity = false;
  35 layout(constant_id=auto) const bool use_reflectivity_map = false;
  36
  37 #pragma MSP stage(fragment)
  38 virtual vec4 get_diffuse_color()
  39 {
  40         if(use_diffuse_map)
  41                 return texture(diffuse_map, texcoord.xy);
  42         else
  43                 return basic_material.diffuse;
  44 }
  45
  46 virtual vec3 get_specular_color()
  47 {
  48         if(use_specular_map)
  49                 return texture(specular_map, texcoord.xy).rgb;
  50         else
  51                 return basic_material.specular.rgb;
  52 }
  53
  54 virtual float get_shininess_value()
  55 {
  56         if(use_shininess_map)
  57                 return texture(shininess_map, texcoord.xy).r*255.0;
  58         else
  59                 return basic_material.shininess;
  60 }
  61
  62 virtual vec3 get_emission_color()
  63 {
  64         if(use_emission_map)
  65                 return texture(emission_map, texcoord.xy).rgb;
  66         else
  67                 return basic_material.emission.rgb;
  68 }
  69
  70 virtual float get_reflectivity_value()
  71 {
  72         if(use_reflectivity_map)
  73                 return texture(reflectivity_map, texcoord.xy).r;
  74         else
  75                 return basic_material.reflectivity;
  76 }
  77
  78 vec3 phong_ambient(vec3 surface_diffuse)
  79 {
  80         return ambient_color.rgb*surface_diffuse;
  81 }
  82
  83 vec3 phong_one_light(vec3 light, vec3 normal, vec3 look, vec3 surface_diffuse, vec3 surface_specular, float shininess)
  84 {
  85         float diffuse_intensity = max(dot(light, normal), 0.0);
  86         vec3 color = surface_diffuse*diffuse_intensity;
  87         if(use_specular)
  88         {
  89                 vec3 reflected = reflect(look, normal);
  90                 float specular_intensity = pow(max(dot(reflected, light), 0.0), shininess);
  91                 color += surface_specular*specular_intensity;
  92         }
  93         return color;
  94 }
  95
  96 vec3 phong_lighting(vec3 normal, vec3 look, vec3 surface_diffuse, vec3 surface_specular, float shininess)
  97 {
  98         vec3 color = phong_ambient(surface_diffuse);
  99         for(int i=0; i<max_lights; ++i)
 100                 if(light_sources[i].type!=0)
 101                 {
 102                         IncomingLight incoming = get_incoming_light(i, world_vertex.xyz);
 103                         float shadow = get_shadow_factor(i, world_vertex);
 104                         color += phong_one_light(incoming.direction, normal, look, surface_diffuse, surface_specular, shininess)*incoming.color*shadow;
 105                 }
 106
 107         if(use_emission)
 108                 color += get_emission_color();
 109
 110         if(use_reflectivity)
 111                 color += get_reflection(normal, look)*get_reflectivity_value();
 112
 113         return color;
 114 }
 115
 116 void main()
 117 {
 118         vec4 surface_diffuse = get_diffuse_color();
 119         float alpha = apply_alpha_cutoff(surface_diffuse.a, alpha_cutoff);
 120
 121         vec3 normal = get_fragment_normal();
 122         vec3 look = normalize(world_look_dir);
 123
 124         vec3 surface_specular = get_specular_color();
 125         float shininess = get_shininess_value();
 126
 127         vec3 lit_color = phong_lighting(normal, look, surface_diffuse.rgb, surface_specular, shininess);
 128
 129         frag_color = vec4(lit_color, alpha);
 130 }