Fixed implicit conversion warnings

Exporters/FBX/BabylonFbxNative/BabylonCamera.cpp

@@ -72,7 +72,7 @@ BabylonCamera buildCameraFromBoundingBox(const babylon_boundingbox& box){
 	result.target = box.getCenter();
 	result.position = babylon_vector3(result.target.x, result.target.y, result.target.z - 2 * std::max(box.getWidth(), std::max(box.getHeight(), box.getDepth())));
 	result.fov = 0.8576f;
-	result.minZ = -0.01*result.position.z;
+	result.minZ = -0.01f*result.position.z;
 	result.maxZ = -5 * result.position.z;
 	result.speed = (-result.position.z - result.target.z) / 10;
 	result.inertia = 0.9f;
@@ -107,9 +107,9 @@ BabylonCamera::BabylonCamera(BabylonNode& babnode)
 	position = babnode.localTranslate();
 	rotationQuaternion = babnode.localRotationQuat();
 	
-	fov = camera->FieldOfViewY * Euler2Rad;
-	minZ = camera->FrontPlaneDistance.Get();
-	maxZ = camera->BackPlaneDistance.Get();
+	fov = static_cast<float>(camera->FieldOfViewY * Euler2Rad);
+	minZ = static_cast<float>(camera->FrontPlaneDistance.Get());
+	maxZ = static_cast<float>(camera->BackPlaneDistance.Get());
 
 	auto hasAnimStack = node->GetScene()->GetSrcObjectCount<FbxAnimStack>() > 0;
 	if (!hasAnimStack){
@@ -124,11 +124,11 @@ BabylonCamera::BabylonCamera(BabylonNode& babnode)
 	auto endFrame = takeInfo->mLocalTimeSpan.GetStop().GetFrameCount(animTimeMode);
 	auto animLengthInFrame = endFrame - startFrame + 1;
 
-	auto posAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, animFrameRate, L"position", L"position", true, 0, animLengthInFrame, true);
-	auto rotAnim = std::make_shared<BabylonAnimation<babylon_vector4>>(BabylonAnimationBase::loopBehavior_Cycle, animFrameRate, L"rotation", L"rotation", true, 0, animLengthInFrame, true);
-	auto targetAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, animFrameRate, L"target", L"target", true, 0, animLengthInFrame, true);
+	auto posAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, static_cast<int>(animFrameRate), L"position", L"position", true, 0, static_cast<int>(animLengthInFrame), true);
+	auto rotAnim = std::make_shared<BabylonAnimation<babylon_vector4>>(BabylonAnimationBase::loopBehavior_Cycle, static_cast<int>(animFrameRate), L"rotation", L"rotation", true, 0, static_cast<int>(animLengthInFrame), true);
+	auto targetAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, static_cast<int>(animFrameRate), L"target", L"target", true, 0, static_cast<int>(animLengthInFrame), true);
 	
-	for (auto ix = 0ll; ix < animLengthInFrame; ix++){
+	for (auto ix = 0; ix < animLengthInFrame; ix++){
 		FbxTime currTime;
 		currTime.SetFrame(startFrame + ix, animTimeMode);
 

Exporters/FBX/BabylonFbxNative/BabylonLight.cpp

@@ -93,7 +93,7 @@ specular(1, 1, 1)
 			auto transDir = rotM.MultT(vDir);
 			direction = transDir;
 			exponent = 1;
-			angle = light->OuterAngle*Euler2Rad;
+			angle = static_cast<float>(light->OuterAngle*Euler2Rad);
 
 		}
 		break;
@@ -101,9 +101,9 @@ specular(1, 1, 1)
 		break;
 	}
 	diffuse = light->Color.Get();
-	intensity = light->Intensity.Get() / 100.0;
+	intensity = static_cast<float>(light->Intensity.Get() / 100.0);
 	if (light->EnableFarAttenuation.Get()) {
-		range = light->FarAttenuationEnd.Get();
+		range = static_cast<float>(light->FarAttenuationEnd.Get());
 	}
 	auto hasAnimStack = node->GetScene()->GetSrcObjectCount<FbxAnimStack>() > 0;
 	if (!hasAnimStack){
@@ -121,9 +121,9 @@ specular(1, 1, 1)
 	auto dirAnimName = getNodeId(node);
 	posAnimName.append(L"_position");
 	dirAnimName.append(L"_direction");
-	auto posAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, animFrameRate, posAnimName, L"position", true, 0, animLengthInFrame, true);
-	auto dirAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, animFrameRate, dirAnimName, L"direction", true, 0, animLengthInFrame, true);
-	for (auto ix = 0ll; ix < animLengthInFrame; ix++){
+	auto posAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, static_cast<int>(animFrameRate), posAnimName, L"position", true, 0, static_cast<int>(animLengthInFrame), true);
+	auto dirAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, static_cast<int>(animFrameRate), dirAnimName, L"direction", true, 0, static_cast<int>(animLengthInFrame), true);
+	for (auto ix = 0; ix < animLengthInFrame; ix++){
 		babylon_animation_key<babylon_vector3> key;
 		key.frame = ix;
 		FbxTime currTime;

Exporters/FBX/BabylonFbxNative/BabylonMaterial.cpp

@@ -61,10 +61,10 @@ alpha(1)
 }
 
 std::wstring utf8ToWstring(const std::string& src){
-	auto size = MultiByteToWideChar(CP_UTF8, 0, src.c_str(), src.size(), nullptr, 0);
+	auto size = MultiByteToWideChar(CP_UTF8, 0, src.c_str(), static_cast<int>(src.size()), nullptr, 0);
 	std::wstring result;
 	result.resize(size, ' ');
-	MultiByteToWideChar(CP_UTF8, 0, src.c_str(), src.size(), &result[0], result.size());
+	MultiByteToWideChar(CP_UTF8, 0, src.c_str(), static_cast<int>(src.size()), &result[0], size);
 	return result;
 }
 
@@ -133,7 +133,7 @@ alpha(1){
 		transcolor = transColorProp.Get<FbxDouble3>();
 		if (transfactor== 1.0){ // from Maya .fbx
 			if (transcolor[0] >= DBL_MIN) {
-				alpha = 1 - transcolor[0];
+				alpha = static_cast<float>(1 - transcolor[0]);
 			}
 			else {
 				alpha = 1;
@@ -141,7 +141,7 @@ alpha(1){
 		}
 		else { // from 3dsmax .fbx
 			if (transfactor>=DBL_MIN){
-				alpha = 1 - transfactor;
+				alpha = static_cast<float>(1 - transfactor);
 			}
 			else {
 				alpha = 1;
@@ -156,7 +156,7 @@ alpha(1){
 	GetMaterialProperty(mat, FbxSurfaceMaterial::sReflection, FbxSurfaceMaterial::sReflectionFactor, reflectionTex);
 	auto shininessProp = mat->FindProperty(FbxSurfaceMaterial::sShininess);
 	if (shininessProp.IsValid()){
-		specularPower = shininessProp.Get<FbxDouble>();
+		specularPower = static_cast<float>(shininessProp.Get<FbxDouble>());
 	}
 
 	auto normalMapProp = mat->FindProperty(FbxSurfaceMaterial::sNormalMap);
@@ -304,13 +304,13 @@ BabylonTexture::BabylonTexture(FbxFileTexture* texture){
 	auto translation = texture->Translation.Get();
 	auto rot = texture->Rotation.Get();
 	auto scale  = texture->Scaling.Get();
-	uOffset = translation[0];
-	vOffset = translation[1];
-	uScale = scale[0];
-	vScale = scale[1];
-	uAng = rot[0] * Euler2Rad;
-	vAng = rot[1] * Euler2Rad;
-	wAng = rot[2] * Euler2Rad;
+	uOffset = static_cast<float>(translation[0]);
+	vOffset = static_cast<float>(translation[1]);
+	uScale = static_cast<float>(scale[0]);
+	vScale = static_cast<float>(scale[1]);
+	uAng = static_cast<float>(rot[0] * Euler2Rad);
+	vAng = static_cast<float>(rot[1] * Euler2Rad);
+	wAng = static_cast<float>(rot[2] * Euler2Rad);
 	auto uwrapMode = texture->GetWrapModeU();
 	auto vwrapMode = texture->GetWrapModeV();
 	wrapU = uwrapMode == FbxTexture::eRepeat;

Exporters/FBX/BabylonFbxNative/BabylonMesh.cpp

@@ -448,11 +448,11 @@ BabylonMesh::BabylonMesh(BabylonNode* node) :
 	auto endFrame = takeInfo->mLocalTimeSpan.GetStop().GetFrameCount(animTimeMode);
 	auto animLengthInFrame = endFrame - startFrame + 1;
 
-	auto posAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, animFrameRate, L"position", L"position", true, 0, animLengthInFrame, true);
-	auto rotAnim = std::make_shared<BabylonAnimation<babylon_vector4>>(BabylonAnimationBase::loopBehavior_Cycle, animFrameRate, L"rotationQuaternion", L"rotationQuaternion", true, 0, animLengthInFrame, true);
-	auto scaleAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, animFrameRate, L"scale", L"scale", true, 0, animLengthInFrame, true);
+	auto posAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, static_cast<int>(animFrameRate), L"position", L"position", true, 0, static_cast<int>(animLengthInFrame), true);
+	auto rotAnim = std::make_shared<BabylonAnimation<babylon_vector4>>(BabylonAnimationBase::loopBehavior_Cycle, static_cast<int>(animFrameRate), L"rotationQuaternion", L"rotationQuaternion", true, 0, static_cast<int>(animLengthInFrame), true);
+	auto scaleAnim = std::make_shared<BabylonAnimation<babylon_vector3>>(BabylonAnimationBase::loopBehavior_Cycle, static_cast<int>(animFrameRate), L"scale", L"scale", true, 0, static_cast<int>(animLengthInFrame), true);
 
-	for (auto ix = 0ll; ix < animLengthInFrame; ix++){
+	for (auto ix = 0; ix < animLengthInFrame; ix++){
 		FbxTime currTime;
 		currTime.SetFrame(startFrame + ix, animTimeMode);
 
@@ -703,7 +703,7 @@ BabylonMesh::BabylonMesh(BabylonNode* node) :
 				auto& skinData = skinInfo.controlPointBoneIndicesAndWeights(controlPointIndex);
 				for (auto boneix = 0; boneix < skinData.size()&&boneix<4; ++boneix){
 					v.boneIndices[boneix] = skinData[boneix].index;
-					v.boneWeights[boneix] = skinData[boneix].weight;
+					v.boneWeights[boneix] = static_cast<float>(skinData[boneix].weight);
 				}
 				for (auto boneix = skinData.size(); boneix < 4; ++boneix){
 
@@ -717,7 +717,7 @@ BabylonMesh::BabylonMesh(BabylonNode* node) :
 				t.indices[cornerIndex] = foundVertex->second;
 			}
 			else {
-				auto index = submesh.vertices.size();
+				auto index = static_cast<int>(submesh.vertices.size());
 				submesh.vertices.push_back(v);
 				//submesh.indices.push_back(index);
 				submesh.knownVertices[v] = index;
@@ -739,11 +739,11 @@ BabylonMesh::BabylonMesh(BabylonNode* node) :
 	for (auto matIndex = 0u; matIndex < submeshes.size(); ++matIndex) {
 		auto& submesh = submeshes[matIndex];
 		BabylonSubmesh babsubmesh;
-		babsubmesh.indexCount = submesh.indices.size();
-		babsubmesh.indexStart = _indices.size();
+		babsubmesh.indexCount = static_cast<int>(submesh.indices.size());
+		babsubmesh.indexStart = static_cast<int>(_indices.size());
 		babsubmesh.materialIndex = matIndex;
-		babsubmesh.verticesCount = submesh.vertices.size();
-		babsubmesh.verticesStart = _positions.size();
+		babsubmesh.verticesCount = static_cast<int>(submesh.vertices.size());
+		babsubmesh.verticesStart = static_cast<int>(_positions.size());
 		for (auto& v : submesh.vertices) {
 			_positions.push_back(v.position);
 			if (normals) {
@@ -779,7 +779,7 @@ BabylonMesh::BabylonMesh(BabylonNode* node) :
 				 int bone2 = v.boneIndices[2];
 				 int bone3 = v.boneIndices[3];
                
-				_boneWeights.push_back(babylon_vector4( weight0, weight1, weight2, 1.0 - weight0 - weight1 - weight2));
+				_boneWeights.push_back(babylon_vector4( weight0, weight1, weight2, 1.0f - weight0 - weight1 - weight2));
                 _boneIndices.push_back((bone3 << 24) | (bone2 << 16) | (bone1 << 8) | bone0);
 			}
 		}
@@ -787,7 +787,7 @@ BabylonMesh::BabylonMesh(BabylonNode* node) :
 			_indices.push_back(i + vertexOffset);
 		}
 
-		vertexOffset = _positions.size();
+		vertexOffset = static_cast<int>(_positions.size());
 		_submeshes.push_back(babsubmesh);
 	}
 

Exporters/FBX/BabylonFbxNative/BabylonNode.cpp

@@ -1,5 +1,3 @@
-#include "BabylonNode.h"
-#include "BabylonNode.h"
 #include "stdafx.h"
 #include "BabylonNode.h"
 #include "NodeHelpers.h"
@@ -74,13 +72,13 @@ babylon_vector3 BabylonNode::localScale(FbxTime time){
 
 babylon_vector4 BabylonNode::localRotationQuat(){
 	auto ret = _localTransform.GetQ();
-	return babylon_vector4(ret[0], ret[1], ret[2], ret[3]);
+	return babylon_vector4(static_cast<float>(ret[0]), static_cast<float>(ret[1]), static_cast<float>(ret[2]), static_cast<float>(ret[3]));
 }
 babylon_vector4 BabylonNode::localRotationQuat(FbxTime time){
 
 	auto transform = ConvertToBabylonCoordinateSystem(CalculateLocalTransform(_node, time));
 	auto ret = transform.GetQ();
-	return babylon_vector4(ret[0], ret[1], ret[2], ret[3]);
+	return babylon_vector4(static_cast<float>(ret[0]), static_cast<float>(ret[1]), static_cast<float>(ret[2]), static_cast<float>(ret[3]));
 }
 babylon_vector3 BabylonNode::localTranslate(FbxTime time){
 	auto transform = ConvertToBabylonCoordinateSystem(CalculateLocalTransform(_node, time));

Exporters/FBX/BabylonFbxNative/BabylonScene.cpp

@@ -8,7 +8,7 @@ web::json::value BabylonScene::toJson()
 	jobj[L"autoClear"] = web::json::value::boolean(_autoClear);
 	writeVector3(jobj, L"clearColor", _clearColor);
 	writeVector3(jobj, L"ambientColor", _ambientColor);
-	jobj[L"fogMode"] = web::json::value::boolean(_fogMode);
+	jobj[L"fogMode"] = web::json::value::number(_fogMode);
 	writeVector3(jobj, L"fogColor", _fogColor);
 	jobj[L"fogStart"] = web::json::value::number(_fogStart);
 	jobj[L"fogEnd"] = web::json::value::number(_fogEnd);

Exporters/FBX/BabylonFbxNative/BabylonVertex.h

@@ -84,7 +84,7 @@ struct babylon_vector2{
 	babylon_vector2() :x(0), y(0){}
 	babylon_vector2(float x, float y, float z) :x(x), y(y){}
 	babylon_vector2(const babylon_vector2& v) :x(v.x), y(v.y){}
-	babylon_vector2(const FbxDouble2& v) :x(v[0]), y(v[1]){}
+	babylon_vector2(const FbxDouble2& v) :x(static_cast<float>(v[0])), y(static_cast<float>(v[1])){}
 
 };
 
@@ -253,7 +253,7 @@ struct babylon_color{
 	float a;
 
 	babylon_color() :r(0), g(0), b(0), a(0){}
-	babylon_color(const FbxColor& v) : r(v.mRed), g(v.mGreen), b(v.mBlue), a(v.mAlpha){}
+	babylon_color(const FbxColor& v) : r(static_cast<float>(v.mRed)), g(static_cast<float>(v.mGreen)), b(static_cast<float>(v.mBlue)), a(static_cast<float>(v.mAlpha)){}
 };
 
 inline bool operator <(const babylon_color& lhs, const babylon_color& rhs){

Exporters/FBX/BabylonFbxNative/FbxMeshLoader.h

@@ -169,7 +169,7 @@ babylon_mesh<babylon_vertex_normal_uv_color> loadStaticMesh<babylon_vertex_norma
 			submesh.indices.push_back(found->second);
 		}
 		else{
-			int index = submesh.resolvedVertices.size();
+			int index = static_cast<int>(submesh.resolvedVertices.size());
 			babylon_vertex_normal_uv_color babVertex;
 			auto& elements = vertexKey.getKeyMembers();
 			babVertex.pos_x = (float) elements.at(0);
@@ -192,8 +192,8 @@ babylon_mesh<babylon_vertex_normal_uv_color> loadStaticMesh<babylon_vertex_norma
 	int totalVertices = 0;
 	int totalIndices = 0;
 	for (auto&& submesh : submeshes){
-		totalVertices += submesh.second.vertices.size();
-		totalIndices += submesh.second.indices.size();
+		totalVertices += static_cast<int>(submesh.second.vertices.size());
+		totalIndices += static_cast<int>(submesh.second.indices.size());
 	}
 	std::vector<babylon_vertex_normal_uv_color>vertices(totalVertices);
 	std::vector<int> indices(totalIndices);
@@ -218,10 +218,10 @@ babylon_mesh<babylon_vertex_normal_uv_color> loadStaticMesh<babylon_vertex_norma
 		babylon_submesh babSubmesh;
 		babSubmesh.material_id = materialHandler.RegisterMaterial(submesh.first);
 		babSubmesh.index_start = indicesFilled;
-		babSubmesh.index_count = submesh.second.indices.size();
+		babSubmesh.index_count = static_cast<int>(submesh.second.indices.size());
 		finalSubmeshes.push_back(babSubmesh);
-		verticesFilled += submesh.second.vertices.size();
-		indicesFilled += submesh.second.indices.size();
+		verticesFilled += static_cast<int>(submesh.second.vertices.size());
+		indicesFilled += static_cast<int>(submesh.second.indices.size());
 	}
 	return babylon_mesh<babylon_vertex_normal_uv_color>(mesh->GetName(), std::move(vertices), std::move(indices), std::move(finalSubmeshes), node->GetAnimationEvaluator()->GetNodeGlobalTransform(node));
 }

Exporters/FBX/BabylonFbxNative/SkinInfo.cpp

@@ -31,7 +31,7 @@ void ComputeBoneHierarchy(const std::vector<FbxNode*>& unsortedFlatListOfNodes,
 		info.linkNode = unsortedFlatListOfNodes[ix];
 		info.parentBoneIndex = currentRootIndex;
 		info.name = getNodeId(node);
-		auto boneIndex = output.size();
+		auto boneIndex = static_cast<int>(output.size());
 		output.push_back(info);
 		clusterIndexToBoneIndex[ix] = boneIndex;
 
@@ -45,7 +45,7 @@ void ComputeBoneHierarchy(const std::vector<FbxNode*>& unsortedFlatListOfNodes,
 			controlPointsData[controlPoint].push_back(biw);
 		}
 		// recursively parse children
-		ComputeBoneHierarchy(unsortedFlatListOfNodes, unsortedFlatListOfClusters, output, clusterIndexToBoneIndex, controlPointsData, node, boneIndex);
+		ComputeBoneHierarchy(unsortedFlatListOfNodes, unsortedFlatListOfClusters, output, clusterIndexToBoneIndex, controlPointsData, node, static_cast<int>(boneIndex));
 	}
 }
 FbxAMatrix NotDecomposedMultiply(const FbxAMatrix& lhs, const FbxAMatrix& rhs){
@@ -151,7 +151,7 @@ _node(meshNode), _mesh(meshNode->GetMesh()), _skin(nullptr)
 	auto animLengthInFrame = endFrame - startFrame + 1;
 
 
-	for (auto ix = 0ll; ix < animLengthInFrame; ix++){
+	for (auto ix = 0; ix < animLengthInFrame; ix++){
 		FbxTime currTime;
 		currTime.SetFrame(startFrame + ix, animTimeMode);
 
@@ -193,7 +193,7 @@ void SkinInfo::buildBabylonSkeleton(BabylonSkeleton& skel){
 	skel.name = getNodeId(_node) + L"_skeleton";
 	for (auto& b : _bones){
 		BabylonBone babbone;
-		babbone.index = skel.bones.size();
+		babbone.index = static_cast<int>(skel.bones.size());
 		//babbone.matrix = ConvertToBabylonCoordinateSystem( b.matrixLocalBindPose);
 		babbone.matrix = b.matrixLocalBindPose;
 		babbone.name = b.name;
@@ -208,7 +208,7 @@ void SkinInfo::buildBabylonSkeleton(BabylonSkeleton& skel){
 		auto endFrame = takeInfo->mLocalTimeSpan.GetStop().GetFrameCount(animTimeMode);
 		auto animLengthInFrame = endFrame - startFrame + 1;
 
-		auto matrixAnim = std::make_shared<BabylonAnimation<FbxAMatrix>>(BabylonAnimationBase::loopBehavior_Cycle, animFrameRate, L"_matrix", L"_matrix", true, 0, animLengthInFrame, true);
+		auto matrixAnim = std::make_shared<BabylonAnimation<FbxAMatrix>>(BabylonAnimationBase::loopBehavior_Cycle, static_cast<int>(animFrameRate), L"_matrix", L"_matrix", true, 0, static_cast<int>(animLengthInFrame), true);
 		for (auto& kf : b.keyFrames){
 
 			babylon_animation_key<FbxAMatrix> key;

Exporters/FBX/BabylonFbxNative/SkinInfo.h

@@ -49,7 +49,7 @@ public:
 	}
 
 	int bonesCount() const{
-		return _bones.size();
+		return static_cast<int>( _bones.size());
 	}
 
 	void buildBabylonSkeleton(BabylonSkeleton& skel);

Exporters/FBX/BabylonFbxNative/babylon_boundingbox.cpp

@@ -19,12 +19,12 @@ babylon_boundingbox::babylon_boundingbox()
 babylon_boundingbox::babylon_boundingbox(FbxScene* scene){
 	FbxVector4 vmin, vmax, vcenter;
 	scene->ComputeBoundingBoxMinMaxCenter(vmin, vmax, vcenter);
-	_minX = vmin[0];
-	_minY = vmin[1];
-	_minZ = vmin[2];
-	_maxX = vmax[0];
-	_maxY = vmax[1];
-	_maxZ = vmax[2];
+	_minX = static_cast<float>(vmin[0]);
+	_minY = static_cast<float>(vmin[1]);
+	_minZ = static_cast<float>(vmin[2]);
+	_maxX = static_cast<float>(vmax[0]);
+	_maxY = static_cast<float>(vmax[1]);
+	_maxZ = static_cast<float>(vmax[2]);
 
 }
 void babylon_boundingbox::addPosition(float x, float y, float z){

Exporters/FBX/FbxExporter/FbxExporter.cpp

@@ -32,6 +32,7 @@ std::string toString(BabylonNodeType type) {
 		return "<empty>";
 		break;
 	default:
+		return "unknown";
 		break;
 	}
 }
@@ -54,10 +55,10 @@ void printNode(BabylonNode& node, int indent = 0) {
 
 
 std::string wstringToUtf8(const std::wstring& src){
-	auto size = WideCharToMultiByte(CP_UTF8, 0, src.c_str(), src.size(), nullptr, 0, nullptr, nullptr);
+	auto size = WideCharToMultiByte(CP_UTF8, 0, src.c_str(), static_cast<int>( src.size()), nullptr, 0, nullptr, nullptr);
 	std::string result;
 	result.resize(size, ' ');
-	WideCharToMultiByte(CP_UTF8, 0, src.c_str(), src.size(), &result[0], result.size(),nullptr, nullptr);
+	WideCharToMultiByte(CP_UTF8, 0, src.c_str(), static_cast<int>(src.size()), &result[0], size,nullptr, nullptr);
 	return result;
 }
 
@@ -112,8 +113,8 @@ void exploreMeshes(BabylonScene& scene, BabylonNode& node, bool skipEmptyNodes)
 		scene.meshes().emplace_back(&node);
 		auto& mesh = scene.meshes()[scene.meshes().size() - 1];
 		if (mesh.associatedSkeleton){
-			mesh.associatedSkeleton->id = scene.skeletons().size()+1;
-			mesh.skeletonId(scene.skeletons().size()+1);
+			mesh.associatedSkeleton->id = static_cast<int>(scene.skeletons().size()+1);
+			mesh.skeletonId(static_cast<int>(scene.skeletons().size()+1));
 			scene.skeletons().push_back(mesh.associatedSkeleton);
 		}
 		if (multiMat.materials.size() > 0) {
@@ -189,7 +190,7 @@ void exportTexture(const std::shared_ptr<BabylonTexture>& tex, const std::wstrin
 		}
 		outputPath[indexOfSlash] = L'\\';
 	}
-	auto start = 0;
+	size_t start = 0;
 	for (;;){
 		auto indexOfSlash = outputPath.find(L'\\', start);
 		if (indexOfSlash == outputPath.npos){

Exporters/FBX/FbxRerouteSkeleton/FbxRerouteSkeleton.cpp

@@ -12,10 +12,10 @@
 #include <memory>
 
 std::string wstringToUtf8(const std::wstring& src){
-	auto size = WideCharToMultiByte(CP_UTF8, 0, src.c_str(), src.size(), nullptr, 0, nullptr, nullptr);
+	auto size = WideCharToMultiByte(CP_UTF8, 0, src.c_str(), static_cast<int>(src.size()), nullptr, 0, nullptr, nullptr);
 	std::string result;
 	result.resize(size, ' ');
-	WideCharToMultiByte(CP_UTF8, 0, src.c_str(), src.size(), &result[0], result.size(), nullptr, nullptr);
+	WideCharToMultiByte(CP_UTF8, 0, src.c_str(), static_cast<int>(src.size()), &result[0], size, nullptr, nullptr);
 	return result;
 }