[Libreoffice-commits] core.git: Branch 'libreoffice-4-3' - avmedia/source configure.ac external/collada2gltf
Zolnai Tamás
tamas.zolnai at collabora.com
Tue Oct 7 08:28:11 PDT 2014
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 <tamas.zolnai at collabora.com>
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 <vmiklos at collabora.co.uk>
Tested-by: Miklos Vajna <vmiklos at collabora.co.uk>
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
More information about the Libreoffice-commits
mailing list