Large OpenGL Object handling overhaul
This commit is contained in:
NaifBanana
@@ -2,4 +2,20 @@
|
||||
|
||||
namespace nb {
|
||||
|
||||
using BufferErrorCodes = BufferError::Codes;
|
||||
const std::string BufferError::type = "nb::BufferError";
|
||||
const ErrorCodeMap BufferError::ErrorMessages = {
|
||||
{ BufferErrorCodes::UNDEFINED, "Error" },
|
||||
{ BufferErrorCodes::DATA_OVERFLOW, "Attempting buffer overflow" },
|
||||
{ BufferErrorCodes::INVALID_BUFFER, "Attempting operation on invalid buffer" },
|
||||
{BufferErrorCodes::HANDLE_OVERWRITE, "Attempting to overwrite active buffer"}
|
||||
|
||||
};
|
||||
|
||||
template<>
|
||||
ArrayBuffer<false>::ArrayBuffer(const ByteVector& data_, GLenum usage_)
|
||||
: BufferType() {
|
||||
data(data_, usage_);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
#include "Camera.h"
|
||||
namespace NB {
|
||||
#include "Camera.hpp"
|
||||
|
||||
namespace nb {
|
||||
|
||||
// Camera class
|
||||
Camera::Camera(const Vec3& pos, const Vec3& tar, const Vec3& up) {
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
#include "OGLObjects.hpp"
|
||||
|
||||
namespace nb {
|
||||
|
||||
const std::string OGLError::type = "nb::OGLError";
|
||||
const ErrorCodeMap OGLError::ErrorMessages = {
|
||||
{ OGLError::Codes::UNDEFINED, "Error" },
|
||||
{OGLError::Codes::HANGING_OBJECT, "Attempting to leave a hanging OpenGL object"}
|
||||
};
|
||||
|
||||
} // namespace nb
|
||||
@@ -0,0 +1,10 @@
|
||||
#include "Textures.hpp"
|
||||
|
||||
namespace nb{
|
||||
|
||||
Texture::Texture(GLenum target_) : target(target_) {
|
||||
glGenTextures(1, &_id);
|
||||
}
|
||||
|
||||
|
||||
} // namespace nb
|
||||
@@ -1,225 +0,0 @@
|
||||
#include "VAOManager.hpp"
|
||||
|
||||
namespace NB {
|
||||
|
||||
using BufferManagerPointer = std::shared_ptr<Buffer>;
|
||||
|
||||
VAOManager::VAOManager() { glGenVertexArrays(1, &_id); }
|
||||
|
||||
VAOManager::VAOManager(
|
||||
std::vector<BufferManagerPointer> vert_bufs,
|
||||
BufferManagerPointer elmt_buf,
|
||||
const VertexAttributeList& vert_attrs
|
||||
) : VAOManager() {
|
||||
_elmt_buffer = elmt_buf;
|
||||
for (BufferManagerPointer vb : vert_bufs) {
|
||||
_vert_buffers[vb->id()] = vb;
|
||||
}
|
||||
if (vert_attrs.size()!=0) {
|
||||
generate(vert_attrs);
|
||||
}
|
||||
}
|
||||
|
||||
VAOManager::VAOManager(VAOManager&& rhs) { *this = std::move(rhs); }
|
||||
|
||||
VAOManager& VAOManager::operator=(VAOManager&& rhs) {
|
||||
remove();
|
||||
_vert_buffers = rhs._vert_buffers;
|
||||
_elmt_buffer = rhs._elmt_buffer;
|
||||
_vert_attrs = rhs._vert_attrs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::getLayout() const { return _vert_attrs; }
|
||||
|
||||
GLuint VAOManager::id() const { return _id; }
|
||||
|
||||
bool VAOManager::isInitialized() const {
|
||||
return _id && glIsVertexArray(_id);
|
||||
}
|
||||
|
||||
void VAOManager::remove() const {
|
||||
bind();
|
||||
for (int i{0}; i < _vert_attrs.size(); ++i) {
|
||||
glDisableVertexAttribArray(i);
|
||||
}
|
||||
unbind();
|
||||
glDisableVertexAttribArray(_id);
|
||||
}
|
||||
|
||||
unsigned int VAOManager::vertSize(GLuint id) const {
|
||||
unsigned int size = 0;
|
||||
for (const VertexAttribute& va : _vert_attrs) {
|
||||
if (va.ptr.buffer == id) {
|
||||
size += va.GLSLSize * GLSLTypeSize(va.GLSLType);
|
||||
}
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
std::vector<BufferManagerPointer> VAOManager::getVertexBuffers() const {
|
||||
std::vector<BufferManagerPointer> ret;
|
||||
for (const auto& i : _vert_buffers) {
|
||||
ret.emplace_back(i.second);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
RawVec VAOManager::attributeData(unsigned int i) {
|
||||
if (i <= _vert_attrs.size()) {
|
||||
throw std::out_of_range("No vertex attribute exists for specified index");
|
||||
}
|
||||
VertexAttribute attr = _vert_attrs[i];
|
||||
BufferManagerPointer buffer = _vert_buffers[attr.ptr.buffer];
|
||||
RawVec data = buffer->data();
|
||||
unsigned int attr_size = attr.GLSLSize*GLSLTypeSize(attr.GLSLType);
|
||||
RawVec ret((buffer->size()-attr.ptr.offset-attr_size)*attr_size/attr.ptr.stride);
|
||||
int data_size = data.size();
|
||||
for (int i{0}; i < data_size; ++i) {
|
||||
if (isIndexInVertexAttribute(i, attr)) {
|
||||
ret[i] = data[i];
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
RawVec VAOManager::attributeData(unsigned int i, const RawVec& new_data) {
|
||||
if (i >= _vert_attrs.size()) {
|
||||
throw std::out_of_range("No vertex attribute exists for specified index.");
|
||||
}
|
||||
VertexAttribute attr = _vert_attrs[i];
|
||||
BufferManagerPointer buffer = _vert_buffers[attr.ptr.buffer];
|
||||
unsigned int attr_size = attr.GLSLSize*GLSLTypeSize(attr.GLSLType);
|
||||
unsigned int offset = attr.ptr.offset;
|
||||
unsigned int num_verts = buffer->size() / vertSize(buffer->id());
|
||||
if (num_verts*attr_size != new_data.size()) {
|
||||
// WHY HERE????
|
||||
THROW_VAO_ERROR(
|
||||
"Input data size of " + std::to_string(new_data.size())
|
||||
+ " does not match data size for requested vertex attribute of total size " + std::to_string(num_verts*attr_size)
|
||||
+ "."
|
||||
);
|
||||
}
|
||||
uint64_t pos = uint64_t(new_data.data());
|
||||
for (int i{0}; i<num_verts; i++) {
|
||||
buffer->data((void*)(pos+i*attr_size), offset+i*attr.ptr.stride, attr_size);
|
||||
}
|
||||
return RawVec(new_data);
|
||||
}
|
||||
|
||||
void VAOManager::bind() const {
|
||||
glBindVertexArray(_id);
|
||||
if (_elmt_buffer) { _elmt_buffer->bind(); }
|
||||
}
|
||||
|
||||
void VAOManager::unbind() const {
|
||||
glBindVertexArray(0);
|
||||
if (_elmt_buffer) { _elmt_buffer->unbind(); }
|
||||
}
|
||||
|
||||
void VAOManager::addVBO(BufferManagerPointer vert_buf) {
|
||||
GLuint vert_id = vert_buf->id();
|
||||
if (_vert_buffers.find(vert_id) == _vert_buffers.end()) {
|
||||
_vert_buffers[vert_buf->id()] = vert_buf;
|
||||
} else {
|
||||
THROW_VAO_ERROR("Attempting to add identical VBO id of " + std::to_string(vert_id) + ".");
|
||||
}
|
||||
}
|
||||
|
||||
void VAOManager::changeEBO(BufferManagerPointer ebo) {
|
||||
_elmt_buffer = ebo;
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::addVertexAttributes(const VertexAttributeList& vert_attrs) {
|
||||
VertexAttributeList curr_vas = _vert_attrs;
|
||||
curr_vas.insert(curr_vas.end(), vert_attrs.begin(), vert_attrs.end());
|
||||
try {
|
||||
throw checkValid(curr_vas);
|
||||
} catch (VAOError vaoe) {
|
||||
if (vaoe.error) {
|
||||
THROW_VAO_ERROR(vaoe.what());
|
||||
}
|
||||
}
|
||||
_vert_attrs = curr_vas;
|
||||
generate();
|
||||
return _vert_attrs;
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::addVertexAttributes(VertexAttribute vert_attr) {
|
||||
return addVertexAttributes({vert_attr});
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::generate() {
|
||||
bind();
|
||||
unsigned int num_attrs = _vert_attrs.size();
|
||||
VertexAttribute* va;
|
||||
for (int i = 0; i < num_attrs; ++i) {
|
||||
va = &(_vert_attrs[i]);
|
||||
_vert_buffers[va->ptr.buffer]->bind();
|
||||
glVertexAttribPointer(
|
||||
i,
|
||||
va->GLSLSize,
|
||||
va->GLSLType,
|
||||
va->GLSLNormalization,
|
||||
va->ptr.stride,
|
||||
(void*)va->ptr.offset
|
||||
);
|
||||
glVertexAttribDivisor(i, va->ptr.divisor);
|
||||
glEnableVertexAttribArray(i);
|
||||
}
|
||||
if (_elmt_buffer != nullptr) {
|
||||
_elmt_buffer->bind();
|
||||
}
|
||||
unbind();
|
||||
return _vert_attrs;
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::generate(VertexAttributeList vert_attrs) {
|
||||
try {
|
||||
throw checkValid(vert_attrs);
|
||||
} catch (VAOError vaoe) {
|
||||
if (vaoe.error) {
|
||||
THROW_VAO_ERROR(vaoe.what());
|
||||
}
|
||||
}
|
||||
_vert_attrs.swap(vert_attrs);
|
||||
return generate();
|
||||
}
|
||||
|
||||
VertexAttributeList VAOManager::changeLayout(unsigned int i, VertexAttributePointer vap) {
|
||||
_vert_attrs[i].ptr = vap;
|
||||
bind();
|
||||
const VertexAttribute* va = &(_vert_attrs[i]);
|
||||
glDisableVertexAttribArray(i);
|
||||
_vert_buffers[va->ptr.buffer]->bind();
|
||||
glVertexAttribPointer(
|
||||
_id,
|
||||
va->GLSLSize,
|
||||
va->GLSLType,
|
||||
va->GLSLNormalization,
|
||||
va->ptr.stride,
|
||||
(void*)va->ptr.offset
|
||||
);
|
||||
glVertexAttribDivisor(i, va->ptr.divisor);
|
||||
glEnableVertexAttribArray(i);
|
||||
unbind();
|
||||
return _vert_attrs;
|
||||
}
|
||||
|
||||
VAOError VAOManager::checkValid(const VertexAttributeList& vert_attrs) {
|
||||
GLuint va_id;
|
||||
unsigned int num_attrs = vert_attrs.size();
|
||||
for (int i = 0; i < num_attrs; ++i) {
|
||||
va_id = vert_attrs[i].ptr.buffer;
|
||||
if (_vert_buffers.find(va_id) == _vert_buffers.cend()) {
|
||||
return VAOError("Attempting to point to unknown VBO of id " + std::to_string(va_id) +
|
||||
" at Vertex Attribute " + std::to_string(i) + ".");
|
||||
}
|
||||
if (vert_attrs[i].ptr.stride<0) {
|
||||
return VAOError("Invalid stride value at Vertex Attribute " + std::to_string(i) + ".");
|
||||
}
|
||||
}
|
||||
return VAOError(false);
|
||||
}
|
||||
|
||||
} // namespace NB
|
||||
@@ -0,0 +1,222 @@
|
||||
#include "VertexArray.hpp"
|
||||
|
||||
namespace nb {
|
||||
|
||||
using VAOErrorCodes = VAOError::Codes;
|
||||
const std::string VAOError::type = "nb::VAOError";
|
||||
const ErrorCodeMap VAOError::ErrorMessages = {
|
||||
{ VAOErrorCodes::UNDEFINED, "Error" },
|
||||
{ VAOErrorCodes::INVALID_ATTRIBUTE, "Targeting invalid attribute"},
|
||||
{ VAOErrorCodes::INVALID_VAO, "Targeting invalid VAO" }
|
||||
};
|
||||
|
||||
VAO::VAO(const VertexAttributePointerList& attr_ptrs) {
|
||||
attributes(attr_ptrs);
|
||||
}
|
||||
|
||||
VAO::VAO(VAO&& other) {
|
||||
*this = std::move(other);
|
||||
}
|
||||
|
||||
VAO& VAO::operator=(VAO&& rhs) {
|
||||
_id = rhs._id;
|
||||
_attrs = rhs._attrs;
|
||||
|
||||
rhs._id = 0;
|
||||
rhs._attrs = {};
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
VertexAttributePointerList VAO::attributes() const {
|
||||
return _attrs;
|
||||
}
|
||||
|
||||
VertexAttributePointerList VAO::attributes(const VertexAttributePointerList& attrs_) {
|
||||
declare();
|
||||
disable();
|
||||
_attrs = attrs_;
|
||||
bind();
|
||||
for (auto attr_ptr : attrs_) {
|
||||
attr_ptr.buffer->bind();
|
||||
GLuint idx = attr_ptr.index;
|
||||
glVertexAttribPointer(
|
||||
idx,
|
||||
attr_ptr.attribute.GLSLSize,
|
||||
attr_ptr.attribute.GLSLType,
|
||||
attr_ptr.attribute.GLSLNormalization,
|
||||
attr_ptr.attribute.layout.stride,
|
||||
(void*)attr_ptr.attribute.layout.offset
|
||||
);
|
||||
glEnableVertexAttribArray(idx);
|
||||
}
|
||||
unbind();
|
||||
return _attrs;
|
||||
}
|
||||
|
||||
VertexAttributePointer VAO::attr(GLuint idx) const {
|
||||
for (auto attr_ptr : _attrs) {
|
||||
if (idx == attr_ptr.index) {
|
||||
return attr_ptr;
|
||||
}
|
||||
}
|
||||
THROW(BufferError(Codes::INVALID_ATTRIBUTE));
|
||||
}
|
||||
|
||||
void VAO::enable() const {
|
||||
if (_id) {
|
||||
bind();
|
||||
for(auto attr_ptr : _attrs) {
|
||||
glEnableVertexAttribArray(attr_ptr.index);
|
||||
}
|
||||
unbind();
|
||||
}
|
||||
}
|
||||
|
||||
void VAO::enable(GLuint idx) const {
|
||||
if(_id) {
|
||||
bind();
|
||||
glEnableVertexAttribArray(attr(idx).index);
|
||||
unbind();
|
||||
}
|
||||
}
|
||||
|
||||
void VAO::disable() const {
|
||||
if(_id) {
|
||||
bind();
|
||||
for(auto attr_ptr : _attrs) {
|
||||
glDisableVertexAttribArray(attr_ptr.index);
|
||||
}
|
||||
unbind();
|
||||
}
|
||||
}
|
||||
|
||||
void VAO::disable(GLuint idx) const {
|
||||
if(_id) {
|
||||
bind();
|
||||
glDisableVertexAttribArray(attr(idx).index);
|
||||
unbind();
|
||||
}
|
||||
}
|
||||
|
||||
VertexGroup::VertexGroup(VertexGroup&& other) {
|
||||
*this = std::move(other);
|
||||
}
|
||||
|
||||
VertexGroup& VertexGroup::operator=(VertexGroup&& rhs) {
|
||||
_vertex_data = rhs._vertex_data;
|
||||
_elmt_buf = std::move(rhs._elmt_buf);
|
||||
_vao = std::move(rhs._vao);
|
||||
|
||||
rhs._vertex_data = {};
|
||||
rhs._elmt_buf = ElementBuffer<false>();
|
||||
rhs._vao = VAO();
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
size_t VertexGroup::buffer(VertexBuffer<false>&& buf_) {
|
||||
_vertex_data.emplace_back(
|
||||
std::make_shared<VertexBuffer<false>>(std::move(buf_))
|
||||
);
|
||||
VertexBuffer<false>* buf_ptr = _vertex_data.back().get();
|
||||
VertexAttributePointerList attrs = _vao.attributes();
|
||||
GLuint idx = attrs.size();
|
||||
for (auto attr : buf_ptr->attributes) {
|
||||
attrs.emplace_back(
|
||||
VertexAttributePointer{attr, buf_ptr,idx}
|
||||
);
|
||||
idx++;
|
||||
}
|
||||
_vao.attributes(attrs);
|
||||
return _vertex_data.size();
|
||||
}
|
||||
|
||||
VertexBuffer<false>& VertexGroup::buffer(size_t idx) {
|
||||
return *_vertex_data[idx];
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<VertexBuffer<false>>> VertexGroup::buffers() {
|
||||
return _vertex_data;
|
||||
}
|
||||
|
||||
size_t VertexGroup::buffers(std::vector<VertexBuffer<false>>&& bufs_) {
|
||||
_vertex_data = {};
|
||||
for (auto& buf : bufs_) {
|
||||
_vertex_data.emplace_back(
|
||||
std::make_shared<VertexBuffer<false>>(std::move(buf))
|
||||
);
|
||||
}
|
||||
VertexAttributePointerList attr_ptrs;
|
||||
GLuint idx = 0;
|
||||
for (auto buf : _vertex_data) {
|
||||
for (auto attr : buf->attributes) {
|
||||
attr_ptrs.emplace_back(
|
||||
VertexAttributePointer{attr, buf.get(), idx}
|
||||
);
|
||||
idx++;
|
||||
}
|
||||
}
|
||||
_vao.attributes(attr_ptrs);
|
||||
return _vertex_data.size();
|
||||
}
|
||||
|
||||
VertexBuffer<false>&& VertexGroup::dropBuffer(size_t idx) {
|
||||
if (idx >= _vertex_data.size()) {
|
||||
THROW(BufferError(BufferError::Codes::INVALID_BUFFER));
|
||||
}
|
||||
std::vector<VertexBuffer<false>> tmp;
|
||||
for (auto buf : _vertex_data) {
|
||||
tmp.emplace_back(std::move(*buf));
|
||||
}
|
||||
_vertex_data.clear();
|
||||
std::shared_ptr<VertexBuffer<false>> ret_ptr =
|
||||
std::make_shared<VertexBuffer<false>>(std::move(tmp[idx]));
|
||||
tmp.erase(tmp.begin()+idx);
|
||||
buffers(std::move(tmp));
|
||||
return std::move(*ret_ptr);
|
||||
}
|
||||
|
||||
VertexAttributePointer VertexGroup::attribute(size_t idx_) const {
|
||||
return _vao.attr(idx_);
|
||||
}
|
||||
|
||||
void VertexGroup::enableAttr(GLuint idx) {
|
||||
bind();
|
||||
_vao.enable(idx);
|
||||
unbind();
|
||||
}
|
||||
|
||||
void VertexGroup::disableAttr(GLuint idx) {
|
||||
bind();
|
||||
_vao.disable(idx);
|
||||
unbind();
|
||||
}
|
||||
|
||||
void VertexGroup::disableBuffer(size_t idx) {
|
||||
auto buf_ptr = _vertex_data[idx].get();
|
||||
bind();
|
||||
for (auto attr : _vao.attributes()) {
|
||||
if (attr.buffer == buf_ptr) {
|
||||
_vao.disable(attr.index);
|
||||
}
|
||||
}
|
||||
unbind();
|
||||
}
|
||||
|
||||
void VertexGroup::enableBuffer(size_t idx) {
|
||||
auto buf_ptr = _vertex_data[idx].get();
|
||||
bind();
|
||||
for (auto attr : _vao.attributes()) {
|
||||
if (attr.buffer == buf_ptr) {
|
||||
_vao.enable(attr.index);
|
||||
}
|
||||
}
|
||||
unbind();
|
||||
}
|
||||
|
||||
void VertexGroup::enable() { _vao.enable(); }
|
||||
|
||||
void VertexGroup::disable() { _vao.disable(); }
|
||||
|
||||
} // namespace nb
|
||||
Reference in New Issue
Block a user