Mirrors/overte-JulianGro
3
0
Fork 0
mirror of https://github.com/JulianGro/overte.git synced 2025-04-13 22:27:13 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Buffer usage flags

Browse source
This commit is contained in:
Brad Davis 2018-10-28 19:41:40 -07:00 committed by Karol Suprynowicz
parent c13d3d68f5
commit 683b091bbd
48 changed files with 290 additions and 347 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
interface/src/raypick/ParabolaPointer.h
View file

@ -78,7 +78,7 @@ public:
};
ParabolaData _parabolaData;
gpu::BufferPointer _uniformBuffer { std::make_shared<gpu::Buffer>() };
gpu::BufferPointer _uniformBuffer { std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer) };
};
RenderState() {}

2
interface/src/workload/GameWorkloadRenderer.cpp
View file

@ -200,7 +200,7 @@ const gpu::BufferPointer GameWorkloadRenderItem::getDrawViewBuffer() {
verts[numSegments] = verts[0];
verts[numSegments].p.w = 0.0f;
_drawViewBuffer = std::make_shared<gpu::Buffer>(verts.size() * sizeof(Vert), (const gpu::Byte*) verts.data());
_drawViewBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, verts.size() * sizeof(Vert), (const gpu::Byte*) verts.data());
_numDrawViewVerts = numSegments + 1;
}
return _drawViewBuffer;

6
libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp
View file

@ -361,8 +361,8 @@ glm::mat4 HmdDisplayPlugin::getViewCorrection() {
}
void HmdDisplayPlugin::HUDRenderer::build() {
vertices = std::make_shared<gpu::Buffer>();
indices = std::make_shared<gpu::Buffer>();
vertices = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
indices = std::make_shared<gpu::Buffer>(gpu::Buffer::IndexBuffer);
//UV mapping source: http://www.mvps.org/directx/articles/spheremap.htm
@ -416,7 +416,7 @@ void HmdDisplayPlugin::HUDRenderer::build() {
format = std::make_shared<gpu::Stream::Format>(); // 1 for everyone
format->setAttribute(gpu::Stream::POSITION, gpu::Stream::POSITION, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
format->setAttribute(gpu::Stream::TEXCOORD, gpu::Stream::TEXCOORD, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::UV));
uniformsBuffer = std::make_shared<gpu::Buffer>(sizeof(Uniforms), nullptr);
uniformsBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Uniforms), nullptr);
auto program = gpu::Shader::createProgram(shader::render_utils::program::hmd_ui);
gpu::StatePointer state = std::make_shared<gpu::State>();

18
libraries/entities-renderer/src/ModelScriptingInterface.cpp
View file

@ -116,27 +116,27 @@ ScriptValue ModelScriptingInterface::appendMeshes(MeshProxyList in) {
graphics::MeshPointer result(std::make_shared<graphics::Mesh>());
gpu::Element vertexElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
gpu::Buffer* combinedVertexBuffer = new gpu::Buffer(combinedVertexSize, combinedVertexData.get());
gpu::Buffer* combinedVertexBuffer = new gpu::Buffer(gpu::Buffer::VertexBuffer, combinedVertexSize, combinedVertexData.get());
gpu::BufferPointer combinedVertexBufferPointer(combinedVertexBuffer);
gpu::BufferView combinedVertexBufferView(combinedVertexBufferPointer, vertexElement);
result->setVertexBuffer(combinedVertexBufferView);
int attributeTypeColor = gpu::Stream::InputSlot::COLOR; // libraries/gpu/src/gpu/Stream.h
gpu::Element colorElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
gpu::Buffer* combinedColorsBuffer = new gpu::Buffer(combinedColorSize, combinedColorData.get());
gpu::Buffer* combinedColorsBuffer = new gpu::Buffer(gpu::Buffer::VertexBuffer, combinedColorSize, combinedColorData.get());
gpu::BufferPointer combinedColorsBufferPointer(combinedColorsBuffer);
gpu::BufferView combinedColorsBufferView(combinedColorsBufferPointer, colorElement);
result->addAttribute(attributeTypeColor, combinedColorsBufferView);
int attributeTypeNormal = gpu::Stream::InputSlot::NORMAL; // libraries/gpu/src/gpu/Stream.h
gpu::Element normalElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
gpu::Buffer* combinedNormalsBuffer = new gpu::Buffer(combinedNormalSize, combinedNormalData.get());
gpu::Buffer* combinedNormalsBuffer = new gpu::Buffer(gpu::Buffer::VertexBuffer, combinedNormalSize, combinedNormalData.get());
gpu::BufferPointer combinedNormalsBufferPointer(combinedNormalsBuffer);
gpu::BufferView combinedNormalsBufferView(combinedNormalsBufferPointer, normalElement);
result->addAttribute(attributeTypeNormal, combinedNormalsBufferView);
gpu::Element indexElement = gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::RAW);
gpu::Buffer* combinedIndexesBuffer = new gpu::Buffer(combinedIndexSize, combinedIndexData.get());
gpu::Buffer* combinedIndexesBuffer = new gpu::Buffer(gpu::Buffer::IndexBuffer, combinedIndexSize, combinedIndexData.get());
gpu::BufferPointer combinedIndexesBufferPointer(combinedIndexesBuffer);
gpu::BufferView combinedIndexesBufferView(combinedIndexesBufferPointer, indexElement);
result->setIndexBuffer(combinedIndexesBufferView);
@ -146,7 +146,7 @@ ScriptValue ModelScriptingInterface::appendMeshes(MeshProxyList in) {
(graphics::Index)result->getNumIndices(), // numIndices
(graphics::Index)0, // baseVertex
graphics::Mesh::TRIANGLES)); // topology
result->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(graphics::Mesh::Part),
result->setPartBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::IndirectBuffer, parts.size() * sizeof(graphics::Mesh::Part),
(gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
@ -213,7 +213,7 @@ ScriptValue ModelScriptingInterface::newMesh(const QVector<glm::vec3>& vertices,
graphics::MeshPointer mesh(std::make_shared<graphics::Mesh>());
// vertices
auto vertexBuffer = std::make_shared<gpu::Buffer>(vertices.size() * sizeof(glm::vec3), (gpu::Byte*)vertices.data());
auto vertexBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer, vertices.size() * sizeof(glm::vec3), (gpu::Byte*)vertices.data());
auto vertexBufferPtr = gpu::BufferPointer(vertexBuffer);
gpu::BufferView vertexBufferView(vertexBufferPtr, 0, vertexBufferPtr->getSize(),
sizeof(glm::vec3), gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
@ -221,7 +221,7 @@ ScriptValue ModelScriptingInterface::newMesh(const QVector<glm::vec3>& vertices,
if (vertices.size() == normals.size()) {
// normals
auto normalBuffer = std::make_shared<gpu::Buffer>(normals.size() * sizeof(glm::vec3), (gpu::Byte*)normals.data());
auto normalBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer, normals.size() * sizeof(glm::vec3), (gpu::Byte*)normals.data());
auto normalBufferPtr = gpu::BufferPointer(normalBuffer);
gpu::BufferView normalBufferView(normalBufferPtr, 0, normalBufferPtr->getSize(),
sizeof(glm::vec3), gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
@ -241,7 +241,7 @@ ScriptValue ModelScriptingInterface::newMesh(const QVector<glm::vec3>& vertices,
indexDataCursor += sizeof(uint32_t);
}
}
auto indexBuffer = std::make_shared<gpu::Buffer>(indexBufferSize, (gpu::Byte*)indexData);
auto indexBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::IndexBuffer, indexBufferSize, (gpu::Byte*)indexData);
auto indexBufferPtr = gpu::BufferPointer(indexBuffer);
gpu::BufferView indexBufferView(indexBufferPtr, gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::RAW));
mesh->setIndexBuffer(indexBufferView);
@ -252,7 +252,7 @@ ScriptValue ModelScriptingInterface::newMesh(const QVector<glm::vec3>& vertices,
(graphics::Index)faces.size() * 3, // numIndices
(graphics::Index)0, // baseVertex
graphics::Mesh::TRIANGLES)); // topology
mesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(graphics::Mesh::Part),
mesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::IndirectBuffer, parts.size() * sizeof(graphics::Mesh::Part),
(gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));

2
libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
View file

@ -75,7 +75,7 @@ using GpuParticles = std::vector<GpuParticle>;
ParticleEffectEntityRenderer::ParticleEffectEntityRenderer(const EntityItemPointer& entity) : Parent(entity) {
ParticleUniforms uniforms;
_uniformBuffer = std::make_shared<Buffer>(sizeof(ParticleUniforms), (const gpu::Byte*) &uniforms);
_uniformBuffer = std::make_shared<Buffer>(gpu::Buffer::UniformBuffer, sizeof(ParticleUniforms), (const gpu::Byte*) &uniforms);
static std::once_flag once;
std::call_once(once, [] {

2
libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h
View file

@ -102,7 +102,7 @@ private:
CpuParticles _cpuParticles;
bool _emitting { false };
uint64_t _timeUntilNextEmit { 0 };
BufferPointer _particleBuffer { std::make_shared<Buffer>() };
BufferPointer _particleBuffer { std::make_shared<Buffer>(gpu::Buffer::VertexBuffer) };
BufferView _uniformBuffer;
quint64 _lastSimulated { 0 };

10
libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp
View file

@ -1336,14 +1336,14 @@ void RenderablePolyVoxEntityItem::recomputeMesh() {
// convert PolyVox mesh to a Sam mesh
const std::vector<uint32_t>& vecIndices = polyVoxMesh.getIndices();
auto indexBuffer = std::make_shared<gpu::Buffer>(vecIndices.size() * sizeof(uint32_t),
auto indexBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::IndexBuffer, vecIndices.size() * sizeof(uint32_t),
(gpu::Byte*)vecIndices.data());
auto indexBufferPtr = gpu::BufferPointer(indexBuffer);
gpu::BufferView indexBufferView(indexBufferPtr, gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::INDEX));
mesh->setIndexBuffer(indexBufferView);
const std::vector<PolyVox::PositionMaterialNormal>& vecVertices = polyVoxMesh.getRawVertexData();
auto vertexBuffer = std::make_shared<gpu::Buffer>(vecVertices.size() * sizeof(PolyVox::PositionMaterialNormal),
auto vertexBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer, vecVertices.size() * sizeof(PolyVox::PositionMaterialNormal),
(gpu::Byte*)vecVertices.data());
auto vertexBufferPtr = gpu::BufferPointer(vertexBuffer);
gpu::BufferView vertexBufferView(vertexBufferPtr, 0,
@ -1365,8 +1365,8 @@ void RenderablePolyVoxEntityItem::recomputeMesh() {
(graphics::Index)vecIndices.size(), // numIndices
(graphics::Index)0, // baseVertex
graphics::Mesh::TRIANGLES)); // topology
mesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(graphics::Mesh::Part), (gpu::Byte*) parts.data()),
gpu::Element::PART_DRAWCALL));
mesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::IndirectBuffer, parts.size() * sizeof(graphics::Mesh::Part),
(gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
entity->setMesh(mesh);
});
}
@ -1766,7 +1766,7 @@ PolyVoxEntityRenderer::PolyVoxEntityRenderer(const EntityItemPointer& entity) :
_vertexFormat->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
_vertexFormat->setAttribute(gpu::Stream::NORMAL, 0, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 12);
});
_params = std::make_shared<gpu::Buffer>(sizeof(glm::vec4), nullptr);
_params = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(glm::vec4), nullptr);
}
ShapeKey PolyVoxEntityRenderer::getShapeKey() {

112
libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp
View file

@ -575,6 +575,15 @@ void GLBackend::render(const Batch& batch) {
_stereo._enable = savedStereo;
}
void GLBackend::executeFrame(const FramePointer& frame) {
setStereoState(frame->stereoState);
// Execute the frame rendering commands
for (auto& batch : frame->batches) {
render(*batch);
}
}
void GLBackend::syncCache() {
PROFILE_RANGE(render_gpu_gl_detail, __FUNCTION__);
@ -661,7 +670,7 @@ void GLBackend::resetStages() {
void GLBackend::do_pushProfileRange(const Batch& batch, size_t paramOffset) {
if (trace_render_gpu_gl_detail().isDebugEnabled()) {
auto name = batch._profileRanges.get(batch._params[paramOffset]._uint);
const auto& name = batch._profileRanges.get(batch._params[paramOffset]._uint);
profileRanges.push_back(name);
#if defined(NSIGHT_FOUND)
nvtxRangePush(name.c_str());
@ -679,25 +688,6 @@ void GLBackend::do_popProfileRange(const Batch& batch, size_t paramOffset) {
}
// TODO: As long as we have gl calls explicitely issued from interface
// code, we need to be able to record and batch these calls. THe long
// term strategy is to get rid of any GL calls in favor of the HIFI GPU API
void GLBackend::do_glUniform1i(const Batch& batch, size_t paramOffset) {
if (_pipeline._program == 0) {
// We should call updatePipeline() to bind the program but we are not doing that
// because these uniform setters are deprecated and we don;t want to create side effect
return;
}
updatePipeline();
GLint location = getRealUniformLocation(batch._params[paramOffset + 1]._int);
glUniform1i(
location,
batch._params[paramOffset + 0]._int);
(void)CHECK_GL_ERROR();
}
void GLBackend::do_glUniform1f(const Batch& batch, size_t paramOffset) {
if (_pipeline._program == 0) {
// We should call updatePipeline() to bind the program but we are not doing that
@ -761,88 +751,6 @@ void GLBackend::do_glUniform4f(const Batch& batch, size_t paramOffset) {
(void)CHECK_GL_ERROR();
}
void GLBackend::do_glUniform3fv(const Batch& batch, size_t paramOffset) {
if (_pipeline._program == 0) {
// We should call updatePipeline() to bind the program but we are not doing that
// because these uniform setters are deprecated and we don;t want to create side effect
return;
}
updatePipeline();
GLint location = getRealUniformLocation(batch._params[paramOffset + 2]._int);
glUniform3fv(
location,
batch._params[paramOffset + 1]._uint,
(const GLfloat*)batch.readData(batch._params[paramOffset + 0]._uint));
(void)CHECK_GL_ERROR();
}
void GLBackend::do_glUniform4fv(const Batch& batch, size_t paramOffset) {
if (_pipeline._program == 0) {
// We should call updatePipeline() to bind the program but we are not doing that
// because these uniform setters are deprecated and we don;t want to create side effect
return;
}
updatePipeline();
GLint location = getRealUniformLocation(batch._params[paramOffset + 2]._int);
GLsizei count = batch._params[paramOffset + 1]._uint;
const GLfloat* value = (const GLfloat*)batch.readData(batch._params[paramOffset + 0]._uint);
glUniform4fv(location, count, value);
(void)CHECK_GL_ERROR();
}
void GLBackend::do_glUniform4iv(const Batch& batch, size_t paramOffset) {
if (_pipeline._program == 0) {
// We should call updatePipeline() to bind the program but we are not doing that
// because these uniform setters are deprecated and we don;t want to create side effect
return;
}
updatePipeline();
GLint location = getRealUniformLocation(batch._params[paramOffset + 2]._int);
glUniform4iv(
location,
batch._params[paramOffset + 1]._uint,
(const GLint*)batch.readData(batch._params[paramOffset + 0]._uint));
(void)CHECK_GL_ERROR();
}
void GLBackend::do_glUniformMatrix3fv(const Batch& batch, size_t paramOffset) {
if (_pipeline._program == 0) {
// We should call updatePipeline() to bind the program but we are not doing that
// because these uniform setters are deprecated and we don;t want to create side effect
return;
}
updatePipeline();
GLint location = getRealUniformLocation(batch._params[paramOffset + 3]._int);
glUniformMatrix3fv(
location,
batch._params[paramOffset + 2]._uint,
batch._params[paramOffset + 1]._uint,
(const GLfloat*)batch.readData(batch._params[paramOffset + 0]._uint));
(void)CHECK_GL_ERROR();
}
void GLBackend::do_glUniformMatrix4fv(const Batch& batch, size_t paramOffset) {
if (_pipeline._program == 0) {
// We should call updatePipeline() to bind the program but we are not doing that
// because these uniform setters are deprecated and we don;t want to create side effect
return;
}
updatePipeline();
GLint location = getRealUniformLocation(batch._params[paramOffset + 3]._int);
glUniformMatrix4fv(
location,
batch._params[paramOffset + 2]._uint,
batch._params[paramOffset + 1]._uint,
(const GLfloat*)batch.readData(batch._params[paramOffset + 0]._uint));
(void)CHECK_GL_ERROR();
}
void GLBackend::releaseBuffer(GLuint id, Size size) const {
Lock lock(_trashMutex);
_currentFrameTrash.buffersTrash.push_back({ id, size });

16
libraries/gpu-gl-common/src/gpu/gl/GLBackend.h
View file

@ -122,7 +122,10 @@ public:
void shutdown() override;
void setCameraCorrection(const Mat4& correction, const Mat4& prevRenderView, bool primary, bool reset = false) override;
void render(const Batch& batch) final override;
void executeFrame(const FramePointer& frame) override;
void render(const Batch& batch);
// This call synchronize the Full Backend cache with the current GLState
// THis is only intended to be used when mixing raw gl calls with the gpu api usage in order to sync
@ -231,16 +234,10 @@ public:
// TODO: As long as we have gl calls explicitely issued from interface
// code, we need to be able to record and batch these calls. THe long
// term strategy is to get rid of any GL calls in favor of the HIFI GPU API
virtual void do_glUniform1i(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniform1f(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniform2f(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniform3f(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniform4f(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniform3fv(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniform4fv(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniform4iv(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniformMatrix3fv(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniformMatrix4fv(const Batch& batch, size_t paramOffset) final;
// The State setters called by the GLState::Commands when a new state is assigned
virtual void do_setStateFillMode(int32 mode) final;
@ -526,9 +523,8 @@ protected:
GLShader* _programShader{ nullptr };
bool _invalidProgram{ false };
BufferView _cameraCorrectionBuffer{ gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(CameraCorrection), nullptr)) };
BufferView _cameraCorrectionBufferIdentity{ gpu::BufferView(
std::make_shared<gpu::Buffer>(sizeof(CameraCorrection), nullptr)) };
BufferView _cameraCorrectionBuffer { gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(CameraCorrection), nullptr )) };
BufferView _cameraCorrectionBufferIdentity { gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(CameraCorrection), nullptr )) };
State::Data _stateCache{ State::DEFAULT };
State::Signature _stateSignatureCache{ 0 };

2
libraries/gpu-gl/src/gpu/gl41/GL41Backend.h
View file

@ -47,7 +47,7 @@ public:
static const std::string GL41_VERSION;
const std::string& getVersion() const override { return GL41_VERSION; }
bool supportedTextureFormat(const gpu::Element& format) override;
bool supportedTextureFormat(const gpu::Element& format) const override;
class GL41Texture : public GLTexture {
using Parent = GLTexture;

2
libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp
View file

@ -19,7 +19,7 @@ using namespace gpu;
using namespace gpu::gl;
using namespace gpu::gl41;
bool GL41Backend::supportedTextureFormat(const gpu::Element& format) {
bool GL41Backend::supportedTextureFormat(const gpu::Element& format) const {
switch (format.getSemantic()) {
case gpu::Semantic::COMPRESSED_ETC2_RGB:
case gpu::Semantic::COMPRESSED_ETC2_SRGB:

2
libraries/gpu-gl/src/gpu/gl45/GL45Backend.h
View file

@ -51,7 +51,7 @@ public:
static const std::string GL45_VERSION;
const std::string& getVersion() const override { return GL45_VERSION; }
bool supportedTextureFormat(const gpu::Element& format) override;
bool supportedTextureFormat(const gpu::Element& format) const override;
class GL45Texture : public GLTexture {
using Parent = GLTexture;

2
libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
View file

@ -35,7 +35,7 @@ using namespace gpu::gl45;
#define FORCE_STRICT_TEXTURE 0
#define ENABLE_SPARSE_TEXTURE 0
bool GL45Backend::supportedTextureFormat(const gpu::Element& format) {
bool GL45Backend::supportedTextureFormat(const gpu::Element& format) const {
switch (format.getSemantic()) {
// ETC textures are actually required by the OpenGL spec as of 4.3, but aren't always supported by hardware
// They'll be recompressed by OpenGL, which will be slow or have poor quality, so disable them for now

2
libraries/gpu/src/gpu/Batch.cpp
View file

@ -527,7 +527,7 @@ const BufferPointer& Batch::getNamedBuffer(const std::string& instanceName, uint
instance.buffers.resize(index + 1);
}
if (!instance.buffers[index]) {
instance.buffers[index] = std::make_shared<Buffer>();
instance.buffers[index] = std::make_shared<Buffer>(Buffer::VertexBuffer);
}
return instance.buffers[index];
}

8
libraries/gpu/src/gpu/Buffer.cpp
View file

@ -22,16 +22,16 @@ Buffer::Size Buffer::getBufferCPUMemSize() {
return _bufferCPUMemSize.getValue();
}
Buffer::Buffer(Size pageSize) :
_renderPages(pageSize), _pages(pageSize) {
Buffer::Buffer(uint32_t usage, Size pageSize) :
_renderPages(pageSize), _pages(pageSize), _usage(usage) {
_bufferCPUCount.increment();
}
Buffer::Buffer(Size size, const Byte* bytes, Size pageSize) : Buffer(pageSize) {
Buffer::Buffer(uint32_t usage, Size size, const Byte* bytes, Size pageSize) : Buffer(usage, pageSize) {
setData(size, bytes);
}
Buffer::Buffer(const Buffer& buf) : Buffer(buf._pages._pageSize) {
Buffer::Buffer(const Buffer& buf) : Buffer(buf._usage, buf._pages._pageSize) {
setData(buf.getSize(), buf.getData());
}

184
libraries/gpu/src/gpu/Buffer.h
View file

@ -27,9 +27,26 @@ namespace gpu {
class Buffer : public Resource {
static ContextMetricCount _bufferCPUCount;
static ContextMetricSize _bufferCPUMemSize;
public:
using Flag = PageManager::Flag;
// Flags match VkBufferUsageFlagBits for convenience... do not modify
enum Usage
{
// These values are unused in our API
//TransferSrc = 0x0001,
//TransferDst = 0x0002,
//UniformTexelBuffer = 0x0004,
//StorageTexelBuffer = 0x0008,
UniformBuffer = 0x0010,
ResourceBuffer = 0x0020,
IndexBuffer = 0x0040,
VertexBuffer = 0x0080,
IndirectBuffer = 0x0100,
AllFlags = 0x01F3
};
class Update {
public:
Update(const Buffer& buffer);
@ -61,6 +78,8 @@ public:
const Byte* getData() const { return getSysmem().readData(); }
uint32_t getUsage() const { return _usage; }
// Resize the buffer
// Keep previous data [0 to min(pSize, mSize)]
Size resize(Size pSize);
@ -108,8 +127,7 @@ public:
return append(sizeof(T) * t.size(), reinterpret_cast<const Byte*>(&t[0]));
}
const GPUObjectPointer gpuObject {};
const GPUObjectPointer gpuObject{};
// Access the sysmem object, limited to ourselves and GPUObject derived classes
const Sysmem& getSysmem() const { return _sysmem; }
@ -132,8 +150,8 @@ protected:
mutable PageManager _renderPages;
mutable Sysmem _renderSysmem;
mutable std::atomic<size_t> _getUpdateCount { 0 };
mutable std::atomic<size_t> _applyUpdateCount { 0 };
mutable std::atomic<size_t> _getUpdateCount{ 0 };
mutable std::atomic<size_t> _applyUpdateCount{ 0 };
void markDirty(Size offset, Size bytes);
@ -148,6 +166,7 @@ protected:
mutable PageManager _pages;
Size _end{ 0 };
Sysmem _sysmem;
const uint32_t _usage{ 0 };
friend class Serializer;
friend class Deserializer;
@ -156,18 +175,19 @@ protected:
friend class Batch;
// FIXME find a more generic way to do this.
friend class ::gpu::vulkan::VKBuffer;
friend class gl::GLBackend;
friend class gl::GLBuffer;
friend class gl41::GL41Buffer;
friend class gl45::GL45Buffer;
friend class gles::GLESBuffer;
friend class vulkan::VKBuffer;
};
using BufferUpdates = std::vector<Buffer::Update>;
typedef std::shared_ptr<Buffer> BufferPointer;
typedef std::vector< BufferPointer > Buffers;
typedef std::vector<BufferPointer> Buffers;
class BufferView {
protected:
@ -179,10 +199,10 @@ public:
using Index = int32_t;
BufferPointer _buffer;
Size _offset { 0 };
Size _size { 0 };
Element _element { DEFAULT_ELEMENT };
uint16 _stride { 0 };
Size _offset{ 0 };
Size _size{ 0 };
Element _element{ DEFAULT_ELEMENT };
uint16 _stride{ 0 };
BufferView(const BufferView& view) = default;
BufferView& operator=(const BufferView& view) = default;
@ -197,12 +217,10 @@ public:
Size getNumElements() const { return _size / _stride; }
//Template iterator with random access on the buffer sysmem
template<typename T>
class Iterator : public std::iterator<std::random_access_iterator_tag, T, Index, T*, T&>
{
template <typename T>
class Iterator : public std::iterator<std::random_access_iterator_tag, T, Index, T*, T&> {
public:
Iterator(T* ptr = NULL, int stride = sizeof(T)): _ptr(ptr), _stride(stride) { }
Iterator(T* ptr = NULL, int stride = sizeof(T)): _ptr(ptr), _stride(stride) {}
Iterator(const Iterator<T>& iterator) = default;
~Iterator() {}
@ -213,9 +231,8 @@ public:
return (*this);
}
operator bool() const
{
if(_ptr)
operator bool() const {
if (_ptr)
return true;
else
return false;
@ -273,17 +290,16 @@ public:
return temp;
}
Index operator-(const Iterator<T>& iterator) { return (iterator.getPtr() - this->getPtr())/sizeof(T); }
Index operator-(const Iterator<T>& iterator) { return (iterator.getPtr() - this->getPtr()) / sizeof(T); }
T& operator*(){return *_ptr;}
const T& operator*()const{return *_ptr;}
T* operator->(){return _ptr;}
T& operator*() { return *_ptr; }
const T& operator*() const { return *_ptr; }
T* operator->() { return _ptr; }
T* getPtr()const{return _ptr;}
const T* getConstPtr()const{return _ptr;}
T* getPtr() const { return _ptr; }
const T* getConstPtr() const { return _ptr; }
protected:
T* _ptr;
int _stride;
};
@ -293,112 +309,130 @@ public:
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 {
template <typename T>
Iterator<const T> begin() const {
return Iterator<const T>(&get<T>(), _stride);
}
template <typename T>
Iterator<const T> end() const {
// reimplement get<T> without bounds checking
Resource::Size elementOffset = getNum<T>() * _stride + _offset;
return Iterator<const T>((reinterpret_cast<const T*> (_buffer->getData() + elementOffset)), _stride);
return Iterator<const T>((reinterpret_cast<const T*>(_buffer->getData() + elementOffset)), _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 {
template <typename T>
Iterator<const T> cbegin() const {
return Iterator<const T>(&get<T>(), _stride);
}
template <typename T>
Iterator<const T> cend() const {
// reimplement get<T> without bounds checking
Resource::Size elementOffset = getNum<T>() * _stride + _offset;
return Iterator<const T>((reinterpret_cast<const T*> (_buffer->getData() + elementOffset)), _stride);
return Iterator<const T>((reinterpret_cast<const T*>(_buffer->getData() + elementOffset)), _stride);
}
// the number of elements of the specified type fitting in the view size
template <typename T> Index getNum() const {
template <typename T>
Index getNum() const {
return Index(_size / _stride);
}
template <typename T> const T& get() const {
#if _DEBUG
template <typename T>
const T& get() const {
#if _DEBUG
if (!_buffer) {
qCDebug(gpulogging) << "Accessing null gpu::buffer!";
}
if (sizeof(T) > (_buffer->getSize() - _offset)) {
qCDebug(gpulogging) << "Accessing buffer in non allocated memory, element size = " << sizeof(T) << " available space in buffer at offset is = " << (_buffer->getSize() - _offset);
qCDebug(gpulogging) << "Accessing buffer in non allocated memory, element size = " << sizeof(T)
<< " available space in buffer at offset is = " << (_buffer->getSize() - _offset);
}
if (sizeof(T) > _size) {
qCDebug(gpulogging) << "Accessing buffer outside the BufferView range, element size = " << sizeof(T) << " when bufferView size = " << _size;
qCDebug(gpulogging) << "Accessing buffer outside the BufferView range, element size = " << sizeof(T)
<< " when bufferView size = " << _size;
}
#endif
const T* t = (reinterpret_cast<const T*> (_buffer->getData() + _offset));
#endif
const T* t = (reinterpret_cast<const T*>(_buffer->getData() + _offset));
return *(t);
}
template <typename T> T& edit() {
#if _DEBUG
template <typename T>
T& edit() {
#if _DEBUG
if (!_buffer) {
qCDebug(gpulogging) << "Accessing null gpu::buffer!";
}
if (sizeof(T) > (_buffer->getSize() - _offset)) {
qCDebug(gpulogging) << "Accessing buffer in non allocated memory, element size = " << sizeof(T) << " available space in buffer at offset is = " << (_buffer->getSize() - _offset);
qCDebug(gpulogging) << "Accessing buffer in non allocated memory, element size = " << sizeof(T)
<< " available space in buffer at offset is = " << (_buffer->getSize() - _offset);
}
if (sizeof(T) > _size) {
qCDebug(gpulogging) << "Accessing buffer outside the BufferView range, element size = " << sizeof(T) << " when bufferView size = " << _size;
qCDebug(gpulogging) << "Accessing buffer outside the BufferView range, element size = " << sizeof(T)
<< " when bufferView size = " << _size;
}
#endif
#endif
_buffer->markDirty(_offset, sizeof(T));
T* t = (reinterpret_cast<T*> (_buffer->editData() + _offset));
T* t = (reinterpret_cast<T*>(_buffer->editData() + _offset));
return *(t);
}
template <typename T> const T& get(const Index index) const {
template <typename T>
const T& get(const Index index) const {
Resource::Size elementOffset = index * _stride + _offset;
#if _DEBUG
#if _DEBUG
if (!_buffer) {
qCDebug(gpulogging) << "Accessing null gpu::buffer!";
}
if (sizeof(T) > (_buffer->getSize() - elementOffset)) {
qCDebug(gpulogging) << "Accessing buffer in non allocated memory, index = " << index << ", element size = " << sizeof(T) << " available space in buffer at offset is = " << (_buffer->getSize() - elementOffset);
qCDebug(gpulogging) << "Accessing buffer in non allocated memory, index = " << index
<< ", element size = " << sizeof(T)
<< " available space in buffer at offset is = " << (_buffer->getSize() - elementOffset);
}
if (index > getNum<T>()) {
qCDebug(gpulogging) << "Accessing buffer outside the BufferView range, index = " << index << " number elements = " << getNum<T>();
qCDebug(gpulogging) << "Accessing buffer outside the BufferView range, index = " << index
<< " number elements = " << getNum<T>();
}
#endif
return *(reinterpret_cast<const T*> (_buffer->getData() + elementOffset));
#endif
return *(reinterpret_cast<const T*>(_buffer->getData() + elementOffset));
}
template <typename T> T& edit(const Index index) const {
template <typename T>
T& edit(const Index index) const {
Resource::Size elementOffset = index * _stride + _offset;
#if _DEBUG
#if _DEBUG
if (!_buffer) {
qCDebug(gpulogging) << "Accessing null gpu::buffer!";
}
if (sizeof(T) > (_buffer->getSize() - elementOffset)) {
qCDebug(gpulogging) << "Accessing buffer in non allocated memory, index = " << index << ", element size = " << sizeof(T) << " available space in buffer at offset is = " << (_buffer->getSize() - elementOffset);
qCDebug(gpulogging) << "Accessing buffer in non allocated memory, index = " << index
<< ", element size = " << sizeof(T)
<< " available space in buffer at offset is = " << (_buffer->getSize() - elementOffset);
}
if (index > getNum<T>()) {
qCDebug(gpulogging) << "Accessing buffer outside the BufferView range, index = " << index << " number elements = " << getNum<T>();
qCDebug(gpulogging) << "Accessing buffer outside the BufferView range, index = " << index
<< " number elements = " << getNum<T>();
}
#endif
#endif
_buffer->markDirty(elementOffset, sizeof(T));
return *(reinterpret_cast<T*> (_buffer->editData() + elementOffset));
return *(reinterpret_cast<T*>(_buffer->editData() + elementOffset));
}
};
template <class T>
class StructBuffer : public gpu::BufferView {
public:
template <class U>
static BufferPointer makeBuffer(uint32_t usage = gpu::Buffer::UniformBuffer) {
U t;
return std::make_shared<gpu::Buffer>(usage, sizeof(U), (const gpu::Byte*)&t, sizeof(U));
}
~StructBuffer<T>(){};
StructBuffer<T>() : gpu::BufferView(makeBuffer<T>()) {}
template <class T> class StructBuffer : public gpu::BufferView {
public:
template <class U> static BufferPointer makeBuffer() {
U t;
return std::make_shared<gpu::Buffer>(sizeof(U), (const gpu::Byte*) &t, sizeof(U));
}
~StructBuffer() {};
StructBuffer() : gpu::BufferView(makeBuffer<T>()) {}
T& edit() {
return BufferView::edit<T>(0);
}
const T& get() const {
return BufferView::get<T>(0);
}
const T* operator ->() const { return &get(); }
};
T& edit() { return BufferView::edit<T>(0); }
const T& get() const { return BufferView::get<T>(0); }
const T* operator->() const { return &get(); }
};
}; // namespace gpu
#endif

3
libraries/gpu/src/gpu/Frame.h
View file

@ -19,6 +19,7 @@ namespace gpu {
class Frame {
friend class Context;
friend class Backend;
public:
Frame();
@ -44,12 +45,12 @@ namespace gpu {
std::queue<std::tuple<std::function<void(const QImage&)>, float, bool>> snapshotOperators;
void preRender();
protected:
friend class Deserializer;
// Should be called once per frame, on the recording thred
void finish();
void preRender();
};
};

4
libraries/gpu/src/gpu/null/NullBackend.h
View file

@ -35,8 +35,8 @@ protected:
public:
~Backend() { }
void render(const Batch& batch) final { }
void executeFrame(const FramePointer& frame) {}
// This call synchronize the Full Backend cache with the current GLState
// THis is only intended to be used when mixing raw gl calls with the gpu api usage in order to sync
// the gpu::Backend state with the true gl state which has probably been messed up by these ugly naked gl calls

12
libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
View file

@ -254,19 +254,19 @@ scriptable::ScriptableMeshPointer GraphicsScriptingInterface::newMesh(const QVar
// TODO: newFromVector does inbound type conversion, but not compression or packing
// (later we should autodetect if fitting into gpu::INDEX_UINT16 and reduce / pack normals etc.)
mesh->setIndexBuffer(buffer_helpers::newFromVector(indices, gpu::Format::INDEX_INT32));
mesh->setVertexBuffer(buffer_helpers::newFromVector(vertices, gpu::Format::VEC3F_XYZ));
mesh->setIndexBuffer(buffer_helpers::newFromVector(gpu::Buffer::IndexBuffer, indices, gpu::Format::INDEX_INT32));
mesh->setVertexBuffer(buffer_helpers::newFromVector(gpu::Buffer::VertexBuffer, vertices, gpu::Format::VEC3F_XYZ));
if (normals.size()) {
mesh->addAttribute(gpu::Stream::NORMAL, buffer_helpers::newFromVector(normals, gpu::Format::VEC3F_XYZ));
mesh->addAttribute(gpu::Stream::NORMAL, buffer_helpers::newFromVector(gpu::Buffer::VertexBuffer, normals, gpu::Format::VEC3F_XYZ));
}
if (colors.size()) {
mesh->addAttribute(gpu::Stream::COLOR, buffer_helpers::newFromVector(colors, gpu::Format::VEC3F_XYZ));
mesh->addAttribute(gpu::Stream::COLOR, buffer_helpers::newFromVector(gpu::Buffer::VertexBuffer, colors, gpu::Format::VEC3F_XYZ));
}
if (texCoords0.size()) {
mesh->addAttribute(gpu::Stream::TEXCOORD0, buffer_helpers::newFromVector(texCoords0, gpu::Format::VEC2F_UV));
mesh->addAttribute(gpu::Stream::TEXCOORD0, buffer_helpers::newFromVector(gpu::Buffer::VertexBuffer, texCoords0, gpu::Format::VEC2F_UV));
}
QVector<graphics::Mesh::Part> parts = {{ 0, indices.size(), 0, topology }};
mesh->setPartBuffer(buffer_helpers::newFromVector(parts, gpu::Element::PART_DRAWCALL));
mesh->setPartBuffer(buffer_helpers::newFromVector(gpu::Buffer::IndirectBuffer, parts, gpu::Element::PART_DRAWCALL));
return scriptable::make_scriptowned<scriptable::ScriptableMesh>(mesh, nullptr);
}

4
libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.cpp
View file

@ -181,7 +181,7 @@ glm::uint32 scriptable::ScriptableMesh::addAttribute(const QString& attributeNam
if (!getAttributeNames().contains(attributeName)) {
QVector<QVariant> values;
values.fill(defaultValue, numVertices);
mesh->addAttribute(slot, buffer_helpers::newFromVector(values, gpu::Stream::getDefaultElements()[slot]));
mesh->addAttribute(slot, buffer_helpers::newFromVector(gpu::Buffer::VertexBuffer, values, gpu::Stream::getDefaultElements()[slot]));
return values.size();
} else {
auto bufferView = buffer_helpers::mesh::getBufferView(mesh, slot);
@ -209,7 +209,7 @@ glm::uint32 scriptable::ScriptableMesh::fillAttribute(const QString& attributeNa
auto numVertices = getNumVertices();
QVector<QVariant> values;
values.fill(value, numVertices);
mesh->addAttribute(slot, buffer_helpers::newFromVector(values, gpu::Stream::getDefaultElements()[slot]));
mesh->addAttribute(slot, buffer_helpers::newFromVector(gpu::Buffer::VertexBuffer, values, gpu::Stream::getDefaultElements()[slot]));
return true;
}

4
libraries/graphics-scripting/src/graphics-scripting/ScriptableMeshPart.cpp
View file

@ -206,8 +206,8 @@ bool scriptable::ScriptableMeshPart::dedupeVertices(float epsilon) {
}
}
mesh->setIndexBuffer(buffer_helpers::newFromVector(newIndices, { gpu::SCALAR, gpu::UINT32, gpu::INDEX }));
mesh->setVertexBuffer(buffer_helpers::newFromVector(uniqueVerts, gpu::Element::VEC3F_XYZ));
mesh->setIndexBuffer(buffer_helpers::newFromVector(gpu::Buffer::IndexBuffer, newIndices, { gpu::SCALAR, gpu::UINT32, gpu::INDEX }));
mesh->setVertexBuffer(buffer_helpers::newFromVector(gpu::Buffer::VertexBuffer, uniqueVerts, gpu::Element::VEC3F_XYZ));
auto attributeViews = buffer_helpers::mesh::getAllBufferViews(mesh);
glm::uint32 numUniqueVerts = uniqueVerts.size();

26
libraries/graphics/src/graphics/BufferViewHelpers.cpp
View file

@ -122,21 +122,21 @@ template<> glm::uint32 forEach<glm::vec3>(const gpu::BufferView& view, std::func
// QVector<T> => BufferView
template <typename T>
gpu::BufferView newFromVector(const QVector<T>& elements, const gpu::Element& elementType) {
auto vertexBuffer = std::make_shared<gpu::Buffer>(elements.size() * sizeof(T), (gpu::Byte*)elements.data());
gpu::BufferView newFromVector(uint32_t usage, const QVector<T>& elements, const gpu::Element& elementType) {
auto vertexBuffer = std::make_shared<gpu::Buffer>(usage, elements.size() * sizeof(T), (gpu::Byte*)elements.data());
return { vertexBuffer, 0, vertexBuffer->getSize(),sizeof(T), elementType };
}
template <typename T>
gpu::BufferView bufferViewFromVector(const QVector<T>& elements, const gpu::Element& elementType) {
auto vertexBuffer = std::make_shared<gpu::Buffer>(elements.size() * sizeof(T), (gpu::Byte*)elements.data());
gpu::BufferView bufferViewFromVector(uint32_t usage, const QVector<T>& elements, const gpu::Element& elementType) {
auto vertexBuffer = std::make_shared<gpu::Buffer>(usage, elements.size() * sizeof(T), (gpu::Byte*)elements.data());
return { vertexBuffer, 0, vertexBuffer->getSize(),sizeof(T), elementType };
}
template<> gpu::BufferView newFromVector<unsigned int>(const QVector<unsigned int>& elements, const gpu::Element& elementType) { return bufferViewFromVector(elements, elementType); }
template<> gpu::BufferView newFromVector<glm::vec2>(const QVector<glm::vec2>& elements, const gpu::Element& elementType) { return bufferViewFromVector(elements, elementType); }
template<> gpu::BufferView newFromVector<glm::vec3>( const QVector<glm::vec3>& elements, const gpu::Element& elementType) { return bufferViewFromVector(elements, elementType); }
template<> gpu::BufferView newFromVector<glm::vec4>(const QVector<glm::vec4>& elements, const gpu::Element& elementType) { return bufferViewFromVector(elements, elementType); }
template<> gpu::BufferView newFromVector<graphics::Mesh::Part>(const QVector<graphics::Mesh::Part>& elements, const gpu::Element& elementType) { return bufferViewFromVector(elements, elementType); }
template<> gpu::BufferView newFromVector<unsigned int>(uint32_t usage, const QVector<unsigned int>& elements, const gpu::Element& elementType) { return bufferViewFromVector(usage, elements, elementType); }
template<> gpu::BufferView newFromVector<glm::vec2>(uint32_t usage, const QVector<glm::vec2>& elements, const gpu::Element& elementType) { return bufferViewFromVector(usage, elements, elementType); }
template<> gpu::BufferView newFromVector<glm::vec3>(uint32_t usage, const QVector<glm::vec3>& elements, const gpu::Element& elementType) { return bufferViewFromVector(usage, elements, elementType); }
template<> gpu::BufferView newFromVector<glm::vec4>(uint32_t usage, const QVector<glm::vec4>& elements, const gpu::Element& elementType) { return bufferViewFromVector(usage, elements, elementType); }
template<> gpu::BufferView newFromVector<graphics::Mesh::Part>(uint32_t usage, const QVector<graphics::Mesh::Part>& elements, const gpu::Element& elementType) { return bufferViewFromVector(usage, elements, elementType); }
struct GpuToGlmAdapter {
static float error(const QString& name, const gpu::BufferView& view, glm::uint32 index, const char *hint) {
@ -443,9 +443,9 @@ template<> QVector<glm::vec2> variantToVector<glm::vec2>(const QVariant& value)
template<> QVector<glm::vec3> variantToVector<glm::vec3>(const QVariant& value) { return qVariantListToGlmVector<glm::vec3>(value.toList()); }
template<> QVector<glm::vec4> variantToVector<glm::vec4>(const QVariant& value) { return qVariantListToGlmVector<glm::vec4>(value.toList()); }
template<> gpu::BufferView newFromVector<QVariant>(const QVector<QVariant>& _elements, const gpu::Element& elementType) {
template<> gpu::BufferView newFromVector<QVariant>(uint32_t usage, const QVector<QVariant>& _elements, const gpu::Element& elementType) {
glm::uint32 numElements = _elements.size();
auto buffer = new gpu::Buffer();
auto buffer = new gpu::Buffer(usage);
buffer->resize(elementType.getSize() * numElements);
auto bufferView = gpu::BufferView(buffer, elementType);
for (glm::uint32 i = 0; i < numElements; i++) {
@ -457,7 +457,7 @@ template<> gpu::BufferView newFromVector<QVariant>(const QVector<QVariant>& _ele
gpu::BufferView clone(const gpu::BufferView& input) {
return gpu::BufferView(
std::make_shared<gpu::Buffer>(input._buffer->getSize(), input._buffer->getData()),
std::make_shared<gpu::Buffer>(input._buffer->getUsage(), input._buffer->getSize(), input._buffer->getData()),
input._offset, input._size, input._stride, input._element
);
}
@ -470,7 +470,7 @@ gpu::BufferView resized(const gpu::BufferView& input, glm::uint32 numElements) {
auto vsize = input._element.getSize() * numElements;
std::unique_ptr<gpu::Byte[]> data{ new gpu::Byte[vsize] };
memset(data.get(), 0, vsize);
auto buffer = new gpu::Buffer(vsize, data.get());
auto buffer = new gpu::Buffer(input._buffer->getUsage(), vsize, data.get());
memcpy(data.get(), input._buffer->getData(), std::min(vsize, (glm::uint32)input._buffer->getSize()));
auto output = gpu::BufferView(buffer, input._element);
#ifdef DEBUG_BUFFERVIEW_HELPERS

4
libraries/graphics/src/graphics/BufferViewHelpers.h
View file

@ -79,8 +79,8 @@ namespace buffer_helpers {
glm::uint32 forEachVariant(const gpu::BufferView& view, std::function<bool(glm::uint32 index, const QVariant& value)> func, const char* hint = "");
template <typename T> glm::uint32 forEach(const gpu::BufferView& view, std::function<bool(glm::uint32 index, const T& value)> func);
template <typename T> gpu::BufferView newFromVector(const QVector<T>& elements, const gpu::Element& elementType);
template <typename T> gpu::BufferView newFromVariantList(const QVariantList& list, const gpu::Element& elementType);
template <typename T> gpu::BufferView newFromVector(uint32_t usage, const QVector<T>& elements, const gpu::Element& elementType);
template <typename T> gpu::BufferView newFromVariantList(uint32_t usage, const QVariantList& list, const gpu::Element& elementType);
template <typename T> QVector<T> variantToVector(const QVariant& value);
template <typename T> QVector<T> bufferToVector(const gpu::BufferView& view, const char *hint = "");

18
libraries/graphics/src/graphics/Geometry.cpp
View file

@ -255,25 +255,25 @@ graphics::MeshPointer Mesh::map(std::function<glm::vec3(glm::vec3)> vertexFunc,
result->displayName = displayName;
gpu::Element vertexElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
gpu::Buffer* resultVertexBuffer = new gpu::Buffer(vertexSize, resultVertexData.get());
gpu::Buffer* resultVertexBuffer = new gpu::Buffer(gpu::Buffer::VertexBuffer, vertexSize, resultVertexData.get());
gpu::BufferPointer resultVertexBufferPointer(resultVertexBuffer);
gpu::BufferView resultVertexBufferView(resultVertexBufferPointer, vertexElement);
result->setVertexBuffer(resultVertexBufferView);
gpu::Element colorElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
gpu::Buffer* resultColorsBuffer = new gpu::Buffer(colorSize, resultColorData.get());
gpu::Buffer* resultColorsBuffer = new gpu::Buffer(gpu::Buffer::VertexBuffer, colorSize, resultColorData.get());
gpu::BufferPointer resultColorsBufferPointer(resultColorsBuffer);
gpu::BufferView resultColorsBufferView(resultColorsBufferPointer, colorElement);
result->addAttribute(attributeTypeColor, resultColorsBufferView);
gpu::Element normalElement = gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ);
gpu::Buffer* resultNormalsBuffer = new gpu::Buffer(normalSize, resultNormalData.get());
gpu::Buffer* resultNormalsBuffer = new gpu::Buffer(gpu::Buffer::VertexBuffer, normalSize, resultNormalData.get());
gpu::BufferPointer resultNormalsBufferPointer(resultNormalsBuffer);
gpu::BufferView resultNormalsBufferView(resultNormalsBufferPointer, normalElement);
result->addAttribute(attributeTypeNormal, resultNormalsBufferView);
gpu::Element indexElement = gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::RAW);
gpu::Buffer* resultIndexesBuffer = new gpu::Buffer(indexSize, resultIndexData.get());
gpu::Buffer* resultIndexesBuffer = new gpu::Buffer(gpu::Buffer::IndexBuffer, indexSize, resultIndexData.get());
gpu::BufferPointer resultIndexesBufferPointer(resultIndexesBuffer);
gpu::BufferView resultIndexesBufferView(resultIndexesBufferPointer, indexElement);
result->setIndexBuffer(resultIndexesBufferView);
@ -286,7 +286,7 @@ graphics::MeshPointer Mesh::map(std::function<glm::vec3(glm::vec3)> vertexFunc,
(graphics::Index)result->getNumIndices(), // numIndices
(graphics::Index)0, // baseVertex
graphics::Mesh::TRIANGLES)); // topology
result->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(graphics::Mesh::Part),
result->setPartBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::VertexBuffer, parts.size() * sizeof(graphics::Mesh::Part),
(gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
return result;
@ -358,7 +358,7 @@ MeshPointer Mesh::createIndexedTriangles_P3F(uint32_t numVertices, uint32_t numI
mesh = std::make_shared<Mesh>();
// Vertex buffer
mesh->setVertexBuffer(gpu::BufferView(new gpu::Buffer(numVertices * sizeof(glm::vec3), (gpu::Byte*) vertices), gpu::Element::VEC3F_XYZ));
mesh->setVertexBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::VertexBuffer, numVertices * sizeof(glm::vec3), (gpu::Byte*) vertices), gpu::Element::VEC3F_XYZ));
// trim down the indices to shorts if possible
if (numIndices < std::numeric_limits<uint16_t>::max()) {
@ -372,16 +372,16 @@ MeshPointer Mesh::createIndexedTriangles_P3F(uint32_t numVertices, uint32_t numI
shortIndices = shortIndicesVector.data();
}
mesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(numIndices * sizeof(uint16_t), (gpu::Byte*) shortIndices), gpu::Element::INDEX_UINT16));
mesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::IndexBuffer, numIndices * sizeof(uint16_t), (gpu::Byte*) shortIndices), gpu::Element::INDEX_UINT16));
} else {
mesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(numIndices * sizeof(uint32_t), (gpu::Byte*) indices), gpu::Element::INDEX_INT32));
mesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::IndexBuffer, numIndices * sizeof(uint32_t), (gpu::Byte*) indices), gpu::Element::INDEX_INT32));
}
std::vector<graphics::Mesh::Part> parts;
parts.push_back(graphics::Mesh::Part(0, numIndices, 0, graphics::Mesh::TRIANGLES));
mesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(graphics::Mesh::Part), (gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
mesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::VertexBuffer, parts.size() * sizeof(graphics::Mesh::Part), (gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
return mesh;
}

2
libraries/graphics/src/graphics/Haze.cpp
View file

@ -37,7 +37,7 @@ const float Haze::LOG_P_05{ logf(0.5f) };
Haze::Haze() {
Parameters parameters;
_hazeParametersBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(Parameters), (const gpu::Byte*) &parameters));
_hazeParametersBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Parameters), (const gpu::Byte*) &parameters));
}
enum HazeModes {

12
libraries/graphics/src/graphics/Material.cpp
View file

@ -68,6 +68,9 @@ Material::Material() {
for (int i = 0; i < NUM_TOTAL_FLAGS; i++) {
_propertyFallthroughs[i] = false;
}
// created from nothing: create the Buffer to store the properties
Schema schema;
_schemaBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Schema), (const gpu::Byte*) &schema, sizeof(Schema)));
}
Material::Material(const Material& material) :
@ -89,6 +92,10 @@ Material::Material(const Material& material) :
_defaultFallthrough(material._defaultFallthrough),
_propertyFallthroughs(material._propertyFallthroughs)
{
// copied: create the Buffer to store the properties, avoid holding a ref to the old Buffer
Schema schema;
_schemaBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Schema), (const gpu::Byte*) &schema, sizeof(Schema)));
_schemaBuffer.edit<Schema>() = material._schemaBuffer.get<Schema>();
}
Material& Material::operator=(const Material& material) {
@ -113,6 +120,11 @@ Material& Material::operator=(const Material& material) {
_defaultFallthrough = material._defaultFallthrough;
_propertyFallthroughs = material._propertyFallthroughs;
// copied: create the Buffer to store the properties, avoid holding a ref to the old Buffer
Schema schema;
_schemaBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Schema), (const gpu::Byte*) &schema, sizeof(Schema)));
_schemaBuffer.edit<Schema>() = material._schemaBuffer.get<Schema>();
return (*this);
}

2
libraries/graphics/src/graphics/Skybox.cpp
View file

@ -21,7 +21,7 @@ using namespace graphics;
Skybox::Skybox() {
Schema schema;
_schemaBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(Schema), (const gpu::Byte*) &schema));
_schemaBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Schema), (const gpu::Byte*) &schema));
}
void Skybox::setColor(const Color& color) {

3
libraries/procedural/src/procedural/Procedural.cpp
View file

@ -118,6 +118,7 @@ void ProceduralData::parse(const QJsonObject& proceduralData) {
std::function<void(gpu::StatePointer)> Procedural::opaqueStencil = [](gpu::StatePointer state) {};
std::function<void(gpu::StatePointer)> Procedural::transparentStencil = [](gpu::StatePointer state) {};
Procedural::Procedural() {
_opaqueState->setCullMode(gpu::State::CULL_NONE);
_opaqueState->setDepthTest(true, true, gpu::LESS_EQUAL);
@ -133,7 +134,7 @@ Procedural::Procedural() {
gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
transparentStencil(_transparentState);
_standardInputsBuffer = std::make_shared<gpu::Buffer>(sizeof(StandardInputs), nullptr);
_standardInputsBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(StandardInputs), nullptr);
}
void Procedural::setProceduralData(const ProceduralData& proceduralData) {

4
libraries/render-utils/src/AnimDebugDraw.cpp
View file

@ -33,8 +33,8 @@ public:
AnimDebugDrawData() {
_vertexFormat = std::make_shared<gpu::Stream::Format>();
_vertexBuffer = std::make_shared<gpu::Buffer>();
_indexBuffer = std::make_shared<gpu::Buffer>();
_vertexBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
_indexBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::IndexBuffer);
_vertexFormat->setAttribute(gpu::Stream::POSITION, 0, gpu::Element::VEC3F_XYZ, 0);
_vertexFormat->setAttribute(gpu::Stream::COLOR, 0, gpu::Element::COLOR_RGBA_32, offsetof(Vertex, rgba));

2
libraries/render-utils/src/AntialiasingEffect.cpp
View file

@ -293,7 +293,7 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const
batch.setResourceFramebufferSwapChainTexture(0, _antialiasingBuffers, 1);
// Disable sharpen if FXAA
if (!_blendParamsBuffer) {
_blendParamsBuffer = std::make_shared<gpu::Buffer>(sizeof(glm::vec4), nullptr);
_blendParamsBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(glm::vec4), nullptr);
}
_blendParamsBuffer->setSubData(0, _sharpen * _params.get().regionInfo.z);
batch.setUniformBuffer(0, _blendParamsBuffer);

2
libraries/render-utils/src/BloomEffect.cpp
View file

@ -200,7 +200,7 @@ void DebugBloomConfig::setMode(int mode) {
}
DebugBloom::DebugBloom() {
_params = std::make_shared<gpu::Buffer>(sizeof(glm::vec4), nullptr);
_params = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(glm::vec4), nullptr);
}
void DebugBloom::configure(const Config& config) {

4
libraries/render-utils/src/CauterizedMeshPartPayload.cpp
View file

@ -28,7 +28,7 @@ void CauterizedMeshPartPayload::updateClusterBuffer(const std::vector<glm::mat4>
if (cauterizedClusterMatrices.size() > 1) {
if (!_cauterizedClusterBuffer) {
_cauterizedClusterBuffer = std::make_shared<gpu::Buffer>(cauterizedClusterMatrices.size() * sizeof(glm::mat4),
_cauterizedClusterBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, cauterizedClusterMatrices.size() * sizeof(glm::mat4),
(const gpu::Byte*) cauterizedClusterMatrices.data());
} else {
_cauterizedClusterBuffer->setSubData(0, cauterizedClusterMatrices.size() * sizeof(glm::mat4),
@ -43,7 +43,7 @@ void CauterizedMeshPartPayload::updateClusterBuffer(const std::vector<Model::Tra
if (cauterizedClusterDualQuaternions.size() > 1) {
if (!_cauterizedClusterBuffer) {
_cauterizedClusterBuffer = std::make_shared<gpu::Buffer>(cauterizedClusterDualQuaternions.size() * sizeof(Model::TransformDualQuaternion),
_cauterizedClusterBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, cauterizedClusterDualQuaternions.size() * sizeof(Model::TransformDualQuaternion),
(const gpu::Byte*) cauterizedClusterDualQuaternions.data());
} else {
_cauterizedClusterBuffer->setSubData(0, cauterizedClusterDualQuaternions.size() * sizeof(Model::TransformDualQuaternion),

2
libraries/render-utils/src/DeferredFrameTransform.cpp
View file

@ -15,7 +15,7 @@
DeferredFrameTransform::DeferredFrameTransform() {
FrameTransform frameTransform;
_frameTransformBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(FrameTransform), (const gpu::Byte*) &frameTransform));
_frameTransformBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(FrameTransform), (const gpu::Byte*) &frameTransform));
}
void DeferredFrameTransform::update(RenderArgs* args, glm::vec2 jitter) {

32
libraries/render-utils/src/DeferredLightingEffect.cpp
View file

@ -147,32 +147,18 @@ graphics::MeshPointer DeferredLightingEffect::getPointLightMesh() {
// let's use a icosahedron
auto solid = geometry::icosahedron();
solid.fitDimension(1.05f); // scaled to 1.05 meters, it will be scaled by the shader accordingly to the light size
_pointLightMesh->setVertexBuffer(gpu::BufferView(gpu::Buffer::createBuffer(gpu::Buffer::VertexBuffer, solid.vertices), gpu::Element::VEC3F_XYZ));
int verticesSize = (int) (solid.vertices.size() * 3 * sizeof(float));
float* vertexData = (float*) solid.vertices.data();
_pointLightMesh->setVertexBuffer(gpu::BufferView(new gpu::Buffer(verticesSize, (gpu::Byte*) vertexData), gpu::Element::VEC3F_XYZ));
int nbIndices = (int) solid.faces.size() * 3;
gpu::uint16* indexData = new gpu::uint16[nbIndices];
gpu::uint16* index = indexData;
for (auto face : solid.faces) {
*(index++) = face[0];
*(index++) = face[1];
*(index++) = face[2];
}
_pointLightMesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(sizeof(unsigned short) * nbIndices, (gpu::Byte*) indexData), gpu::Element::INDEX_UINT16));
delete[] indexData;
auto indices = solid.getIndices<gpu::uint16>();
_pointLightMesh->setIndexBuffer(gpu::BufferView(gpu::Buffer::createBuffer(gpu::Buffer::IndexBuffer, indices), gpu::Element::INDEX_UINT16));
uint32_t nbIndices = (uint32_t)(indices.size());
std::vector<graphics::Mesh::Part> parts;
parts.push_back(graphics::Mesh::Part(0, nbIndices, 0, graphics::Mesh::TRIANGLES));
parts.push_back(graphics::Mesh::Part(0, nbIndices, 0, graphics::Mesh::LINE_STRIP)); // outline version
_pointLightMesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(graphics::Mesh::Part), (gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
_pointLightMesh->setPartBuffer(gpu::BufferView(gpu::Buffer::createBuffer(gpu::Buffer::IndirectBuffer, parts), gpu::Element::PART_DRAWCALL));
}
return _pointLightMesh;
}
@ -221,7 +207,7 @@ graphics::MeshPointer DeferredLightingEffect::getSpotLightMesh() {
*(vertexRing2++) = 0.0f;
*(vertexRing2++) = 1.0f;
_spotLightMesh->setVertexBuffer(gpu::BufferView(new gpu::Buffer(verticesSize, (gpu::Byte*) vertexData), gpu::Element::VEC3F_XYZ));
_spotLightMesh->setVertexBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::VertexBuffer, verticesSize, (gpu::Byte*) vertexData), gpu::Element::VEC3F_XYZ));
delete[] vertexData;
gpu::uint16* indexData = new gpu::uint16[indices];
@ -260,7 +246,7 @@ graphics::MeshPointer DeferredLightingEffect::getSpotLightMesh() {
*(index++) = capVertex;
}
_spotLightMesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(sizeof(unsigned short) * indices, (gpu::Byte*) indexData), gpu::Element::INDEX_UINT16));
_spotLightMesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::IndexBuffer, sizeof(unsigned short) * indices, (gpu::Byte*) indexData), gpu::Element::INDEX_UINT16));
delete[] indexData;
@ -269,7 +255,7 @@ graphics::MeshPointer DeferredLightingEffect::getSpotLightMesh() {
parts.push_back(graphics::Mesh::Part(0, indices, 0, graphics::Mesh::LINE_STRIP)); // outline version
_spotLightMesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(graphics::Mesh::Part), (gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
_spotLightMesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(gpu::Buffer::VertexBuffer, parts.size() * sizeof(graphics::Mesh::Part), (gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
}
return _spotLightMesh;
}
@ -446,7 +432,7 @@ void RenderDeferredSetup::run(const render::RenderContextPointer& renderContext,
}
RenderDeferredLocals::RenderDeferredLocals() :
_localLightsBuffer(std::make_shared<gpu::Buffer>()) {
_localLightsBuffer(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer)) {
}

61
libraries/render-utils/src/GeometryCache.cpp
View file

@ -541,8 +541,8 @@ void extrudePolygon(GeometryCache::ShapeData& shapeData, gpu::BufferPointer& ver
// and smooth shading
void GeometryCache::buildShapes() {
using namespace geometry;
auto vertexBuffer = std::make_shared<gpu::Buffer>();
auto indexBuffer = std::make_shared<gpu::Buffer>();
auto vertexBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto indexBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::IndexBuffer);
// Cube
setupFlatShape(_shapes[Cube], geometry::cube(), _shapeVertices, _shapeIndices);
//Quad renders as flat Cube
@ -786,7 +786,7 @@ void GeometryCache::renderGrid(gpu::Batch& batch, const glm::vec2& minCorner, co
gridBuffer = gridBufferIter.value();
} else {
GridSchema gridSchema;
gridBuffer = std::make_shared<gpu::Buffer>(sizeof(GridSchema), (const gpu::Byte*)&gridSchema);
gridBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(GridSchema), (const gpu::Byte*)&gridSchema);
}
if (!hadGridBuffer || _lastRegisteredGridBuffer[id] != key) {
@ -827,9 +827,10 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, con
details.vertices = points.size();
details.vertexSize = FLOATS_PER_VERTEX;
auto verticesBuffer = std::make_shared<gpu::Buffer>();
auto normalBuffer = std::make_shared<gpu::Buffer>();
auto colorBuffer = std::make_shared<gpu::Buffer>();
auto verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto normalBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto colorBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto streamFormat = std::make_shared<gpu::Stream::Format>();
auto stream = std::make_shared<gpu::BufferStream>();
@ -897,9 +898,9 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, con
details.vertices = points.size();
details.vertexSize = FLOATS_PER_VERTEX;
auto verticesBuffer = std::make_shared<gpu::Buffer>();
auto normalBuffer = std::make_shared<gpu::Buffer>();
auto colorBuffer = std::make_shared<gpu::Buffer>();
auto verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto normalBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto colorBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto streamFormat = std::make_shared<gpu::Stream::Format>();
auto stream = std::make_shared<gpu::BufferStream>();
@ -972,9 +973,9 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, con
details.vertices = points.size();
details.vertexSize = FLOATS_PER_VERTEX;
auto verticesBuffer = std::make_shared<gpu::Buffer>();
auto normalBuffer = std::make_shared<gpu::Buffer>();
auto colorBuffer = std::make_shared<gpu::Buffer>();
auto verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto normalBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto colorBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto streamFormat = std::make_shared<gpu::Stream::Format>();
auto stream = std::make_shared<gpu::BufferStream>();
@ -1060,8 +1061,8 @@ void GeometryCache::renderBevelCornersRect(gpu::Batch& batch, int x, int y, int
details.vertices = NUM_VERTICES;
details.vertexSize = FLOATS_PER_VERTEX;
auto verticesBuffer = std::make_shared<gpu::Buffer>();
auto colorBuffer = std::make_shared<gpu::Buffer>();
auto verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto colorBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto streamFormat = std::make_shared<gpu::Stream::Format>();
auto stream = std::make_shared<gpu::BufferStream>();
@ -1153,9 +1154,9 @@ void GeometryCache::renderQuad(gpu::Batch& batch, const glm::vec2& minCorner, co
details.vertices = VERTICES;
details.vertexSize = FLOATS_PER_VERTEX;
auto verticesBuffer = std::make_shared<gpu::Buffer>();
auto normalBuffer = std::make_shared<gpu::Buffer>();
auto colorBuffer = std::make_shared<gpu::Buffer>();
auto verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto normalBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto colorBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto streamFormat = std::make_shared<gpu::Stream::Format>();
auto stream = std::make_shared<gpu::BufferStream>();
@ -1236,9 +1237,9 @@ void GeometryCache::renderQuad(gpu::Batch& batch, const glm::vec2& minCorner, co
details.vertices = VERTICES;
details.vertexSize = FLOATS_PER_VERTEX;
auto verticesBuffer = std::make_shared<gpu::Buffer>();
auto normalBuffer = std::make_shared<gpu::Buffer>();
auto colorBuffer = std::make_shared<gpu::Buffer>();
auto verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto normalBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto colorBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto streamFormat = std::make_shared<gpu::Stream::Format>();
auto stream = std::make_shared<gpu::BufferStream>();
@ -1306,9 +1307,9 @@ void GeometryCache::renderQuad(gpu::Batch& batch, const glm::vec3& minCorner, co
details.vertices = VERTICES;
details.vertexSize = FLOATS_PER_VERTEX;
auto verticesBuffer = std::make_shared<gpu::Buffer>();
auto normalBuffer = std::make_shared<gpu::Buffer>();
auto colorBuffer = std::make_shared<gpu::Buffer>();
auto verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto normalBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto colorBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto streamFormat = std::make_shared<gpu::Stream::Format>();
auto stream = std::make_shared<gpu::BufferStream>();
@ -1396,9 +1397,9 @@ void GeometryCache::renderQuad(gpu::Batch& batch, const glm::vec3& topLeft, cons
details.vertices = VERTICES;
details.vertexSize = FLOATS_PER_VERTEX; // NOTE: this isn't used for BatchItemDetails maybe we can get rid of it
auto verticesBuffer = std::make_shared<gpu::Buffer>();
auto normalBuffer = std::make_shared<gpu::Buffer>();
auto colorBuffer = std::make_shared<gpu::Buffer>();
auto verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto normalBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto colorBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto streamFormat = std::make_shared<gpu::Stream::Format>();
auto stream = std::make_shared<gpu::BufferStream>();
@ -1553,9 +1554,9 @@ void GeometryCache::renderDashedLine(gpu::Batch& batch, const glm::vec3& start,
details.vertices = (segmentCountFloor + 1) * 2;
details.vertexSize = FLOATS_PER_VERTEX;
auto verticesBuffer = std::make_shared<gpu::Buffer>();
auto normalBuffer = std::make_shared<gpu::Buffer>();
auto colorBuffer = std::make_shared<gpu::Buffer>();
auto verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto normalBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto colorBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
auto streamFormat = std::make_shared<gpu::Stream::Format>();
auto stream = std::make_shared<gpu::BufferStream>();
@ -1990,7 +1991,7 @@ graphics::MeshPointer GeometryCache::meshFromShape(Shape geometryShape, glm::vec
const auto startIndex = 0, baseVertex = 0;
graphics::Mesh::Part part(startIndex, (graphics::Index)indexBufferView.getNumElements(), baseVertex, graphics::Mesh::TRIANGLES);
auto partBuffer = new gpu::Buffer(sizeof(graphics::Mesh::Part), (gpu::Byte*)&part);
auto partBuffer = new gpu::Buffer(gpu::Buffer::IndirectBuffer, sizeof(graphics::Mesh::Part), (gpu::Byte*)&part);
mesh->setPartBuffer(gpu::BufferView(partBuffer, gpu::Element::PART_DRAWCALL));
mesh->modelName = GeometryCache::stringFromShape(geometryShape).toStdString();

4
libraries/render-utils/src/GeometryCache.h
View file

@ -315,8 +315,8 @@ private:
gpu::PipelinePointer _standardDrawPipeline;
gpu::PipelinePointer _standardDrawPipelineNoBlend;
gpu::BufferPointer _shapeVertices{ std::make_shared<gpu::Buffer>() };
gpu::BufferPointer _shapeIndices{ std::make_shared<gpu::Buffer>() };
gpu::BufferPointer _shapeVertices { std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer) };
gpu::BufferPointer _shapeIndices { std::make_shared<gpu::Buffer>(gpu::Buffer::IndexBuffer) };
class GridSchema {
public:

2
libraries/render-utils/src/HighlightEffect.cpp
View file

@ -153,7 +153,7 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c
}
if (!_boundsBuffer) {
_boundsBuffer = std::make_shared<gpu::Buffer>(sizeof(render::ItemBound));
_boundsBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::ResourceBuffer, sizeof(render::ItemBound));
}
auto highlightStage = renderContext->_scene->getStage<render::HighlightStage>();

6
libraries/render-utils/src/LightClusters.cpp
View file

@ -77,7 +77,7 @@ const glm::uvec4 LightClusters::MAX_GRID_DIMENSIONS { 32, 32, 31, 16384 };
LightClusters::LightClusters() :
_lightIndicesBuffer(std::make_shared<gpu::Buffer>()),
_lightIndicesBuffer(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer)),
_clusterGridBuffer(/*std::make_shared<gpu::Buffer>(), */gpu::Element::INDEX_INT32),
_clusterContentBuffer(/*std::make_shared<gpu::Buffer>(), */gpu::Element::INDEX_INT32) {
}
@ -126,7 +126,7 @@ uint32_t LightClusters::getNumClusters() const {
_clusterGrid.clear();
_clusterGrid.resize(numClusters, EMPTY_CLUSTER);
_clusterGridBuffer._size = (numClusters * sizeof(uint32_t));
_clusterGridBuffer._buffer = std::make_shared<gpu::Buffer>(_clusterGridBuffer._size, (gpu::Byte*) _clusterGrid.data(), _clusterGridBuffer._size);
_clusterGridBuffer._buffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, _clusterGridBuffer._size, (gpu::Byte*) _clusterGrid.data(), _clusterGridBuffer._size);
}
// Since LightIndex is 2bytes, we can fit 2 in a uint32
@ -139,7 +139,7 @@ uint32_t LightClusters::getNumClusters() const {
_clusterContent.clear();
_clusterContent.resize(configListBudget, INVALID_LIGHT);
_clusterContentBuffer._size = (configListBudget * sizeof(LightIndex));
_clusterContentBuffer._buffer = std::make_shared<gpu::Buffer>(_clusterContentBuffer._size, (gpu::Byte*) _clusterContent.data(), _clusterContentBuffer._size);
_clusterContentBuffer._buffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, _clusterContentBuffer._size, (gpu::Byte*) _clusterContent.data(), _clusterContentBuffer._size);
}
}

2
libraries/render-utils/src/LightStage.cpp
View file

@ -127,7 +127,7 @@ LightStage::Shadow::Shadow(graphics::LightPointer light, unsigned int cascadeCou
cascadeCount = std::min(cascadeCount, (unsigned int)SHADOW_CASCADE_MAX_COUNT);
Schema schema;
schema.cascadeCount = cascadeCount;
_schemaBuffer = std::make_shared<gpu::Buffer>(sizeof(Schema), (const gpu::Byte*) &schema);
_schemaBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Schema), (const gpu::Byte*) &schema);
// Create shadow cascade texture array
auto depthFormat = gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::DEPTH); // Depth32 texel format

4
libraries/render-utils/src/MeshPartPayload.cpp
View file

@ -101,7 +101,7 @@ void ModelMeshPartPayload::updateClusterBuffer(const std::vector<glm::mat4>& clu
// Once computed the cluster matrices, update the buffer(s)
if (clusterMatrices.size() > 1) {
if (!_clusterBuffer) {
_clusterBuffer = std::make_shared<gpu::Buffer>(clusterMatrices.size() * sizeof(glm::mat4),
_clusterBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, clusterMatrices.size() * sizeof(glm::mat4),
(const gpu::Byte*) clusterMatrices.data());
} else {
_clusterBuffer->setSubData(0, clusterMatrices.size() * sizeof(glm::mat4),
@ -120,7 +120,7 @@ void ModelMeshPartPayload::updateClusterBuffer(const std::vector<Model::Transfor
// Once computed the cluster matrices, update the buffer(s)
if (clusterDualQuaternions.size() > 1) {
if (!_clusterBuffer) {
_clusterBuffer = std::make_shared<gpu::Buffer>(clusterDualQuaternions.size() * sizeof(Model::TransformDualQuaternion),
_clusterBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, clusterDualQuaternions.size() * sizeof(Model::TransformDualQuaternion),
(const gpu::Byte*) clusterDualQuaternions.data());
} else {
_clusterBuffer->setSubData(0, clusterDualQuaternions.size() * sizeof(Model::TransformDualQuaternion),

5
libraries/render-utils/src/MetaModelPayload.cpp
View file

@ -37,7 +37,10 @@ void MetaModelPayload::setBlendedVertices(int blendNumber, const QVector<Blendsh
const auto& buffer = _blendshapeBuffers.find(i);
const auto blendShapeBufferSize = numVertices * sizeof(BlendshapeOffset);
if (buffer == _blendshapeBuffers.end()) {
_blendshapeBuffers[i] = std::make_shared<gpu::Buffer>(blendShapeBufferSize, (gpu::Byte*) blendshapeOffsets.constData() + index * sizeof(BlendshapeOffset), blendShapeBufferSize);
auto usage = gpu::Buffer::VertexBuffer;
auto data = (gpu::Byte*) blendshapeOffsets.constData() + index * sizeof(BlendshapeOffset);
auto size = blendShapeBufferSize;
_blendshapeBuffers[i] = std::make_shared<gpu::Buffer>(usage, size, data);
} else {
buffer->second->setData(blendShapeBufferSize, (gpu::Byte*) blendshapeOffsets.constData() + index * sizeof(BlendshapeOffset));
}

6
libraries/render-utils/src/SubsurfaceScattering.cpp
View file

@ -35,7 +35,7 @@ namespace gr {
SubsurfaceScatteringResource::SubsurfaceScatteringResource() {
Parameters parameters;
_parametersBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(Parameters), (const gpu::Byte*) &parameters));
_parametersBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Parameters), (const gpu::Byte*) &parameters));
}
@ -422,7 +422,7 @@ void DebugSubsurfaceScattering::configure(const Config& config) {
_showCursorPixel = config.showCursorPixel;
_debugCursorTexcoord = config.debugCursorTexcoord;
if (!_debugParams) {
_debugParams = std::make_shared<gpu::Buffer>(sizeof(glm::vec4), nullptr);
_debugParams = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(glm::vec4), nullptr);
}
_debugParams->setSubData(0, _debugCursorTexcoord);
}
@ -476,7 +476,7 @@ void DebugSubsurfaceScattering::run(const render::RenderContextPointer& renderCo
// const auto light = DependencyManager::get<DeferredLightingEffect>()->getLightStage()->getElement(0);
const auto light = lightStage->getElement(0);
if (!_debugParams) {
_debugParams = std::make_shared<gpu::Buffer>(sizeof(glm::vec4), nullptr);
_debugParams = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(glm::vec4), nullptr);
_debugParams->setSubData(0, _debugCursorTexcoord);
}

2
libraries/render-utils/src/SurfaceGeometryPass.cpp
View file

@ -369,7 +369,7 @@ SurfaceGeometryPass::SurfaceGeometryPass() :
_diffusePass(false)
{
Parameters parameters;
_parametersBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(Parameters), (const gpu::Byte*) &parameters));
_parametersBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Parameters), (const gpu::Byte*) &parameters));
}
void SurfaceGeometryPass::configure(const Config& config) {

6
libraries/render-utils/src/text/Font.cpp
View file

@ -389,8 +389,8 @@ inline QuadBuilder adjustedQuadBuilderForAlignmentMode(const Glyph& glyph, glm::
void Font::buildVertices(Font::DrawInfo& drawInfo, const QString& str, const glm::vec2& origin, const glm::vec2& bounds, float scale, bool enlargeForShadows,
TextAlignment alignment, TextVerticalAlignment verticalAlignment) {
drawInfo.verticesBuffer = std::make_shared<gpu::Buffer>();
drawInfo.indicesBuffer = std::make_shared<gpu::Buffer>();
drawInfo.verticesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
drawInfo.indicesBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::IndexBuffer);
drawInfo.indexCount = 0;
int numVertices = 0;
@ -585,7 +585,7 @@ void Font::drawString(gpu::Batch& batch, Font::DrawInfo& drawInfo, const DrawPro
gpuDrawParams.effectThickness = drawInfo.params.effectThickness;
gpuDrawParams.effectColor = ColorUtils::sRGBToLinearVec3(drawInfo.params.effectColor);
if (!drawInfo.paramsBuffer) {
drawInfo.paramsBuffer = std::make_shared<gpu::Buffer>(sizeof(DrawParams), nullptr);
drawInfo.paramsBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(GpuDrawParams), nullptr);
}
drawInfo.paramsBuffer->setSubData(0, sizeof(DrawParams), (const gpu::Byte*)&gpuDrawParams);

2
libraries/render/src/render/BlurTask.cpp
View file

@ -25,7 +25,7 @@ enum BlurShaderMapSlots {
BlurParams::BlurParams() {
Params params;
_parametersBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(Params), (const gpu::Byte*) &params));
_parametersBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(Params), (const gpu::Byte*) &params));
setFilterGaussianTaps(3);
}

9
libraries/render/src/render/DrawSceneOctree.cpp
View file

@ -71,6 +71,7 @@ void DrawSceneOctree::configure(const Config& config) {
_showEmptyCells = config.showEmptyCells;
}
void DrawSceneOctree::run(const RenderContextPointer& renderContext, const ItemSpatialTree::ItemSelection& inSelection) {
assert(renderContext->args);
assert(renderContext->args->hasViewFrustum());
@ -174,16 +175,16 @@ void DrawItemSelection::run(const RenderContextPointer& renderContext, const Ite
auto& scene = renderContext->_scene;
if (!_boundsBufferInside) {
_boundsBufferInside = std::make_shared<gpu::Buffer>(sizeof(render::ItemBound));
_boundsBufferInside = std::make_shared<gpu::Buffer>(gpu::Buffer::ResourceBuffer, sizeof(render::ItemBound));
}
if (!_boundsBufferInsideSubcell) {
_boundsBufferInsideSubcell = std::make_shared<gpu::Buffer>(sizeof(render::ItemBound));
_boundsBufferInsideSubcell = std::make_shared<gpu::Buffer>(gpu::Buffer::ResourceBuffer, sizeof(render::ItemBound));
}
if (!_boundsBufferPartial) {
_boundsBufferPartial = std::make_shared<gpu::Buffer>(sizeof(render::ItemBound));
_boundsBufferPartial = std::make_shared<gpu::Buffer>(gpu::Buffer::ResourceBuffer, sizeof(render::ItemBound));
}
if (!_boundsBufferPartialSubcell) {
_boundsBufferPartialSubcell = std::make_shared<gpu::Buffer>(sizeof(render::ItemBound));
_boundsBufferPartialSubcell = std::make_shared<gpu::Buffer>(gpu::Buffer::ResourceBuffer, sizeof(render::ItemBound));
}
gpu::doInBatch("DrawItemSelection::run", args->_context, [&](gpu::Batch& batch) {

4
libraries/render/src/render/DrawStatus.cpp
View file

@ -208,7 +208,7 @@ void DrawStatus::run(const RenderContextPointer& renderContext, const Input& inp
}
if (!_boundsBuffer) {
_boundsBuffer = std::make_shared<gpu::Buffer>(sizeof(render::ItemBound));
_boundsBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::ResourceBuffer, sizeof(render::ItemBound));
}
// Alright, something to render let's do it
@ -241,7 +241,7 @@ void DrawStatus::run(const RenderContextPointer& renderContext, const Input& inp
if (_showNetwork || _showFade) {
if (!_instanceBuffer) {
_instanceBuffer = std::make_shared<gpu::Buffer>();
_instanceBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer);
}
struct InstanceData {

12
libraries/render/src/render/DrawTask.cpp
View file

@ -182,11 +182,11 @@ void DrawBounds::run(const RenderContextPointer& renderContext,
static const uint32_t sizeOfItemBound = sizeof(ItemBound);
if (!_drawBuffer) {
_drawBuffer = std::make_shared<gpu::Buffer>(sizeOfItemBound);
_drawBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::ResourceBuffer, sizeOfItemBound);
}
if (!_paramsBuffer) {
_paramsBuffer = std::make_shared<gpu::Buffer>(sizeof(vec4), nullptr);
_paramsBuffer = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(vec4), nullptr);
}
_drawBuffer->setData(numItems * sizeOfItemBound, (const gpu::Byte*) items.data());
@ -219,8 +219,8 @@ void DrawBounds::run(const RenderContextPointer& renderContext,
gpu::Stream::FormatPointer DrawQuadVolume::_format;
DrawQuadVolume::DrawQuadVolume(const glm::vec3& color) {
_meshVertices = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(glm::vec3) * 8, nullptr), gpu::Element::VEC3F_XYZ);
_params = std::make_shared<gpu::Buffer>(sizeof(glm::vec4), nullptr);
_meshVertices = gpu::BufferView(std::make_shared<gpu::Buffer>(gpu::Buffer::VertexBuffer, sizeof(glm::vec3) * 8, nullptr), gpu::Element::VEC3F_XYZ);
_params = std::make_shared<gpu::Buffer>(gpu::Buffer::UniformBuffer, sizeof(glm::vec4), nullptr);
_params->setSubData(0, vec4(color, 1.0));
if (!_format) {
_format = std::make_shared<gpu::Stream::Format>();
@ -301,7 +301,7 @@ void DrawAABox::run(const render::RenderContextPointer& renderContext, const Inp
};
if (!_cubeMeshIndices._buffer) {
auto indices = std::make_shared<gpu::Buffer>(sizeof(indexData), indexData);
auto indices = std::make_shared<gpu::Buffer>(gpu::Buffer::IndexBuffer, sizeof(indexData), indexData);
_cubeMeshIndices = gpu::BufferView(indices, gpu::Element(gpu::SCALAR, gpu::UINT8, gpu::INDEX));
}
@ -354,7 +354,7 @@ void DrawFrustum::run(const render::RenderContextPointer& renderContext, const I
};
if (!_frustumMeshIndices._buffer) {
auto indices = std::make_shared<gpu::Buffer>(sizeof(indexData), indexData);
auto indices = std::make_shared<gpu::Buffer>(gpu::Buffer::IndexBuffer, sizeof(indexData), indexData);
_frustumMeshIndices = gpu::BufferView(indices, gpu::Element(gpu::SCALAR, gpu::UINT8, gpu::INDEX));
}