manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

added wrapping files using qt features (mainly QReadWriteLock but not only) in order to synchronize the new rendering system

This commit is contained in:
granzuglia 2016-05-06 02:11:38 +00:00
parent e278fceee8
commit 361c3a6a1d
3 changed files with 290 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
wrap/qt/qt_thread_safe_memory_info.h Normal file
View File

@ -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 <QReadWriteLock>
#include <wrap/system/memory_info.h>
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

114
wrap/qt/qt_thread_safe_mesh_attributes_multi_viewer_bo_manager.h Normal file
View File

@ -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 <wrap/qt/qt_thread_safe_memory_info.h>
#include <wrap/qt/qt_thread_safe_texture_names_container.h>
#include <wrap/gl/gl_mesh_attributes_multi_viewer_bo_manager.h>
namespace vcg
{
template<typename MESH_TYPE,typename UNIQUE_VIEW_ID_TYPE,typename GL_OPTIONS_DERIVED_TYPE = vcg::PerViewPerRenderingModalityGLOptions>
class QtThreadSafeGLMeshAttributesMultiViewerBOManager : public vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>
{
public:
QtThreadSafeGLMeshAttributesMultiViewerBOManager(MESH_TYPE& mesh,QtThreadSafeMemoryInfo& gpumeminfo,size_t perbatchtriangles)
:vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>(mesh,gpumeminfo,perbatchtriangles),_lock(QReadWriteLock::Recursive)
{
}
~QtThreadSafeGLMeshAttributesMultiViewerBOManager() {}
void meshAttributesUpdated(bool hasmeshconnectivitychanged,const RendAtts& changedrendatts)
{
QWriteLocker locker(&_lock);
vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::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<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::getPerViewInfo(viewid,mask,rendatts,opts);
}
void setPerViewInfo(UNIQUE_VIEW_ID_TYPE viewid,PRIMITIVE_MODALITY_MASK pm,const RendAtts& reqatts)
{
QWriteLocker locker(&_lock);
vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::setPerViewInfo(viewid,pm,reqatts);
}
void removeView(UNIQUE_VIEW_ID_TYPE viewid)
{
QWriteLocker locker(&_lock);
vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::removeView(viewid);
}
void draw(UNIQUE_VIEW_ID_TYPE viewid) const
{
QReadLocker locker(&_lock);
vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::draw(viewid,_textids.textId());
}
bool isBORenderingAvailable() const
{
QReadLocker locker(&_lock);
return vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::isBORenderingAvailable();
}
bool manageBuffers()
{
QWriteLocker locker(&_lock);
return vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::manageBuffers();
}
void removeAllViewsAndDeallocateBO()
{
QWriteLocker locker(&_lock);
vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::removeAllViews();
vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::manageBuffers();
}
inline vcg::QtThreadSafeTextureNamesContainer& textureIDContainer() {return _textids;}
void setTrMatrix(const vcg::Matrix44<typename MESH_TYPE::ScalarType>& tr)
{
QWriteLocker locker(&_lock);
vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::setTrMatrix(tr);
}
void setGLOptions(UNIQUE_VIEW_ID_TYPE viewid,const GL_OPTIONS_DERIVED_TYPE& opts)
{
QWriteLocker locker(&_lock);
vcg::NotThreadSafeGLMeshAttributesMultiViewerBOManager<MESH_TYPE,UNIQUE_VIEW_ID_TYPE,GL_OPTIONS_DERIVED_TYPE>::setGLOptions(viewid,opts);
}
private:
mutable QReadWriteLock _lock;
vcg::QtThreadSafeTextureNamesContainer _textids;
};
}
#endif

94
wrap/qt/qt_thread_safe_texture_names_container.h Normal file
View File

@ -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 <vector>
#include <wrap/qt/qt_thread_safe_memory_info.h>
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<GLuint>::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<GLuint>& textId() const
{
QReadLocker locker(&_lock);
return _tmid;
}
private:
std::vector<GLuint> _tmid;
mutable QReadWriteLock _lock;
};
}
#endif