Something went wrong. Try again.
OpenMW is an open implementation of the Morrowind engine
Something went wrong. Try again.
76 kB · 2065 lines
C++
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066// clang-format off/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield * * This library is open source and may be redistributed and/or modified under * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * (at your option) any later version. The full license is in LICENSE file * included with this distribution, and on the openscenegraph.org website. * * This library 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 * OpenSceneGraph Public License for more details.*/
/* Modified for OpenMW */
#include "optimizer.hpp"
#include <osg/Transform>#include <osg/MatrixTransform>#include <osg/PositionAttitudeTransform>#include <osg/LOD>#include <osg/Sequence>#include <osg/Billboard>#include <osg/Geometry>#include <osg/Notify>#include <osg/Timer>#include <osg/io_utils>#include <osg/Depth>
#include <osgDB/SharedStateManager>
#include <osgUtil/TransformAttributeFunctor>#include <osgUtil/Statistics>#include <osgUtil/MeshOptimizers>
#include <algorithm>#include <numeric>
#include <iterator>#include <cassert>
#include <components/sceneutil/depth.hpp>
// NOLINTBEGIN(readability-identifier-naming)
using namespace osgUtil;
namespace SceneUtil{
void Optimizer::reset(){}
void Optimizer::optimize(osg::Node* node, unsigned int options){ StatsVisitor stats;
if (osg::getNotifyLevel()>=osg::INFO) { node->accept(stats); stats.totalUpStats(); OSG_NOTICE<<std::endl<<"Stats before:"<<std::endl; stats.print(osg::notify(osg::NOTICE)); }
if (options & FLATTEN_STATIC_TRANSFORMS) { OSG_INFO<<"Optimizer::optimize() doing FLATTEN_STATIC_TRANSFORMS"<<std::endl;
int i=0; bool result = false; do { OSG_DEBUG << "** RemoveStaticTransformsVisitor *** Pass "<<i<<std::endl; FlattenStaticTransformsVisitor fstv(this); node->accept(fstv); result = fstv.removeTransforms(node); ++i; } while (result);
// now combine any adjacent static transforms. CombineStaticTransformsVisitor cstv(this); node->accept(cstv); cstv.removeTransforms(node); }
if (options & SHARE_DUPLICATE_STATE && _sharedStateManager) { if (_sharedStateMutex) _sharedStateMutex->lock(); _sharedStateManager->share(node); if (_sharedStateMutex) _sharedStateMutex->unlock(); }
if (options & REMOVE_REDUNDANT_NODES) { OSG_INFO<<"Optimizer::optimize() doing REMOVE_REDUNDANT_NODES"<<std::endl;
RemoveEmptyNodesVisitor renv(this); node->accept(renv); renv.removeEmptyNodes();
RemoveRedundantNodesVisitor rrnv(this); node->accept(rrnv); rrnv.removeRedundantNodes();
MergeGroupsVisitor mgrp(this); node->accept(mgrp); }
if (options & MERGE_GEOMETRY) { OSG_INFO<<"Optimizer::optimize() doing MERGE_GEOMETRY"<<std::endl;
osg::Timer_t startTick = osg::Timer::instance()->tick();
MergeGeometryVisitor mgv(this); mgv.setTargetMaximumNumberOfVertices(1000000); mgv.setMergeAlphaBlending(_mergeAlphaBlending); mgv.setViewPoint(_viewPoint); node->accept(mgv);
osg::Timer_t endTick = osg::Timer::instance()->tick();
OSG_INFO<<"MERGE_GEOMETRY took "<<osg::Timer::instance()->delta_s(startTick,endTick)<<std::endl; }
if (options & VERTEX_POSTTRANSFORM) { OSG_INFO<<"Optimizer::optimize() doing VERTEX_POSTTRANSFORM"<<std::endl; VertexCacheVisitor vcv; node->accept(vcv); vcv.optimizeVertices(); }
if (options & VERTEX_PRETRANSFORM) { OSG_INFO<<"Optimizer::optimize() doing VERTEX_PRETRANSFORM"<<std::endl; VertexAccessOrderVisitor vaov; node->accept(vaov); vaov.optimizeOrder(); }
if (osg::getNotifyLevel()>=osg::INFO) { stats.reset(); node->accept(stats); stats.totalUpStats(); OSG_NOTICE<<std::endl<<"Stats after:"<<std::endl; stats.print(osg::notify(osg::NOTICE)); }}
////////////////////////////////////////////////////////////////////////////// Flatten static transforms////////////////////////////////////////////////////////////////////////////
class CollectLowestTransformsVisitor : public BaseOptimizerVisitor{ public:
CollectLowestTransformsVisitor(Optimizer* optimizer=0): BaseOptimizerVisitor(optimizer,Optimizer::FLATTEN_STATIC_TRANSFORMS), _transformFunctor(osg::Matrix()) { setTraversalMode(osg::NodeVisitor::TRAVERSE_PARENTS); }
void apply(osg::Group& node) override { if (node.getNumParents()) { traverse(node); } else { // for all current objects mark a nullptr transform for them. registerWithCurrentObjects(static_cast<osg::Transform*>(nullptr)); } }
void apply(osg::LOD& lod) override { _currentObjectList.push_back(&lod);
traverse(lod);
_currentObjectList.pop_back(); }
void apply(osg::Transform& transform) override { // for all current objects associated this transform with them. registerWithCurrentObjects(&transform); } void apply(osg::MatrixTransform& transform) override { // for all current objects associated this transform with them. registerWithCurrentObjects(&transform); }
void apply(osg::Node& node) override { traverse(node); }
void apply(osg::Geometry& geometry) override { }
void collectDataFor(osg::Node* node) { _currentObjectList.push_back(node);
node->accept(*this);
_currentObjectList.pop_back(); }
void collectDataFor(osg::Billboard* billboard) { _currentObjectList.push_back(billboard);
billboard->accept(*this);
_currentObjectList.pop_back(); }
void collectDataFor(osg::Drawable* drawable) { _currentObjectList.push_back(drawable);
const osg::Drawable::ParentList& parents = drawable->getParents(); for(osg::Drawable::ParentList::const_iterator itr=parents.begin(); itr!=parents.end(); ++itr) { (*itr)->accept(*this); }
_currentObjectList.pop_back(); }
void setUpMaps(); void disableTransform(osg::Transform* transform); bool removeTransforms(osg::Node* nodeWeCannotRemove);
inline bool isOperationPermissibleForObject(const osg::Object* object) const { const osg::Node* node = object->asNode(); if (node) { const osg::Drawable* drawable = node->asDrawable(); if (drawable) return isOperationPermissibleForObject(drawable); else return isOperationPermissibleForObject(node); } return true; }
inline bool isOperationPermissibleForObject(const osg::Drawable* drawable) const { return BaseOptimizerVisitor::isOperationPermissibleForObject(drawable); }
inline bool isOperationPermissibleForObject(const osg::Node* node) const { return BaseOptimizerVisitor::isOperationPermissibleForObject(node); }
protected:
struct TransformStruct { typedef std::set<osg::Object*> ObjectSet;
TransformStruct():_canBeApplied(true) {}
void add(osg::Object* obj) { _objectSet.insert(obj); }
bool _canBeApplied; ObjectSet _objectSet; };
struct ObjectStruct { typedef std::set<osg::Transform*> TransformSet;
ObjectStruct():_canBeApplied(true),_moreThanOneMatrixRequired(false) {}
inline const osg::Matrix& getMatrix(osg::MatrixTransform* transform) { return transform->getMatrix(); } osg::Matrix getMatrix(osg::Transform* transform) { osg::Matrix matrix; transform->computeLocalToWorldMatrix(matrix, 0); return matrix; } template<typename T> void add(T* transform, bool canOptimize) { if (transform) { if (!canOptimize) _moreThanOneMatrixRequired=true; else if (transform->getReferenceFrame()!=osg::Transform::RELATIVE_RF) _moreThanOneMatrixRequired=true; else { if (_transformSet.empty()) _firstMatrix = getMatrix(transform); else { if (_firstMatrix!=getMatrix(transform)) _moreThanOneMatrixRequired=true; } } } else { if (!_transformSet.empty()) { if (!_firstMatrix.isIdentity()) _moreThanOneMatrixRequired=true; }
} _transformSet.insert(transform); }
bool _canBeApplied; bool _moreThanOneMatrixRequired; osg::Matrix _firstMatrix; TransformSet _transformSet; };
template <typename T> void registerWithCurrentObjects(T* transform) { for(ObjectList::iterator itr=_currentObjectList.begin(); itr!=_currentObjectList.end(); ++itr) { _objectMap[*itr].add(transform, transform && isOperationPermissibleForObject(transform)); } }
typedef std::map<osg::Transform*,TransformStruct> TransformMap; typedef std::map<osg::Object*,ObjectStruct> ObjectMap; typedef std::vector<osg::Object*> ObjectList;
void disableObject(osg::Object* object) { disableObject(_objectMap.find(object)); }
void disableObject(ObjectMap::iterator itr); void doTransform(osg::Object* obj,osg::Matrix& matrix);
osgUtil::TransformAttributeFunctor _transformFunctor; TransformMap _transformMap; ObjectMap _objectMap; ObjectList _currentObjectList;
};
void CollectLowestTransformsVisitor::doTransform(osg::Object* obj,osg::Matrix& matrix){ osg::Node* node = obj->asNode(); if (!node) return; osg::Drawable* drawable = node->asDrawable(); if (drawable) { osgUtil::TransformAttributeFunctor tf(matrix); drawable->accept(tf);
osg::Geometry *geom = drawable->asGeometry(); osg::Vec4Array* tangents = geom ? dynamic_cast<osg::Vec4Array*>(geom->getTexCoordArray(7)) : nullptr; if (tangents) { for (unsigned int i=0; i<tangents->size(); ++i) { osg::Vec4f& itr = (*tangents)[i]; osg::Vec3f vec3 (itr.x(), itr.y(), itr.z()); vec3 = osg::Matrix::transform3x3(tf._im, vec3); vec3.normalize(); itr = osg::Vec4f(vec3.x(), vec3.y(), vec3.z(), itr.w()); } }
drawable->dirtyBound(); drawable->dirtyDisplayList();
return; }
osg::LOD* lod = dynamic_cast<osg::LOD*>(obj); if (lod) { osg::Matrix matrix_no_trans = matrix; matrix_no_trans.setTrans(0.0f,0.0f,0.0f);
osg::Vec3 v111(1.0f,1.0f,1.0f); osg::Vec3 new_v111 = v111*matrix_no_trans; float ratio = new_v111.length()/v111.length();
// move center point. lod->setCenter(lod->getCenter()*matrix);
// adjust ranges to new scale. for(unsigned int i=0;i<lod->getNumRanges();++i) { lod->setRange(i,lod->getMinRange(i)*ratio,lod->getMaxRange(i)*ratio); }
lod->dirtyBound(); return; }
osg::Billboard* billboard = dynamic_cast<osg::Billboard*>(obj); if (billboard) { osg::Matrix matrix_no_trans = matrix; matrix_no_trans.setTrans(0.0f,0.0f,0.0f);
osgUtil::TransformAttributeFunctor tf(matrix_no_trans);
osg::Vec3 axis = osg::Matrix::transform3x3(tf._im,billboard->getAxis()); axis.normalize(); billboard->setAxis(axis);
osg::Vec3 normal = osg::Matrix::transform3x3(tf._im,billboard->getNormal()); normal.normalize(); billboard->setNormal(normal);
for(unsigned int i=0;i<billboard->getNumDrawables();++i) { billboard->setPosition(i,billboard->getPosition(i)*matrix); billboard->getDrawable(i)->accept(tf); billboard->getDrawable(i)->dirtyBound(); }
billboard->dirtyBound();
return; }}
void CollectLowestTransformsVisitor::disableObject(ObjectMap::iterator itr){ if (itr==_objectMap.end()) { return; }
if (itr->second._canBeApplied) { // we haven't been disabled yet so we need to disable, itr->second._canBeApplied = false;
// and then inform everybody we have been disabled. for(ObjectStruct::TransformSet::iterator titr = itr->second._transformSet.begin(); titr != itr->second._transformSet.end(); ++titr) { disableTransform(*titr); } }}
void CollectLowestTransformsVisitor::disableTransform(osg::Transform* transform){ TransformMap::iterator itr=_transformMap.find(transform); if (itr==_transformMap.end()) { return; }
if (itr->second._canBeApplied) {
// we haven't been disabled yet so we need to disable, itr->second._canBeApplied = false; // and then inform everybody we have been disabled. for(TransformStruct::ObjectSet::iterator oitr = itr->second._objectSet.begin(); oitr != itr->second._objectSet.end(); ++oitr) { disableObject(*oitr); } }}
void CollectLowestTransformsVisitor::setUpMaps(){ // create the TransformMap from the ObjectMap ObjectMap::iterator oitr; for(oitr=_objectMap.begin(); oitr!=_objectMap.end(); ++oitr) { osg::Object* object = oitr->first; ObjectStruct& os = oitr->second;
for(ObjectStruct::TransformSet::iterator titr = os._transformSet.begin(); titr != os._transformSet.end(); ++titr) { _transformMap[*titr].add(object); } }
// disable all the objects which have more than one matrix associated // with them, and then disable all transforms which have an object associated // them that can't be applied, and then disable all objects which have // disabled transforms associated, recursing until all disabled // associativity. // and disable all objects that the operation is not permisable for) for(oitr=_objectMap.begin(); oitr!=_objectMap.end(); ++oitr) { osg::Object* object = oitr->first; ObjectStruct& os = oitr->second; if (os._canBeApplied) { if (os._moreThanOneMatrixRequired || !isOperationPermissibleForObject(object)) { disableObject(oitr); } } }
}
bool CollectLowestTransformsVisitor::removeTransforms(osg::Node* nodeWeCannotRemove){ // transform the objects that can be applied. for(ObjectMap::iterator oitr=_objectMap.begin(); oitr!=_objectMap.end(); ++oitr) { osg::Object* object = oitr->first; ObjectStruct& os = oitr->second; if (os._canBeApplied) { doTransform(object,os._firstMatrix); } }
bool transformRemoved = false;
// clean up the transforms. for(TransformMap::iterator titr=_transformMap.begin(); titr!=_transformMap.end(); ++titr) { if (titr->first!=0 && titr->second._canBeApplied) { if (titr->first!=nodeWeCannotRemove) { transformRemoved = true;
osg::ref_ptr<osg::Transform> transform = titr->first; osg::ref_ptr<osg::Group> group = new osg::Group; group->setName( transform->getName() ); group->setDataVariance(osg::Object::STATIC); group->setNodeMask(transform->getNodeMask()); group->setStateSet(transform->getStateSet()); group->setUpdateCallback(transform->getUpdateCallback()); group->setEventCallback(transform->getEventCallback()); group->setCullCallback(transform->getCullCallback()); group->setUserDataContainer(transform->getUserDataContainer()); group->setDescriptions(transform->getDescriptions()); for(unsigned int i=0;i<transform->getNumChildren();++i) { group->addChild(transform->getChild(i)); }
for(int i2=transform->getNumParents()-1;i2>=0;--i2) { transform->getParent(i2)->replaceChild(transform.get(),group.get()); } } else { osg::MatrixTransform* mt = titr->first->asMatrixTransform(); if (mt) mt->setMatrix(osg::Matrix::identity()); else { osg::PositionAttitudeTransform* pat = titr->first->asPositionAttitudeTransform(); if (pat) { pat->setPosition(osg::Vec3(0.0f,0.0f,0.0f)); pat->setAttitude(osg::Quat()); pat->setPivotPoint(osg::Vec3(0.0f,0.0f,0.0f)); } else { OSG_WARN<<"Warning:: during Optimize::CollectLowestTransformsVisitor::removeTransforms(Node*)"<<std::endl; OSG_WARN<<" unhandled of setting of indentity matrix on "<< titr->first->className()<<std::endl; OSG_WARN<<" model will appear in the incorrect position."<<std::endl; } }
} } } _objectMap.clear(); _transformMap.clear();
return transformRemoved;}
void Optimizer::FlattenStaticTransformsVisitor::apply(osg::Node& node){ traverse(node);}
osg::Array* cloneArray(osg::Array* array, osg::VertexBufferObject*& vbo, const osg::Geometry* geom){ array = static_cast<osg::Array*>(array->clone(osg::CopyOp::DEEP_COPY_ALL)); if (!vbo) vbo = new osg::VertexBufferObject; array->setVertexBufferObject(vbo); return array;}
void Optimizer::FlattenStaticTransformsVisitor::apply(osg::Geometry& geometry){ if(isOperationPermissibleForObject(&geometry)) { osg::VertexBufferObject* vbo = nullptr; if(geometry.getVertexArray() && geometry.getVertexArray()->referenceCount() > 1) geometry.setVertexArray(cloneArray(geometry.getVertexArray(), vbo, &geometry)); if(geometry.getNormalArray() && geometry.getNormalArray()->referenceCount() > 1) geometry.setNormalArray(cloneArray(geometry.getNormalArray(), vbo, &geometry)); if(geometry.getTexCoordArray(7) && geometry.getTexCoordArray(7)->referenceCount() > 1) // tangents geometry.setTexCoordArray(7, cloneArray(geometry.getTexCoordArray(7), vbo, &geometry)); } _drawableSet.insert(&geometry);}
void Optimizer::FlattenStaticTransformsVisitor::apply(osg::Drawable& drawable){ _drawableSet.insert(&drawable);}
void Optimizer::FlattenStaticTransformsVisitor::apply(osg::Billboard& billboard){ if (!_transformStack.empty()) { _billboardSet.insert(&billboard); }}
void Optimizer::FlattenStaticTransformsVisitor::apply(osg::Transform& transform){ if (!_transformStack.empty()) { // we need to disable any transform higher in the list. _transformSet.insert(_transformStack.back()); }
_transformStack.push_back(&transform);
// simple traverse the children as if this Transform didn't exist. traverse(transform);
_transformStack.pop_back();}
void Optimizer::FlattenStaticTransformsVisitor::apply(osg::MatrixTransform& transform){ apply(static_cast<osg::Transform&>(transform));}
bool Optimizer::FlattenStaticTransformsVisitor::removeTransforms(osg::Node* nodeWeCannotRemove){ CollectLowestTransformsVisitor cltv(_optimizer);
for(NodeSet::iterator nitr=_excludedNodeSet.begin(); nitr!=_excludedNodeSet.end(); ++nitr) { cltv.collectDataFor(*nitr); }
for(DrawableSet::iterator ditr=_drawableSet.begin(); ditr!=_drawableSet.end(); ++ditr) { cltv.collectDataFor(*ditr); }
for(BillboardSet::iterator bitr=_billboardSet.begin(); bitr!=_billboardSet.end(); ++bitr) { cltv.collectDataFor(*bitr); }
cltv.setUpMaps();
for(TransformSet::iterator titr=_transformSet.begin(); titr!=_transformSet.end(); ++titr) { cltv.disableTransform(*titr); }
return cltv.removeTransforms(nodeWeCannotRemove);}
////////////////////////////////////////////////////////////////////////////// CombineStaticTransforms////////////////////////////////////////////////////////////////////////////
void Optimizer::CombineStaticTransformsVisitor::apply(osg::MatrixTransform& transform){ if (transform.getDataVariance()==osg::Object::STATIC && transform.getNumChildren()==1 && transform.getChild(0)->asTransform()!=0 && transform.getChild(0)->asTransform()->asMatrixTransform()!=0 && transform.getChild(0)->asTransform()->getDataVariance()==osg::Object::STATIC && isOperationPermissibleForObject(&transform) && isOperationPermissibleForObject(transform.getChild(0))) { _transformSet.insert(&transform); }
traverse(transform);}
bool Optimizer::CombineStaticTransformsVisitor::removeTransforms(osg::Node* nodeWeCannotRemove){ if (nodeWeCannotRemove && nodeWeCannotRemove->asTransform()!=0 && nodeWeCannotRemove->asTransform()->asMatrixTransform()!=0) { // remove topmost node from transform set if it exists there. TransformSet::iterator itr = _transformSet.find(nodeWeCannotRemove->asTransform()->asMatrixTransform()); if (itr!=_transformSet.end()) _transformSet.erase(itr); }
bool transformRemoved = false;
while (!_transformSet.empty()) { // get the first available transform to combine. osg::ref_ptr<osg::MatrixTransform> transform = *_transformSet.begin(); _transformSet.erase(_transformSet.begin());
if (transform->getNumChildren()==1 && transform->getChild(0)->asTransform()!=0 && transform->getChild(0)->asTransform()->asMatrixTransform()!=0 && (!transform->getChild(0)->getStateSet() || transform->getChild(0)->getStateSet()->referenceCount()==1) && transform->getChild(0)->getDataVariance()==osg::Object::STATIC) { // now combine with its child. osg::MatrixTransform* child = transform->getChild(0)->asTransform()->asMatrixTransform();
osg::Matrix newMatrix = child->getMatrix()*transform->getMatrix(); child->setMatrix(newMatrix); if (transform->getStateSet()) { if(child->getStateSet()) child->getStateSet()->merge(*transform->getStateSet()); else child->setStateSet(transform->getStateSet()); }
transformRemoved = true;
osg::Node::ParentList parents = transform->getParents(); for(osg::Node::ParentList::iterator pitr=parents.begin(); pitr!=parents.end(); ++pitr) { (*pitr)->replaceChild(transform.get(),child); }
}
} return transformRemoved;}
////////////////////////////////////////////////////////////////////////////// RemoveEmptyNodes.////////////////////////////////////////////////////////////////////////////
void Optimizer::RemoveEmptyNodesVisitor::apply(osg::Group& group){ if (group.getNumParents()>0) { // only remove empty groups, but not empty occluders. if (group.getNumChildren()==0 && isOperationPermissibleForObject(&group) && (typeid(group)==typeid(osg::Group) || (group.asTransform())) && (group.getNumChildrenRequiringUpdateTraversal()==0 && group.getNumChildrenRequiringEventTraversal()==0) ) { _redundantNodeList.insert(&group); } } traverse(group);}
void Optimizer::RemoveEmptyNodesVisitor::removeEmptyNodes(){
NodeList newEmptyGroups;
// keep iterator through until scene graph is cleaned of empty nodes. while (!_redundantNodeList.empty()) { for(NodeList::iterator itr=_redundantNodeList.begin(); itr!=_redundantNodeList.end(); ++itr) {
osg::ref_ptr<osg::Node> nodeToRemove = (*itr);
// take a copy of parents list since subsequent removes will modify the original one. osg::Node::ParentList parents = nodeToRemove->getParents();
for(osg::Node::ParentList::iterator pitr=parents.begin(); pitr!=parents.end(); ++pitr) { osg::Group* parent = *pitr; if (!parent->asSwitch() && !dynamic_cast<osg::LOD*>(parent) && !dynamic_cast<osg::Sequence*>(parent)) { parent->removeChild(nodeToRemove.get()); if (parent->getNumChildren()==0 && isOperationPermissibleForObject(parent)) newEmptyGroups.insert(parent); } } }
_redundantNodeList.clear(); _redundantNodeList.swap(newEmptyGroups); }}
////////////////////////////////////////////////////////////////////////////// RemoveRedundantNodes.////////////////////////////////////////////////////////////////////////////
bool Optimizer::RemoveRedundantNodesVisitor::isOperationPermissible(osg::Node& node){ return node.getNumParents()>0 && !node.getStateSet() && !node.getCullCallback() && !node.getEventCallback() && !node.getUpdateCallback() && isOperationPermissibleForObject(&node);}
void Optimizer::RemoveRedundantNodesVisitor::apply(osg::LOD& lod){ // don't remove any direct children of the LOD because they are used to define each LOD level. for (unsigned int i=0; i<lod.getNumChildren(); ++i) traverse(*lod.getChild(i));}
void Optimizer::RemoveRedundantNodesVisitor::apply(osg::Switch& switchNode){ // We should keep all switch child nodes since they reflect different switch states. for (unsigned int i=0; i<switchNode.getNumChildren(); ++i) traverse(*switchNode.getChild(i));}
void Optimizer::RemoveRedundantNodesVisitor::apply(osg::Sequence& sequenceNode){ // We should keep all sequence child nodes since they reflect different sequence states. for (unsigned int i=0; i<sequenceNode.getNumChildren(); ++i) traverse(*sequenceNode.getChild(i));}
void Optimizer::RemoveRedundantNodesVisitor::apply(osg::Group& group){ if (typeid(group)==typeid(osg::Group) && isOperationPermissible(group)) { _redundantNodeList.insert(&group); }
traverse(group);}
void Optimizer::RemoveRedundantNodesVisitor::apply(osg::Transform& transform){ if (transform.getDataVariance()==osg::Object::STATIC && isOperationPermissible(transform)) { osg::Matrix matrix; transform.computeWorldToLocalMatrix(matrix,nullptr); if (matrix.isIdentity()) { _redundantNodeList.insert(&transform); } } traverse(transform);}
void Optimizer::RemoveRedundantNodesVisitor::removeRedundantNodes(){
for(NodeList::iterator itr=_redundantNodeList.begin(); itr!=_redundantNodeList.end(); ++itr) { osg::ref_ptr<osg::Group> group = (*itr)->asGroup(); if (group.valid()) { // take a copy of parents list since subsequent removes will modify the original one. osg::Node::ParentList parents = group->getParents();
for(osg::Node::ParentList::iterator pitr=parents.begin(); pitr!=parents.end(); ++pitr) { unsigned int childIndex = (*pitr)->getChildIndex(group); for (unsigned int i=0; i<group->getNumChildren(); ++i) { if (i==0) (*pitr)->setChild(childIndex, group->getChild(i)); else (*pitr)->insertChild(childIndex+i, group->getChild(i)); } }
group->removeChildren(0, group->getNumChildren()); } else { OSG_WARN<<"Optimizer::RemoveRedundantNodesVisitor::removeRedundantNodes() - failed dynamic_cast"<<std::endl; } } _redundantNodeList.clear();}
////////////////////////////////////////////////////////////////////////////// code to merge geometry object which share, state, and attribute bindings.////////////////////////////////////////////////////////////////////////////
#define COMPARE_BINDING(lhs, rhs) \ if (osg::getBinding(lhs)<osg::getBinding(rhs)) return true; \ if (osg::getBinding(rhs)<osg::getBinding(lhs)) return false;
struct LessGeometry{ bool operator() (const osg::ref_ptr<osg::Geometry>& lhs,const osg::ref_ptr<osg::Geometry>& rhs) const { if (lhs->getStateSet()<rhs->getStateSet()) return true; if (rhs->getStateSet()<lhs->getStateSet()) return false;
COMPARE_BINDING(lhs->getNormalArray(), rhs->getNormalArray()) COMPARE_BINDING(lhs->getColorArray(), rhs->getColorArray()) COMPARE_BINDING(lhs->getSecondaryColorArray(), rhs->getSecondaryColorArray()) COMPARE_BINDING(lhs->getFogCoordArray(), rhs->getFogCoordArray())
if (lhs->getNumTexCoordArrays()<rhs->getNumTexCoordArrays()) return true; if (rhs->getNumTexCoordArrays()<lhs->getNumTexCoordArrays()) return false;
// therefore lhs->getNumTexCoordArrays()==rhs->getNumTexCoordArrays()
unsigned int i; for(i=0;i<lhs->getNumTexCoordArrays();++i) { if (rhs->getTexCoordArray(i)) { if (!lhs->getTexCoordArray(i)) return true; } else if (lhs->getTexCoordArray(i)) return false; }
for(i=0;i<lhs->getNumVertexAttribArrays();++i) { if (rhs->getVertexAttribArray(i)) { if (!lhs->getVertexAttribArray(i)) return true; } else if (lhs->getVertexAttribArray(i)) return false; }
if (osg::getBinding(lhs->getNormalArray())==osg::Array::BIND_OVERALL) { // assumes that the bindings and arrays are set up correctly, this // should be the case after running computeCorrectBindingsAndArraySizes(); const osg::Array* lhs_normalArray = lhs->getNormalArray(); const osg::Array* rhs_normalArray = rhs->getNormalArray(); if (lhs_normalArray->getType()<rhs_normalArray->getType()) return true; if (rhs_normalArray->getType()<lhs_normalArray->getType()) return false; switch(lhs_normalArray->getType()) { case(osg::Array::Vec3bArrayType): if ((*static_cast<const osg::Vec3bArray*>(lhs_normalArray))[0]<(*static_cast<const osg::Vec3bArray*>(rhs_normalArray))[0]) return true; if ((*static_cast<const osg::Vec3bArray*>(rhs_normalArray))[0]<(*static_cast<const osg::Vec3bArray*>(lhs_normalArray))[0]) return false; break; case(osg::Array::Vec3sArrayType): if ((*static_cast<const osg::Vec3sArray*>(lhs_normalArray))[0]<(*static_cast<const osg::Vec3sArray*>(rhs_normalArray))[0]) return true; if ((*static_cast<const osg::Vec3sArray*>(rhs_normalArray))[0]<(*static_cast<const osg::Vec3sArray*>(lhs_normalArray))[0]) return false; break; case(osg::Array::Vec3ArrayType): if ((*static_cast<const osg::Vec3Array*>(lhs_normalArray))[0]<(*static_cast<const osg::Vec3Array*>(rhs_normalArray))[0]) return true; if ((*static_cast<const osg::Vec3Array*>(rhs_normalArray))[0]<(*static_cast<const osg::Vec3Array*>(lhs_normalArray))[0]) return false; break; default: break; } }
if (osg::getBinding(lhs->getColorArray())==osg::Array::BIND_OVERALL) { const osg::Array* lhs_colorArray = lhs->getColorArray(); const osg::Array* rhs_colorArray = rhs->getColorArray(); if (lhs_colorArray->getType()<rhs_colorArray->getType()) return true; if (rhs_colorArray->getType()<lhs_colorArray->getType()) return false; switch(lhs_colorArray->getType()) { case(osg::Array::Vec4ubArrayType): if ((*static_cast<const osg::Vec4ubArray*>(lhs_colorArray))[0]<(*static_cast<const osg::Vec4ubArray*>(rhs_colorArray))[0]) return true; if ((*static_cast<const osg::Vec4ubArray*>(rhs_colorArray))[0]<(*static_cast<const osg::Vec4ubArray*>(lhs_colorArray))[0]) return false; break; case(osg::Array::Vec3ArrayType): if ((*static_cast<const osg::Vec3Array*>(lhs_colorArray))[0]<(*static_cast<const osg::Vec3Array*>(rhs_colorArray))[0]) return true; if ((*static_cast<const osg::Vec3Array*>(rhs_colorArray))[0]<(*static_cast<const osg::Vec3Array*>(lhs_colorArray))[0]) return false; break; case(osg::Array::Vec4ArrayType): if ((*static_cast<const osg::Vec4Array*>(lhs_colorArray))[0]<(*static_cast<const osg::Vec4Array*>(rhs_colorArray))[0]) return true; if ((*static_cast<const osg::Vec4Array*>(rhs_colorArray))[0]<(*static_cast<const osg::Vec4Array*>(lhs_colorArray))[0]) return false; break; default: break; }
}
return false;
}};
struct LessGeometryViewPoint{ osg::Vec3f _viewPoint; bool operator() (const osg::ref_ptr<osg::Geometry>& lhs,const osg::ref_ptr<osg::Geometry>& rhs) const { float len1 = (lhs->getBoundingBox().center() - _viewPoint).length2(); float len2 = (rhs->getBoundingBox().center() - _viewPoint).length2(); return len2 < len1; }};
struct LessGeometryPrimitiveType{ bool operator() (const osg::ref_ptr<osg::Geometry>& lhs,const osg::ref_ptr<osg::Geometry>& rhs) const { for(unsigned int i=0; i<lhs->getNumPrimitiveSets() && i<rhs->getNumPrimitiveSets(); ++i) { if (lhs->getPrimitiveSet(i)->getType()<rhs->getPrimitiveSet(i)->getType()) return true; else if (rhs->getPrimitiveSet(i)->getType()<lhs->getPrimitiveSet(i)->getType()) return false;
if (lhs->getPrimitiveSet(i)->getMode()<rhs->getPrimitiveSet(i)->getMode()) return true; else if (rhs->getPrimitiveSet(i)->getMode()<lhs->getPrimitiveSet(i)->getMode()) return false;
} return lhs->getNumPrimitiveSets()<rhs->getNumPrimitiveSets(); }};
/// Shortcut to get size of an array, even if pointer is nullptr.inline unsigned int getSize(const osg::Array * a) { return a ? a->getNumElements() : 0; }
/// When merging geometries, tests if two arrays can be merged, regarding to their number of components, and the number of vertices.bool isArrayCompatible(unsigned int numVertice1, unsigned int numVertice2, const osg::Array* compare1, const osg::Array* compare2){ // Sumed up truth table: // If array (1 or 2) not empty and vertices empty => error, should not happen (allows simplification in formulae below) // If one side has both vertices and array, and the other side has only vertices => then arrays cannot be merged // Else, arrays can be merged //assert(numVertice1 || !getSize(compare1)); //assert(numVertice2 || !getSize(compare2)); return !( (numVertice1 && !getSize(compare1) && getSize(compare2)) || (numVertice2 && !getSize(compare2) && getSize(compare1)) );}
/// Return true only if both geometries have same array type and if arrays (such as TexCoords) are compatible (i.e. both empty or both filled)bool isAbleToMerge(const osg::Geometry& g1, const osg::Geometry& g2){ unsigned int numVertice1( getSize(g1.getVertexArray()) ); unsigned int numVertice2( getSize(g2.getVertexArray()) );
// first verify arrays size if (!isArrayCompatible(numVertice1,numVertice2,g1.getNormalArray(),g2.getNormalArray()) || !isArrayCompatible(numVertice1,numVertice2,g1.getColorArray(),g2.getColorArray()) || !isArrayCompatible(numVertice1,numVertice2,g1.getSecondaryColorArray(),g2.getSecondaryColorArray()) || !isArrayCompatible(numVertice1,numVertice2,g1.getFogCoordArray(),g2.getFogCoordArray()) || g1.getNumTexCoordArrays()!=g2.getNumTexCoordArrays()) return false;
for (unsigned int eachTexCoordArray=0;eachTexCoordArray<g1.getNumTexCoordArrays();++eachTexCoordArray) { if (!isArrayCompatible(numVertice1,numVertice2,g1.getTexCoordArray(eachTexCoordArray),g2.getTexCoordArray(eachTexCoordArray))) return false; }
// then verify data type compatibility if (g1.getVertexArray() && g2.getVertexArray() && g1.getVertexArray()->getDataType()!=g2.getVertexArray()->getDataType()) return false; if (g1.getNormalArray() && g2.getNormalArray() && g1.getNormalArray()->getDataType()!=g2.getNormalArray()->getDataType()) return false; if (g1.getColorArray() && g2.getColorArray() && g1.getColorArray()->getDataType()!=g2.getColorArray()->getDataType()) return false; if (g1.getSecondaryColorArray() && g2.getSecondaryColorArray() && g1.getSecondaryColorArray()->getDataType()!=g2.getSecondaryColorArray()->getDataType()) return false; if (g1.getFogCoordArray() && g2.getNormalArray() && g1.getFogCoordArray()->getDataType()!=g2.getFogCoordArray()->getDataType()) return false; return true;}
bool Optimizer::MergeGeometryVisitor::pushStateSet(osg::StateSet *stateSet){ if (!stateSet || stateSet->getRenderBinMode() & osg::StateSet::INHERIT_RENDERBIN_DETAILS) return false; _stateSetStack.push_back(stateSet); checkAlphaBlendingActive(); return true;}
void Optimizer::MergeGeometryVisitor::popStateSet(){ _stateSetStack.pop_back(); checkAlphaBlendingActive();}
void Optimizer::MergeGeometryVisitor::checkAlphaBlendingActive(){ int renderingHint = 0; bool override = false; for (std::vector<osg::StateSet*>::const_iterator it = _stateSetStack.begin(); it != _stateSetStack.end(); ++it) { osg::StateSet* stateSet = *it; osg::StateSet::RenderBinMode mode = stateSet->getRenderBinMode(); if (override && !(mode & osg::StateSet::PROTECTED_RENDERBIN_DETAILS)) continue; if (mode & osg::StateSet::USE_RENDERBIN_DETAILS) renderingHint = stateSet->getRenderingHint(); if (mode & osg::StateSet::OVERRIDE_RENDERBIN_DETAILS) override = true; } // Can't merge Geometry that are using a transparent sorting bin as that would cause the sorting to break. _alphaBlendingActive = renderingHint == osg::StateSet::TRANSPARENT_BIN;}
void Optimizer::MergeGeometryVisitor::apply(osg::Group &group){ bool pushed = pushStateSet(group.getStateSet());
if (!_alphaBlendingActive || _mergeAlphaBlending) mergeGroup(group);
traverse(group);
if (pushed) popStateSet();}
osg::PrimitiveSet* clonePrimitive(osg::PrimitiveSet* ps, osg::ElementBufferObject*& ebo, const osg::Geometry* geom){ if (ps->referenceCount() <= 1) return ps; ps = static_cast<osg::PrimitiveSet*>(ps->clone(osg::CopyOp::DEEP_COPY_ALL));
osg::DrawElements* drawElements = ps->getDrawElements(); if (!drawElements) return ps;
if (!ebo) ebo = new osg::ElementBufferObject; drawElements->setElementBufferObject(ebo);
return ps;}
bool containsSharedPrimitives(const osg::Geometry* geom){ for (unsigned int i=0; i<geom->getNumPrimitiveSets(); ++i) if (geom->getPrimitiveSet(i)->referenceCount() > 1) return true; return false;}
// clang-format on
namespace { unsigned getArraySizeOrZero(const osg::Array* array) { return array == nullptr ? 0 : array->getNumElements(); }
void fillArraySizes(const std::vector<osg::ref_ptr<osg::Array>>& arrays, std::vector<unsigned>& sizes) { sizes.reserve(arrays.size()); for (const auto& array : arrays) sizes.push_back(getArraySizeOrZero(array)); }
void initArraySizes(const osg::Geometry& geometry, Optimizer::GeometryArraySizes& sizes) { sizes.mVertex = getArraySizeOrZero(geometry.getVertexArray()); sizes.mNormal = getArraySizeOrZero(geometry.getNormalArray()); sizes.mColor = getArraySizeOrZero(geometry.getColorArray()); sizes.mSecondaryColor = getArraySizeOrZero(geometry.getSecondaryColorArray()); sizes.mFogCoord = getArraySizeOrZero(geometry.getFogCoordArray()); sizes.mTexCoord.clear(); sizes.mVertexAttrib.clear();
fillArraySizes(geometry.getTexCoordArrayList(), sizes.mTexCoord); fillArraySizes(geometry.getVertexAttribArrayList(), sizes.mVertexAttrib); }
void addArraySize(const osg::Array* array, unsigned& size) { if (array != nullptr) size += array->getNumElements(); }
void addArraySizes(const std::vector<osg::ref_ptr<osg::Array>>& dst, const std::vector<osg::ref_ptr<osg::Array>>& src, std::vector<unsigned>& sizes) { assert(sizes.size() == dst.size());
for (std::size_t i = 0, n = std::min(dst.size(), src.size()); i < n; ++i) if (osg::Array* const array = src[i]) sizes[i] += array->getNumElements(); }
void addArraysSizes(const osg::Geometry& dst, const osg::Geometry& src, Optimizer::GeometryArraySizes& sizes) { addArraySize(src.getVertexArray(), sizes.mVertex); addArraySize(src.getNormalArray(), sizes.mNormal); addArraySize(src.getColorArray(), sizes.mColor); addArraySize(src.getSecondaryColorArray(), sizes.mSecondaryColor); addArraySize(src.getFogCoordArray(), sizes.mFogCoord);
addArraySizes(dst.getTexCoordArrayList(), src.getTexCoordArrayList(), sizes.mTexCoord); addArraySizes(dst.getVertexAttribArrayList(), src.getVertexAttribArrayList(), sizes.mVertexAttrib); } }
// clang-format off
bool Optimizer::MergeGeometryVisitor::mergeGroup(osg::Group& group){ if (!isOperationPermissibleForObject(&group)) return false;
if (group.getNumChildren()>=2) {
typedef std::vector< osg::ref_ptr<osg::Geometry> > DuplicateList; typedef std::vector< osg::ref_ptr<osg::Node> > Nodes; typedef std::map< osg::ref_ptr<osg::Geometry> ,DuplicateList,LessGeometry> GeometryDuplicateMap;
typedef std::vector<DuplicateList> MergeList;
GeometryDuplicateMap geometryDuplicateMap; Nodes standardChildren;
unsigned int i; for(i=0;i<group.getNumChildren();++i) { osg::Node* child = group.getChild(i); osg::Geometry* geom = child->asGeometry(); if (geom) { if ( geom->getDataVariance()!=osg::Object::DYNAMIC && isOperationPermissibleForObject(geom)) { geometryDuplicateMap[geom].push_back(geom); } else { standardChildren.push_back(geom); } } else { standardChildren.push_back(child); } }
// first try to group geometries with the same properties // (i.e. array types) to avoid loss of data during merging MergeList mergeListChecked; // List of drawables just before merging, grouped by "compatibility" and vertex limit MergeList mergeList; // Intermediate list of drawables, grouped ony by "compatibility" for(GeometryDuplicateMap::iterator itr=geometryDuplicateMap.begin(); itr!=geometryDuplicateMap.end(); ++itr) { if (itr->second.empty()) continue; if (itr->second.size()==1) { mergeList.push_back(DuplicateList()); DuplicateList* duplicateList = &mergeList.back(); duplicateList->push_back(itr->second[0]); continue; }
std::sort(itr->second.begin(),itr->second.end(),LessGeometryPrimitiveType());
// initialize the temporary list by pushing the first geometry MergeList mergeListTmp; mergeListTmp.push_back(DuplicateList()); DuplicateList* duplicateList = &mergeListTmp.back(); duplicateList->push_back(itr->second[0]);
for(DuplicateList::iterator dupItr=itr->second.begin()+1; dupItr!=itr->second.end(); ++dupItr) { osg::Geometry* geomToPush = dupItr->get();
// try to group geomToPush with another geometry MergeList::iterator eachMergeList=mergeListTmp.begin(); for(;eachMergeList!=mergeListTmp.end();++eachMergeList) { if (!eachMergeList->empty() && eachMergeList->front()!=nullptr && isAbleToMerge(*eachMergeList->front(),*geomToPush)) { eachMergeList->push_back(geomToPush); break; } }
// if no suitable group was found, then a new one is created if (eachMergeList==mergeListTmp.end()) { mergeListTmp.push_back(DuplicateList()); duplicateList = &mergeListTmp.back(); duplicateList->push_back(geomToPush); } }
// copy the group in the mergeListChecked for(MergeList::iterator eachMergeList=mergeListTmp.begin();eachMergeList!=mergeListTmp.end();++eachMergeList) { mergeListChecked.push_back(*eachMergeList); } }
// then build merge list using _targetMaximumNumberOfVertices bool needToDoMerge = false; // dequeue each DuplicateList when vertices limit is reached or when all elements has been checked for(MergeList::iterator itr=mergeListChecked.begin(); itr!=mergeListChecked.end(); ++itr) { DuplicateList& duplicateList(*itr); if (duplicateList.size()==0) { continue; }
if (duplicateList.size()==1) { mergeList.push_back(duplicateList); continue; }
unsigned int totalNumberVertices = 0; DuplicateList subset; for(DuplicateList::iterator ditr = duplicateList.begin(); ditr != duplicateList.end(); ++ditr) { osg::Geometry* geometry = ditr->get(); unsigned int numVertices = (geometry->getVertexArray() ? geometry->getVertexArray()->getNumElements() : 0); if ((totalNumberVertices+numVertices)>_targetMaximumNumberOfVertices && !subset.empty()) { mergeList.push_back(subset); subset.clear(); totalNumberVertices = 0; } totalNumberVertices += numVertices; subset.push_back(geometry); if (subset.size()>1) needToDoMerge = true; } if (!subset.empty()) mergeList.push_back(std::move(subset)); }
if (needToDoMerge) { // to avoid performance issues associated with incrementally removing a large number children, we remove them all and add back the ones we need. group.removeChildren(0, group.getNumChildren());
for(Nodes::iterator itr = standardChildren.begin(); itr != standardChildren.end(); ++itr) { group.addChild(*itr); }
// Place outside the loop to keep vectors allocated GeometryArraySizes sizes;
// now do the merging of geometries for(MergeList::iterator mitr = mergeList.begin(); mitr != mergeList.end(); ++mitr) { DuplicateList& duplicateList = *mitr; if (!duplicateList.empty()) { if (_alphaBlendingActive) { LessGeometryViewPoint lgvp; lgvp._viewPoint = _viewPoint; std::sort(duplicateList.begin(), duplicateList.end(), lgvp); } DuplicateList::iterator ditr = duplicateList.begin(); osg::ref_ptr<osg::Geometry> lhs = *ditr++;
initArraySizes(*lhs, sizes);
for (auto it = ditr; it != duplicateList.end(); ++it) addArraysSizes(*lhs, **it, sizes);
group.addChild(lhs.get()); for(; ditr != duplicateList.end(); ++ditr) { mergeGeometry(*lhs, **ditr, sizes); } } } }
}
// convert all polygon primitives which has 3 indices into TRIANGLES, 4 indices into QUADS. unsigned int i; for(i=0;i<group.getNumChildren();++i) { osg::Drawable* drawable = group.getChild(i)->asDrawable(); if (!drawable) continue; osg::Geometry* geom = drawable->asGeometry(); osg::ElementBufferObject* ebo = nullptr; if (geom) { osg::Geometry::PrimitiveSetList& primitives = geom->getPrimitiveSetList(); for(osg::Geometry::PrimitiveSetList::iterator itr=primitives.begin(); itr!=primitives.end(); ++itr) { osg::PrimitiveSet* prim = itr->get(); if (prim->getMode()==osg::PrimitiveSet::POLYGON) { if (prim->getNumIndices()==3) { prim = clonePrimitive(prim, ebo, geom); (*itr) = prim; prim->setMode(osg::PrimitiveSet::TRIANGLES); } else if (prim->getNumIndices()==4) { prim = clonePrimitive(prim, ebo, geom); (*itr) = prim; prim->setMode(osg::PrimitiveSet::QUADS); } } } } }
// now merge any compatible primitives. for(i=0;i<group.getNumChildren();++i) { osg::Drawable* drawable = group.getChild(i)->asDrawable(); if (!drawable) continue; osg::Geometry* geom = drawable->asGeometry(); osg::ElementBufferObject* ebo = nullptr; if (geom) { if (geom->getNumPrimitiveSets()>0 && osg::getBinding(geom->getNormalArray())!=osg::Array::BIND_PER_PRIMITIVE_SET && osg::getBinding(geom->getColorArray())!=osg::Array::BIND_PER_PRIMITIVE_SET && osg::getBinding(geom->getSecondaryColorArray())!=osg::Array::BIND_PER_PRIMITIVE_SET && osg::getBinding(geom->getFogCoordArray())!=osg::Array::BIND_PER_PRIMITIVE_SET) {
#if 1 bool doneCombine = false;
std::set<osg::PrimitiveSet*> toremove;
osg::Geometry::PrimitiveSetList& primitives = geom->getPrimitiveSetList(); unsigned int lhsNo=0; unsigned int rhsNo=1; while(rhsNo<primitives.size()) { osg::PrimitiveSet* lhs = primitives[lhsNo].get(); osg::PrimitiveSet* rhs = primitives[rhsNo].get();
bool combine = false;
if (lhs->getType()==rhs->getType() && lhs->getMode()==rhs->getMode()) {
switch(lhs->getMode()) { case(osg::PrimitiveSet::POINTS): case(osg::PrimitiveSet::LINES): case(osg::PrimitiveSet::TRIANGLES): case(osg::PrimitiveSet::QUADS): combine = true; break; }
}
if (combine) { lhs = clonePrimitive(lhs, ebo, geom); primitives[lhsNo] = lhs;
switch(lhs->getType()) { case(osg::PrimitiveSet::DrawArraysPrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawArrays*>(lhs)),*(static_cast<osg::DrawArrays*>(rhs))); break; case(osg::PrimitiveSet::DrawArrayLengthsPrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawArrayLengths*>(lhs)),*(static_cast<osg::DrawArrayLengths*>(rhs))); break; case(osg::PrimitiveSet::DrawElementsUBytePrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawElementsUByte*>(lhs)),*(static_cast<osg::DrawElementsUByte*>(rhs))); break; case(osg::PrimitiveSet::DrawElementsUShortPrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawElementsUShort*>(lhs)),*(static_cast<osg::DrawElementsUShort*>(rhs))); break; case(osg::PrimitiveSet::DrawElementsUIntPrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawElementsUInt*>(lhs)),*(static_cast<osg::DrawElementsUInt*>(rhs))); break; default: combine = false; break; } }
if (combine) { // make this primitive set as invalid and needing cleaning up. toremove.insert(rhs); doneCombine = true; ++rhsNo; } else { lhsNo = rhsNo; ++rhsNo; } }
#if 1 if (doneCombine) { // now need to clean up primitiveset so it no longer contains the rhs combined primitives. // first swap with a empty primitiveSet to empty it completely. osg::Geometry::PrimitiveSetList oldPrimitives; primitives.swap(oldPrimitives);
// now add the active primitive sets for(osg::Geometry::PrimitiveSetList::iterator pitr = oldPrimitives.begin(); pitr != oldPrimitives.end(); ++pitr) { if (!toremove.count(*pitr)) primitives.push_back(*pitr); } } #endif
#else
osg::Geometry::PrimitiveSetList& primitives = geom->getPrimitiveSetList(); unsigned int primNo=0; while(primNo+1<primitives.size()) { osg::PrimitiveSet* lhs = primitives[primNo].get(); osg::PrimitiveSet* rhs = primitives[primNo+1].get();
bool combine = false;
if (lhs->getType()==rhs->getType() && lhs->getMode()==rhs->getMode()) {
switch(lhs->getMode()) { case(osg::PrimitiveSet::POINTS): case(osg::PrimitiveSet::LINES): case(osg::PrimitiveSet::TRIANGLES): case(osg::PrimitiveSet::QUADS): combine = true; break; }
}
if (combine) {
switch(lhs->getType()) { case(osg::PrimitiveSet::DrawArraysPrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawArrays*>(lhs)),*(static_cast<osg::DrawArrays*>(rhs))); break; case(osg::PrimitiveSet::DrawArrayLengthsPrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawArrayLengths*>(lhs)),*(static_cast<osg::DrawArrayLengths*>(rhs))); break; case(osg::PrimitiveSet::DrawElementsUBytePrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawElementsUByte*>(lhs)),*(static_cast<osg::DrawElementsUByte*>(rhs))); break; case(osg::PrimitiveSet::DrawElementsUShortPrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawElementsUShort*>(lhs)),*(static_cast<osg::DrawElementsUShort*>(rhs))); break; case(osg::PrimitiveSet::DrawElementsUIntPrimitiveType): combine = mergePrimitive(*(static_cast<osg::DrawElementsUInt*>(lhs)),*(static_cast<osg::DrawElementsUInt*>(rhs))); break; default: break; } } if (combine) { primitives.erase(primitives.begin()+primNo+1); }
if (!combine) { primNo++; } }#endif if (doneCombine && !geom->containsSharedArrays() && !containsSharedPrimitives(geom)) { // prefer to use vbo for merged geometries as vbo uses less memory than display lists. geom->setUseVertexBufferObjects(true); geom->setUseDisplayList(false); } if (_alphaBlendingActive && _mergeAlphaBlending && !geom->getStateSet()) { osg::ref_ptr<osg::Depth> d = new SceneUtil::AutoDepth; d->setWriteMask(false); geom->getOrCreateStateSet()->setAttribute(d); } } }
}
return false;}
class MergeArrayVisitor : public osg::ArrayVisitor{ protected: osg::Array* _lhs; public: MergeArrayVisitor() : _lhs(0) {}
/// try to merge the content of two arrays. bool merge(osg::Array* lhs,osg::Array* rhs) { if (lhs==0 || rhs==0) return true; if (lhs->getType()!=rhs->getType()) return false;
_lhs = lhs;
rhs->accept(*this); return true; }
template<typename T> void _merge(T& rhs) { T* lhs = static_cast<T*>(_lhs); lhs->insert(lhs->end(),rhs.begin(),rhs.end()); }
void apply(osg::Array&) override { OSG_WARN << "Warning: Optimizer's MergeArrayVisitor cannot merge Array type." << std::endl; }
void apply(osg::ByteArray& rhs) override { _merge(rhs); } void apply(osg::ShortArray& rhs) override { _merge(rhs); } void apply(osg::IntArray& rhs) override { _merge(rhs); } void apply(osg::UByteArray& rhs) override { _merge(rhs); } void apply(osg::UShortArray& rhs) override { _merge(rhs); } void apply(osg::UIntArray& rhs) override { _merge(rhs); }
void apply(osg::Vec4ubArray& rhs) override { _merge(rhs); } void apply(osg::Vec3ubArray& rhs) override{ _merge(rhs); } void apply(osg::Vec2ubArray& rhs) override { _merge(rhs); }
void apply(osg::Vec4usArray& rhs) override { _merge(rhs); } void apply(osg::Vec3usArray& rhs) override { _merge(rhs); } void apply(osg::Vec2usArray& rhs) override { _merge(rhs); }
void apply(osg::FloatArray& rhs) override { _merge(rhs); } void apply(osg::Vec2Array& rhs) override { _merge(rhs); } void apply(osg::Vec3Array& rhs) override { _merge(rhs); } void apply(osg::Vec4Array& rhs) override { _merge(rhs); }
void apply(osg::DoubleArray& rhs) override { _merge(rhs); } void apply(osg::Vec2dArray& rhs) override { _merge(rhs); } void apply(osg::Vec3dArray& rhs) override { _merge(rhs); } void apply(osg::Vec4dArray& rhs) override { _merge(rhs); }
void apply(osg::Vec2bArray& rhs) override { _merge(rhs); } void apply(osg::Vec3bArray& rhs) override { _merge(rhs); } void apply(osg::Vec4bArray& rhs) override { _merge(rhs); }
void apply(osg::Vec2sArray& rhs) override { _merge(rhs); } void apply(osg::Vec3sArray& rhs) override { _merge(rhs); } void apply(osg::Vec4sArray& rhs) override { _merge(rhs); }};
bool Optimizer::MergeGeometryVisitor::mergeGeometry(osg::Geometry& lhs, osg::Geometry& rhs, const GeometryArraySizes& sizes){ MergeArrayVisitor merger; osg::VertexBufferObject* vbo = nullptr; unsigned int base = 0; if (lhs.getVertexArray() && rhs.getVertexArray()) { base = lhs.getVertexArray()->getNumElements(); if (lhs.getVertexArray()->referenceCount() > 1) lhs.setVertexArray(cloneArray(lhs.getVertexArray(), vbo, &lhs)); lhs.getVertexArray()->reserveArray(sizes.mVertex); if (!merger.merge(lhs.getVertexArray(),rhs.getVertexArray())) { OSG_DEBUG << "MergeGeometry: vertex array not merged. Some data may be lost." <<std::endl; } } else if (rhs.getVertexArray()) { base = 0; lhs.setVertexArray(rhs.getVertexArray()); }
if (lhs.getNormalArray() && rhs.getNormalArray() && lhs.getNormalArray()->getBinding()!=osg::Array::BIND_OVERALL) { if (lhs.getNormalArray()->referenceCount() > 1) lhs.setNormalArray(cloneArray(lhs.getNormalArray(), vbo, &lhs)); lhs.getNormalArray()->reserveArray(sizes.mNormal); if (!merger.merge(lhs.getNormalArray(),rhs.getNormalArray())) { OSG_DEBUG << "MergeGeometry: normal array not merged. Some data may be lost." <<std::endl; } } else if (rhs.getNormalArray()) { lhs.setNormalArray(rhs.getNormalArray()); }
if (lhs.getColorArray() && rhs.getColorArray() && lhs.getColorArray()->getBinding()!=osg::Array::BIND_OVERALL) { if (lhs.getColorArray()->referenceCount() > 1) lhs.setColorArray(cloneArray(lhs.getColorArray(), vbo, &lhs)); lhs.getColorArray()->reserveArray(sizes.mColor); if (!merger.merge(lhs.getColorArray(),rhs.getColorArray())) { OSG_DEBUG << "MergeGeometry: color array not merged. Some data may be lost." <<std::endl; } } else if (rhs.getColorArray()) { lhs.setColorArray(rhs.getColorArray()); }
if (lhs.getSecondaryColorArray() && rhs.getSecondaryColorArray() && lhs.getSecondaryColorArray()->getBinding()!=osg::Array::BIND_OVERALL) { if (lhs.getSecondaryColorArray()->referenceCount() > 1) lhs.setSecondaryColorArray(cloneArray(lhs.getSecondaryColorArray(), vbo, &lhs)); lhs.getSecondaryColorArray()->reserveArray(static_cast<unsigned>(sizes.mSecondaryColor)); if (!merger.merge(lhs.getSecondaryColorArray(),rhs.getSecondaryColorArray())) { OSG_DEBUG << "MergeGeometry: secondary color array not merged. Some data may be lost." <<std::endl; } } else if (rhs.getSecondaryColorArray()) { lhs.setSecondaryColorArray(rhs.getSecondaryColorArray()); }
if (lhs.getFogCoordArray() && rhs.getFogCoordArray() && lhs.getFogCoordArray()->getBinding()!=osg::Array::BIND_OVERALL) { if (lhs.getFogCoordArray()->referenceCount() > 1) lhs.setFogCoordArray(cloneArray(lhs.getFogCoordArray(), vbo, &lhs)); lhs.getFogCoordArray()->reserveArray(sizes.mFogCoord); if (!merger.merge(lhs.getFogCoordArray(),rhs.getFogCoordArray())) { OSG_DEBUG << "MergeGeometry: fog coord array not merged. Some data may be lost." <<std::endl; } } else if (rhs.getFogCoordArray()) { lhs.setFogCoordArray(rhs.getFogCoordArray()); }
unsigned int unit; for(unit=0;unit<lhs.getNumTexCoordArrays();++unit) { if (!lhs.getTexCoordArray(unit)) continue; if (lhs.getTexCoordArray(unit)->referenceCount() > 1) lhs.setTexCoordArray(unit, cloneArray(lhs.getTexCoordArray(unit), vbo, &lhs)); osg::Array* const lhsArray = lhs.getTexCoordArray(unit); lhsArray->reserveArray(sizes.mTexCoord[unit]); if (!merger.merge(lhsArray, rhs.getTexCoordArray(unit))) { OSG_DEBUG << "MergeGeometry: tex coord array not merged. Some data may be lost." <<std::endl; } }
for(unit=0;unit<lhs.getNumVertexAttribArrays();++unit) { if (!lhs.getVertexAttribArray(unit)) continue; if (lhs.getVertexAttribArray(unit)->referenceCount() > 1) lhs.setVertexAttribArray(unit, cloneArray(lhs.getVertexAttribArray(unit), vbo, &lhs)); osg::Array* const lhsArray = lhs.getVertexAttribArray(unit); lhsArray->reserveArray(sizes.mVertexAttrib[unit]); if (!merger.merge(lhsArray, rhs.getVertexAttribArray(unit))) { OSG_DEBUG << "MergeGeometry: vertex attrib array not merged. Some data may be lost." <<std::endl; } }
// shift the indices of the incoming primitives to account for the pre existing geometry. osg::ElementBufferObject* ebo = nullptr; osg::Geometry::PrimitiveSetList::iterator primItr; for(primItr=rhs.getPrimitiveSetList().begin(); primItr!=rhs.getPrimitiveSetList().end(); ++primItr) { osg::PrimitiveSet* primitive = primItr->get();
switch(primitive->getType()) { case(osg::PrimitiveSet::DrawElementsUBytePrimitiveType): { osg::DrawElementsUByte* primitiveUByte = static_cast<osg::DrawElementsUByte*>(primitive); unsigned int currentMaximum = 0; for(osg::DrawElementsUByte::iterator eitr=primitiveUByte->begin(); eitr!=primitiveUByte->end(); ++eitr) { currentMaximum = osg::maximum(currentMaximum,(unsigned int)*eitr); } if ((base+currentMaximum)>=65536) { // must promote to a DrawElementsUInt osg::DrawElementsUInt* new_primitive = new osg::DrawElementsUInt(primitive->getMode()); if (!ebo) ebo = new osg::ElementBufferObject; new_primitive->setElementBufferObject(ebo); std::copy(primitiveUByte->begin(),primitiveUByte->end(),std::back_inserter(*new_primitive)); new_primitive->offsetIndices(base); (*primItr) = new_primitive; } else if ((base+currentMaximum)>=256) { // must promote to a DrawElementsUShort osg::DrawElementsUShort* new_primitive = new osg::DrawElementsUShort(primitive->getMode()); if (!ebo) ebo = new osg::ElementBufferObject; new_primitive->setElementBufferObject(ebo); std::copy(primitiveUByte->begin(),primitiveUByte->end(),std::back_inserter(*new_primitive)); new_primitive->offsetIndices(base); (*primItr) = new_primitive; } else { (*primItr) = clonePrimitive(primitive, ebo, &lhs); (*primItr)->offsetIndices(base); } } break;
case(osg::PrimitiveSet::DrawElementsUShortPrimitiveType): { osg::DrawElementsUShort* primitiveUShort = static_cast<osg::DrawElementsUShort*>(primitive); unsigned int currentMaximum = 0; for(osg::DrawElementsUShort::iterator eitr=primitiveUShort->begin(); eitr!=primitiveUShort->end(); ++eitr) { currentMaximum = osg::maximum(currentMaximum,(unsigned int)*eitr); } if ((base+currentMaximum)>=65536) { // must promote to a DrawElementsUInt osg::DrawElementsUInt* new_primitive = new osg::DrawElementsUInt(primitive->getMode()); if (!ebo) ebo = new osg::ElementBufferObject; new_primitive->setElementBufferObject(ebo); std::copy(primitiveUShort->begin(),primitiveUShort->end(),std::back_inserter(*new_primitive)); new_primitive->offsetIndices(base); (*primItr) = new_primitive; } else { (*primItr) = clonePrimitive(primitive, ebo, &lhs); (*primItr)->offsetIndices(base); } } break;
case(osg::PrimitiveSet::DrawArraysPrimitiveType): case(osg::PrimitiveSet::DrawArrayLengthsPrimitiveType): case(osg::PrimitiveSet::DrawElementsUIntPrimitiveType): default: (*primItr) = clonePrimitive(primitive, ebo, &lhs); (*primItr)->offsetIndices(base); break; } }
for(primItr=rhs.getPrimitiveSetList().begin(); primItr!=rhs.getPrimitiveSetList().end(); ++primItr) { lhs.addPrimitiveSet(primItr->get()); }
lhs.dirtyBound(); lhs.dirtyDisplayList();
if (osg::UserDataContainer* rhsUserData = rhs.getUserDataContainer()) for (unsigned int i=0; i<rhsUserData->getNumUserObjects(); ++i) lhs.getOrCreateUserDataContainer()->addUserObject(rhsUserData->getUserObject(i));
return true;}
bool Optimizer::MergeGeometryVisitor::mergePrimitive(osg::DrawArrays& lhs,osg::DrawArrays& rhs){ if (lhs.getFirst()+lhs.getCount()==rhs.getFirst()) { lhs.setCount(lhs.getCount()+rhs.getCount()); return true; } return false;}
bool Optimizer::MergeGeometryVisitor::mergePrimitive(osg::DrawArrayLengths& lhs,osg::DrawArrayLengths& rhs){ int lhs_count = std::accumulate(lhs.begin(),lhs.end(),0);
if (lhs.getFirst()+lhs_count==rhs.getFirst()) { lhs.insert(lhs.end(),rhs.begin(),rhs.end()); return true; } return false;}
bool Optimizer::MergeGeometryVisitor::mergePrimitive(osg::DrawElementsUByte& lhs,osg::DrawElementsUByte& rhs){ lhs.insert(lhs.end(),rhs.begin(),rhs.end()); return true;}
bool Optimizer::MergeGeometryVisitor::mergePrimitive(osg::DrawElementsUShort& lhs,osg::DrawElementsUShort& rhs){ lhs.insert(lhs.end(),rhs.begin(),rhs.end()); return true;}
bool Optimizer::MergeGeometryVisitor::mergePrimitive(osg::DrawElementsUInt& lhs,osg::DrawElementsUInt& rhs){ lhs.insert(lhs.end(),rhs.begin(),rhs.end()); return true;}
bool Optimizer::MergeGroupsVisitor::isOperationPermissible(osg::Group& node){ return !node.getCullCallback() && !node.getEventCallback() && !node.getUpdateCallback() && typeid(node)==typeid(osg::Group) && isOperationPermissibleForObject(&node);}
void Optimizer::MergeGroupsVisitor::apply(osg::LOD &lod){ // don't merge the direct children of the LOD because they are used to define each LOD level. traverse(lod);}
void Optimizer::MergeGroupsVisitor::apply(osg::Switch &switchNode){ // We should keep all switch child nodes since they reflect different switch states. traverse(switchNode);}
void Optimizer::MergeGroupsVisitor::apply(osg::Sequence &sequenceNode){ // We should keep all sequence child nodes since they reflect different sequence states. traverse(sequenceNode);}
void Optimizer::MergeGroupsVisitor::apply(osg::Group &group){ if (group.getNumChildren() <= 1) traverse(group); else { typedef std::map<osg::StateSet*, std::set<osg::Group*> > GroupMap; GroupMap childGroups; for (unsigned int i=0; i<group.getNumChildren(); ++i) { osg::Node* child = group.getChild(i); osg::Group* childGroup = child->asGroup(); if (childGroup && isOperationPermissible(*childGroup)) { childGroups[childGroup->getStateSet()].insert(childGroup); } }
for (GroupMap::iterator it = childGroups.begin(); it != childGroups.end(); ++it) { const std::set<osg::Group*>& groupSet = it->second; if (groupSet.size() <= 1) continue; else { osg::Group* first = *groupSet.begin(); for (std::set<osg::Group*>::const_iterator groupIt = ++groupSet.begin(); groupIt != groupSet.end(); ++groupIt) { osg::Group* toMerge = *groupIt; for (unsigned int i=0; i<toMerge->getNumChildren(); ++i) first->addChild(toMerge->getChild(i)); toMerge->removeChildren(0, toMerge->getNumChildren()); group.removeChild(toMerge); } } } traverse(group); }}
}
// NOLINTEND(readability-identifier-naming)
// clang-format on