Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-17 08:56:36 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Cleaning up for review

Browse source
This commit is contained in:
samcake 2016-03-25 18:38:52 -07:00
parent 5190878db2
commit 7361304084
10 changed files with 137 additions and 148 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
examples/utilities/tools/render/PlotPerf.qml
View file

@ -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++;

14
examples/utilities/tools/render/stats.qml
View file

@ -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"
}
}
}

10
libraries/gpu/src/gpu/GLBackendBuffer.cpp
View file

@ -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::_numGPUBuffers--;
Buffer::_bufferGPUMemoryUsage.fetch_sub(_size);
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;

10
libraries/gpu/src/gpu/GLBackendTexture.cpp
View file

@ -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::_numGPUTextures--;
Texture::_textureGPUMemoryUsage.fetch_sub(_size);
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;

58
libraries/gpu/src/gpu/Resource.cpp
View file

@ -232,43 +232,35 @@ Resource::Size Resource::Sysmem::append(Size size, const Byte* bytes) {
return 0;
}
std::atomic<int> Buffer::_numBuffers{ 0 };
std::atomic<int> Buffer::_numGPUBuffers{ 0 };
std::atomic<unsigned long long> Buffer::_bufferSystemMemoryUsage{ 0 };
std::atomic<unsigned long long> Buffer::_bufferVideoMemoryUsage{ 0 };
std::atomic<uint32_t> Buffer::_bufferCPUCount{ 0 };
std::atomic<uint32_t> Buffer::_bufferGPUCount{ 0 };
std::atomic<Buffer::Size> Buffer::_bufferCPUMemoryUsage{ 0 };
std::atomic<Buffer::Size> Buffer::_bufferGPUMemoryUsage{ 0 };
int Buffer::getCurrentNumBuffers() {
return _numBuffers.load();
uint32_t Buffer::getBufferCPUCount() {
return _bufferCPUCount.load();
}
Buffer::Size Buffer::getCurrentSystemMemoryUsage() {
return _bufferSystemMemoryUsage.load();
Buffer::Size Buffer::getBufferCPUMemoryUsage() {
return _bufferCPUMemoryUsage.load();
}
int Buffer::getCurrentNumGPUBuffers() {
return _numGPUBuffers.load();
uint32_t Buffer::getBufferGPUCount() {
return _bufferGPUCount.load();
}
Buffer::Size Buffer::getCurrentVideoMemoryUsage() {
return _bufferVideoMemoryUsage.load();
Buffer::Size Buffer::getBufferGPUMemoryUsage() {
return _bufferGPUMemoryUsage.load();
}
void Buffer::addSystemMemoryUsage(Size memorySize) {
_bufferSystemMemoryUsage.fetch_add(memorySize);
}
void Buffer::subSystemMemoryUsage(Size memorySize) {
_bufferSystemMemoryUsage.fetch_sub(memorySize);
}
void Buffer::updateSystemMemoryUsage(Size prevObjectSize, Size newObjectSize) {
void Buffer::updateBufferCPUMemoryUsage(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++;
Buffer::updateSystemMemoryUsage(0, _sysmem->getSize());
_bufferCPUCount++;
Buffer::updateBufferCPUMemoryUsage(0, _sysmem->getSize());
}
Buffer::Buffer(const Buffer& buf) :
Resource(),
_sysmem(new Sysmem(buf.getSysmem())) {
_numBuffers++;
Buffer::updateSystemMemoryUsage(0, _sysmem->getSize());
_bufferCPUCount++;
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;
}

24
libraries/gpu/src/gpu/Resource.h
View file

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

56
libraries/gpu/src/gpu/Texture.cpp
View file

@ -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() {
return _numTextures.load();
uint32_t Texture::getTextureCPUCount() {
return _textureCPUCount.load();
}
Texture::Size Texture::getCurrentSystemMemoryUsage() {
return _textureSystemMemoryUsage.load();
Texture::Size Texture::getTextureCPUMemoryUsage() {
return _textureCPUMemoryUsage.load();
}
int Texture::getCurrentNumGPUTextures() {
return _numGPUTextures.load();
uint32_t Texture::getTextureGPUCount() {
return _textureGPUCount.load();
}
Texture::Size Texture::getCurrentVideoMemoryUsage() {
return _textureVideoMemoryUsage.load();
Texture::Size Texture::getTextureGPUMemoryUsage() {
return _textureGPUMemoryUsage.load();
}
void Texture::addSystemMemoryUsage(Size memorySize) {
_textureSystemMemoryUsage.fetch_add(memorySize);
}
void Texture::subSystemMemoryUsage(Size memorySize) {
_textureSystemMemoryUsage.fetch_sub(memorySize);
}
void Texture::updateSystemMemoryUsage(Size prevObjectSize, Size newObjectSize) {
void Texture::updateTextureCPUMemoryUsage(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);

25
libraries/gpu/src/gpu/Texture.h
View file

@ -138,22 +138,19 @@ protected:
};
class Texture : public Resource {
static std::atomic<int> _numTextures;
static std::atomic<Size> _textureSystemMemoryUsage;
public:
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);
static std::atomic<uint32_t> _textureCPUCount;
static std::atomic<Size> _textureCPUMemoryUsage;
static void updateTextureCPUMemoryUsage(Size prevObjectSize, Size newObjectSize);
public:
static std::atomic<uint32_t> _textureGPUCount;
static std::atomic<Size> _textureGPUMemoryUsage;
static int getCurrentNumTextures();
static Size getCurrentSystemMemoryUsage();
static int getCurrentNumGPUTextures();
static Size getCurrentVideoMemoryUsage();
public:
static uint32_t getTextureCPUCount();
static Size getTextureCPUMemoryUsage();
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:

22
libraries/render/src/render/EngineStats.cpp
View file

@ -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();
config->numGPUBuffers = gpu::Buffer::getCurrentNumGPUBuffers();
config->bufferSysmemUsage = gpu::Buffer::getCurrentSystemMemoryUsage();
config->bufferVidmemUsage = gpu::Buffer::getCurrentVideoMemoryUsage();
quint32 textureCPUCount{ 0 };
quint32 textureGPUCount{ 0 };
qint64 textureCPUMemoryUsage{ 0 };
qint64 textureGPUMemoryUsage{ 0 };
config->numTextures = gpu::Texture::getCurrentNumTextures();
config->numGPUTextures = gpu::Texture::getCurrentNumGPUTextures();
config->textureSysmemUsage = gpu::Texture::getCurrentSystemMemoryUsage();
config->textureVidmemUsage = gpu::Texture::getCurrentVideoMemoryUsage();
config->bufferCPUCount = gpu::Buffer::getBufferCPUCount();
config->bufferGPUCount = gpu::Buffer::getBufferGPUCount();
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);

56
libraries/render/src/render/EngineStats.h
View file

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