VulkanShader_1.21.10-0.0.4-alpha.jar

• VulkanShader_1.21.10-0.0.4-alpha.jar
• net
• vulkanmod
• render
• vertex
• QuadSorter.java

Download file

    package net.vulkanmod.render.vertex;

import com.mojang.blaze3d.vertex.VertexFormat;
import net.vulkanmod.render.util.SortUtil;
import org.joml.Vector3f;
import org.lwjgl.system.MemoryUtil;

public class QuadSorter {
   private Vector3f[] sortingPoints;
   private float sortX = Float.NaN;
   private float sortY = Float.NaN;
   private float sortZ = Float.NaN;
   private boolean indexOnly;
   private VertexFormat format;
   private int vertexCount;
   private int indexCount;
   private float[] distances;
   private int[] sortingPointsIndices;

   public void setQuadSortOrigin(float x, float y, float z) {
      this.sortX = x;
      this.sortY = y;
      this.sortZ = z;
   }

   public SortState getSortState() {
      return new SortState(this.vertexCount, this.sortingPoints, this.distances, this.sortingPointsIndices);
   }

   public void restoreSortState(SortState sortState) {
      this.vertexCount = sortState.vertexCount;
      this.sortingPoints = sortState.sortingPoints;
      this.distances = sortState.distances;
      this.sortingPointsIndices = sortState.sortingPointsIndices;
      this.indexOnly = true;
   }

   public void setupQuadSortingPoints(long bufferPtr, int vertexCount, VertexFormat format) {
      this.vertexCount = vertexCount;
      int pointCount = vertexCount / 4;
      Vector3f[] sortingPoints = new Vector3f[pointCount];
      int vertexSize = format.getVertexSize();
      int quadStride = vertexSize * 4;
      int offset = vertexSize * 2;
      if (format == CustomVertexFormat.COMPRESSED_TERRAIN) {
         float invConv = 4.8828125E-4F;
         float convOffset = 4.0F;

         for(int m = 0; m < pointCount; ++m) {
            long ptr = bufferPtr + (long)m * (long)quadStride;
            short x0 = MemoryUtil.memGetShort(ptr + 0L);
            short y0 = MemoryUtil.memGetShort(ptr + 2L);
            short z0 = MemoryUtil.memGetShort(ptr + 4L);
            short x2 = MemoryUtil.memGetShort(ptr + (long)offset + 0L);
            short y2 = MemoryUtil.memGetShort(ptr + (long)offset + 2L);
            short z2 = MemoryUtil.memGetShort(ptr + (long)offset + 4L);
            float xa = (float)(x0 + x2) * 4.8828125E-4F * 0.5F + 4.0F;
            float ya = (float)(y0 + y2) * 4.8828125E-4F * 0.5F + 4.0F;
            float za = (float)(z0 + z2) * 4.8828125E-4F * 0.5F + 4.0F;
            sortingPoints[m] = new Vector3f(xa, ya, za);
         }
      } else {
         for(int m = 0; m < pointCount; ++m) {
            long ptr = bufferPtr + (long)m * (long)quadStride;
            float x0 = MemoryUtil.memGetFloat(ptr + 0L);
            float y0 = MemoryUtil.memGetFloat(ptr + 4L);
            float z0 = MemoryUtil.memGetFloat(ptr + 8L);
            float x2 = MemoryUtil.memGetFloat(ptr + (long)offset + 0L);
            float y2 = MemoryUtil.memGetFloat(ptr + (long)offset + 4L);
            float z2 = MemoryUtil.memGetFloat(ptr + (long)offset + 8L);
            float q = (x0 + x2) * 0.5F;
            float r = (y0 + y2) * 0.5F;
            float s = (z0 + z2) * 0.5F;
            sortingPoints[m] = new Vector3f(q, r, s);
         }
      }

      this.sortingPoints = sortingPoints;
      this.distances = new float[pointCount];
      this.sortingPointsIndices = new int[pointCount];
   }

   public void putSortedQuadIndices(TerrainBufferBuilder bufferBuilder, VertexFormat.class_5595 indexType) {
      float[] distances = this.distances;
      int[] sortingPointsIndices = this.sortingPointsIndices;

      for(int i = 0; i < this.sortingPoints.length; sortingPointsIndices[i] = i++) {
         float dx = this.sortingPoints[i].x() - this.sortX;
         float dy = this.sortingPoints[i].y() - this.sortY;
         float dz = this.sortingPoints[i].z() - this.sortZ;
         distances[i] = dx * dx + dy * dy + dz * dz;
      }

      SortUtil.mergeSort(sortingPointsIndices, distances);
      long ptr = bufferBuilder.getPtr();
      int size = indexType.field_27375;
      int stride = 4;

      for(int i = 0; i < sortingPointsIndices.length; ++i) {
         int quadIndex = sortingPointsIndices[i];
         int baseVertex = quadIndex * 4;
         MemoryUtil.memPutInt(ptr + (long)size * 0L, baseVertex + 0);
         MemoryUtil.memPutInt(ptr + (long)size * 1L, baseVertex + 1);
         MemoryUtil.memPutInt(ptr + (long)size * 2L, baseVertex + 2);
         MemoryUtil.memPutInt(ptr + (long)size * 3L, baseVertex + 2);
         MemoryUtil.memPutInt(ptr + (long)size * 4L, baseVertex + 3);
         MemoryUtil.memPutInt(ptr + (long)size * 5L, baseVertex + 0);
         ptr += (long)size * 6L;
      }

   }

   public void putSortedQuadIndices(TerrainBuilder bufferBuilder, VertexFormat.class_5595 indexType) {
      float[] distances = new float[this.sortingPoints.length];
      int[] sortingPoints = new int[this.sortingPoints.length];

      for(int i = 0; i < this.sortingPoints.length; sortingPoints[i] = i++) {
         float dx = this.sortingPoints[i].x() - this.sortX;
         float dy = this.sortingPoints[i].y() - this.sortY;
         float dz = this.sortingPoints[i].z() - this.sortZ;
         distances[i] = dx * dx + dy * dy + dz * dz;
      }

      SortUtil.mergeSort(sortingPoints, distances);
      long ptr = bufferBuilder.indexBufferPtr;
      int size = indexType.field_27375;
      int stride = 4;

      for(int i = 0; i < sortingPoints.length; ++i) {
         int quadIndex = sortingPoints[i];
         int baseVertex = quadIndex * 4;
         MemoryUtil.memPutInt(ptr + (long)size * 0L, baseVertex + 0);
         MemoryUtil.memPutInt(ptr + (long)size * 1L, baseVertex + 1);
         MemoryUtil.memPutInt(ptr + (long)size * 2L, baseVertex + 2);
         MemoryUtil.memPutInt(ptr + (long)size * 3L, baseVertex + 2);
         MemoryUtil.memPutInt(ptr + (long)size * 4L, baseVertex + 3);
         MemoryUtil.memPutInt(ptr + (long)size * 5L, baseVertex + 0);
         ptr += (long)size * 6L;
      }

   }

   public void reset() {
      this.vertexCount = 0;
   }

   public int getVertexCount() {
      return this.vertexCount;
   }

   public int getIndexCount() {
      return this.indexCount;
   }

   public static class SortState {
      final int vertexCount;
      final Vector3f[] sortingPoints;
      final float[] distances;
      final int[] sortingPointsIndices;

      SortState(int vertexCount, Vector3f[] sortingPoints, float[] distances, int[] sortingPointsIndices) {
         this.vertexCount = vertexCount;
         this.sortingPoints = sortingPoints;
         this.distances = distances;
         this.sortingPointsIndices = sortingPointsIndices;
      }
   }
}
    

Download file