VulkanShader_1.21.10-0.0.4-alpha.jar

• VulkanShader_1.21.10-0.0.4-alpha.jar
• net
• vulkanmod
• vulkan
• shader
• PipelineState.java

Download file

    package net.vulkanmod.vulkan.shader;

import java.util.Objects;
import net.vulkanmod.vulkan.VRenderSystem;
import net.vulkanmod.vulkan.framebuffer.RenderPass;

public class PipelineState {
   private static final int DEFAULT_DEPTH_OP = 515;
   public static BlendInfo blendInfo = defaultBlendInfo();
   public static final PipelineState DEFAULT = new PipelineState(getAssemblyRasterState(), getBlendState(), getDepthState(), getLogicOpState(), VRenderSystem.getColorMask(), (RenderPass)null);
   public static PipelineState currentState;
   final RenderPass renderPass;
   int assemblyRasterState;
   int blendState_i;
   int depthState_i;
   int colorMask_i;
   int logicOp_i;

   public static PipelineState getCurrentPipelineState(RenderPass renderPass) {
      int assemblyRasterState = getAssemblyRasterState();
      int blendState = getBlendState();
      int currentColorMask = VRenderSystem.getColorMask();
      int depthState = getDepthState();
      int logicOp = getLogicOpState();
      return currentState.checkEquals(assemblyRasterState, blendState, depthState, logicOp, currentColorMask, renderPass) ? currentState : (currentState = new PipelineState(assemblyRasterState, blendState, depthState, logicOp, currentColorMask, renderPass));
   }

   public static int getBlendState() {
      return PipelineState.BlendState.getState(blendInfo);
   }

   public static int getAssemblyRasterState() {
      return PipelineState.AssemblyRasterState.encode(VRenderSystem.cull, VRenderSystem.topology, VRenderSystem.polygonMode);
   }

   public static int getDepthState() {
      int depthState = 0;
      depthState |= VRenderSystem.depthTest ? 1 : 0;
      depthState |= VRenderSystem.depthMask ? 2 : 0;
      depthState |= PipelineState.DepthState.encodeDepthFun(VRenderSystem.depthFun);
      return depthState;
   }

   public static int getLogicOpState() {
      int logicOpState = 0;
      logicOpState |= VRenderSystem.logicOp ? 1 : 0;
      logicOpState |= PipelineState.LogicOpState.encodeLogicOpFun(VRenderSystem.logicOpFun);
      return logicOpState;
   }

   public PipelineState(int assemblyRasterState, int blendState, int depthState, int logicOp, int colorMask, RenderPass renderPass) {
      this.renderPass = renderPass;
      this.assemblyRasterState = assemblyRasterState;
      this.blendState_i = blendState;
      this.depthState_i = depthState;
      this.colorMask_i = colorMask;
      this.logicOp_i = logicOp;
   }

   private boolean checkEquals(int assemblyRasterState, int blendState, int depthState, int logicOp, int colorMask, RenderPass renderPass) {
      return blendState == this.blendState_i && depthState == this.depthState_i && renderPass == this.renderPass && logicOp == this.logicOp_i && assemblyRasterState == this.assemblyRasterState && colorMask == this.colorMask_i;
   }

   public boolean equals(Object o) {
      if (this == o) {
         return true;
      } else if (o != null && this.getClass() == o.getClass()) {
         PipelineState that = (PipelineState)o;
         return this.blendState_i == that.blendState_i && this.depthState_i == that.depthState_i && this.renderPass == that.renderPass && this.logicOp_i == that.logicOp_i && this.assemblyRasterState == that.assemblyRasterState && this.colorMask_i == that.colorMask_i;
      } else {
         return false;
      }
   }

   public int hashCode() {
      return Objects.hash(new Object[]{this.blendState_i, this.depthState_i, this.logicOp_i, this.assemblyRasterState, this.colorMask_i, this.renderPass});
   }

   public static BlendInfo defaultBlendInfo() {
      return new BlendInfo(true, 6, 7, 1, 0, 0);
   }

   static {
      currentState = DEFAULT;
   }

   public static class BlendInfo {
      public boolean enabled;
      public int srcRgbFactor;
      public int dstRgbFactor;
      public int srcAlphaFactor;
      public int dstAlphaFactor;
      public int blendOp;

      public BlendInfo(boolean enabled, int srcRgbFactor, int dstRgbFactor, int srcAlphaFactor, int dstAlphaFactor, int blendOp) {
         this.enabled = enabled;
         this.srcRgbFactor = srcRgbFactor;
         this.dstRgbFactor = dstRgbFactor;
         this.srcAlphaFactor = srcAlphaFactor;
         this.dstAlphaFactor = dstAlphaFactor;
         this.blendOp = blendOp;
      }

      public void setBlendFunction(int sourceFactor, int destFactor) {
         this.srcRgbFactor = glToVulkanBlendFactor(sourceFactor);
         this.srcAlphaFactor = glToVulkanBlendFactor(sourceFactor);
         this.dstRgbFactor = glToVulkanBlendFactor(destFactor);
         this.dstAlphaFactor = glToVulkanBlendFactor(destFactor);
      }

      public void setBlendFuncSeparate(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
         this.srcRgbFactor = glToVulkanBlendFactor(srcRgb);
         this.srcAlphaFactor = glToVulkanBlendFactor(srcAlpha);
         this.dstRgbFactor = glToVulkanBlendFactor(dstRgb);
         this.dstAlphaFactor = glToVulkanBlendFactor(dstAlpha);
      }

      public void setBlendOp(int i) {
         this.blendOp = glToVulkanBlendOp(i);
      }

      public int createBlendState() {
         return PipelineState.BlendState.getState(this);
      }

      private static int glToVulkanBlendOp(int value) {
         byte var10000;
         switch (value) {
            case 32774:
               var10000 = 0;
               break;
            case 32775:
               var10000 = 3;
               break;
            case 32776:
               var10000 = 4;
               break;
            case 32777:
            default:
               throw new RuntimeException("unknown blend factor: " + value);
            case 32778:
               var10000 = 1;
               break;
            case 32779:
               var10000 = 2;
         }

         return var10000;
      }

      private static int glToVulkanBlendFactor(int value) {
         byte var10000;
         switch (value) {
            case 0 -> var10000 = 0;
            case 1 -> var10000 = 1;
            case 768 -> var10000 = 2;
            case 769 -> var10000 = 3;
            case 770 -> var10000 = 6;
            case 771 -> var10000 = 7;
            case 774 -> var10000 = 4;
            case 775 -> var10000 = 5;
            default -> throw new RuntimeException("unknown blend factor: " + value);
         }

         return var10000;
      }
   }

   public static class BlendState {
      public static final int SRC_RGB_OFFSET = 0;
      public static final int DST_RGB_OFFSET = 5;
      public static final int SRC_A_OFFSET = 10;
      public static final int DST_A_OFFSET = 15;
      public static final int FUN_OFFSET = 20;
      public static final int ENABLE_BIT = 16777216;
      public static final int OP_MASK = 15;
      public static final int FACTOR_MASK = 31;

      public static int getState(BlendInfo blendInfo) {
         int s = 0;
         s |= blendInfo.enabled ? 16777216 : 0;
         s |= encode(blendInfo.srcRgbFactor, 0, 31);
         s |= encode(blendInfo.dstRgbFactor, 5, 31);
         s |= encode(blendInfo.srcAlphaFactor, 10, 31);
         s |= encode(blendInfo.dstAlphaFactor, 15, 31);
         s |= encode(blendInfo.blendOp, 20, 15);
         return s;
      }

      public static boolean enable(int i) {
         return (i & 16777216) != 0;
      }

      public static int encode(int i, int offset, int mask) {
         return (i & mask) << offset;
      }

      public static int decode(int i, int offset, int bits) {
         return i >>> offset & bits;
      }

      public static int getSrcRgbFactor(int s) {
         return decode(s, 0, 31);
      }

      public static int getDstRgbFactor(int s) {
         return decode(s, 5, 31);
      }

      public static int getSrcAlphaFactor(int s) {
         return decode(s, 10, 31);
      }

      public static int getDstAlphaFactor(int s) {
         return decode(s, 15, 31);
      }

      public static int blendOp(int state) {
         return decode(state, 20, 15);
      }
   }

   public abstract static class LogicOpState {
      public static final int ENABLE_BIT = 1;
      public static final int FUN_OFFSET = 1;
      public static final int FUN_BITS = 5;

      public static boolean enable(int i) {
         return (i & 1) != 0;
      }

      public static int encodeLogicOpFun(int glFun) {
         int fun = glToVulkan(glFun);
         return fun << 1;
      }

      public static int decodeFun(int state) {
         return state >>> 1;
      }

      public static int glToVulkan(int f) {
         byte var10000;
         switch (f) {
            case 5387 -> var10000 = 11;
            default -> var10000 = 1;
         }

         return var10000;
      }
   }

   public abstract static class AssemblyRasterState {
      public static final int POLYGON_MODE_MASK = 7;
      public static final int TOPOLOGY_OFFSET = 3;
      public static final int TOPOLOGY_BITS = 4;
      public static final int TOPOLOGY_MASK = 31;
      public static final int CULL_MODE_OFFSET = 7;
      public static final int CULL_MODE_BITS = 2;
      public static final int CULL_MODE_MASK = 3;

      public static int encode(boolean cull, int topology, int polygonMode) {
         int state = polygonMode | topology << 3;
         state |= (cull ? 2 : 0) << 7;
         return state;
      }

      public static int decodeTopology(int state) {
         return state >>> 3 & 31;
      }

      public static int decodePolygonMode(int state) {
         return state & 7;
      }

      public static int decodeCullMode(int state) {
         return state >>> 7 & 3;
      }
   }

   public abstract static class ColorMask {
      public static int getColorMask(boolean r, boolean g, boolean b, boolean a) {
         return (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0) | (a ? 8 : 0);
      }
   }

   public abstract static class DepthState {
      public static final int DEPTH_TEST_BIT = 1;
      public static final int DEPTH_MASK_BIT = 2;
      public static final int DEPTH_FUN_OFFSET = 2;
      public static final int DEPTH_FUN_BITS = 4;

      public static boolean depthTest(int i) {
         return (i & 1) != 0;
      }

      public static boolean depthMask(int i) {
         return (i & 2) != 0;
      }

      public static int encodeDepthFun(int glFun) {
         int fun = glToVulkan(glFun);
         return fun << 2;
      }

      public static int decodeDepthFun(int state) {
         return state >>> 2;
      }

      private static int glToVulkan(int value) {
         byte var10000;
         switch (value) {
            case 514:
               var10000 = 2;
               break;
            case 515:
               var10000 = 3;
               break;
            case 516:
               var10000 = 4;
               break;
            case 517:
            default:
               throw new RuntimeException("unknown blend factor..");
            case 518:
               var10000 = 6;
               break;
            case 519:
               var10000 = 7;
         }

         return var10000;
      }
   }
}
    

Download file