source/core/bufferable.cpp

   1 #include <stdexcept>
   2 #include "buffer.h"
   3 #include "bufferable.h"
   4
   5 using namespace std;
   6
   7 namespace Msp {
   8 namespace GL {
   9
  10 Bufferable::Bufferable():
  11         buffer(0),
  12         offset(0),
  13         next_in_buffer(0),
  14         prev_in_buffer(0),
  15         location_dirty(false),
  16         dirty(false)
  17 { }
  18
  19 Bufferable::~Bufferable()
  20 {
  21         unlink_from_buffer();
  22 }
  23
  24 void Bufferable::use_buffer(Buffer *buf, Bufferable *prev)
  25 {
  26         if(prev && buf!=prev->buffer)
  27                 throw invalid_argument("Bufferable::use_buffer");
  28
  29         if(buffer)
  30                 unlink_from_buffer();
  31
  32         buffer = buf;
  33         if(buffer)
  34         {
  35                 prev_in_buffer = prev;
  36                 if(prev_in_buffer)
  37                 {
  38                         next_in_buffer = prev_in_buffer->next_in_buffer;
  39                         prev_in_buffer->next_in_buffer = this;
  40                 }
  41         }
  42
  43         location_dirty = true;
  44         dirty = true;
  45         update_offset();
  46 }
  47
  48 void Bufferable::change_buffer(Buffer *buf)
  49 {
  50         for(Bufferable *b=this; b; b=b->next_in_buffer)
  51         {
  52                 b->buffer = buf;
  53                 b->location_dirty = true;
  54                 b->dirty = true;
  55         }
  56         for(Bufferable *b=prev_in_buffer; b; b=b->prev_in_buffer)
  57         {
  58                 b->buffer = buf;
  59                 b->location_dirty = true;
  60                 b->dirty = true;
  61         }
  62 }
  63
  64 unsigned Bufferable::get_required_buffer_size() const
  65 {
  66         const Bufferable *last = this;
  67         for(; last->next_in_buffer; last=last->next_in_buffer) ;
  68         return last->offset+last->get_data_size();
  69 }
  70
  71 Bufferable::AsyncUpdater *Bufferable::refresh_async() const
  72 {
  73         return dirty ? new AsyncUpdater(*this) : 0;
  74 }
  75
  76 void Bufferable::unlink_from_buffer()
  77 {
  78         if(prev_in_buffer)
  79                 prev_in_buffer->next_in_buffer = next_in_buffer;
  80         if(next_in_buffer)
  81         {
  82                 next_in_buffer->prev_in_buffer = prev_in_buffer;
  83                 next_in_buffer->update_offset();
  84         }
  85         prev_in_buffer = 0;
  86         next_in_buffer = 0;
  87         buffer = 0;
  88         offset = 0;
  89 }
  90
  91 void Bufferable::update_offset()
  92 {
  93         unsigned new_offset = 0;
  94         if(prev_in_buffer)
  95                 new_offset = prev_in_buffer->offset+prev_in_buffer->get_data_size();
  96
  97         unsigned align = get_alignment();
  98         new_offset += align-1;
  99         new_offset -= new_offset%align;
 100         if(new_offset!=offset)
 101         {
 102                 offset = new_offset;
 103                 location_dirty = true;
 104                 dirty = true;
 105         }
 106
 107         if(next_in_buffer)
 108                 next_in_buffer->update_offset();
 109         else if(buffer && offset+get_data_size()>buffer->get_size())
 110         {
 111                 location_dirty = true;
 112                 dirty = true;
 113         }
 114 }
 115
 116 void Bufferable::upload_data(char *target) const
 117 {
 118         unsigned data_size = get_data_size();
 119         if(location_dirty)
 120         {
 121                 buffer->require_size(offset+data_size);
 122                 location_changed(buffer, offset, data_size);
 123                 location_dirty = false;
 124         }
 125
 126         if(target)
 127         {
 128                 const char *source = reinterpret_cast<const char *>(get_data_pointer());
 129                 copy(source, source+data_size, target);
 130         }
 131         else
 132                 buffer->sub_data(offset, data_size, get_data_pointer());
 133         dirty = false;
 134 }
 135
 136
 137 Bufferable::AsyncUpdater::AsyncUpdater(const Bufferable &b):
 138         bufferable(b)
 139 {
 140         bufferable.buffer->require_size(bufferable.get_required_buffer_size());
 141         mapped_address = reinterpret_cast<char *>(bufferable.buffer->map());
 142 }
 143
 144 Bufferable::AsyncUpdater::~AsyncUpdater()
 145 {
 146         bufferable.buffer->unmap();
 147 }
 148
 149 void Bufferable::AsyncUpdater::upload_data()
 150 {
 151         bufferable.upload_data(mapped_address+bufferable.offset);
 152         // Update all bufferables in the same buffer at once
 153         for(const Bufferable *b=bufferable.prev_in_buffer; b; b=b->prev_in_buffer)
 154                 if(b->dirty)
 155                         b->upload_data(mapped_address+b->offset);
 156         for(const Bufferable *b=bufferable.next_in_buffer; b; b=b->next_in_buffer)
 157                 if(b->dirty)
 158                         b->upload_data(mapped_address+b->offset);
 159 }
 160
 161 } // namespace GL
 162 } // namespace Msp