source/programdata.cpp

   1 #include "buffer.h"
   2 #include "color.h"
   3 #include "error.h"
   4 #include "extension.h"
   5 #include "matrix.h"
   6 #include "program.h"
   7 #include "programdata.h"
   8 #include "uniform.h"
   9 #include "uniformblock.h"
  10 #include "vector.h"
  11
  12 using namespace std;
  13
  14 namespace Msp {
  15 namespace GL {
  16
  17 ProgramData::ProgramData():
  18         last_block(0),
  19         buffer(0),
  20         modified(false)
  21 {
  22         static RequireExtension _ext("GL_ARB_shader_objects");
  23 }
  24
  25 // Blocks are intentionally left uncopied
  26 ProgramData::ProgramData(const ProgramData &other):
  27         uniforms(other.uniforms),
  28         last_block(0),
  29         buffer(0),
  30         modified(false)
  31 {
  32         for(UniformMap::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
  33                 i->second = i->second->clone();
  34 }
  35
  36 ProgramData::~ProgramData()
  37 {
  38         for(UniformMap::iterator i=uniforms.begin(); i!=uniforms.end(); ++i)
  39                 delete i->second;
  40         for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
  41                 delete i->second.block;
  42 }
  43
  44 void ProgramData::uniform(const string &name, Uniform *uni)
  45 {
  46         UniformMap::iterator i = uniforms.find(name);
  47         if(i!=uniforms.end())
  48         {
  49                 delete i->second;
  50                 i->second = uni;
  51         }
  52         else
  53                 uniforms[name] = uni;
  54
  55         modified = true;
  56 }
  57
  58 void ProgramData::uniform(const string &name, int v)
  59 {
  60         uniform(name, new Uniform1i(v));
  61 }
  62
  63 void ProgramData::uniform(const string &name, float v)
  64 {
  65         uniform(name, new Uniform1f(v));
  66 }
  67
  68 void ProgramData::uniform(const string &name, float v0, float v1)
  69 {
  70         float va[2] = { v0, v1 };
  71         uniform2(name, va);
  72 }
  73
  74 void ProgramData::uniform2(const string &name, const float *v)
  75 {
  76         uniform(name, new Uniform2f(v));
  77 }
  78
  79 void ProgramData::uniform(const string &name, float v0, float v1, float v2)
  80 {
  81         float va[3] = { v0, v1, v2 };
  82         uniform3(name, va);
  83 }
  84
  85 void ProgramData::uniform(const string &name, const Vector3 &v)
  86 {
  87         uniform(name, v.x, v.y, v.z);
  88 }
  89
  90 void ProgramData::uniform3(const string &name, const float *v)
  91 {
  92         uniform(name, new Uniform3f(v));
  93 }
  94
  95 void ProgramData::uniform(const string &name, float v0, float v1, float v2, float v3)
  96 {
  97         float va[4] = { v0, v1, v2, v3 };
  98         uniform4(name, va);
  99 }
 100
 101 void ProgramData::uniform(const string &name, const Vector4 &v)
 102 {
 103         uniform(name, v.x, v.y, v.z, v.w);
 104 }
 105
 106 void ProgramData::uniform(const string &name, const Color &c)
 107 {
 108         uniform(name, c.r, c.g, c.b, c.a);
 109 }
 110
 111 void ProgramData::uniform4(const string &name, const float *v)
 112 {
 113         uniform(name, new Uniform4f(v));
 114 }
 115
 116 void ProgramData::uniform_matrix4(const string &name, const float *v)
 117 {
 118         uniform(name, new UniformMatrix4x4f(v));
 119 }
 120
 121 void ProgramData::uniform_matrix4(const string &name, const Matrix &m)
 122 {
 123         float v[16];
 124         copy(m.data(), m.data()+16, v);
 125         uniform_matrix4(name, v);
 126 }
 127
 128 void ProgramData::uniform1_array(const string &name, unsigned n, const float *v)
 129 {
 130         uniform(name, new UniformArray<Uniform1f>(n, v));
 131 }
 132
 133 void ProgramData::uniform2_array(const string &name, unsigned n, const float *v)
 134 {
 135         uniform(name, new UniformArray<Uniform2f>(n, v));
 136 }
 137
 138 void ProgramData::uniform3_array(const string &name, unsigned n, const float *v)
 139 {
 140         uniform(name, new UniformArray<Uniform3f>(n, v));
 141 }
 142
 143 void ProgramData::uniform4_array(const string &name, unsigned n, const float *v)
 144 {
 145         uniform(name, new UniformArray<Uniform4f>(n, v));
 146 }
 147
 148 void ProgramData::uniform_matrix4_array(const string &name, unsigned n, const float *v)
 149 {
 150         uniform(name, new UniformArray<UniformMatrix4x4f>(n, v));
 151 }
 152
 153 const UniformBlock &ProgramData::get_block(const Program &prog, const string &name) const
 154 {
 155         if(modified)
 156         {
 157                 for(BlockMap::iterator i=blocks.begin(); i!=blocks.end(); ++i)
 158                         i->second.dirty = true;
 159                 modified = false;
 160         }
 161
 162         const Program::UniformBlockInfo *info = 0;
 163         unsigned layout_hash;
 164         if(!name.empty())
 165         {
 166                 info = &prog.get_uniform_block_info(name);
 167                 layout_hash = info->layout_hash;
 168         }
 169         else
 170                 layout_hash = prog.get_uniform_layout_hash();
 171
 172         map<unsigned, Block>::iterator i = blocks.find(layout_hash);
 173         if(i==blocks.end())
 174         {
 175                 i = blocks.insert(BlockMap::value_type(layout_hash, Block())).first;
 176                 i->second.dirty = true;
 177                 if(info)
 178                 {
 179                         i->second.block = new UniformBlock(info->data_size);
 180                         if(!buffer)
 181                                 buffer = new Buffer(UNIFORM_BUFFER);
 182                         i->second.block->use_buffer(buffer, last_block);
 183                         last_block = i->second.block;
 184                 }
 185                 else
 186                         i->second.block = new UniformBlock;
 187         }
 188
 189         UniformBlock &block = *i->second.block;
 190         if(i->second.dirty)
 191         {
 192                 if(info)
 193                 {
 194                         for(vector<const Program::UniformInfo *>::const_iterator j=info->uniforms.begin(); j!=info->uniforms.end(); ++j)
 195                         {
 196                                 // XXX individual array elements
 197                                 UniformMap::const_iterator k = uniforms.find((*j)->name);
 198                                 if(k!=uniforms.end())
 199                                         block.attach(**j, *k->second);
 200                         }
 201                 }
 202                 else
 203                 {
 204                         for(UniformMap::const_iterator j=uniforms.begin(); j!=uniforms.end(); ++j)
 205                         {
 206                                 int loc = prog.get_uniform_location(j->first);
 207                                 if(loc>=0)
 208                                         block.attach(loc, *j->second);
 209                         }
 210                 }
 211                 i->second.dirty = false;
 212         }
 213
 214         return block;
 215 }
 216
 217 void ProgramData::apply() const
 218 {
 219         const Program *prog = Program::current();
 220         if(!prog)
 221                 throw invalid_operation("ProgramData::apply");
 222
 223         const Program::UniformBlockMap &prog_blocks = prog->get_uniform_blocks();
 224         for(Program::UniformBlockMap::const_iterator i=prog_blocks.begin(); i!=prog_blocks.end(); ++i)
 225         {
 226                 const UniformBlock &block = get_block(*prog, i->second.name);
 227                 block.apply(i->second.bind_point);
 228         }
 229
 230         const UniformBlock &block = get_block(*prog, string());
 231         block.apply(-1);
 232 }
 233
 234
 235 ProgramData::Block::Block():
 236         dirty(false),
 237         block(0)
 238 { }
 239
 240
 241 ProgramData::Loader::Loader(ProgramData &pd):
 242         DataFile::ObjectLoader<ProgramData>(pd)
 243 {
 244         add("uniform1i", &Loader::uniform1i);
 245         add("uniform1f", &Loader::uniform1f);
 246         add("uniform2f", &Loader::uniform2f);
 247         add("uniform3f", &Loader::uniform3f);
 248         add("uniform4f", &Loader::uniform4f);
 249 }
 250
 251 void ProgramData::Loader::uniform1i(const string &n, int v)
 252 {
 253         obj.uniform(n, v);
 254 }
 255
 256 void ProgramData::Loader::uniform1f(const string &n, float v)
 257 {
 258         obj.uniform(n, v);
 259 }
 260
 261 void ProgramData::Loader::uniform2f(const string &n, float v0, float v1)
 262 {
 263         obj.uniform(n, v0, v1);
 264 }
 265
 266 void ProgramData::Loader::uniform3f(const string &n, float v0, float v1, float v2)
 267 {
 268         obj.uniform(n, v0, v1, v2);
 269 }
 270
 271 void ProgramData::Loader::uniform4f(const string &n, float v0, float v1, float v2, float v3)
 272 {
 273         obj.uniform(n, v0, v1, v2, v3);
 274 }
 275
 276 } // namespace GL
 277 } // namespace Msp