MeltyPlayer / MeltyTool / 21805539193

  public IReadOnlyTreeFile MainFile => this.LvlFile;

  public required IReadOnlyTreeFile LvlFile { get; init; }

  public required IReadOnlyTreeDirectory RootDirectory { get; init; }

  public IScene Import(LvlSceneFileBundle sceneFileBundle) {

    var lvlFile = sceneFileBundle.LvlFile;

    var lvl = lvlFile.ReadNewFromText<Lvl>();

    var files = sceneFileBundle.LvlFile.AsFileSet();

    var finScene = new SceneImpl {

        FileBundle = sceneFileBundle,

        Files = files

    };

    var finArea = finScene.AddArea();

    if (lvl.HasRoomModel) {

      var modelFile = lvlFile.AssertGetParent()

                             .AssertGetExistingFile("model.omd");

      files.Add(modelFile);

      var finModel

          = new OmdModelImporter().Import(new OmdModelFileBundle {

              OmdFile = modelFile

          });

      finArea.AddRootNode().AddSceneModel(finModel);

    }

    var textureDirectory

        = sceneFileBundle.RootDirectory.AssertGetExistingSubdir("Textures");

    var lazyImageMap = new LazyDictionary<string?, IImage?>(

        imageName => imageName != null &&

                     textureDirectory.TryToGetExistingFile(

                         $"{imageName}.png",

                         out var textureFile)

            ? FinImage.FromFile(textureFile)

            : null);

    if (lvl.FloorBlocks.Count > 0) {

      foreach (var floorBlockParams in lvl.FloorBlocks) {

        var (start, end, textureName, type, flags) = floorBlockParams;

        var (floorBlockModel, floorBlockRootBone)

            = D3dModelImporter.CreateModel();

        var floorBlockSkin = floorBlockModel.Skin;

        var floorBlockMesh = floorBlockSkin.AddMesh();

        var shouldRepeat = !flags.CheckFlag(FloorBlockFlags.NO_REPEAT);

        var floorBlockMaterialManager = floorBlockModel.MaterialManager;

        IMaterial? floorBlockMaterial = null;

        if (flags.CheckFlag(FloorBlockFlags.INVISIBLE)) {

          floorBlockMaterial = floorBlockMaterialManager.AddHiddenMaterial();

        } else {

          var image = lazyImageMap[textureName];

          if (image != null) {

            (floorBlockMaterial, var floorBlockTexture)

                = floorBlockMaterialManager.AddSimpleTextureMaterialFromImage(

                    image,

                    textureName);

            if (shouldRepeat) {

              floorBlockTexture.WrapModeU = WrapMode.REPEAT;

              floorBlockTexture.WrapModeV = WrapMode.REPEAT;

            }

          }

        }

        switch (type) {

          case FloorBlockType.WALL: {

            (float, float)? repeat = shouldRepeat

                ? ((end.Xy() - start.Xy()).Length() / 64,

                   Math.Abs(end.Z - start.Z) / 64)

                : null;

            floorBlockMesh.AddSimpleWall(floorBlockSkin,

                                         start,

                                         end,

                                         floorBlockMaterial,

                                         floorBlockRootBone,

                                         repeat);

            break;

          case FloorBlockType.FLOOR: {

            (float, float, float)? repeat = shouldRepeat

                ? (Math.Abs(end.X - start.X) / 64,

                   Math.Abs(end.Y - start.Y) / 64,

                   Math.Abs(end.Z - start.Z) / 64)

                : null;

            floorBlockMesh.AddSimpleCube(floorBlockSkin,

                                         start,

                                         end,

                                         floorBlockMaterial,

                                         floorBlockRootBone,

                                         repeat);

            break;

        finArea.AddRootNode().AddSceneModel(floorBlockModel);

      }

    }

    var characterDirectory

        = sceneFileBundle.RootDirectory.AssertGetExistingSubdir("Characters");

    if (lvl.Npcs.Count > 0) {

      var lazyNpcModels

          = new LazyCaseInvariantStringDictionary<IReadOnlyModel>(characterType

              => new PmdcCharacterModelImporter().Import(

                  new PmdcCharacterModelFileBundle {

                      AnimationImageFiles = characterDirectory

                                            .AssertGetExistingSubdir(

                                                characterType)

                                            .GetFilesWithFileType(".gif")

                                            .ToArray(),

                  }));

      foreach (var (npcPosition, npcName, npcCharacterType) in lvl.Npcs) {

        var npcNode

            = finArea.AddRootNode()

                     .SetPosition(npcPosition.X, npcPosition.Z, npcPosition.Y)

                     .AddComponent(

                         new SimpleModelRenderComponent(

                             lazyNpcModels[npcCharacterType]));

        npcNode.Name = npcName;

      }

    }

    if (lvl.SaveBlocks.Count > 0) {

      var saveBlockModel = CreateSaveBlockModel_(sceneFileBundle.RootDirectory);

      foreach (var saveBlockPosition in lvl.SaveBlocks) {

        finArea.AddRootNode()

               .SetPosition(saveBlockPosition.X, saveBlockPosition.Z, saveBlockPosition.Y)

               .AddSceneModel(saveBlockModel);

      }

    }

    if (lvl.SaveBlocks.Count > 0) {

      var saveBlockModel = CreateSaveBlockModel_(sceneFileBundle.RootDirectory);

      foreach (var saveBlockPosition in lvl.SaveBlocks) {

        finArea.AddRootNode()

               .SetPosition(saveBlockPosition.X, saveBlockPosition.Z, saveBlockPosition.Y)

               .AddSceneModel(saveBlockModel);

      }

    }

    if (lvl.Trees.Count > 0) {

      var treeModel = CreateTreeModel_(sceneFileBundle.RootDirectory);

      foreach (var treePosition in lvl.Trees) {

        finArea.AddRootNode()

               .SetPosition(treePosition.X, treePosition.Z, treePosition.Y)

               .AddSceneModel(treeModel);

      }

    }

    if (sceneFileBundle.LvlFile.Name is "battle.lvl") {

      var battleWallModel = CreateBattleWallModel_(lazyImageMap);

      finArea.AddRootNode()

             .SetPosition(176, 0, 176)

             .AddSceneModel(battleWallModel);

      finArea.AddRootNode()

             .SetPosition(176, 0, 464)

             .AddSceneModel(battleWallModel);

      var (battleFloorModel, battleFloorRootBone)

          = D3dModelImporter.CreateModel();

      var bfSkin = battleFloorModel.Skin;

      var bfMesh = bfSkin.AddMesh();

      var bfMaterialManager = battleFloorModel.MaterialManager;

      var frontOfFloorImage = lazyImageMap["bacFrontOfFloor"].AssertNonnull();

      var frontOfFloorTexture

          = bfMaterialManager.CreateTexture(frontOfFloorImage);

      frontOfFloorTexture.WrapModeV = WrapMode.REPEAT;

      var frontOfFloorMaterial

          = bfMaterialManager.AddTextureMaterial(frontOfFloorTexture);

      bfMesh.AddSimpleFloor(bfSkin,

                            new Vector3(0, 16, -64),

                            new Vector3(64, 640, 0),

                            frontOfFloorMaterial,

                            battleFloorRootBone,

                            (1, 10));

      finArea.AddRootNode()

             .AddSceneModel(battleFloorModel);

    }

    if (lvl.BackgroundName != null) {

      var backgroundImageFile

          = sceneFileBundle

            .RootDirectory.AssertGetExistingSubdir("Backgrounds")

            .AssertGetExistingFile($"{lvl.BackgroundName}.png");

      finArea.BackgroundImage = FinImage.FromFile(backgroundImageFile);

      finArea.CreateCustomSkyboxNode();

    }

    finScene.CreateDefaultLighting(finArea.AddRootNode());

    return finScene;

  }

      ILazyDictionary<string?, IImage?> lazyImageMap) {

    var (battleWallModel, battleWallRootBone)

        = D3dModelImporter.CreateModel();

    var battleSkin = battleWallModel.Skin;

    var battleWallMesh = battleSkin.AddMesh();

    var battleMaterialManager = battleWallModel.MaterialManager;

    var frontOfFloorImage = lazyImageMap["bacFrontOfFloor"].AssertNonnull();

    var frontOfFloorTexture

        = battleMaterialManager.CreateTexture(frontOfFloorImage);

    frontOfFloorTexture.WrapModeU = WrapMode.REPEAT;

    var frontOfFloorMaterial

        = battleMaterialManager.AddTextureMaterial(frontOfFloorTexture);

    battleWallMesh.AddSimpleWall(battleSkin,

                                 new Vector3(-32, -12, 160),

                                 new Vector3(32, -12, 0),

                                 frontOfFloorMaterial,

                                 battleWallRootBone,

                                 (-1, 1));

    battleWallMesh.AddSimpleWall(battleSkin,

                                 new Vector3(-32, 12, 160),

                                 new Vector3(32, 12, 0),

                                 frontOfFloorMaterial,

                                 battleWallRootBone,

                                 (-1, 1));

    var battleWallImage = lazyImageMap["bacBattleWall"].AssertNonnull();

    var battleWallTexture

        = battleMaterialManager.CreateTexture(battleWallImage);

    battleWallTexture.WrapModeV = WrapMode.REPEAT;

    var battleWallMaterial

        = battleMaterialManager.AddTextureMaterial(battleWallTexture);

    battleWallMesh.AddSimpleWall(battleSkin,

                                 new Vector3(-32, -12, 160),

                                 new Vector3(-32, 12, 0),

                                 battleWallMaterial,

                                 battleWallRootBone,

                                 (1, 6));

    return battleWallModel;

  }

      IReadOnlyTreeDirectory rootDirectory) {

    var treeDirectory

        = rootDirectory.AssertGetExistingSubdir(

            "Models/Tree");

    var (treeModel, treeRootBone) = D3dModelImporter.CreateModel();

    var treeSkin = treeModel.Skin;

    var treeMaterialManager = treeModel.MaterialManager;

    {

      var barkRootBone = treeRootBone.AddChild(0, 0, 12);

      barkRootBone.Transform.SetRotationDegrees(0, 0, 45);

      barkRootBone.Transform.SetScale(1.5f, 1.5f, 2);

      var barkTexture = treeMaterialManager.CreateTexture(

          FinImage.FromFile(

              treeDirectory.AssertGetExistingFile("bacTree.png")));

      var barkMaterial = treeMaterialManager.AddTextureMaterial(barkTexture);

      D3dModelImporter.AddToModel(

          treeDirectory

              .AssertGetExistingFile("treemodel1.mod")

              .ReadNewFromText<D3d>(),

          treeModel,

          barkRootBone,

          out _,

          barkMaterial);

    }

    {

      var leavesMesh = treeSkin.AddMesh();

      var leavesTexture = treeMaterialManager.CreateTexture(

          FinImage.FromFile(

              treeDirectory.AssertGetExistingFile("bacTreeLeaves1.png")));

      leavesTexture.WrapModeU = WrapMode.REPEAT;

      var leavesMaterial

          = treeMaterialManager.AddTextureMaterial(leavesTexture);

      var leavesRootBone = treeRootBone.AddChild(Vector3.Zero);

      var leavesBone1 = leavesRootBone.AddChild(new Vector3(0, 0, 12));

      leavesMesh.AddSimpleCylinder(treeSkin,

                                   new Vector3(-60, -60, 20),

                                   new Vector3(60, 60, 160),

                                   8,

                                   leavesMaterial,

                                   leavesBone1,

                                   (2, 1));

      var leavesBone2 = leavesRootBone.AddChild(new Vector3(0, 0, 12));

      leavesBone2.Transform.LocalEulerRadians = new Vector3(0, 0, MathF.PI / 2);

      leavesMesh.AddSimpleCylinder(treeSkin,

                                   new Vector3(-80, -80, 20),

                                   new Vector3(80, 80, 180),

                                   8,

                                   leavesMaterial,

                                   leavesBone2,

                                   (2, 1));

      var leavesBone3 = leavesRootBone.AddChild(new Vector3(0, 0, 30));

      leavesMesh.AddSimpleCylinder(treeSkin,

                                   new Vector3(-70, -70, 20),

                                   new Vector3(70, 70, 180),

                                   8,

                                   leavesMaterial,

                                   leavesBone3,

                                   (2, 1));

    }

    {

      var shadowBone = treeRootBone.AddChild(0, 0, 0.05f);

      var shadowTexture = treeMaterialManager.CreateTexture(

          FinImage.FromFile(

              treeDirectory.AssertGetExistingFile("bacShadowXL.png")));

      var shadowMaterial

          = treeMaterialManager.AddTextureMaterial(shadowTexture);

      var shadowSize = 96;

      var shadowMesh = treeSkin.AddMesh();

      shadowMesh.AddSimpleFloor(

          treeSkin,

          new Vector3(-shadowSize, -shadowSize, 0),

          new Vector3(shadowSize, shadowSize, 0),

          shadowMaterial,

          shadowBone);

    }

    return treeModel;

  }

      IReadOnlyTreeDirectory rootDirectory) {

    var saveBlockDirectory

        = rootDirectory.AssertGetExistingSubdir(

            "Models/SaveBlock");

    var (saveBlockModel, saveBlockRootBone) = D3dModelImporter.CreateModel();

    var saveBlockSkin = saveBlockModel.Skin;

    var saveBlockMaterialManager = saveBlockModel.MaterialManager;

    var saveBlockFloatingBone = saveBlockRootBone.AddChild(0, 0, 39);

    {

      var starBone = saveBlockFloatingBone.AddChild(0, 0, 0);

      var starAnimation = saveBlockModel.AnimationManager.AddAnimation();

      starAnimation.FrameRate = 30;

      var frameCount = 64;

      starAnimation.FrameCount = frameCount;

      var starBoneTracks = starAnimation.GetOrCreateBoneTracks(starBone);

      var starBoneRotations = starBoneTracks.UseSeparateEulerRadiansKeyframes();

      starBoneRotations.Axes[2].Add(new Keyframe<float>(0, 0));

      starBoneRotations.Axes[2]

                       .Add(new Keyframe<float>(frameCount / 2, MathF.PI));

      starBoneRotations.Axes[2]

                       .Add(new Keyframe<float>(frameCount, 2 * MathF.PI));

      var (starMaterial, _)

          = saveBlockMaterialManager.AddSimpleTextureMaterialFromFile(

              saveBlockDirectory.AssertGetExistingFile("bacSaveBlockStar.png"));

      starMaterial.DiffuseColor = FinColor.FromAlphaFloat(.25f).ToSystemColor();

      saveBlockSkin

          .AddMesh()

          .AddSimpleWall(saveBlockSkin,

                         new Vector3(-8, 0, 16),

                         new Vector3(8, 0, 0),

                         starMaterial,

                         starBone);

    }

    {

      var (saveBlockSideMaterial, _)

          = saveBlockMaterialManager.AddSimpleTextureMaterialFromFile(

              saveBlockDirectory.AssertGetExistingFile("bacSaveBlock.png"));

      var (saveBlockTopBottomMaterial, _)

          = saveBlockMaterialManager.AddSimpleTextureMaterialFromFile(

              saveBlockDirectory.AssertGetExistingFile(

                  "bacSaveBlockEmpty.png"));

      saveBlockSideMaterial.DiffuseColor

          = saveBlockTopBottomMaterial.DiffuseColor

              = FinColor.FromAlphaFloat(.7f).ToSystemColor();

      saveBlockSkin

          .AddMesh()

          .AddSimpleCube(saveBlockSkin,

                         new Vector3(-8, -8, 16),

                         new Vector3(8, 8, 0),

                         saveBlockTopBottomMaterial,

                         saveBlockSideMaterial,

                         saveBlockFloatingBone);

    }

    {

      var shadowBone = saveBlockRootBone.AddChild(0, 0, 1);

      var shadowTexture = saveBlockMaterialManager.CreateTexture(

          FinImage.FromFile(rootDirectory.AssertGetExistingFile(

                                "Textures/bacSquareShadow.png")));

      var shadowMaterial

          = saveBlockMaterialManager.AddTextureMaterial(shadowTexture);

      var shadowSize = 9;

      var shadowMesh = saveBlockSkin.AddMesh();

      shadowMesh.AddSimpleFloor(

          saveBlockSkin,

          new Vector3(-shadowSize, -shadowSize, 0),

          new Vector3(shadowSize, shadowSize, 0),

          shadowMaterial,

          shadowBone);

    }

    return saveBlockModel;

  }