From c977c02ba3a6ad6ada3f1a458b41a77f2be2b871 Mon Sep 17 00:00:00 2001 From: Dan Goodliffe Date: Mon, 1 May 2023 21:29:01 +0100 Subject: Refactor InstanceVertices in terms of glContainer --- gfx/gl/instanceVertices.h | 124 +++++++++++----------------------------------- 1 file changed, 29 insertions(+), 95 deletions(-) (limited to 'gfx') diff --git a/gfx/gl/instanceVertices.h b/gfx/gl/instanceVertices.h index 9df6e12..7b0341b 100644 --- a/gfx/gl/instanceVertices.h +++ b/gfx/gl/instanceVertices.h @@ -1,20 +1,15 @@ #pragma once -#include "glArrays.h" +#include "glContainer.h" +#include "pack.h" #include -#include -#include #include #include -#include -template class InstanceVertices { -public: - InstanceVertices(size_t initialSize = 16) - { - allocBuffer(initialSize); - } +template class InstanceVertices : protected glContainer { + using base = glContainer; +public: class [[nodiscard]] InstanceProxy { public: InstanceProxy(InstanceVertices * iv, std::size_t idx) : instances {iv}, index {idx} { } @@ -44,27 +39,27 @@ public: T & operator=(U && v) { - return instances->at(index) = std::forward(v); + return instances->lookup(index) = std::forward(v); } [[nodiscard]] operator T &() { - return instances->at(index); + return instances->lookup(index); } [[nodiscard]] operator const T &() const { - return instances->at(index); + return instances->lookup(index); } [[nodiscard]] T * get() { - return &instances->at(index); + return &instances->lookup(index); } [[nodiscard]] const T * get() const { - return &instances->at(index); + return &instances->lookup(index); } [[nodiscard]] T * operator->() @@ -79,12 +74,12 @@ public: [[nodiscard]] T & operator*() { - return instances->at(index); + return instances->lookup(index); } [[nodiscard]] const T & operator*() const { - return instances->at(index); + return instances->lookup(index); } private: @@ -96,33 +91,25 @@ public: [[nodiscard]] InstanceProxy acquire(Params &&... params) { - map(); if (!unused.empty()) { auto idx = unused.back(); unused.pop_back(); - index[idx] = next++; - new (&at(idx)) T(std::forward(params)...); + index[idx] = base::size(); + base::emplace_back(std::forward(params)...); return InstanceProxy {this, idx}; } - if (next >= capacity) { - resize(capacity * 2); - } - index.emplace_back(next++); - new (data + index.back()) T(std::forward(params)...); + index.emplace_back(base::size()); + base::emplace_back(std::forward(params)...); return InstanceProxy {this, index.size() - 1}; } - [[nodiscard]] const auto & - bufferName() const - { - return buffer; - } + using base::bufferName; [[nodiscard]] auto - count() const + size() const { - unmap(); - return next; + base::unmap(); + return base::size(); } protected: @@ -131,16 +118,13 @@ protected: void release(const size_t pidx) { - // Destroy p's object - at(pidx).~T(); - if (--next != index[pidx]) { - // Move last object into p's slot - new (&at(pidx)) T {std::move(data[next])}; - (data[next]).~T(); - *std::find_if(index.begin(), index.end(), [this](const auto & i) { - return i == next && !std::binary_search(unused.begin(), unused.end(), &i - index.data()); + if (base::size() - 1 != index[pidx]) { + lookup(pidx) = std::move(base::back()); + *std::find_if(index.begin(), index.end(), [this, old = base::size() - 1](const auto & i) { + return i == old && !std::binary_search(unused.begin(), unused.end(), &i - index.data()); }) = index[pidx]; } + base::pop_back(); if (pidx == index.size() - 1) { index.pop_back(); } @@ -150,64 +134,14 @@ protected: } } - void - allocBuffer(std::size_t newCapacity) - { - glBindBuffer(GL_ARRAY_BUFFER, buffer); - glBufferData(GL_ARRAY_BUFFER, static_cast(sizeof(T) * newCapacity), nullptr, GL_DYNAMIC_DRAW); - glBindBuffer(GL_ARRAY_BUFFER, 0); - capacity = newCapacity; - data = nullptr; - } - - void - resize(size_t newCapacity) - { - const auto maintain = std::min(newCapacity, capacity); - std::vector existing; - const auto maintaind = static_cast(maintain); - existing.reserve(maintain); - map(); - std::move(data, data + maintain, std::back_inserter(existing)); - allocBuffer(newCapacity); - map(); - std::move(existing.begin(), existing.begin() + maintaind, data); - capacity = newCapacity; - } - [[nodiscard]] T & - at(size_t pindex) - { - map(); - return data[index[pindex]]; - } - - void - map() const + lookup(size_t pindex) { - if (!data) { - data = static_cast(glMapNamedBuffer(buffer, GL_READ_WRITE)); - assert(data); - } - } - - void - unmap() const - { - if (data) { - glUnmapNamedBuffer(buffer); - data = nullptr; - } + return base::data()[index[pindex]]; } - glBuffer buffer; - mutable T * data {}; - // Size of buffer - std::size_t capacity {}; - // # used of capacity - std::size_t next {}; - // Index into buffer given to nth proxy + // Index into buffer given to nth proxy std::vector index; - // List of free spaces in index + // List of free spaces in index std::vector unused; }; -- cgit v1.2.3 From 72ab29786f6d4c97a92cb95c75091537490e2d0f Mon Sep 17 00:00:00 2001 From: Dan Goodliffe Date: Sat, 6 May 2023 16:42:08 +0100 Subject: Templated BufferedLocation and single buffer storage for RVC locations --- gfx/gl/bufferedLocation.cpp | 16 ++-------------- gfx/gl/bufferedLocation.h | 32 +++++++++++++++++++++++++++----- 2 files changed, 29 insertions(+), 19 deletions(-) (limited to 'gfx') diff --git a/gfx/gl/bufferedLocation.cpp b/gfx/gl/bufferedLocation.cpp index 7027b4c..eb3dac3 100644 --- a/gfx/gl/bufferedLocation.cpp +++ b/gfx/gl/bufferedLocation.cpp @@ -3,15 +3,9 @@ #include "maths.h" #include -BufferedLocation::BufferedLocation(InstanceVertices & i, glm::vec3 p, glm::vec3 r) : - BufferedLocation {i, Location {p, r}} -{ -} +BufferedLocation::BufferedLocation(glm::vec3 p, glm::vec3 r) : BufferedLocation {Location {p, r}} { } -BufferedLocation::BufferedLocation(InstanceVertices & i, const Location & l) : - loc {l}, buffer {i.acquire(getTransform())} -{ -} +BufferedLocation::BufferedLocation(const Location & l) : loc {l} { } BufferedLocation::operator const Location &() const { @@ -64,12 +58,6 @@ BufferedLocation::setLocation(glm::vec3 p, glm::vec3 r) updateBuffer(); } -void -BufferedLocation::updateBuffer() -{ - buffer = getTransform(); -} - glm::mat4 BufferedLocation::getTransform() const { diff --git a/gfx/gl/bufferedLocation.h b/gfx/gl/bufferedLocation.h index 6d148cd..8096489 100644 --- a/gfx/gl/bufferedLocation.h +++ b/gfx/gl/bufferedLocation.h @@ -1,14 +1,16 @@ #pragma once -#include "instanceVertices.h" #include "location.h" +#include #include #include +#include class BufferedLocation { public: - BufferedLocation(InstanceVertices &, glm::vec3 = {}, glm::vec3 = {}); - BufferedLocation(InstanceVertices &, const Location &); + BufferedLocation(glm::vec3 = {}, glm::vec3 = {}); + BufferedLocation(const Location &); + virtual ~BufferedLocation() = default; BufferedLocation & operator=(const Location &); @@ -23,8 +25,28 @@ public: glm::mat4 getTransform() const; private: - void updateBuffer(); + virtual void updateBuffer() = 0; Location loc; - InstanceVertices::InstanceProxy buffer; +}; + +template class BufferedLocationT : public BufferedLocation { +public: + template + BufferedLocationT(Target &&... target, LocationArgs &&... t) : + BufferedLocation {std::forward(t)...}, target {std::forward(target)...} + { + updateBuffer(); + } + + using BufferedLocation::operator=; + +private: + void + updateBuffer() override + { + std::apply(std::invoke, target) = getTransform(); + } + + std::tuple target; }; -- cgit v1.2.3