Commit 443b9e63 authored by Pierre Kraemer's avatar Pierre Kraemer
Browse files

grosse mise a jour des Containers, AttributeHandler, etc..

parent 54d09f40
......@@ -536,44 +536,27 @@ void MyGlutWin::myKeyboard(unsigned char keycode, int x, int y)
case 'd':
{
GLint t1 = glutGet(GLUT_ELAPSED_TIME);
myMap.removeAttribute<PFP::VEC3>(normal) ;
myMap.removeAttribute<PFP::VEC3>(laplacian) ;
AttributeHandler<PFP::VEC3> newPosition = myMap.addAttribute<PFP::VEC3>(FACE_ORBIT, "position") ;
Algo::Geometry::computeCentroidFaces<PFP>(myMap, position, newPosition) ;
std::vector<std::string> attrNames ;
for(unsigned int i = 0; i < NB_ORBITS; ++i)
{
AttributeContainer& cont = myMap.getAttributeContainer(i) ;
std::cout << "container " << i << " (" << cont.getNbAttributes() << ") :" << std::endl ;
cont.getAttributesNames(attrNames) ;
for(unsigned int j = 0; j < attrNames.size(); ++j)
std::cout << " -> " << attrNames[j] << std::endl ;
}
std::cout << std::endl ;
GLint t1 = glutGet(GLUT_ELAPSED_TIME);
Algo::Modelisation::computeDual<PFP>(myMap) ;
for(unsigned int i = 0; i < NB_ORBITS; ++i)
{
AttributeContainer& cont = myMap.getAttributeContainer(i) ;
std::cout << "container " << i << " (" << cont.getNbAttributes() << ") :" << std::endl ;
cont.getAttributesNames(attrNames) ;
for(unsigned int j = 0; j < attrNames.size(); ++j)
std::cout << " -> " << attrNames[j] << std::endl ;
}
GLint t2 = glutGet(GLUT_ELAPSED_TIME);
GLfloat seconds = (t2 - t1) / 1000.0f;
std::cout << "dual computation: "<< seconds << "sec" << std::endl;
newPosition = myMap.getAttribute<PFP::VEC3>(FACE_ORBIT, "position") ;
myMap.removeAttribute<PFP::VEC3>(newPosition) ;
position = myMap.getAttribute<PFP::VEC3>(VERTEX_ORBIT, "position") ;
normal = myMap.addAttribute<PFP::VEC3>(VERTEX_ORBIT, "normal") ;
laplacian = myMap.addAttribute<PFP::VEC3>(VERTEX_ORBIT, "laplacian") ;
GLint t2 = glutGet(GLUT_ELAPSED_TIME);
GLfloat seconds = (t2 - t1) / 1000.0f;
std::cout << "dual computation: "<< seconds << "sec" << std::endl;
t1 = glutGet(GLUT_ELAPSED_TIME);
updateVBOprimitives(Algo::Render::VBO::TRIANGLES | Algo::Render::VBO::LINES | Algo::Render::VBO::POINTS) ;
updateVBOdata(Algo::Render::VBO::POSITIONS | Algo::Render::VBO::NORMALS) ;
......@@ -743,6 +726,7 @@ int main(int argc, char** argv)
std::cerr << "could not import " << filename << std::endl ;
return 1 ;
}
mgw->position = myMap.getAttribute<PFP::VEC3>(VERTEX_ORBIT, attrNames[0]) ;
GLint t2 = glutGet(GLUT_ELAPSED_TIME) ;
GLfloat seconds = (t2 - t1) / 1000.0f ;
......
......@@ -211,7 +211,7 @@ public:
AttributeHandler_IHM() : AttributeHandler<T>()
{}
AttributeHandler_IHM(GenericMap* m, unsigned int idAttr) : AttributeHandler<T>(m, idAttr)
AttributeHandler_IHM(GenericMap* m, unsigned int orbit, unsigned int index) : AttributeHandler<T>(m, orbit, index)
{}
AttributeMultiVector<T>* getDataVector() const
......
......@@ -54,14 +54,14 @@ AttributeHandler_IHM<T> ImplicitHierarchicalMap::addAttribute(unsigned int orbit
amv[i] = EMBNULL ;
}
return AttributeHandler_IHM<T>(this, h.id()) ;
return AttributeHandler_IHM<T>(this, h.getOrbit(), h.getIndex()) ;
}
template <typename T>
AttributeHandler_IHM<T> ImplicitHierarchicalMap::getAttribute(unsigned int orbit, const std::string& nameAttr)
{
AttributeHandler<T> h = Map2::getAttribute<T>(orbit, nameAttr) ;
return AttributeHandler_IHM<T>(this, h.id()) ;
return AttributeHandler_IHM<T>(this, h.getOrbit(), h.getIndex()) ;
}
/***************************************************
......@@ -344,7 +344,7 @@ T& AttributeHandler_IHM<T>::operator[](Dart d)
assert(m->m_dartLevel[d] <= m->m_curLevel || !"Access to a dart introduced after current level") ;
assert(m->vertexInsertionLevel(d) <= m->m_curLevel || !"Access to the embedding of a vertex inserted after current level") ;
unsigned int orbit = AttributeContainer::orbitAttr(this->m_id) ;
unsigned int orbit = this->m_orbit ;
unsigned int nbSteps = m->m_curLevel - m->vertexInsertionLevel(d) ;
unsigned int index = m->getEmbedding(d, orbit) ;
......@@ -381,7 +381,7 @@ const T& AttributeHandler_IHM<T>::operator[](Dart d) const
assert(m->m_dartLevel[d] <= m->m_curLevel || !"Access to a dart introduced after current level") ;
assert(m->vertexInsertionLevel(d) <= m->m_curLevel || !"Access to the embedding of a vertex inserted after current level") ;
unsigned int orbit = AttributeContainer::orbitAttr(this->m_id) ;
unsigned int orbit = this->m_orbit ;
unsigned int nbSteps = m->m_curLevel - m->vertexInsertionLevel(d) ;
unsigned int index = m->getEmbedding(d, orbit) ;
......
......@@ -444,7 +444,7 @@ void computeDual(typename PFP::MAP& map, const FunctorSelect& selected)
for(Dart d = map.begin(); d != map.end(); map.next(d))
{
Dart dd = map.alpha1(d) ;
Dart dd = map.alpha_1(d) ;
new_phi1[d] = dd ;
new_phi_1[dd] = d ;
}
......@@ -469,7 +469,6 @@ template <typename PFP, typename EMBV, typename EMB>
void quadranguleFacesVolume(typename PFP::MAP& map, EMBV& attributs, const FunctorSelect& selected)
{
}
template <typename PFP, typename EMBV, typename EMB>
......
......@@ -36,8 +36,6 @@ namespace Render
namespace VBO
{
template <typename ATTR_HANDLER>
void MapRender_VBO::updateData(int upType, const ATTR_HANDLER& attrib, ConvertAttrib* conv)
{
......@@ -64,8 +62,6 @@ void MapRender_VBO::updateData(int upType, const ATTR_HANDLER& attrib, ConvertAt
fillBufferDirect(indexVBO, attrib) ;
}
template <typename ATTR_HANDLER>
void MapRender_VBO::fillBufferDirect(unsigned int indexVBO, const ATTR_HANDLER& attrib)
{
......@@ -73,7 +69,7 @@ void MapRender_VBO::fillBufferDirect(unsigned int indexVBO, const ATTR_HANDLER&
std::vector<void*> addr;
unsigned int byteTableSize;
unsigned int nbb = mv->getStartAddresses(addr, byteTableSize);
unsigned int nbb = mv->getBlocksPointers(addr, byteTableSize);
glBindBufferARB(GL_ARRAY_BUFFER, m_VBOBuffers[indexVBO]);
glBufferDataARB(GL_ARRAY_BUFFER, nbb * byteTableSize, 0, GL_STREAM_DRAW);
......@@ -88,7 +84,6 @@ void MapRender_VBO::fillBufferDirect(unsigned int indexVBO, const ATTR_HANDLER&
}
}
template <typename ATTR_HANDLER>
void MapRender_VBO::fillBufferConvert(unsigned int indexVBO, const ATTR_HANDLER& attrib, ConvertAttrib* conv)
{
......@@ -96,10 +91,10 @@ void MapRender_VBO::fillBufferConvert(unsigned int indexVBO, const ATTR_HANDLER&
std::vector<void*> addr;
unsigned int byteTableSize;
unsigned int nbb = mv->getStartAddresses(addr, byteTableSize);
unsigned int nbb = mv->getBlocksPointers(addr, byteTableSize);
// alloue la memoire pour le buffer et initialise le conv
conv->reserve(mv->BlockSize());
conv->reserve(mv->getBlockSize());
// bind buffer to update
glBindBufferARB(GL_ARRAY_BUFFER, m_VBOBuffers[indexVBO]);
......@@ -338,9 +333,6 @@ void MapRender_VBO::initPrimitives(typename PFP::MAP& map, const FunctorSelect&
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER, size*sizeof(GLuint), &(tableIndices[0]), GL_STREAM_DRAW);
}
template<typename PFP>
void MapRender_VBO::initFlatTriangles(typename PFP::MAP& map, const FunctorSelect& good)
{
......@@ -393,13 +385,8 @@ void MapRender_VBO::initFlatTriangles(typename PFP::MAP& map, const FunctorSelec
//creating VBO for flat
glBindBufferARB(GL_ARRAY_BUFFER, m_VBOBuffers[FLAT_BUFFER]);
glBufferDataARB(GL_ARRAY_BUFFER, tableFlat.size() * sizeof(Geom::Vec3f), (char*)(&(tableFlat[0])), GL_STREAM_DRAW);
}
} // namespace VBO
} // namespace Render
......
This diff is collapsed.
......@@ -30,278 +30,381 @@
namespace CGoGN
{
///////////////////////////
// GESTION DES ATTRIBUTS
///////////////////////////
inline unsigned int AttributeContainer::getOrbit()
{
return m_orbit ;
}
template <typename T>
unsigned int AttributeContainer::addAttribute(const std::string& attribName)
inline void AttributeContainer::setOrbit(unsigned int orbit)
{
m_orbit = orbit ;
for(unsigned int i = 0; i < m_tableAttribs.size(); ++i)
{
if (m_tableAttribs[i] != NULL)
m_tableAttribs[i]->setOrbit(orbit);
}
}
inline void AttributeContainer::setRegistry(std::map< std::string, RegisteredBaseAttribute* >* re)
{
std::string nametype = nameOfType(T());
m_attributes_registry_map = re;
}
/**************************************
* BASIC FEATURES *
**************************************/
template <typename T>
AttributeMultiVector<T>* AttributeContainer::addAttribute(const std::string& attribName)
{
// first check if attribute already exist
unsigned int index ;
if (attribName != "")
{
MapNameId::iterator it = m_attribNameMap.find(attribName);
if (it != m_attribNameMap.end())
return UNKNOWN;
index = getAttributeIndex(attribName) ;
if (index != UNKNOWN)
return NULL ;
}
// new attribut
AttributeMultiVector<T>* amv = new AttributeMultiVector<T>(attribName, nametype);
// create the new attribute
std::string typeName = nameOfType(T()) ;
AttributeMultiVector<T>* amv = new AttributeMultiVector<T>(attribName, typeName) ;
unsigned int idxAttrib ;
if(!m_freeIndices.empty())
{
idxAttrib = m_freeIndices.back() ;
index = m_freeIndices.back() ;
m_freeIndices.pop_back() ;
m_tableAttribs[idxAttrib] = amv ;
m_tableAttribs[index] = amv ;
}
else
{
idxAttrib = m_tableAttribs.size();
m_tableAttribs.push_back(amv);
index = m_tableAttribs.size() ;
m_tableAttribs.push_back(amv) ;
}
// add it in the map
if (attribName == "") // if no name, generate a fake name
amv->setOrbit(m_orbit) ;
amv->setIndex(index) ;
// generate a name for the attribute if no one was given
if (attribName == "")
{
std::stringstream ss;
ss << "unknown" << m_nbUnknown++;
m_attribNameMap.insert(std::pair<std::string, unsigned int>(ss.str(), idxAttrib));
amv->setName(ss.str());
std::stringstream ss ;
ss << "unknown" << m_nbUnknown++ ;
amv->setName(ss.str()) ;
}
else
m_attribNameMap.insert(std::pair<std::string, unsigned int>(attribName, idxAttrib));
// maj taille d'une ligne
m_lineCost += sizeof(T);
// resize the new attribute container to have same size than others
int nbb = m_holesBlocks.size();
amv->setNbBlocks(nbb);
// update the memory cost of a line
m_lineCost += sizeof(T) ;
m_nbAttributes++;
// resize the new attribute so that it has the same size than others
amv->setNbBlocks(m_holesBlocks.size()) ;
m_nbAttributes++ ;
return idxAttrib;
return amv ;
}
template <typename T>
unsigned int AttributeContainer::addAttribute(const std::string& attribName, const std::string& nametype, unsigned int idxAttrib)
void AttributeContainer::addAttribute(const std::string& attribName, const std::string& nametype, unsigned int index)
{
// first check if attribute already exist
if (attribName != "")
{
MapNameId::iterator it = m_attribNameMap.find(attribName);
if (it != m_attribNameMap.end())
return UNKNOWN;
unsigned int i = getAttributeIndex(attribName) ;
if (i != UNKNOWN)
return ;
}
// new attribut
// create the new attribute
AttributeMultiVector<T>* amv = new AttributeMultiVector<T>(attribName, nametype);
// add it to table of attribut_manager
m_tableAttribs[idxAttrib] = amv;
// add it in the map
if (attribName == "") // if no name, generate a fake name
m_tableAttribs[index] = amv;
amv->setOrbit(m_orbit) ;
amv->setIndex(index) ;
// generate a name for the attribute if no one was given
if (attribName == "")
{
std::stringstream ss;
ss << "unknown" << m_nbUnknown++;
m_attribNameMap.insert(std::pair<std::string, unsigned int>(ss.str(), idxAttrib));
amv->setName(ss.str());
}
else
m_attribNameMap.insert(std::pair<std::string, unsigned int>(attribName, idxAttrib));
// maj taille d'une ligne
m_lineCost += sizeof(T);
// update the memory cost of a line
m_lineCost += sizeof(T) ;
// resize the new attribute container to have same size than others
int nbb = m_holesBlocks.size();
amv->setNbBlocks(nbb);
// resize the new attribute so that it has the same size than others
amv->setNbBlocks(m_holesBlocks.size()) ;
m_nbAttributes++;
return idxAttrib;
}
inline unsigned int AttributeContainer::getNbAttributes()
/**************************************
* INFO ABOUT THE CONTAINER *
**************************************/
inline unsigned int AttributeContainer::getNbAttributes() const
{
return m_nbAttributes;
}
///////////////////////////
// ACCES AUX DONNEES
///////////////////////////
inline unsigned int AttributeContainer::size() const
{
return m_size;
}
template <typename T>
T& AttributeContainer::getData(unsigned int codeAttrib, unsigned int eltIdx)
inline unsigned int AttributeContainer::capacity() const
{
assert(eltIdx < m_maxSize || !"Attribut non existant (indice trop grand)");
assert(m_holesBlocks[eltIdx/_BLOCKSIZE_]->used(eltIdx%_BLOCKSIZE_) || !"Attribut non existant");
assert((m_tableAttribs[codeAttrib] != NULL) || !"Attribut detruit");
return m_holesBlocks.size() * _BLOCKSIZE_;
}
AttributeMultiVector<T>* atm = dynamic_cast< AttributeMultiVector<T>* >(m_tableAttribs[codeAttrib]);
assert((atm != NULL) || !"type attribut non concordant");
inline unsigned int AttributeContainer::memoryTotalSize() const
{
return _BLOCKSIZE_ * (m_holesBlocks.size() * m_lineCost + 8);
}
return atm->operator[](eltIdx);
inline bool AttributeContainer::used(unsigned int index) const
{
return m_holesBlocks[index / _BLOCKSIZE_]->used(index % _BLOCKSIZE_);
}
template <typename T>
const T& AttributeContainer::getData(unsigned int codeAttrib, unsigned int eltIdx) const
/**************************************
* CONTAINER TRAVERSAL *
**************************************/
inline unsigned int AttributeContainer::begin() const
{
assert(eltIdx < m_maxSize || !"Attribut non existant (indice trop grand)");
assert(m_holesBlocks[eltIdx/_BLOCKSIZE_]->used(eltIdx%_BLOCKSIZE_) || !"Attribut non existant");
assert((m_tableAttribs[codeAttrib] != NULL) || !"Attribut detruit");
unsigned int it = 0;
while ((it < m_maxSize) && (!used(it)))
++it;
return it;
}
AttributeMultiVector<T>* atm = dynamic_cast< AttributeMultiVector<T>* >(m_tableAttribs[codeAttrib]);
assert((atm != NULL) || !"type attribut non concordant");
inline unsigned int AttributeContainer::end() const
{
return m_maxSize;
}
return atm->operator[](eltIdx);
inline void AttributeContainer::next(unsigned int &it) const
{
do
{
++it;
} while ((it < m_maxSize) && (!used(it)));
}
template <typename T>
void AttributeContainer::setData(unsigned int codeAttrib, unsigned int eltIdx, const T& data)
/**************************************
* LINES MANAGEMENT *
**************************************/
inline void AttributeContainer::initLine(unsigned int index)
{
assert(eltIdx < m_maxSize || !"Attribut non existant (indice trop grand)");
assert(m_holesBlocks[eltIdx/_BLOCKSIZE_]->used(eltIdx%_BLOCKSIZE_) || !"Attribut non existant");
assert((m_tableAttribs[codeAttrib] != NULL) || !"Attribut detruit");
for(unsigned int i = 0; i < m_tableAttribs.size(); ++i)
{
if (m_tableAttribs[i] != NULL)
m_tableAttribs[i]->initElt(index);
}
}
AttributeMultiVector<T>* atm = dynamic_cast< AttributeMultiVector<T>* >(m_tableAttribs[codeAttrib]);
assert((atm != NULL) || !"type attribut non concordant");
inline void AttributeContainer::copyLine(unsigned int dstIndex, unsigned int srcIndex)
{
for(unsigned int i = 0; i < m_tableAttribs.size(); ++i)
{
if (m_tableAttribs[i] != NULL)
m_tableAttribs[i]->copyElt(dstIndex, srcIndex);
}
}
atm->operator[](eltIdx) = data;
inline void AttributeContainer::refLine(unsigned int index)
{
m_holesBlocks[index / _BLOCKSIZE_]->ref(index % _BLOCKSIZE_);
}
//template <typename T>
//unsigned int AttributeContainer::insertLineWidthData(unsigned int codeAttrib,const T& data)
//{
// unsigned int it = insertLine();
// setData<T>(codeAttrib, it, data);
// return it;
//}
inline bool AttributeContainer::unrefLine(unsigned int index)
{
if (m_holesBlocks[index / _BLOCKSIZE_]->unref(index % _BLOCKSIZE_))
{
--m_size;
return true;
}
return false;
}
template<typename T>
AttributeMultiVector<T>& AttributeContainer::getDataVector(unsigned int codeAttrib)
inline unsigned int AttributeContainer::getNbRefs(unsigned int index)
{
assert((codeAttrib < m_tableAttribs.size()) || !"Attribut inexistant");
assert((m_tableAttribs[codeAttrib] != NULL) || !"Attribut detruit");
unsigned int bi = index / _BLOCKSIZE_;
unsigned int j = index % _BLOCKSIZE_;
AttributeMultiVector<T>* atm = dynamic_cast< AttributeMultiVector<T>* >(m_tableAttribs[codeAttrib]);
assert((atm != NULL) || !"type attribut non concordant");
return *atm;
return m_holesBlocks[bi]->nbRefs(j);
}
template<typename T>
bool AttributeContainer::getAttributesVector(const std::string& attribName, AttributeMultiVector<T>** ptr)
inline void AttributeContainer::setNbRefs(unsigned int index, unsigned int nb)
{
MapNameId::iterator it = m_attribNameMap.find(attribName);
if (it == m_attribNameMap.end())
return false;
int codeAttrib = it->second;
m_holesBlocks[index / _BLOCKSIZE_]->setNbRefs(index % _BLOCKSIZE_, nb);
}
if (m_tableAttribs[codeAttrib] == NULL)
return false;
/**************************************
* ATTRIBUTES MANAGEMENT *
**************************************/
AttributeMultiVector<T>* atm = dynamic_cast< AttributeMultiVector<T>* >(m_tableAttribs[codeAttrib]);
if (atm == NULL)
return false;
inline bool AttributeContainer::copyAttribute(unsigned int index_dst, unsigned int index_src)
{
return m_tableAttribs[index_dst]->copy(m_tableAttribs[index_src]);
}
*ptr = atm;
return true;
inline bool AttributeContainer::swapAttributes(unsigned int index1, unsigned int index2)
{
return m_tableAttribs[index1]->swap(m_tableAttribs[index2]);
}
///////////////////////////
// ADRESSES MEMOIRES
///////////////////////////
/**************************************
* ATTRIBUTES DATA ACCESS *
**************************************/
template <typename T>
unsigned int AttributeContainer::getAddresses(unsigned int attr, std::vector<T*>& vect_adr)
AttributeMultiVector<T>& AttributeContainer::getDataVector(unsigned int attrIndex)
{
AttributeMultiVector<T>* atm = dynamic_cast< AttributeMultiVector<T>* >(m_tableAttribs[attr]);
assert((atm != NULL) || !"type attribut non concordant");
return atm->getStartAddresses(vect_adr);
assert(attrIndex < m_tableAttribs.size() || !"getDataVector: attribute index out of bounds");
assert(m_tableAttribs[attrIndex] != NULL || !"getDataVector: attribute does not exist");
AttributeMultiVector<T>* atm = dynamic_cast<AttributeMultiVector<T>*>(m_tableAttribs[attrIndex]);
assert((atm != NULL) || !"getDataVector: wrong type");
return *atm;
}
//////////////////////////////
// Enregistrement attributs
//////////////////////////////
inline AttributeMultiVectorGen& AttributeContainer::getVirtualDataVector(unsigned int attrIndex)
{
return *(m_tableAttribs[attrIndex]);
}
//// INLINED FUNCTIONS
inline bool AttributeContainer::used(unsigned int eltIdx) const
template <typename T>
AttributeMultiVector<T>& AttributeContainer::getDataVector(const std::string& attribName)
{
return m_holesBlocks[ eltIdx / _BLOCKSIZE_ ]->used( eltIdx % _BLOCKSIZE_ );
unsigned int index = getAttributeIndex(attribName) ;
assert(index != UNKNOWN) ;
AttributeMultiVector<T>* atm = dynamic_cast<AttributeMultiVector<T>*>(m_tableAttribs[index]);
assert((atm != NULL) || !"getDataVector: wrong type");
return *atm;
}
inline void AttributeContainer::setRegistry(std::map< std::string, RegisteredBaseAttribute* >* re)
inline AttributeMultiVectorGen& AttributeContainer::getVirtualDataVector(const std::string& attribName)
{
m_attributes_registry_map = re;
unsigned int index = getAttributeIndex(attribName) ;
assert(index != UNKNOWN) ;
return *(m_tableAttribs[index]);
}