diff --git a/wrap/qt/qt_thread_safe_memory_info.h b/wrap/qt/qt_thread_safe_memory_info.h new file mode 100644 index 00000000..2386b37f --- /dev/null +++ b/wrap/qt/qt_thread_safe_memory_info.h @@ -0,0 +1,82 @@ +/**************************************************************************** +* VCGLib o o * +* Visual and Computer Graphics Library o o * +* _ O _ * +* Copyright(C) 2004 \/)\/ * +* Visual Computing Lab /\/| * +* ISTI - Italian National Research Council | * +* \ * +* All rights reserved. * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * +* for more details. * +* * +****************************************************************************/ + +#ifndef __QT_THREAD_SAFE_MEMORY_INFO_H +#define __QT_THREAD_SAFE_MEMORY_INFO_H + +#include + +#include + +namespace vcg +{ + class QtThreadSafeMemoryInfo : public vcg::NotThreadSafeMemoryInfo + { + public: + QtThreadSafeMemoryInfo(std::ptrdiff_t originalmem) + :vcg::NotThreadSafeMemoryInfo(originalmem),lock(QReadWriteLock::Recursive) + { + } + + ~QtThreadSafeMemoryInfo() + { + } + + void acquiredMemory(std::ptrdiff_t mem) + { + QWriteLocker locker(&lock); + vcg::NotThreadSafeMemoryInfo::acquiredMemory(mem); + } + + std::ptrdiff_t usedMemory() const + { + QReadLocker locker(&lock); + return vcg::NotThreadSafeMemoryInfo::usedMemory(); + } + + std::ptrdiff_t currentFreeMemory() const + { + QReadLocker locker(&lock); + return vcg::NotThreadSafeMemoryInfo::currentFreeMemory(); + } + + void releasedMemory(std::ptrdiff_t mem = 0) + { + QWriteLocker locker(&lock); + vcg::NotThreadSafeMemoryInfo::releasedMemory(mem); + } + + bool isAdditionalMemoryAvailable(std::ptrdiff_t mem) + { + QReadLocker locker(&lock); + return vcg::NotThreadSafeMemoryInfo::isAdditionalMemoryAvailable(mem); + } + private: + //mutable objects can be modified from the declared const functions + //in this way we have not to modified the basic vcg::MemoryInfo interface for the logically const functions + //whose need to lock the mutex for a simple reading operation + mutable QReadWriteLock lock; + }; +} + +#endif diff --git a/wrap/qt/qt_thread_safe_mesh_attributes_multi_viewer_bo_manager.h b/wrap/qt/qt_thread_safe_mesh_attributes_multi_viewer_bo_manager.h new file mode 100644 index 00000000..02341cce --- /dev/null +++ b/wrap/qt/qt_thread_safe_mesh_attributes_multi_viewer_bo_manager.h @@ -0,0 +1,114 @@ +/*************************************************************************** +* VCGLib o o * +* Visual and Computer Graphics Library o o * +* _ O _ * +* Copyright(C) 2004-2014 \/)\/ * +* Visual Computing Lab /\/| * +* ISTI - Italian National Research Council | * +* \ * +* All rights reserved. * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * +* for more details. * +* * +****************************************************************************/ + +#ifndef __QT_THREAD_SAFE_RENDERER_H +#define __QT_THREAD_SAFE_RENDERER_H + + +#include +#include +#include + +namespace vcg +{ + template + class QtThreadSafeGLMeshAttributesMultiViewerBOManager : public vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager + { + public: + QtThreadSafeGLMeshAttributesMultiViewerBOManager(MESH_TYPE& mesh,QtThreadSafeMemoryInfo& gpumeminfo,size_t perbatchtriangles) + :vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager(mesh,gpumeminfo,perbatchtriangles),_lock(QReadWriteLock::Recursive) + { + } + + ~QtThreadSafeGLMeshAttributesMultiViewerBOManager() {} + + void meshAttributesUpdated(bool hasmeshconnectivitychanged,const RendAtts& changedrendatts) + { + QWriteLocker locker(&_lock); + vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::meshAttributesUpdated(hasmeshconnectivitychanged,changedrendatts); + } + + bool getPerViewInfo(UNIQUE_VIEW_ID_TYPE viewid,PRIMITIVE_MODALITY_MASK* mask,RendAtts* rendatts,vcg::PerViewPerRenderingModalityGLOptions* opts) + { + QReadLocker locker(&_lock); + return vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::getPerViewInfo(viewid,mask,rendatts,opts); + } + + void setPerViewInfo(UNIQUE_VIEW_ID_TYPE viewid,PRIMITIVE_MODALITY_MASK pm,const RendAtts& reqatts) + { + QWriteLocker locker(&_lock); + vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::setPerViewInfo(viewid,pm,reqatts); + } + + void removeView(UNIQUE_VIEW_ID_TYPE viewid) + { + QWriteLocker locker(&_lock); + vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::removeView(viewid); + } + + void draw(UNIQUE_VIEW_ID_TYPE viewid) const + { + QReadLocker locker(&_lock); + vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::draw(viewid,_textids.textId()); + } + + bool isBORenderingAvailable() const + { + QReadLocker locker(&_lock); + return vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::isBORenderingAvailable(); + } + + bool manageBuffers() + { + QWriteLocker locker(&_lock); + return vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::manageBuffers(); + } + + void removeAllViewsAndDeallocateBO() + { + QWriteLocker locker(&_lock); + vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::removeAllViews(); + vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::manageBuffers(); + } + + inline vcg::QtThreadSafeTextureNamesContainer& textureIDContainer() {return _textids;} + + void setTrMatrix(const vcg::Matrix44& tr) + { + QWriteLocker locker(&_lock); + vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::setTrMatrix(tr); + } + + void setGLOptions(UNIQUE_VIEW_ID_TYPE viewid,const GL_OPTIONS_DERIVED_TYPE& opts) + { + QWriteLocker locker(&_lock); + vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager::setGLOptions(viewid,opts); + } + + private: + mutable QReadWriteLock _lock; + vcg::QtThreadSafeTextureNamesContainer _textids; + }; +} + +#endif diff --git a/wrap/qt/qt_thread_safe_texture_names_container.h b/wrap/qt/qt_thread_safe_texture_names_container.h new file mode 100644 index 00000000..bf78d033 --- /dev/null +++ b/wrap/qt/qt_thread_safe_texture_names_container.h @@ -0,0 +1,94 @@ +/*************************************************************************** +* VCGLib o o * +* Visual and Computer Graphics Library o o * +* _ O _ * +* Copyright(C) 2004-2014 \/)\/ * +* Visual Computing Lab /\/| * +* ISTI - Italian National Research Council | * +* \ * +* All rights reserved. * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * +* for more details. * +* * +****************************************************************************/ + +#ifndef __QT_THREAD_SAFE_TEXTURE_NAMES_CONTAINER_H +#define __QT_THREAD_SAFE_TEXTURE_NAMES_CONTAINER_H + +#include +#include + +namespace vcg +{ + struct QtThreadSafeTextureNamesContainer + { + QtThreadSafeTextureNamesContainer() + :_tmid(),_lock(QReadWriteLock::Recursive) + { + _tmid.push_back(0); + } + + ~QtThreadSafeTextureNamesContainer() + { + } + + void push_back(GLuint textid) + { + QWriteLocker locker(&_lock); + _tmid.push_back(textid); + } + + GLuint remove(GLuint textid) + { + QWriteLocker locker(&_lock); + std::vector::iterator it = std::find(_tmid.begin(),_tmid.end(),textid); + GLuint res = 0; + if (it != _tmid.end()) + { + res = *it; + _tmid.erase(it); + } + return res; + } + + size_t size() const + { + QReadLocker locker(&_lock); + return _tmid.size(); + } + + bool empty() const + { + QReadLocker locker(&_lock); + return _tmid.empty(); + } + + GLuint operator[](size_t ii) const + { + QReadLocker locker(&_lock); + return _tmid[ii]; + }; + + ////WARNING! By itself when i exit from the function scope the returned vector is NOT thread-safe!!!! + ////BUT after i use it in another function that is thread-safe again, so it should not be problems...maybe... + const std::vector& textId() const + { + QReadLocker locker(&_lock); + return _tmid; + } + private: + std::vector _tmid; + mutable QReadWriteLock _lock; + }; +} + +#endif \ No newline at end of file