public FaceTransparencyDemo()
    {
        fileLocator   = new ContentFileLocator();
        objectLocator = new DsonObjectLocator(fileLocator);
        var contentPackConfs = ContentPackImportConfiguration.LoadAll(CommonPaths.ConfDir);

        pathManager = ImporterPathManager.Make(contentPackConfs);
        device      = new Device(DriverType.Hardware, DeviceCreationFlags.None, FeatureLevel.Level_11_1);
        shaderCache = new ShaderCache(device);
    }
Пример #2
0
    public ApplyHdMorphDemo()
    {
        var fileLocator      = new ContentFileLocator();
        var objectLocator    = new DsonObjectLocator(fileLocator);
        var contentPackConfs = ContentPackImportConfiguration.LoadAll(CommonPaths.ConfDir);
        var pathManager      = ImporterPathManager.Make(contentPackConfs);
        var loader           = new FigureRecipeLoader(fileLocator, objectLocator, pathManager);
        var figureRecipe     = loader.LoadFigureRecipe("genesis-3-female", null);
        var figure           = figureRecipe.Bake(fileLocator, null);
        var geometry         = figure.Geometry;

        controlTopology        = new QuadTopology(geometry.VertexCount, geometry.Faces);
        controlVertexPositions = geometry.VertexPositions;
    }
    public static void Import(ImporterPathManager pathManager, FileInfo outfitConfFile, DirectoryInfo contentDestDirectory)
    {
        string name = outfitConfFile.GetNameWithoutExtension();

        var outfitsDir      = contentDestDirectory.Subdirectory("outfits");
        var destinationFile = outfitsDir.File(name + ".dat");

        if (destinationFile.Exists)
        {
            return;
        }

        string json  = outfitConfFile.ReadAllText();
        var    proxy = JsonConvert.DeserializeObject <OutfitJsonProxy>(json);

        var items = proxy.items
                    .Select(itemProxy => {
            ImportProperties.Load(pathManager, 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 figureConfDir     = pathManager.GetConfDirForFigure(figureName);
                var materialSetsConfs = MaterialSetImportConfiguration.Load(figureConfDir);
                materialSetsConfs.Where(conf => conf.name == materialSetName).Single();
            }

            return(new Outfit.Fabric(label, materialSetsByFigureName));
        })
                                       .ToList();

        var outfit = new Outfit(proxy.label, items, fabrics);

        outfitsDir.CreateWithParents();
        Persistance.Save(destinationFile, outfit);
    }
Пример #4
0
    public static ImportProperties Load(ImporterPathManager pathManager, string figureName)
    {
        JsonSerializerSettings settings = new JsonSerializerSettings {
            MissingMemberHandling = MissingMemberHandling.Error
        };
        string        json      = pathManager.GetConfDirForFigure(figureName).File("import-properties.json").ReadAllText();
        JsonProxy     proxy     = JsonConvert.DeserializeObject <JsonProxy>(json, settings);
        UrisJsonProxy urisProxy = proxy.uris;

        var uris = new FigureUris(
            urisProxy.basePath,
            urisProxy.documentName,
            urisProxy.geometryId,
            urisProxy.rootNodeId,
            urisProxy.skinBindingId);

        return(new ImportProperties(uris, proxy.hdCorrectionInitialValue));
    }
    public void Run()
    {
        var fileLocator      = new ContentFileLocator();
        var objectLocator    = new DsonObjectLocator(fileLocator);
        var contentPackConfs = ContentPackImportConfiguration.LoadAll(CommonPaths.ConfDir);
        var pathManager      = ImporterPathManager.Make(contentPackConfs);
        var loader           = new FigureRecipeLoader(fileLocator, objectLocator, pathManager);
        var figureRecipe     = loader.LoadFigureRecipe("genesis-3-female", null);
        var figure           = figureRecipe.Bake(fileLocator, null);

        var calculator = new BoneAttributesCalculator(figure.ChannelSystem, figure.BoneSystem, figure.Geometry, figure.SkinBinding);

        BoneAttributes[] boneAttributes = calculator.CalculateBoneAttributes();

        for (int boneIdx = 0; boneIdx < figure.Bones.Count; ++boneIdx)
        {
            Console.WriteLine("{0}: {1}", figure.Bones[boneIdx].Name, boneAttributes[boneIdx]);
        }
    }
Пример #6
0
    public static void Import(ImporterPathManager pathManager, FileInfo characterConfFile, DirectoryInfo contentDestDirectory)
    {
        string name = characterConfFile.GetNameWithoutExtension();

        var charactersDir   = contentDestDirectory.Subdirectory("characters");
        var destinationFile = charactersDir.File(name + ".dat");

        if (destinationFile.Exists)
        {
            return;
        }

        string json      = characterConfFile.ReadAllText();
        var    proxy     = JsonConvert.DeserializeObject <CharacterJsonProxy>(json);
        var    character = new Character(proxy.label, proxy.shape, proxy.materialSet);

        charactersDir.CreateWithParents();
        Persistance.Save(destinationFile, character);
    }
Пример #7
0
    public static SurfaceProperties Load(ImporterPathManager pathManager, Figure figure)
    {
        JsonSerializerSettings settings = new JsonSerializerSettings {
            MissingMemberHandling = MissingMemberHandling.Error
        };
        string    json  = pathManager.GetConfDirForFigure(figure.Name).File("surface-properties.json").ReadAllText();
        JsonProxy proxy = JsonConvert.DeserializeObject <JsonProxy>(json, settings);

        int subdivisionLevel = proxy.subdivisionLevel;

        string[] surfaceNames = figure.Geometry.SurfaceNames;
        Dictionary <string, int> surfaceNameToIdx = Enumerable.Range(0, surfaceNames.Length)
                                                    .ToDictionary(idx => surfaceNames[idx], idx => idx);

        int[] renderOrder;
        if (proxy.renderOrder == null)
        {
            renderOrder = new int[] { };
        }
        else
        {
            renderOrder = proxy.renderOrder.Select(surfaceName => surfaceNameToIdx[surfaceName]).ToArray();
        }

        float[] opacities = surfaceNames.Select(name => proxy.defaultOpacity).ToArray();
        if (proxy.opacities != null)
        {
            foreach (var entry in proxy.opacities)
            {
                opacities[surfaceNameToIdx[entry.Key]] = entry.Value;
            }
        }

        bool precomputeScattering = proxy.precomputeScattering;

        string materialSetForOpacities = proxy.materialSetForOpacities;

        return(new SurfaceProperties(subdivisionLevel, renderOrder, opacities, precomputeScattering, materialSetForOpacities));
    }
Пример #8
0
    public FigureDumperLoader(ContentFileLocator fileLocator, DsonObjectLocator objectLocator, ImporterPathManager pathManager, Device device, ShaderCache shaderCache)
    {
        this.fileLocator   = fileLocator;
        this.objectLocator = objectLocator;
        this.pathManager   = pathManager;
        this.device        = device;
        this.shaderCache   = shaderCache;

        figureRecipeLoader = new FigureRecipeLoader(objectLocator, pathManager);

        FigureRecipe      genesis3FemaleRecipe = figureRecipeLoader.LoadFigureRecipe("genesis-3-female", null);
        FigureRecipe      genitaliaRecipe      = figureRecipeLoader.LoadFigureRecipe("genesis-3-female-genitalia", genesis3FemaleRecipe);
        FigureRecipe      genesis3FemaleWithGenitaliaRecipe = new FigureRecipeMerger(genesis3FemaleRecipe, genitaliaRecipe).Merge();
        Figure            genesis3FemaleWithGenitalia       = genesis3FemaleWithGenitaliaRecipe.Bake(null);
        SurfaceProperties genesis3FemaleSurfaceProperties   = SurfacePropertiesJson.Load(pathManager, genesis3FemaleWithGenitalia);

        float[] genesis3FemaleFaceTransparencies = FaceTransparencies.For(genesis3FemaleWithGenitalia, genesis3FemaleSurfaceProperties, null);

        parentFigureRecipe       = genesis3FemaleRecipe;
        parentFigure             = genesis3FemaleWithGenitalia;
        parentFaceTransparencies = genesis3FemaleFaceTransparencies;
    }
 public FigureRecipeLoader(ContentFileLocator fileLocator, DsonObjectLocator objectLocator, ImporterPathManager pathManager)
 {
     this.fileLocator   = fileLocator;
     this.objectLocator = objectLocator;
     this.pathManager   = pathManager;
 }
Пример #10
0
    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();
        }
    }
Пример #11
0
    public void Run()
    {
        LeakTracking.Setup();

        var device           = new Device(DriverType.Hardware, DeviceCreationFlags.Debug, FeatureLevel.Level_11_1);
        var shaderCache      = new ShaderCache(device);
        var fileLocator      = new ContentFileLocator();
        var objectLocator    = new DsonObjectLocator(fileLocator);
        var contentPackConfs = ContentPackImportConfiguration.LoadAll(CommonPaths.ConfDir);
        var pathManager      = ImporterPathManager.Make(contentPackConfs);
        var loader           = new FigureRecipeLoader(fileLocator, objectLocator, pathManager);
        var figureRecipe     = loader.LoadFigureRecipe("genesis-3-female", null);
        var figure           = figureRecipe.Bake(fileLocator, null);
        var geometry         = figure.Geometry;

        var ldChannelInputs = figure.ChannelSystem.MakeDefaultChannelInputs();

        figure.ChannelsByName["PBMNavel?value"].SetValue(ldChannelInputs, 1);
        figure.ChannelsByName["PBMNipples?value"].SetValue(ldChannelInputs, 1);
        figure.ChannelsByName["CTRLRune7?value"].SetValue(ldChannelInputs, 1);

        var hdChannelInputs = figure.ChannelSystem.MakeDefaultChannelInputs();

        figure.ChannelsByName["PBMNavel?value"].SetValue(hdChannelInputs, 1);
        figure.ChannelsByName["PBMNipples?value"].SetValue(hdChannelInputs, 1);
        figure.ChannelsByName["CTRLRune7?value"].SetValue(hdChannelInputs, 1);
        figure.ChannelsByName["CTRLRune7HD?value"].SetValue(hdChannelInputs, 1);

        var converter = new HdMorphToNormalMapConverter(device, shaderCache, figure);

        var mapRenderer = converter.MakeNormalMapRenderer(ldChannelInputs, hdChannelInputs, figure.UvSets["Rune 7"]);

        string character = "rune";

        var faceMap = mapRenderer.Render(new HashSet <int> {
            9, 13, 5, 6
        });

        faceMap.Save(CommonPaths.WorkDir.File(character + "-face.png"));
        faceMap.Dispose();

        var torsoMap = mapRenderer.Render(new HashSet <int> {
            12
        });

        torsoMap.Save(CommonPaths.WorkDir.File(character + "-torso.png"));
        torsoMap.Dispose();

        var legsMap = mapRenderer.Render(new HashSet <int> {
            11, 2
        });

        legsMap.Save(CommonPaths.WorkDir.File(character + "-legs.png"));
        legsMap.Dispose();

        var armsMap = mapRenderer.Render(new HashSet <int> {
            16, 1
        });

        armsMap.Save(CommonPaths.WorkDir.File(character + "-arms.png"));
        armsMap.Dispose();

        mapRenderer.Dispose();

        shaderCache.Dispose();
        device.Dispose();

        LeakTracking.Finish();
    }
Пример #12
0
 public FigureRecipeLoader(DsonObjectLocator objectLocator, ImporterPathManager pathManager)
 {
     this.objectLocator = objectLocator;
     this.pathManager   = pathManager;
 }