bufferobject.h

Go to the documentation of this file.

#ifndef ION_GFX_BUFFEROBJECT_H_
#define ION_GFX_BUFFEROBJECT_H_

#include "ion/base/datacontainer.h"
#include "ion/base/invalid.h"
#include "ion/base/referent.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/external/gtest/gunit_prod.h"  // For FRIEND_TEST().
#include "ion/gfx/resourceholder.h"
#include "ion/math/range.h"

namespace ion {
namespace gfx {
class BufferObject;
typedef base::ReferentPtr<BufferObject>::Type BufferObjectPtr;

class ION_API BufferObject : public ResourceHolder {
 public:
  enum Changes {
    kDataChanged = kNumBaseChanges,
    kSubDataChanged,
    kNumChanges
  };

  enum ComponentType {
    kInvalid,  // An invalid spec.
    kByte,
    kUnsignedByte,
    kShort,
    kUnsignedShort,
    kInt,
    kUnsignedInt,
    kFloat,
    kFloatMatrixColumn2,
    kFloatMatrixColumn3,
    kFloatMatrixColumn4
  };

  enum Target {
    kArrayBuffer,
    kElementBuffer,
    kCopyReadBuffer,
    kCopyWriteBuffer
  };

  enum UsageMode {
    kDynamicDraw,
    kStaticDraw,
    kStreamDraw,
  };

  struct BufferSubData {
    BufferSubData() : read_offset(0) {}

    BufferSubData(const math::Range1ui& range_in,
                  const base::DataContainerPtr& data_in)
        : range(range_in), data(data_in), read_offset(0) {
      DCHECK(data_in.Get());
    }
    BufferSubData(const BufferObjectPtr& src_in,
                  const math::Range1ui& range_in,
                  uint32 read_offset_in)
        : range(range_in), read_offset(read_offset_in), src(src_in) {}
    ~BufferSubData();

    math::Range1ui range;
    base::DataContainerPtr data;
    uint32 read_offset;
    BufferObjectPtr src;
  };

  BufferObject();

  Target GetTarget() const { return target_; }

  struct Spec {
    Spec()
        : component_count(0U),
          byte_offset(0U),
          type(kInvalid) {}

    Spec(const ComponentType type_in, const size_t count_in,
         const size_t offset_in)
        : component_count(count_in),
          byte_offset(offset_in),
          type(type_in) {}

    bool operator==(const Spec& other) const {
      return component_count == other.component_count &&
             byte_offset == other.byte_offset &&
             type == other.type;
    }

    size_t component_count;
    size_t byte_offset;
    ComponentType type;
  };

  size_t AddSpec(const ComponentType type, const size_t component_count,
                 const size_t byte_offset);

  const Spec& GetSpec(const size_t spec_index) const;

  size_t GetSpecCount() const { return specs_.size(); }

  void SetData(const base::DataContainerPtr& data, const size_t struct_size,
               const size_t count, UsageMode usage) {
    if (base::DataContainer* old_data = GetData().Get())
      old_data->RemoveReceiver(this);
    if (base::DataContainer* new_data = data.Get())
      new_data->AddReceiver(this);
    data_.Set(BufferData(data, struct_size, count, usage));
  }

  const base::DataContainerPtr& GetData() const { return data_.Get().data; }

  void SetSubData(const math::Range1ui& byte_range,
                  const base::DataContainerPtr& data) {
    if (!byte_range.IsEmpty() && data.Get() && data->GetData()) {
      sub_data_.push_back(BufferSubData(byte_range, data));
      sub_data_changed_.Set(true);
      sub_data_changed_.Set(false);
    }
  }
  void CopySubData(const BufferObjectPtr& src,
                   const math::Range1ui& dst_byte_range,
                   uint32 read_offset) {
    if (src.Get() && !dst_byte_range.IsEmpty()) {
      sub_data_.push_back(BufferSubData(
          src.Get() == this ? BufferObjectPtr() : src,
          dst_byte_range, read_offset));
      sub_data_changed_.Set(true);
      sub_data_changed_.Set(false);
    }
  }
  void ClearSubData() const {
    sub_data_.clear();
  }
  const base::AllocVector<BufferSubData>& GetSubData() const {
    return sub_data_;
  }

  void* GetMappedPointer() const {
    return mapped_data_.pointer;
  }

  size_t GetStructSize() const { return data_.Get().struct_size; }
  size_t GetCount() const { return data_.Get().count; }
  UsageMode GetUsageMode() const { return data_.Get().usage; }

 protected:
  explicit BufferObject(Target target);

  ~BufferObject() override;

 private:
  struct BufferData {
    BufferData()
        : data(nullptr),
          struct_size(0U),
          count(0U),
          usage(kStaticDraw) {}

    BufferData(const base::DataContainerPtr& data_in,
               const size_t struct_size_in,
               const size_t count_in, const UsageMode usage_in)
        : data(data_in),
          struct_size(struct_size_in),
          count(count_in),
          usage(usage_in) {}

    inline bool operator !=(const BufferData& other) const {
      return true;
    }

    base::DataContainerPtr data;
    size_t struct_size;
    size_t count;
    UsageMode usage;
  };

  struct MappedBufferData {
    enum DataSource {
      kGpuMapped,  // Data is mapped by GPU.
      kAllocated,  // Data is allocated from Allocator, needs free.
      kDataContainer  // Data comes from BufferObject's DataContainer, no free.
    };
    MappedBufferData()
        : range(math::Range1ui()),
          pointer(nullptr),
          data_source(base::InvalidEnumValue<
                      BufferObject::MappedBufferData::DataSource>()),
          read_only(true) {}
    math::Range1ui range;
    void* pointer;
    DataSource data_source;
    bool read_only;
  };

  void OnNotify(const base::Notifier* notifier) override;

  void SetMappedData(const math::Range1ui& range, void* pointer,
                     MappedBufferData::DataSource data_source, bool read_only) {
    mapped_data_.range = range;
    mapped_data_.pointer = pointer;
    mapped_data_.data_source = data_source;
    mapped_data_.read_only = read_only;
  }

  const MappedBufferData& GetMappedData() const {
    return mapped_data_;
  }

  base::AllocVector<Spec> specs_;

  Field<BufferData> data_;

  Target target_;

  mutable base::AllocVector<BufferSubData> sub_data_;
  Field<bool> sub_data_changed_;

  MappedBufferData mapped_data_;

  friend class Renderer;

  FRIEND_TEST(BufferObjectTest, MappedData);
  FRIEND_TEST(RendererTest, MappedBuffer);
};

struct BufferObjectElement {
  BufferObjectElement()
      : buffer_object(nullptr),
        spec_index(0U) {}

  BufferObjectElement(const BufferObjectPtr& buffer_in,
                      const size_t spec_index_in)
      : buffer_object(buffer_in),
        spec_index(spec_index_in) {}

  bool operator==(const BufferObjectElement& other) const {
    return buffer_object == other.buffer_object &&
        spec_index == other.spec_index;
  }

  const BufferObjectPtr buffer_object;
  const size_t spec_index;
};

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_BUFFEROBJECT_H_