void BuildIOS::Build(const String& buildPath)
{
buildPath_ = buildPath + "/IOS-Build";
Initialize();
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if (fileSystem->DirExists(buildPath_))
fileSystem->RemoveDir(buildPath_, true);
#ifdef ATOMIC_PLATFORM_WINDOWS
String buildSourceDir = fileSystem->GetProgramDir();
#else
String buildSourceDir = fileSystem->GetAppBundleResourceFolder();
#endif
String buildAppSourceDir = buildSourceDir + "Deployment/IOS/AtomicPlayer.app";
fileSystem->CreateDir(buildPath_);
String buildDestDist = buildPath_ + "/AtomicPlayer.app";
fileSystem->CreateDir(buildDestDist);
String resourcePackagePath = buildDestDist + "/AtomicResources.pak";
GenerateResourcePackage(resourcePackagePath);
fileSystem->Copy(buildAppSourceDir + "/AtomicPlayer", buildDestDist + "/AtomicPlayer");
fileSystem->Copy(buildAppSourceDir + "/PkgInfo", buildDestDist + "/PkgInfo");
BuildSystem* buildSystem = GetSubsystem<BuildSystem>();
IOSBuildSettings settings = buildSystem->GetBuildSettings()->GetIOSSettings();
fileSystem->Copy(settings.provisionFile, buildDestDist + "/embedded.mobileprovision");
String entitlements = GenerateEntitlements();
String plist = GenerateInfoPlist();
File file(context_, buildPath_ + "/AtomicPlayer.app.xcent", FILE_WRITE);
if (file.IsOpen())
{
file.Write(entitlements.CString(), entitlements.Length());
file.Close();
}
File pfile(context_, buildDestDist + "/Info.plist", FILE_WRITE);
if (pfile.IsOpen())
{
pfile.Write(plist.CString(), plist.Length());
pfile.Close();
}
RunConvertPList();
}
void ResourceOps::HandleNewFolder(const String& resourcePath, bool reportError)
{
Editor* editor = GetSubsystem<Editor>();
FileSystem* fs = GetSubsystem<FileSystem>();
if (fs->DirExists(resourcePath) || fs->FileExists(resourcePath))
{
if (reportError)
{
String errorMsg;
errorMsg.AppendWithFormat("Already exists:\n\n %s", resourcePath.CString());
editor->PostModalError("New Folder Error", errorMsg);
}
return;
}
if (!fs->CreateDir(resourcePath))
{
if (reportError)
{
String errorMsg;
errorMsg.AppendWithFormat("Could not create:\n\n %s", resourcePath.CString());
editor->PostModalError("New Folder Error", errorMsg);
}
return;
}
// file watcher doesn't currently handle subdir
GetSubsystem<MainFrame>()->GetProjectFrame()->Refresh();
}
void BuildMac::Build(const String& buildPath)
{
ToolSystem* tsystem = GetSubsystem<ToolSystem>();
buildPath_ = AddTrailingSlash(buildPath) + GetBuildSubfolder();
Initialize();
BuildSystem* buildSystem = GetSubsystem<BuildSystem>();
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if (fileSystem->DirExists(buildPath_))
fileSystem->RemoveDir(buildPath_, true);
String dataPath = tsystem->GetDataPath();
String appSrcPath = dataPath + "Deployment/MacOS/AtomicPlayer.app";
fileSystem->CreateDir(buildPath_);
buildPath_ += "/AtomicPlayer.app";
fileSystem->CreateDir(buildPath_);
fileSystem->CreateDir(buildPath_ + "/Contents");
fileSystem->CreateDir(buildPath_ + "/Contents/MacOS");
fileSystem->CreateDir(buildPath_ + "/Contents/Resources");
String resourcePackagePath = buildPath_ + "/Contents/Resources/AtomicResources.pak";
GenerateResourcePackage(resourcePackagePath);
fileSystem->Copy(appSrcPath + "/Contents/Resources/Atomic.icns", buildPath_ + "/Contents/Resources/Atomic.icns");
fileSystem->Copy(appSrcPath + "/Contents/Info.plist", buildPath_ + "/Contents/Info.plist");
fileSystem->Copy(appSrcPath + "/Contents/MacOS/AtomicPlayer", buildPath_ + "/Contents/MacOS/AtomicPlayer");
#ifdef ATOMIC_PLATFORM_OSX
Vector<String> args;
args.Push("+x");
args.Push(buildPath_ + "/Contents/MacOS/AtomicPlayer");
fileSystem->SystemRun("chmod", args);
#endif
buildPath_ = buildPath + "/Mac-Build";
buildSystem->BuildComplete(PLATFORMID_MAC, buildPath_);
}
void ShaderCompiler::LoadSahders()
{
FileSystem* fileSystem = new FileSystem(context_);
if(!fileSystem->DirExists("../Shaders"))
fileSystem->CreateDir("../Shaders");
}
void ShaderVariation::SaveByteCode(const String& binaryShaderName)
{
ResourceCache* cache = owner_->GetSubsystem<ResourceCache>();
FileSystem* fileSystem = owner_->GetSubsystem<FileSystem>();
// Filename may or may not be inside the resource system
String fullName = binaryShaderName;
if (!IsAbsolutePath(fullName))
{
// If not absolute, use the resource dir of the shader
String shaderFileName = cache->GetResourceFileName(owner_->GetName());
if (shaderFileName.Empty())
return;
fullName = shaderFileName.Substring(0, shaderFileName.Find(owner_->GetName())) + binaryShaderName;
}
String path = GetPath(fullName);
if (!fileSystem->DirExists(path))
fileSystem->CreateDir(path);
SharedPtr<File> file(new File(owner_->GetContext(), fullName, FILE_WRITE));
if (!file->IsOpen())
return;
file->WriteFileID("USHD");
file->WriteShort((unsigned short)type_);
file->WriteShort(3);
file->WriteUInt(parameters_.Size());
for (HashMap<StringHash, ShaderParameter>::ConstIterator i = parameters_.Begin(); i != parameters_.End(); ++i)
{
file->WriteString(i->second_.name_);
file->WriteUByte((unsigned char)i->second_.register_);
file->WriteUByte((unsigned char)i->second_.regCount_);
}
unsigned usedTextureUnits = 0;
for (unsigned i = 0; i < MAX_TEXTURE_UNITS; ++i)
{
if (useTextureUnit_[i])
++usedTextureUnits;
}
file->WriteUInt(usedTextureUnits);
for (unsigned i = 0; i < MAX_TEXTURE_UNITS; ++i)
{
if (useTextureUnit_[i])
{
file->WriteString(graphics_->GetTextureUnitName((TextureUnit)i));
file->WriteUByte((unsigned char)i);
}
}
unsigned dataSize = byteCode_.Size();
file->WriteUInt(dataSize);
if (dataSize)
file->Write(&byteCode_[0], dataSize);
}
void AssetDatabase::HandleProjectLoaded(StringHash eventType, VariantMap& eventData)
{
project_ = GetSubsystem<ToolSystem>()->GetProject();
FileSystem* fs = GetSubsystem<FileSystem>();
if (!fs->DirExists(GetCachePath()))
fs->CreateDir(GetCachePath());
ResourceCache* cache = GetSubsystem<ResourceCache>();
cache->AddResourceDir(GetCachePath());
Scan();
SubscribeToEvent(E_FILECHANGED, HANDLER(AssetDatabase, HandleFileChanged));
}
bool BuildBase::BuildCreateDirectory(const String& path)
{
if (buildFailed_)
{
LOGERRORF("BuildBase::BuildCreateDirectory - Attempt to create directory of failed build, %s", path.CString());
return false;
}
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if (fileSystem->DirExists(path))
return true;
bool result = fileSystem->CreateDir(path);
if (!result)
{
FailBuild(ToString("BuildBase::BuildCreateDirectory: Unable to create directory %s", path.CString()));
return false;
}
return true;
}
void AtomicTool::Start()
{
// Subscribe to events
SubscribeToEvent(E_COMMANDERROR, HANDLER(AtomicTool, HandleCommandError));
SubscribeToEvent(E_COMMANDFINISHED, HANDLER(AtomicTool, HandleCommandFinished));
SubscribeToEvent(E_LICENSE_EULAREQUIRED, HANDLER(AtomicTool, HandleLicenseEulaRequired));
SubscribeToEvent(E_LICENSE_ACTIVATIONREQUIRED, HANDLER(AtomicTool, HandleLicenseActivationRequired));
SubscribeToEvent(E_LICENSE_ERROR, HANDLER(AtomicTool, HandleLicenseError));
SubscribeToEvent(E_LICENSE_SUCCESS, HANDLER(AtomicTool, HandleLicenseSuccess));
const Vector<String>& arguments = GetArguments();
ToolSystem* tsystem = new ToolSystem(context_);
context_->RegisterSubsystem(tsystem);
ToolEnvironment* env = new ToolEnvironment(context_);
context_->RegisterSubsystem(env);
//#ifdef ATOMIC_DEV_BUILD
if (!env->InitFromJSON())
{
ErrorExit(ToString("Unable to initialize tool environment from %s", env->GetDevConfigFilename().CString()));
return;
}
if (!cliDataPath_.Length())
{
cliDataPath_ = env->GetRootSourceDir() + "/Resources/";
}
//#endif
tsystem->SetCLI();
tsystem->SetDataPath(cliDataPath_);
if (activationKey_.Length())
{
DoActivation();
return;
} else if (deactivate_)
{
DoDeactivation();
return;
}
BuildSystem* buildSystem = GetSubsystem<BuildSystem>();
SharedPtr<CommandParser> parser(new CommandParser(context_));
SharedPtr<Command> cmd(parser->Parse(arguments));
if (!cmd)
{
String error = "No command found";
if (parser->GetErrorMessage().Length())
error = parser->GetErrorMessage();
ErrorExit(error);
return;
}
if (cmd->RequiresProjectLoad())
{
FileSystem* fileSystem = GetSubsystem<FileSystem>();
String projectDirectory = fileSystem->GetCurrentDir();
Vector<String> projectFiles;
fileSystem->ScanDir(projectFiles, projectDirectory, "*.atomic", SCAN_FILES, false);
if (!projectFiles.Size())
{
ErrorExit(ToString("No .atomic project file in %s", projectDirectory.CString()));
return;
}
else if (projectFiles.Size() > 1)
{
ErrorExit(ToString("Multiple .atomic project files found in %s", projectDirectory.CString()));
return;
}
String projectFile = projectDirectory + "/" + projectFiles[0];
if (!tsystem->LoadProject(projectFile))
{
//ErrorExit(ToString("Failed to load project: %s", projectFile.CString()));
//return;
}
// Set the build path
String buildFolder = projectDirectory + "/" + "Build";
buildSystem->SetBuildPath(buildFolder);
if (!fileSystem->DirExists(buildFolder))
{
fileSystem->CreateDir(buildFolder);
if (!fileSystem->DirExists(buildFolder))
{
ErrorExit(ToString("Failed to create build folder: %s", buildFolder.CString()));
return;
}
}
}
command_ = cmd;
// BEGIN LICENSE MANAGEMENT
if (cmd->RequiresLicenseValidation())
{
GetSubsystem<LicenseSystem>()->Initialize();
}
else
{
if (command_.Null())
{
GetSubsystem<Engine>()->Exit();
return;
}
command_->Run();
}
// END LICENSE MANAGEMENT
}
void BuildMac::Build(const String& buildPath)
{
buildPath_ = buildPath + "/Mac-Build";
Initialize();
BuildSystem* buildSystem = GetSubsystem<BuildSystem>();
// BEGIN LICENSE MANAGEMENT
LicenseSystem *licenseSystem = GetSubsystem<LicenseSystem>();
if (licenseSystem->IsStandardLicense())
{
if (containsMDL_)
{
buildSystem->BuildComplete(CE_PLATFORM_MAC, buildPath_, false, true);
return;
}
}
// END LICENSE MANAGEMENT
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if (fileSystem->DirExists(buildPath_))
fileSystem->RemoveDir(buildPath_, true);
#ifdef CLOCKWORK_PLATFORM_WINDOWS
String buildSourceDir = fileSystem->GetProgramDir();
#else
String buildSourceDir = fileSystem->GetAppBundleResourceFolder();
#endif
buildSourceDir += "Deployment/MacOS/ClockworkPlayer.app";
fileSystem->CreateDir(buildPath_);
buildPath_ += "/ClockworkPlayer.app";
fileSystem->CreateDir(buildPath_);
fileSystem->CreateDir(buildPath_ + "/Contents");
fileSystem->CreateDir(buildPath_ + "/Contents/MacOS");
fileSystem->CreateDir(buildPath_ + "/Contents/Resources");
String resourcePackagePath = buildPath_ + "/Contents/Resources/ClockworkResources.pak";
GenerateResourcePackage(resourcePackagePath);
fileSystem->Copy(buildSourceDir + "/Contents/Resources/Clockwork.icns", buildPath_ + "/Contents/Resources/Clockwork.icns");
fileSystem->Copy(buildSourceDir + "/Contents/Info.plist", buildPath_ + "/Contents/Info.plist");
fileSystem->Copy(buildSourceDir + "/Contents/MacOS/ClockworkPlayer", buildPath_ + "/Contents/MacOS/ClockworkPlayer");
#ifdef CLOCKWORK_PLATFORM_OSX
Vector<String> args;
args.Push("+x");
args.Push(buildPath_ + "/Contents/MacOS/ClockworkPlayer");
fileSystem->SystemRun("chmod", args);
#endif
buildPath_ = buildPath + "/Mac-Build";
buildSystem->BuildComplete(CE_PLATFORM_MAC, buildPath_);
}
void BuildWindows::BuildAtomicNET()
{
// AtomicNET
FileSystem* fileSystem = GetSubsystem<FileSystem>();
ToolEnvironment* tenv = GetSubsystem<ToolEnvironment>();
ToolSystem* tsystem = GetSubsystem<ToolSystem>();
Project* project = tsystem->GetProject();
String projectResources = project->GetResourcePath();
String assembliesPath = projectResources + "Assemblies/";
// if no assemblies path, no need to install AtomicNET
if (!fileSystem->DirExists(assembliesPath))
return;
Vector<String> results;
fileSystem->ScanDir(results, assembliesPath, "*.dll", SCAN_FILES, true);
// if no assembiles in Assemblies path, no need to install AtomicNET
if (!results.Size())
return;
BuildLog("Building AtomicNET");
fileSystem->CreateDir(buildPath_ + "/AtomicPlayer_Resources/AtomicNET");
fileSystem->CreateDir(buildPath_ + "/AtomicPlayer_Resources/AtomicNET/Atomic");
fileSystem->CreateDir(buildPath_ + "/AtomicPlayer_Resources/AtomicNET/Atomic/Assemblies");
fileSystem->CopyDir(tenv->GetNETCoreCLRAbsPath(), buildPath_ + "/AtomicPlayer_Resources/AtomicNET/CoreCLR");
fileSystem->CopyDir(tenv->GetNETTPAPaths(), buildPath_ + "/AtomicPlayer_Resources/AtomicNET/Atomic/TPA");
// Atomic Assemblies
const String& assemblyLoadPaths = tenv->GetNETAssemblyLoadPaths();
Vector<String> paths = assemblyLoadPaths.Split(';');
for (unsigned i = 0; i < paths.Size(); i++)
{
Vector<String> loadResults;
fileSystem->ScanDir(loadResults, paths[i], "*.dll", SCAN_FILES, true);
for (unsigned j = 0; j < loadResults.Size(); j++)
{
String pathName, fileName, ext;
SplitPath(loadResults[j], pathName, fileName, ext);
if (fileName != "AtomicNETEngine")
continue;
fileSystem->Copy(paths[i] + "/" + loadResults[j], ToString("%s/AtomicPlayer_Resources/AtomicNET/Atomic/Assemblies/%s.dll", buildPath_.CString(), fileName.CString()));
}
}
// Project assemblied
for (unsigned i = 0; i < results.Size(); i++)
{
String pathName, fileName, ext;
SplitPath(results[i], pathName, fileName, ext);
fileSystem->Copy(assembliesPath + results[i], ToString("%s/AtomicPlayer_Resources/AtomicNET/Atomic/Assemblies/%s.dll", buildPath_.CString(), fileName.CString()));
}
}