source/core/batch.cpp

   1 #include <msp/gl/extensions/arb_draw_instanced.h>
   2 #include <msp/gl/extensions/msp_primitive_restart.h>
   3 #include "batch.h"
   4 #include "bindable.h"
   5 #include "buffer.h"
   6 #include "error.h"
   7 #include "mesh.h"
   8 #include "vertexarray.h"
   9
  10 using namespace std;
  11
  12 namespace {
  13
  14 template<typename T>
  15 void append(vector<Msp::UInt8> &data, T i)
  16 {
  17         data.insert(data.end(), sizeof(T), 0);
  18         *(T *)(&data[data.size()-sizeof(T)]) = i;
  19 }
  20
  21 template<typename T, typename U>
  22 U convert(T n)
  23 {
  24         if(!static_cast<T>(~n))
  25                 return ~0;
  26         else
  27                 return n;
  28 }
  29
  30 template<typename T, typename U>
  31 void expand(vector<Msp::UInt8> &data)
  32 {
  33         unsigned count = data.size()/sizeof(T);
  34         data.resize(count*sizeof(U));
  35         for(unsigned i=count; i--;)
  36                 *(U *)(&data[i*sizeof(U)]) = convert<T, U>(*(T *)(&data[i*sizeof(T)]));
  37 }
  38
  39 template<typename T, typename U>
  40 void shrink(vector<Msp::UInt8> &data)
  41 {
  42         unsigned count = data.size()/sizeof(T);
  43         for(unsigned i=0; i<count; ++i)
  44                 *(U *)(&data[i*sizeof(U)]) = convert<T, U>(*(T *)(&data[i*sizeof(T)]));
  45         data.resize(count*sizeof(U));
  46 }
  47
  48 }
  49
  50 namespace Msp {
  51 namespace GL {
  52
  53 unsigned Batch::restart_index = 0;
  54
  55 Batch::Batch(PrimitiveType t):
  56         prim_type(t),
  57         index_type(UNSIGNED_SHORT),
  58         max_index(0),
  59         restart(false)
  60 { }
  61
  62 Batch::~Batch()
  63 {
  64 }
  65
  66 void Batch::set_index_type(DataType t)
  67 {
  68         if(t!=UNSIGNED_SHORT && t!=UNSIGNED_INT)
  69                 throw invalid_argument("Batch::set_data_type");
  70         if(t==UNSIGNED_SHORT && max_index>0xFFFE)
  71                 throw invalid_operation("Batch::set_data_type");
  72
  73         if(index_type==UNSIGNED_SHORT && t==UNSIGNED_INT)
  74                 expand<UInt16, UInt32>(data);
  75         else if(index_type==UNSIGNED_INT && t==UNSIGNED_SHORT)
  76                 shrink<UInt32, UInt16>(data);
  77
  78         index_type = t;
  79         update_offset();
  80         dirty = true;
  81 }
  82
  83 Batch &Batch::append(unsigned i)
  84 {
  85         append_index(i);
  86
  87         update_offset();
  88         dirty = true;
  89
  90         return *this;
  91 }
  92
  93 Batch &Batch::append(const vector<unsigned> &ind)
  94 {
  95         if(ind.empty())
  96                 return *this;
  97
  98         data.reserve(data.size()+ind.size()*get_index_size());
  99         for(vector<unsigned>::const_iterator i=ind.begin(); i!=ind.end(); ++i)
 100                 append_index(*i);
 101
 102         update_offset();
 103         dirty = true;
 104
 105         return *this;
 106 }
 107
 108 bool Batch::can_append(PrimitiveType other_type)
 109 {
 110         if(other_type!=prim_type)
 111                 return false;
 112         else if(prim_type==LINE_STRIP || prim_type==LINE_LOOP || prim_type==TRIANGLE_FAN)
 113                 return MSP_primitive_restart;
 114         else
 115                 return true;
 116 }
 117
 118 Batch &Batch::append(const Batch &other)
 119 {
 120         if(other.prim_type!=prim_type)
 121                 throw invalid_argument("Batch::append");
 122         if(prim_type==LINE_STRIP || prim_type==LINE_LOOP || prim_type==TRIANGLE_FAN)
 123                 static Require _req(MSP_primitive_restart);
 124
 125         if(other.data.empty())
 126                 return *this;
 127
 128         // TODO allow appending triangles to a triangle strip
 129
 130         if(prim_type==POINTS || prim_type==LINES || prim_type==TRIANGLES)
 131                 ;
 132         else if(MSP_primitive_restart)
 133         {
 134                 restart = true;
 135                 if(index_type==UNSIGNED_INT)
 136                         ::append<UInt32>(data, 0xFFFFFFFF);
 137                 else
 138                         ::append<UInt16>(data, 0xFFFF);
 139         }
 140         else if(prim_type==TRIANGLE_STRIP)
 141         {
 142                 append(get_index(size()-1));
 143                 append(other.get_index(0));
 144                 if(size()&1)
 145                         append(other.get_index(0));
 146         }
 147
 148         unsigned count = other.size();
 149         for(unsigned i=0; i<count; ++i)
 150                 append_index(other.get_index(i));
 151
 152         update_offset();
 153         dirty = true;
 154
 155         return *this;
 156 }
 157
 158 void Batch::append_index(unsigned i)
 159 {
 160         if(data.empty())
 161                 max_index = i;
 162         else
 163                 max_index = max(max_index, i);
 164
 165         if(index_type==UNSIGNED_SHORT && max_index>0xFFFE)
 166                 set_index_type(UNSIGNED_INT);
 167
 168         if(index_type==UNSIGNED_INT)
 169                 ::append<UInt32>(data, i);
 170         else
 171                 ::append<UInt16>(data, i);
 172 }
 173
 174 unsigned Batch::get_index_size() const
 175 {
 176         return (index_type==UNSIGNED_INT ? sizeof(UInt32) : sizeof(UInt16));
 177 }
 178
 179 unsigned Batch::get_index(unsigned i) const
 180 {
 181         if(index_type==UNSIGNED_INT)
 182                 return *(UInt32 *)&data[i*sizeof(UInt32)];
 183         else
 184                 return *(UInt16 *)&data[i*sizeof(UInt16)];
 185 }
 186
 187 void Batch::draw() const
 188 {
 189         BindRestore _bind_ibuf(get_buffer(), ELEMENT_ARRAY_BUFFER);
 190         const void *data_ptr = setup_draw();
 191
 192         glDrawElements(prim_type, size(), index_type, data_ptr);
 193 }
 194
 195 void Batch::draw_instanced(unsigned count) const
 196 {
 197         static Require req(ARB_draw_instanced);
 198
 199         BindRestore _bind_ibuf(get_buffer(), ELEMENT_ARRAY_BUFFER);
 200         const void *data_ptr = setup_draw();
 201
 202         glDrawElementsInstanced(prim_type, size(), index_type, data_ptr, count);
 203 }
 204
 205 const void *Batch::setup_draw() const
 206 {
 207         if(!get_buffer())
 208                 throw invalid_operation("Batch::setup_draw");
 209
 210         if(restart)
 211         {
 212                 unsigned index = (index_type==UNSIGNED_INT ? 0xFFFFFFFF : 0xFFFF);
 213
 214                 if(index!=restart_index)
 215                         set_restart_index(index);
 216         }
 217         else if(restart_index && restart_index<=max_index)
 218                 set_restart_index(0);
 219
 220         refresh();
 221
 222         return reinterpret_cast<const void *>(get_offset());
 223 }
 224
 225 void Batch::set_restart_index(unsigned index)
 226 {
 227         if(index>0)
 228         {
 229                 if(!restart_index)
 230                         glEnable(GL_PRIMITIVE_RESTART);
 231                 glPrimitiveRestartIndex(index);
 232         }
 233         else
 234                 glDisable(GL_PRIMITIVE_RESTART);
 235
 236         restart_index = index;
 237 }
 238
 239
 240 Batch::Loader::Loader(Batch &b):
 241         DataFile::ObjectLoader<Batch>(b)
 242 {
 243         add("indices", &Loader::indices);
 244 }
 245
 246 void Batch::Loader::indices(const vector<unsigned> &ind)
 247 {
 248         obj.append(ind);
 249 }
 250
 251 } // namespace GL
 252 } // namespace Msp