Cleaning up for review

examples/utilities/tools/render/PlotPerf.qml

@@ -19,7 +19,9 @@ Item {
     property var config
     property string parameters
 
-    property var trigger: config["numTextures"]
+    // THis is my hack to get the name of the first property and assign it to a trigger var in order to get
+    // a signal called whenever the value changed
+    property var trigger: config[parameters.split(":")[3].split("-")[0]]
 
     property var inputs: parameters.split(":")
     property var valueScale: +inputs[0]
@@ -36,11 +38,11 @@ Item {
                 for (var i = input_VALUE_OFFSET; i < inputs.length; i++) {
                     var varProps = inputs[i].split("-")
                     _values.push( {                      
-                        value: varProps[1],
+                        value: varProps[0],
                         valueMax: 1,
                         numSamplesConstantMax: 0,
                         valueHistory: new Array(),
-                        label: varProps[0],
+                        label: varProps[1],
                         color: varProps[2],
                         scale: (varProps.length > 3 ? varProps[3] : 1),
                         unit: (varProps.length > 4 ? varProps[4] : valueUnit)
@@ -67,7 +69,7 @@ Item {
         var currentValueMax = 0
         for (var i = 0; i < _values.length; i++) {
 
-            var currentVal = stats.config[_values[i].value] * _values[i].scale;
+            var currentVal = config[_values[i].value] * _values[i].scale;
             _values[i].valueHistory.push(currentVal)
             _values[i].numSamplesConstantMax++;
 

examples/utilities/tools/render/stats.qml

@@ -32,38 +32,38 @@ Item {
             title: "Num Buffers"
             config: stats.config
             height: parent.evalEvenHeight()
-            parameters: "1::0:CPU-numBuffers-#00B4EF:GPU-numGPUBuffers-#1AC567"
+            parameters: "1::0:bufferCPUCount-CPU-#00B4EF:bufferGPUCount-GPU-#1AC567"
         }
         PlotPerf {
             title: "gpu::Buffer Memory"
-            config: stats.config
+            config: stats.config          
             height: parent.evalEvenHeight()
-            parameters: "1048576:Mb:1:CPU-bufferSysmemUsage-#00B4EF:GPU-bufferVidmemUsage-#1AC567"
+            parameters: "1048576:Mb:1:bufferCPUMemoryUsage-CPU-#00B4EF:bufferGPUMemoryUsage-GPU-#1AC567"
         }
 
         PlotPerf {
             title: "Num Textures"
             config: stats.config
             height: parent.evalEvenHeight()
-            parameters: "1::0:CPU-numTextures-#00B4EF:GPU-numGPUTextures-#1AC567:Frame-frameTextureCount-#E2334D"
+            parameters: "1::0:textureCPUCount-CPU-#00B4EF:textureGPUCount-GPU-#1AC567:frameTextureCount-Frame-#E2334D"
         }
         PlotPerf {
             title: "gpu::Texture Memory"
             config: stats.config
             height: parent.evalEvenHeight()
-            parameters: "1048576:Mb:1:CPU-textureSysmemUsage-#00B4EF:GPU-textureVidmemUsage-#1AC567"
+            parameters: "1048576:Mb:1:textureCPUMemoryUsage-CPU-#00B4EF:textureGPUMemoryUsage-GPU-#1AC567"
         }
         PlotPerf {
             title: "Drawcalls"
             config: stats.config
             height: parent.evalEvenHeight()
-            parameters: "1::0:frame-frameDrawcallCount-#E2334D:rate-frameDrawcallRate-#1AC567-0.001-K/s"
+            parameters: "1::0:frameDrawcallCount-frame-#E2334D:frameDrawcallRate-rate-#1AC567-0.001-K/s"
         }
         PlotPerf {
             title: "Triangles"
             config: stats.config
             height: parent.evalEvenHeight()
-            parameters: "1000:K:0:frame-frameTriangleCount-#E2334D:rate-frameTriangleRate-#1AC567-0.001-MT/s"
+            parameters: "1000:K:0:frameTriangleCount-frame-#E2334D:frameTriangleRate-rate-#1AC567-0.001-MT/s"
         }
     }
 }

libraries/gpu/src/gpu/GLBackendBuffer.cpp

@@ -17,15 +17,15 @@ GLBackend::GLBuffer::GLBuffer() :
     _buffer(0),
     _size(0)
 {
-    Buffer::_numGPUBuffers++;
+    Buffer::_bufferGPUCount++;
 }
 
 GLBackend::GLBuffer::~GLBuffer() {
     if (_buffer != 0) {
         glDeleteBuffers(1, &_buffer);
     }
-    Buffer::_bufferVideoMemoryUsage.fetch_sub(_size);
+    Buffer::_bufferGPUMemoryUsage.fetch_sub(_size);
-    Buffer::_numGPUBuffers--;
+    Buffer::_bufferGPUCount--;
 }
 
 void GLBackend::GLBuffer::setSize(GLuint size) {
@@ -33,9 +33,9 @@ void GLBackend::GLBuffer::setSize(GLuint size) {
         return;
     }
     if (size > _size) {
-        Buffer::_bufferVideoMemoryUsage.fetch_add(size - _size);
+        Buffer::_bufferGPUMemoryUsage.fetch_add(size - _size);
     } else {
-        Buffer::_bufferVideoMemoryUsage.fetch_sub(_size - size);
+        Buffer::_bufferGPUMemoryUsage.fetch_sub(_size - size);
     }
 
     _size = size;

libraries/gpu/src/gpu/GLBackendTexture.cpp

@@ -20,15 +20,15 @@ GLBackend::GLTexture::GLTexture() :
     _target(GL_TEXTURE_2D),
     _size(0)
 {
-    Texture::_numGPUTextures++;
+    Texture::_textureGPUCount++;
 }
 
 GLBackend::GLTexture::~GLTexture() {
     if (_texture != 0) {
         glDeleteTextures(1, &_texture);
     }
-    Texture::_textureVideoMemoryUsage.fetch_sub(_size);
+    Texture::_textureGPUMemoryUsage.fetch_sub(_size);
-    Texture::_numGPUTextures--;
+    Texture::_textureGPUCount--;
 }
 
 void GLBackend::GLTexture::setSize(GLuint size) {
@@ -36,9 +36,9 @@ void GLBackend::GLTexture::setSize(GLuint size) {
         return;
     }
     if (size > _size) {
-        Texture::_textureVideoMemoryUsage.fetch_add(size - _size);
+        Texture::_textureGPUMemoryUsage.fetch_add(size - _size);
     } else {
-        Texture::_textureVideoMemoryUsage.fetch_sub(_size - size);
+        Texture::_textureGPUMemoryUsage.fetch_sub(_size - size);
     }
 
     _size = size;

libraries/gpu/src/gpu/Resource.cpp

@@ -232,43 +232,35 @@ Resource::Size Resource::Sysmem::append(Size size, const Byte* bytes) {
     return 0;
 }
 
-std::atomic<int> Buffer::_numBuffers{ 0 };
+std::atomic<uint32_t> Buffer::_bufferCPUCount{ 0 };
-std::atomic<int> Buffer::_numGPUBuffers{ 0 };
+std::atomic<uint32_t> Buffer::_bufferGPUCount{ 0 };
-std::atomic<unsigned long long> Buffer::_bufferSystemMemoryUsage{ 0 };
+std::atomic<Buffer::Size> Buffer::_bufferCPUMemoryUsage{ 0 };
-std::atomic<unsigned long long> Buffer::_bufferVideoMemoryUsage{ 0 };
+std::atomic<Buffer::Size> Buffer::_bufferGPUMemoryUsage{ 0 };
 
-
+uint32_t Buffer::getBufferCPUCount() {
-int Buffer::getCurrentNumBuffers() {
+    return _bufferCPUCount.load();
-    return _numBuffers.load();
 }
 
-Buffer::Size Buffer::getCurrentSystemMemoryUsage() {
+Buffer::Size Buffer::getBufferCPUMemoryUsage() {
-    return _bufferSystemMemoryUsage.load();
+    return _bufferCPUMemoryUsage.load();
 }
 
-int Buffer::getCurrentNumGPUBuffers() {
+uint32_t Buffer::getBufferGPUCount() {
-    return _numGPUBuffers.load();
+    return _bufferGPUCount.load();
 }
 
-Buffer::Size Buffer::getCurrentVideoMemoryUsage() {
+Buffer::Size Buffer::getBufferGPUMemoryUsage() {
-    return _bufferVideoMemoryUsage.load();
+    return _bufferGPUMemoryUsage.load();
 }
 
-void Buffer::addSystemMemoryUsage(Size memorySize) {
+void Buffer::updateBufferCPUMemoryUsage(Size prevObjectSize, Size newObjectSize) {
-    _bufferSystemMemoryUsage.fetch_add(memorySize);
-}
-void Buffer::subSystemMemoryUsage(Size memorySize) {
-    _bufferSystemMemoryUsage.fetch_sub(memorySize);
-}
-
-void Buffer::updateSystemMemoryUsage(Size prevObjectSize, Size newObjectSize) {
     if (prevObjectSize == newObjectSize) {
         return;
     }
     if (prevObjectSize > newObjectSize) {
-        subSystemMemoryUsage(prevObjectSize - newObjectSize);
+        _bufferCPUMemoryUsage.fetch_sub(prevObjectSize - newObjectSize);
     } else {
-        addSystemMemoryUsage(newObjectSize - prevObjectSize);
+        _bufferCPUMemoryUsage.fetch_add(newObjectSize - prevObjectSize);
     }
 }
 
@@ -276,22 +268,22 @@ void Buffer::updateSystemMemoryUsage(Size prevObjectSize, Size newObjectSize) {
 Buffer::Buffer() :
     Resource(),
     _sysmem(new Sysmem()) {
-    _numBuffers++;
+    _bufferCPUCount++;
 
 }
 
 Buffer::Buffer(Size size, const Byte* bytes) :
     Resource(),
     _sysmem(new Sysmem(size, bytes)) {
-    _numBuffers++;
+    _bufferCPUCount++;
-    Buffer::updateSystemMemoryUsage(0, _sysmem->getSize());
+    Buffer::updateBufferCPUMemoryUsage(0, _sysmem->getSize());
 }
 
 Buffer::Buffer(const Buffer& buf) :
     Resource(),
     _sysmem(new Sysmem(buf.getSysmem())) {
-    _numBuffers++;
+    _bufferCPUCount++;
-    Buffer::updateSystemMemoryUsage(0, _sysmem->getSize());
+    Buffer::updateBufferCPUMemoryUsage(0, _sysmem->getSize());
 }
 
 Buffer& Buffer::operator=(const Buffer& buf) {
@@ -300,10 +292,10 @@ Buffer& Buffer::operator=(const Buffer& buf) {
 }
 
 Buffer::~Buffer() {
-    _numBuffers--;
+    _bufferCPUCount--;
 
     if (_sysmem) {
-        Buffer::updateSystemMemoryUsage(_sysmem->getSize(), 0);
+        Buffer::updateBufferCPUMemoryUsage(_sysmem->getSize(), 0);
         delete _sysmem;
         _sysmem = NULL;
     }
@@ -312,14 +304,14 @@ Buffer::~Buffer() {
 Buffer::Size Buffer::resize(Size size) {
     auto prevSize = editSysmem().getSize();
     auto newSize = editSysmem().resize(size);
-    Buffer::updateSystemMemoryUsage(prevSize, newSize);
+    Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
     return newSize;
 }
 
 Buffer::Size Buffer::setData(Size size, const Byte* data) {
     auto prevSize = editSysmem().getSize();
     auto newSize = editSysmem().setData(size, data);
-    Buffer::updateSystemMemoryUsage(prevSize, newSize);
+    Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
     return newSize;
 }
 
@@ -330,7 +322,7 @@ Buffer::Size Buffer::setSubData(Size offset, Size size, const Byte* data) {
 Buffer::Size Buffer::append(Size size, const Byte* data) {
     auto prevSize = editSysmem().getSize();
     auto newSize = editSysmem().append( size, data);
-    Buffer::updateSystemMemoryUsage(prevSize, newSize);
+    Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
     return newSize;
 }
 

libraries/gpu/src/gpu/Resource.h

@@ -110,21 +110,19 @@ protected:
 };
 
 class Buffer : public Resource {
-    static std::atomic<int> _numBuffers;
+    static std::atomic<uint32_t> _bufferCPUCount;
-    static std::atomic<Size> _bufferSystemMemoryUsage;
+    static std::atomic<Size> _bufferCPUMemoryUsage;
-public:
+    static void updateBufferCPUMemoryUsage(Size prevObjectSize, Size newObjectSize);
-    static std::atomic<int> _numGPUBuffers;
-    static std::atomic<Size> _bufferVideoMemoryUsage;
-private:
-    static void addSystemMemoryUsage(Size memorySize);
-    static void subSystemMemoryUsage(Size memorySize);
-    static void updateSystemMemoryUsage(Size prevObjectSize, Size newObjectSize);
 
 public:
-    static int getCurrentNumBuffers();
+    static std::atomic<uint32_t> _bufferGPUCount;
-    static Size getCurrentSystemMemoryUsage();
+    static std::atomic<Size> _bufferGPUMemoryUsage;
-    static int getCurrentNumGPUBuffers();
+
-    static Size getCurrentVideoMemoryUsage();
+public:
+    static uint32_t getBufferCPUCount();
+    static Size getBufferCPUMemoryUsage();
+    static uint32_t getBufferGPUCount();
+    static Size getBufferGPUMemoryUsage();
 
     Buffer();
     Buffer(Size size, const Byte* bytes);

libraries/gpu/src/gpu/Texture.cpp

@@ -17,63 +17,57 @@
 
 using namespace gpu;
 
-std::atomic<int> Texture::_numTextures{ 0 };
-std::atomic<int> Texture::_numGPUTextures{ 0 };
-std::atomic<unsigned long long> Texture::_textureSystemMemoryUsage{ 0 };
-std::atomic<unsigned long long> Texture::_textureVideoMemoryUsage{ 0 };
 
+std::atomic<uint32_t> Texture::_textureCPUCount{ 0 };
+std::atomic<uint32_t> Texture::_textureGPUCount{ 0 };
+std::atomic<Texture::Size> Texture::_textureCPUMemoryUsage{ 0 };
+std::atomic<Texture::Size> Texture::_textureGPUMemoryUsage{ 0 };
 
-int Texture::getCurrentNumTextures() {
+uint32_t Texture::getTextureCPUCount() {
-    return _numTextures.load();
+    return _textureCPUCount.load();
 }
 
-Texture::Size Texture::getCurrentSystemMemoryUsage() {
+Texture::Size Texture::getTextureCPUMemoryUsage() {
-    return _textureSystemMemoryUsage.load();
+    return _textureCPUMemoryUsage.load();
 }
 
-int Texture::getCurrentNumGPUTextures() {
+uint32_t Texture::getTextureGPUCount() {
-    return _numGPUTextures.load();
+    return _textureGPUCount.load();
 }
 
-Texture::Size Texture::getCurrentVideoMemoryUsage() {
+Texture::Size Texture::getTextureGPUMemoryUsage() {
-    return _textureVideoMemoryUsage.load();
+    return _textureGPUMemoryUsage.load();
 }
 
-void Texture::addSystemMemoryUsage(Size memorySize) {
+void Texture::updateTextureCPUMemoryUsage(Size prevObjectSize, Size newObjectSize) {
-    _textureSystemMemoryUsage.fetch_add(memorySize);
-}
-void Texture::subSystemMemoryUsage(Size memorySize) {
-    _textureSystemMemoryUsage.fetch_sub(memorySize);
-}
-
-void Texture::updateSystemMemoryUsage(Size prevObjectSize, Size newObjectSize) {
     if (prevObjectSize == newObjectSize) {
         return;
     }
     if (prevObjectSize > newObjectSize) {
-        subSystemMemoryUsage(prevObjectSize - newObjectSize);
+        _textureCPUMemoryUsage.fetch_sub(prevObjectSize - newObjectSize);
     } else {
-        addSystemMemoryUsage(newObjectSize - prevObjectSize);
+        _textureCPUMemoryUsage.fetch_add(newObjectSize - prevObjectSize);
     }
 }
 
+
 uint8 Texture::NUM_FACES_PER_TYPE[NUM_TYPES] = {1, 1, 1, 6};
 
 Texture::Pixels::Pixels(const Element& format, Size size, const Byte* bytes) :
     _format(format),
     _sysmem(size, bytes),
     _isGPULoaded(false) {
-    Texture::updateSystemMemoryUsage(0, _sysmem.getSize());
+    Texture::updateTextureCPUMemoryUsage(0, _sysmem.getSize());
 }
 
 Texture::Pixels::~Pixels() {
-    Texture::updateSystemMemoryUsage(_sysmem.getSize(), 0);
+    Texture::updateTextureCPUMemoryUsage(_sysmem.getSize(), 0);
 }
 
 Texture::Size Texture::Pixels::resize(Size pSize) {
     auto prevSize = _sysmem.getSize();
     auto newSize = _sysmem.resize(pSize);
-    Texture::updateSystemMemoryUsage(prevSize, newSize);
+    Texture::updateTextureCPUMemoryUsage(prevSize, newSize);
     return newSize;
 }
 
@@ -81,7 +75,7 @@ Texture::Size Texture::Pixels::setData(const Element& format, Size size, const B
     _format = format;
     auto prevSize = _sysmem.getSize();
     auto newSize = _sysmem.setData(size, bytes);
-    Texture::updateSystemMemoryUsage(prevSize, newSize);
+    Texture::updateTextureCPUMemoryUsage(prevSize, newSize);
     _isGPULoaded = false;
     return newSize;
 }
@@ -90,7 +84,7 @@ void Texture::Pixels::notifyGPULoaded() {
     _isGPULoaded = true;
     auto prevSize = _sysmem.getSize();
     auto newSize = _sysmem.resize(0);
-    Texture::updateSystemMemoryUsage(prevSize, newSize);
+    Texture::updateTextureCPUMemoryUsage(prevSize, newSize);
 }
 
 void Texture::Storage::assignTexture(Texture* texture) {
@@ -232,12 +226,12 @@ Texture* Texture::createFromStorage(Storage* storage) {
 Texture::Texture():
     Resource()
 {
-    _numTextures++;
+    _textureCPUCount++;
 }
 
 Texture::~Texture()
 {
-    _numTextures--;
+    _textureCPUCount--;
 }
 
 Texture::Size Texture::resize(Type type, const Element& texelFormat, uint16 width, uint16 height, uint16 depth, uint16 numSamples, uint16 numSlices) {
@@ -355,7 +349,7 @@ bool Texture::assignStoredMip(uint16 level, const Element& format, Size size, co
         }
     }
 
-    // THen check that the mem buffer passed make sense with its format
+    // THen check that the mem texture passed make sense with its format
     Size expectedSize = evalStoredMipSize(level, format);
     if (size == expectedSize) {
         _storage->assignMipData(level, format, size, bytes);
@@ -386,7 +380,7 @@ bool Texture::assignStoredMipFace(uint16 level, const Element& format, Size size
         }
     }
 
-    // THen check that the mem buffer passed make sense with its format
+    // THen check that the mem texture passed make sense with its format
     Size expectedSize = evalStoredMipFaceSize(level, format);
     if (size == expectedSize) {
         _storage->assignMipFaceData(level, format, size, bytes, face);

libraries/gpu/src/gpu/Texture.h

@@ -138,22 +138,19 @@ protected:
 };
 
 class Texture : public Resource {
-    static std::atomic<int> _numTextures;
+    static std::atomic<uint32_t> _textureCPUCount;
-    static std::atomic<Size> _textureSystemMemoryUsage;
+    static std::atomic<Size> _textureCPUMemoryUsage;
-public:
+    static void updateTextureCPUMemoryUsage(Size prevObjectSize, Size newObjectSize);
-    static std::atomic<int> _numGPUTextures;
-    static std::atomic<Size> _textureVideoMemoryUsage;
-private:
-    static void addSystemMemoryUsage(Size memorySize);
-    static void subSystemMemoryUsage(Size memorySize);
-    static void updateSystemMemoryUsage(Size prevObjectSize, Size newObjectSize);
 
 public:
+    static std::atomic<uint32_t> _textureGPUCount;
+    static std::atomic<Size> _textureGPUMemoryUsage;
 
-    static int getCurrentNumTextures();
+public:
-    static Size getCurrentSystemMemoryUsage();
+    static uint32_t getTextureCPUCount();
-    static int getCurrentNumGPUTextures();
+    static Size getTextureCPUMemoryUsage();
-    static Size getCurrentVideoMemoryUsage();
+    static uint32_t getTextureGPUCount();
+    static Size getTextureGPUMemoryUsage();
 
     class Usage {
     public:
@@ -475,7 +472,7 @@ typedef std::shared_ptr<Texture> TexturePointer;
 typedef std::vector< TexturePointer > Textures;
 
 
- // TODO: For now TextureView works with Buffer as a place holder for the Texture.
+ // TODO: For now TextureView works with Texture as a place holder for the Texture.
  // The overall logic should be about the same except that the Texture will be a real GL Texture under the hood
 class TextureView {
 public:

libraries/render/src/render/EngineStats.cpp

@@ -24,15 +24,21 @@ void EngineStats::run(const SceneContextPointer& sceneContext, const RenderConte
     // Update the stats
     auto config = std::static_pointer_cast<Config>(renderContext->jobConfig);
 
-    config->numBuffers = gpu::Buffer::getCurrentNumBuffers();
+    quint32 textureCPUCount{ 0 };
-    config->numGPUBuffers = gpu::Buffer::getCurrentNumGPUBuffers();
+    quint32 textureGPUCount{ 0 };
-    config->bufferSysmemUsage = gpu::Buffer::getCurrentSystemMemoryUsage();
+    qint64 textureCPUMemoryUsage{ 0 };
-    config->bufferVidmemUsage = gpu::Buffer::getCurrentVideoMemoryUsage();
+    qint64 textureGPUMemoryUsage{ 0 };
 
-    config->numTextures = gpu::Texture::getCurrentNumTextures();
+
-    config->numGPUTextures = gpu::Texture::getCurrentNumGPUTextures();
+    config->bufferCPUCount = gpu::Buffer::getBufferCPUCount();
-    config->textureSysmemUsage = gpu::Texture::getCurrentSystemMemoryUsage();
+    config->bufferGPUCount = gpu::Buffer::getBufferGPUCount();
-    config->textureVidmemUsage = gpu::Texture::getCurrentVideoMemoryUsage();
+    config->bufferCPUMemoryUsage = gpu::Buffer::getBufferCPUMemoryUsage();
+    config->bufferGPUMemoryUsage = gpu::Buffer::getBufferGPUMemoryUsage();
+
+    config->textureCPUCount = gpu::Texture::getTextureCPUCount();
+    config->textureGPUCount = gpu::Texture::getTextureGPUCount();
+    config->textureCPUMemoryUsage = gpu::Texture::getTextureCPUMemoryUsage();
+    config->textureGPUMemoryUsage = gpu::Texture::getTextureGPUMemoryUsage();
 
     gpu::ContextStats gpuStats(_gpuStats);
     renderContext->args->_context->getStats(_gpuStats);

libraries/render/src/render/EngineStats.h

@@ -24,47 +24,47 @@ namespace render {
     class EngineStatsConfig : public Job::Config{
         Q_OBJECT
 
-        Q_PROPERTY(int numBuffers MEMBER numBuffers NOTIFY dirty)
+        Q_PROPERTY(quint32 bufferCPUCount MEMBER bufferCPUCount NOTIFY dirty)
-        Q_PROPERTY(int numGPUBuffers MEMBER numGPUBuffers NOTIFY dirty)
+        Q_PROPERTY(quint32 bufferGPUCount MEMBER bufferGPUCount NOTIFY dirty)
-        Q_PROPERTY(qint64 bufferSysmemUsage MEMBER bufferSysmemUsage NOTIFY dirty)
+        Q_PROPERTY(qint64 bufferCPUMemoryUsage MEMBER bufferCPUMemoryUsage NOTIFY dirty)
-        Q_PROPERTY(qint64 bufferVidmemUsage MEMBER bufferVidmemUsage NOTIFY dirty)
+        Q_PROPERTY(qint64 bufferGPUMemoryUsage MEMBER bufferGPUMemoryUsage NOTIFY dirty)
 
-        Q_PROPERTY(int numTextures MEMBER numTextures NOTIFY dirty)
+        Q_PROPERTY(quint32 textureCPUCount MEMBER textureCPUCount NOTIFY dirty)
-        Q_PROPERTY(int numGPUTextures MEMBER numGPUTextures NOTIFY dirty)
+        Q_PROPERTY(quint32 textureGPUCount MEMBER textureGPUCount NOTIFY dirty)
-        Q_PROPERTY(qint64 textureSysmemUsage MEMBER textureSysmemUsage NOTIFY dirty)
+        Q_PROPERTY(qint64 textureCPUMemoryUsage MEMBER textureCPUMemoryUsage NOTIFY dirty)
-        Q_PROPERTY(qint64 textureVidmemUsage MEMBER textureVidmemUsage NOTIFY dirty)
+        Q_PROPERTY(qint64 textureGPUMemoryUsage MEMBER textureGPUMemoryUsage NOTIFY dirty)
 
-        Q_PROPERTY(int frameDrawcallCount MEMBER frameDrawcallCount NOTIFY dirty)
+        Q_PROPERTY(quint32 frameDrawcallCount MEMBER frameDrawcallCount NOTIFY dirty)
-        Q_PROPERTY(int frameDrawcallRate MEMBER frameDrawcallRate NOTIFY dirty)
+        Q_PROPERTY(quint32 frameDrawcallRate MEMBER frameDrawcallRate NOTIFY dirty)
 
-        Q_PROPERTY(int frameTriangleCount MEMBER frameTriangleCount NOTIFY dirty)
+        Q_PROPERTY(quint32 frameTriangleCount MEMBER frameTriangleCount NOTIFY dirty)
-        Q_PROPERTY(int frameTriangleRate MEMBER frameTriangleRate NOTIFY dirty)
+        Q_PROPERTY(quint32 frameTriangleRate MEMBER frameTriangleRate NOTIFY dirty)
 
-        Q_PROPERTY(int frameTextureCount MEMBER frameTextureCount NOTIFY dirty)
+        Q_PROPERTY(quint32 frameTextureCount MEMBER frameTextureCount NOTIFY dirty)
-        Q_PROPERTY(int frameTextureRate MEMBER frameTextureRate NOTIFY dirty)
+        Q_PROPERTY(quint32 frameTextureRate MEMBER frameTextureRate NOTIFY dirty)
 
 
     public:
         EngineStatsConfig() : Job::Config(true) {}
 
-        int numBuffers{ 0 };
+        quint32 bufferCPUCount{ 0 };
-        int numGPUBuffers{ 0 };
+        quint32 bufferGPUCount{ 0 };
-        qint64 bufferSysmemUsage{ 0 };
+        qint64 bufferCPUMemoryUsage{ 0 };
-        qint64 bufferVidmemUsage{ 0 };
+        qint64 bufferGPUMemoryUsage{ 0 };
 
-        int numTextures{ 0 };
+        quint32 textureCPUCount{ 0 };
-        int numGPUTextures{ 0 };
+        quint32 textureGPUCount{ 0 };
-        qint64 textureSysmemUsage{ 0 };
+        qint64 textureCPUMemoryUsage{ 0 };
-        qint64 textureVidmemUsage{ 0 };
+        qint64 textureGPUMemoryUsage{ 0 };
 
-        int frameDrawcallCount{ 0 };
+        quint32 frameDrawcallCount{ 0 };
-        int frameDrawcallRate{ 0 };
+        quint32 frameDrawcallRate{ 0 };
 
-        int frameTriangleCount{ 0 };
+        quint32 frameTriangleCount{ 0 };
-        int frameTriangleRate{ 0 };
+        quint32 frameTriangleRate{ 0 };
 
-        int frameTextureCount{ 0 };
+        quint32 frameTextureCount{ 0 };
-        int frameTextureRate{ 0 };
+        quint32 frameTextureRate{ 0 };
 
         void emitDirty() { emit dirty(); }