source/core/batch.cpp

   1 #include <msp/gl/extensions/msp_primitive_restart.h>
   2 #include "batch.h"
   3 #include "buffer.h"
   4 #include "error.h"
   5 #include "mesh.h"
   6 #include "vertexarray.h"
   7
   8 using namespace std;
   9
  10 namespace {
  11
  12 template<typename T>
  13 void append(vector<Msp::UInt8> &data, T i)
  14 {
  15         data.insert(data.end(), sizeof(T), 0);
  16         *(T *)(&data[data.size()-sizeof(T)]) = i;
  17 }
  18
  19 template<typename T, typename U>
  20 U convert(T n)
  21 {
  22         if(!static_cast<T>(~n))
  23                 return ~0;
  24         else
  25                 return n;
  26 }
  27
  28 template<typename T, typename U>
  29 void expand(vector<Msp::UInt8> &data)
  30 {
  31         unsigned count = data.size()/sizeof(T);
  32         data.resize(count*sizeof(U));
  33         for(unsigned i=count; i--;)
  34                 *(U *)(&data[i*sizeof(U)]) = convert<T, U>(*(T *)(&data[i*sizeof(T)]));
  35 }
  36
  37 template<typename T, typename U>
  38 void shrink(vector<Msp::UInt8> &data)
  39 {
  40         unsigned count = data.size()/sizeof(T);
  41         for(unsigned i=0; i<count; ++i)
  42                 *(U *)(&data[i*sizeof(U)]) = convert<T, U>(*(T *)(&data[i*sizeof(T)]));
  43         data.resize(count*sizeof(U));
  44 }
  45
  46 }
  47
  48 namespace Msp {
  49 namespace GL {
  50
  51 unsigned Batch::restart_index = 0;
  52
  53 Batch::Batch(PrimitiveType t):
  54         prim_type(t),
  55         gl_prim_type(GL::get_gl_primitive_type(prim_type)),
  56         index_type(UNSIGNED_SHORT),
  57         gl_index_type(get_gl_type(index_type)),
  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==index_type)
  69                 return;
  70         if(t!=UNSIGNED_SHORT && t!=UNSIGNED_INT)
  71                 throw invalid_argument("Batch::set_data_type");
  72         if(t==UNSIGNED_SHORT && max_index>0xFFFE)
  73                 throw invalid_operation("Batch::set_data_type");
  74
  75         if(index_type==UNSIGNED_SHORT && t==UNSIGNED_INT)
  76                 expand<UInt16, UInt32>(data);
  77         else if(index_type==UNSIGNED_INT && t==UNSIGNED_SHORT)
  78                 shrink<UInt32, UInt16>(data);
  79
  80         index_type = t;
  81         gl_index_type = get_gl_type(t);
  82         update_offset();
  83         dirty = true;
  84 }
  85
  86 Batch &Batch::append(unsigned i)
  87 {
  88         append_index(i);
  89
  90         update_offset();
  91         dirty = true;
  92
  93         return *this;
  94 }
  95
  96 Batch &Batch::append(const vector<unsigned> &ind)
  97 {
  98         if(ind.empty())
  99                 return *this;
 100
 101         data.reserve(data.size()+ind.size()*get_index_size());
 102         for(vector<unsigned>::const_iterator i=ind.begin(); i!=ind.end(); ++i)
 103                 append_index(*i);
 104
 105         update_offset();
 106         dirty = true;
 107
 108         return *this;
 109 }
 110
 111 bool Batch::can_append(PrimitiveType other_type)
 112 {
 113         if(other_type!=prim_type)
 114                 return false;
 115         else if(prim_type==LINE_STRIP || prim_type==LINE_LOOP || prim_type==TRIANGLE_FAN)
 116                 return MSP_primitive_restart;
 117         else
 118                 return true;
 119 }
 120
 121 Batch &Batch::append(const Batch &other)
 122 {
 123         if(other.prim_type!=prim_type)
 124                 throw invalid_argument("Batch::append");
 125         if(prim_type==LINE_STRIP || prim_type==LINE_LOOP || prim_type==TRIANGLE_FAN)
 126                 static Require _req(MSP_primitive_restart);
 127
 128         if(other.data.empty())
 129                 return *this;
 130
 131         // TODO allow appending triangles to a triangle strip
 132
 133         if(prim_type==POINTS || prim_type==LINES || prim_type==TRIANGLES)
 134                 ;
 135         else if(MSP_primitive_restart)
 136         {
 137                 restart = true;
 138                 if(index_type==UNSIGNED_INT)
 139                         ::append<UInt32>(data, 0xFFFFFFFF);
 140                 else
 141                         ::append<UInt16>(data, 0xFFFF);
 142         }
 143         else if(prim_type==TRIANGLE_STRIP)
 144         {
 145                 append(get_index(size()-1));
 146                 append(other.get_index(0));
 147                 if(size()&1)
 148                         append(other.get_index(0));
 149         }
 150
 151         unsigned count = other.size();
 152         for(unsigned i=0; i<count; ++i)
 153                 append_index(other.get_index(i));
 154
 155         update_offset();
 156         dirty = true;
 157
 158         return *this;
 159 }
 160
 161 void Batch::append_index(unsigned i)
 162 {
 163         if(data.empty())
 164                 max_index = i;
 165         else
 166                 max_index = max(max_index, i);
 167
 168         if(index_type==UNSIGNED_SHORT && max_index>0xFFFE)
 169                 set_index_type(UNSIGNED_INT);
 170
 171         if(index_type==UNSIGNED_INT)
 172                 ::append<UInt32>(data, i);
 173         else
 174                 ::append<UInt16>(data, i);
 175 }
 176
 177 unsigned Batch::get_index_size() const
 178 {
 179         return (index_type==UNSIGNED_INT ? sizeof(UInt32) : sizeof(UInt16));
 180 }
 181
 182 unsigned Batch::get_index(unsigned i) const
 183 {
 184         if(index_type==UNSIGNED_INT)
 185                 return *(UInt32 *)&data[i*sizeof(UInt32)];
 186         else
 187                 return *(UInt16 *)&data[i*sizeof(UInt16)];
 188 }
 189
 190
 191 Batch::Loader::Loader(Batch &b):
 192         DataFile::ObjectLoader<Batch>(b)
 193 {
 194         add("indices", &Loader::indices);
 195 }
 196
 197 void Batch::Loader::indices(const vector<unsigned> &ind)
 198 {
 199         obj.append(ind);
 200 }
 201
 202 } // namespace GL
 203 } // namespace Msp