void CommandConvertScene::Execute()
{
DVASSERT(CheckExtension(String(".dae")) && "Wrong extension");
SceneValidator::Instance()->CreateDefaultDescriptors(EditorSettings::Instance()->GetDataSourcePath());
eColladaErrorCodes code = ConvertDaeToSce(filePathname);
if(code == COLLADA_OK)
{
// load sce to scene object
String path = FileSystem::Instance()->ReplaceExtension(filePathname, ".sce");
Scene * scene = new Scene();
Entity *rootNode = scene->GetRootNode(path);
scene->AddNode(rootNode);
scene->BakeTransforms();
// Export to *.sc2
path = FileSystem::Instance()->ReplaceExtension(path, ".sc2");
SceneFileV2 * file = new SceneFileV2();
file->EnableDebugLog(true);
file->SaveScene(path.c_str(), scene);
SafeRelease(file);
SafeRelease(scene);
}
else if(code == COLLADA_ERROR_OF_ROOT_NODE)
{
ShowErrorDialog(String("Can't convert from DAE. Looks like one of materials has same name as root node."));
}
else
{
ShowErrorDialog(String("Can't convert from DAE."));
}
}
void SceneEditorScreenMain::AutoSaveLevel(BaseObject *, void *, void *)
{
time_t now = time(0);
tm* utcTime = localtime(&now);
String folderPath = EditorSettings::Instance()->GetDataSourcePath() + "Autosave";
bool folderExcists = FileSystem::Instance()->IsDirectory(folderPath);
if(!folderExcists)
{
FileSystem::Instance()->CreateDirectory(folderPath);
}
String pathToFile = folderPath + Format("/AutoSave_%04d.%02d.%02d_%02d_%02d.sc2",
utcTime->tm_year + 1900, utcTime->tm_mon + 1, utcTime->tm_mday,
utcTime->tm_hour, utcTime->tm_min);
BodyItem *iBody = bodies[0];
Scene * scene = iBody->bodyControl->GetScene();
SceneFileV2 * file = new SceneFileV2();
file->EnableDebugLog(false);
file->SaveScene(pathToFile, scene);
SafeRelease(file);
SetupAnimation();
}
void SceneSaver::SaveScene(Scene *scene, const FilePath &fileName, Set<String> &errorLog)
{
DVASSERT(0 == texturesForSave.size())
String relativeFilename = fileName.GetRelativePathname(sceneUtils.dataSourceFolder);
sceneUtils.workingFolder = fileName.GetDirectory().GetRelativePathname(sceneUtils.dataSourceFolder);
FileSystem::Instance()->CreateDirectory(sceneUtils.dataFolder + sceneUtils.workingFolder, true);
scene->Update(0.1f);
FilePath oldPath = SceneValidator::Instance()->SetPathForChecking(sceneUtils.dataSourceFolder);
SceneValidator::Instance()->ValidateScene(scene, errorLog);
texturesForSave.clear();
SceneDataManager::EnumerateTextures(scene, texturesForSave);
CopyTextures(scene, errorLog);
ReleaseTextures();
Landscape *landscape = EditorScene::GetLandscape(scene);
if (landscape)
{
sceneUtils.CopyFile(landscape->GetHeightmapPathname(), errorLog);
}
CopyReferencedObject(scene, errorLog);
CopyEffects(scene, errorLog);
CopyCustomColorTexture(scene, fileName.GetDirectory(), errorLog);
//save scene to new place
FilePath tempSceneName = sceneUtils.dataSourceFolder + relativeFilename;
tempSceneName.ReplaceExtension(".saved.sc2");
SceneFileV2 * outFile = new SceneFileV2();
outFile->EnableSaveForGame(true);
outFile->EnableDebugLog(false);
outFile->SaveScene(tempSceneName, scene);
SafeRelease(outFile);
bool moved = FileSystem::Instance()->MoveFile(tempSceneName, sceneUtils.dataFolder + relativeFilename, true);
if(!moved)
{
errorLog.insert(Format("Can't move file %s", fileName.GetAbsolutePathname().c_str()));
}
SceneValidator::Instance()->SetPathForChecking(oldPath);
}
void SceneEditorScreenMain::SaveSceneToFile(const String &pathToFile)
{
BodyItem *iBody = FindCurrentBody();
iBody->bodyControl->SetFilePath(pathToFile);
iBody->bodyControl->PushDebugCamera();
Scene * scene = iBody->bodyControl->GetScene();
uint64 startTime = SystemTimer::Instance()->AbsoluteMS();
SceneFileV2 * file = new SceneFileV2();
file->EnableDebugLog(false);
file->SaveScene(pathToFile, scene);
SafeRelease(file);
uint64 endTime = SystemTimer::Instance()->AbsoluteMS();
Logger::Info("[SAVE SCENE TIME] %d ms", (endTime - startTime));
iBody->bodyControl->PopDebugCamera();
}
Entity *Scene::GetRootNode(const FilePath &rootNodePath)
{
ProxyNodeMap::const_iterator it = rootNodes.find(FILEPATH_MAP_KEY(rootNodePath));
if (it != rootNodes.end())
{
ProxyNode * node = it->second;
return node->GetNode();
}
if(rootNodePath.IsEqualToExtension(".sce"))
{
SceneFile *file = new SceneFile();
file->SetDebugLog(true);
file->LoadScene(rootNodePath, this);
SafeRelease(file);
}
else if(rootNodePath.IsEqualToExtension(".sc2"))
{
uint64 startTime = SystemTimer::Instance()->AbsoluteMS();
SceneFileV2 *file = new SceneFileV2();
file->EnableDebugLog(false);
SceneFileV2::eError loadResult = file->LoadScene(rootNodePath, this);
SafeRelease(file);
uint64 deltaTime = SystemTimer::Instance()->AbsoluteMS() - startTime;
Logger::FrameworkDebug("[GETROOTNODE TIME] %dms (%ld)", deltaTime, deltaTime);
if (loadResult != SceneFileV2::ERROR_NO_ERROR)
{
return 0;
}
}
it = rootNodes.find(FILEPATH_MAP_KEY(rootNodePath));
if (it != rootNodes.end())
{
ProxyNode * node = it->second;
//int32 nowCount = node->GetNode()->GetChildrenCountRecursive();
return node->GetNode();
}
return 0;
}
void SceneSaver::ResaveFile(const String &fileName, Set<String> &errorLog)
{
DVASSERT(0); //TODO: check save
Logger::Info("[SceneSaver::ResaveFile] %s", fileName.c_str());
FilePath sc2Filename = sceneUtils.dataSourceFolder + fileName;
//Load scene with *.sc2
Scene *scene = new Scene();
Entity *rootNode = scene->GetRootNode(sc2Filename);
if(rootNode)
{
int32 count = rootNode->GetChildrenCount();
Vector<Entity*> tempV;
tempV.reserve((count));
for(int32 i = 0; i < count; ++i)
{
tempV.push_back(rootNode->GetChild(i));
}
for(int32 i = 0; i < count; ++i)
{
scene->AddNode(tempV[i]);
}
scene->Update(0.f);
SceneFileV2 * outFile = new SceneFileV2();
outFile->EnableDebugLog(false);
outFile->SaveScene(sc2Filename, scene);
SafeRelease(outFile);
}
else
{
errorLog.insert(Format("[SceneSaver::ResaveFile] Can't open file %s", fileName.c_str()));
}
SafeRelease(scene);
}
DAVA::Scene * DAEConvertWithSettingsAction::CreateSceneFromSc2(const DAVA::FilePath &scenePathname)
{
Scene * scene = new Scene();
Entity * rootNode = scene->GetRootNode(scenePathname);
if(rootNode)
{
rootNode = rootNode->Clone();
Vector<Entity*> tmpEntities;
uint32 entitiesCount = (uint32)rootNode->GetChildrenCount();
// optimize scene
SceneFileV2 *sceneFile = new SceneFileV2();
sceneFile->OptimizeScene(rootNode);
sceneFile->Release();
// remember all child pointers, but don't add them to scene in this cycle
// because when entity is adding it is automatically removing from its old hierarchy
tmpEntities.reserve(entitiesCount);
for (uint32 i = 0; i < entitiesCount; ++i)
{
tmpEntities.push_back(rootNode->GetChild(i));
}
// now we can safely add entities into our hierarchy
for (uint32 i = 0; i < (uint32) tmpEntities.size(); ++i)
{
scene->AddNode(tmpEntities[i]);
}
rootNode->Release();
Set<String> errorsLog;
SceneValidator::Instance()->ValidateScene(scene, scenePathname, errorsLog);
}
return scene;
}
Entity *Scene::GetRootNode(const FilePath &rootNodePath)
{
// ProxyNode * proxyNode = dynamic_cast<ProxyNode*>(scenes->FindByName(rootNodePath));
// if (proxyNode)
// {
// return proxyNode->GetNode();
// }
//
// String ext = FileSystem::Instance()->GetExtension(rootNodePath);
// if(ext == ".sce")
// {
// SceneFile *file = new SceneFile();
// file->SetDebugLog(true);
// file->LoadScene(rootNodePath, this);
// SafeRelease(file);
// }
// else if(ext == ".sc2")
// {
// SceneFileV2 *file = new SceneFileV2();
// file->EnableDebugLog(true);
// file->LoadScene(rootNodePath.c_str(), this);
// SafeRelease(file);
// }
//
// proxyNode = dynamic_cast<ProxyNode*>(scenes->FindByName(rootNodePath));
// if (proxyNode)
// {
// return proxyNode->GetNode();
// }
// return 0;
Map<String, ProxyNode*>::const_iterator it;
it = rootNodes.find(rootNodePath.GetAbsolutePathname());
if (it != rootNodes.end())
{
ProxyNode * node = it->second;
return node->GetNode();
}
if(rootNodePath.IsEqualToExtension(".sce"))
{
SceneFile *file = new SceneFile();
file->SetDebugLog(true);
file->LoadScene(rootNodePath, this);
SafeRelease(file);
}
else if(rootNodePath.IsEqualToExtension(".sc2"))
{
uint64 startTime = SystemTimer::Instance()->AbsoluteMS();
SceneFileV2 *file = new SceneFileV2();
file->EnableDebugLog(false);
file->LoadScene(rootNodePath, this);
SafeRelease(file);
uint64 deltaTime = SystemTimer::Instance()->AbsoluteMS() - startTime;
Logger::Info("[GETROOTNODE TIME] %dms (%ld)", deltaTime, deltaTime);
}
it = rootNodes.find(rootNodePath.GetAbsolutePathname());
if (it != rootNodes.end())
{
ProxyNode * node = it->second;
//int32 nowCount = node->GetNode()->GetChildrenCountRecursive();
return node->GetNode();
}
return 0;
}
int32 ScenePreviewControl::OpenScene(const FilePath &pathToFile)
{
ReleaseScene();
RecreateScene();
int32 retError = SceneFileV2::ERROR_NO_ERROR;
if(pathToFile.IsEqualToExtension(".sce"))
{
SceneFile *file = new SceneFile();
file->SetDebugLog(true);
if(!file->LoadScene(pathToFile, editorScene))
{
retError = ERROR_CANNOT_OPEN_FILE;
}
SafeRelease(file);
}
else if(pathToFile.IsEqualToExtension(".sc2"))
{
SceneFileV2 *file = new SceneFileV2();
file->EnableDebugLog(true);
retError = file->LoadScene(pathToFile, editorScene);
SafeRelease(file);
}
else
{
retError = ERROR_WRONG_EXTENSION;
}
if(SceneFileV2::ERROR_NO_ERROR == retError)
{
rootNode = editorScene->GetRootNode(pathToFile);
if(rootNode)
{
currentScenePath = pathToFile;
editorScene->AddNode(rootNode);
needSetCamera = true;
Camera *cam = editorScene->GetCamera(0);
if(!cam)
{
Camera * cam = new Camera();
//cam->SetDebugFlags(Entity::DEBUG_DRAW_ALL);
cam->SetUp(Vector3(0.0f, 0.0f, 1.0f));
cam->SetPosition(Vector3(0.0f, 0.0f, 0.0f));
cam->SetTarget(Vector3(0.0f, 1.0f, 0.0f));
cam->SetupPerspective(70.0f, 320.0f / 480.0f, 1.0f, 5000.0f);
ScopedPtr<Entity> node(new Entity());
node->SetName("preview-camera");
node->AddComponent(new CameraComponent(cam));
editorScene->AddNode(node);
editorScene->AddCamera(cam);
editorScene->SetCurrentCamera(cam);
cameraController->SetScene(editorScene);
SafeRelease(cam);
sceCamera = false;
}
else
{
sceCamera = true;
}
}
}
SceneValidator::Instance()->ValidateSceneAndShowErrors(editorScene);
return retError;
}
