/// Check if request is for an AngelScript file and reroute to compiled version if necessary (.as file not available)
virtual void Route(String& name, ResourceRequest requestType)
{
String extension = GetExtension(name);
if (extension == ".as")
{
String replaced = ReplaceExtension(name, ".asc");
// Note: ResourceCache prevents recursive calls to the resource routers so this is OK, the nested Exists()
// check does not go through the router again
ResourceCache* cache = GetSubsystem<ResourceCache>();
if (!cache->Exists(name) && cache->Exists(replaced))
name = replaced;
}
}
void Texture::LoadParameters()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
if (cache->Exists(xmlName))
{
XMLFile* file = cache->GetResource<XMLFile>(xmlName);
LoadParameters(file);
}
}
void TextureCube::OnDeviceReset()
{
if (pool_ == D3DPOOL_DEFAULT || !object_ || dataPending_)
{
// If has a resource file, reload through the resource cache. Otherwise just recreate.
ResourceCache* cache = GetSubsystem<ResourceCache>();
if (cache->Exists(GetName()))
dataLost_ = !cache->ReloadResource(this);
if (!object_)
{
Create();
dataLost_ = true;
}
}
dataPending_ = false;
}
void Texture2DArray::OnDeviceReset()
{
if (usage_ > TEXTURE_STATIC || !object_.ptr_ || dataPending_)
{
// If has a resource file, reload through the resource cache. Otherwise just recreate.
ResourceCache* cache = GetSubsystem<ResourceCache>();
if (cache->Exists(GetName()))
dataLost_ = !cache->ReloadResource(this);
if (!object_.ptr_)
{
Create();
dataLost_ = true;
}
}
dataPending_ = false;
}
void TextureCube::OnDeviceReset()
{
if (!object_ || dataPending_)
{
// If has a resource file, reload through the resource cache. Otherwise just recreate.
ResourceCache* cache = context_->resourceCache();
if (cache->Exists(GetName()))
dataLost_ = !cache->ReloadResource(this);
if (!object_)
{
Create();
dataLost_ = true;
}
}
dataPending_ = false;
}
void Sound::LoadParameters()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
if (!cache->Exists(xmlName))
return;
XMLFile* file = cache->GetResource<XMLFile>(xmlName);
if (!file)
return;
XMLElement rootElem = file->GetRoot();
XMLElement paramElem = rootElem.GetChild();
while (paramElem)
{
String name = paramElem.GetName();
if (name == "format" && !compressed_)
{
if (paramElem.HasAttribute("frequency"))
frequency_ = paramElem.GetInt("frequency");
if (paramElem.HasAttribute("sixteenbit"))
sixteenBit_ = paramElem.GetBool("sixteenbit");
if (paramElem.HasAttribute("16bit"))
sixteenBit_ = paramElem.GetBool("16bit");
if (paramElem.HasAttribute("stereo"))
stereo_ = paramElem.GetBool("stereo");
}
if (name == "loop")
{
if (paramElem.HasAttribute("enable"))
SetLooped(paramElem.GetBool("enable"));
if (paramElem.HasAttribute("start") && paramElem.HasAttribute("end"))
SetLoop(paramElem.GetInt("start"), paramElem.GetInt("end"));
}
paramElem = paramElem.GetNext();
}
}
void Cursor::DefineShape(CursorShape shape, Image* image, const IntRect& imageRect, const IntVector2& hotSpot)
{
if (shape < CS_NORMAL || shape >= CS_MAX_SHAPES)
{
LOGERROR("Shape index out of bounds, can not define cursor shape");
return;
}
if (!image)
return;
ResourceCache* cache = GetSubsystem<ResourceCache>();
CursorShapeInfo& info = shapeInfos_[shape];
// Prefer to get the texture with same name from cache to prevent creating several copies of the texture
if (cache->Exists(image->GetName()))
info.texture_ = cache->GetResource<Texture2D>(image->GetName());
else
{
Texture2D* texture = new Texture2D(context_);
texture->Load(SharedPtr<Image>(image));
info.texture_ = texture;
}
info.image_ = image;
info.imageRect_ = imageRect;
info.hotSpot_ = hotSpot;
// Remove existing SDL cursor
if (info.osCursor_)
{
SDL_FreeCursor(info.osCursor_);
info.osCursor_ = 0;
}
// Reset current shape if it was edited
if (shape == shape_)
ApplyShape();
}
bool ScriptFile::AddScriptSection(asIScriptEngine* engine, Deserializer& source)
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
unsigned dataSize = source.GetSize();
SharedArrayPtr<char> buffer(new char[dataSize]);
source.Read((void*)buffer.Get(), dataSize);
// Pre-parse for includes
// Adapted from Angelscript's scriptbuilder add-on
Vector<String> includeFiles;
unsigned pos = 0;
while(pos < dataSize)
{
int len;
asETokenClass t = engine->ParseToken(&buffer[pos], dataSize - pos, &len);
if (t == asTC_COMMENT || t == asTC_WHITESPACE)
{
pos += len;
continue;
}
// Is this a preprocessor directive?
if (buffer[pos] == '#')
{
int start = pos++;
asETokenClass t = engine->ParseToken(&buffer[pos], dataSize - pos, &len);
if (t == asTC_IDENTIFIER)
{
String token(&buffer[pos], len);
if (token == "include")
{
pos += len;
t = engine->ParseToken(&buffer[pos], dataSize - pos, &len);
if (t == asTC_WHITESPACE)
{
pos += len;
t = engine->ParseToken(&buffer[pos], dataSize - pos, &len);
}
if (t == asTC_VALUE && len > 2 && buffer[pos] == '"')
{
// Get the include file
String includeFile(&buffer[pos+1], len - 2);
pos += len;
// If the file is not found as it is, add the path of current file but only if it is found there
if (!cache->Exists(includeFile))
{
String prefixedIncludeFile = GetPath(GetName()) + includeFile;
if (cache->Exists(prefixedIncludeFile))
includeFile = prefixedIncludeFile;
}
String includeFileLower = includeFile.ToLower();
// If not included yet, store it for later processing
if (!includeFiles_.Contains(includeFileLower))
{
includeFiles_.Insert(includeFileLower);
includeFiles.Push(includeFile);
}
// Overwrite the include directive with space characters to avoid compiler error
memset(&buffer[start], ' ', pos - start);
}
}
}
}
// Don't search includes within statement blocks or between tokens in statements
else
{
int len;
// Skip until ; or { whichever comes first
while (pos < dataSize && buffer[pos] != ';' && buffer[pos] != '{')
{
engine->ParseToken(&buffer[pos], 0, &len);
pos += len;
}
// Skip entire statement block
if (pos < dataSize && buffer[pos] == '{')
{
++pos;
// Find the end of the statement block
int level = 1;
while (level > 0 && pos < dataSize)
{
asETokenClass t = engine->ParseToken(&buffer[pos], 0, &len);
if (t == asTC_KEYWORD)
{
if (buffer[pos] == '{')
++level;
else if(buffer[pos] == '}')
--level;
}
pos += len;
}
}
else
++pos;
}
}
// Process includes first
for (unsigned i = 0; i < includeFiles.Size(); ++i)
{
cache->StoreResourceDependency(this, includeFiles[i]);
SharedPtr<File> file = cache->GetFile(includeFiles[i]);
if (file)
{
if (!AddScriptSection(engine, *file))
return false;
}
else
{
LOGERROR("Could not process all the include directives in " + GetName() + ": missing " + includeFiles[i]);
return false;
}
}
// Then add this section
if (scriptModule_->AddScriptSection(source.GetName().CString(), (const char*)buffer.Get(), dataSize) < 0)
{
LOGERROR("Failed to add script section " + source.GetName());
return false;
}
SetMemoryUse(GetMemoryUse() + dataSize);
return true;
}
// see http://duktape.org/guide.html#modules
static int js_module_search(duk_context* ctx)
{
JSVM* vm = JSVM::GetJSVM(ctx);
FileSystem* fs = vm->GetSubsystem<FileSystem>();
ResourceCache* cache = vm->GetSubsystem<ResourceCache>();
int top = duk_get_top(ctx);
assert(top == 4);
String moduleID = duk_to_string(ctx, 0);
if (top > 1)
{
// require function
assert(duk_is_function(ctx, 1));
}
if (top > 2)
{
// exports
assert(duk_is_object(ctx, 2));
}
if (top > 3)
{
// module (module.id == a resolved absolute identifier for the module being loaded)
assert(duk_is_object(ctx, 3));
}
String pathName, fileName, extension;
SplitPath(moduleID, pathName, fileName, extension);
String path = moduleID;
// Do we really want this? It is nice to not have to specify the Atomic path
if (fileName.StartsWith("Atomic"))
{
path = "AtomicModules/" + path + ".js";
}
else
{
path += ".js";
if (!cache->Exists(path))
{
const Vector<String>& searchPaths = vm->GetModuleSearchPaths();
for (unsigned i = 0; i < searchPaths.Size(); i++)
{
String search = searchPaths[i] + path;
if (cache->Exists(search))
{
path = search;
break;
}
}
}
}
if (cache->Exists(path))
{
SharedPtr<File> jsfile(cache->GetFile(path, false));
vm->SetLastModuleSearchFile(jsfile->GetFullPath());
String source;
jsfile->ReadText(source);
source.Append('\n');
duk_push_string(ctx, source.CString());
return 1;
}
else
{
// we're not a JS file, so check if we're a native module
const Vector<String>& resourceDirs = cache->GetResourceDirs();
for (unsigned i = 0; i < resourceDirs.Size(); i++)
{
String pluginLibrary;
// TODO: proper platform folder detection
#ifdef ATOMIC_PLATFORM_WINDOWS
pluginLibrary = resourceDirs.At(i) + "Plugins/Windows/x64/" + moduleID + ".dll";
#elif ATOMIC_PLATFORM_OSX
pluginLibrary = resourceDirs.At(i) + "Plugins/Mac/x64/lib" + moduleID + ".dylib";
#endif
if (pluginLibrary.Length() && fs->FileExists(pluginLibrary))
{
// let duktape know we loaded a native module
if (jsplugin_load(vm, pluginLibrary))
{
duk_push_undefined(ctx);
return 1;
}
else
{
duk_push_sprintf(ctx, "Failed loading native plugins: %s", pluginLibrary.CString());
duk_throw(ctx);
}
}
}
}
duk_push_sprintf(ctx, "Failed loading module: %s", path.CString());
duk_throw(ctx);
}
bool Shader::ProcessSource(SharedArrayPtr<char>& dest, unsigned& length, const String& fileName)
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
if (!cache)
return false;
// Allow to define only a vertex shader or only a pixel shader
if (!cache->Exists(fileName))
return true;
cache->StoreResourceDependency(this, fileName);
Vector<String> glslCode;
// Load the shader source code
SharedPtr<File> glslFile = cache->GetFile(fileName);
if (!glslFile)
return false;
while (!glslFile->IsEof())
glslCode.Push(glslFile->ReadLine());
// Process the code for includes
for (unsigned i = 0; i < glslCode.Size(); ++i)
{
if (glslCode[i].StartsWith("#include"))
{
String includeFileName = GetPath(fileName) + glslCode[i].Substring(9).Replaced("\"", "").Trimmed();
SharedPtr<File> glslIncludeFile = cache->GetFile(includeFileName);
if (!glslIncludeFile)
return false;
// Remove the #include line, then include the code
glslCode.Erase(i);
unsigned pos = i;
while (!glslIncludeFile->IsEof())
{
glslCode.Insert(pos, glslIncludeFile->ReadLine());
++pos;
}
// Finally insert an empty line to mark the space between files
glslCode.Insert(pos, "");
}
}
// Copy the final code into one memory block
length = 0;
for (unsigned i = 0; i < glslCode.Size(); ++i)
length += glslCode[i].Length() + 1;
dest = new char[length];
char* destPtr = dest.Get();
for (unsigned i = 0; i < glslCode.Size(); ++i)
{
memcpy(destPtr, glslCode[i].CString(), glslCode[i].Length());
destPtr += glslCode[i].Length();
*destPtr++ = '\n';
}
return true;
}
bool ShaderVariation::LoadByteCode(const String& binaryShaderName)
{
ResourceCache* cache = owner_->GetSubsystem<ResourceCache>();
if (!cache->Exists(binaryShaderName))
return false;
FileSystem* fileSystem = owner_->GetSubsystem<FileSystem>();
unsigned sourceTimeStamp = owner_->GetTimeStamp();
// If source code is loaded from a package, its timestamp will be zero. Else check that binary is not older
// than source
if (sourceTimeStamp && fileSystem->GetLastModifiedTime(cache->GetResourceFileName(binaryShaderName)) < sourceTimeStamp)
return false;
SharedPtr<File> file = cache->GetFile(binaryShaderName);
if (!file || file->ReadFileID() != "USHD")
{
ATOMIC_LOGERROR(binaryShaderName + " is not a valid shader bytecode file");
return false;
}
/// \todo Check that shader type and model match
/*unsigned short shaderType = */file->ReadUShort();
/*unsigned short shaderModel = */file->ReadUShort();
unsigned numParameters = file->ReadUInt();
for (unsigned i = 0; i < numParameters; ++i)
{
String name = file->ReadString();
unsigned reg = file->ReadUByte();
unsigned regCount = file->ReadUByte();
ShaderParameter parameter;
parameter.type_ = type_;
parameter.name_ = name;
parameter.register_ = reg;
parameter.regCount_ = regCount;
parameters_[StringHash(name)] = parameter;
}
unsigned numTextureUnits = file->ReadUInt();
for (unsigned i = 0; i < numTextureUnits; ++i)
{
/*String unitName = */file->ReadString();
unsigned reg = file->ReadUByte();
if (reg < MAX_TEXTURE_UNITS)
useTextureUnit_[reg] = true;
}
unsigned byteCodeSize = file->ReadUInt();
if (byteCodeSize)
{
byteCode_.Resize(byteCodeSize);
file->Read(&byteCode_[0], byteCodeSize);
if (type_ == VS)
ATOMIC_LOGDEBUG("Loaded cached vertex shader " + GetFullName());
else
ATOMIC_LOGDEBUG("Loaded cached pixel shader " + GetFullName());
return true;
}
else
{
ATOMIC_LOGERROR(binaryShaderName + " has zero length bytecode");
return false;
}
}
bool Animation::Load(Deserializer& source)
{
PROFILE(LoadAnimation);
unsigned memoryUse = sizeof(Animation);
// Check ID
if (source.ReadFileID() != "UANI")
{
LOGERROR(source.GetName() + " is not a valid animation file");
return false;
}
// Read name and length
animationName_ = source.ReadString();
animationNameHash_ = animationName_;
length_ = source.ReadFloat();
tracks_.Clear();
unsigned tracks = source.ReadUInt();
tracks_.Resize(tracks);
memoryUse += tracks * sizeof(AnimationTrack);
// Read tracks
for (unsigned i = 0; i < tracks; ++i)
{
AnimationTrack& newTrack = tracks_[i];
newTrack.name_ = source.ReadString();
newTrack.nameHash_ = newTrack.name_;
newTrack.channelMask_ = source.ReadUByte();
unsigned keyFrames = source.ReadUInt();
newTrack.keyFrames_.Resize(keyFrames);
memoryUse += keyFrames * sizeof(AnimationKeyFrame);
// Read keyframes of the track
for (unsigned j = 0; j < keyFrames; ++j)
{
AnimationKeyFrame& newKeyFrame = newTrack.keyFrames_[j];
newKeyFrame.time_ = source.ReadFloat();
if (newTrack.channelMask_ & CHANNEL_POSITION)
newKeyFrame.position_ = source.ReadVector3();
if (newTrack.channelMask_ & CHANNEL_ROTATION)
newKeyFrame.rotation_ = source.ReadQuaternion();
if (newTrack.channelMask_ & CHANNEL_SCALE)
newKeyFrame.scale_ = source.ReadVector3();
}
}
// Optionally read triggers from an XML file
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
if (cache->Exists(xmlName))
{
XMLFile* file = cache->GetResource<XMLFile>(xmlName);
if (file)
{
XMLElement rootElem = file->GetRoot();
XMLElement triggerElem = rootElem.GetChild("trigger");
while (triggerElem)
{
if (triggerElem.HasAttribute("normalizedtime"))
AddTrigger(triggerElem.GetFloat("normalizedtime"), true, triggerElem.GetVariant());
else if (triggerElem.HasAttribute("time"))
AddTrigger(triggerElem.GetFloat("time"), false, triggerElem.GetVariant());
triggerElem = triggerElem.GetNext("trigger");
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
}
}
SetMemoryUse(memoryUse);
return true;
}
int JSVM::GetRealLineNumber(const String& fileName, const int lineNumber) {
int realLineNumber = lineNumber;
String mapPath = fileName;
if (!mapPath.EndsWith(".js.map"))
mapPath += ".js.map";
if (mapPath.EndsWith(".js")) {
return realLineNumber;
}
ResourceCache* cache = GetSubsystem<ResourceCache>();
String path;
const Vector<String>& searchPaths = GetModuleSearchPaths();
for (unsigned i = 0; i < searchPaths.Size(); i++)
{
String checkPath = searchPaths[i] + mapPath;
if (cache->Exists(checkPath))
{
path = checkPath;
break;
}
}
if (!path.Length())
return realLineNumber;
SharedPtr<File> mapFile(GetSubsystem<ResourceCache>()->GetFile(path));
//if there's no source map file, maybe you use a pure js, so give an error, or maybe forgot to generate source-maps :(
if (mapFile.Null())
{
return realLineNumber;
}
String map;
mapFile->ReadText(map);
int top = duk_get_top(ctx_);
duk_get_global_string(ctx_, "require");
duk_push_string(ctx_, "AtomicEditor/EditorScripts/Lib/jsutils");
if (duk_pcall(ctx_, 1))
{
printf("Error: %s\n", duk_safe_to_string(ctx_, -1));
duk_set_top(ctx_, top);
return false;
}
duk_get_prop_string(ctx_, -1, "getRealLineNumber");
duk_push_string(ctx_, map.CString());
duk_push_int(ctx_, lineNumber);
bool ok = true;
if (duk_pcall(ctx_, 2))
{
ok = false;
printf("Error: %s\n", duk_safe_to_string(ctx_, -1));
}
else
{
realLineNumber = duk_to_int(ctx_, -1);
}
duk_set_top(ctx_, top);
return realLineNumber;
}
bool AnimationSet2D::LoadFolders(const XMLElement& rootElem)
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
bool async = GetAsyncLoadState() == ASYNC_LOADING;
String parentPath = GetParentPath(GetName());
String spriteSheetFilePath = parentPath + GetFileName(GetName()) + ".xml";
SpriteSheet2D* spriteSheet = 0;
bool hasSpriteSheet = false;
// When async loading, request the sprite sheet for background loading but do not actually get it
if (!async)
spriteSheet = cache->GetResource<SpriteSheet2D>(spriteSheetFilePath, false);
else
{
hasSpriteSheet = cache->Exists(spriteSheetFilePath);
if (hasSpriteSheet)
cache->BackgroundLoadResource<SpriteSheet2D>(spriteSheetFilePath, false, this);
}
for (XMLElement folderElem = rootElem.GetChild("folder"); folderElem; folderElem = folderElem.GetNext("folder"))
{
unsigned folderId = folderElem.GetUInt("id");
for (XMLElement fileElem = folderElem.GetChild("file"); fileElem; fileElem = fileElem.GetNext("file"))
{
unsigned fileId = fileElem.GetUInt("id");
String fileName = fileElem.GetAttribute("name");
// When async loading, request the sprites for background loading but do not actually get them
if (!async)
{
SharedPtr<Sprite2D> sprite;
if (spriteSheet)
sprite = spriteSheet->GetSprite(GetFileName(fileName));
else
sprite = (cache->GetResource<Sprite2D>(parentPath + fileName));
if (!sprite)
{
LOGERROR("Could not load sprite " + fileName);
return false;
}
Vector2 hotSpot(0.0f, 1.0f);
if (fileElem.HasAttribute("pivot_x"))
hotSpot.x_ = fileElem.GetFloat("pivot_x");
if (fileElem.HasAttribute("pivot_y"))
hotSpot.y_ = fileElem.GetFloat("pivot_y");
// If sprite is trimmed, recalculate hot spot
const IntVector2& offset = sprite->GetOffset();
if (offset != IntVector2::ZERO)
{
int width = fileElem.GetInt("width");
int height = fileElem.GetInt("height");
float pivotX = width * hotSpot.x_;
float pivotY = height * (1.0f - hotSpot.y_);
const IntRect& rectangle = sprite->GetRectangle();
hotSpot.x_ = (offset.x_ + pivotX) / rectangle.Width();
hotSpot.y_ = 1.0f - (offset.y_ + pivotY) / rectangle.Height();
}
sprite->SetHotSpot(hotSpot);
sprites_[(folderId << 16) + fileId] = sprite;
}
else if (!hasSpriteSheet)
cache->BackgroundLoadResource<Sprite2D>(parentPath + fileName, true, this);
}
}
return true;
}