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 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]);
        }
    }
示例#4
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();
        }
    }
示例#5
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();
    }