mirror of
https://github.com/JulianGro/overte.git
synced 2025-04-25 17:14:59 +02:00
Merge pull request #7880 from jherico/gpu_smart_buffers
Support partial CPU->GPU buffer transfers
This commit is contained in:
Brad Hefta-Gaub
commit
1f800294c6
8 changed files with 289 additions and 191 deletions
|
|
@ -267,7 +267,7 @@ void RenderableParticleEffectEntityItem::updateRenderItem() {
|
|||
if (numBytes == 0) {
|
||||
return;
|
||||
}
|
||||
memcpy(particleBuffer->editData(), particlePrimitives->data(), numBytes);
|
||||
particleBuffer->setData(numBytes, (const gpu::Byte*)particlePrimitives->data());
|
||||
|
||||
// Update transform and bounds
|
||||
payload.setModelTransform(transform);
|
||||
|
|
|
|||
|
|
@ -65,15 +65,22 @@ public:
|
|||
|
||||
class GLBuffer : public GPUObject {
|
||||
public:
|
||||
Stamp _stamp;
|
||||
GLuint _buffer;
|
||||
GLuint _size;
|
||||
const GLuint _buffer;
|
||||
const GLuint _size;
|
||||
const Stamp _stamp;
|
||||
|
||||
GLBuffer();
|
||||
GLBuffer(const Buffer& buffer, GLBuffer* original = nullptr);
|
||||
~GLBuffer();
|
||||
|
||||
void setSize(GLuint size);
|
||||
void transfer();
|
||||
|
||||
private:
|
||||
bool getNextTransferBlock(GLintptr& outOffset, GLsizeiptr& outSize, size_t& currentPage) const;
|
||||
|
||||
// The owning texture
|
||||
const Buffer& _gpuBuffer;
|
||||
};
|
||||
|
||||
static GLBuffer* syncGPUObject(const Buffer& buffer);
|
||||
static GLuint getBufferID(const Buffer& buffer);
|
||||
|
||||
|
|
|
|||
|
|
@ -12,12 +12,40 @@
|
|||
|
||||
using namespace gpu;
|
||||
|
||||
GLBackend::GLBuffer::GLBuffer() :
|
||||
_stamp(0),
|
||||
_buffer(0),
|
||||
_size(0)
|
||||
{
|
||||
GLuint allocateSingleBuffer() {
|
||||
GLuint result;
|
||||
glGenBuffers(1, &result);
|
||||
(void)CHECK_GL_ERROR();
|
||||
return result;
|
||||
}
|
||||
|
||||
GLBackend::GLBuffer::GLBuffer(const Buffer& buffer, GLBuffer* original) :
|
||||
_buffer(allocateSingleBuffer()),
|
||||
_size((GLuint)buffer._sysmem.getSize()),
|
||||
_stamp(buffer._sysmem.getStamp()),
|
||||
_gpuBuffer(buffer) {
|
||||
glBindBuffer(GL_ARRAY_BUFFER, _buffer);
|
||||
if (GLEW_VERSION_4_4 || GLEW_ARB_buffer_storage) {
|
||||
glBufferStorage(GL_ARRAY_BUFFER, _size, nullptr, GL_DYNAMIC_STORAGE_BIT);
|
||||
(void)CHECK_GL_ERROR();
|
||||
} else {
|
||||
glBufferData(GL_ARRAY_BUFFER, _size, nullptr, GL_DYNAMIC_DRAW);
|
||||
(void)CHECK_GL_ERROR();
|
||||
}
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
|
||||
if (original) {
|
||||
glBindBuffer(GL_COPY_WRITE_BUFFER, _buffer);
|
||||
glBindBuffer(GL_COPY_READ_BUFFER, original->_buffer);
|
||||
glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, original->_size);
|
||||
glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
|
||||
glBindBuffer(GL_COPY_READ_BUFFER, 0);
|
||||
(void)CHECK_GL_ERROR();
|
||||
}
|
||||
|
||||
Backend::setGPUObject(buffer, this);
|
||||
Backend::incrementBufferGPUCount();
|
||||
Backend::updateBufferGPUMemoryUsage(0, _size);
|
||||
}
|
||||
|
||||
GLBackend::GLBuffer::~GLBuffer() {
|
||||
|
|
@ -28,37 +56,56 @@ GLBackend::GLBuffer::~GLBuffer() {
|
|||
Backend::decrementBufferGPUCount();
|
||||
}
|
||||
|
||||
void GLBackend::GLBuffer::setSize(GLuint size) {
|
||||
Backend::updateBufferGPUMemoryUsage(_size, size);
|
||||
_size = size;
|
||||
void GLBackend::GLBuffer::transfer() {
|
||||
glBindBuffer(GL_ARRAY_BUFFER, _buffer);
|
||||
(void)CHECK_GL_ERROR();
|
||||
GLintptr offset;
|
||||
GLsizeiptr size;
|
||||
size_t currentPage { 0 };
|
||||
auto data = _gpuBuffer.getSysmem().readData();
|
||||
while (getNextTransferBlock(offset, size, currentPage)) {
|
||||
glBufferSubData(GL_ARRAY_BUFFER, offset, size, data + offset);
|
||||
(void)CHECK_GL_ERROR();
|
||||
}
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
(void)CHECK_GL_ERROR();
|
||||
_gpuBuffer._flags &= ~Buffer::DIRTY;
|
||||
}
|
||||
|
||||
bool GLBackend::GLBuffer::getNextTransferBlock(GLintptr& outOffset, GLsizeiptr& outSize, size_t& currentPage) const {
|
||||
size_t pageCount = _gpuBuffer._pages.size();
|
||||
// Advance to the first dirty page
|
||||
while (currentPage < pageCount && (0 == (Buffer::DIRTY & _gpuBuffer._pages[currentPage]))) {
|
||||
++currentPage;
|
||||
}
|
||||
|
||||
// If we got to the end, we're done
|
||||
if (currentPage >= pageCount) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Advance to the next clean page
|
||||
outOffset = static_cast<GLintptr>(currentPage * _gpuBuffer._pageSize);
|
||||
while (currentPage < pageCount && (0 != (Buffer::DIRTY & _gpuBuffer._pages[currentPage]))) {
|
||||
_gpuBuffer._pages[currentPage] &= ~Buffer::DIRTY;
|
||||
++currentPage;
|
||||
}
|
||||
outSize = static_cast<GLsizeiptr>((currentPage * _gpuBuffer._pageSize) - outOffset);
|
||||
return true;
|
||||
}
|
||||
|
||||
GLBackend::GLBuffer* GLBackend::syncGPUObject(const Buffer& buffer) {
|
||||
GLBuffer* object = Backend::getGPUObject<GLBackend::GLBuffer>(buffer);
|
||||
|
||||
if (object && (object->_stamp == buffer.getSysmem().getStamp())) {
|
||||
return object;
|
||||
// Has the storage size changed?
|
||||
if (!object || object->_stamp != buffer.getSysmem().getStamp()) {
|
||||
object = new GLBuffer(buffer, object);
|
||||
}
|
||||
|
||||
// need to have a gpu object?
|
||||
if (!object) {
|
||||
object = new GLBuffer();
|
||||
glGenBuffers(1, &object->_buffer);
|
||||
(void) CHECK_GL_ERROR();
|
||||
Backend::setGPUObject(buffer, object);
|
||||
if (0 != (buffer._flags & Buffer::DIRTY)) {
|
||||
object->transfer();
|
||||
}
|
||||
|
||||
// Now let's update the content of the bo with the sysmem version
|
||||
// TODO: in the future, be smarter about when to actually upload the glBO version based on the data that did change
|
||||
//if () {
|
||||
glBindBuffer(GL_ARRAY_BUFFER, object->_buffer);
|
||||
glBufferData(GL_ARRAY_BUFFER, buffer.getSysmem().getSize(), buffer.getSysmem().readData(), GL_DYNAMIC_DRAW);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
object->_stamp = buffer.getSysmem().getStamp();
|
||||
object->setSize((GLuint)buffer.getSysmem().getSize());
|
||||
//}
|
||||
(void) CHECK_GL_ERROR();
|
||||
|
||||
return object;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -109,40 +109,18 @@ void Resource::Sysmem::deallocateMemory(Byte* dataAllocated, Size size) {
|
|||
}
|
||||
}
|
||||
|
||||
Resource::Sysmem::Sysmem() :
|
||||
_stamp(0),
|
||||
_size(0),
|
||||
_data(NULL)
|
||||
{
|
||||
}
|
||||
Resource::Sysmem::Sysmem() {}
|
||||
|
||||
Resource::Sysmem::Sysmem(Size size, const Byte* bytes) :
|
||||
_stamp(0),
|
||||
_size(0),
|
||||
_data(NULL)
|
||||
{
|
||||
if (size > 0) {
|
||||
_size = allocateMemory(&_data, size);
|
||||
if (_size >= size) {
|
||||
if (bytes) {
|
||||
memcpy(_data, bytes, size);
|
||||
}
|
||||
}
|
||||
Resource::Sysmem::Sysmem(Size size, const Byte* bytes) {
|
||||
if (size > 0 && bytes) {
|
||||
setData(_size, bytes);
|
||||
}
|
||||
}
|
||||
|
||||
Resource::Sysmem::Sysmem(const Sysmem& sysmem) :
|
||||
_stamp(0),
|
||||
_size(0),
|
||||
_data(NULL)
|
||||
{
|
||||
Resource::Sysmem::Sysmem(const Sysmem& sysmem) {
|
||||
if (sysmem.getSize() > 0) {
|
||||
_size = allocateMemory(&_data, sysmem.getSize());
|
||||
if (_size >= sysmem.getSize()) {
|
||||
if (sysmem.readData()) {
|
||||
memcpy(_data, sysmem.readData(), sysmem.getSize());
|
||||
}
|
||||
}
|
||||
allocate(sysmem._size);
|
||||
setData(_size, sysmem._data);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -208,7 +186,6 @@ Resource::Size Resource::Sysmem::setData( Size size, const Byte* bytes ) {
|
|||
if (allocate(size) == size) {
|
||||
if (size && bytes) {
|
||||
memcpy( _data, bytes, _size );
|
||||
_stamp++;
|
||||
}
|
||||
}
|
||||
return _size;
|
||||
|
|
@ -217,7 +194,6 @@ Resource::Size Resource::Sysmem::setData( Size size, const Byte* bytes ) {
|
|||
Resource::Size Resource::Sysmem::setSubData( Size offset, Size size, const Byte* bytes) {
|
||||
if (size && ((offset + size) <= getSize()) && bytes) {
|
||||
memcpy( _data + offset, bytes, size );
|
||||
_stamp++;
|
||||
return size;
|
||||
}
|
||||
return 0;
|
||||
|
|
@ -264,65 +240,105 @@ Buffer::Size Buffer::getBufferGPUMemoryUsage() {
|
|||
return Context::getBufferGPUMemoryUsage();
|
||||
}
|
||||
|
||||
Buffer::Buffer() :
|
||||
Resource(),
|
||||
_sysmem(new Sysmem()) {
|
||||
Buffer::Buffer(Size pageSize) :
|
||||
_pageSize(pageSize) {
|
||||
_bufferCPUCount++;
|
||||
|
||||
}
|
||||
|
||||
Buffer::Buffer(Size size, const Byte* bytes) :
|
||||
Resource(),
|
||||
_sysmem(new Sysmem(size, bytes)) {
|
||||
_bufferCPUCount++;
|
||||
Buffer::updateBufferCPUMemoryUsage(0, _sysmem->getSize());
|
||||
Buffer::Buffer(Size size, const Byte* bytes, Size pageSize) : Buffer(pageSize) {
|
||||
setData(size, bytes);
|
||||
}
|
||||
|
||||
Buffer::Buffer(const Buffer& buf) :
|
||||
Resource(),
|
||||
_sysmem(new Sysmem(buf.getSysmem())) {
|
||||
_bufferCPUCount++;
|
||||
Buffer::updateBufferCPUMemoryUsage(0, _sysmem->getSize());
|
||||
Buffer::Buffer(const Buffer& buf) : Buffer(buf._pageSize) {
|
||||
setData(buf.getSize(), buf.getData());
|
||||
}
|
||||
|
||||
Buffer& Buffer::operator=(const Buffer& buf) {
|
||||
(*_sysmem) = buf.getSysmem();
|
||||
const_cast<Size&>(_pageSize) = buf._pageSize;
|
||||
setData(buf.getSize(), buf.getData());
|
||||
return (*this);
|
||||
}
|
||||
|
||||
Buffer::~Buffer() {
|
||||
_bufferCPUCount--;
|
||||
|
||||
if (_sysmem) {
|
||||
Buffer::updateBufferCPUMemoryUsage(_sysmem->getSize(), 0);
|
||||
delete _sysmem;
|
||||
_sysmem = NULL;
|
||||
}
|
||||
Buffer::updateBufferCPUMemoryUsage(_sysmem.getSize(), 0);
|
||||
}
|
||||
|
||||
Buffer::Size Buffer::resize(Size size) {
|
||||
_end = size;
|
||||
auto prevSize = editSysmem().getSize();
|
||||
auto newSize = editSysmem().resize(size);
|
||||
Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
|
||||
return newSize;
|
||||
if (prevSize < size) {
|
||||
auto newPages = getRequiredPageCount();
|
||||
auto newSize = newPages * _pageSize;
|
||||
editSysmem().resize(newSize);
|
||||
// All new pages start off as clean, because they haven't been populated by data
|
||||
_pages.resize(newPages, 0);
|
||||
Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
|
||||
}
|
||||
return _end;
|
||||
}
|
||||
|
||||
void Buffer::markDirty(Size offset, Size bytes) {
|
||||
if (!bytes) {
|
||||
return;
|
||||
}
|
||||
_flags |= DIRTY;
|
||||
// Find the starting page
|
||||
Size startPage = (offset / _pageSize);
|
||||
// Non-zero byte count, so at least one page is dirty
|
||||
Size pageCount = 1;
|
||||
// How much of the page is after the offset?
|
||||
Size remainder = _pageSize - (offset % _pageSize);
|
||||
// If there are more bytes than page space remaining, we need to increase the page count
|
||||
if (bytes > remainder) {
|
||||
// Get rid of the amount that will fit in the current page
|
||||
bytes -= remainder;
|
||||
|
||||
pageCount += (bytes / _pageSize);
|
||||
if (bytes % _pageSize) {
|
||||
++pageCount;
|
||||
}
|
||||
}
|
||||
|
||||
// Mark the pages dirty
|
||||
for (Size i = 0; i < pageCount; ++i) {
|
||||
_pages[i + startPage] |= DIRTY;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Buffer::Size Buffer::setData(Size size, const Byte* data) {
|
||||
auto prevSize = editSysmem().getSize();
|
||||
auto newSize = editSysmem().setData(size, data);
|
||||
Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
|
||||
return newSize;
|
||||
resize(size);
|
||||
setSubData(0, size, data);
|
||||
return _end;
|
||||
}
|
||||
|
||||
Buffer::Size Buffer::setSubData(Size offset, Size size, const Byte* data) {
|
||||
return editSysmem().setSubData( offset, size, data);
|
||||
auto changedBytes = editSysmem().setSubData(offset, size, data);
|
||||
if (changedBytes) {
|
||||
markDirty(offset, changedBytes);
|
||||
}
|
||||
return changedBytes;
|
||||
}
|
||||
|
||||
Buffer::Size Buffer::append(Size size, const Byte* data) {
|
||||
auto prevSize = editSysmem().getSize();
|
||||
auto newSize = editSysmem().append( size, data);
|
||||
Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
|
||||
return newSize;
|
||||
auto offset = _end;
|
||||
resize(_end + size);
|
||||
setSubData(offset, size, data);
|
||||
return _end;
|
||||
}
|
||||
|
||||
Buffer::Size Buffer::getSize() const {
|
||||
Q_ASSERT(getSysmem().getSize() >= _end);
|
||||
return _end;
|
||||
}
|
||||
|
||||
Buffer::Size Buffer::getRequiredPageCount() const {
|
||||
Size result = _end / _pageSize;
|
||||
if (_end % _pageSize) {
|
||||
++result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
const Element BufferView::DEFAULT_ELEMENT = Element( gpu::SCALAR, gpu::UINT8, gpu::RAW );
|
||||
|
|
|
|||
|
|
@ -88,10 +88,10 @@ protected:
|
|||
// Access the byte array.
|
||||
// The edit version allow to map data.
|
||||
const Byte* readData() const { return _data; }
|
||||
Byte* editData() { _stamp++; return _data; }
|
||||
Byte* editData() { return _data; }
|
||||
|
||||
template< typename T > const T* read() const { return reinterpret_cast< T* > ( _data ); }
|
||||
template< typename T > T* edit() { _stamp++; return reinterpret_cast< T* > ( _data ); }
|
||||
template< typename T > T* edit() { return reinterpret_cast< T* > ( _data ); }
|
||||
|
||||
// Access the current version of the sysmem, used to compare if copies are in sync
|
||||
Stamp getStamp() const { return _stamp; }
|
||||
|
|
@ -102,9 +102,9 @@ protected:
|
|||
bool isAvailable() const { return (_data != 0); }
|
||||
|
||||
private:
|
||||
Stamp _stamp;
|
||||
Size _size;
|
||||
Byte* _data;
|
||||
Stamp _stamp { 0 };
|
||||
Size _size { 0 };
|
||||
Byte* _data { nullptr };
|
||||
};
|
||||
|
||||
};
|
||||
|
|
@ -115,22 +115,28 @@ class Buffer : public Resource {
|
|||
static void updateBufferCPUMemoryUsage(Size prevObjectSize, Size newObjectSize);
|
||||
|
||||
public:
|
||||
enum Flag {
|
||||
DIRTY = 0x01,
|
||||
};
|
||||
|
||||
// Currently only one flag... 'dirty'
|
||||
using PageFlags = std::vector<uint8_t>;
|
||||
static const Size DEFAULT_PAGE_SIZE = 4096;
|
||||
static uint32_t getBufferCPUCount();
|
||||
static Size getBufferCPUMemoryUsage();
|
||||
static uint32_t getBufferGPUCount();
|
||||
static Size getBufferGPUMemoryUsage();
|
||||
|
||||
Buffer();
|
||||
Buffer(Size size, const Byte* bytes);
|
||||
Buffer(Size pageSize = DEFAULT_PAGE_SIZE);
|
||||
Buffer(Size size, const Byte* bytes, Size pageSize = DEFAULT_PAGE_SIZE);
|
||||
Buffer(const Buffer& buf); // deep copy of the sysmem buffer
|
||||
Buffer& operator=(const Buffer& buf); // deep copy of the sysmem buffer
|
||||
~Buffer();
|
||||
|
||||
// The size in bytes of data stored in the buffer
|
||||
Size getSize() const { return getSysmem().getSize(); }
|
||||
Size getSize() const;
|
||||
const Byte* getData() const { return getSysmem().readData(); }
|
||||
Byte* editData() { return editSysmem().editData(); }
|
||||
|
||||
|
||||
// Resize the buffer
|
||||
// Keep previous data [0 to min(pSize, mSize)]
|
||||
Size resize(Size pSize);
|
||||
|
|
@ -143,6 +149,23 @@ public:
|
|||
// \return the number of bytes copied
|
||||
Size setSubData(Size offset, Size size, const Byte* data);
|
||||
|
||||
template <typename T>
|
||||
Size setSubData(Size index, const T& t) {
|
||||
Size offset = index * sizeof(T);
|
||||
Size size = sizeof(T);
|
||||
return setSubData(offset, size, reinterpret_cast<const Byte*>(&t));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
Size setSubData(Size index, const std::vector<T>& t) {
|
||||
if (t.empty()) {
|
||||
return 0;
|
||||
}
|
||||
Size offset = index * sizeof(T);
|
||||
Size size = t.size() * sizeof(T);
|
||||
return setSubData(offset, size, reinterpret_cast<const Byte*>(&t[0]));
|
||||
}
|
||||
|
||||
// Append new data at the end of the current buffer
|
||||
// do a resize( size + getSize) and copy the new data
|
||||
// \return the number of bytes copied
|
||||
|
|
@ -155,18 +178,38 @@ public:
|
|||
|
||||
template <typename T>
|
||||
Size append(const std::vector<T>& t) {
|
||||
if (t.empty()) {
|
||||
return _end;
|
||||
}
|
||||
return append(sizeof(T) * t.size(), reinterpret_cast<const Byte*>(&t[0]));
|
||||
}
|
||||
|
||||
// Access the sysmem object.
|
||||
const Sysmem& getSysmem() const { assert(_sysmem); return (*_sysmem); }
|
||||
Sysmem& editSysmem() { assert(_sysmem); return (*_sysmem); }
|
||||
|
||||
const GPUObjectPointer gpuObject {};
|
||||
|
||||
protected:
|
||||
void markDirty(Size offset, Size bytes);
|
||||
|
||||
Sysmem* _sysmem = NULL;
|
||||
template <typename T>
|
||||
void markDirty(Size index, Size count = 1) {
|
||||
markDirty(sizeof(T) * index, sizeof(T) * count);
|
||||
}
|
||||
|
||||
// Access the sysmem object, limited to ourselves and GPUObject derived classes
|
||||
const Sysmem& getSysmem() const { return _sysmem; }
|
||||
Sysmem& editSysmem() { return _sysmem; }
|
||||
Byte* editData() { return editSysmem().editData(); }
|
||||
|
||||
Size getRequiredPageCount() const;
|
||||
|
||||
Size _end { 0 };
|
||||
mutable uint8_t _flags;
|
||||
mutable PageFlags _pages;
|
||||
const Size _pageSize;
|
||||
Sysmem _sysmem;
|
||||
|
||||
// FIXME find a more generic way to do this.
|
||||
friend class GLBackend;
|
||||
friend class BufferView;
|
||||
};
|
||||
|
||||
typedef std::shared_ptr<Buffer> BufferPointer;
|
||||
|
|
@ -290,8 +333,14 @@ public:
|
|||
int _stride;
|
||||
};
|
||||
|
||||
#if 0
|
||||
// Direct memory access to the buffer contents is incompatible with the paging memory scheme
|
||||
template <typename T> Iterator<T> begin() { return Iterator<T>(&edit<T>(0), _stride); }
|
||||
template <typename T> Iterator<T> end() { return Iterator<T>(&edit<T>(getNum<T>()), _stride); }
|
||||
#else
|
||||
template <typename T> Iterator<const T> begin() const { return Iterator<const T>(&get<T>(), _stride); }
|
||||
template <typename T> Iterator<const T> end() const { return Iterator<const T>(&get<T>(getNum<T>()), _stride); }
|
||||
#endif
|
||||
template <typename T> Iterator<const T> cbegin() const { return Iterator<const T>(&get<T>(), _stride); }
|
||||
template <typename T> Iterator<const T> cend() const { return Iterator<const T>(&get<T>(getNum<T>()), _stride); }
|
||||
|
||||
|
|
@ -328,6 +377,7 @@ public:
|
|||
qDebug() << "Accessing buffer outside the BufferView range, element size = " << sizeof(T) << " when bufferView size = " << _size;
|
||||
}
|
||||
#endif
|
||||
_buffer->markDirty(_offset, sizeof(T));
|
||||
T* t = (reinterpret_cast<T*> (_buffer->editData() + _offset));
|
||||
return *(t);
|
||||
}
|
||||
|
|
@ -361,6 +411,7 @@ public:
|
|||
qDebug() << "Accessing buffer outside the BufferView range, index = " << index << " number elements = " << getNum<T>();
|
||||
}
|
||||
#endif
|
||||
_buffer->markDirty(elementOffset, sizeof(T));
|
||||
return *(reinterpret_cast<T*> (_buffer->editData() + elementOffset));
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -118,29 +118,18 @@ AnimDebugDraw::AnimDebugDraw() :
|
|||
|
||||
// HACK: add red, green and blue axis at (1,1,1)
|
||||
_animDebugDrawData->_vertexBuffer->resize(sizeof(Vertex) * 6);
|
||||
Vertex* data = (Vertex*)_animDebugDrawData->_vertexBuffer->editData();
|
||||
|
||||
data[0].pos = glm::vec3(1.0, 1.0f, 1.0f);
|
||||
data[0].rgba = toRGBA(255, 0, 0, 255);
|
||||
data[1].pos = glm::vec3(2.0, 1.0f, 1.0f);
|
||||
data[1].rgba = toRGBA(255, 0, 0, 255);
|
||||
|
||||
data[2].pos = glm::vec3(1.0, 1.0f, 1.0f);
|
||||
data[2].rgba = toRGBA(0, 255, 0, 255);
|
||||
data[3].pos = glm::vec3(1.0, 2.0f, 1.0f);
|
||||
data[3].rgba = toRGBA(0, 255, 0, 255);
|
||||
|
||||
data[4].pos = glm::vec3(1.0, 1.0f, 1.0f);
|
||||
data[4].rgba = toRGBA(0, 0, 255, 255);
|
||||
data[5].pos = glm::vec3(1.0, 1.0f, 2.0f);
|
||||
data[5].rgba = toRGBA(0, 0, 255, 255);
|
||||
|
||||
_animDebugDrawData->_indexBuffer->resize(sizeof(uint16_t) * 6);
|
||||
uint16_t* indices = (uint16_t*)_animDebugDrawData->_indexBuffer->editData();
|
||||
for (int i = 0; i < 6; i++) {
|
||||
indices[i] = i;
|
||||
}
|
||||
|
||||
|
||||
static std::vector<Vertex> vertices({
|
||||
Vertex { glm::vec3(1.0, 1.0f, 1.0f), toRGBA(255, 0, 0, 255) },
|
||||
Vertex { glm::vec3(2.0, 1.0f, 1.0f), toRGBA(255, 0, 0, 255) },
|
||||
Vertex { glm::vec3(1.0, 1.0f, 1.0f), toRGBA(0, 255, 0, 255) },
|
||||
Vertex { glm::vec3(1.0, 2.0f, 1.0f), toRGBA(0, 255, 0, 255) },
|
||||
Vertex { glm::vec3(1.0, 1.0f, 1.0f), toRGBA(0, 0, 255, 255) },
|
||||
Vertex { glm::vec3(1.0, 1.0f, 2.0f), toRGBA(0, 0, 255, 255) },
|
||||
});
|
||||
static std::vector<uint16_t> indices({ 0, 1, 2, 3, 4, 5 });
|
||||
_animDebugDrawData->_vertexBuffer->setSubData<Vertex>(0, vertices);
|
||||
_animDebugDrawData->_indexBuffer->setSubData<uint16_t>(0, indices);
|
||||
}
|
||||
|
||||
AnimDebugDraw::~AnimDebugDraw() {
|
||||
|
|
@ -356,9 +345,13 @@ void AnimDebugDraw::update() {
|
|||
numVerts += (int)DebugDraw::getInstance().getRays().size() * VERTICES_PER_RAY;
|
||||
|
||||
// allocate verts!
|
||||
data._vertexBuffer->resize(sizeof(Vertex) * numVerts);
|
||||
Vertex* verts = (Vertex*)data._vertexBuffer->editData();
|
||||
Vertex* v = verts;
|
||||
std::vector<Vertex> vertices;
|
||||
vertices.resize(numVerts);
|
||||
//Vertex* verts = (Vertex*)data._vertexBuffer->editData();
|
||||
Vertex* v = nullptr;
|
||||
if (numVerts) {
|
||||
v = &vertices[0];
|
||||
}
|
||||
|
||||
// draw absolute poses
|
||||
for (auto& iter : _absolutePoses) {
|
||||
|
|
@ -381,6 +374,8 @@ void AnimDebugDraw::update() {
|
|||
}
|
||||
}
|
||||
}
|
||||
data._vertexBuffer->resize(sizeof(Vertex) * numVerts);
|
||||
data._vertexBuffer->setSubData<Vertex>(0, vertices);
|
||||
|
||||
// draw markers from shared DebugDraw singleton
|
||||
for (auto& iter : markerMap) {
|
||||
|
|
@ -408,20 +403,19 @@ void AnimDebugDraw::update() {
|
|||
}
|
||||
DebugDraw::getInstance().clearRays();
|
||||
|
||||
assert(numVerts == (v - verts));
|
||||
assert((!numVerts && !v) || (numVerts == (v - &vertices[0])));
|
||||
|
||||
render::Item::Bound theBound;
|
||||
for (int i = 0; i < numVerts; i++) {
|
||||
theBound += verts[i].pos;
|
||||
theBound += vertices[i].pos;
|
||||
}
|
||||
data._bound = theBound;
|
||||
|
||||
data._isVisible = (numVerts > 0);
|
||||
|
||||
data._indexBuffer->resize(sizeof(uint16_t) * numVerts);
|
||||
uint16_t* indices = (uint16_t*)data._indexBuffer->editData();
|
||||
for (int i = 0; i < numVerts; i++) {
|
||||
indices[i] = i;
|
||||
data._indexBuffer->setSubData<uint16_t>(i, (uint16_t)i);;
|
||||
}
|
||||
});
|
||||
scene->enqueuePendingChanges(pendingChanges);
|
||||
|
|
|
|||
|
|
@ -116,35 +116,25 @@ void DrawStatus::run(const SceneContextPointer& sceneContext,
|
|||
// FIrst thing, we collect the bound and the status for all the items we want to render
|
||||
int nbItems = 0;
|
||||
{
|
||||
if (!_itemBounds) {
|
||||
_itemBounds = std::make_shared<gpu::Buffer>();
|
||||
}
|
||||
if (!_itemStatus) {
|
||||
_itemStatus = std::make_shared<gpu::Buffer>();;
|
||||
}
|
||||
if (!_itemCells) {
|
||||
_itemCells = std::make_shared<gpu::Buffer>();;
|
||||
}
|
||||
_itemBounds.resize(inItems.size());
|
||||
_itemStatus.resize(inItems.size());
|
||||
_itemCells.resize(inItems.size());
|
||||
|
||||
_itemBounds->resize((inItems.size() * sizeof(AABox)));
|
||||
_itemStatus->resize((inItems.size() * NUM_STATUS_VEC4_PER_ITEM * sizeof(glm::vec4)));
|
||||
_itemCells->resize((inItems.size() * sizeof(Octree::Location)));
|
||||
|
||||
AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData());
|
||||
glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData());
|
||||
Octree::Location* itemCell = reinterpret_cast<Octree::Location*> (_itemCells->editData());
|
||||
for (auto& item : inItems) {
|
||||
// AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData());
|
||||
// glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData());
|
||||
// Octree::Location* itemCell = reinterpret_cast<Octree::Location*> (_itemCells->editData());
|
||||
for (size_t i = 0; i < inItems.size(); ++i) {
|
||||
const auto& item = inItems[i];
|
||||
if (!item.bound.isInvalid()) {
|
||||
if (!item.bound.isNull()) {
|
||||
(*itemAABox) = item.bound;
|
||||
_itemBounds[i] = item.bound;
|
||||
} else {
|
||||
(*itemAABox).setBox(item.bound.getCorner(), 0.1f);
|
||||
_itemBounds[i].setBox(item.bound.getCorner(), 0.1f);
|
||||
}
|
||||
|
||||
|
||||
auto& itemScene = scene->getItem(item.id);
|
||||
|
||||
(*itemCell) = scene->getSpatialTree().getCellLocation(itemScene.getCell());
|
||||
_itemCells[i] = scene->getSpatialTree().getCellLocation(itemScene.getCell());
|
||||
|
||||
auto itemStatusPointer = itemScene.getStatus();
|
||||
if (itemStatusPointer) {
|
||||
|
|
@ -152,25 +142,19 @@ void DrawStatus::run(const SceneContextPointer& sceneContext,
|
|||
auto&& currentStatusValues = itemStatusPointer->getCurrentValues();
|
||||
int valueNum = 0;
|
||||
for (int vec4Num = 0; vec4Num < NUM_STATUS_VEC4_PER_ITEM; vec4Num++) {
|
||||
(*itemStatus) = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
|
||||
auto& value = (vec4Num ? _itemStatus[i].first : _itemStatus[i].second);
|
||||
value = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
|
||||
for (int component = 0; component < VEC4_LENGTH; component++) {
|
||||
valueNum = vec4Num * VEC4_LENGTH + component;
|
||||
if (valueNum < (int)currentStatusValues.size()) {
|
||||
(*itemStatus)[component] = currentStatusValues[valueNum].getPackedData();
|
||||
value[component] = currentStatusValues[valueNum].getPackedData();
|
||||
}
|
||||
}
|
||||
itemStatus++;
|
||||
}
|
||||
} else {
|
||||
(*itemStatus) = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
|
||||
itemStatus++;
|
||||
(*itemStatus) = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
|
||||
itemStatus++;
|
||||
_itemStatus[i].first = _itemStatus[i].second = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
|
||||
}
|
||||
|
||||
nbItems++;
|
||||
itemAABox++;
|
||||
itemCell++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -194,25 +178,20 @@ void DrawStatus::run(const SceneContextPointer& sceneContext,
|
|||
// bind the one gpu::Pipeline we need
|
||||
batch.setPipeline(getDrawItemBoundsPipeline());
|
||||
|
||||
AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData());
|
||||
glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData());
|
||||
Octree::Location* itemCell = reinterpret_cast<Octree::Location*> (_itemCells->editData());
|
||||
//AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData());
|
||||
//glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData());
|
||||
//Octree::Location* itemCell = reinterpret_cast<Octree::Location*> (_itemCells->editData());
|
||||
|
||||
const unsigned int VEC3_ADRESS_OFFSET = 3;
|
||||
|
||||
if (_showDisplay) {
|
||||
for (int i = 0; i < nbItems; i++) {
|
||||
batch._glUniform3fv(_drawItemBoundPosLoc, 1, (const float*) (itemAABox + i));
|
||||
batch._glUniform3fv(_drawItemBoundDimLoc, 1, ((const float*) (itemAABox + i)) + VEC3_ADRESS_OFFSET);
|
||||
|
||||
|
||||
glm::ivec4 cellLocation(itemCell->pos.x, itemCell->pos.y, itemCell->pos.z, itemCell->depth);
|
||||
batch._glUniform3fv(_drawItemBoundPosLoc, 1, (const float*)&(_itemBounds[i]));
|
||||
batch._glUniform3fv(_drawItemBoundDimLoc, 1, ((const float*)&(_itemBounds[i])) + VEC3_ADRESS_OFFSET);
|
||||
|
||||
glm::ivec4 cellLocation(_itemCells[i].pos, _itemCells[i].depth);
|
||||
batch._glUniform4iv(_drawItemCellLocLoc, 1, ((const int*)(&cellLocation)));
|
||||
|
||||
|
||||
batch.draw(gpu::LINES, 24, 0);
|
||||
itemCell++;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -222,10 +201,10 @@ void DrawStatus::run(const SceneContextPointer& sceneContext,
|
|||
|
||||
if (_showNetwork) {
|
||||
for (int i = 0; i < nbItems; i++) {
|
||||
batch._glUniform3fv(_drawItemStatusPosLoc, 1, (const float*) (itemAABox + i));
|
||||
batch._glUniform3fv(_drawItemStatusDimLoc, 1, ((const float*) (itemAABox + i)) + VEC3_ADRESS_OFFSET);
|
||||
batch._glUniform4iv(_drawItemStatusValue0Loc, 1, (const int*)(itemStatus + NUM_STATUS_VEC4_PER_ITEM * i));
|
||||
batch._glUniform4iv(_drawItemStatusValue1Loc, 1, (const int*)(itemStatus + NUM_STATUS_VEC4_PER_ITEM * i + 1));
|
||||
batch._glUniform3fv(_drawItemStatusPosLoc, 1, (const float*)&(_itemBounds[i]));
|
||||
batch._glUniform3fv(_drawItemStatusDimLoc, 1, ((const float*)&(_itemBounds[i])) + VEC3_ADRESS_OFFSET);
|
||||
batch._glUniform4iv(_drawItemStatusValue0Loc, 1, (const int*)&(_itemStatus[i].first));
|
||||
batch._glUniform4iv(_drawItemStatusValue1Loc, 1, (const int*)&(_itemStatus[i].second));
|
||||
batch.draw(gpu::TRIANGLES, 24 * NUM_STATUS_VEC4_PER_ITEM, 0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -68,9 +68,13 @@ namespace render {
|
|||
gpu::Stream::FormatPointer _drawItemFormat;
|
||||
gpu::PipelinePointer _drawItemBoundsPipeline;
|
||||
gpu::PipelinePointer _drawItemStatusPipeline;
|
||||
gpu::BufferPointer _itemBounds;
|
||||
gpu::BufferPointer _itemCells;
|
||||
gpu::BufferPointer _itemStatus;
|
||||
|
||||
std::vector<AABox> _itemBounds;
|
||||
std::vector<std::pair<glm::ivec4, glm::ivec4>> _itemStatus;
|
||||
std::vector<Octree::Location> _itemCells;
|
||||
//gpu::BufferPointer _itemBounds;
|
||||
//gpu::BufferPointer _itemCells;
|
||||
//gpu::BufferPointer _itemStatus;
|
||||
gpu::TexturePointer _statusIconMap;
|
||||
};
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue