Babylon.js/Exporters/FBX/BabylonFbxNative/BabylonScene.cpp

#include "stdafx.h"
#include "BabylonScene.h"


web::json::value BabylonScene::toJson() 
{
	auto jobj = web::json::value::object();
	jobj[L"autoClear"] = web::json::value::boolean(_autoClear);
	writeVector3(jobj, L"clearColor", _clearColor);
	writeVector3(jobj, L"ambientColor", _ambientColor);
	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);
	jobj[L"fogDensity"] = web::json::value::number(_fogDensity);
	writeVector3(jobj, L"gravity", _gravity);
	jobj[L"activeCameraID"] = web::json::value::string(_activeCameraID);

	auto jcameras = web::json::value::array();

	for (auto& cam : _cameras) {
		jcameras[jcameras.size()] = cam.toJson();
	}

	jobj[L"cameras"] = jcameras;

	auto jmeshes = web::json::value::array();
	for (auto& mesh : _meshes) {
		jmeshes[jmeshes.size()] = mesh.toJson();
	}
	jobj[L"meshes"] = jmeshes;


	auto jmats = web::json::value::array();
	for (auto& mat : _materials) {
		jmats[jmats.size()] = mat.toJson();
	}
	jobj[L"materials"] = jmats;

	auto jmulmats = web::json::value::array();
	for (auto& mat : _multiMaterials) {
		jmulmats[jmulmats.size()] = mat.toJson();
	}
	jobj[L"multiMaterials"] = jmulmats;

	auto jlights = web::json::value::array();
	for (auto& light : _lights) {
		jlights[jlights.size()] = light.toJson();
	}
	jobj[L"lights"] = jlights;

	auto jskeletons = web::json::value::array();
	for (auto& skel : _skeletons){
		jskeletons[jskeletons.size()] = skel->toJson();
	}
	jobj[L"skeletons"] = jskeletons;
	auto jshadowGenerators = web::json::value::array();
	for (auto& sg : _shadowGenerators) {
		jshadowGenerators[jshadowGenerators.size()] = sg->toJson();
	}
	jobj[L"shadowGenerators"] = jshadowGenerators;
	return jobj;
}

BabylonScene::BabylonScene() :
_autoClear(true),
_clearColor(.2f, .2f, .3f),
_ambientColor(0,0,0),
_gravity(0,0,-.9f)
{
}

BabylonScene::BabylonScene(BabylonNode & rootNode, bool skipEmptyNodes) :
	_autoClear(true),
	_clearColor(.2f, .2f, .3f),
	_ambientColor(0, 0, 0),
	_gravity(0, 0, -.9f)
{
	exploreNodes(rootNode, skipEmptyNodes);
	if (_cameras.size() == 0) {
		babylon_boundingbox bbox(rootNode.fbxNode()->GetScene());
		auto cam = buildCameraFromBoundingBox(bbox);
		_activeCameraID = cam.id;
		_cameras.push_back(std::move(cam));
	}
	if (_lights.size() == 0) {
		BabylonLight light;
		light.diffuse = babylon_vector3(1, 1, 1);
		light.specular = babylon_vector3(1, 1, 1);
		light.position = babylon_vector3(0, 0, 0);
		light.parentId = _activeCameraID;
		light.type = 0;
		light.id = L"default_light";
		light.name = L"default_light";
		light.intensity = 1;
		_lights.push_back(std::move(light));
	}
}


BabylonScene::BabylonScene(BabylonScene && moved) : 
	_autoClear(std::move(moved._autoClear)),
	_clearColor(std::move(moved._clearColor)),
	_ambientColor(std::move(moved._ambientColor)),
	_fogMode(std::move(moved._fogMode)),
	_fogColor(std::move(moved._fogColor)),
	_fogStart(std::move(moved._fogStart)),
	_fogEnd(std::move(moved._fogEnd)),
	_fogDensity(std::move(moved._fogDensity)),
	_gravity(std::move(moved._gravity)),
	_cameras(std::move(moved._cameras)),
	_activeCameraID(std::move(moved._activeCameraID)),
	_meshes(std::move(moved._meshes)),
	_materials(std::move(moved._materials)),
	_multiMaterials(std::move(moved._multiMaterials)),
	_lights(std::move(moved._lights)),
	_shadowGenerators(std::move(moved._shadowGenerators)),
	_skeletons(std::move(moved._skeletons))
{
}

BabylonScene::~BabylonScene()
{
}


void fixupTextureCoordinateIndices(BabylonMaterial& mat, BabylonMesh& mesh) {
	std::vector<std::shared_ptr<BabylonTexture>> textures;
	if (mat.ambientTexture) {
		textures.push_back(mat.ambientTexture);
	}
	if (mat.diffuseTexture) {
		textures.push_back(mat.diffuseTexture);
	}
	if (mat.specularTexture) {
		textures.push_back(mat.specularTexture);
	}
	if (mat.emissiveTexture) {
		textures.push_back(mat.emissiveTexture);
	}
	if (mat.reflectionTexture) {
		textures.push_back(mat.reflectionTexture);
	}
	if (mat.bumpTexture) {
		textures.push_back(mat.bumpTexture);
	}
	for (auto& tex : textures) {
		auto found = std::find(mesh.uvsets.begin(), mesh.uvsets.end(), tex->uvset);
		if (found != mesh.uvsets.end()) {
			tex->coordinatesIndex = static_cast<int>(found - mesh.uvsets.begin());
		}
	}
}

void BabylonScene::exploreNodes(BabylonNode & node, bool skipEmptyNodes)
{
	if (node.nodeType() == BabylonNodeType::Skeleton && node.hasOnlySkeletonDescendants()) {
		return;
	}
	if (skipEmptyNodes && node.isEmptySkeletonOrEmptyMeshRecursive()) {
		return;
	}
	// append mesh
	switch (node.nodeType())
	{
	case BabylonNodeType::Empty:
	case BabylonNodeType::Mesh:
	case BabylonNodeType::Skeleton:
	{

		BabylonMesh mesh(&node);

		auto matCount = node.fbxNode()->GetMaterialCount();
		BabylonMultiMaterial multiMat;
		for (auto i = 0; i < matCount; ++i) {
			auto mat = node.fbxNode()->GetMaterial(i);
			if (mat) {

				auto id = getMaterialId(mat);
				auto existing = std::find_if(_materials.begin(), _materials.end(), [id](const BabylonMaterial& e) {
					return e.id == id;
				});
				if (existing == _materials.end()) {
					auto babMat = BabylonMaterial(mat);
					fixupTextureCoordinateIndices(babMat, mesh);
					_materials.push_back(std::move(babMat));
				}

				multiMat.materials.push_back(id);

			}
		}

		if (mesh.associatedSkeleton) {
			mesh.associatedSkeleton->id = static_cast<int>(_skeletons.size() + 1);
			mesh.skeletonId(static_cast<int>(_skeletons.size() + 1));
			_skeletons.push_back(mesh.associatedSkeleton);
		}
		if (multiMat.materials.size() > 0) {

			multiMat.id = mesh.id();
			multiMat.name = mesh.name();
			mesh.materialId(multiMat.id);
			_multiMaterials.push_back(std::move(multiMat));
		}

		_meshes.push_back(std::move(mesh));
	}
	break;
	case BabylonNodeType::Camera:
	{
		_cameras.emplace_back(node);
		if (_cameras.size() == 1) {
			activeCameraID(_cameras[0].id);
		}
	}
	break;
	case BabylonNodeType::Light:
	{
		_lights.emplace_back(node);
		auto& l = _lights[_lights.size() - 1];
		if (l.shadowGenerator) {
			_shadowGenerators.push_back(l.shadowGenerator);
		}
	}
	break;
	default:
		break;
	}


	for (auto& child : node.children()) {
		exploreNodes(child, skipEmptyNodes);
	}

}