mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-19 11:59:40 +00:00
Purge FRAPI code
Also use a baked stone model and fix a stupid in JSON
This commit is contained in:
1 parent
236a513705
commit
2ca4d5338f
20 files changed
+150
-927
No files matched your search
@@ -47,7 +47,7 @@ public class BlockTest extends Block implements QuadProvider {
|
||||
false
|
||||
),
|
||||
};
|
||||
public static final List<Quad> EMPTY = ObjectImmutableList.of();
|
||||
private static final List<Quad> EMPTY = ObjectImmutableList.of();
|
||||
private static final JsonModel[] model = new JsonModel[4];
|
||||
|
||||
public BlockTest() {
|
||||
|
||||
+3
-1
@@ -2,6 +2,8 @@ package com.gtnewhorizons.angelica.mixins.early.angelica.models;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import com.gtnewhorizons.angelica.models.MixinModels;
|
||||
import com.gtnewhorizons.angelica.models.json.Variant;
|
||||
import com.gtnewhorizons.angelica.utils.ObjectPooler;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
@@ -18,6 +20,6 @@ public abstract class MixinBlockStone implements QuadProvider {
|
||||
|
||||
// TODO: Use modern model API
|
||||
public List<Quad> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, ObjectPooler<Quad> quadPool) {
|
||||
return CubeModel.INSTANCE.get().getQuads(world, pos, block, meta, dir, random, quadPool);
|
||||
return MixinModels.stoneModel.getQuads(world, pos, block, meta, dir, random, quadPool);
|
||||
}
|
||||
}
|
||||
@@ -1,134 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.mojang.DefaultVertexFormat;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
|
||||
import com.gtnewhorizons.angelica.models.material.RenderMaterialImpl;
|
||||
import net.minecraft.util.MathHelper;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
/**
|
||||
* Holds all the array offsets and bit-wise encoders/decoders for
|
||||
* packing/unpacking quad data in an array of integers.
|
||||
* All of this is implementation-specific - that's why it isn't a "helper" class.
|
||||
*/
|
||||
public abstract class EncodingFormat {
|
||||
private EncodingFormat() { }
|
||||
|
||||
static final int HEADER_BITS = 0;
|
||||
static final int HEADER_FACE_NORMAL = 1;
|
||||
static final int HEADER_COLOR_INDEX = 2;
|
||||
static final int HEADER_TAG = 3;
|
||||
public static final int HEADER_STRIDE = 4;
|
||||
|
||||
static final int VERTEX_X;
|
||||
static final int VERTEX_Y;
|
||||
static final int VERTEX_Z;
|
||||
static final int VERTEX_COLOR;
|
||||
static final int VERTEX_U;
|
||||
static final int VERTEX_V;
|
||||
static final int VERTEX_LIGHTMAP;
|
||||
static final int VERTEX_NORMAL;
|
||||
public static final int VERTEX_STRIDE;
|
||||
|
||||
public static final int QUAD_STRIDE;
|
||||
public static final int QUAD_STRIDE_BYTES;
|
||||
public static final int TOTAL_STRIDE;
|
||||
|
||||
static {
|
||||
// Upstream uses POSITION_COLOR_TEXTURE_LIGHT_NORMAL, but Nd uses POSITION_COLOR_TEXTURE_LIGHT_NORMAL_NOPAD
|
||||
final VertexFormat format = DefaultVertexFormat.POSITION_COLOR_TEXTURE_LIGHT_NORMAL;
|
||||
VERTEX_X = HEADER_STRIDE + 0;
|
||||
VERTEX_Y = HEADER_STRIDE + 1;
|
||||
VERTEX_Z = HEADER_STRIDE + 2;
|
||||
VERTEX_COLOR = HEADER_STRIDE + 3;
|
||||
VERTEX_U = HEADER_STRIDE + 4;
|
||||
VERTEX_V = VERTEX_U + 1;
|
||||
VERTEX_LIGHTMAP = HEADER_STRIDE + 6;
|
||||
VERTEX_NORMAL = HEADER_STRIDE + 7;
|
||||
VERTEX_STRIDE = format.getVertexSize();
|
||||
QUAD_STRIDE = VERTEX_STRIDE * 4;
|
||||
QUAD_STRIDE_BYTES = QUAD_STRIDE * 4;
|
||||
TOTAL_STRIDE = HEADER_STRIDE + QUAD_STRIDE;
|
||||
|
||||
//Preconditions.checkState(VERTEX_STRIDE == QuadView.VANILLA_VERTEX_STRIDE, "Indigo vertex stride (%s) mismatched with rendering API (%s)", VERTEX_STRIDE, QuadView.VANILLA_VERTEX_STRIDE);
|
||||
//Preconditions.checkState(QUAD_STRIDE == QuadView.VANILLA_QUAD_STRIDE, "Indigo quad stride (%s) mismatched with rendering API (%s)", QUAD_STRIDE, QuadView.VANILLA_QUAD_STRIDE);
|
||||
}
|
||||
|
||||
/** used for quick clearing of quad buffers. */
|
||||
static final int[] EMPTY = new int[TOTAL_STRIDE];
|
||||
|
||||
// Default 7
|
||||
private static final int DIRECTION_MASK = MathHelper.roundUpToPowerOfTwo(ModelHelper.NULL_FACE_ID) - 1;
|
||||
// Default 3
|
||||
private static final int DIRECTION_BIT_COUNT = Integer.bitCount(DIRECTION_MASK);
|
||||
private static final int CULL_SHIFT = 0;
|
||||
private static final int CULL_INVERSE_MASK = ~(DIRECTION_MASK << CULL_SHIFT);
|
||||
private static final int LIGHT_SHIFT = CULL_SHIFT + DIRECTION_BIT_COUNT;
|
||||
private static final int LIGHT_INVERSE_MASK = ~(DIRECTION_MASK << LIGHT_SHIFT);
|
||||
private static final int NORMALS_SHIFT = LIGHT_SHIFT + DIRECTION_BIT_COUNT;
|
||||
private static final int NORMALS_COUNT = 4;
|
||||
// Lowest 4 bits
|
||||
private static final int NORMALS_MASK = (1 << NORMALS_COUNT) - 1;
|
||||
// -------- -------- ------NN NN------
|
||||
private static final int NORMALS_INVERSE_MASK = ~(NORMALS_MASK << NORMALS_SHIFT);
|
||||
private static final int GEOMETRY_SHIFT = NORMALS_SHIFT + NORMALS_COUNT;
|
||||
private static final int GEOMETRY_MASK = (1 << GeometryHelper.FLAG_BIT_COUNT) - 1;
|
||||
private static final int GEOMETRY_INVERSE_MASK = ~(GEOMETRY_MASK << GEOMETRY_SHIFT);
|
||||
private static final int MATERIAL_SHIFT = GEOMETRY_SHIFT + GeometryHelper.FLAG_BIT_COUNT;
|
||||
private static final int MATERIAL_MASK = MathHelper.roundUpToPowerOfTwo(RenderMaterialImpl.VALUE_COUNT) - 1;
|
||||
//private static final int MATERIAL_BIT_COUNT = Integer.bitCount(MATERIAL_MASK);
|
||||
private static final int MATERIAL_INVERSE_MASK = ~(MATERIAL_MASK << MATERIAL_SHIFT);
|
||||
|
||||
/*static {
|
||||
Preconditions.checkArgument(MATERIAL_SHIFT + MATERIAL_BIT_COUNT <= 32, "Indigo header encoding bit count (%s) exceeds integer bit length)", TOTAL_STRIDE);
|
||||
}*/
|
||||
|
||||
static ForgeDirection cullFace(int bits) {
|
||||
return ModelHelper.faceFromIndex((bits >>> CULL_SHIFT) & DIRECTION_MASK);
|
||||
}
|
||||
|
||||
static int cullFace(int bits, ForgeDirection face) {
|
||||
return (bits & CULL_INVERSE_MASK) | (ModelHelper.toFaceIndex(face) << CULL_SHIFT);
|
||||
}
|
||||
|
||||
static ForgeDirection lightFace(int bits) {
|
||||
return ModelHelper.faceFromIndex((bits >>> LIGHT_SHIFT) & DIRECTION_MASK);
|
||||
}
|
||||
|
||||
static int lightFace(int bits, ForgeDirection face) {
|
||||
return (bits & LIGHT_INVERSE_MASK) | (ModelHelper.toFaceIndex(face) << LIGHT_SHIFT);
|
||||
}
|
||||
|
||||
/** indicate if vertex normal has been set - bits correspond to vertex ordinals. */
|
||||
static int normalFlags(int bits) {
|
||||
return (bits >>> NORMALS_SHIFT) & NORMALS_MASK;
|
||||
}
|
||||
|
||||
/**
|
||||
* I believe this merges a set of flags with the given normal flags.
|
||||
*/
|
||||
public static int normalFlags(int bits, int normalFlags) {
|
||||
|
||||
// (normalFlags & NORMALS_MASK) extracts the bottom four bits
|
||||
// << NORMALS_SHIFT shifts it up to the right spot
|
||||
// (bits & NORMALS_INVERSE_MASK) extracts normals from the bits
|
||||
// The two sets are ORd together and returned
|
||||
return (bits & NORMALS_INVERSE_MASK) | ((normalFlags & NORMALS_MASK) << NORMALS_SHIFT);
|
||||
}
|
||||
|
||||
static int geometryFlags(int bits) {
|
||||
return (bits >>> GEOMETRY_SHIFT) & GEOMETRY_MASK;
|
||||
}
|
||||
|
||||
static int geometryFlags(int bits, int geometryFlags) {
|
||||
return (bits & GEOMETRY_INVERSE_MASK) | ((geometryFlags & GEOMETRY_MASK) << GEOMETRY_SHIFT);
|
||||
}
|
||||
|
||||
static RenderMaterialImpl material(int bits) {
|
||||
return RenderMaterialImpl.byIndex((bits >>> MATERIAL_SHIFT) & MATERIAL_MASK);
|
||||
}
|
||||
|
||||
public static int material(int bits, RenderMaterialImpl material) {
|
||||
return (bits & MATERIAL_INVERSE_MASK) | (material.index() << MATERIAL_SHIFT);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package com.gtnewhorizons.angelica.models;
|
||||
|
||||
import org.antlr.v4.codegen.model.TestSetInline;
|
||||
|
||||
import java.util.BitSet;
|
||||
|
||||
public class Material {
|
||||
|
||||
/**
|
||||
* The following masks control whether the property is enabled.
|
||||
*/
|
||||
|
||||
// If true, renders face as fullbright
|
||||
private static final int EMISSIVE_MASK = 1;
|
||||
private static final int COLOR_MASK = 1 << 1;
|
||||
// If true, uses diffuse shading/shadows
|
||||
private static final int DIFFUSE_MASK = 1 << 2;
|
||||
private static final int AO_MASK = 1 << 3;
|
||||
|
||||
// By default, quads use diffuse shading and AO
|
||||
private static final int DEFAULTS = DIFFUSE_MASK | AO_MASK;
|
||||
|
||||
private int flags = DEFAULTS;
|
||||
|
||||
public void reset() {
|
||||
this.flags = DEFAULTS;
|
||||
}
|
||||
|
||||
private void setMask(int mask, boolean val) {
|
||||
if (val)
|
||||
this.flags |= mask;
|
||||
else
|
||||
this.flags &= ~mask;
|
||||
}
|
||||
|
||||
private boolean getMask(int mask) {
|
||||
return (this.flags & mask) == mask;
|
||||
}
|
||||
|
||||
public void setAO(boolean val) {
|
||||
this.setMask(AO_MASK, val);
|
||||
}
|
||||
|
||||
public boolean getAO() {
|
||||
return getMask(AO_MASK);
|
||||
}
|
||||
|
||||
public void setDiffuse(boolean val) {
|
||||
this.setMask(DIFFUSE_MASK, val);
|
||||
}
|
||||
|
||||
public boolean getDiffuse() {
|
||||
return getMask(DIFFUSE_MASK);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
package com.gtnewhorizons.angelica.models;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import com.gtnewhorizons.angelica.models.json.JsonModel;
|
||||
import com.gtnewhorizons.angelica.models.json.Loader;
|
||||
import com.gtnewhorizons.angelica.models.json.Variant;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectImmutableList;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class MixinModels {
|
||||
|
||||
public static final Variant stoneVariant = new Variant(
|
||||
new ResourceLocation("blocks/stone"),
|
||||
0,
|
||||
0,
|
||||
true
|
||||
);
|
||||
public static JsonModel stoneModel;
|
||||
|
||||
public static void loadModels() {
|
||||
|
||||
stoneModel = Loader.getModel(stoneVariant);
|
||||
}
|
||||
}
|
||||
@@ -3,25 +3,19 @@ package com.gtnewhorizons.angelica.models;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import java.util.Arrays;
|
||||
|
||||
import com.gtnewhorizons.angelica.models.material.RenderMaterial;
|
||||
import com.gtnewhorizons.angelica.models.material.RenderMaterialImpl;
|
||||
import com.gtnewhorizons.angelica.models.renderer.IndigoRenderer;
|
||||
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.util.IIcon;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.joml.Vector3f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import static com.gtnewhorizons.angelica.models.EncodingFormat.*;
|
||||
|
||||
public class NdQuadBuilder {
|
||||
|
||||
// x, y, z, u, v, color, normal, lightmap
|
||||
public static final int INTS_PER_VERTEX = 8;
|
||||
public static final int QUAD_STRIDE = INTS_PER_VERTEX * 4;
|
||||
private static final int HEADER_STRIDE = 2;
|
||||
public static final int X_INDEX = 0;
|
||||
public static final int Y_INDEX = 1;
|
||||
public static final int Z_INDEX = 2;
|
||||
@@ -96,31 +90,30 @@ public class NdQuadBuilder {
|
||||
*/
|
||||
public static float CULL_FACE_EPSILON = 0.00001f;
|
||||
|
||||
private ForgeDirection cullFace = ForgeDirection.UNKNOWN;
|
||||
private ForgeDirection nominalFace = ForgeDirection.UNKNOWN;
|
||||
// Defaults to UP, but only because it can't be UNKNOWN or null
|
||||
private ForgeDirection lightFace = ForgeDirection.UP;
|
||||
// It's called a header, but because I'm lazy it's at the end
|
||||
// The header is an int with flags -------- -------- -------- -GGGNNNN, then an int for the normal
|
||||
private final int[] data = new int[QUAD_STRIDE + HEADER_STRIDE];
|
||||
private int geometry = 0;
|
||||
private int normalFlags = 0;
|
||||
private boolean isGeometryInvalid = true;
|
||||
private int tag = 0;
|
||||
private int colorIndex = -1;
|
||||
final Vector3f faceNormal = new Vector3f();
|
||||
private int packedNormal = 0;
|
||||
public final Material mat = new Material();
|
||||
|
||||
/**
|
||||
* Dumps to {@param out} and returns it.
|
||||
*/
|
||||
public Quad build(Quad out) {
|
||||
|
||||
/*out.setState(
|
||||
data,
|
||||
0,
|
||||
new BlockRenderer.Flags(true, false, this.colorIndex != -1, false),
|
||||
GL11.GL_QUADS,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
);*/
|
||||
// FRAPI does this late, but we need to do it before baking to Nd quads
|
||||
this.computeGeometry();
|
||||
out.setRaw(this.data, this.hasShade(), this.cullFace(), this.colorIndex, this.data[QUAD_STRIDE + HEADER_BITS]);
|
||||
out.setRaw(this.data, this.hasShade(), this.cullFace(), this.colorIndex, this.data[QUAD_STRIDE]);
|
||||
this.clear();
|
||||
return out;
|
||||
}
|
||||
@@ -128,13 +121,15 @@ public class NdQuadBuilder {
|
||||
public void clear() {
|
||||
|
||||
Arrays.fill(this.data, 0);
|
||||
this.isGeometryInvalid = true;
|
||||
this.cullFace = ForgeDirection.UNKNOWN;
|
||||
this.nominalFace = ForgeDirection.UNKNOWN;
|
||||
this.normalFlags(0);
|
||||
this.lightFace = ForgeDirection.UP;
|
||||
this.geometry = 0;
|
||||
this.normalFlags = 0;
|
||||
this.isGeometryInvalid = true;
|
||||
this.tag(0);
|
||||
this.colorIndex(-1);
|
||||
this.cullFace(null);
|
||||
this.material(IndigoRenderer.MATERIAL_STANDARD);
|
||||
this.mat.reset();
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -163,29 +158,28 @@ public class NdQuadBuilder {
|
||||
}
|
||||
|
||||
private void computeGeometry() {
|
||||
if (isGeometryInvalid) {
|
||||
isGeometryInvalid = false;
|
||||
if (this.isGeometryInvalid) {
|
||||
this.isGeometryInvalid = false;
|
||||
|
||||
NormalHelper.computeFaceNormal(faceNormal, this);
|
||||
this.data[QUAD_STRIDE + HEADER_FACE_NORMAL] = NormalHelper.packNormal(this.faceNormal);
|
||||
NormalHelper.computeFaceNormal(this.faceNormal, this);
|
||||
this.packedNormal = NormalHelper.packNormal(this.faceNormal);
|
||||
|
||||
// depends on face normal
|
||||
this.data[QUAD_STRIDE +HEADER_BITS] = EncodingFormat.lightFace(this.data[QUAD_STRIDE +HEADER_BITS], GeometryHelper.lightFace(this));
|
||||
this.lightFace = GeometryHelper.lightFace(this);
|
||||
|
||||
// depends on light face
|
||||
this.data[QUAD_STRIDE +HEADER_BITS] = EncodingFormat.geometryFlags(this.data[QUAD_STRIDE +HEADER_BITS], GeometryHelper.computeShapeFlags(this));
|
||||
this.geometry = GeometryHelper.computeShapeFlags(this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* If non-null, quad should not be rendered in-world if the
|
||||
* If not {@link ForgeDirection#UNKNOWN}, quad should not be rendered in-world if the
|
||||
* opposite face of a neighbor block occludes it.
|
||||
*
|
||||
* @see NdQuadBuilder#cullFace(ForgeDirection)
|
||||
*/
|
||||
@Nullable
|
||||
public final ForgeDirection cullFace() {
|
||||
return EncodingFormat.cullFace(this.data[QUAD_STRIDE + HEADER_BITS]);
|
||||
return this.cullFace;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -203,14 +197,14 @@ public class NdQuadBuilder {
|
||||
* is computed based on face geometry and must be non-{@link ForgeDirection#UNKNOWN} in vanilla quads.
|
||||
* That computed value is returned by {@link #lightFace()}.
|
||||
*/
|
||||
public void cullFace(@Nullable ForgeDirection dir) {
|
||||
public void cullFace(ForgeDirection dir) {
|
||||
|
||||
this.data[QUAD_STRIDE + HEADER_BITS] = EncodingFormat.cullFace(this.data[QUAD_STRIDE + HEADER_BITS], dir);
|
||||
this.cullFace = dir;
|
||||
this.nominalFace(dir);
|
||||
}
|
||||
|
||||
private boolean hasShade() {
|
||||
return !this.material().disableDiffuse();
|
||||
return this.mat.getDiffuse();
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -220,28 +214,9 @@ public class NdQuadBuilder {
|
||||
* {@link ForgeDirection#UNKNOWN} or null.
|
||||
*/
|
||||
@NotNull
|
||||
ForgeDirection lightFace() {
|
||||
public ForgeDirection lightFace() {
|
||||
this.computeGeometry();
|
||||
return EncodingFormat.lightFace(this.data[QUAD_STRIDE + HEADER_BITS]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the material serialized with the quad.
|
||||
*/
|
||||
public final RenderMaterialImpl material() {
|
||||
return EncodingFormat.material(this.data[QUAD_STRIDE + HEADER_BITS]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Assigns a different material to this quad. Useful for transformation of
|
||||
* existing meshes because lighting and texture blending are controlled by material.
|
||||
*/
|
||||
public final void material(RenderMaterial material) {
|
||||
if (material == null) {
|
||||
material = IndigoRenderer.MATERIAL_STANDARD;
|
||||
}
|
||||
|
||||
this.data[QUAD_STRIDE + HEADER_BITS] = EncodingFormat.material(this.data[QUAD_STRIDE + HEADER_BITS], (RenderMaterialImpl) material);
|
||||
return this.lightFace;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -271,8 +246,9 @@ public class NdQuadBuilder {
|
||||
/**
|
||||
* Sets the normal flags.
|
||||
*/
|
||||
private void normalFlags(int flags) {
|
||||
this.data[QUAD_STRIDE + HEADER_BITS] = EncodingFormat.normalFlags(this.data[QUAD_STRIDE + HEADER_BITS], flags);
|
||||
private void normalFlags(int normalFlags) {
|
||||
|
||||
this.normalFlags = normalFlags;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -341,7 +317,7 @@ public class NdQuadBuilder {
|
||||
cullFace(nominalFace);
|
||||
depth = 0; // avoid any inconsistency for face quads
|
||||
} else {
|
||||
cullFace(null);
|
||||
cullFace(ForgeDirection.UNKNOWN);
|
||||
}
|
||||
|
||||
nominalFace(nominalFace);
|
||||
@@ -384,6 +360,10 @@ public class NdQuadBuilder {
|
||||
}
|
||||
}
|
||||
|
||||
public int tag() {
|
||||
return this.tag;
|
||||
}
|
||||
|
||||
/**
|
||||
* Encodes an integer tag with this quad that can later be retrieved via
|
||||
* {@link NdQuadBuilder#tag()}. Useful for models that want to perform conditional
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.fapi;
|
||||
|
||||
/**
|
||||
* Represents a function that accepts a boolean-valued argument and produces a result.
|
||||
*
|
||||
* <p>This is the {@code boolean}-consuming primitive specialization for {@link java.util.function.Function}.
|
||||
*/
|
||||
@FunctionalInterface
|
||||
public interface BooleanFunction<R> {
|
||||
/**
|
||||
* Applies this function to the given argument.
|
||||
*
|
||||
* @param value the function argument
|
||||
* @return the function result
|
||||
*/
|
||||
R apply(boolean value);
|
||||
}
|
||||
@@ -1,122 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.fapi;
|
||||
|
||||
import javax.annotation.Nullable;
|
||||
import java.util.Objects;
|
||||
import java.util.Optional;
|
||||
import java.util.function.BooleanSupplier;
|
||||
import java.util.function.Supplier;
|
||||
|
||||
/**
|
||||
* Represents a boolean value which can be true, false or refer to a default value.
|
||||
*/
|
||||
public enum TriState {
|
||||
/**
|
||||
* Represents the boolean value of {@code false}.
|
||||
*/
|
||||
FALSE,
|
||||
/**
|
||||
* Represents a value that refers to a "default" value, often as a fallback.
|
||||
*/
|
||||
DEFAULT,
|
||||
/**
|
||||
* Represents the boolean value of {@code true}.
|
||||
*/
|
||||
TRUE;
|
||||
|
||||
/**
|
||||
* Gets the corresponding tri-state from a boolean value.
|
||||
*
|
||||
* @param bool the boolean value
|
||||
* @return {@link TriState#TRUE} or {@link TriState#FALSE} depending on the value of the boolean.
|
||||
*/
|
||||
public static TriState of(boolean bool) {
|
||||
return bool ? TRUE : FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a tri-state from a nullable boxed boolean.
|
||||
*
|
||||
* @param bool the boolean value
|
||||
* @return {@link TriState#DEFAULT} if {@code null}.
|
||||
* Otherwise {@link TriState#TRUE} or {@link TriState#FALSE} depending on the value of the boolean.
|
||||
*/
|
||||
public static TriState of(@Nullable Boolean bool) {
|
||||
return bool == null ? DEFAULT : of(bool.booleanValue());
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value of the tri-state.
|
||||
*
|
||||
* @return true if the tri-state is {@link TriState#TRUE},
|
||||
* otherwise false.
|
||||
*/
|
||||
public boolean get() {
|
||||
return this == TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value of the tri-state as a boxed, nullable boolean.
|
||||
*
|
||||
* @return {@code null} if {@link TriState#DEFAULT}.
|
||||
* Otherwise {@code true} if {@link TriState#TRUE} or {@code false} if {@link TriState#FALSE}.
|
||||
*/
|
||||
@Nullable
|
||||
public Boolean getBoxed() {
|
||||
return this == DEFAULT ? null : this.get();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value of this tri-state.
|
||||
* If the value is {@link TriState#DEFAULT} then use the supplied value.
|
||||
*
|
||||
* @param value the value to fall back to
|
||||
* @return the value of the tri-state or the supplied value if {@link TriState#DEFAULT}.
|
||||
*/
|
||||
public boolean orElse(boolean value) {
|
||||
return this == DEFAULT ? value : this.get();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value of this tri-state.
|
||||
* If the value is {@link TriState#DEFAULT} then use the supplied value.
|
||||
*
|
||||
* @param supplier the supplier used to get the value to fall back to
|
||||
* @return the value of the tri-state or the value of the supplier if the tri-state is {@link TriState#DEFAULT}.
|
||||
*/
|
||||
public boolean orElseGet(BooleanSupplier supplier) {
|
||||
return this == DEFAULT ? supplier.getAsBoolean() : this.get();
|
||||
}
|
||||
|
||||
/**
|
||||
* Maps the boolean value of this tri-state if it is {@link TriState#TRUE} or {@link TriState#FALSE}.
|
||||
*
|
||||
* @param mapper the mapper to use
|
||||
* @param <T> the type of object being supplier by the mapper
|
||||
* @return an optional containing the mapped value; {@link Optional#empty()} if the tri-state is {@link TriState#DEFAULT} or the value provided by the mapper is {@code null}.
|
||||
*/
|
||||
public <T> Optional<T> map(BooleanFunction<? extends T> mapper) {
|
||||
Objects.requireNonNull(mapper, "Mapper function cannot be null");
|
||||
|
||||
if (this == DEFAULT) {
|
||||
return Optional.empty();
|
||||
}
|
||||
|
||||
return Optional.ofNullable(mapper.apply(this.get()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value of this tri-state, or throws an exception if this tri-state's value is {@link TriState#DEFAULT}.
|
||||
*
|
||||
* @param exceptionSupplier the supplying function that produces an exception to be thrown
|
||||
* @param <X> Type of the exception to be thrown
|
||||
* @return the value
|
||||
* @throws X if the value is {@link TriState#DEFAULT}
|
||||
*/
|
||||
public <X extends Throwable> boolean orElseThrow(Supplier<X> exceptionSupplier) throws X {
|
||||
if (this != DEFAULT) {
|
||||
return this.get();
|
||||
}
|
||||
|
||||
throw exceptionSupplier.get();
|
||||
}
|
||||
}
|
||||
@@ -11,9 +11,6 @@ import com.gtnewhorizons.angelica.compat.mojang.Axis;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import com.gtnewhorizons.angelica.models.NdQuadBuilder;
|
||||
import com.gtnewhorizons.angelica.models.fapi.TriState;
|
||||
import com.gtnewhorizons.angelica.models.material.RenderMaterial;
|
||||
import com.gtnewhorizons.angelica.models.renderer.IndigoRenderer;
|
||||
import com.gtnewhorizons.angelica.utils.DirUtil;
|
||||
import com.gtnewhorizons.angelica.utils.ObjectPooler;
|
||||
import it.unimi.dsi.fastutil.Function;
|
||||
@@ -52,8 +49,9 @@ public class JsonModel implements QuadProvider {
|
||||
private final Map<ModelDisplay.Position, ModelDisplay> display;
|
||||
private final Map<String, String> textures;
|
||||
private List<ModelElement> elements;
|
||||
// TODO: Make a sided list
|
||||
private List<Quad> bakedQuadStore = new ObjectArrayList<>();
|
||||
private List<Quad> allQuadStore = new ObjectArrayList<>();
|
||||
private final Map<ForgeDirection, List<Quad>> sidedQuadStore = new Object2ObjectOpenHashMap<>();
|
||||
private static final List<Quad> EMPTY = ObjectImmutableList.of();
|
||||
|
||||
JsonModel(@Nullable ResourceLocation parentId, boolean useAO, Map<ModelDisplay.Position, ModelDisplay> display, Map<String, String> textures, List<ModelElement> elements) {
|
||||
this.parentId = parentId;
|
||||
@@ -81,14 +79,13 @@ public class JsonModel implements QuadProvider {
|
||||
final Matrix4f vRot = v.getAffineMatrix();
|
||||
|
||||
final NdQuadBuilder builder = new NdQuadBuilder();
|
||||
final RenderMaterial mat =
|
||||
IndigoRenderer.INSTANCE.materialFinder().ambientOcclusion(TriState.of(this.useAO)).find();
|
||||
|
||||
// Append faces from each element
|
||||
for (ModelElement e : this.elements) {
|
||||
|
||||
final Matrix4f rot = (e.getRotation() == null) ? ModelElement.Rotation.NOOP.getAffineMatrix() : e.getRotation().getAffineMatrix();
|
||||
//rot.mulLocal(vRot);
|
||||
final Matrix4f rot = (e.getRotation() == null)
|
||||
? ModelElement.Rotation.NOOP.getAffineMatrix()
|
||||
: e.getRotation().getAffineMatrix();
|
||||
|
||||
final Vector3f from = e.getFrom();
|
||||
final Vector3f to = e.getTo();
|
||||
@@ -98,7 +95,8 @@ public class JsonModel implements QuadProvider {
|
||||
// Assign vertexes
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
|
||||
final Vector3f vert = rot.transformPosition(NdQuadBuilder.mapSideToVertex(from, to, i, f.getName()));
|
||||
final Vector3f vert =
|
||||
rot.transformPosition(NdQuadBuilder.mapSideToVertex(from, to, i, f.getName()));
|
||||
vRot.transformPosition(vert);
|
||||
builder.pos(i, vert.x, vert.y, vert.z);
|
||||
}
|
||||
@@ -137,14 +135,17 @@ public class JsonModel implements QuadProvider {
|
||||
builder.color(tint, tint, tint, tint);
|
||||
|
||||
// Set AO
|
||||
builder.material(mat);
|
||||
builder.mat.setAO(this.useAO);
|
||||
|
||||
// Bake and add it
|
||||
this.bakedQuadStore.add(builder.build(new Quad()));
|
||||
final Quad q = builder.build(new Quad());
|
||||
this.allQuadStore.add(q);
|
||||
this.sidedQuadStore.computeIfAbsent(f.getCullFace(),
|
||||
o -> new ObjectArrayList<>()).add(q);
|
||||
}
|
||||
}
|
||||
|
||||
this.bakedQuadStore = new ObjectImmutableList<>(this.bakedQuadStore);
|
||||
this.allQuadStore = new ObjectImmutableList<>(this.allQuadStore);
|
||||
}
|
||||
|
||||
public List<ResourceLocation> getParents() {
|
||||
@@ -154,12 +155,13 @@ public class JsonModel implements QuadProvider {
|
||||
@Override
|
||||
public List<Quad> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, ObjectPooler<Quad> quadPool) {
|
||||
|
||||
final List<Quad> ret = new ObjectArrayList<>(this.bakedQuadStore.size());
|
||||
final List<Quad> src = this.sidedQuadStore.getOrDefault(dir, EMPTY);
|
||||
final List<Quad> ret = new ObjectArrayList<>(src.size());
|
||||
|
||||
//noinspection ForLoopReplaceableByForEach
|
||||
for (int i = 0; i < bakedQuadStore.size(); ++i) {
|
||||
for (int i = 0; i < src.size(); ++i) {
|
||||
final Quad q = quadPool.getInstance();
|
||||
q.copyFrom(this.bakedQuadStore.get(i));
|
||||
q.copyFrom(src.get(i));
|
||||
ret.add(q);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,56 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.material;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
|
||||
|
||||
/**
|
||||
* Defines how sprite pixels will be blended with the scene.
|
||||
*/
|
||||
public enum BlendMode {
|
||||
/**
|
||||
* Emulate blending behavior of {@code BlockRenderLayer} associated with the block.
|
||||
*/
|
||||
DEFAULT(null),
|
||||
|
||||
/**
|
||||
* Fully opaque with depth test, no blending. Used for most normal blocks.
|
||||
*/
|
||||
SOLID(RenderLayer.solid()),
|
||||
|
||||
/**
|
||||
* Pixels with alpha > 0.5 are rendered as if {@code SOLID}. Other pixels are not rendered.
|
||||
* Texture mip-map enabled. Used for leaves on modern, unused in 1.7.10.
|
||||
*/
|
||||
//CUTOUT_MIPPED(RenderLayer.cutout()),
|
||||
|
||||
/**
|
||||
* Pixels with alpha > 0.5 are rendered as if {@code SOLID}. Other pixels are not rendered.
|
||||
* Texture mip-map disabled. Used for iron bars, glass and other cutout sprites with hard edges.
|
||||
*/
|
||||
CUTOUT(RenderLayer.cutout()),
|
||||
|
||||
/**
|
||||
* Pixels are blended with the background according to alpha color values. Some performance cost,
|
||||
* use in moderation. Texture mip-map enabled. Used for stained glass.
|
||||
*/
|
||||
TRANSLUCENT(RenderLayer.translucent());
|
||||
|
||||
public final RenderLayer blockRenderLayer;
|
||||
|
||||
BlendMode(RenderLayer blockRenderLayer) {
|
||||
this.blockRenderLayer = blockRenderLayer;
|
||||
}
|
||||
|
||||
public static BlendMode fromRenderLayer(RenderLayer renderLayer) {
|
||||
if (renderLayer == RenderLayer.solid()) {
|
||||
return SOLID;
|
||||
/*} else if (renderLayer == RenderLayer.getCutoutMipped()) {
|
||||
return CUTOUT_MIPPED;*/
|
||||
} else if (renderLayer == RenderLayer.cutout()) {
|
||||
return CUTOUT;
|
||||
} else if (renderLayer == RenderLayer.translucent()) {
|
||||
return TRANSLUCENT;
|
||||
} else {
|
||||
return DEFAULT;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,156 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.material;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
|
||||
import com.gtnewhorizons.angelica.models.renderer.IndigoRenderer;
|
||||
import com.gtnewhorizons.angelica.models.NdQuadBuilder;
|
||||
import com.gtnewhorizons.angelica.models.fapi.TriState;
|
||||
import com.gtnewhorizons.angelica.models.json.JsonModel;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.item.ItemStack;
|
||||
|
||||
/**
|
||||
* Finds standard {@link RenderMaterial} instances used to communicate
|
||||
* quad rendering characteristics to a {@link RenderContext}.
|
||||
*
|
||||
* <p>Must be obtained via {@link IndigoRenderer#materialFinder()}.
|
||||
*/
|
||||
public interface MaterialFinder extends MaterialView {
|
||||
/**
|
||||
* Defines how sprite pixels will be blended with the scene.
|
||||
*
|
||||
* <p>See {@link BlendMode} for more information.
|
||||
*/
|
||||
MaterialFinder blendMode(BlendMode blendMode);
|
||||
|
||||
/**
|
||||
* Vertex color(s) will be modified for quad color index unless disabled.
|
||||
*/
|
||||
MaterialFinder disableColorIndex(boolean disable);
|
||||
|
||||
/**
|
||||
* When true, sprite texture and color will be rendered at full brightness.
|
||||
* Lightmap values provided via {@link NdQuadBuilder#lightmap(int)} will be ignored.
|
||||
* False by default
|
||||
*
|
||||
* <p>This is the preferred method for emissive lighting effects. Some renderers
|
||||
* with advanced lighting models may not use block lightmaps and this method will
|
||||
* allow per-sprite emissive lighting in future extensions that support overlay sprites.
|
||||
*
|
||||
* <p>Note that color will still be modified by diffuse shading and ambient occlusion,
|
||||
* unless disabled via {@link #disableDiffuse(boolean)} and {@link #ambientOcclusion(TriState)}.
|
||||
*/
|
||||
MaterialFinder emissive(boolean isEmissive);
|
||||
|
||||
/**
|
||||
* Vertex color(s) will be modified for diffuse shading unless disabled.
|
||||
*
|
||||
* <p>This property is guaranteed to be respected in block contexts. Some renderers may also respect it in item
|
||||
* contexts, but this is not guaranteed.
|
||||
*/
|
||||
MaterialFinder disableDiffuse(boolean disable);
|
||||
|
||||
/**
|
||||
* Controls whether vertex color(s) will be modified for ambient occlusion.
|
||||
*
|
||||
* <p>By default, ambient occlusion will be used if {@link JsonModel#isUseAO() the model uses ambient occlusion}
|
||||
* and the block has {@link Block#getLightValue() a luminance} of 0.
|
||||
* Set to {@link TriState#TRUE} or {@link TriState#FALSE} to override this behavior.
|
||||
*
|
||||
* <p>This property is respected only in block contexts. It will not have an effect in other contexts.
|
||||
*/
|
||||
MaterialFinder ambientOcclusion(TriState mode);
|
||||
|
||||
/**
|
||||
* Controls whether glint should be applied.
|
||||
*
|
||||
* <p>By default, glint will be applied in item contexts if {@link ItemStack#isItemEnchanted()} the item stack has glint}.
|
||||
* Set to {@link TriState#TRUE} or {@link TriState#FALSE} to override this behavior.
|
||||
*
|
||||
* <p>This property is guaranteed to be respected in item contexts. Some renderers may also respect it in block
|
||||
* contexts, but this is not guaranteed.
|
||||
*/
|
||||
MaterialFinder glint(TriState mode);
|
||||
|
||||
/**
|
||||
* Copies all properties from the given {@link MaterialView} to this material finder.
|
||||
*/
|
||||
MaterialFinder copyFrom(MaterialView material);
|
||||
|
||||
/**
|
||||
* Resets this instance to default values. Values will match those
|
||||
* in effect when an instance is newly obtained via {@link IndigoRenderer#materialFinder()}.
|
||||
*/
|
||||
MaterialFinder clear();
|
||||
|
||||
/**
|
||||
* Returns the standard material encoding all
|
||||
* of the current settings in this finder. The settings in
|
||||
* this finder are not changed.
|
||||
*
|
||||
* <p>Resulting instances can and should be re-used to prevent
|
||||
* needless memory allocation. {@link IndigoRenderer} implementations
|
||||
* may or may not cache standard material instances.
|
||||
*/
|
||||
RenderMaterial find();
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link #blendMode(BlendMode)} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
default MaterialFinder blendMode(int spriteIndex, RenderLayer renderLayer) {
|
||||
return blendMode(BlendMode.fromRenderLayer(renderLayer));
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link #blendMode(BlendMode)} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
default MaterialFinder blendMode(int spriteIndex, BlendMode blendMode) {
|
||||
// Null check is kept for legacy reasons, but the new blendMode method will NPE if passed null!
|
||||
if (blendMode == null) {
|
||||
blendMode = BlendMode.DEFAULT;
|
||||
}
|
||||
|
||||
return blendMode(blendMode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link #disableColorIndex(boolean)} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
default MaterialFinder disableColorIndex(int spriteIndex, boolean disable) {
|
||||
return disableColorIndex(disable);
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link #emissive(boolean)} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
default MaterialFinder emissive(int spriteIndex, boolean isEmissive) {
|
||||
return emissive(isEmissive);
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link #disableDiffuse(boolean)} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
default MaterialFinder disableDiffuse(int spriteIndex, boolean disable) {
|
||||
return disableDiffuse(disable);
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link #ambientOcclusion(TriState)} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
default MaterialFinder disableAo(int spriteIndex, boolean disable) {
|
||||
return ambientOcclusion(disable ? TriState.FALSE : TriState.DEFAULT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Do not use. Does nothing.
|
||||
*/
|
||||
@Deprecated
|
||||
default MaterialFinder spriteDepth(int depth) {
|
||||
return this;
|
||||
}
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.material;
|
||||
|
||||
import com.gtnewhorizons.angelica.models.fapi.TriState;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
public class MaterialFinderImpl extends MaterialViewImpl implements MaterialFinder {
|
||||
private static int defaultBits = 0;
|
||||
|
||||
static {
|
||||
MaterialFinderImpl finder = new MaterialFinderImpl();
|
||||
finder.ambientOcclusion(TriState.DEFAULT);
|
||||
finder.glint(TriState.DEFAULT);
|
||||
defaultBits = finder.bits;
|
||||
|
||||
if (!areBitsValid(defaultBits)) {
|
||||
throw new AssertionError("Default MaterialFinder bits are not valid!");
|
||||
}
|
||||
}
|
||||
|
||||
public MaterialFinderImpl() {
|
||||
super(defaultBits);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MaterialFinder blendMode(BlendMode blendMode) {
|
||||
Objects.requireNonNull(blendMode, "BlendMode may not be null");
|
||||
|
||||
bits = (bits & ~BLEND_MODE_MASK) | (blendMode.ordinal() << BLEND_MODE_BIT_OFFSET);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MaterialFinder disableColorIndex(boolean disable) {
|
||||
bits = disable ? (bits | COLOR_DISABLE_FLAG) : (bits & ~COLOR_DISABLE_FLAG);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MaterialFinder emissive(boolean isEmissive) {
|
||||
bits = isEmissive ? (bits | EMISSIVE_FLAG) : (bits & ~EMISSIVE_FLAG);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MaterialFinder disableDiffuse(boolean disable) {
|
||||
bits = disable ? (bits | DIFFUSE_FLAG) : (bits & ~DIFFUSE_FLAG);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MaterialFinder ambientOcclusion(TriState mode) {
|
||||
Objects.requireNonNull(mode, "ambient occlusion TriState may not be null");
|
||||
|
||||
bits = (bits & ~AO_MASK) | (mode.ordinal() << AO_BIT_OFFSET);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MaterialFinder glint(TriState mode) {
|
||||
Objects.requireNonNull(mode, "glint TriState may not be null");
|
||||
|
||||
bits = (bits & ~GLINT_MASK) | (mode.ordinal() << GLINT_BIT_OFFSET);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MaterialFinder copyFrom(MaterialView material) {
|
||||
bits = ((MaterialViewImpl) material).bits;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MaterialFinder clear() {
|
||||
bits = defaultBits;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RenderMaterial find() {
|
||||
return RenderMaterialImpl.byIndex(bits);
|
||||
}
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.material;
|
||||
|
||||
import com.gtnewhorizons.angelica.models.fapi.TriState;
|
||||
|
||||
/**
|
||||
* Getter methods for {@link RenderMaterial} (immutable) and {@link MaterialFinder} (mutable).
|
||||
*
|
||||
* <p>Values returned by the getters may not necessarily be identical to those requested in the {@link MaterialFinder}.
|
||||
* The renderer may choose different values that are sufficiently representative for its own processing.
|
||||
*/
|
||||
public interface MaterialView {
|
||||
/**
|
||||
* @see MaterialFinder#blendMode(BlendMode)
|
||||
*/
|
||||
BlendMode blendMode();
|
||||
|
||||
/**
|
||||
* @see MaterialFinder#disableColorIndex(boolean)
|
||||
*/
|
||||
boolean disableColorIndex();
|
||||
|
||||
/**
|
||||
* @see MaterialFinder#emissive(boolean)
|
||||
*/
|
||||
boolean emissive();
|
||||
|
||||
/**
|
||||
* @see MaterialFinder#disableDiffuse(boolean)
|
||||
*/
|
||||
boolean disableDiffuse();
|
||||
|
||||
/**
|
||||
* @see MaterialFinder#ambientOcclusion(TriState)
|
||||
*/
|
||||
TriState ambientOcclusion();
|
||||
|
||||
/**
|
||||
* @see MaterialFinder#glint(TriState)
|
||||
*/
|
||||
TriState glint();
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.material;
|
||||
|
||||
import com.gtnewhorizons.angelica.models.fapi.TriState;
|
||||
import net.minecraft.util.MathHelper;
|
||||
|
||||
/**
|
||||
* Default implementation of the standard render materials.
|
||||
* The underlying representation is simply an int with bit-wise
|
||||
* packing of the various material properties. This offers
|
||||
* easy/fast interning via int/object hashmap.
|
||||
*/
|
||||
public class MaterialViewImpl implements MaterialView {
|
||||
private static final BlendMode[] BLEND_MODES = BlendMode.values();
|
||||
private static final int BLEND_MODE_COUNT = BLEND_MODES.length;
|
||||
private static final TriState[] TRI_STATES = TriState.values();
|
||||
private static final int TRI_STATE_COUNT = TRI_STATES.length;
|
||||
|
||||
protected static final int BLEND_MODE_BIT_LENGTH = MathHelper.calculateLogBaseTwoDeBruijn(BLEND_MODE_COUNT);
|
||||
protected static final int COLOR_DISABLE_BIT_LENGTH = 1;
|
||||
protected static final int EMISSIVE_BIT_LENGTH = 1;
|
||||
protected static final int DIFFUSE_BIT_LENGTH = 1;
|
||||
protected static final int AO_BIT_LENGTH = MathHelper.calculateLogBaseTwoDeBruijn(TRI_STATE_COUNT);
|
||||
protected static final int GLINT_BIT_LENGTH = MathHelper.calculateLogBaseTwoDeBruijn(TRI_STATE_COUNT);
|
||||
|
||||
protected static final int BLEND_MODE_BIT_OFFSET = 0;
|
||||
protected static final int COLOR_DISABLE_BIT_OFFSET = BLEND_MODE_BIT_OFFSET + BLEND_MODE_BIT_LENGTH;
|
||||
protected static final int EMISSIVE_BIT_OFFSET = COLOR_DISABLE_BIT_OFFSET + COLOR_DISABLE_BIT_LENGTH;
|
||||
protected static final int DIFFUSE_BIT_OFFSET = EMISSIVE_BIT_OFFSET + EMISSIVE_BIT_LENGTH;
|
||||
protected static final int AO_BIT_OFFSET = DIFFUSE_BIT_OFFSET + DIFFUSE_BIT_LENGTH;
|
||||
protected static final int GLINT_BIT_OFFSET = AO_BIT_OFFSET + AO_BIT_LENGTH;
|
||||
protected static final int TOTAL_BIT_LENGTH = GLINT_BIT_OFFSET + GLINT_BIT_LENGTH;
|
||||
|
||||
protected static final int BLEND_MODE_MASK = bitMask(BLEND_MODE_BIT_LENGTH, BLEND_MODE_BIT_OFFSET);
|
||||
protected static final int COLOR_DISABLE_FLAG = bitMask(COLOR_DISABLE_BIT_LENGTH, COLOR_DISABLE_BIT_OFFSET);
|
||||
protected static final int EMISSIVE_FLAG = bitMask(EMISSIVE_BIT_LENGTH, EMISSIVE_BIT_OFFSET);
|
||||
protected static final int DIFFUSE_FLAG = bitMask(DIFFUSE_BIT_LENGTH, DIFFUSE_BIT_OFFSET);
|
||||
protected static final int AO_MASK = bitMask(AO_BIT_LENGTH, AO_BIT_OFFSET);
|
||||
protected static final int GLINT_MASK = bitMask(GLINT_BIT_LENGTH, GLINT_BIT_OFFSET);
|
||||
|
||||
protected static int bitMask(int bitLength, int bitOffset) {
|
||||
return ((1 << bitLength) - 1) << bitOffset;
|
||||
}
|
||||
|
||||
protected static boolean areBitsValid(int bits) {
|
||||
int blendMode = (bits & BLEND_MODE_MASK) >>> BLEND_MODE_BIT_OFFSET;
|
||||
int ao = (bits & AO_MASK) >>> AO_BIT_OFFSET;
|
||||
int glint = (bits & GLINT_MASK) >>> GLINT_BIT_OFFSET;
|
||||
|
||||
return blendMode < BLEND_MODE_COUNT
|
||||
&& ao < TRI_STATE_COUNT
|
||||
&& glint < TRI_STATE_COUNT;
|
||||
}
|
||||
|
||||
protected int bits;
|
||||
|
||||
protected MaterialViewImpl(int bits) {
|
||||
this.bits = bits;
|
||||
}
|
||||
|
||||
@Override
|
||||
public BlendMode blendMode() {
|
||||
return BLEND_MODES[(bits & BLEND_MODE_MASK) >>> BLEND_MODE_BIT_OFFSET];
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean disableColorIndex() {
|
||||
return (bits & COLOR_DISABLE_FLAG) != 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean emissive() {
|
||||
return (bits & EMISSIVE_FLAG) != 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean disableDiffuse() {
|
||||
return (bits & DIFFUSE_FLAG) != 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public TriState ambientOcclusion() {
|
||||
return TRI_STATES[(bits & AO_MASK) >>> AO_BIT_OFFSET];
|
||||
}
|
||||
|
||||
@Override
|
||||
public TriState glint() {
|
||||
return TRI_STATES[(bits & GLINT_MASK) >>> GLINT_BIT_OFFSET];
|
||||
}
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.material;
|
||||
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraft.block.Block;
|
||||
|
||||
/**
|
||||
* All model quads have an associated render material governing
|
||||
* how the quad will be rendered.
|
||||
*
|
||||
* <p>A material instance is always immutable and thread-safe. References to a material
|
||||
* remain valid until the end of the current game session.
|
||||
*
|
||||
* <p>Materials can be registered and shared between mods using {@link Renderer#registerMaterial(net.minecraft.util.Identifier, RenderMaterial)}.
|
||||
* The registering mod is responsible for creating each registered material at startup.
|
||||
*
|
||||
* <p>Materials are not required to know their registration identity, and two materials
|
||||
* with the same attributes may or may not satisfy equality and identity tests. Model
|
||||
* implementations should never attempt to analyze materials or implement control logic based on them.
|
||||
* They are only tokens for communicating quad attributes to the ModelRenderer.
|
||||
*
|
||||
* <p>There are three classes of materials...
|
||||
*
|
||||
* <p><b>STANDARD MATERIALS</b>
|
||||
*
|
||||
* <p>Standard materials have "normal" rendering with control over lighting,
|
||||
* color, and texture blending. In the default renderer, "normal" rendering
|
||||
* emulates unmodified Minecraft. Other renderers may offer a different aesthetic.
|
||||
*
|
||||
* <p>The number of standard materials is finite, but not necessarily small.
|
||||
* To find a standard material, use {@link Renderer#materialFinder()}.
|
||||
*
|
||||
* <p>All renderer implementations should support standard materials.
|
||||
*
|
||||
* <p><b>SPECIAL MATERIALS</b>
|
||||
*
|
||||
* <p>Special materials are implemented directly by the Renderer implementation, typically
|
||||
* with the aim of providing advanced/extended features. Such materials may offer additional
|
||||
* vertex attributes via extensions to {@link MeshBuilder} and {@link MutableQuadView}.
|
||||
*
|
||||
* <p>Special materials can be obtained using {@link Renderer#materialById(Identifier)}
|
||||
* with a known identifier. Renderers may provide other means of access. Popular
|
||||
* special materials could be implemented by multiple renderers, however there is
|
||||
* no requirement that special materials be cross-compatible.
|
||||
*/
|
||||
public interface RenderMaterial extends MaterialView {
|
||||
/**
|
||||
* This will be identical to the material that would be obtained by calling {@link MaterialFinder#find()}
|
||||
* on a new, unaltered, {@link MaterialFinder} instance. It is defined here for clarity and convenience.
|
||||
*
|
||||
* <p>Quads using this material use {@link Block#getRenderBlockPass()} of
|
||||
* the associated block to determine texture blending, honor block color index, are non-emissive, and apply both
|
||||
* diffuse and ambient occlusion shading to vertex colors.
|
||||
*
|
||||
* <p>All standard, non-fluid baked models are rendered using this material.
|
||||
*/
|
||||
ResourceLocation MATERIAL_STANDARD = new ResourceLocation("fabric", "standard");
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.material;
|
||||
|
||||
public class RenderMaterialImpl extends MaterialViewImpl implements RenderMaterial {
|
||||
public static final int VALUE_COUNT = 1 << TOTAL_BIT_LENGTH;
|
||||
private static final RenderMaterialImpl[] BY_INDEX = new RenderMaterialImpl[VALUE_COUNT];
|
||||
|
||||
static {
|
||||
for (int i = 0; i < VALUE_COUNT; i++) {
|
||||
if (areBitsValid(i)) {
|
||||
BY_INDEX[i] = new RenderMaterialImpl(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private RenderMaterialImpl(int bits) {
|
||||
super(bits);
|
||||
}
|
||||
|
||||
public int index() {
|
||||
return bits;
|
||||
}
|
||||
|
||||
public static RenderMaterialImpl byIndex(int index) {
|
||||
return BY_INDEX[index];
|
||||
}
|
||||
|
||||
public static RenderMaterialImpl setDisableDiffuse(RenderMaterialImpl material, boolean disable) {
|
||||
if (material.disableDiffuse() != disable) {
|
||||
return byIndex(disable ? (material.bits | DIFFUSE_FLAG) : (material.bits & ~DIFFUSE_FLAG));
|
||||
}
|
||||
|
||||
return material;
|
||||
}
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.models.renderer;
|
||||
|
||||
import com.gtnewhorizons.angelica.models.material.MaterialFinder;
|
||||
import com.gtnewhorizons.angelica.models.material.MaterialFinderImpl;
|
||||
import com.gtnewhorizons.angelica.models.material.RenderMaterial;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
||||
/**
|
||||
* The Fabric default renderer implementation. Supports all
|
||||
* features defined in the API except shaders and offers no special materials.
|
||||
*/
|
||||
public class IndigoRenderer {
|
||||
public static final IndigoRenderer INSTANCE = new IndigoRenderer();
|
||||
|
||||
public static final RenderMaterial MATERIAL_STANDARD = INSTANCE.materialFinder().find();
|
||||
|
||||
static {
|
||||
INSTANCE.registerMaterial(RenderMaterial.MATERIAL_STANDARD, MATERIAL_STANDARD);
|
||||
}
|
||||
|
||||
private final HashMap<ResourceLocation, RenderMaterial> materialMap = new HashMap<>();
|
||||
|
||||
private IndigoRenderer() { }
|
||||
|
||||
/**
|
||||
* Obtain a new {@link MaterialFinder} instance used to retrieve
|
||||
* standard {@link RenderMaterial} instances.
|
||||
*
|
||||
* <p>Renderer does not retain a reference to returned instances and they should be re-used for
|
||||
* multiple materials when possible to avoid memory allocation overhead.
|
||||
*/
|
||||
public MaterialFinder materialFinder() {
|
||||
return new MaterialFinderImpl();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a material previously registered via {@link #registerMaterial(ResourceLocation, RenderMaterial)}.
|
||||
* Will return null if no material was found matching the given identifier.
|
||||
*/
|
||||
public RenderMaterial materialById(ResourceLocation id) {
|
||||
return materialMap.get(id);
|
||||
}
|
||||
|
||||
/**
|
||||
* Register a material for re-use by other mods or models within a mod.
|
||||
* The registry does not persist registrations - mods must create and register
|
||||
* all materials at game initialization.
|
||||
*
|
||||
* <p>Returns false if a material with the given identifier is already present,
|
||||
* leaving the existing material intact.
|
||||
*/
|
||||
public boolean registerMaterial(ResourceLocation id, RenderMaterial material) {
|
||||
if (materialMap.containsKey(id)) return false;
|
||||
|
||||
// cast to prevent acceptance of impostor implementations
|
||||
materialMap.put(id, material);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -7,6 +7,7 @@ import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.debug.OpenGLDebugging;
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import com.gtnewhorizons.angelica.models.MixinModels;
|
||||
import com.gtnewhorizons.angelica.models.json.Loader;
|
||||
import com.gtnewhorizons.angelica.render.CloudRenderer;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry;
|
||||
@@ -63,6 +64,7 @@ public class ClientProxy extends CommonProxy {
|
||||
MinecraftForge.EVENT_BUS.register(this);
|
||||
|
||||
Loader.registerModels(BlockTest::loadModel, BlockTest.modelId);
|
||||
Loader.registerModels(MixinModels::loadModels, MixinModels.stoneVariant);
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in new issue
Block a user