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::change_buffer(Buffer *buf)
  52 {
  53         for(Bufferable *b=this; b; b=b->next_in_buffer)
  54         {
  55                 b->buffer = buf;
  56                 b->location_dirty = true;
  57                 b->dirty = true;
  58         }
  59         for(Bufferable *b=prev_in_buffer; b; b=b->prev_in_buffer)
  60         {
  61                 b->buffer = buf;
  62                 b->location_dirty = true;
  63                 b->dirty = true;
  64         }
  65 }
  66
  67 unsigned Bufferable::get_required_buffer_size() const
  68 {
  69         const Bufferable *last = this;
  70         for(; last->next_in_buffer; last=last->next_in_buffer) ;
  71         return last->offset+last->get_data_size();
  72 }
  73
  74 Bufferable::AsyncUpdater *Bufferable::refresh_async() const
  75 {
  76         return dirty ? new AsyncUpdater(*this) : 0;
  77 }
  78
  79 void Bufferable::unlink_from_buffer()
  80 {
  81         if(prev_in_buffer)
  82                 prev_in_buffer->next_in_buffer = next_in_buffer;
  83         if(next_in_buffer)
  84         {
  85                 next_in_buffer->prev_in_buffer = prev_in_buffer;
  86                 next_in_buffer->update_offset();
  87         }
  88         prev_in_buffer = 0;
  89         next_in_buffer = 0;
  90         buffer = 0;
  91 }
  92
  93 void Bufferable::update_offset()
  94 {
  95         unsigned new_offset = 0;
  96         if(prev_in_buffer)
  97                 new_offset = prev_in_buffer->offset+prev_in_buffer->get_data_size();
  98
  99         unsigned align = get_alignment();
 100         new_offset += align-1;
 101         new_offset -= new_offset%align;
 102         if(new_offset!=offset)
 103         {
 104                 offset = new_offset;
 105                 location_dirty = true;
 106                 dirty = true;
 107         }
 108
 109         if(next_in_buffer)
 110                 next_in_buffer->update_offset();
 111         else if(buffer && offset+get_data_size()>buffer->get_size())
 112         {
 113                 location_dirty = true;
 114                 dirty = true;
 115         }
 116 }
 117
 118 void Bufferable::upload_data(char *target) const
 119 {
 120         unsigned data_size = get_data_size();
 121         if(location_dirty)
 122         {
 123                 buffer->require_size(offset+data_size);
 124                 location_changed(buffer, offset, data_size);
 125                 location_dirty = false;
 126         }
 127
 128         if(target)
 129         {
 130                 const char *source = reinterpret_cast<const char *>(get_data_pointer());
 131                 copy(source, source+data_size, target);
 132         }
 133         else
 134                 buffer->sub_data(offset, data_size, get_data_pointer());
 135         dirty = false;
 136 }
 137
 138
 139 Bufferable::AsyncUpdater::AsyncUpdater(const Bufferable &b):
 140         bufferable(b)
 141 {
 142         bufferable.buffer->require_size(bufferable.get_required_buffer_size());
 143         mapped_address = reinterpret_cast<char *>(bufferable.buffer->map());
 144 }
 145
 146 Bufferable::AsyncUpdater::~AsyncUpdater()
 147 {
 148         bufferable.buffer->unmap();
 149 }
 150
 151 void Bufferable::AsyncUpdater::upload_data()
 152 {
 153         bufferable.upload_data(mapped_address+bufferable.offset);
 154         // Update all bufferables in the same buffer at once
 155         for(const Bufferable *b=bufferable.prev_in_buffer; b; b=b->prev_in_buffer)
 156                 if(b->dirty)
 157                         b->upload_data(mapped_address+b->offset);
 158         for(const Bufferable *b=bufferable.next_in_buffer; b; b=b->next_in_buffer)
 159                 if(b->dirty)
 160                         b->upload_data(mapped_address+b->offset);
 161 }
 162
 163 } // namespace GL
 164 } // namespace Msp