avmedia/source/framework/modeltools.cxx | 3 configure.ac | 23 external/collada2gltf/StaticLibrary_collada2gltf.mk | 1 external/collada2gltf/UnpackedTarball_collada2gltf.mk | 1 external/collada2gltf/patches/kill_c++11_code.patch.1 | 5824 ++++++++++++++++++ 5 files changed, 5829 insertions(+), 23 deletions(-)
New commits: commit c48190a89507ad2a3e6e05c1281b014ad9be0552 Author: Zolnai Tamás <[email protected]> Date: Tue Sep 30 11:13:47 2014 +0200 fdo#84008: kill c++11 code from collada2gltf ... so older compliers can deal with it. Change-Id: I7ecfa37601cae2979a5285436596175d2ebe1fe4 Reviewed-on: https://gerrit.libreoffice.org/11706 Reviewed-by: Miklos Vajna <[email protected]> Tested-by: Miklos Vajna <[email protected]> diff --git a/avmedia/source/framework/modeltools.cxx b/avmedia/source/framework/modeltools.cxx index 8c4251e..872e00a 100644 --- a/avmedia/source/framework/modeltools.cxx +++ b/avmedia/source/framework/modeltools.cxx @@ -28,6 +28,7 @@ #include <boost/property_tree/json_parser.hpp> #include <boost/foreach.hpp> #include <boost/optional.hpp> +#include <boost/shared_ptr.hpp> #include <config_features.h> @@ -85,7 +86,7 @@ bool KmzDae2Gltf(const OUString& rSourceURL, OUString& o_rOutput) // remove .tmp extension sOutput = sOutput.copy(0, sOutput.getLength()-4); - std::shared_ptr <GLTF::GLTFAsset> asset(new GLTF::GLTFAsset()); + boost::shared_ptr <GLTF::GLTFAsset> asset(new GLTF::GLTFAsset()); asset->setBundleOutputPath(OUStringToOString( sOutput, RTL_TEXTENCODING_UTF8 ).getStr()); // If *.dae file is not in the local file system, then copy it to a temp folder for the conversion diff --git a/configure.ac b/configure.ac index 7aaa5d0..363eb2f 100644 --- a/configure.ac +++ b/configure.ac @@ -6364,27 +6364,6 @@ fi AC_SUBST(CXXFLAGS_CXX11) AC_SUBST(HAVE_CXX11) -AC_MSG_CHECKING([for std::shared_ptr]) -if test "$HAVE_CXX11" = "TRUE" -a "$GCC" = "yes"; then - save_CXXFLAGS=$CXXFLAGS - CXXFLAGS="$CXXFLAGS $CXXFLAGS_CXX11" - AC_LANG_PUSH([C++]) - AC_COMPILE_IFELSE([AC_LANG_PROGRAM([ - #include <memory> - using std::shared_ptr; - ])], - [ have_std_shared_ptr=yes ], - [ have_std_shared_ptr=no ] - ) - AC_LANG_POP([C++]) - CXXFLAGS=$save_CXXFLAGS -elif test "$COM" = "MSC"; then - have_std_shared_ptr=yes -else - have_std_shared_ptr=no -fi -AC_MSG_RESULT([$have_std_shared_ptr]) - dnl ================================== dnl Check for C++11 "= delete" support dnl ================================== @@ -10589,7 +10568,7 @@ dnl Check whether to enable COLLADA support dnl =================================================================== AC_MSG_CHECKING([whether to enable COLLADA support]) ENABLE_COLLADA= -if test "$enable_collada" != "no" -a "$ENABLE_GLTF" = "TRUE" -a "$have_std_shared_ptr" = "yes"; then +if test "$enable_collada" != "no" -a "$ENABLE_GLTF" = "TRUE"; then AC_MSG_RESULT([yes]) ENABLE_COLLADA=TRUE AC_DEFINE(HAVE_FEATURE_COLLADA,1) diff --git a/external/collada2gltf/StaticLibrary_collada2gltf.mk b/external/collada2gltf/StaticLibrary_collada2gltf.mk index a25f63d..9adb9d8 100644 --- a/external/collada2gltf/StaticLibrary_collada2gltf.mk +++ b/external/collada2gltf/StaticLibrary_collada2gltf.mk @@ -12,6 +12,7 @@ $(eval $(call gb_StaticLibrary_StaticLibrary,collada2gltf)) $(eval $(call gb_StaticLibrary_use_unpacked,collada2gltf,collada2gltf)) $(eval $(call gb_StaticLibrary_use_externals,collada2gltf, \ + boost_headers \ opencollada_parser \ png \ )) diff --git a/external/collada2gltf/UnpackedTarball_collada2gltf.mk b/external/collada2gltf/UnpackedTarball_collada2gltf.mk index b4c05f8..25c445b 100644 --- a/external/collada2gltf/UnpackedTarball_collada2gltf.mk +++ b/external/collada2gltf/UnpackedTarball_collada2gltf.mk @@ -15,6 +15,7 @@ $(eval $(call gb_UnpackedTarball_add_file,collada2gltf,.,external/collada2gltf/G $(eval $(call gb_UnpackedTarball_add_patches,collada2gltf,\ external/collada2gltf/patches/wrong_uri_usage.patch.1 \ + external/collada2gltf/patches/kill_c++11_code.patch.1 \ )) # vim: set noet sw=4 ts=4: diff --git a/external/collada2gltf/patches/kill_c++11_code.patch.1 b/external/collada2gltf/patches/kill_c++11_code.patch.1 new file mode 100644 index 0000000..daaa6d0 --- /dev/null +++ b/external/collada2gltf/patches/kill_c++11_code.patch.1 @@ -0,0 +1,5824 @@ +diff -ur collada2gltf.org/assetModifiers/GLTFAssetModifier.h collada2gltf/assetModifiers/GLTFAssetModifier.h +--- collada2gltf.org/assetModifiers/GLTFAssetModifier.h 2014-09-29 15:30:40.134494471 +0200 ++++ collada2gltf/assetModifiers/GLTFAssetModifier.h 2014-09-29 15:32:47.000000000 +0200 +@@ -24,6 +24,8 @@ + #ifndef __GLTFASSETMODIFIER__ + #define __GLTFASSETMODIFIER__ + ++#include <boost/shared_ptr.hpp> ++ + namespace GLTF + { + /* Abstract +@@ -33,7 +35,7 @@ + class GLTFAssetModifier { + public: + virtual bool init() { return true; }; +- virtual void modify(std::shared_ptr<JSONObject> glTFAsset) = 0; ++ virtual void modify(boost::shared_ptr<JSONObject> glTFAsset) = 0; + virtual void cleanup() { }; + virtual ~GLTFAssetModifier() {}; + }; +diff -ur collada2gltf.org/assetModifiers/GLTFFlipUVModifier.cpp collada2gltf/assetModifiers/GLTFFlipUVModifier.cpp +--- collada2gltf.org/assetModifiers/GLTFFlipUVModifier.cpp 2014-09-29 15:30:40.134494471 +0200 ++++ collada2gltf/assetModifiers/GLTFFlipUVModifier.cpp 2014-09-29 15:39:27.000000000 +0200 +@@ -65,21 +65,21 @@ + } + } + +- void GLTFFlipUVModifier::modify(shared_ptr<JSONObject> glTFAsset) { ++ void GLTFFlipUVModifier::modify(boost::shared_ptr<JSONObject> glTFAsset) { + if (glTFAsset->contains(kMeshes) == false) + return; + +- shared_ptr<JSONObject> meshes = glTFAsset->getObject(kMeshes); ++ boost::shared_ptr<JSONObject> meshes = glTFAsset->getObject(kMeshes); + std::vector <std::string> meshesUIDs = meshes->getAllKeys(); + + for (size_t i = 0 ; i < meshesUIDs.size() ; i++) { +- shared_ptr<GLTFMesh> mesh = static_pointer_cast<GLTFMesh>(meshes->getObject(meshesUIDs[i])); ++ boost::shared_ptr<GLTFMesh> mesh = boost::static_pointer_cast<GLTFMesh>(meshes->getObject(meshesUIDs[i])); + if (mesh->hasSemantic(GLTF::TEXCOORD)) { + //https://github.com/KhronosGroup/collada2json/issues/41 + + size_t attributesCount = mesh->getMeshAttributesCountForSemantic(GLTF::TEXCOORD); + for (size_t k = 0 ; k < attributesCount ; k++) { +- shared_ptr <GLTF::GLTFAccessor> meshAttribute = mesh->getMeshAttribute(GLTF::TEXCOORD, k); ++ boost::shared_ptr <GLTF::GLTFAccessor> meshAttribute = mesh->getMeshAttribute(GLTF::TEXCOORD, k); + meshAttribute->applyOnAccessor(__InvertV, NULL); + } + } +diff -ur collada2gltf.org/assetModifiers/GLTFFlipUVModifier.h collada2gltf/assetModifiers/GLTFFlipUVModifier.h +--- collada2gltf.org/assetModifiers/GLTFFlipUVModifier.h 2014-09-29 15:30:40.134494471 +0200 ++++ collada2gltf/assetModifiers/GLTFFlipUVModifier.h 2014-09-29 15:33:01.000000000 +0200 +@@ -24,6 +24,8 @@ + #ifndef __GLTFFLIPUVMODIFIER__ + #define __GLTFFLIPUVMODIFIER__ + ++#include <boost/shared_ptr.hpp> ++ + namespace GLTF + { + class GLTFFlipUVModifier : public GLTFAssetModifier { +@@ -32,7 +34,7 @@ + virtual ~GLTFFlipUVModifier(); + + virtual bool init(); +- virtual void modify(std::shared_ptr<JSONObject> glTFAsset); ++ virtual void modify(boost::shared_ptr<JSONObject> glTFAsset); + virtual void cleanup(); + }; + } +diff -ur collada2gltf.org/COLLADA2GLTFWriter.cpp collada2gltf/COLLADA2GLTFWriter.cpp +--- collada2gltf.org/COLLADA2GLTFWriter.cpp 2014-09-29 15:30:40.142494472 +0200 ++++ collada2gltf/COLLADA2GLTFWriter.cpp 2014-09-29 15:39:59.000000000 +0200 +@@ -48,7 +48,7 @@ + { + /* + */ +- COLLADA2GLTFWriter::COLLADA2GLTFWriter(shared_ptr<GLTFAsset> asset): ++ COLLADA2GLTFWriter::COLLADA2GLTFWriter(boost::shared_ptr<GLTFAsset> asset): + _asset(asset), + _visualScene(0) { + } +@@ -71,14 +71,17 @@ + //To comply with macro to access config + GLTFAsset *asset = this->_asset.get(); + asset->setExtras(this->_extraDataHandler->allExtras()); +- asset->prepareForProfile(shared_ptr <GLTFWebGL_1_0_Profile> (new GLTFWebGL_1_0_Profile())); ++ asset->prepareForProfile(boost::shared_ptr <GLTFWebGL_1_0_Profile> (new GLTFWebGL_1_0_Profile())); + + COLLADAFW::Root root(&this->_loader, this); + this->_loader.registerExtraDataCallbackHandler(this->_extraDataHandler); +- if (!root.loadDocument(asset->getInputFilePath())) ++ if (!root.loadDocument(asset->getInputFilePath())) { ++ delete _extraDataHandler; + return false; ++ } + + asset->write(); ++ delete _extraDataHandler; + + return true; + } +@@ -99,7 +102,7 @@ + //-------------------------------------------------------------------- + bool COLLADA2GLTFWriter::writeGlobalAsset( const COLLADAFW::FileInfo* globalAsset ) { + GLTFAsset* asset = this->_asset.get(); +- shared_ptr<JSONObject> assetObject = asset->root()->createObjectIfNeeded(kAsset); ++ boost::shared_ptr<JSONObject> assetObject = asset->root()->createObjectIfNeeded(kAsset); + std::string version = "collada2gltf@"+std::string(g_GIT_SHA1); + + assetObject->setString("generator",version); +@@ -127,7 +130,7 @@ + return getTransparency(effectCommon) >= 1; + } + +- void COLLADA2GLTFWriter::registerObjectWithOriginalUID(std::string originalId, shared_ptr <JSONObject> obj, shared_ptr <JSONObject> objLib) { ++ void COLLADA2GLTFWriter::registerObjectWithOriginalUID(std::string originalId, boost::shared_ptr <JSONObject> obj, boost::shared_ptr <JSONObject> objLib) { + if (this->_asset->_originalIDToTrackedObject.count(originalId) == 0) { + if (!objLib->contains(originalId)) { + objLib->setValue(originalId, obj); +@@ -149,13 +152,13 @@ + return; + } + +- shared_ptr <GLTFMesh> mesh = static_pointer_cast<GLTFMesh>(this->_asset->getValueForUniqueId(meshUID)); ++ boost::shared_ptr <GLTFMesh> mesh = boost::static_pointer_cast<GLTFMesh>(this->_asset->getValueForUniqueId(meshUID)); + this->_asset->setOriginalId(meshUID, mesh->getID()); + + MaterialBindingsForNodeUID& mb = this->_asset->materialBindingsForNodeUID(); +- shared_ptr <MaterialBindingsForMeshUID> materialBindingsMap; ++ boost::shared_ptr <MaterialBindingsForMeshUID> materialBindingsMap; + if (mb.count(nodeUID) == 0) { +- materialBindingsMap = shared_ptr<MaterialBindingsForMeshUID>(new MaterialBindingsForMeshUID()); ++ materialBindingsMap = boost::shared_ptr<MaterialBindingsForMeshUID>(new MaterialBindingsForMeshUID()); + mb[nodeUID] = materialBindingsMap; + } else { + materialBindingsMap = mb[nodeUID]; +@@ -163,9 +166,9 @@ + + //apply prefix on MeshUID + std::string prefixedMeshUID = prefix + meshUID; +- shared_ptr <MaterialBindingsPrimitiveMap> materialBindingsPrimitiveMap; ++ boost::shared_ptr <MaterialBindingsPrimitiveMap> materialBindingsPrimitiveMap; + if (materialBindingsMap->count(prefixedMeshUID) == 0) { +- materialBindingsPrimitiveMap = shared_ptr<MaterialBindingsPrimitiveMap> (new MaterialBindingsPrimitiveMap()); ++ materialBindingsPrimitiveMap = boost::shared_ptr<MaterialBindingsPrimitiveMap> (new MaterialBindingsPrimitiveMap()); + (*materialBindingsMap)[prefixedMeshUID] = materialBindingsPrimitiveMap; + } else { + materialBindingsPrimitiveMap = (*materialBindingsMap)[prefixedMeshUID]; +@@ -173,7 +176,7 @@ + + GLTF::JSONValueVector primitives = mesh->getPrimitives()->values(); + for (size_t j = 0 ; j < primitives.size() ; j++) { +- shared_ptr <GLTF::GLTFPrimitive> primitive = static_pointer_cast<GLTFPrimitive>(primitives[j]); ++ boost::shared_ptr <GLTF::GLTFPrimitive> primitive = boost::static_pointer_cast<GLTFPrimitive>(primitives[j]); + //FIXME: consider optimizing this with a hashtable, would be better if it was coming that way from OpenCOLLADA + int materialBindingIndex = -1; + for (size_t k = 0; k < materialBindings.getCount() ; k++) { +@@ -182,7 +185,7 @@ + } + } + if (materialBindingIndex != -1) { +- shared_ptr <COLLADAFW::MaterialBinding> materialBinding(new COLLADAFW::MaterialBinding(materialBindings[materialBindingIndex])); ++ boost::shared_ptr <COLLADAFW::MaterialBinding> materialBinding(new COLLADAFW::MaterialBinding(materialBindings[materialBindingIndex])); + (*materialBindingsPrimitiveMap)[primitive->getMaterialObjectID()] = materialBinding; + } + } +@@ -191,7 +194,7 @@ + + + bool COLLADA2GLTFWriter::writeNode( const COLLADAFW::Node* node, +- shared_ptr <GLTF::JSONObject> nodesObject, ++ boost::shared_ptr <GLTF::JSONObject> nodesObject, + COLLADABU::Math::Matrix4 parentMatrix, + SceneFlatteningInfo* sceneFlatteningInfo) { + GLTFAsset *asset = this->_asset.get(); +@@ -206,10 +209,10 @@ + + COLLADABU::Math::Matrix4 matrix = COLLADABU::Math::Matrix4::IDENTITY; + +- shared_ptr <GLTF::JSONObject> nodeObject(new GLTF::JSONObject()); ++ boost::shared_ptr <GLTF::JSONObject> nodeObject(new GLTF::JSONObject()); + nodeObject->setString(kName,node->getName()); + +- this->_asset->_uniqueIDToOpenCOLLADAObject[uniqueUID] = shared_ptr <COLLADAFW::Object> (node->clone()); ++ this->_asset->_uniqueIDToOpenCOLLADAObject[uniqueUID] = boost::shared_ptr <COLLADAFW::Object> (node->clone()); + this->_asset->setOriginalId(uniqueUID, nodeOriginalID); + this->_asset->setValueForUniqueId(uniqueUID, nodeObject); + if (node->getType() == COLLADAFW::Node::JOINT) { +@@ -222,7 +225,7 @@ + size_t camerasCount = instanceCameras.getCount(); + if (camerasCount > 0) { + InstanceCamera* instanceCamera = instanceCameras[0]; +- shared_ptr <GLTF::JSONObject> cameraObject(new GLTF::JSONObject()); ++ boost::shared_ptr <GLTF::JSONObject> cameraObject(new GLTF::JSONObject()); + + std::string cameraId = uniqueIdWithType(kCamera, instanceCamera->getInstanciatedObjectId()); + nodeObject->setString(kCamera, cameraId); +@@ -265,10 +268,10 @@ + if (!animationListID.isValid()) + continue; + +- shared_ptr<AnimatedTargets> animatedTargets(new AnimatedTargets()); ++ boost::shared_ptr<AnimatedTargets> animatedTargets(new AnimatedTargets()); + + this->_asset->_uniqueIDToAnimatedTargets[animationListID.toAscii()] = animatedTargets; +- shared_ptr <JSONObject> animatedTarget(new JSONObject()); ++ boost::shared_ptr <JSONObject> animatedTarget(new JSONObject()); + std::string animationID = animationListID.toAscii(); + animatedTarget->setString(kTarget, uniqueUID); + animatedTarget->setString("transformId", animationID); +@@ -326,16 +329,16 @@ + const InstanceControllerPointerArray& instanceControllers = node->getInstanceControllers(); + unsigned int count = (unsigned int)instanceControllers.getCount(); + if (count > 0) { +- shared_ptr<JSONObject> skins = this->_asset->root()->createObjectIfNeeded(kSkins); ++ boost::shared_ptr<JSONObject> skins = this->_asset->root()->createObjectIfNeeded(kSkins); + for (unsigned int i = 0 ; i < count; i++) { + InstanceController* instanceController = instanceControllers[i]; + MaterialBindingArray &materialBindings = instanceController->getMaterialBindings(); + COLLADAFW::UniqueId uniqueId = instanceController->getInstanciatedObjectId(); + if (asset->containsValueForUniqueId(uniqueId.toAscii())) { + +- shared_ptr<JSONString> skinControllerDataUID = static_pointer_cast<JSONString>(asset->getValueForUniqueId(uniqueId.toAscii())); ++ boost::shared_ptr<JSONString> skinControllerDataUID = boost::static_pointer_cast<JSONString>(asset->getValueForUniqueId(uniqueId.toAscii())); + +- shared_ptr<GLTFSkin> skin = static_pointer_cast<GLTFSkin>(skins->getObject(skinControllerDataUID->getString())); ++ boost::shared_ptr<GLTFSkin> skin = boost::static_pointer_cast<GLTFSkin>(skins->getObject(skinControllerDataUID->getString())); + + UniqueId meshUniqueId(skin->getSourceUID()); + _storeMaterialBindingArray("skin-meshes-", +@@ -344,7 +347,7 @@ + materialBindings); + + //write instanceController +- shared_ptr<JSONObject> serializedInstanceController(new JSONObject()); ++ boost::shared_ptr<JSONObject> serializedInstanceController(new JSONObject()); + + UniqueId skinDataUniqueId(skin->extras()->getString("uniqueId")); + +@@ -352,13 +355,13 @@ + Loader::InstanceControllerDataList list = this->_loader.getInstanceControllerDataListMap()[skinDataUniqueId]; + Loader::InstanceControllerData instanceControllerData = *list.begin(); + +- shared_ptr<JSONObject> instanceSkin(new JSONObject()); ++ boost::shared_ptr<JSONObject> instanceSkin(new JSONObject()); + +- shared_ptr<JSONArray> skeletons(new JSONArray()); ++ boost::shared_ptr<JSONArray> skeletons(new JSONArray()); + URIList::iterator listIterator; + for(listIterator = instanceControllerData.skeletonRoots.begin(); listIterator != instanceControllerData.skeletonRoots.end(); ++listIterator) { + std::string skeleton = listIterator->getFragment(); +- skeletons->appendValue(shared_ptr<JSONString>(new JSONString(skeleton))); ++ skeletons->appendValue(boost::shared_ptr<JSONString>(new JSONString(skeleton))); + } + + instanceSkin->setValue("skeletons", skeletons); +@@ -384,7 +387,7 @@ + } + } + +- shared_ptr <GLTF::JSONArray> childrenArray(new GLTF::JSONArray()); ++ boost::shared_ptr <GLTF::JSONArray> childrenArray(new GLTF::JSONArray()); + nodeObject->setValue(kChildren, childrenArray); + + count = (unsigned int)nodes.getCount(); +@@ -393,7 +396,7 @@ + if (childOriginalID.length() == 0) { + childOriginalID = uniqueIdWithType(kNode, nodes[i]->getUniqueId()); + } +- childrenArray->appendValue(shared_ptr <GLTF::JSONString> (new GLTF::JSONString(childOriginalID))); ++ childrenArray->appendValue(boost::shared_ptr <GLTF::JSONString> (new GLTF::JSONString(childOriginalID))); + } + + registerObjectWithOriginalUID(nodeOriginalID, nodeObject, nodesObject); +@@ -407,43 +410,43 @@ + for (unsigned int i = 0 ; i < count ; i++) { + InstanceNode* instanceNode = instanceNodes[i]; + std::string id = instanceNode->getInstanciatedObjectId().toAscii(); +- shared_ptr<JSONArray> parents; ++ boost::shared_ptr<JSONArray> parents; + if (this->_asset->_uniqueIDToParentsOfInstanceNode.count(id) == 0) { +- parents = shared_ptr<JSONArray> (new JSONArray()); ++ parents = boost::shared_ptr<JSONArray> (new JSONArray()); + this->_asset->_uniqueIDToParentsOfInstanceNode[id] = parents; + } else { + parents = this->_asset->_uniqueIDToParentsOfInstanceNode[id]; + } + +- parents->appendValue(shared_ptr<JSONString> (new JSONString(node->getUniqueId().toAscii()))); ++ parents->appendValue(boost::shared_ptr<JSONString> (new JSONString(node->getUniqueId().toAscii()))); + } + +- shared_ptr <GLTF::JSONArray> lightsInNode(new GLTF::JSONArray()); ++ boost::shared_ptr <GLTF::JSONArray> lightsInNode(new GLTF::JSONArray()); + + const InstanceLightPointerArray& instanceLights = node->getInstanceLights(); + count = (unsigned int)instanceLights.getCount(); + + //For a given light, keep track of all the nodes holding it + if (count) { +- shared_ptr<JSONObject> lights = this->_asset->root()->createObjectIfNeeded(kLights); ++ boost::shared_ptr<JSONObject> lights = this->_asset->root()->createObjectIfNeeded(kLights); + for (unsigned int i = 0 ; i < count ; i++) { + InstanceLight* instanceLight = instanceLights[i]; + std::string id = instanceLight->getInstanciatedObjectId().toAscii(); + +- shared_ptr<JSONObject> light = static_pointer_cast<JSONObject>(this->_asset->getValueForUniqueId(id)); ++ boost::shared_ptr<JSONObject> light = boost::static_pointer_cast<JSONObject>(this->_asset->getValueForUniqueId(id)); + if (light) { + std::string lightUID = this->_asset->getOriginalId(id); + +- shared_ptr<JSONArray> listOfNodesPerLight; ++ boost::shared_ptr<JSONArray> listOfNodesPerLight; + if (this->_asset->_uniqueIDOfLightToNodes.count(id) == 0) { +- listOfNodesPerLight = shared_ptr<JSONArray> (new JSONArray()); ++ listOfNodesPerLight = boost::shared_ptr<JSONArray> (new JSONArray()); + this->_asset->_uniqueIDOfLightToNodes[lightUID] = listOfNodesPerLight; + } else { + listOfNodesPerLight = this->_asset->_uniqueIDOfLightToNodes[lightUID]; + } + + listOfNodesPerLight->appendValue(JSONSTRING(nodeOriginalID)); +- lightsInNode->appendValue(shared_ptr <JSONString> (new JSONString(lightUID))); ++ lightsInNode->appendValue(boost::shared_ptr <JSONString> (new JSONString(lightUID))); + lights->setValue(lightUID, light); + } + } +@@ -484,9 +487,9 @@ + //First collect all kind of meshAttributes available + size_t count = allMeshes.size(); + for (size_t i = 0 ; i < count ; i++) { +- shared_ptr <MeshFlatteningInfo> meshInfo = allMeshes[i]; ++ boost::shared_ptr <MeshFlatteningInfo> meshInfo = allMeshes[i]; + MeshVectorSharedPtr *meshes = this->_uniqueIDToMeshes[meshInfo->getUID()]; +- // shared_ptr <MeshAttributeVector> meshAttributes = mesh->meshAttributes(); ++ // boost::shared_ptr <MeshAttributeVector> meshAttributes = mesh->meshAttributes(); + } + */ + return true; +@@ -494,9 +497,9 @@ + + bool COLLADA2GLTFWriter::writeVisualScene( const COLLADAFW::VisualScene* visualScene ) { + //FIXME: only one visual scene assumed/handled +- shared_ptr <GLTF::JSONObject> scenesObject(new GLTF::JSONObject()); +- shared_ptr <GLTF::JSONObject> sceneObject(new GLTF::JSONObject()); +- shared_ptr <GLTF::JSONObject> nodesObject = this->_asset->root()->createObjectIfNeeded(kNodes); ++ boost::shared_ptr <GLTF::JSONObject> scenesObject(new GLTF::JSONObject()); ++ boost::shared_ptr <GLTF::JSONObject> sceneObject(new GLTF::JSONObject()); ++ boost::shared_ptr <GLTF::JSONObject> nodesObject = this->_asset->root()->createObjectIfNeeded(kNodes); + + const NodePointerArray& nodePointerArray = visualScene->getRootNodes(); + size_t nodeCount = nodePointerArray.getCount(); +@@ -507,7 +510,7 @@ + scenesObject->setValue("defaultScene", sceneObject); //FIXME: should use this id -> visualScene->getOriginalId() + + //first pass to output children name of our root node +- shared_ptr <GLTF::JSONArray> childrenArray(new GLTF::JSONArray()); ++ boost::shared_ptr <GLTF::JSONArray> childrenArray(new GLTF::JSONArray()); + sceneObject->setValue(kNodes, childrenArray); + + for (size_t i = 0 ; i < nodeCount ; i++) { +@@ -516,8 +519,8 @@ + nodeUID = uniqueIdWithType(kNode, nodePointerArray[i]->getUniqueId()); + } + +- shared_ptr <GLTF::JSONString> nodeIDValue(new GLTF::JSONString(nodeUID)); +- childrenArray->appendValue(static_pointer_cast <GLTF::JSONValue> (nodeIDValue)); ++ boost::shared_ptr <GLTF::JSONString> nodeIDValue(new GLTF::JSONString(nodeUID)); ++ childrenArray->appendValue(boost::static_pointer_cast <GLTF::JSONValue> (nodeIDValue)); + } + + for (size_t i = 0 ; i < nodeCount ; i++) { +@@ -537,7 +540,7 @@ + bool COLLADA2GLTFWriter::writeLibraryNodes( const COLLADAFW::LibraryNodes* libraryNodes ) { + const NodePointerArray& nodes = libraryNodes->getNodes(); + +- shared_ptr <GLTF::JSONObject> nodesObject = this->_asset->root()->createObjectIfNeeded(kNodes); ++ boost::shared_ptr <GLTF::JSONObject> nodesObject = this->_asset->root()->createObjectIfNeeded(kNodes); + + size_t count = nodes.getCount(); + for (size_t i = 0 ; i < count ; i++) { +@@ -545,15 +548,15 @@ + + std::string id = node->getUniqueId().toAscii(); + if (this->_asset->_uniqueIDToParentsOfInstanceNode.count(id) > 0) { +- shared_ptr<JSONArray> parents = this->_asset->_uniqueIDToParentsOfInstanceNode[id]; +- std::vector <shared_ptr <JSONValue> > values = parents->values(); ++ boost::shared_ptr<JSONArray> parents = this->_asset->_uniqueIDToParentsOfInstanceNode[id]; ++ std::vector <boost::shared_ptr <JSONValue> > values = parents->values(); + for (size_t k = 0 ; k < values.size() ; k++) { +- shared_ptr<JSONString> value = static_pointer_cast<JSONString>(values[k]); ++ boost::shared_ptr<JSONString> value = boost::static_pointer_cast<JSONString>(values[k]); + +- shared_ptr<JSONObject> parentNode = static_pointer_cast<JSONObject>(this->_asset->getValueForUniqueId(value->getString())); ++ boost::shared_ptr<JSONObject> parentNode = boost::static_pointer_cast<JSONObject>(this->_asset->getValueForUniqueId(value->getString())); + if (parentNode) { +- shared_ptr <JSONArray> children = parentNode->createArrayIfNeeded(kChildren); +- children->appendValue(shared_ptr <JSONString>(new JSONString(node->getOriginalId()))); ++ boost::shared_ptr <JSONArray> children = parentNode->createArrayIfNeeded(kChildren); ++ children->appendValue(boost::shared_ptr <JSONString>(new JSONString(node->getOriginalId()))); + } + } + } +@@ -573,8 +576,8 @@ + const COLLADAFW::Mesh* mesh = (COLLADAFW::Mesh*)geometry; + std::string meshUID = geometry->getUniqueId().toAscii(); + if (this->_asset->containsValueForUniqueId(meshUID) == false) { +- shared_ptr<GLTFMesh> cvtMesh = convertOpenCOLLADAMesh((COLLADAFW::Mesh*)mesh, this->_asset.get()); +- if (cvtMesh != nullptr) { ++ boost::shared_ptr<GLTFMesh> cvtMesh = convertOpenCOLLADAMesh((COLLADAFW::Mesh*)mesh, this->_asset.get()); ++ if (cvtMesh != 0) { + this->_asset->root()->createObjectIfNeeded(kMeshes)->setValue(cvtMesh->getID(), cvtMesh); + this->_asset->setValueForUniqueId(meshUID, cvtMesh); + } +@@ -660,14 +663,14 @@ + + std::string samplerUID = "sampler_"+GLTFUtils::toString(index); + if (addSampler) { +- shared_ptr <JSONObject> sampler2D(new JSONObject()); ++ boost::shared_ptr <JSONObject> sampler2D(new JSONObject()); + + sampler2D->setUnsignedInt32("wrapS", wrapS); + sampler2D->setUnsignedInt32("wrapT", wrapT); + sampler2D->setUnsignedInt32("minFilter", minFilter); + sampler2D->setUnsignedInt32("magFilter", maxFilter); + +- shared_ptr <GLTF::JSONObject> samplers = this->_asset->root()->createObjectIfNeeded("samplers"); ++ boost::shared_ptr <GLTF::JSONObject> samplers = this->_asset->root()->createObjectIfNeeded("samplers"); + samplers->setValue(samplerUID, sampler2D); + } + +@@ -678,18 +681,18 @@ + void COLLADA2GLTFWriter::_installTextureSlot(Sampler* sampler, + const std::string& slotName, + const std::string& texcoord, +- shared_ptr <GLTFAsset> asset, +- shared_ptr<GLTFEffect> cvtEffect) ++ boost::shared_ptr <GLTFAsset> asset, ++ boost::shared_ptr<GLTFEffect> cvtEffect) + { + assert(sampler); + assert(asset); + assert(cvtEffect); +- shared_ptr <JSONObject> values = cvtEffect->getValues(); ++ boost::shared_ptr <JSONObject> values = cvtEffect->getValues(); + std::string originalImageUID = asset->getOriginalId(sampler->getSourceImage().toAscii()); + GLTFProfile* profile = asset->profile().get(); + + cvtEffect->addSemanticForTexcoordName(texcoord, slotName); +- shared_ptr <JSONObject> slotObject(new JSONObject()); ++ boost::shared_ptr <JSONObject> slotObject(new JSONObject()); + + //do we need to export a new texture ? if yes compose a new unique ID + slotObject->setUnsignedInt32("type", profile->getGLenumForString("SAMPLER_2D")); +@@ -701,9 +704,9 @@ + __GetFilterMode(sampler->getMagFilter(), profile)); + + std::string textureUID = "texture_" + originalImageUID; +- shared_ptr <GLTF::JSONObject> textures = asset->root()->createObjectIfNeeded("textures"); ++ boost::shared_ptr <GLTF::JSONObject> textures = asset->root()->createObjectIfNeeded("textures"); + if (textures->contains(textureUID) == false) { +- shared_ptr <JSONObject> textureObject(new JSONObject()); ++ boost::shared_ptr <JSONObject> textureObject(new JSONObject()); + textureObject->setString(kSource, originalImageUID); + textureObject->setString("sampler", samplerUID); + textureObject->setUnsignedInt32("format", profile->getGLenumForString("RGBA")); +@@ -723,9 +726,9 @@ + + void COLLADA2GLTFWriter::handleEffectSlot(const COLLADAFW::EffectCommon* commonProfile, + std::string slotName, +- shared_ptr <GLTFEffect> cvtEffect, +- shared_ptr <JSONObject> extras) { +- shared_ptr <JSONObject> values = cvtEffect->getValues(); ++ boost::shared_ptr <GLTFEffect> cvtEffect, ++ boost::shared_ptr <JSONObject> extras) { ++ boost::shared_ptr <JSONObject> values = cvtEffect->getValues(); + GLTFAsset *asset = this->_asset.get(); + GLTFProfile* profile = asset->profile().get(); + +@@ -754,9 +757,9 @@ + //here we handle an extras slot + //for other extras, this will need refactoring + if (extras->contains("textures")) { +- shared_ptr <JSONObject> textures = extras->getObject("textures"); ++ boost::shared_ptr <JSONObject> textures = extras->getObject("textures"); + if (textures->contains("bump")) { +- shared_ptr <JSONObject> bump = textures->getObject("bump"); ++ boost::shared_ptr <JSONObject> bump = textures->getObject("bump"); + + std::string texture = bump->getString("texture"); + std::string texcoord = bump->getString("texcoord"); +@@ -782,7 +785,7 @@ + blue = color.getBlue(); + alpha = color.getAlpha(); + } +- shared_ptr <JSONObject> slotObject(new JSONObject()); ++ boost::shared_ptr <JSONObject> slotObject(new JSONObject()); + slotObject->setValue("value", serializeVec4(red, green, blue, alpha)); + slotObject->setUnsignedInt32("type", profile->getGLenumForString("FLOAT_VEC4")); + values->setValue(slotName, slotObject); +@@ -812,8 +815,8 @@ + #endif + uniqueId += GLTF::GLTFUtils::toString(effect->getUniqueId().getObjectId());; + +- shared_ptr <GLTFEffect> cvtEffect(new GLTFEffect(effect->getOriginalId())); +- shared_ptr <JSONObject> values(new JSONObject()); ++ boost::shared_ptr <GLTFEffect> cvtEffect(new GLTFEffect(effect->getOriginalId())); ++ boost::shared_ptr <JSONObject> values(new JSONObject()); + + cvtEffect->setValues(values); + +@@ -836,7 +839,7 @@ + break; + } + +- shared_ptr<JSONObject> extras = this->_extraDataHandler->getExtras(effect->getUniqueId()); ++ boost::shared_ptr<JSONObject> extras = this->_extraDataHandler->getExtras(effect->getUniqueId()); + + handleEffectSlot(effectCommon,"diffuse" , cvtEffect, extras); + handleEffectSlot(effectCommon,"ambient" , cvtEffect, extras); +@@ -846,14 +849,14 @@ + handleEffectSlot(effectCommon,"bump" , cvtEffect, extras); + + if (CONFIG_BOOL(asset, "alwaysExportFilterColor")) { +- shared_ptr <JSONObject> slotObject(new JSONObject()); ++ boost::shared_ptr <JSONObject> slotObject(new JSONObject()); + slotObject->setValue("value", serializeVec4(1, 1, 1, 1)); + slotObject->setUnsignedInt32("type", profile->getGLenumForString("FLOAT_VEC4")); + values->setValue("filterColor", slotObject); + } + + if (!isOpaque(effectCommon) || CONFIG_BOOL(asset, "alwaysExportTransparency")) { +- shared_ptr <JSONObject> transparency(new JSONObject()); ++ boost::shared_ptr <JSONObject> transparency(new JSONObject()); + transparency->setDouble("value", this->getTransparency(effectCommon)); + transparency->setUnsignedInt32("type", profile->getGLenumForString("FLOAT")); + values->setValue("transparency", transparency); +@@ -865,13 +868,13 @@ + if (shininess < 1) { + shininess *= 128.0; + } +- shared_ptr <JSONObject> shininessObject(new JSONObject()); ++ boost::shared_ptr <JSONObject> shininessObject(new JSONObject()); + shininessObject->setUnsignedInt32("type", profile->getGLenumForString("FLOAT")); + shininessObject->setDouble("value", shininess); + values->setValue("shininess", shininessObject); + } + +- shared_ptr<JSONObject> materials = this->_asset->root()->createObjectIfNeeded(kMaterials); ++ boost::shared_ptr<JSONObject> materials = this->_asset->root()->createObjectIfNeeded(kMaterials); + materials->setValue(cvtEffect->getID(), cvtEffect); + this->_asset->setValueForUniqueId(effect->getUniqueId().toAscii(), cvtEffect); + +@@ -881,14 +884,14 @@ + + //-------------------------------------------------------------------- + bool COLLADA2GLTFWriter::writeCamera( const COLLADAFW::Camera* camera ) { +- shared_ptr <GLTF::JSONObject> camerasObject = static_pointer_cast <GLTF::JSONObject> (this->_asset->root()->getValue("cameras")); ++ boost::shared_ptr <GLTF::JSONObject> camerasObject = boost::static_pointer_cast <GLTF::JSONObject> (this->_asset->root()->getValue("cameras")); + if (!camerasObject) { +- camerasObject = shared_ptr <GLTF::JSONObject> (new GLTF::JSONObject()); ++ camerasObject = boost::shared_ptr <GLTF::JSONObject> (new GLTF::JSONObject()); + this->_asset->root()->setValue("cameras", camerasObject); + } + +- shared_ptr <GLTF::JSONObject> cameraObject(new GLTF::JSONObject()); +- shared_ptr <GLTF::JSONObject> projectionObject(new GLTF::JSONObject()); ++ boost::shared_ptr <GLTF::JSONObject> cameraObject(new GLTF::JSONObject()); ++ boost::shared_ptr <GLTF::JSONObject> projectionObject(new GLTF::JSONObject()); + + std::string id = uniqueIdWithType(kCamera, camera->getUniqueId()); + +@@ -968,8 +971,8 @@ + + //-------------------------------------------------------------------- + bool COLLADA2GLTFWriter::writeImage( const COLLADAFW::Image* openCOLLADAImage ) { +- shared_ptr <GLTF::JSONObject> images = this->_asset->root()->createObjectIfNeeded(kImages); +- shared_ptr <GLTF::JSONObject> image(new GLTF::JSONObject()); ++ boost::shared_ptr <GLTF::JSONObject> images = this->_asset->root()->createObjectIfNeeded(kImages); ++ boost::shared_ptr <GLTF::JSONObject> image(new GLTF::JSONObject()); + + std::string imageUID = openCOLLADAImage->getUniqueId().toAscii(); + this->_asset->setValueForUniqueId(imageUID, image); +@@ -992,8 +995,8 @@ + //-------------------------------------------------------------------- + bool COLLADA2GLTFWriter::writeLight( const COLLADAFW::Light* light ) { + //FIXME: add projection +- shared_ptr <JSONObject> glTFLight(new JSONObject()); +- shared_ptr <JSONObject> description(new JSONObject()); ++ boost::shared_ptr <JSONObject> glTFLight(new JSONObject()); ++ boost::shared_ptr <JSONObject> description(new JSONObject()); + + COLLADAFW::Light::LightType lightType = light->getLightType(); + Color color = light->getColor(); +@@ -1002,7 +1005,7 @@ + float linearAttenuation = (float)light->getLinearAttenuation().getValue(); + float quadraticAttenuation = (float)light->getQuadraticAttenuation().getValue(); + +- shared_ptr <JSONValue> lightColor = serializeVec3(color.getRed(), color.getGreen(), color.getBlue()); ++ boost::shared_ptr <JSONValue> lightColor = serializeVec3(color.getRed(), color.getGreen(), color.getBlue()); + + switch (lightType) { + case COLLADAFW::Light::AMBIENT_LIGHT: +@@ -1014,9 +1017,9 @@ + case COLLADAFW::Light::POINT_LIGHT: { + glTFLight->setString("type", "point"); + +- description->setValue("constantAttenuation", shared_ptr <JSONNumber> (new JSONNumber(constantAttenuation))); +- description->setValue("linearAttenuation", shared_ptr <JSONNumber> (new JSONNumber(linearAttenuation))); +- description->setValue("quadraticAttenuation", shared_ptr <JSONNumber> (new JSONNumber(quadraticAttenuation))); ++ description->setValue("constantAttenuation", boost::shared_ptr <JSONNumber> (new JSONNumber(constantAttenuation))); ++ description->setValue("linearAttenuation", boost::shared_ptr <JSONNumber> (new JSONNumber(linearAttenuation))); ++ description->setValue("quadraticAttenuation", boost::shared_ptr <JSONNumber> (new JSONNumber(quadraticAttenuation))); + } + break; + case COLLADAFW::Light::SPOT_LIGHT: { +@@ -1025,12 +1028,12 @@ + float fallOffAngle = (float)light->getFallOffAngle().getValue(); + float fallOffExponent = (float)light->getFallOffExponent().getValue(); + +- description->setValue("constantAttenuation", shared_ptr <JSONNumber> (new JSONNumber(constantAttenuation))); +- description->setValue("linearAttenuation", shared_ptr <JSONNumber> (new JSONNumber(linearAttenuation))); +- description->setValue("quadraticAttenuation", shared_ptr <JSONNumber> (new JSONNumber(quadraticAttenuation))); ++ description->setValue("constantAttenuation", boost::shared_ptr <JSONNumber> (new JSONNumber(constantAttenuation))); ++ description->setValue("linearAttenuation", boost::shared_ptr <JSONNumber> (new JSONNumber(linearAttenuation))); ++ description->setValue("quadraticAttenuation", boost::shared_ptr <JSONNumber> (new JSONNumber(quadraticAttenuation))); + +- description->setValue("fallOffAngle", shared_ptr <JSONNumber> (new JSONNumber(fallOffAngle))); +- description->setValue("fallOffExponent", shared_ptr <JSONNumber> (new JSONNumber(fallOffExponent))); ++ description->setValue("fallOffAngle", boost::shared_ptr <JSONNumber> (new JSONNumber(fallOffAngle))); ++ description->setValue("fallOffExponent", boost::shared_ptr <JSONNumber> (new JSONNumber(fallOffExponent))); + } + break; + default: +@@ -1044,23 +1047,23 @@ + this->_asset->setValueForUniqueId(lightId, glTFLight); + this->_asset->setOriginalId(lightId, light->getOriginalId()); + +- shared_ptr<JSONArray> lightsIds = this->_asset->root()->createArrayIfNeeded("lightsIds"); +- lightsIds->appendValue(shared_ptr<JSONString>(new JSONString(light->getOriginalId()))); ++ boost::shared_ptr<JSONArray> lightsIds = this->_asset->root()->createArrayIfNeeded("lightsIds"); ++ lightsIds->appendValue(boost::shared_ptr<JSONString>(new JSONString(light->getOriginalId()))); + + return true; + } + + //-------------------------------------------------------------------- + bool COLLADA2GLTFWriter::writeAnimation( const COLLADAFW::Animation* animation) { +- shared_ptr <GLTFAnimation> cvtAnimation = convertOpenCOLLADAAnimationToGLTFAnimation(animation, this->_asset.get()); ++ boost::shared_ptr <GLTFAnimation> cvtAnimation = convertOpenCOLLADAAnimationToGLTFAnimation(animation, this->_asset.get()); + + cvtAnimation->setOriginalID(animation->getOriginalId()); + + if (this->_asset->_flattenerMapsForAnimationID.count(animation->getOriginalId()) == 0) { +- this->_asset->_flattenerMapsForAnimationID[animation->getOriginalId()] = shared_ptr <AnimationFlattenerForTargetUID> (new AnimationFlattenerForTargetUID()); ++ this->_asset->_flattenerMapsForAnimationID[animation->getOriginalId()] = boost::shared_ptr <AnimationFlattenerForTargetUID> (new AnimationFlattenerForTargetUID()); + } + +- shared_ptr<JSONObject> animations = this->_asset->root()->createObjectIfNeeded("animations"); ++ boost::shared_ptr<JSONObject> animations = this->_asset->root()->createObjectIfNeeded("animations"); + animations->setValue(animation->getUniqueId().toAscii(), cvtAnimation); + + return true; +@@ -1070,23 +1073,23 @@ + bool COLLADA2GLTFWriter::writeAnimationList( const COLLADAFW::AnimationList* animationList ) { + const COLLADAFW::AnimationList::AnimationBindings &animationBindings = animationList->getAnimationBindings(); + +- shared_ptr<JSONObject> animations = this->_asset->root()->createObjectIfNeeded("animations"); ++ boost::shared_ptr<JSONObject> animations = this->_asset->root()->createObjectIfNeeded("animations"); + AnimatedTargetsSharedPtr animatedTargets = this->_asset->_uniqueIDToAnimatedTargets[animationList->getUniqueId().toAscii()]; + + for (size_t i = 0 ; i < animationBindings.getCount() ; i++) { + const COLLADAFW::AnimationList::AnimationClass animationClass = animationBindings[i].animationClass; + +- shared_ptr <GLTFAnimation> cvtAnimation = static_pointer_cast<GLTFAnimation>(animations->getObject(animationBindings[i].animation.toAscii())); ++ boost::shared_ptr <GLTFAnimation> cvtAnimation = boost::static_pointer_cast<GLTFAnimation>(animations->getObject(animationBindings[i].animation.toAscii())); + + AnimationFlattenerForTargetUIDSharedPtr animationFlattenerMap = this->_asset->_flattenerMapsForAnimationID[cvtAnimation->getOriginalID()]; + for (size_t j = 0 ; j < animatedTargets->size() ; j++) { +- shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[j]; +- shared_ptr<GLTFAnimationFlattener> animationFlattener; ++ boost::shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[j]; ++ boost::shared_ptr<GLTFAnimationFlattener> animationFlattener; + std::string targetUID = animatedTarget->getString(kTarget); + if (animationFlattenerMap->count(targetUID) == 0) { + //FIXME: assuming node here is wrong + COLLADAFW::Node *node = (COLLADAFW::Node*)this->_asset->_uniqueIDToOpenCOLLADAObject[targetUID].get(); +- animationFlattener = shared_ptr<GLTFAnimationFlattener> (new GLTFAnimationFlattener(node)); ++ animationFlattener = boost::shared_ptr<GLTFAnimationFlattener> (new GLTFAnimationFlattener(node)); + (*animationFlattenerMap)[targetUID] = animationFlattener; + } + } +@@ -1104,8 +1107,8 @@ + + //-------------------------------------------------------------------- + bool COLLADA2GLTFWriter::writeSkinControllerData( const COLLADAFW::SkinControllerData* skinControllerData ) { +- shared_ptr <GLTFSkin> glTFSkin(new GLTFSkin(skinControllerData->getOriginalId())); +- shared_ptr <GLTFProfile> profile = this->_asset->profile(); ++ boost::shared_ptr <GLTFSkin> glTFSkin(new GLTFSkin(skinControllerData->getOriginalId())); ++ boost::shared_ptr <GLTFProfile> profile = this->_asset->profile(); + + glTFSkin->extras()->setString("uniqueId", skinControllerData->getUniqueId().toAscii()); + glTFSkin->setBindShapeMatrix(serializeOpenCOLLADAMatrix4(skinControllerData->getBindShapeMatrix())); +@@ -1169,23 +1172,23 @@ + for (size_t i = 0 ; i < skinControllerData->getJointsCount() ; i++) { + fillFloatPtrFromOpenCOLLADAMatrix4(matrices[i], matricesPtr + (i*16)); + } +- shared_ptr <GLTFBufferView> inverseBindMatricesView = createBufferViewWithAllocatedBuffer(matricesPtr, 0, matricesSize, true); ++ boost::shared_ptr <GLTFBufferView> inverseBindMatricesView = createBufferViewWithAllocatedBuffer(matricesPtr, 0, matricesSize, true); + glTFSkin->setInverseBindMatrices(inverseBindMatricesView); + +- shared_ptr<JSONObject> inverseBindMatrices(new JSONObject()); ++ boost::shared_ptr<JSONObject> inverseBindMatrices(new JSONObject()); + inverseBindMatrices->setUnsignedInt32(kType, profile->getGLenumForString("FLOAT_MAT4")); + inverseBindMatrices->setUnsignedInt32(kCount, (unsigned int)skinControllerData->getJointsCount()); + inverseBindMatrices->setUnsignedInt32(kByteOffset, 0); + glTFSkin->extras()->setValue(kInverseBindMatrices, inverseBindMatrices); + +- shared_ptr<GLTFOutputStream> animationOutputStream = this->_asset->createOutputStreamIfNeeded(this->_asset->getSharedBufferId()); ++ boost::shared_ptr<GLTFOutputStream> animationOutputStream = this->_asset->createOutputStreamIfNeeded(this->_asset->getSharedBufferId()); + inverseBindMatrices->setUnsignedInt32(kByteOffset, (unsigned int)animationOutputStream->length()); +- shared_ptr<GLTFBuffer> buffer = glTFSkin->getInverseBindMatrices()->getBuffer(); ++ boost::shared_ptr<GLTFBuffer> buffer = glTFSkin->getInverseBindMatrices()->getBuffer(); + animationOutputStream->write(buffer); + + // +- shared_ptr <GLTFBufferView> weightsView = createBufferViewWithAllocatedBuffer(weightsPtr, 0, skinAttributeSize, true); +- shared_ptr <GLTFAccessor> weightsAttribute(new GLTFAccessor(profile, profile->getGLTypeForComponentType(GLTF::FLOAT, bucketSize))); ++ boost::shared_ptr <GLTFBufferView> weightsView = createBufferViewWithAllocatedBuffer(weightsPtr, 0, skinAttributeSize, true); ++ boost::shared_ptr <GLTFAccessor> weightsAttribute(new GLTFAccessor(profile, profile->getGLTypeForComponentType(GLTF::FLOAT, bucketSize))); + + weightsAttribute->setBufferView(weightsView); + weightsAttribute->setByteStride(componentSize * bucketSize); +@@ -1193,8 +1196,8 @@ + + glTFSkin->setWeights(weightsAttribute); + +- shared_ptr <GLTFBufferView> jointsView = createBufferViewWithAllocatedBuffer(bonesIndices, 0, skinAttributeSize, true); +- shared_ptr <GLTFAccessor> jointsAttribute(new GLTFAccessor(profile, profile->getGLTypeForComponentType(GLTF::FLOAT, bucketSize))); ++ boost::shared_ptr <GLTFBufferView> jointsView = createBufferViewWithAllocatedBuffer(bonesIndices, 0, skinAttributeSize, true); ++ boost::shared_ptr <GLTFAccessor> jointsAttribute(new GLTFAccessor(profile, profile->getGLTypeForComponentType(GLTF::FLOAT, bucketSize))); + + jointsAttribute->setBufferView(jointsView); + jointsAttribute->setByteStride(componentSize * bucketSize); +@@ -1203,7 +1206,7 @@ + glTFSkin->setJoints(jointsAttribute); + glTFSkin->setJointsCount(skinControllerData->getJointsCount()); + +- shared_ptr<JSONObject> skins = this->_asset->root()->createObjectIfNeeded(kSkins); ++ boost::shared_ptr<JSONObject> skins = this->_asset->root()->createObjectIfNeeded(kSkins); + + //Also we work around here what looks to be a bug in OpenCOLLADA with a fileId == 0 + COLLADAFW::UniqueId uniqueId = skinControllerData->getUniqueId(); +@@ -1216,12 +1219,12 @@ + + //-------------------------------------------------------------------- + +- static shared_ptr<GLTFAccessor> __CreateAttributeByApplyingRemapTable(shared_ptr<GLTFAccessor> meshAttribute, size_t vertexCount, unsigned int* remapTableForPositions, shared_ptr<GLTFProfile> profile) { ++ static boost::shared_ptr<GLTFAccessor> __CreateAttributeByApplyingRemapTable(boost::shared_ptr<GLTFAccessor> meshAttribute, size_t vertexCount, unsigned int* remapTableForPositions, boost::shared_ptr<GLTFProfile> profile) { + unsigned char* sourcePtr = (unsigned char*)meshAttribute->getBufferView()->getBufferDataByApplyingOffset(); + size_t bufferSize = meshAttribute->elementByteLength() * vertexCount; + unsigned char* destinationPtr = (unsigned char*)malloc(bufferSize); + +- shared_ptr <GLTFAccessor> targetAttribute(new GLTFAccessor(profile, profile->getGLTypeForComponentType(meshAttribute->componentType(), meshAttribute->componentsPerElement()))); ++ boost::shared_ptr <GLTFAccessor> targetAttribute(new GLTFAccessor(profile, profile->getGLTypeForComponentType(meshAttribute->componentType(), meshAttribute->componentsPerElement()))); + targetAttribute->setByteStride(meshAttribute->getByteStride()); + targetAttribute->setCount(vertexCount); + +@@ -1233,7 +1236,7 @@ + memcpy(ptrDst, ptrSrc , meshAttribute->elementByteLength()); + } + +- shared_ptr<GLTFBufferView> targetView = createBufferViewWithAllocatedBuffer(destinationPtr, 0, bufferSize, true); ++ boost::shared_ptr<GLTFBufferView> targetView = createBufferViewWithAllocatedBuffer(destinationPtr, 0, bufferSize, true); + targetAttribute->setBufferView(targetView); + + return targetAttribute; +@@ -1244,40 +1247,40 @@ + COLLADAFW::SkinController* skinController = (COLLADAFW::SkinController*)controller; + + //Now we get the skin and the mesh, and +- shared_ptr<JSONObject> skins = this->_asset->root()->createObjectIfNeeded(kSkins); ++ boost::shared_ptr<JSONObject> skins = this->_asset->root()->createObjectIfNeeded(kSkins); + + COLLADAFW::UniqueId uniqueId = skinController->getSkinControllerData().toAscii(); + +- shared_ptr <GLTFSkin> glTFSkin = static_pointer_cast<GLTFSkin>(skins->getValue(uniqueId.toAscii())); +- shared_ptr<GLTFMesh> mesh = static_pointer_cast<GLTFMesh>(this->_asset->getValueForUniqueId(skinController->getSource().toAscii())); ++ boost::shared_ptr <GLTFSkin> glTFSkin = boost::static_pointer_cast<GLTFSkin>(skins->getValue(uniqueId.toAscii())); ++ boost::shared_ptr<GLTFMesh> mesh = boost::static_pointer_cast<GLTFMesh>(this->_asset->getValueForUniqueId(skinController->getSource().toAscii())); + this->_asset->setValueForUniqueId(controller->getUniqueId().toAscii(), +- shared_ptr<JSONString> (new JSONString(uniqueId.toAscii()))); ++ boost::shared_ptr<JSONString> (new JSONString(uniqueId.toAscii()))); + glTFSkin->setSourceUID(skinController->getSource().toAscii()); + + unsigned int *remapTableForPositions = mesh->getRemapTableForPositions(); + size_t vertexCount = mesh->getMeshAttribute(GLTF::POSITION, 0)->getCount(); + //Now we remap the bone indices and weight attribute in respect of deindexing we have + +- shared_ptr<GLTFAccessor> weightsAttribute = __CreateAttributeByApplyingRemapTable(glTFSkin->getWeights(), vertexCount, remapTableForPositions, this->_asset->profile()); ++ boost::shared_ptr<GLTFAccessor> weightsAttribute = __CreateAttributeByApplyingRemapTable(glTFSkin->getWeights(), vertexCount, remapTableForPositions, this->_asset->profile()); + + mesh->setMeshAttribute(GLTF::WEIGHT, 0, weightsAttribute); + +- shared_ptr<GLTFAccessor> jointsAttribute = __CreateAttributeByApplyingRemapTable(glTFSkin->getJoints(), vertexCount, remapTableForPositions, this->_asset->profile()); ++ boost::shared_ptr<GLTFAccessor> jointsAttribute = __CreateAttributeByApplyingRemapTable(glTFSkin->getJoints(), vertexCount, remapTableForPositions, this->_asset->profile()); + + mesh->setMeshAttribute(GLTF::JOINT, 0, jointsAttribute); + + GLTF::JSONValueVector primitives = mesh->getPrimitives()->values(); + for (size_t i = 0 ; i < primitives.size() ; i++) { +- shared_ptr<GLTFPrimitive> primitive = static_pointer_cast<GLTFPrimitive>(primitives[i]); +- primitive->appendVertexAttribute(shared_ptr <GLTF::JSONVertexAttribute>( new GLTF::JSONVertexAttribute(GLTF::JOINT,0))); +- primitive->appendVertexAttribute(shared_ptr <GLTF::JSONVertexAttribute>( new GLTF::JSONVertexAttribute(GLTF::WEIGHT,0))); ++ boost::shared_ptr<GLTFPrimitive> primitive = boost::static_pointer_cast<GLTFPrimitive>(primitives[i]); ++ primitive->appendVertexAttribute(boost::shared_ptr <GLTF::JSONVertexAttribute>( new GLTF::JSONVertexAttribute(GLTF::JOINT,0))); ++ primitive->appendVertexAttribute(boost::shared_ptr <GLTF::JSONVertexAttribute>( new GLTF::JSONVertexAttribute(GLTF::WEIGHT,0))); + } + + //save the list of joints, first as uniqueIds, and then we will replace with sid's +- shared_ptr <JSONArray> joints(new JSONArray()); ++ boost::shared_ptr <JSONArray> joints(new JSONArray()); + UniqueIdArray& jointsUID = skinController->getJoints(); + for (size_t i = 0 ; i < jointsUID.getCount() ; i++) { +- shared_ptr<JSONString> jointId(new JSONString(jointsUID[i].toAscii())); ++ boost::shared_ptr<JSONString> jointId(new JSONString(jointsUID[i].toAscii())); + joints->appendValue(jointId); + } + glTFSkin->setJointsIds(joints); +diff -ur collada2gltf.org/COLLADA2GLTFWriter.h collada2gltf/COLLADA2GLTFWriter.h +--- collada2gltf.org/COLLADA2GLTFWriter.h 2014-09-29 15:30:40.134494471 +0200 ++++ collada2gltf/COLLADA2GLTFWriter.h 2014-09-29 15:31:48.000000000 +0200 +@@ -36,6 +36,8 @@ + #include "convert/animationConverter.h" + #include "convert/meshConverter.h" + ++#include <boost/shared_ptr.hpp> ++ + namespace GLTF + { + class GLTFObject; +@@ -59,7 +61,7 @@ + }; + + +- typedef std::vector < std::shared_ptr <MeshFlatteningInfo> > MeshFlatteningInfoVector; ++ typedef std::vector < boost::shared_ptr <MeshFlatteningInfo> > MeshFlatteningInfoVector; + + typedef struct + { +@@ -72,17 +74,17 @@ + class COLLADA2GLTFWriter : public COLLADAFW::IWriter + { + public: +- COLLADA2GLTFWriter(std::shared_ptr<GLTF::GLTFAsset> asset); ++ COLLADA2GLTFWriter(boost::shared_ptr<GLTF::GLTFAsset> asset); + virtual ~COLLADA2GLTFWriter(); + private: + static void reportError(const std::string& method, const std::string& message); +- bool writeNode(const COLLADAFW::Node* node, std::shared_ptr <GLTF::JSONObject> nodesObject, COLLADABU::Math::Matrix4, SceneFlatteningInfo*); ++ bool writeNode(const COLLADAFW::Node* node, boost::shared_ptr <GLTF::JSONObject> nodesObject, COLLADABU::Math::Matrix4, SceneFlatteningInfo*); + bool processSceneFlatteningInfo(SceneFlatteningInfo* sceneFlatteningInfo); + float getTransparency(const COLLADAFW::EffectCommon* effectCommon); + float isOpaque(const COLLADAFW::EffectCommon* effectCommon); + bool writeMeshFromUIDWithMaterialBindings(COLLADAFW::UniqueId uniqueId, + COLLADAFW::MaterialBindingArray &materialBindings, +- std::shared_ptr <GLTF::JSONArray> &meshesArray); ++ boost::shared_ptr <GLTF::JSONArray> &meshesArray); + + public: + +@@ -168,25 +170,25 @@ + void _installTextureSlot(COLLADAFW::Sampler* sampler, + const std::string& slotName, + const std::string& texcoord, +- std::shared_ptr <GLTF::GLTFAsset> asset, +- std::shared_ptr<GLTF::GLTFEffect> cvtEffect); ++ boost::shared_ptr <GLTF::GLTFAsset> asset, ++ boost::shared_ptr<GLTF::GLTFEffect> cvtEffect); + + void _storeMaterialBindingArray(const std::string& prefix, + const std::string& nodeUID, + const std::string& meshUID, + COLLADAFW::MaterialBindingArray &materialBindings); +- void registerObjectWithOriginalUID(std::string nodeUID, std::shared_ptr <JSONObject> nodeObject, std::shared_ptr <JSONObject> nodesObject); ++ void registerObjectWithOriginalUID(std::string nodeUID, boost::shared_ptr <JSONObject> nodeObject, boost::shared_ptr <JSONObject> nodesObject); + bool writeData(std::string filename, unsigned char* data, size_t length); + void handleEffectSlot(const COLLADAFW::EffectCommon* commonProfile, + std::string slotName, +- std::shared_ptr <GLTFEffect> cvtEffect, +- std::shared_ptr<JSONObject> extras); ++ boost::shared_ptr <GLTFEffect> cvtEffect, ++ boost::shared_ptr<JSONObject> extras); + + std::string getSamplerUIDForParameters(unsigned int wrapS, unsigned int wrapT, unsigned int minFilter, unsigned int maxFilter); + + private: + COLLADASaxFWL::Loader _loader; +- std::shared_ptr<GLTF::GLTFAsset> _asset; ++ boost::shared_ptr<GLTF::GLTFAsset> _asset; + const COLLADAFW::VisualScene *_visualScene; + SceneFlatteningInfo _sceneFlatteningInfo; + GLTF::ExtraDataHandler *_extraDataHandler; +diff -ur collada2gltf.org/convert/animationConverter.cpp collada2gltf/convert/animationConverter.cpp +--- collada2gltf.org/convert/animationConverter.cpp 2014-09-29 15:30:40.134494471 +0200 ++++ collada2gltf/convert/animationConverter.cpp 2014-09-29 15:33:17.000000000 +0200 +@@ -29,19 +29,19 @@ + The animation creation/write is in 2 steps. + We first create the animation, but then, we need to set the channels for every targets, and targets ids are not available when animations are created + */ +- bool writeAnimation(shared_ptr <GLTFAnimation> cvtAnimation, ++ bool writeAnimation(boost::shared_ptr <GLTFAnimation> cvtAnimation, + const COLLADAFW::AnimationList::AnimationClass animationClass, + AnimatedTargetsSharedPtr animatedTargets, + GLTF::GLTFAsset *asset) { + + std::string inputParameterName = "TIME"; +- shared_ptr<JSONObject> samplers = cvtAnimation->samplers(); +- shared_ptr<JSONArray> channels = cvtAnimation->channels(); +- shared_ptr<GLTFBufferView> timeBufferView = cvtAnimation->getBufferViewForParameter(inputParameterName); ++ boost::shared_ptr<JSONObject> samplers = cvtAnimation->samplers(); ++ boost::shared_ptr<JSONArray> channels = cvtAnimation->channels(); ++ boost::shared_ptr<GLTFBufferView> timeBufferView = cvtAnimation->getBufferViewForParameter(inputParameterName); + +- shared_ptr<GLTFAnimationFlattener> animationFlattener; ++ boost::shared_ptr<GLTFAnimationFlattener> animationFlattener; + +- shared_ptr<GLTFBufferView> bufferView = cvtAnimation->getBufferViewForParameter("OUTPUT"); ++ boost::shared_ptr<GLTFBufferView> bufferView = cvtAnimation->getBufferViewForParameter("OUTPUT"); + cvtAnimation->unregisterBufferView("OUTPUT"); + + switch (animationClass) { +@@ -54,7 +54,7 @@ + //the angles to radians necessary convertion is done within the animationFlattener + //but it might be better to make it before... + for (size_t animatedTargetIndex = 0 ; animatedTargetIndex < animatedTargets->size() ; animatedTargetIndex++) { +- shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; ++ boost::shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; + std::string targetID = animatedTarget->getString(kTarget); + if (asset->_uniqueIDToOpenCOLLADAObject.count(targetID) != 0) { + cvtAnimation->targets()->setValue(targetID, animatedTarget); +@@ -69,7 +69,7 @@ + for (size_t k = 0 ; k < cvtAnimation->getCount() ; k++) { + size_t offset = k * 4; + +- shared_ptr <COLLADAFW::Rotate> rotate(new COLLADAFW::Rotate(rotations[offset + 0], ++ boost::shared_ptr <COLLADAFW::Rotate> rotate(new COLLADAFW::Rotate(rotations[offset + 0], + rotations[offset + 1], + rotations[offset + 2], + rotations[offset + 3])); +@@ -81,13 +81,13 @@ + } + return true; + case COLLADAFW::AnimationList::MATRIX4X4: { +- std::vector< shared_ptr <GLTFBufferView> > TRSBufferViews; ++ std::vector< boost::shared_ptr <GLTFBufferView> > TRSBufferViews; + //FIXME: we assume float here, might be double + float* matrices = (float*)bufferView->getBufferDataByApplyingOffset(); + float* timeValues = (float*)timeBufferView->getBufferDataByApplyingOffset(); + + for (size_t animatedTargetIndex = 0 ; animatedTargetIndex < animatedTargets->size() ; animatedTargetIndex++) { +- shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; ++ boost::shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; + if (animatedTarget->getString("path") == "MATRIX") { + std::string targetID = animatedTarget->getString(kTarget); + if (asset->_uniqueIDToOpenCOLLADAObject.count(targetID) != 0) { +@@ -105,7 +105,7 @@ + m[8], m[9], m[10], m[11], + m[12], m[13], m[14], m[15] ); + +- shared_ptr <COLLADAFW::Matrix> matTr(new COLLADAFW::Matrix(mat)); ++ boost::shared_ptr <COLLADAFW::Matrix> matTr(new COLLADAFW::Matrix(mat)); + animationFlattener->insertTransformAtTime(transformID, matTr, timeValues[k]); + } + } +@@ -117,7 +117,7 @@ + //the angles to radians necessary convertion is done within the animationFlattener + //but it might be better to make it before... + for (size_t animatedTargetIndex = 0 ; animatedTargetIndex < animatedTargets->size() ; animatedTargetIndex++) { +- shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; ++ boost::shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; + std::string targetID = animatedTarget->getString(kTarget); + if (asset->_uniqueIDToOpenCOLLADAObject.count(targetID) != 0) { + cvtAnimation->targets()->setValue(targetID, animatedTarget); +@@ -131,7 +131,7 @@ + float* translations = (float*)bufferView->getBufferDataByApplyingOffset(); + for (size_t k = 0 ; k < cvtAnimation->getCount() ; k++) { + size_t offset = k * 3; +- shared_ptr <COLLADAFW::Translate> translate(new COLLADAFW::Translate(translations[offset + 0], ++ boost::shared_ptr <COLLADAFW::Translate> translate(new COLLADAFW::Translate(translations[offset + 0], + translations[offset + 1], + translations[offset + 2])); + animationFlattener->insertTransformAtTime(transformID, translate, timeValues[k]); +@@ -143,7 +143,7 @@ + float* scales = (float*)bufferView->getBufferDataByApplyingOffset(); + for (size_t k = 0 ; k < cvtAnimation->getCount() ; k++) { + size_t offset = k * 3; +- shared_ptr <COLLADAFW::Scale> scale(new COLLADAFW::Scale(scales[offset + 0], ++ boost::shared_ptr <COLLADAFW::Scale> scale(new COLLADAFW::Scale(scales[offset + 0], + scales[offset + 1], + scales[offset + 2])); + animationFlattener->insertTransformAtTime(transformID, scale, timeValues[k]); +@@ -158,7 +158,7 @@ + //the angles to radians necessary convertion is done within the animationFlattener + //but it might be better to make it before... + for (size_t animatedTargetIndex = 0 ; animatedTargetIndex < animatedTargets->size() ; animatedTargetIndex++) { +- shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; ++ boost::shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; + std::string targetID = animatedTarget->getString(kTarget); + if (asset->_uniqueIDToOpenCOLLADAObject.count(targetID) != 0) { + cvtAnimation->targets()->setValue(targetID, animatedTarget); +@@ -184,7 +184,7 @@ + { + int index = animationClass - COLLADAFW::AnimationList::POSITION_X; + for (size_t animatedTargetIndex = 0 ; animatedTargetIndex < animatedTargets->size() ; animatedTargetIndex++) { +- shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; ++ boost::shared_ptr<JSONObject> animatedTarget = (*animatedTargets)[animatedTargetIndex]; + std::string targetID = animatedTarget->getString(kTarget); + if (asset->_uniqueIDToOpenCOLLADAObject.count(targetID) != 0) { + cvtAnimation->targets()->setValue(targetID, animatedTarget); +@@ -223,11 +223,11 @@ + return false; + } + +- shared_ptr <GLTFAnimation> convertOpenCOLLADAAnimationToGLTFAnimation(const COLLADAFW::Animation* animation, GLTF::GLTFAsset *asset) ++ boost::shared_ptr <GLTFAnimation> convertOpenCOLLADAAnimationToGLTFAnimation(const COLLADAFW::Animation* animation, GLTF::GLTFAsset *asset) + { +- shared_ptr <GLTFAnimation> cvtAnimation(new GLTFAnimation()); ++ boost::shared_ptr <GLTFAnimation> cvtAnimation(new GLTFAnimation()); + if (animation->getAnimationType() == COLLADAFW::Animation::ANIMATION_CURVE) { +- shared_ptr <JSONObject> animationParameters = cvtAnimation->parameters(); ++ boost::shared_ptr <JSONObject> animationParameters = cvtAnimation->parameters(); + + const COLLADAFW::AnimationCurve *animationCurve = (const COLLADAFW::AnimationCurve*)animation; + +@@ -246,9 +246,9 @@ + + const std::string originalID = animationCurve->getOriginalId(); + +- //shared_ptr <JSONObject> inputParameter(new JSONObject()); +- shared_ptr <GLTFBufferView> inputBufferView = convertFloatOrDoubleArrayToGLTFBufferView(inputArray); +- shared_ptr <GLTFBufferView> outputBufferView = convertFloatOrDoubleArrayToGLTFBufferView(outputArray); ++ //boost::shared_ptr <JSONObject> inputParameter(new JSONObject()); ++ boost::shared_ptr <GLTFBufferView> inputBufferView = convertFloatOrDoubleArrayToGLTFBufferView(inputArray); ++ boost::shared_ptr <GLTFBufferView> outputBufferView = convertFloatOrDoubleArrayToGLTFBufferView(outputArray); + + cvtAnimation->registerBufferView("TIME", inputBufferView); + cvtAnimation->registerBufferView("OUTPUT", outputBufferView); +diff -ur collada2gltf.org/convert/animationConverter.h collada2gltf/convert/animationConverter.h +--- collada2gltf.org/convert/animationConverter.h 2014-09-29 15:30:40.134494471 +0200 ++++ collada2gltf/convert/animationConverter.h 2014-09-29 15:33:30.000000000 +0200 +@@ -8,16 +8,18 @@ + #include "../GLTFOpenCOLLADA.h" + #include "mathHelpers.h" + ++#include <boost/shared_ptr.hpp> ++ + namespace GLTF + { + //a few helper classes to help flattening animations + +- typedef std::map<std::string , std::shared_ptr<COLLADAFW::Transformation> > IDToTransform; ++ typedef std::map<std::string , boost::shared_ptr<COLLADAFW::Transformation> > IDToTransform; + + class GLTFTransformKey { + public: + +- GLTFTransformKey(double time, std::shared_ptr<COLLADAFW::Transformation> transform, std::string transformID) { ++ GLTFTransformKey(double time, boost::shared_ptr<COLLADAFW::Transformation> transform, std::string transformID) { + this->_subTransforms[transformID] = transform; + this->_time = time; + } +@@ -47,7 +49,7 @@ + + class GLTFAnimationFlattener { + private: +- void _updateTransformByReplacingValueAtIndex(std::shared_ptr<COLLADAFW::Transformation> transform, size_t index, float value) ++ void _updateTransformByReplacingValueAtIndex(boost::shared_ptr<COLLADAFW::Transformation> transform, size_t index, float value) + { + switch (transform->getTransformationType()) { + case COLLADAFW::Transformation::ROTATE: +@@ -115,10 +117,10 @@ + } + } + +- std::shared_ptr<COLLADAFW::Transformation> _cloneTransformByReplacingValueAtIndex(std::string transformID, size_t index, float value) ++ boost::shared_ptr<COLLADAFW::Transformation> _cloneTransformByReplacingValueAtIndex(std::string transformID, size_t index, float value) + { +- std::shared_ptr<COLLADAFW::Transformation> transform = _idToTransform[transformID]; +- std::shared_ptr<COLLADAFW::Transformation> clonedTransform(transform->clone()); ++ boost::shared_ptr<COLLADAFW::Transformation> transform = _idToTransform[transformID]; ++ boost::shared_ptr<COLLADAFW::Transformation> clonedTransform(transform->clone()); + + _updateTransformByReplacingValueAtIndex(clonedTransform, index, value); + +@@ -128,7 +130,7 @@ + public: + + GLTFAnimationFlattener(COLLADAFW::Node *node) { +- this->_transformsOrder = std::shared_ptr <std::vector<std::string> > (new std::vector<std::string>); ++ this->_transformsOrder = boost::shared_ptr <std::vector<std::string> > (new std::vector<std::string>); + const COLLADAFW::TransformationPointerArray& transformations = node->getTransformations(); + size_t transformationsCount = transformations.getCount(); + int index = 0; +@@ -140,7 +142,7 @@ + _idIndex = (int*)malloc(sizeof(int) * transformationsCount); + for (size_t i = 0 ; i < transformationsCount ; i++) { + const COLLADAFW::Transformation* tr = transformations[i]; +- std::shared_ptr<COLLADAFW::Transformation> clonedTransform(tr->clone()); ++ boost::shared_ptr<COLLADAFW::Transformation> clonedTransform(tr->clone()); + const COLLADAFW::UniqueId& animationListID = tr->getAnimationList(); + if (animationListID.isValid()) { + _idIndex[i] = index++; +@@ -196,7 +198,7 @@ + float *previousAxisAngle = 0; + float axisAngle[4]; + for (size_t i = 0 ; i < _transforms.size() ; i++) { +- std::shared_ptr<GLTFTransformKey> key = this->_transforms[i]; ++ boost::shared_ptr<GLTFTransformKey> key = this->_transforms[i]; + + if ((i > 0) && (rotations != 0)) { + previousAxisAngle = rotations + ((i-1) * 4); +@@ -269,7 +271,7 @@ + } + } + +- void transformWasInserted(std::shared_ptr<COLLADAFW::Transformation> tr) { ++ void transformWasInserted(boost::shared_ptr<COLLADAFW::Transformation> tr) { + switch (tr->getTransformationType()) { + case COLLADAFW::Transformation::MATRIX: + this->_hasAnimatedScale = this->_hasAnimatedTranslation = this->_hasAnimatedRotation = true; +@@ -290,14 +292,14 @@ + } + + //to be used for whole matrices and angle axis +- void insertTransformAtTime(std::string transformID, std::shared_ptr<COLLADAFW::Transformation> transformation, double time) { ++ void insertTransformAtTime(std::string transformID, boost::shared_ptr<COLLADAFW::Transformation> transformation, double time) { + transformWasInserted(transformation); + if (_transforms.size() == 0) { +- std::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); ++ boost::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); + _transforms.push_back(key); + } else { + for (size_t i = 0 ; i < _transforms.size() ; i++) { +- std::shared_ptr<GLTFTransformKey> key = _transforms[i]; ++ boost::shared_ptr<GLTFTransformKey> key = _transforms[i]; + if (time == key->getTime()) { + if ( (*key->subTransforms()).count(transformID) > 0) { + printf("INCONSISTENCY ERROR: overlap\n"); +@@ -306,16 +308,16 @@ + return; + } else if (time > key->getTime()) { + if (i + 1 == _transforms.size()) { +- std::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); ++ boost::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); + _transforms.push_back(key); + return; + } else if (time < _transforms[i+1]->getTime()) { +- std::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); ++ boost::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); + _transforms.insert(_transforms.begin() + i, key); + return; + } + } else { +- std::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); ++ boost::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); + _transforms.insert(_transforms.begin() + i, key); + return; + } +@@ -324,17 +326,17 @@ + } + + void insertValueAtTime(std::string transformID, float value, size_t index, double time) { +- std::shared_ptr <COLLADAFW::Transformation> transformation; ++ boost::shared_ptr <COLLADAFW::Transformation> transformation; + if (_transforms.size() == 0) { + transformation = this->_cloneTransformByReplacingValueAtIndex(transformID, index, value); + +- std::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); ++ boost::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); + _transforms.push_back(key); + transformWasInserted(transformation); + return; + } else { + for (size_t i = 0 ; i < _transforms.size() ; i++) { +- std::shared_ptr<GLTFTransformKey> key = _transforms[i]; ++ boost::shared_ptr<GLTFTransformKey> key = _transforms[i]; + if (time == key->getTime()) { + if ( (*key->subTransforms()).count(transformID) > 0) { + transformation = (*key->subTransforms())[transformID]; +@@ -349,14 +351,14 @@ + if (i + 1 == _transforms.size()) { + transformation = this->_cloneTransformByReplacingValueAtIndex(transformID, index, value); + +- std::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); ++ boost::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); + _transforms.push_back(key); + transformWasInserted(transformation); + return; + } else if (time < _transforms[i+1]->getTime()) { + transformation = this->_cloneTransformByReplacingValueAtIndex(transformID, index, value); + +- std::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); ++ boost::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); + _transforms.insert(_transforms.begin() + i, key); + transformWasInserted(transformation); + return; +@@ -364,7 +366,7 @@ + } else { + transformation = this->_cloneTransformByReplacingValueAtIndex(transformID, index, value); + +- std::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); ++ boost::shared_ptr <GLTFTransformKey> key(new GLTFTransformKey(time, transformation, transformID)); + _transforms.insert(_transforms.begin() + i, key); + transformWasInserted(transformation); + return; +@@ -374,11 +376,11 @@ + + } + +- void setTransformsOrder(std::shared_ptr<std::vector<std::string> > transformsOrder) { ++ void setTransformsOrder(boost::shared_ptr<std::vector<std::string> > transformsOrder) { + this->_transformsOrder = transformsOrder; + } + +- std::shared_ptr<std::vector<std::string> > getTransformsOrder() { ++ boost::shared_ptr<std::vector<std::string> > getTransformsOrder() { + return this->_transformsOrder; + } + +@@ -387,10 +389,10 @@ + #define _INTERPOLATE(I1, I2, STEP) (I1 + (STEP * (I2-I1))) + + //TODO: might be worth checking for equality for prev & transform to be interpolated here +- std::shared_ptr <COLLADAFW::Transformation> _interpolateTransforms(std::shared_ptr<COLLADAFW::Transformation> previousTransform, std::shared_ptr<COLLADAFW::Transformation> nextTransform, double ratio) { ++ boost::shared_ptr <COLLADAFW::Transformation> _interpolateTransforms(boost::shared_ptr<COLLADAFW::Transformation> previousTransform, boost::shared_ptr<COLLADAFW::Transformation> nextTransform, double ratio) { + + COLLADAFW::Transformation::TransformationType transformationType = previousTransform->getTransformationType(); +- std::shared_ptr<COLLADAFW::Transformation> transform(previousTransform->clone()); ++ boost::shared_ptr<COLLADAFW::Transformation> transform(previousTransform->clone()); + + switch (transformationType) { + case COLLADAFW::Transformation::ROTATE: +@@ -464,16 +466,16 @@ + int idIndex = _idIndex[i]; + if (idIndex != -1) { + std::string transformID = this->_transformsOrder->at(idIndex); +- std::shared_ptr <GLTFTransformKey> key = this->_transforms[index]; ++ boost::shared_ptr <GLTFTransformKey> key = this->_transforms[index]; + + if ((*key->subTransforms()).count(transformID) == 0) { + //so here we need to get a transform matching transformID for this key but it does not contain it, + //we need to figure it out by interpolating the previous/next key containing this transform (this involves a search. + +- std::shared_ptr<COLLADAFW::Transformation> previousTransform; +- std::shared_ptr<COLLADAFW::Transformation> nextTransform; +- std::shared_ptr <GLTFTransformKey> previousKey; +- std::shared_ptr <GLTFTransformKey> nextKey; ++ boost::shared_ptr<COLLADAFW::Transformation> previousTransform; ++ boost::shared_ptr<COLLADAFW::Transformation> nextTransform; ++ boost::shared_ptr <GLTFTransformKey> previousKey; ++ boost::shared_ptr <GLTFTransformKey> nextKey; + double t1 = 0, t2 = 0; + + bool found = false; +@@ -510,7 +512,7 @@ + } + + if (found == false) { +- std::shared_ptr <GLTFTransformKey> lastKey = this->_transforms[this->_transforms.size() - 1]; ++ boost::shared_ptr <GLTFTransformKey> lastKey = this->_transforms[this->_transforms.size() - 1]; + nextTransform = _idToTransform[transformID]; + t2 = lastKey->getTime(); + } +@@ -579,14 +581,14 @@ + bool _hasAnimatedScale, _hasAnimatedTranslation, _hasAnimatedRotation; + std::string _targetUID; + int *_idIndex; +- std::vector<std::shared_ptr<COLLADAFW::Transformation> > _originalTransforms; +- std::vector<std::shared_ptr<GLTFTransformKey> > _transforms; +- std::map<std::string , std::shared_ptr<COLLADAFW::Transformation> > _idToTransform; +- std::shared_ptr<std::vector<std::string> > _transformsOrder; ++ std::vector<boost::shared_ptr<COLLADAFW::Transformation> > _originalTransforms; ++ std::vector<boost::shared_ptr<GLTFTransformKey> > _transforms; ++ std::map<std::string , boost::shared_ptr<COLLADAFW::Transformation> > _idToTransform; ++ boost::shared_ptr<std::vector<std::string> > _transformsOrder; + }; + +- std::shared_ptr <GLTFAnimation> convertOpenCOLLADAAnimationToGLTFAnimation(const COLLADAFW::Animation* animation, GLTF::GLTFAsset *asset); +- bool writeAnimation(std::shared_ptr <GLTFAnimation> cvtAnimation, ++ boost::shared_ptr <GLTFAnimation> convertOpenCOLLADAAnimationToGLTFAnimation(const COLLADAFW::Animation* animation, GLTF::GLTFAsset *asset); ++ bool writeAnimation(boost::shared_ptr <GLTFAnimation> cvtAnimation, + const COLLADAFW::AnimationList::AnimationClass animationClass, + AnimatedTargetsSharedPtr animatedTargets, + GLTF::GLTFAsset *asset); +diff -ur collada2gltf.org/convert/meshConverter.cpp collada2gltf/convert/meshConverter.cpp +--- collada2gltf.org/convert/meshConverter.cpp 2014-09-29 15:30:40.134494471 +0200 ++++ collada2gltf/convert/meshConverter.cpp 2014-09-29 15:40:28.000000000 +0200 +@@ -35,7 +35,7 @@ + Convert an OpenCOLLADA's FloatOrDoubleArray type to a GLTFBufferView + Note: the resulting GLTFBufferView is not typed, it's the call responsability to keep track of the type if needed. + */ +- shared_ptr <GLTFBufferView> convertFloatOrDoubleArrayToGLTFBufferView(const COLLADAFW::FloatOrDoubleArray &floatOrDoubleArray) { ++ boost::shared_ptr <GLTFBufferView> convertFloatOrDoubleArrayToGLTFBufferView(const COLLADAFW::FloatOrDoubleArray &floatOrDoubleArray) { + unsigned char* sourceData = 0; + size_t sourceSize = 0; + +@@ -62,28 +62,28 @@ + unsigned char* copiedData = (unsigned char*)malloc(sourceSize); + memcpy(copiedData, sourceData, sourceSize); + +- shared_ptr <GLTF::GLTFBufferView> bufferView = createBufferViewWithAllocatedBuffer(copiedData, 0, sourceSize, true); ++ boost::shared_ptr <GLTF::GLTFBufferView> bufferView = createBufferViewWithAllocatedBuffer(copiedData, 0, sourceSize, true); + + return bufferView; + } + +- shared_ptr <GLTFBufferView> convertUnsignedIntArrayToGLTFBufferView(const COLLADAFW::UIntValuesArray &array) { ++ boost::shared_ptr <GLTFBufferView> convertUnsignedIntArrayToGLTFBufferView(const COLLADAFW::UIntValuesArray &array) { + unsigned char* sourceData = (unsigned char*)array.getData(); + size_t sourceSize = array.getCount() * sizeof(unsigned int); + unsigned char* copiedData = (unsigned char*)malloc(sourceSize); + memcpy(copiedData, sourceData, sourceSize); +- shared_ptr <GLTF::GLTFBufferView> bufferView = createBufferViewWithAllocatedBuffer(copiedData, 0, sourceSize, true); ++ boost::shared_ptr <GLTF::GLTFBufferView> bufferView = createBufferViewWithAllocatedBuffer(copiedData, 0, sourceSize, true); + + return bufferView; + } + + //FIXME: these 3 functions up there could use some refactoring +- shared_ptr <GLTFBufferView> convertIntArrayToGLTFBufferView(const COLLADAFW::IntValuesArray &array) { ++ boost::shared_ptr <GLTFBufferView> convertIntArrayToGLTFBufferView(const COLLADAFW::IntValuesArray &array) { + unsigned char* sourceData = (unsigned char*)array.getData(); + size_t sourceSize = array.getCount() * sizeof(int); + unsigned char* copiedData = (unsigned char*)malloc(sourceSize); + memcpy(copiedData, sourceData, sourceSize); +- shared_ptr <GLTF::GLTFBufferView> bufferView = createBufferViewWithAllocatedBuffer(copiedData, 0, sourceSize, true); ++ boost::shared_ptr <GLTF::GLTFBufferView> bufferView = createBufferViewWithAllocatedBuffer(copiedData, 0, sourceSize, true); + + return bufferView; + } +@@ -93,7 +93,7 @@ + GLTFMesh* mesh, + GLTF::Semantic semantic, + size_t allowedComponentsPerAttribute, +- shared_ptr<GLTFProfile> profile) ++ boost::shared_ptr<GLTFProfile> profile) + { + // The following are OpenCOLLADA fmk issues preventing doing a totally generic processing of sources + //1. "set"(s) other than texCoord don't have valid input infos +@@ -194,8 +194,8 @@ + } + + // FIXME: the source could be shared, store / retrieve it here +- shared_ptr <GLTFBufferView> cvtBufferView = createBufferViewWithAllocatedBuffer(id, sourceData, 0, sourceSize, meshAttributeOwnsBuffer); +- shared_ptr <GLTFAccessor> cvtMeshAttribute(new GLTFAccessor(profile, profile->getGLTypeForComponentType(componentType, componentsPerElement))); ++ boost::shared_ptr <GLTFBufferView> cvtBufferView = createBufferViewWithAllocatedBuffer(id, sourceData, 0, sourceSize, meshAttributeOwnsBuffer); ++ boost::shared_ptr <GLTFAccessor> cvtMeshAttribute(new GLTFAccessor(profile, profile->getGLTypeForComponentType(componentType, componentsPerElement))); + + cvtMeshAttribute->setBufferView(cvtBufferView); + cvtMeshAttribute->setByteStride(stride); +@@ -207,9 +207,9 @@ + return (unsigned int)setCount; + } + +- static void __AppendIndices(shared_ptr <GLTF::GLTFPrimitive> &primitive, IndicesVector &primitiveIndicesVector, shared_ptr <GLTF::GLTFAccessor> &indices, GLTF::Semantic semantic, unsigned int indexOfSet) ++ static void __AppendIndices(boost::shared_ptr <GLTF::GLTFPrimitive> &primitive, IndicesVector &primitiveIndicesVector, boost::shared_ptr <GLTF::GLTFAccessor> &indices, GLTF::Semantic semantic, unsigned int indexOfSet) + { +- primitive->appendVertexAttribute(shared_ptr <GLTF::JSONVertexAttribute>( new GLTF::JSONVertexAttribute(semantic,indexOfSet))); ++ primitive->appendVertexAttribute(boost::shared_ptr <GLTF::JSONVertexAttribute>( new GLTF::JSONVertexAttribute(semantic,indexOfSet))); + primitiveIndicesVector.push_back(indices); + } + +@@ -220,9 +220,9 @@ + unsigned int count, + unsigned int vcount, + unsigned int *verticesCountArray, +- shared_ptr <GLTF::GLTFPrimitive> cvtPrimitive, ++ boost::shared_ptr <GLTF::GLTFPrimitive> cvtPrimitive, + IndicesVector &primitiveIndicesVector, +- shared_ptr<GLTFProfile> profile) ++ boost::shared_ptr<GLTFProfile> profile) + { + unsigned int triangulatedIndicesCount = 0; + bool ownData = false; +@@ -251,8 +251,8 @@ + indices = bufferDestination; + } + +- shared_ptr <GLTF::GLTFBufferView> uvBuffer = createBufferViewWithAllocatedBuffer(indices, 0, count * sizeof(unsigned int), ownData); +- shared_ptr <GLTFAccessor> accessor(new GLTFAccessor(profile, profile->getGLenumForString("UNSIGNED_SHORT"))); ++ boost::shared_ptr <GLTF::GLTFBufferView> uvBuffer = createBufferViewWithAllocatedBuffer(indices, 0, count * sizeof(unsigned int), ownData); ++ boost::shared_ptr <GLTFAccessor> accessor(new GLTFAccessor(profile, profile->getGLenumForString("UNSIGNED_SHORT"))); + + accessor->setBufferView(uvBuffer); + accessor->setCount(count); +@@ -260,11 +260,11 @@ + __AppendIndices(cvtPrimitive, primitiveIndicesVector, accessor, semantic, idx); + } + +- static shared_ptr <GLTF::GLTFPrimitive> __ConvertOpenCOLLADAMeshPrimitive(COLLADAFW::MeshPrimitive *openCOLLADAMeshPrimitive, ++ static boost::shared_ptr <GLTF::GLTFPrimitive> __ConvertOpenCOLLADAMeshPrimitive(COLLADAFW::MeshPrimitive *openCOLLADAMeshPrimitive, + IndicesVector &primitiveIndicesVector, +- shared_ptr<GLTFProfile> profile) ++ boost::shared_ptr<GLTFProfile> profile) + { +- shared_ptr <GLTF::GLTFPrimitive> cvtPrimitive(new GLTF::GLTFPrimitive()); ++ boost::shared_ptr <GLTF::GLTFPrimitive> cvtPrimitive(new GLTF::GLTFPrimitive()); + + // We want to match OpenGL/ES mode , as WebGL spec points to OpenGL/ES spec... + // "Symbolic constants GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, and GL_TRIANGLES are accepted." +@@ -334,9 +334,9 @@ + count = triangulatedIndicesCount; + } + +- shared_ptr <GLTFBufferView> positionBuffer = createBufferViewWithAllocatedBuffer(indices, 0, count * sizeof(unsigned int), shouldTriangulate ? true : false); ++ boost::shared_ptr <GLTFBufferView> positionBuffer = createBufferViewWithAllocatedBuffer(indices, 0, count * sizeof(unsigned int), shouldTriangulate ? true : false); + +- shared_ptr <GLTF::GLTFAccessor> positionIndices(new GLTF::GLTFAccessor(profile, profile->getGLenumForString("UNSIGNED_SHORT"))); ++ boost::shared_ptr <GLTF::GLTFAccessor> positionIndices(new GLTF::GLTFAccessor(profile, profile->getGLenumForString("UNSIGNED_SHORT"))); + + positionIndices->setBufferView(positionBuffer); + positionIndices->setCount(count); +@@ -351,8 +351,8 @@ + count = triangulatedIndicesCount; + } + +- shared_ptr <GLTF::GLTFBufferView> normalBuffer = createBufferViewWithAllocatedBuffer(indices, 0, count * sizeof(unsigned int), shouldTriangulate ? true : false); +- shared_ptr <GLTF::GLTFAccessor> normalIndices(new GLTF::GLTFAccessor(profile, profile->getGLenumForString("UNSIGNED_SHORT"))); ++ boost::shared_ptr <GLTF::GLTFBufferView> normalBuffer = createBufferViewWithAllocatedBuffer(indices, 0, count * sizeof(unsigned int), shouldTriangulate ? true : false); ++ boost::shared_ptr <GLTF::GLTFAccessor> normalIndices(new GLTF::GLTFAccessor(profile, profile->getGLenumForString("UNSIGNED_SHORT"))); + + normalIndices->setBufferView(normalBuffer); + normalIndices->setCount(count); +@@ -402,8 +402,8 @@ + indices = createTrianglesFromPolylist(verticesCountArray, indices, vcount, &triangulatedIndicesCount); + count = triangulatedIndicesCount; + } +- shared_ptr <GLTF::GLTFBufferView> binormalBuffer = createBufferViewWithAllocatedBuffer(indices, 0, count * sizeof(unsigned int), shouldTriangulate ? true : false); +- shared_ptr <GLTF::GLTFAccessor> binormalIndices(new GLTF::GLTFAccessor(profile, profile->getGLenumForString("UNSIGNED_SHORT"))); ++ boost::shared_ptr <GLTF::GLTFBufferView> binormalBuffer = createBufferViewWithAllocatedBuffer(indices, 0, count * sizeof(unsigned int), shouldTriangulate ? true : false); ++ boost::shared_ptr <GLTF::GLTFAccessor> binormalIndices(new GLTF::GLTFAccessor(profile, profile->getGLenumForString("UNSIGNED_SHORT"))); + + binormalIndices->setBufferView(binormalBuffer); + binormalIndices->setCount(count); +@@ -423,8 +423,8 @@ + indices = createTrianglesFromPolylist(verticesCountArray, indices, vcount, &triangulatedIndicesCount); + count = triangulatedIndicesCount; + } +- shared_ptr <GLTF::GLTFBufferView> tangentBuffer = createBufferViewWithAllocatedBuffer(indices, 0, count * sizeof(unsigned int), shouldTriangulate ? true : false); +- shared_ptr <GLTF::GLTFAccessor> tangentIndices(new GLTF::GLTFAccessor(profile, profile->getGLenumForString("UNSIGNED_SHORT"))); ... etc. - the rest is truncated
_______________________________________________ Libreoffice-commits mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
