source/programdata.cpp

   1 /* $Id$
   2
   3 This file is part of libmspgl
   4 Copyright © 2007-2008, 2010-2011  Mikko Rasa, Mikkosoft Productions
   5 Distributed under the LGPL
   6 */
   7
   8 #include "color.h"
   9 #include "extension.h"
  10 #include "matrix.h"
  11 #include "program.h"
  12 #include "programdata.h"
  13 #include "uniform.h"
  14 #include "vector.h"
  15
  16 using namespace std;
  17
  18 namespace Msp {
  19 namespace GL {
  20
  21 ProgramData::ProgramData(const Program &p):
  22         program(p)
  23 {
  24         static RequireExtension _ext("GL_ARB_shader_objects");
  25 }
  26
  27 ProgramData::ProgramData(const ProgramData &other):
  28         program(other.program),
  29         data(other.data)
  30 {
  31         for(map<int, Uniform *>::iterator i=data.begin(); i!=data.end(); ++i)
  32                 i->second = i->second->clone();
  33 }
  34
  35 ProgramData::~ProgramData()
  36 {
  37         for(map<int, Uniform *>::iterator i=data.begin(); i!=data.end(); ++i)
  38                 delete i->second;
  39 }
  40
  41 void ProgramData::uniform(int index, Uniform *uni)
  42 {
  43         map<int, Uniform *>::iterator i = data.find(index);
  44         if(i!=data.end())
  45         {
  46                 delete i->second;
  47                 i->second = uni;
  48         }
  49         else
  50                 data[index] = uni;
  51 }
  52
  53 void ProgramData::uniform(int index, int v)
  54 {
  55         if(index>=0)
  56                 uniform(index, new Uniform1i(v));
  57 }
  58
  59 void ProgramData::uniform(int index, float v)
  60 {
  61         if(index>=0)
  62                 uniform(index, new Uniform1f(v));
  63 }
  64
  65 void ProgramData::uniform(int index, float v0, float v1)
  66 {
  67         if(index>=0)
  68                 uniform(index, new Uniform2f(v0, v1));
  69 }
  70
  71 void ProgramData::uniform2(int index, const float *v)
  72 {
  73         uniform(index, v[0], v[1]);
  74 }
  75
  76 void ProgramData::uniform(int index, float v0, float v1, float v2)
  77 {
  78         if(index>=0)
  79                 uniform(index, new Uniform3f(v0, v1, v2));
  80 }
  81
  82 void ProgramData::uniform(int index, const Vector3 &v)
  83 {
  84         uniform(index, v.x, v.y, v.z);
  85 }
  86
  87 void ProgramData::uniform3(int index, const float *v)
  88 {
  89         uniform(index, v[0], v[1], v[2]);
  90 }
  91
  92 void ProgramData::uniform(int index, float v0, float v1, float v2, float v3)
  93 {
  94         if(index>=0)
  95                 uniform(index, new Uniform4f(v0, v1, v2, v3));
  96 }
  97
  98 void ProgramData::uniform(int index, const Vector4 &v)
  99 {
 100         uniform(index, v.x, v.y, v.z, v.w);
 101 }
 102
 103 void ProgramData::uniform(int index, const Color &c)
 104 {
 105         uniform(index, c.r, c.g, c.b, c.a);
 106 }
 107
 108 void ProgramData::uniform4(int index, const float *v)
 109 {
 110         uniform(index, v[0], v[1], v[2], v[3]);
 111 }
 112
 113 void ProgramData::uniform_matrix4(int index, const float *v)
 114 {
 115         if(index>=0)
 116                 uniform(index, new UniformMatrix4x4f(v));
 117 }
 118
 119 void ProgramData::uniform_matrix4(int index, const Matrix &m)
 120 {
 121         if(index>=0)
 122         {
 123                 float v[16];
 124                 copy(m.data(), m.data()+16, v);
 125                 uniform_matrix4(index, v);
 126         }
 127 }
 128
 129 void ProgramData::uniform(const string &name, int v)
 130 {
 131         uniform(program.get_uniform_location(name), v);
 132 }
 133
 134 void ProgramData::uniform(const string &name, float v)
 135 {
 136         uniform(program.get_uniform_location(name), v);
 137 }
 138
 139 void ProgramData::uniform(const string &name, float v0, float v1)
 140 {
 141         uniform(program.get_uniform_location(name), v0, v1);
 142 }
 143
 144 void ProgramData::uniform2(const string &name, const float *v)
 145 {
 146         uniform2(program.get_uniform_location(name), v);
 147 }
 148
 149 void ProgramData::uniform(const string &name, float v0, float v1, float v2)
 150 {
 151         uniform(program.get_uniform_location(name), v0, v1, v2);
 152 }
 153
 154 void ProgramData::uniform(const string &name, const Vector3 &v)
 155 {
 156         uniform(program.get_uniform_location(name), v);
 157 }
 158
 159 void ProgramData::uniform3(const string &name, const float *v)
 160 {
 161         uniform3(program.get_uniform_location(name), v);
 162 }
 163
 164 void ProgramData::uniform(const string &name, float v0, float v1, float v2, float v3)
 165 {
 166         uniform(program.get_uniform_location(name), v0, v1, v2, v3);
 167 }
 168
 169 void ProgramData::uniform(const string &name, const Vector4 &v)
 170 {
 171         uniform(program.get_uniform_location(name), v);
 172 }
 173
 174 void ProgramData::uniform4(const string &name, const float *v)
 175 {
 176         uniform4(program.get_uniform_location(name), v);
 177 }
 178
 179 void ProgramData::uniform_matrix4(const string &name, const float *v)
 180 {
 181         uniform_matrix4(program.get_uniform_location(name), v);
 182 }
 183
 184 void ProgramData::uniform_matrix4(const string &name, const Matrix &m)
 185 {
 186         uniform_matrix4(program.get_uniform_location(name), m);
 187 }
 188
 189 void ProgramData::apply() const
 190 {
 191         for(map<int, Uniform *>::const_iterator i=data.begin(); i!=data.end(); ++i)
 192                 i->second->apply(i->first);
 193 }
 194
 195
 196 ProgramData::Loader::Loader(ProgramData &pd):
 197         DataFile::ObjectLoader<ProgramData>(pd)
 198 {
 199         add("uniform1i", &Loader::uniform1i);
 200         add("uniform1f", &Loader::uniform1f);
 201         add("uniform2f", &Loader::uniform2f);
 202         add("uniform3f", &Loader::uniform3f);
 203         add("uniform4f", &Loader::uniform4f);
 204 }
 205
 206 void ProgramData::Loader::uniform1i(const string &n, int v)
 207 {
 208         obj.uniform(n, v);
 209 }
 210
 211 void ProgramData::Loader::uniform1f(const string &n, float v)
 212 {
 213         obj.uniform(n, v);
 214 }
 215
 216 void ProgramData::Loader::uniform2f(const string &n, float v0, float v1)
 217 {
 218         obj.uniform(n, v0, v1);
 219 }
 220
 221 void ProgramData::Loader::uniform3f(const string &n, float v0, float v1, float v2)
 222 {
 223         obj.uniform(n, v0, v1, v2);
 224 }
 225
 226 void ProgramData::Loader::uniform4f(const string &n, float v0, float v1, float v2, float v3)
 227 {
 228         obj.uniform(n, v0, v1, v2, v3);
 229 }
 230
 231 } // namespace GL
 232 } // namespace Msp