fabric-renderer-api-v1-7.2.3+9be2a36e6f.jar

• fabric-renderer-api-v1-7.2.3+9be2a36e6f.jar
• net
• fabricmc
• fabric
• api
• renderer
• v1
• model
• ModelBakeSettingsHelper.java

Download file

    package net.fabricmc.fabric.api.renderer.v1.model;

import java.util.EnumMap;
import java.util.Map;
import net.fabricmc.api.EnvType;
import net.fabricmc.api.Environment;
import net.fabricmc.fabric.api.renderer.v1.mesh.QuadTransform;
import net.minecraft.class_1058;
import net.minecraft.class_1086;
import net.minecraft.class_2350;
import net.minecraft.class_3665;
import net.minecraft.class_4590;
import net.minecraft.class_4609;
import net.minecraft.class_7837;
import org.joml.Matrix3f;
import org.joml.Matrix4f;
import org.joml.Matrix4fc;
import org.joml.Vector3f;
import org.joml.Vector4f;

@Environment(EnvType.CLIENT)
public final class ModelBakeSettingsHelper {
   private static final class_2350[] DIRECTIONS = class_2350.values();

   private ModelBakeSettingsHelper() {
   }

   public static class_3665 of(final class_4590 transformation, boolean uvLock) {
      Matrix4fc matrix = transformation.method_22936();
      if (class_7837.method_65174(matrix)) {
         return class_1086.field_5350;
      } else if (!uvLock) {
         return new class_3665() {
            public class_4590 method_3509() {
               return transformation;
            }
         };
      } else {
         final Map<class_2350, Matrix4fc> faceTransformations = new EnumMap(class_2350.class);
         final Map<class_2350, Matrix4fc> inverseFaceTransformations = new EnumMap(class_2350.class);

         for(class_2350 face : DIRECTIONS) {
            Matrix4fc faceTransformation = class_4609.method_68069(transformation, face).method_22936();
            faceTransformations.put(face, faceTransformation);
            inverseFaceTransformations.put(face, faceTransformation.invert(new Matrix4f()));
         }

         return new class_3665() {
            public class_4590 method_3509() {
               return transformation;
            }

            public Matrix4fc method_68011(class_2350 face) {
               return (Matrix4fc)faceTransformations.get(face);
            }

            public Matrix4fc method_68012(class_2350 face) {
               return (Matrix4fc)inverseFaceTransformations.get(face);
            }
         };
      }
   }

   public static class_3665 multiply(class_3665 left, class_3665 right) {
      if (class_7837.method_65174(left.method_3509().method_22936())) {
         return right;
      } else if (class_7837.method_65174(right.method_3509().method_22936())) {
         return left;
      } else {
         final class_4590 transformation = left.method_3509().method_22933(right.method_3509());
         boolean leftHasFaceTransformations = false;
         boolean rightHasFaceTransformations = false;

         for(class_2350 face : DIRECTIONS) {
            if (!leftHasFaceTransformations && !class_7837.method_65174(left.method_68011(face))) {
               leftHasFaceTransformations = true;
            }

            if (!rightHasFaceTransformations && !class_7837.method_65174(right.method_68011(face))) {
               rightHasFaceTransformations = true;
            }
         }

         if (!(leftHasFaceTransformations & rightHasFaceTransformations)) {
            final class_3665 faceTransformDelegate = leftHasFaceTransformations ? left : right;
            return new class_3665() {
               public class_4590 method_3509() {
                  return transformation;
               }

               public Matrix4fc method_68011(class_2350 face) {
                  return faceTransformDelegate.method_68011(face);
               }

               public Matrix4fc method_68012(class_2350 face) {
                  return faceTransformDelegate.method_68012(face);
               }
            };
         } else {
            final Map<class_2350, Matrix4fc> faceTransformations = new EnumMap(class_2350.class);
            final Map<class_2350, Matrix4fc> inverseFaceTransformations = new EnumMap(class_2350.class);

            for(class_2350 face : DIRECTIONS) {
               faceTransformations.put(face, left.method_68011(face).mul(right.method_68011(face), new Matrix4f()));
               inverseFaceTransformations.put(face, right.method_68012(face).mul(left.method_68012(face), new Matrix4f()));
            }

            return new class_3665() {
               public class_4590 method_3509() {
                  return transformation;
               }

               public Matrix4fc method_68011(class_2350 face) {
                  return (Matrix4fc)faceTransformations.get(face);
               }

               public Matrix4fc method_68012(class_2350 face) {
                  return (Matrix4fc)inverseFaceTransformations.get(face);
               }
            };
         }
      }
   }

   public static QuadTransform asQuadTransform(class_3665 settings, SpriteFinder spriteFinder) {
      Matrix4fc matrix = settings.method_3509().method_22936();
      if (class_7837.method_65174(matrix)) {
         return (q) -> true;
      } else {
         Matrix3f normalMatrix = matrix.normal(new Matrix3f());
         Vector4f vec4 = new Vector4f();
         Vector3f vec3 = new Vector3f();
         return (quad) -> {
            class_2350 lightFace = quad.lightFace();
            Matrix4fc reverseMatrix = settings.method_68012(lightFace);
            if (!class_7837.method_65174(reverseMatrix)) {
               class_1058 sprite = spriteFinder.find(quad);

               for(int vertexIndex = 0; vertexIndex < 4; ++vertexIndex) {
                  float frameU = sprite.method_35804(quad.u(vertexIndex));
                  float frameV = sprite.method_35805(quad.v(vertexIndex));
                  vec3.set(frameU - 0.5F, frameV - 0.5F, 0.0F);
                  reverseMatrix.transformPosition(vec3);
                  frameU = vec3.x + 0.5F;
                  frameV = vec3.y + 0.5F;
                  quad.uv(vertexIndex, sprite.method_4580(frameU), sprite.method_4570(frameV));
               }
            }

            for(int vertexIndex = 0; vertexIndex < 4; ++vertexIndex) {
               vec4.set(quad.x(vertexIndex) - 0.5F, quad.y(vertexIndex) - 0.5F, quad.z(vertexIndex) - 0.5F, 1.0F);
               vec4.mul(matrix);
               quad.pos(vertexIndex, vec4.x + 0.5F, vec4.y + 0.5F, vec4.z + 0.5F);
               if (quad.hasNormal(vertexIndex)) {
                  quad.copyNormal(vertexIndex, vec3);
                  vec3.mul(normalMatrix);
                  vec3.normalize();
                  quad.normal(vertexIndex, vec3);
               }
            }

            class_2350 cullFace = quad.cullFace();
            if (cullFace != null) {
               quad.cullFace(class_2350.method_23225(matrix, cullFace));
            }

            return true;
         };
      }
   }
}
    

Download file