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         index_type(UNSIGNED_SHORT),
  56         gl_index_type(get_gl_type(index_type)),
  57         max_index(0),
  58         restart(false)
  59 { }
  60
  61 Batch::~Batch()
  62 {
  63 }
  64
  65 void Batch::set_index_type(DataType t)
  66 {
  67         if(t==index_type)
  68                 return;
  69         if(t!=UNSIGNED_SHORT && t!=UNSIGNED_INT)
  70                 throw invalid_argument("Batch::set_data_type");
  71         if(t==UNSIGNED_SHORT && max_index>0xFFFE)
  72                 throw invalid_operation("Batch::set_data_type");
  73
  74         if(index_type==UNSIGNED_SHORT && t==UNSIGNED_INT)
  75                 expand<UInt16, UInt32>(data);
  76         else if(index_type==UNSIGNED_INT && t==UNSIGNED_SHORT)
  77                 shrink<UInt32, UInt16>(data);
  78
  79         index_type = t;
  80         gl_index_type = get_gl_type(t);
  81         update_offset();
  82         dirty = true;
  83 }
  84
  85 Batch &Batch::append(unsigned i)
  86 {
  87         append_index(i);
  88
  89         update_offset();
  90         dirty = true;
  91
  92         return *this;
  93 }
  94
  95 Batch &Batch::append(const vector<unsigned> &ind)
  96 {
  97         if(ind.empty())
  98                 return *this;
  99
 100         data.reserve(data.size()+ind.size()*get_index_size());
 101         for(vector<unsigned>::const_iterator i=ind.begin(); i!=ind.end(); ++i)
 102                 append_index(*i);
 103
 104         update_offset();
 105         dirty = true;
 106
 107         return *this;
 108 }
 109
 110 bool Batch::can_append(PrimitiveType other_type)
 111 {
 112         if(other_type!=prim_type)
 113                 return false;
 114         else if(prim_type==LINE_STRIP || prim_type==LINE_LOOP || prim_type==TRIANGLE_FAN)
 115                 return MSP_primitive_restart;
 116         else
 117                 return true;
 118 }
 119
 120 Batch &Batch::append(const Batch &other)
 121 {
 122         if(other.prim_type!=prim_type)
 123                 throw invalid_argument("Batch::append");
 124         if(prim_type==LINE_STRIP || prim_type==LINE_LOOP || prim_type==TRIANGLE_FAN)
 125                 static Require _req(MSP_primitive_restart);
 126
 127         if(other.data.empty())
 128                 return *this;
 129
 130         // TODO allow appending triangles to a triangle strip
 131
 132         if(prim_type==POINTS || prim_type==LINES || prim_type==TRIANGLES)
 133                 ;
 134         else if(MSP_primitive_restart)
 135         {
 136                 restart = true;
 137                 if(index_type==UNSIGNED_INT)
 138                         ::append<UInt32>(data, 0xFFFFFFFF);
 139                 else
 140                         ::append<UInt16>(data, 0xFFFF);
 141         }
 142         else if(prim_type==TRIANGLE_STRIP)
 143         {
 144                 append(get_index(size()-1));
 145                 append(other.get_index(0));
 146                 if(size()&1)
 147                         append(other.get_index(0));
 148         }
 149
 150         unsigned count = other.size();
 151         for(unsigned i=0; i<count; ++i)
 152                 append_index(other.get_index(i));
 153
 154         update_offset();
 155         dirty = true;
 156
 157         return *this;
 158 }
 159
 160 void Batch::append_index(unsigned i)
 161 {
 162         if(data.empty())
 163                 max_index = i;
 164         else
 165                 max_index = max(max_index, i);
 166
 167         if(index_type==UNSIGNED_SHORT && max_index>0xFFFE)
 168                 set_index_type(UNSIGNED_INT);
 169
 170         if(index_type==UNSIGNED_INT)
 171                 ::append<UInt32>(data, i);
 172         else
 173                 ::append<UInt16>(data, i);
 174 }
 175
 176 unsigned Batch::get_index_size() const
 177 {
 178         return (index_type==UNSIGNED_INT ? sizeof(UInt32) : sizeof(UInt16));
 179 }
 180
 181 unsigned Batch::get_index(unsigned i) const
 182 {
 183         if(index_type==UNSIGNED_INT)
 184                 return *(UInt32 *)&data[i*sizeof(UInt32)];
 185         else
 186                 return *(UInt16 *)&data[i*sizeof(UInt16)];
 187 }
 188
 189
 190 Batch::Loader::Loader(Batch &b):
 191         DataFile::ObjectLoader<Batch>(b)
 192 {
 193         add("indices", &Loader::indices);
 194 }
 195
 196 void Batch::Loader::indices(const vector<unsigned> &ind)
 197 {
 198         obj.append(ind);
 199 }
 200
 201 } // namespace GL
 202 } // namespace Msp