source/core/bufferable.cpp

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