void PlatformAddCmd::Run()
{
ToolSystem* tsystem = GetSubsystem<ToolSystem>();
Project* project = tsystem->GetProject();
Platform* platform = tsystem->GetPlatformByName(platformToAdd_);
if (!platform)
{
Error(ToString("Unknown platform: %s", platformToAdd_.CString()));
return;
}
if (project->ContainsPlatform(platform->GetPlatformID()))
{
Error(ToString("Project already contains platform: %s", platformToAdd_.CString()));
return;
}
LOGINFOF("Adding platform: %s", platformToAdd_.CString());
project->AddPlatform(platform->GetPlatformID());
Finished();
}
void PlayCmd::Run()
{
LOGINFOF("Playing project");
ToolSystem* tsystem = GetSubsystem<ToolSystem>();
ToolEnvironment* env = GetSubsystem<ToolCore::ToolEnvironment>();
Project* project = tsystem->GetProject();
const String& editorBinary = env->GetEditorBinary();
Vector<String> paths;
paths.Push(env->GetCoreDataDir());
paths.Push(env->GetPlayerDataDir());
paths.Push(project->GetResourcePath());
// fixme: this is for loading from cache
paths.Push(project->GetProjectPath());
paths.Push(project->GetProjectPath() + "Cache");
String resourcePaths;
resourcePaths.Join(paths, "!");
Vector<String> vargs;
String args = ToString("--player --project \"%s\"", AddTrailingSlash(project->GetProjectPath()).CString());
vargs = args.Split(' ');
//vargs.Insert(0, "--player");
// TODO: use IPC (maybe before this set log location/access the log and output it, we need access to errors)
LaunchPlayerProcess(editorBinary, vargs, "");
Finished();
}
void BuildSystem::BuildComplete(PlatformID platform, const String &buildFolder, bool success, bool fail3D)
{
VariantMap eventData;
if (success)
{
eventData[BuildComplete::P_PLATFORMID] = (unsigned) platform;
SendEvent(E_BUILDCOMPLETE, eventData);
LOGINFOF("Build Success");
}
else
{
eventData[BuildFailed::P_PLATFORMID] = (unsigned) platform;
SendEvent(E_BUILDFAILED, eventData);
LOGINFOF("Build Failed");
}
currentBuild_ = 0;
}
bool jsplugin_load(JSVM* vm, const String& pluginLibrary)
{
String errorMsg;
atomic_plugin_validate_function validatefunc;
duk_c_function initfunc;
duk_context* ctx = vm->GetJSContext();
LOGINFOF("Loading Native Plugin: %s", pluginLibrary.CString());
if (!jsplugin_get_entry_points(pluginLibrary, &validatefunc, &initfunc, errorMsg))
{
LOGERRORF("%s", errorMsg.CString());
return false;
}
int version = ATOMIC_JSPLUGIN_VERSION;
if (!validatefunc(version, &gJSVMExports, sizeof(JSVMImports)))
{
LOGERRORF("Native Plugin: atomic_plugin_validate failed: %s", pluginLibrary.CString());
return false;
}
// just to verify that we're not doing anything funky with the stack
int top = duk_get_top(ctx);
// the import function is a standard duktape c function, neat
duk_push_c_function(ctx, initfunc, 1);
// requires exports to be at index 2
duk_dup(ctx, 2);
bool success = true;
if (duk_pcall(ctx, 1) != DUK_EXEC_SUCCESS)
{
success = false;
LOGERRORF("Native Plugin: error calling atomic_plugin_init %s", pluginLibrary.CString());
}
else
{
if (!duk_is_boolean(ctx, -1) || !duk_to_boolean(ctx, -1))
{
success = false;
LOGERRORF("Native Plugin: error calling atomic_plugin_init, didn't return true %s", pluginLibrary.CString());
}
}
duk_pop(ctx);
assert(top == duk_get_top(ctx));
return success;
}
bool ModelImporter::ImportAnimation(const String& filename, const String& name, float startTime, float endTime)
{
SharedPtr<OpenAssetImporter> importer(new OpenAssetImporter(context_));
//importer->SetVerboseLog(true);
importer->SetScale(scale_);
importer->SetExportAnimations(true);
importer->SetStartTime(startTime);
importer->SetEndTime(endTime);
if (importer->Load(filename))
{
importer->ExportModel(asset_->GetCachePath(), name, true);
const Vector<OpenAssetImporter::AnimationInfo>& infos = importer->GetAnimationInfos();
for (unsigned i = 0; i < infos.Size(); i++)
{
const OpenAssetImporter::AnimationInfo& info = infos.At(i);
String pathName, fileName, extension;
SplitPath(info.cacheFilename_, pathName, fileName, extension);
ResourceCache* cache = GetSubsystem<ResourceCache>();
AnimatedModel* animatedModel = importNode_->GetComponent<AnimatedModel>();
if (animatedModel)
{
Model* model = animatedModel->GetModel();
if (model)
{
SharedPtr<Animation> animation = cache->GetTempResource<Animation>(fileName + extension);
if (animation)
model->AddAnimationResource(animation);
}
}
LOGINFOF("Import Info: %s : %s", info.name_.CString(), fileName.CString());
}
return true;
}
return false;
}
// load .asset
bool Asset::Load()
{
FileSystem* fs = GetSubsystem<FileSystem>();
AssetDatabase* db = GetSubsystem<AssetDatabase>();
String assetFilename = GetDotAssetFilename();
SharedPtr<File> file(new File(context_, assetFilename));
json_ = new JSONFile(context_);
json_->Load(*file);
file->Close();
JSONValue root = json_->GetRoot();
assert(root.Get("version").GetInt() == ASSET_VERSION);
guid_ = root.Get("guid").GetString();
db->RegisterGUID(guid_);
dirty_ = false;
if (!CheckCacheFile())
{
LOGINFOF("CheckCacheFile:false - %s", path_.CString());
dirty_ = true;
}
// handle import
if (importer_.NotNull())
importer_->LoadSettings(root);
json_ = 0;
return true;
}
void openWindow(const char* app_name, WindowsDesc* winDesc)
{
winDesc->fullscreenRect = { 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN) };
// If user provided invalid or zero rect, get the rect from renderer
if (getRectWidth(winDesc->windowedRect) <= 0 || getRectHeight(winDesc->windowedRect) <= 0)
{
getRecommendedResolution(&winDesc->windowedRect);
}
RECT clientRect = { (LONG)winDesc->windowedRect.left, (LONG)winDesc->windowedRect.top, (LONG)winDesc->windowedRect.right, (LONG)winDesc->windowedRect.bottom };
AdjustWindowRect(&clientRect, WS_OVERLAPPEDWINDOW, FALSE);
winDesc->windowedRect = { (int)clientRect.left, (int)clientRect.top, (int)clientRect.right, (int)clientRect.bottom };
RectDesc& rect = winDesc->fullScreen ? winDesc->fullscreenRect : winDesc->windowedRect;
WCHAR app[MAX_PATH];
size_t charConverted = 0;
mbstowcs_s(&charConverted, app, app_name, MAX_PATH);
HWND hwnd = CreateWindowW(CONFETTI_WINDOW_CLASS,
app,
WS_OVERLAPPEDWINDOW | ((winDesc->visible) ? WS_VISIBLE : 0),
CW_USEDEFAULT,
CW_USEDEFAULT,
rect.right - rect.left,
rect.bottom - rect.top,
NULL,
NULL,
(HINSTANCE)GetModuleHandle(NULL),
0
);
if (hwnd)
{
GetClientRect(hwnd, &clientRect);
winDesc->windowedRect = { (int)clientRect.left, (int)clientRect.top, (int)clientRect.right, (int)clientRect.bottom };
winDesc->handle = hwnd;
gHWNDMap.insert({ hwnd, winDesc });
if (winDesc->visible)
{
if (winDesc->maximized)
{
ShowWindow(hwnd, SW_MAXIMIZE);
}
else if (winDesc->minimized)
{
ShowWindow(hwnd, SW_MINIMIZE);
}
else if (winDesc->fullScreen)
{
adjustWindow(winDesc);
}
}
LOGINFOF("Created window app %s", app_name);
}
else
{
LOGERRORF("Failed to create window app %s", app_name);
}
}
bool JSBModule::Load(const String& jsonFilename)
{
JSBind* jsbind = GetSubsystem<JSBind>();
LOGINFOF("Loading Module: %s", jsonFilename.CString());
SharedPtr<File> jsonFile(new File(context_, jsonFilename));
if (!jsonFile->IsOpen())
{
LOGERRORF("Unable to open module json: %s", jsonFilename.CString());
return false;
}
moduleJSON_ = new JSONFile(context_);
if (!moduleJSON_->BeginLoad(*jsonFile))
{
LOGERRORF("Unable to parse module json: %s", jsonFilename.CString());
return false;
}
JSONValue root = moduleJSON_->GetRoot();
name_ = root.GetString("name");
JSONValue requires = root.GetChild("requires");
if (requires.IsArray())
{
for (unsigned j = 0; j < requires.GetSize(); j++)
{
requirements_.Push(requires.GetString(j));
}
}
JSONValue classes = root.GetChild("classes");
for (unsigned i = 0; i < classes.GetSize(); i++)
{
classnames_.Push(classes.GetString(i));
}
JSONValue classes_rename = root.GetChild("classes_rename");
if (classes_rename.IsObject())
{
Vector<String> childNames = classes_rename.GetValueNames();
for (unsigned j = 0; j < childNames.Size(); j++)
{
String classname = childNames.At(j);
String crename = classes_rename.GetString(classname);
classRenames_[classname] = crename;
}
}
JSONValue includes = root.GetChild("includes");
if (includes.IsArray())
{
for (unsigned j = 0; j < includes.GetSize(); j++)
{
includes_.Push(includes.GetString(j));
}
}
JSONValue sources = root.GetChild("sources");
for (unsigned i = 0; i < sources.GetSize(); i++)
{
sourceDirs_.Push(sources.GetString(i));
}
if (name_ == "Graphics")
{
#ifdef _MSC_VER
if (jsbind->GetPlatform() == "ANDROID" || jsbind->GetPlatform() == "WEB")
{
sourceDirs_.Push("Source/Atomic/Graphics/OpenGL");
}
else
{
#ifdef ATOMIC_D3D11
sourceDirs_.Push("Source/Atomic/Graphics/Direct3D11");
#else
sourceDirs_.Push("Source/Atomic/Graphics/Direct3D9");
#endif
}
#else
sourceDirs_.Push("Source/Atomic/Graphics/OpenGL");
#endif
}
ScanHeaders();
return true;
}
