public static void DumpAllForFigure(ImportSettings settings, Device device, ShaderCache shaderCache, ContentFileLocator fileLocator, DsonObjectLocator objectLocator, Figure figure, TextureProcessorSharer textureProcessorSharer)
{
MaterialSetImportConfiguration[] configurations = MaterialSetImportConfiguration.Load(figure.Name);
var baseConf = configurations.Single(conf => conf.name == "Base");
var surfaceProperties = SurfacePropertiesJson.Load(figure);
TextureProcessor sharedTextureProcessor = surfaceProperties.ShareTextures != null?
textureProcessorSharer.GetSharedProcessor(surfaceProperties.ShareTextures) : null;
foreach (var conf in configurations)
{
if (conf == baseConf)
{
continue;
}
if (!settings.ShouldImportMaterialSet(figure.Name, conf.name))
{
continue;
}
DumpMaterialSetAndScattering(settings, device, shaderCache, fileLocator, objectLocator, figure, baseConf, conf, sharedTextureProcessor);
}
}
public static void DumpMaterialSetAndScattering(ImportSettings settings, Device device, ShaderCache shaderCache, ContentFileLocator fileLocator, DsonObjectLocator objectLocator, Figure figure, SurfaceProperties surfaceProperties,
MaterialSetImportConfiguration baseConfiguration, TextureProcessor sharedTextureProcessor, DirectoryInfo figureDestDir, MaterialSetImportConfiguration configuration)
{
var materialSettings = DumpMaterialSet(settings, device, shaderCache, fileLocator, objectLocator, figure, surfaceProperties, baseConfiguration, figureDestDir, configuration, sharedTextureProcessor);
ScatteringDumper.Dump(figure, surfaceProperties, materialSettings.PerMaterialSettings, figureDestDir, configuration.name);
}
public static void DumpAllForFigure(ImportSettings settings, ContentFileLocator fileLocator, Device device, ShaderCache shaderCache, Figure parentFigure, Figure figure)
{
ShapeImportConfiguration[] configurations = ShapeImportConfiguration.Load(figure.Name);
var baseConf = configurations.SingleOrDefault(conf => conf.name == "Base");
ShapeDumper dumper = new ShapeDumper(fileLocator, device, shaderCache, parentFigure, figure, baseConf);
foreach (var conf in configurations)
{
if (!settings.ShouldImportShape(figure.Name, conf.name))
{
continue;
}
dumper.Dump(conf);
}
dumper.DumpUnmorphed();
MaterialSetImportConfiguration[] materialSetImportConfigurations = MaterialSetImportConfiguration.Load(figure.Name);
foreach (var materialSetConf in materialSetImportConfigurations)
{
if (!settings.ShouldImportMaterialSet(figure.Name, materialSetConf.name))
{
continue;
}
if (!materialSetConf.useCustomOcclusion)
{
continue;
}
dumper.DumpOcclusionForMaterialSet(materialSetConf.name);
}
}
public FigureDumper(ContentFileLocator fileLocator, DsonObjectLocator objectLocator, Device device, ShaderCache shaderCache, Figure parentFigure, Figure figure, SurfaceProperties surfaceProperties, MaterialSetImportConfiguration baseMaterialSetImportConfiguration, ShapeImportConfiguration baseShapeImportConfiguration, ShapeDumper shapeDumper)
{
this.device = device;
this.shaderCache = shaderCache;
this.fileLocator = fileLocator;
this.objectLocator = objectLocator;
this.parentFigure = parentFigure;
this.figure = figure;
this.surfaceProperties = surfaceProperties;
this.baseMaterialSetImportConfiguration = baseMaterialSetImportConfiguration;
this.baseShapeImportConfiguration = baseShapeImportConfiguration;
this.shapeDumper = shapeDumper;
}
public FigureDumper LoadDumper(string figureName)
{
var figure = figureName == parentFigure.Name ?
parentFigure :
figureRecipeLoader.LoadFigureRecipe(figureName, parentFigureRecipe).Bake(parentFigure);
var figureConfDir = pathManager.GetConfDirForFigure(figure.Name);
MaterialSetImportConfiguration baseMaterialSetConfiguration = MaterialSetImportConfiguration.Load(figureConfDir).Single(conf => conf.name == "Base");
ShapeImportConfiguration baseShapeImportConfiguration = ShapeImportConfiguration.Load(figureConfDir).SingleOrDefault(conf => conf.name == "Base");
SurfaceProperties surfaceProperties = SurfacePropertiesJson.Load(pathManager, figure);
ShapeDumper shapeDumper = new ShapeDumper(fileLocator, device, shaderCache, parentFigure, parentFaceTransparencies, figure, surfaceProperties, baseShapeImportConfiguration);
return(new FigureDumper(fileLocator, objectLocator, device, shaderCache, parentFigure, figure, surfaceProperties, baseMaterialSetConfiguration, baseShapeImportConfiguration, shapeDumper));
}
public static void ImportAll()
{
var outfitsDir = CommonPaths.WorkDir.Subdirectory("outfits");
outfitsDir.CreateWithParents();
foreach (var outfitFile in CommonPaths.OutfitsDir.GetFiles())
{
string name = outfitFile.GetNameWithoutExtension();
var destinationFile = outfitsDir.File(name + ".dat");
if (destinationFile.Exists)
{
continue;
}
string json = outfitFile.ReadAllText();
var proxy = JsonConvert.DeserializeObject <OutfitJsonProxy>(json);
var items = proxy.items
.Select(itemProxy => {
ImportProperties.Load(itemProxy.figure); //verify that that a figure with this name exists
return(new Outfit.Item(itemProxy.figure, itemProxy.label, itemProxy.isInitiallyVisible));
})
.ToList();
List <Outfit.Fabric> fabrics = proxy.fabrics?.Select(entry => {
var label = entry.Key;
var materialSetsByFigureName = entry.Value;
//verify that the material set for each figure exists
foreach (var entry2 in materialSetsByFigureName)
{
var figureName = entry2.Key;
var materialSetName = entry2.Value;
var materialSetsConfs = MaterialSetImportConfiguration.Load(figureName);
materialSetsConfs.Where(conf => conf.name == materialSetName).Single();
}
return(new Outfit.Fabric(label, materialSetsByFigureName));
})
.ToList();
var outfit = new Outfit(proxy.label, items, fabrics);
Persistance.Save(destinationFile, outfit);
}
}
private static MultiMaterialSettings DumpMaterialSet(ImportSettings settings, Device device, ShaderCache shaderCache, ContentFileLocator fileLocator, DsonObjectLocator objectLocator, Figure figure, SurfaceProperties surfaceProperties, MaterialSetImportConfiguration baseConfiguration, DirectoryInfo figureDestDir, MaterialSetImportConfiguration configuration, TextureProcessor textureProcessor)
{
DirectoryInfo materialsSetsDirectory = figureDestDir.Subdirectory("material-sets");
DirectoryInfo materialSetDirectory = materialsSetsDirectory.Subdirectory(configuration.name);
FileInfo materialSettingsFileInfo = materialSetDirectory.File("material-settings.dat");
FileInfo faceTransparenciesFileInfo = materialSetDirectory.File("face-transparencies.array");
if (materialSettingsFileInfo.Exists && faceTransparenciesFileInfo.Exists)
{
return(Persistance.Load <MultiMaterialSettings>(UnpackedArchiveFile.Make(materialSettingsFileInfo)));
}
var aggregator = new DsonMaterialAggregator(fileLocator, objectLocator);
IEnumerable <string> dufPaths = Enumerable.Concat(baseConfiguration.materialsDufPaths, configuration.materialsDufPaths);
foreach (string path in dufPaths)
{
DsonTypes.DsonDocument doc = objectLocator.LocateRoot(path);
aggregator.IncludeDuf(doc.Root);
}
var faceTransparencyProcessor = new FaceTransparencyProcessor(device, shaderCache, figure, surfaceProperties);
IMaterialImporter materialImporter;
if (figure.Name.EndsWith("-hair"))
{
materialImporter = new HairMaterialImporter(figure, textureProcessor, faceTransparencyProcessor);
}
else
{
materialImporter = new UberMaterialImporter(figure, textureProcessor, faceTransparencyProcessor);
}
string[] surfaceNames = figure.Geometry.SurfaceNames;
Dictionary <string, int> surfaceNameToIdx = Enumerable.Range(0, surfaceNames.Length)
.ToDictionary(idx => surfaceNames[idx], idx => idx);
var perMaterialSettings = Enumerable.Range(0, figure.Geometry.SurfaceCount)
.Select(surfaceIdx => {
string surfaceName = figure.Geometry.SurfaceNames[surfaceIdx];
var bag = aggregator.GetBag(surfaceName);
var materialSettings = materialImporter.Import(surfaceIdx, bag);
return(materialSettings);
})
.ToArray();
var variantCategories = configuration.variantCategories
.Select(variantCategoryConf => {
int[] surfaceIdxs = variantCategoryConf.surfaces
.Select(surfaceName => surfaceNameToIdx[surfaceName])
.ToArray();
var variants = variantCategoryConf.variants
.Select(variantConf => {
var variantAggregator = aggregator.Branch();
foreach (string path in variantConf.materialsDufPaths)
{
DsonTypes.DsonDocument doc = objectLocator.LocateRoot(path);
variantAggregator.IncludeDuf(doc.Root);
}
var settingsBySurface = variantCategoryConf.surfaces
.Select(surfaceName => {
int surfaceIdx = surfaceNameToIdx[surfaceName];
var bag = variantAggregator.GetBag(surfaceName);
var materialSettings = materialImporter.Import(surfaceIdx, bag);
return(materialSettings);
})
.ToArray();
return(new MultiMaterialSettings.Variant(variantConf.name, settingsBySurface));
})
.ToArray();
return(new MultiMaterialSettings.VariantCategory(variantCategoryConf.name, surfaceIdxs, variants));
})
.ToArray();
var multiMaterialSettings = new MultiMaterialSettings(perMaterialSettings, variantCategories);
materialSetDirectory.CreateWithParents();
textureProcessor.RegisterAction(() => {
Persistance.Save(materialSettingsFileInfo, multiMaterialSettings);
});
var faceTranparencies = faceTransparencyProcessor.FaceTransparencies;
faceTransparenciesFileInfo.WriteArray(faceTranparencies);
faceTransparencyProcessor.Dispose();
return(multiMaterialSettings);
}
public void DumpMaterialSet(ImportSettings importSettings, TextureProcessor textureProcessor, DirectoryInfo figureDestDir, MaterialSetImportConfiguration conf)
{
MaterialSetDumper.DumpMaterialSetAndScattering(importSettings, device, shaderCache, fileLocator, objectLocator, figure, surfaceProperties, baseMaterialSetImportConfiguration, textureProcessor, figureDestDir, conf);
if (conf.useCustomOcclusion)
{
shapeDumper.DumpOcclusionForMaterialSet(figureDestDir, conf.name);
}
}
private void Run(string[] args)
{
ImportSettings settings;
if (args.Length > 0 && args[0] == "release")
{
settings = ImportSettings.MakeReleaseSettings();
}
else
{
settings = ImportSettings.MakeFromViewerInitialSettings();
}
var contentDestDir = CommonPaths.WorkDir.Subdirectory("content");
var contentPackConfs = ContentPackImportConfiguration.LoadAll(CommonPaths.ConfDir);
var pathManager = ImporterPathManager.Make(contentPackConfs);
var figureDumperLoader = new FigureDumperLoader(fileLocator, objectLocator, pathManager, device, shaderCache);
foreach (var contentPackConf in contentPackConfs)
{
var destDir = contentDestDir.Subdirectory(contentPackConf.Name);
if (contentPackConf.IsCore)
{
new UiImporter(destDir).Run();
new EnvironmentCubeGenerator().Run(settings, destDir);
}
var texturesDir = destDir.Subdirectory("textures").Subdirectory(contentPackConf.Name);
var textureProcessor = new TextureProcessor(device, shaderCache, texturesDir, contentPackConf.Name, settings.CompressTextures);
bool shouldImportAnything = false;
foreach (var figureConf in contentPackConf.Figures)
{
string figureName = figureConf.Name;
if (!settings.FiguresToImport.Contains(figureName))
{
continue;
}
var figureDumper = figureDumperLoader.LoadDumper(figureName);
MaterialSetImportConfiguration[] materialSetConfigurations = MaterialSetImportConfiguration.Load(figureConf.Directory);
ShapeImportConfiguration[] shapeImportConfigurations = ShapeImportConfiguration.Load(figureConf.Directory);
var figureDestDir = destDir.Subdirectory("figures").Subdirectory(figureName);
if (figureConf.IsPrimary)
{
shouldImportAnything = true;
figureDumper.DumpFigure(shapeImportConfigurations, figureDestDir);
}
foreach (var materialSetConf in materialSetConfigurations)
{
if (!settings.ShouldImportMaterialSet(figureConf.Name, materialSetConf.name))
{
continue;
}
shouldImportAnything = true;
figureDumper.DumpMaterialSet(settings, textureProcessor, figureDestDir, materialSetConf);
}
if (figureConf.IsPrimary)
{
shouldImportAnything = true;
figureDumper.DumpBaseShape(figureDestDir);
}
foreach (var shapeConf in shapeImportConfigurations)
{
if (!settings.ShouldImportShape(figureConf.Name, shapeConf.name))
{
continue;
}
shouldImportAnything = true;
figureDumper.DumpShape(textureProcessor, figureDestDir, shapeConf);
}
}
if (shouldImportAnything)
{
foreach (var characterConf in contentPackConf.Characters)
{
CharacterImporter.Import(pathManager, characterConf.File, destDir);
}
foreach (var outfitConf in contentPackConf.Outfits)
{
OutfitImporter.Import(pathManager, outfitConf.File, destDir);
}
}
textureProcessor.ImportAll();
}
}
private static MultiMaterialSettings DumpMaterialSet(ImportSettings settings, Device device, ShaderCache shaderCache, ContentFileLocator fileLocator, DsonObjectLocator objectLocator, Figure figure, MaterialSetImportConfiguration baseConfiguration, MaterialSetImportConfiguration configuration, TextureProcessor sharedTextureProcessor)
{
DirectoryInfo figuresDirectory = CommonPaths.WorkDir.Subdirectory("figures");
DirectoryInfo figureDirectory = figuresDirectory.Subdirectory(figure.Name);
DirectoryInfo materialsSetsDirectory = figureDirectory.Subdirectory("material-sets");
DirectoryInfo materialSetDirectory = materialsSetsDirectory.Subdirectory(configuration.name);
FileInfo materialSettingsFileInfo = materialSetDirectory.File("material-settings.dat");
FileInfo faceTransparenciesFileInfo = materialSetDirectory.File("face-transparencies.array");
if (materialSettingsFileInfo.Exists && faceTransparenciesFileInfo.Exists)
{
return(Persistance.Load <MultiMaterialSettings>(UnpackedArchiveFile.Make(materialSettingsFileInfo)));
}
var aggregator = new DsonMaterialAggregator(fileLocator, objectLocator);
IEnumerable <string> dufPaths = Enumerable.Concat(baseConfiguration.materialsDufPaths, configuration.materialsDufPaths);
foreach (string path in dufPaths)
{
DsonTypes.DsonDocument doc = objectLocator.LocateRoot(path);
aggregator.IncludeDuf(doc.Root);
}
TextureProcessor localTextureProcessor;
if (sharedTextureProcessor == null)
{
localTextureProcessor = new TextureProcessor(device, shaderCache, materialSetDirectory, settings.CompressTextures);
}
else
{
localTextureProcessor = null;
}
var textureProcessor = sharedTextureProcessor ?? localTextureProcessor;
var faceTransparencyProcessor = new FaceTransparencyProcessor(device, shaderCache, figure);
IMaterialImporter materialImporter;
if (figure.Name.EndsWith("-hair"))
{
materialImporter = new HairMaterialImporter(figure, textureProcessor, faceTransparencyProcessor);
}
else
{
materialImporter = new UberMaterialImporter(figure, textureProcessor, faceTransparencyProcessor);
}
var perMaterialSettings = Enumerable.Range(0, figure.Geometry.SurfaceCount)
.Select(surfaceIdx => {
string surfaceName = figure.Geometry.SurfaceNames[surfaceIdx];
var bag = aggregator.GetBag(surfaceName);
var materialSettings = materialImporter.Import(surfaceIdx, bag);
return(materialSettings);
})
.ToArray();
var multiMaterialSettings = new MultiMaterialSettings(perMaterialSettings);
materialSetDirectory.CreateWithParents();
textureProcessor.RegisterAction(() => {
Persistance.Save(materialSettingsFileInfo, multiMaterialSettings);
});
localTextureProcessor?.ImportAll();
var faceTranparencies = faceTransparencyProcessor.FaceTransparencies;
faceTransparenciesFileInfo.WriteArray(faceTranparencies);
faceTransparencyProcessor.Dispose();
return(multiMaterialSettings);
}
