public void Init()
{
// Create and mount database file system
var objDatabase = ObjectDatabase.CreateDefaultDatabase();
var databaseFileProvider = new DatabaseFileProvider(objDatabase);
AssetManager.GetFileProvider = () => databaseFileProvider;
shaderMixinParser = new ShaderMixinParser(AssetManager.FileProvider);
shaderMixinParser.SourceManager.LookupDirectoryList.Add("/shaders");
}
public void Init()
{
// Create and mount database file system
var objDatabase = new ObjectDatabase("/data/db", "index", "/local/db");
var databaseFileProvider = new DatabaseFileProvider(objDatabase);
AssetManager.GetFileProvider = () => databaseFileProvider;
sourceManager = new ShaderSourceManager();
sourceManager.LookupDirectoryList.Add(@"shaders");
shaderLoader = new ShaderLoader(sourceManager);
}
public void Init()
{
// Create and mount database file system
var objDatabase = ObjectDatabase.CreateDefaultDatabase();
var databaseFileProvider = new DatabaseFileProvider(objDatabase);
ContentManager.GetFileProvider = () => databaseFileProvider;
sourceManager = new ShaderSourceManager();
sourceManager.LookupDirectoryList.Add(@"shaders");
shaderLoader = new ShaderLoader(sourceManager);
}
/// <summary>
/// Initializes the asset database. Similar to <see cref="Game.InitializeAssetDatabase"/>, but accessible without using internals.
/// </summary>
private static void InitializeAssetDatabase()
{
// Create and mount database file system
var objDatabase = new ObjectDatabase("/data/db", "index", "/local/db");
// Only set a mount path if not mounted already
var mountPath = VirtualFileSystem.ResolveProviderUnsafe("/asset", true).Provider == null ? "/asset" : null;
var databaseFileProvider = new DatabaseFileProvider(objDatabase, mountPath);
AssetManager.GetFileProvider = () => databaseFileProvider;
}
public void Init()
{
// Create and mount database file system
var objDatabase = new ObjectDatabase("/data/db", "index", "/local/db");
var databaseFileProvider = new DatabaseFileProvider(objDatabase);
AssetManager.GetFileProvider = () => databaseFileProvider;
manager = new ShaderSourceManager();
manager.LookupDirectoryList.Add("shaders");
logger = new SiliconStudio.Shaders.Utility.LoggerResult();
loader = new ShaderLoader(manager);
}
public void Init()
{
// Create and mount database file system
var objDatabase = ObjectDatabase.CreateDefaultDatabase();
var databaseFileProvider = new DatabaseFileProvider(objDatabase);
ContentManager.GetFileProvider = () => databaseFileProvider;
manager = new ShaderSourceManager();
manager.LookupDirectoryList.Add("shaders");
logger = new SiliconStudio.Shaders.Utility.LoggerResult();
loader = new ShaderLoader(manager);
}
public void Init()
{
// Create and mount database file system
var objDatabase = ObjectDatabase.CreateDefaultDatabase();
var databaseFileProvider = new DatabaseFileProvider(objDatabase);
ContentManager.GetFileProvider = () => databaseFileProvider;
Compiler = new EffectCompiler();
Compiler.SourceDirectories.Add("shaders");
MixinParameters = new CompilerParameters();
MixinParameters.EffectParameters.Platform = GraphicsPlatform.Direct3D11;
MixinParameters.EffectParameters.Profile = GraphicsProfile.Level_11_0;
ResultLogger = new LoggerResult();
}
public void Init()
{
// Create and mount database file system
var objDatabase = new ObjectDatabase("/data/db", "index", "/local/db");
var databaseFileProvider = new DatabaseFileProvider(objDatabase);
AssetManager.GetFileProvider = () => databaseFileProvider;
Compiler = new EffectCompiler();
Compiler.SourceDirectories.Add("shaders");
MixinParameters = new ShaderMixinParameters();
MixinParameters.Add(CompilerParameters.GraphicsPlatformKey, GraphicsPlatform.Direct3D11);
MixinParameters.Add(CompilerParameters.GraphicsProfileKey, GraphicsProfile.Level_11_0);
ResultLogger = new LoggerResult();
}
public static void Main3()
{
// Create and mount database file system
var objDatabase = ObjectDatabase.CreateDefaultDatabase();
var assetIndexMap = AssetIndexMap.Load(VirtualFileSystem.ApplicationDatabaseIndexPath);
var databaseFileProvider = new DatabaseFileProvider(assetIndexMap, objDatabase);
ContentManager.GetFileProvider = () => databaseFileProvider;
compiler = new EffectCompiler();
compiler.SourceDirectories.Add("shaders");
var shaderMixinSource = new ShaderMixinSource();
shaderMixinSource.Mixins.Add(new ShaderClassSource("ShaderBase"));
shaderMixinSource.Mixins.Add(new ShaderClassSource("TransformationWVP"));
shaderMixinSource.Mixins.Add(new ShaderClassSource("ShadingBase"));
var shaderMixinSource2 = new ShaderMixinSource();
shaderMixinSource2.Mixins.Add(new ShaderClassSource("ShaderBase"));
shaderMixinSource2.Mixins.Add(new ShaderClassSource("TransformationWVP"));
shaderMixinSource2.Mixins.Add(new ShaderClassSource("ShadingBase"));
shaderMixinSource2.Mixins.Add(new ShaderClassSource("ShadingOverlay"));
var allThreads = new List<Thread>();
for (int i = 0; i < NumThreads; ++i)
{
CompilerThread compilerThread;
if (i % 2 == 0)
compilerThread = new CompilerThread(compiler, shaderMixinSource);
else
compilerThread = new CompilerThread(compiler, shaderMixinSource2);
allThreads.Add(new Thread(compilerThread.Compile));
}
foreach (var thread in allThreads)
{
thread.Start();
}
}
public void TestNoClean(out CompilerResults left, out CompilerResults right)
{
// Create and mount database file system
var objDatabase = ObjectDatabase.CreateDefaultDatabase();
using (var assetIndexMap = AssetIndexMap.Load(VirtualFileSystem.ApplicationDatabaseIndexPath))
{
var database = new DatabaseFileProvider(assetIndexMap, objDatabase);
AssetManager.GetFileProvider = () => database;
foreach (var shaderName in Directory.EnumerateFiles(@"..\..\sources\shaders", "*.pdxsl"))
CopyStream(database, shaderName);
foreach (var shaderName in Directory.EnumerateFiles(@"..\..\sources\engine\SiliconStudio.Paradox.Shaders.Tests\GameAssets\Compiler", "*.pdxsl"))
CopyStream(database, shaderName);
var compiler = new EffectCompiler();
compiler.SourceDirectories.Add("assets/shaders");
var compilerCache = new EffectCompilerCache(compiler);
var compilerParameters = new CompilerParameters {Platform = GraphicsPlatform.Direct3D11};
left = compilerCache.Compile(new ShaderMixinGeneratorSource("SimpleEffect"), compilerParameters);
right = compilerCache.Compile(new ShaderMixinGeneratorSource("SimpleEffect"), compilerParameters);
}
}
private void CopyStream(DatabaseFileProvider database, string fromFilePath)
{
var shaderFilename = string.Format("shaders/{0}", Path.GetFileName(fromFilePath));
using (var outStream = database.OpenStream(shaderFilename, VirtualFileMode.Create, VirtualFileAccess.Write, VirtualFileShare.Write))
{
using (var inStream = new FileStream(fromFilePath, FileMode.Open, FileAccess.Read))
{
inStream.CopyTo(outStream);
}
}
}
public static void Main5()
{
// Create and mount database file system
var objDatabase = new ObjectDatabase("/data/db");
var assetIndexMap = AssetIndexMap.Load();
var databaseFileProvider = new DatabaseFileProvider(assetIndexMap, objDatabase);
AssetManager.GetFileProvider = () => databaseFileProvider;
var test = new TestGenericClass();
test.Run();
}
public static void Main5()
{
// Create and mount database file system
var objDatabase = ObjectDatabase.CreateDefaultDatabase();
var assetIndexMap = ContentIndexMap.Load(VirtualFileSystem.ApplicationDatabaseIndexPath);
var databaseFileProvider = new DatabaseFileProvider(assetIndexMap, objDatabase);
ContentManager.GetFileProvider = () => databaseFileProvider;
var test = new TestGenericClass();
test.Run();
}
public void TestImportModelSimple()
{
var file = Path.Combine(Environment.CurrentDirectory, @"scenes\goblin.fbx");
// Create a project with an asset reference a raw file
var project = new Package { FullPath = Path.Combine(Environment.CurrentDirectory, "ModelAssets", "ModelAssets" + Package.PackageFileExtension) };
using (var session = new PackageSession(project))
{
var importSession = new AssetImportSession(session);
// ------------------------------------------------------------------
// Step 1: Add files to session
// ------------------------------------------------------------------
importSession.AddFile(file, project, UDirectory.Empty);
// ------------------------------------------------------------------
// Step 2: Stage assets
// ------------------------------------------------------------------
var stageResult = importSession.Stage();
Assert.IsTrue(stageResult);
Assert.AreEqual(0, project.Assets.Count);
// ------------------------------------------------------------------
// Step 3: Import asset directly
// ------------------------------------------------------------------
importSession.Import();
Assert.AreEqual(4, project.Assets.Count);
var assetItem = project.Assets.FirstOrDefault(item => item.Asset is EntityAsset);
Assert.NotNull(assetItem);
EntityAnalysis.UpdateEntityReferences(((EntityAsset)assetItem.Asset).Hierarchy);
var assetCollection = new AssetItemCollection();
// Remove directory from the location
assetCollection.Add(assetItem);
Console.WriteLine(assetCollection.ToText());
//session.Save();
// Create and mount database file system
var objDatabase = new ObjectDatabase("/data/db", "index", "/local/db");
var databaseFileProvider = new DatabaseFileProvider(objDatabase);
AssetManager.GetFileProvider = () => databaseFileProvider;
((EntityAsset)assetItem.Asset).Hierarchy.Entities[0].Components.RemoveWhere(x => x.Key != TransformComponent.Key);
//((EntityAsset)assetItem.Asset).Data.Entities[1].Components.RemoveWhere(x => x.Key != SiliconStudio.Paradox.Engine.TransformComponent.Key);
var assetManager = new AssetManager();
assetManager.Save("Entity1", ((EntityAsset)assetItem.Asset).Hierarchy);
assetManager = new AssetManager();
var entity = assetManager.Load<Entity>("Entity1");
var entity2 = entity.Clone();
var entityAsset = (EntityAsset)assetItem.Asset;
entityAsset.Hierarchy.Entities[0].Components.Add(TransformComponent.Key, new TransformComponent());
var entityAsset2 = (EntityAsset)AssetCloner.Clone(entityAsset);
entityAsset2.Hierarchy.Entities[0].Components.Get(TransformComponent.Key).Position = new Vector3(10.0f, 0.0f, 0.0f);
AssetMerge.Merge(entityAsset, entityAsset2, null, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
}
}
private EffectBytecode LoadEffectBytecode(DatabaseFileProvider database, ObjectId bytecodeId)
{
EffectBytecode bytecode = null;
if (!bytecodes.TryGetValue(bytecodeId, out bytecode))
{
if (!bytecodesByPassingStorage.Contains(bytecodeId) && database.ObjectDatabase.Exists(bytecodeId))
{
using (var stream = database.ObjectDatabase.OpenStream(bytecodeId))
{
bytecode = EffectBytecode.FromStream(stream);
}
}
if (bytecode != null)
{
bytecodes.Add(bytecodeId, bytecode);
}
}
// Always check that the bytecode is in sync with hash sources on all platforms
if (bytecode != null && IsBytecodeObsolete(bytecode))
{
bytecodes.Remove(bytecodeId);
bytecode = null;
}
return bytecode;
}
// TODO: Remove this once the thumbnail has been refactored to be done out of the preview game, if possible
public static void MountDatabase(DatabaseFileProvider databaseFileProvider)
{
MicroThreadLocalDatabaseFileProvider.Value = databaseFileProvider;
}
internal static void InitializeAssetDatabase()
{
using (Profiler.Begin(GameProfilingKeys.ObjectDatabaseInitialize))
{
// Create and mount database file system
var objDatabase = ObjectDatabase.CreateDefaultDatabase();
// Only set a mount path if not mounted already
var mountPath = VirtualFileSystem.ResolveProviderUnsafe("/asset", true).Provider == null ? "/asset" : null;
var databaseFileProvider = new DatabaseFileProvider(objDatabase, mountPath);
AssetManager.GetFileProvider = () => databaseFileProvider;
}
}
private EffectBytecodeCompilerResult CompileBytecode(ShaderMixinSource mixinTree, EffectCompilerParameters effectParameters, CompilerParameters compilerParameters, ObjectId mixinObjectId, DatabaseFileProvider database, string compiledUrl)
{
// Open the database for writing
var log = new LoggerResult();
// Note: this compiler is expected to not be async and directly write stuff in localLogger
var compiledShader = base.Compile(mixinTree, effectParameters, compilerParameters).WaitForResult();
compiledShader.CompilationLog.CopyTo(log);
// If there are any errors, return immediately
if (log.HasErrors)
{
lock (compilingShaders)
{
compilingShaders.Remove(mixinObjectId);
}
return new EffectBytecodeCompilerResult(null, log);
}
// Compute the bytecodeId
var newBytecodeId = compiledShader.Bytecode.ComputeId();
// Check if we really need to store the bytecode
lock (bytecodes)
{
// Using custom serialization to the database to store an object with a custom id
// TODO: Check if we really need to write the bytecode everytime even if id is not changed
var memoryStream = new MemoryStream();
compiledShader.Bytecode.WriteTo(memoryStream);
memoryStream.Position = 0;
database.ObjectDatabase.Write(memoryStream, newBytecodeId, true);
database.AssetIndexMap[compiledUrl] = newBytecodeId;
// Save bytecode Id to the database cache as well
memoryStream.SetLength(0);
memoryStream.Write((byte[])newBytecodeId, 0, ObjectId.HashSize);
memoryStream.Position = 0;
database.ObjectDatabase.Write(memoryStream, mixinObjectId, true);
if (!bytecodes.ContainsKey(newBytecodeId))
{
log.Verbose("New effect compiled #{0} [{1}] (db: {2})\r\n{3}", effectCompileCount, mixinObjectId, newBytecodeId, compilerParameters?.ToStringPermutationsDetailed());
Interlocked.Increment(ref effectCompileCount);
// Replace or add new bytecode
bytecodes[newBytecodeId] = compiledShader.Bytecode;
}
}
lock (compilingShaders)
{
compilingShaders.Remove(mixinObjectId);
}
return compiledShader;
}
private KeyValuePair<EffectBytecode, EffectBytecodeCacheLoadSource> LoadEffectBytecode(DatabaseFileProvider database, ObjectId bytecodeId)
{
KeyValuePair<EffectBytecode, EffectBytecodeCacheLoadSource> bytecodePair;
if (!bytecodes.TryGetValue(bytecodeId, out bytecodePair))
{
if (!bytecodesByPassingStorage.Contains(bytecodeId) && database.ObjectDatabase.Exists(bytecodeId))
{
using (var stream = database.ObjectDatabase.OpenStream(bytecodeId))
{
var bytecode = EffectBytecode.FromStream(stream);
// Try to read an integer that would specify what kind of cache it belongs to (if undefined because of old versions, mark it as dynamic cache)
var cacheSource = EffectBytecodeCacheLoadSource.DynamicCache;
if (stream.Position < stream.Length)
{
var binaryReader = new BinarySerializationReader(stream);
cacheSource = (EffectBytecodeCacheLoadSource)binaryReader.ReadInt32();
}
bytecodePair = new KeyValuePair<EffectBytecode, EffectBytecodeCacheLoadSource>(bytecode, cacheSource);
}
}
if (bytecodePair.Key != null)
{
bytecodes.Add(bytecodeId, bytecodePair);
}
}
// Always check that the bytecode is in sync with hash sources on all platforms
if (bytecodePair.Key != null && IsBytecodeObsolete(bytecodePair.Key))
{
bytecodes.Remove(bytecodeId);
bytecodePair = new KeyValuePair<EffectBytecode, EffectBytecodeCacheLoadSource>(null, EffectBytecodeCacheLoadSource.JustCompiled);
}
return bytecodePair;
}