VulkanShader_1.21.10-0.0.4-alpha.jar

• VulkanShader_1.21.10-0.0.4-alpha.jar
• net
• vulkanmod
• render
• shader
• ShaderPackManager.java

Download file

    package net.vulkanmod.render.shader;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import net.fabricmc.loader.api.FabricLoader;
import net.minecraft.class_310;
import net.vulkanmod.Initializer;
import net.vulkanmod.render.PipelineManager;

public final class ShaderPackManager {
   public static final String INTERNAL_PACK = "Internal";
   private static final Path SHADERS_DIR = FabricLoader.getInstance().getGameDir().resolve("shaders");

   private ShaderPackManager() {
   }

   public static void ensureShaderDirectory() {
      try {
         Files.createDirectories(SHADERS_DIR);
      } catch (IOException e) {
         throw new RuntimeException("Failed to create shader directory: " + String.valueOf(SHADERS_DIR), e);
      }
   }

   public static Path getShadersDirectory() {
      ensureShaderDirectory();
      return SHADERS_DIR;
   }

   public static String[] getAvailableShaderPacks() {
      ensureShaderDirectory();
      List<String> packs = new ArrayList();
      packs.add("Internal");

      try {
         Stream<Path> stream = Files.list(SHADERS_DIR);

         try {
            Stream var10000 = stream.filter((path) -> Files.isDirectory(path, new LinkOption[0]) || path.getFileName().toString().endsWith(".zip")).map((path) -> path.getFileName().toString()).filter((name) -> !name.isBlank()).sorted(Comparator.naturalOrder());
            Objects.requireNonNull(packs);
            var10000.forEach(packs::add);
         } catch (Throwable var5) {
            if (stream != null) {
               try {
                  stream.close();
               } catch (Throwable var4) {
                  var5.addSuppressed(var4);
               }
            }

            throw var5;
         }

         if (stream != null) {
            stream.close();
         }
      } catch (IOException e) {
         Initializer.LOGGER.error("Failed to list shader packs from {}", SHADERS_DIR, e);
      }

      return (String[])packs.toArray((x$0) -> new String[x$0]);
   }

   public static Path getActiveShaderPackRoot() {
      ensureShaderDirectory();
      Path selectedPack = getActiveShaderPackPath();
      return selectedPack != null && Files.isDirectory(selectedPack, new LinkOption[0]) ? selectedPack : null;
   }

   public static Path getActiveShaderPackPath() {
      ensureShaderDirectory();
      String shaderPack = Initializer.CONFIG.shaderPack;
      if (shaderPack != null && !shaderPack.isBlank() && !"Internal".equals(shaderPack)) {
         Path packPath = SHADERS_DIR.resolve(shaderPack);
         return !Files.exists(packPath, new LinkOption[0]) ? null : packPath;
      } else {
         return null;
      }
   }

   public static Path getActiveIncludeDirectory() {
      Path root = getActiveShaderPackRoot();
      if (root == null) {
         return null;
      } else {
         Path includeDir = root.resolve("include");
         return Files.isDirectory(includeDir, new LinkOption[0]) ? includeDir : null;
      }
   }

   public static InputStream openActiveShaderResource(String relativePath) {
      Path packPath = getActiveShaderPackPath();
      if (packPath == null) {
         return null;
      } else {
         try {
            if (Files.isDirectory(packPath, new LinkOption[0])) {
               Path file = packPath.resolve(relativePath);
               return !Files.exists(file, new LinkOption[0]) ? null : Files.newInputStream(file);
            } else if (packPath.getFileName().toString().endsWith(".zip")) {
               ZipFile zipFile = new ZipFile(packPath.toFile(), StandardCharsets.UTF_8);

               ByteArrayInputStream var9;
               label55: {
                  try {
                     ZipEntry entry = zipFile.getEntry(relativePath);
                     if (entry == null) {
                        entry = (ZipEntry)zipFile.stream().filter((candidate) -> !candidate.isDirectory()).filter((candidate) -> candidate.getName().equals(relativePath) || candidate.getName().endsWith("/" + relativePath)).findFirst().orElse((Object)null);
                     }

                     if (entry == null) {
                        var9 = null;
                        break label55;
                     }

                     var9 = new ByteArrayInputStream(zipFile.getInputStream(entry).readAllBytes());
                  } catch (Throwable var6) {
                     try {
                        zipFile.close();
                     } catch (Throwable var5) {
                        var6.addSuppressed(var5);
                     }

                     throw var6;
                  }

                  zipFile.close();
                  return var9;
               }

               zipFile.close();
               return var9;
            } else {
               return null;
            }
         } catch (IOException e) {
            throw new UncheckedIOException("Failed to read shader pack resource " + relativePath + " from " + String.valueOf(packPath), e);
         }
      }
   }

   public static void reloadActiveShaderPack() {
      PipelineManager.reloadPipelines();
      class_310 minecraft = class_310.method_1551();
      if (minecraft.field_1769 != null) {
         minecraft.field_1769.method_3279();
      }

   }
}
    

Download file