source/bufferable.cpp

   1 #include <stdexcept>
   2 #include <msp/core/raii.h>
   3 #include <msp/gl/extensions/arb_direct_state_access.h>
   4 #include "bindable.h"
   5 #include "buffer.h"
   6 #include "bufferable.h"
   7
   8 using namespace std;
   9
  10 namespace Msp {
  11 namespace GL {
  12
  13 Bufferable::Bufferable():
  14         buffer(0),
  15         offset(0),
  16         next_in_buffer(0),
  17         prev_in_buffer(0),
  18         location_dirty(false),
  19         dirty(false)
  20 { }
  21
  22 Bufferable::~Bufferable()
  23 {
  24         unlink_from_buffer();
  25 }
  26
  27 void Bufferable::use_buffer(Buffer *buf, Bufferable *prev)
  28 {
  29         if(prev && buf!=prev->buffer)
  30                 throw invalid_argument("Bufferable::use_buffer");
  31
  32         if(buffer)
  33                 unlink_from_buffer();
  34
  35         buffer = buf;
  36         if(buffer)
  37         {
  38                 prev_in_buffer = prev;
  39                 if(prev_in_buffer)
  40                 {
  41                         next_in_buffer = prev_in_buffer->next_in_buffer;
  42                         prev_in_buffer->next_in_buffer = this;
  43                 }
  44         }
  45
  46         location_dirty = true;
  47         dirty = true;
  48         update_offset();
  49 }
  50
  51 void Bufferable::buffer_resized()
  52 {
  53         for(Bufferable *b=this; b; b=b->next_in_buffer)
  54         {
  55                 b->location_dirty = true;
  56                 b->dirty = true;
  57         }
  58         for(Bufferable *b=prev_in_buffer; b; b=b->prev_in_buffer)
  59         {
  60                 b->location_dirty = true;
  61                 b->dirty = true;
  62         }
  63 }
  64
  65 unsigned Bufferable::get_required_buffer_size() const
  66 {
  67         const Bufferable *last = this;
  68         for(; last->next_in_buffer; last=last->next_in_buffer) ;
  69         return last->offset+last->get_data_size();
  70 }
  71
  72 Bufferable::AsyncUpdater *Bufferable::refresh_async() const
  73 {
  74         return dirty ? new AsyncUpdater(*this) : 0;
  75 }
  76
  77 void Bufferable::unlink_from_buffer()
  78 {
  79         if(prev_in_buffer)
  80                 prev_in_buffer->next_in_buffer = next_in_buffer;
  81         if(next_in_buffer)
  82         {
  83                 next_in_buffer->prev_in_buffer = prev_in_buffer;
  84                 next_in_buffer->update_offset();
  85         }
  86         prev_in_buffer = 0;
  87         next_in_buffer = 0;
  88         buffer = 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(WRITE_ONLY));
 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