Method CreateIdentifierFromURI

Libraries/ImageProcessingResolver/Resolver.cpp:326–390

}

std::string ImageProcessingResolverPlugin::CreateIdentifierFromURI(
    const std::string& assetPath, const ArResolvedPath& anchorAssetPath) const
{
    // Parse the asset path as a URI.
    UriUriA uri;
    const char* pErrStr;
    if (uriParseSingleUriA(&uri, assetPath.c_str(), &pErrStr) == URI_SUCCESS)
    {
        // If URI parsing succeeds get the URI scheme.
        std::string scheme(
            uri.scheme.first, (size_t)uri.scheme.afterLast - (size_t)uri.scheme.first);

        // If this is not an imageProcessing URI return empty string.
        if (scheme.compare("imageProcessing") != 0)
            return "";

        // Create an cache entry for this path.
        AssetCacheEntry cacheEntry = AssetCacheEntry();

        // Set the host which defines which processing function to run.
        cacheEntry.host = std::string(
            uri.hostText.first, (size_t)uri.hostText.afterLast - (size_t)uri.hostText.first);

        // Build a query dictionary which defines the function parameters.
        UriQueryListA* queryList;
        int itemCount;
        if (uriDissectQueryMallocA(&queryList, &itemCount, uri.query.first, uri.query.afterLast) ==
            URI_SUCCESS)
        {
            while (queryList)
            {
                cacheEntry.queries[queryList->key] = queryList->value;
                queryList                          = queryList->next;
            }

            // Set the source file name from the file query parameter (Which is
            // common to all functions)
            cacheEntry.sourceFilename = ArDefaultResolver::_CreateIdentifier(
                cacheEntry.queries["filename"], anchorAssetPath);
        }

        // Create a hash from original URI.
        std::size_t assetHash = std::hash<std::string> {}(assetPath.c_str());

        // All images are assigned .exr extension currently.
        string ext = ".exr";

        // Create generated asset path from hash.
        ArResolvedPath generatedAssetPath =
            ArResolvedPath(assetPathPrefix + Aurora::Foundation::sHash(assetHash) + ext);
        cacheEntry.assetPath = generatedAssetPath;

        // If there is no cacheEntry for this path, or the sourceFilename has changed
        // (due to anchor changing) then add to cache.
        auto& assetCache = const_cast<ImageProcessingResolverPlugin*>(this)->_assetCache;
        auto recordIter  = assetCache.find(generatedAssetPath);
        if (recordIter == assetCache.end() ||
            recordIter->second.sourceFilename.compare(cacheEntry.sourceFilename) != 0)