AssetLibraryPtr RayTracerApp2::createAssetLibrary() {
AssetLibraryPtr assetLibrary = std::make_unique<AssetLibrary>();
assetLibrary->addAsset("Vertex.glsl", std::make_unique<StaticBuffer>((void*)vertexshader_glsl_data, vertexshader_glsl_size));
assetLibrary->addAsset("Fragment.glsl", std::make_unique<StaticBuffer>((void*)fragmentshader_glsl_data, fragmentshader_glsl_size));
assetLibrary->addAsset("MultiHardwareTracer.cl", std::make_unique<StaticBuffer>((void*)multihardwaretracer_cl_data, multihardwaretracer_cl_size));
return assetLibrary;
}
void
MaterialParser::parse(const std::string& filename,
const std::string& resolvedFilename,
Options::Ptr options,
const std::vector<unsigned char>& data,
AssetLibraryPtr assetLibrary)
{
msgpack::object msgpackObject;
msgpack::zone mempool;
std::string folderpath = extractFolderPath(resolvedFilename);
std::string str = extractDependencies(assetLibrary, data, options, folderpath);
msgpack::type::tuple<std::vector<ComplexProperty>, std::vector<BasicProperty>> serializedMaterial;
msgpack::unpack(str.data(), str.size(), NULL, &mempool, &msgpackObject);
msgpackObject.convert(&serializedMaterial);
std::vector<ComplexProperty> complexProperties = serializedMaterial.a0;
std::vector<BasicProperty> basicProperties = serializedMaterial.a1;
MaterialPtr material = material::Material::create();
for (auto serializedComplexProperty : complexProperties)
deserializeComplexProperty(material, serializedComplexProperty);
for (auto serializedBasicProperty : basicProperties)
deserializeBasicProperty(material, serializedBasicProperty);
material = options->materialFunction()(material->arrayName(), material);
assetLibrary->material(filename, material);
_lastParsedAssetName = filename;
}
void
AbstractSerializerParser::deserializeAsset(SerializedAsset& asset,
AssetLibraryPtr assetLibrary,
std::shared_ptr<Options> options,
std::string& assetFilePath)
{
if (asset.get<0>() == serialize::AssetType::GEOMETRY_ASSET ||
asset.get<0>() == serialize::AssetType::TEXTURE_ASSET ||
asset.get<0>() == serialize::AssetType::MATERIAL_ASSET ||
asset.get<0>() == serialize::AssetType::TEXTURE_PACK_ASSET ||
asset.get<0>() == serialize::AssetType::EFFECT_ASSET
)
{
if (options->preventLoadingFunction()(asset.get<2>()))
return;
}
std::vector<unsigned char> data;
std::string assetCompletePath = assetFilePath + "/";
std::string resolvedPath = "";
unsigned short metaData = (asset.get<0>() & 0xFFFF0000) >> 16;
asset.get<0>() = asset.get<0>() & 0x000000FF;
// Is this an external asset?
if (asset.get<0>() < 10)
{
assetCompletePath += asset.get<2>();
resolvedPath = asset.get<2>();
}
data.assign(asset.get<2>().begin(), asset.get<2>().end());
if ((asset.get<0>() == serialize::AssetType::GEOMETRY_ASSET || asset.get<0>() == serialize::AssetType::EMBED_GEOMETRY_ASSET) &&
!_dependency->geometryReferenceExists(asset.get<1>())) // geometry
{
if (asset.get<0>() == serialize::AssetType::GEOMETRY_ASSET &&
!loadAssetData(assetCompletePath, options, data))
{
_error->execute(
shared_from_this(),
Error("MissingGeometryDependency", assetCompletePath)
);
return;
}
_geometryParser->_jobList.clear();
_geometryParser->dependency(_dependency);
if (asset.get<0>() == serialize::AssetType::EMBED_GEOMETRY_ASSET)
resolvedPath = "geometry_" + std::to_string(asset.get<1>());
_geometryParser->parse(resolvedPath, assetCompletePath, options, data, assetLibrary);
_dependency->registerReference(asset.get<1>(), assetLibrary->geometry(_geometryParser->_lastParsedAssetName));
_jobList.splice(_jobList.end(), _geometryParser->_jobList);
}
else if ((asset.get<0>() == serialize::AssetType::MATERIAL_ASSET || asset.get<0>() == serialize::AssetType::EMBED_MATERIAL_ASSET) &&
!_dependency->materialReferenceExists(asset.get<1>())) // material
{
if (asset.get<0>() == serialize::AssetType::MATERIAL_ASSET &&
!loadAssetData(assetCompletePath, options, data))
{
_error->execute(
shared_from_this(),
Error("MissingMaterialDependency", assetCompletePath)
);
return;
}
_materialParser->_jobList.clear();
_materialParser->dependency(_dependency);
if (asset.get<0>() == serialize::AssetType::EMBED_MATERIAL_ASSET)
resolvedPath = "material_" + std::to_string(asset.get<1>());
_materialParser->parse(resolvedPath, assetCompletePath, options, data, assetLibrary);
_dependency->registerReference(asset.get<1>(), assetLibrary->material(_materialParser->_lastParsedAssetName));
_jobList.splice(_jobList.end(), _materialParser->_jobList);
}
else if (asset.get<0>() == serialize::AssetType::EFFECT_ASSET)
{
const auto& effectFilename = asset.get<2>();
const auto effectCompleteFilename = "effect/" + effectFilename;
auto effect = assetLibrary->effect(effectFilename);
if (!effect)
{
auto effectLoader = Loader::create(options->clone());
effectLoader->options()->storeDataIfNotParsed(false);
auto errorSlot = effectLoader->error()->connect([](Loader::Ptr loaderThis, const Error& error)
{
LOG_ERROR(error.type() << ": " << error.what());
});
auto completeSlot = effectLoader->complete()->connect(
[&effect, &effectCompleteFilename, assetLibrary](Loader::Ptr loaderThis)
{
effect = assetLibrary->effect(effectCompleteFilename);
}
);
effectLoader
->queue(effectCompleteFilename)
->load();
}
if (effect)
_dependency->registerReference(asset.get<1>(), effect);
}
else if ((asset.get<0>() == serialize::AssetType::EMBED_TEXTURE_ASSET ||
asset.get<0>() == serialize::AssetType::TEXTURE_ASSET) &&
(!_dependency->textureReferenceExists(asset.get<1>()) || _dependency->getTextureReference(asset.get<1>()).texture == nullptr)) // texture
{
if (asset.get<0>() == serialize::AssetType::EMBED_TEXTURE_ASSET)
{
auto imageFormat = static_cast<serialize::ImageFormat>(metaData);
auto extension = serialize::extensionFromImageFormat(imageFormat);
resolvedPath = std::to_string(asset.get<1>()) + "." + extension;
assetCompletePath += resolvedPath;
}
else
{
if (!loadAssetData(assetCompletePath, options, data))
{
_error->execute(
shared_from_this(),
Error("MissingTextureDependency", assetCompletePath)
);
return;
}
}
auto extension = resolvedPath.substr(resolvedPath.find_last_of(".") + 1);
std::shared_ptr<file::AbstractParser> parser = assetLibrary->loader()->options()->getParser(extension);
static auto nameId = 0;
auto uniqueName = resolvedPath;
while (assetLibrary->texture(uniqueName) != nullptr)
uniqueName = "texture" + std::to_string(nameId++);
parser->parse(uniqueName, assetCompletePath, options, data, assetLibrary);
auto texture = assetLibrary->texture(uniqueName);
if (options->disposeTextureAfterLoading())
texture->disposeData();
_dependency->registerReference(asset.get<1>(), texture);
}
else if (asset.get<0>() == serialize::AssetType::EMBED_TEXTURE_PACK_ASSET &&
(!_dependency->textureReferenceExists(asset.get<1>()) ||
_dependency->getTextureReference(asset.get<1>()).texture == nullptr))
{
const auto textureName = "texture_" + std::to_string(asset.get<1>());
auto uniqueTextureName = textureName;
while(assetLibrary->texture(uniqueTextureName) != nullptr)
{
static auto textureId = 0;
uniqueTextureName = textureName + std::to_string(textureId++);
}
const auto hasTextureHeaderSize = (((metaData & 0xf000) >> 15) == 1 ? true : false);
auto textureHeaderSize = static_cast<unsigned int>(metaData & 0x0fff);
_textureParser->textureHeaderSize(textureHeaderSize);
_textureParser->dataEmbed(true);
_textureParser->parse(uniqueTextureName, assetCompletePath, options, data, assetLibrary);
auto texture = assetLibrary->texture(uniqueTextureName);
if (options->disposeTextureAfterLoading())
texture->disposeData();
_dependency->registerReference(asset.get<1>(), texture);
}
else if (asset.get<0>() == serialize::AssetType::TEXTURE_PACK_ASSET)
