source/materials/basicmaterial.cpp

   1 #include "basicmaterial.h"
   2
   3 using namespace std;
   4
   5 namespace Msp {
   6 namespace GL {
   7
   8 const Tag BasicMaterial::texture_tags[] =
   9 {
  10         Tag("diffuse_map"),
  11         Tag("specular_map"),
  12         Tag("shininess_map"),
  13         Tag("normal_map"),
  14         Tag("emission_map"),
  15         Tag("reflectivity_map"),
  16         Tag()
  17 };
  18
  19 BasicMaterial::BasicMaterial()
  20 {
  21         set_diffuse(Color(1.0f));
  22         set_specular(Color(0.0f));
  23         set_emission(Color(0.0f));
  24         set_shininess(50.0f);
  25         set_reflectivity(0.0f);
  26 }
  27
  28 void BasicMaterial::fill_program_info(string &module_name, map<string, int> &spec_values) const
  29 {
  30         module_name = "phong.glsl";
  31         spec_values["use_diffuse_map"] = (diffuse.texture!=0);
  32         bool use_specular = (specular.texture || specular.value.r || specular.value.g || specular.value.b);
  33         spec_values["use_specular"] = use_specular;
  34         spec_values["use_specular_map"] = (specular.texture!=0);
  35         spec_values["use_shininess_map"] = (use_specular && shininess.texture!=0);
  36         spec_values["use_normal_map"] = (normal.texture!=0);
  37         bool use_emission = (emission.texture || emission.value.r || emission.value.g || emission.value.b);
  38         spec_values["use_emission"] = use_emission;
  39         spec_values["use_emission_map"] = (emission.texture!=0);
  40         spec_values["use_reflectivity"] = (reflectivity.value!=0 || reflectivity.texture!=0);
  41         spec_values["use_reflectivity_map"] = (reflectivity.texture!=0);
  42 }
  43
  44 const Texture *BasicMaterial::get_texture(Tag tag) const
  45 {
  46         if(tag==texture_tags[0])
  47                 return diffuse.texture;
  48         else if(tag==texture_tags[1])
  49                 return specular.texture;
  50         else if(tag==texture_tags[2])
  51                 return shininess.texture;
  52         else if(tag==texture_tags[3])
  53                 return normal.texture;
  54         else if(tag==texture_tags[4])
  55                 return emission.texture;
  56         else if(tag==texture_tags[5])
  57                 return reflectivity.texture;
  58         else
  59                 return 0;
  60 }
  61
  62 void BasicMaterial::set_diffuse(const Color &color)
  63 {
  64         diffuse.value = color;
  65         shdata.uniform("basic_material.diffuse", color);
  66 }
  67
  68 void BasicMaterial::set_diffuse_map(const Texture *tex)
  69 {
  70         diffuse.texture = tex;
  71 }
  72
  73 void BasicMaterial::set_specular(const Color &color)
  74 {
  75         specular.value = color;
  76         shdata.uniform("basic_material.specular", color);
  77 }
  78
  79 void BasicMaterial::set_specular_map(const Texture *tex)
  80 {
  81         specular.texture = tex;
  82 }
  83
  84 void BasicMaterial::set_normal_map(const Texture *tex)
  85 {
  86         normal.texture = tex;
  87 }
  88
  89 void BasicMaterial::set_emission(const Color &color)
  90 {
  91         emission.value = color;
  92         shdata.uniform("basic_material.emission", color);
  93 }
  94
  95 void BasicMaterial::set_emission_map(const Texture *tex)
  96 {
  97         emission.texture = tex;
  98 }
  99
 100 void BasicMaterial::set_shininess(float value)
 101 {
 102         shininess.value = value;
 103         shdata.uniform("basic_material.shininess", value);
 104 }
 105
 106 void BasicMaterial::set_shininess_map(const Texture *tex)
 107 {
 108         shininess.texture = tex;
 109 }
 110
 111 void BasicMaterial::set_reflectivity(float value)
 112 {
 113         reflectivity.value = value;
 114         shdata.uniform("basic_material.reflectivity", value);
 115 }
 116
 117 void BasicMaterial::set_reflectivity_map(const Texture *tex)
 118 {
 119         reflectivity.texture = tex;
 120 }
 121
 122
 123 DataFile::Loader::ActionMap BasicMaterial::Loader::shared_actions;
 124
 125 BasicMaterial::Loader::Loader(BasicMaterial &m):
 126         DerivedObjectLoader<BasicMaterial, Material::PropertyLoader<BasicMaterial> >(m)
 127 {
 128         set_actions(shared_actions);
 129 }
 130
 131 BasicMaterial::Loader::Loader(BasicMaterial &m, Collection &c):
 132         DerivedObjectLoader<BasicMaterial, Material::PropertyLoader<BasicMaterial> >(m, c)
 133 {
 134         set_actions(shared_actions);
 135 }
 136
 137 void BasicMaterial::Loader::init_actions()
 138 {
 139         Material::PropertyLoader<BasicMaterial>::init_actions();
 140         add_property("diffuse", &BasicMaterial::set_diffuse, &BasicMaterial::set_diffuse_map, true);
 141         add_property("specular", &BasicMaterial::set_specular, &BasicMaterial::set_specular_map, false);
 142         add_property("normal", &BasicMaterial::set_normal_map);
 143         add_property("emission", &BasicMaterial::set_emission, &BasicMaterial::set_emission_map, false);
 144         add_property("shininess", &BasicMaterial::set_shininess, &BasicMaterial::set_shininess_map);
 145         add_property("reflectivity", &BasicMaterial::set_reflectivity, &BasicMaterial::set_reflectivity_map);
 146 }
 147
 148 } // namespace GL
 149 } // namespace Msp