internal Blob(ObjectDatabase objectDatabase, ObjectId objectId, NativeStream stream)
: this(objectDatabase, objectId)
{
this.size = (int)stream.Length;
this.content = Marshal.AllocHGlobal(this.size);
stream.Read(this.content, this.size);
}
internal Blob(ObjectDatabase objectDatabase, ObjectId objectId, IntPtr content, int size)
: this(objectDatabase, objectId)
{
this.size = size;
this.content = Marshal.AllocHGlobal(size);
Utilities.CopyMemory(this.content, content, size);
}
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;
shaderMixinParser = new ShaderMixinParser(AssetManager.FileProvider);
shaderMixinParser.SourceManager.LookupDirectoryList.Add("/shaders");
}
/// <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 = 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 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);
}
}
public void TestNoClean(out CompilerResults left, out CompilerResults right)
{
// Create and mount database file system
var objDatabase = new ObjectDatabase("/data/db", "index", "/local/db");
using (var assetIndexMap = AssetIndexMap.Load())
{
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);
}
}
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 DatabaseFileProvider(IContentIndexMap contentIndexMap, ObjectDatabase objectDatabase, string mountPoint = null) : base(mountPoint)
{
this.contentIndexMap = contentIndexMap;
this.objectDatabase = objectDatabase;
}
public TemporaryObjectDatabase()
{
VirtualFileSystem.MountFileSystem("/storage_test", temporaryDirectory.DirectoryPath);
ObjectDatabase = new ObjectDatabase("/storage_test");
}
protected Blob(ObjectDatabase objectDatabase, ObjectId objectId)
{
this.objectDatabase = objectDatabase;
this.objectId = objectId;
}
/// <summary>
/// Runs this instance.
/// </summary>
public BuildResultCode Run(Mode mode, bool writeIndexFile = true, bool enableMonitor = true)
{
// When we setup the database ourself we have to take responsibility to close it after
var shouldCloseDatabase = IndexFileCommand.ObjectDatabase == null;
SetupBuildPath(buildPath, indexName);
PreRun();
runMode = mode;
if (IsRunning)
throw new InvalidOperationException("An instance of this Builder is already running.");
// reset build cache from previous build run
var parameters = new BuildParameterCollection();
cancellationTokenSource = new CancellationTokenSource();
Cancelled = false;
IsRunning = true;
DisableCompressionIds.Clear();
// Reseting result map
var inputHashes = FileVersionTracker.GetDefault();
{
var builderContext = new BuilderContext(buildPath, buildProfile, inputHashes, parameters, MaxParallelProcesses, SlaveBuilderPath);
resultMap = IndexFileCommand.ObjectDatabase;
scheduler = new Scheduler();
if (enableMonitor)
{
threadMonitors.Add(new BuildThreadMonitor(scheduler, BuilderId));
foreach (var monitorPipeName in MonitorPipeNames)
threadMonitors.Add(new BuildThreadMonitor(scheduler, BuilderId, monitorPipeName));
foreach (var threadMonitor in threadMonitors)
threadMonitor.Start();
}
// Schedule the build
ScheduleBuildStep(builderContext, null, Root, InitialVariables);
// Create threads
var threads = Enumerable.Range(0, ThreadCount).Select(x => new Thread(SafeAction.Wrap(RunUntilEnd)) { IsBackground = true }).ToArray();
// Start threads
int threadId = 0;
foreach (var thread in threads)
{
thread.Name = (BuilderName ?? "Builder") + " worker thread " + (++threadId);
thread.Start();
}
// Wait for all threads to finish
foreach (var thread in threads)
{
thread.Join();
}
foreach (var threadMonitor in threadMonitors)
threadMonitor.Finish();
foreach (var threadMonitor in threadMonitors)
threadMonitor.Join();
}
threadMonitors.Clear();
BuildResultCode result;
if (runMode == Mode.Build)
{
if (cancellationTokenSource.IsCancellationRequested)
{
Logger.Error("Build cancelled.");
result = BuildResultCode.Cancelled;
}
else if (stepCounter.Get(ResultStatus.Failed) > 0 || stepCounter.Get(ResultStatus.NotTriggeredPrerequisiteFailed) > 0)
{
Logger.Error("Build finished in {0} steps. Command results: {1} succeeded, {2} up-to-date, {3} failed, {4} not triggered due to previous failure.",
stepCounter.Total, stepCounter.Get(ResultStatus.Successful), stepCounter.Get(ResultStatus.NotTriggeredWasSuccessful),
stepCounter.Get(ResultStatus.Failed), stepCounter.Get(ResultStatus.NotTriggeredPrerequisiteFailed));
Logger.Error("Build failed.");
result = BuildResultCode.BuildError;
}
else
{
Logger.Info("Build finished in {0} steps. Command results: {1} succeeded, {2} up-to-date, {3} failed, {4} not triggered due to previous failure.",
stepCounter.Total, stepCounter.Get(ResultStatus.Successful), stepCounter.Get(ResultStatus.NotTriggeredWasSuccessful),
stepCounter.Get(ResultStatus.Failed), stepCounter.Get(ResultStatus.NotTriggeredPrerequisiteFailed));
Logger.Info("Build is successful.");
result = BuildResultCode.Successful;
}
}
else
{
string modeName;
switch (runMode)
{
case Mode.Clean:
modeName = "Clean";
break;
case Mode.CleanAndDelete:
modeName = "Clean-and-delete";
break;
default:
throw new InvalidOperationException("Builder executed in unknown mode.");
}
if (cancellationTokenSource.IsCancellationRequested)
{
Logger.Error(modeName + " has been cancelled.");
result = BuildResultCode.Cancelled;
}
else if (stepCounter.Get(ResultStatus.Failed) > 0 || stepCounter.Get(ResultStatus.NotTriggeredPrerequisiteFailed) > 0)
{
Logger.Error(modeName + " has failed.");
result = BuildResultCode.BuildError;
}
else
{
Logger.Error(modeName + " has been successfully completed.");
result = BuildResultCode.Successful;
}
}
scheduler = null;
resultMap = null;
IsRunning = false;
if (shouldCloseDatabase && IndexFileCommand.ObjectDatabase != null)
{
IndexFileCommand.ObjectDatabase.Dispose();
IndexFileCommand.ObjectDatabase = null;
}
return result;
}
public DatabaseFileProvider(IAssetIndexMap assetIndexMap, ObjectDatabase objectDatabase, string mountPoint = null) : base(mountPoint)
{
this.assetIndexMap = assetIndexMap;
this.objectDatabase = objectDatabase;
}
public static void OpenObjectDatabase(string buildPath, string indexName)
{
// Mount build path
((FileSystemProvider)VirtualFileSystem.ApplicationData).ChangeBasePath(buildPath);
if (ObjectDatabase == null)
{
// Note: this has to be done after VFS.ChangeBasePath
ObjectDatabase = new ObjectDatabase(VirtualFileSystem.ApplicationDatabasePath, indexName, null, false);
}
}
protected Blob(ObjectDatabase objectDatabase, ObjectId objectId)
{
this.objectDatabase = objectDatabase;
this.objectId = objectId;
}
public TemporaryObjectDatabase()
{
VirtualFileSystem.MountFileSystem("/storage_test", temporaryDirectory.DirectoryPath);
ObjectDatabase = new ObjectDatabase("/storage_test", VirtualFileSystem.ApplicationDatabaseIndexName);
}
public DatabaseFileProvider(ObjectDatabase objectDatabase, string mountPoint = null) : this(objectDatabase.ContentIndexMap, objectDatabase, mountPoint)
{
}
