mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-22 21:29:44 +00:00
FRAPI materials + NdQuadBuilder performance
Also speed up the offThreadSafety map
This commit is contained in:
1 parent
6d49e82a0c
commit
236a513705
26 files changed
+1195
-140
No files matched your search
@@ -1,6 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.compat.mojang;
|
||||
|
||||
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFacing;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
public enum Axis {
|
||||
X,
|
||||
@@ -14,7 +15,15 @@ public enum Axis {
|
||||
case WEST, EAST -> X;
|
||||
case UNASSIGNED -> null;
|
||||
};
|
||||
}
|
||||
|
||||
public static Axis fromDirection(ForgeDirection dir) {
|
||||
return switch (dir) {
|
||||
case DOWN, UP -> Y;
|
||||
case NORTH, SOUTH -> Z;
|
||||
case WEST, EAST -> X;
|
||||
case UNKNOWN -> null;
|
||||
};
|
||||
}
|
||||
|
||||
public static Axis fromName(String dir) {
|
||||
@@ -26,4 +35,17 @@ public enum Axis {
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
public enum Direction {
|
||||
POSITIVE,
|
||||
NEGATIVE;
|
||||
|
||||
public static Direction fromDirection(ForgeDirection dir) {
|
||||
return switch (dir) {
|
||||
case DOWN, NORTH, WEST -> NEGATIVE;
|
||||
case UP, SOUTH, EAST -> POSITIVE;
|
||||
case UNKNOWN -> null;
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,8 @@
|
||||
package com.gtnewhorizons.angelica.compat.nd;
|
||||
|
||||
import java.util.Locale;
|
||||
|
||||
import lombok.Getter;
|
||||
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadView;
|
||||
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFacing;
|
||||
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFlags;
|
||||
@@ -10,6 +12,8 @@ import net.minecraftforge.common.util.ForgeDirection;
|
||||
import org.joml.Vector3f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import javax.annotation.Nullable;
|
||||
|
||||
public class Quad implements ModelQuadView {
|
||||
// Adapted from Neodymium
|
||||
|
||||
@@ -27,36 +31,20 @@ public class Quad implements ModelQuadView {
|
||||
|
||||
public boolean deleted;
|
||||
|
||||
public ModelQuadFacing normal;
|
||||
|
||||
private final Vector3f vectorA = new Vector3f(), vectorB = new Vector3f(), vectorC = new Vector3f();
|
||||
|
||||
private boolean hasColor;
|
||||
private boolean hasShade;
|
||||
private boolean hasNormals;
|
||||
|
||||
@Getter
|
||||
private boolean shade;
|
||||
private int cachedFlags;
|
||||
private ForgeDirection face;
|
||||
private int colorIndex = -1;
|
||||
|
||||
public boolean hasColor() {
|
||||
return this.hasColor;
|
||||
}
|
||||
|
||||
public int[] getColors() {
|
||||
return this.cs;
|
||||
}
|
||||
|
||||
public boolean hasShade() {
|
||||
return this.hasShade;
|
||||
}
|
||||
|
||||
public boolean hasNormals() {
|
||||
return this.hasNormals;
|
||||
}
|
||||
|
||||
/** Returns the face, forced to take one of 6 directions to mirror the behavior of baked quads in 1.16.5. */
|
||||
public ForgeDirection getCoercedFace() {
|
||||
public ForgeDirection getLightFace() {
|
||||
return this.face != ForgeDirection.UNKNOWN ? this.face : ForgeDirection.UP;
|
||||
}
|
||||
|
||||
@@ -130,21 +118,41 @@ public class Quad implements ModelQuadView {
|
||||
|
||||
this.deleted = quad.deleted;
|
||||
|
||||
this.normal = quad.normal;
|
||||
|
||||
this.hasColor = quad.hasColor;
|
||||
this.hasShade = quad.hasShade;
|
||||
this.hasNormals = quad.hasNormals;
|
||||
|
||||
this.cachedFlags = quad.cachedFlags;
|
||||
this.face = quad.face;
|
||||
this.colorIndex = quad.colorIndex;
|
||||
}
|
||||
|
||||
public void setRaw(int[] data, boolean shade, @Nullable ForgeDirection face, int colorIndex, int flags) {
|
||||
|
||||
int i = 0;
|
||||
for(int vi = 0; vi < 4; vi++) {
|
||||
|
||||
xs[vi] = Float.intBitsToFloat(data[i + 0]);
|
||||
ys[vi] = Float.intBitsToFloat(data[i + 1]);
|
||||
zs[vi] = Float.intBitsToFloat(data[i + 2]);
|
||||
|
||||
us[vi] = Float.intBitsToFloat(data[i + 3]);
|
||||
vs[vi] = Float.intBitsToFloat(data[i + 4]);
|
||||
|
||||
cs[vi] = data[i + 5];
|
||||
ns[vi] = data[i + 6];
|
||||
bs[vi] = data[i + 7];
|
||||
|
||||
i += 8;
|
||||
}
|
||||
|
||||
this.shade = shade;
|
||||
this.deleted = false;
|
||||
this.face = face;
|
||||
this.colorIndex = colorIndex;
|
||||
this.cachedFlags = ModelQuadFlags.getQuadFlags(flags);
|
||||
}
|
||||
|
||||
private void read(int[] rawBuffer, int offset, float offsetX, float offsetY, float offsetZ, int drawMode, BlockRenderer.Flags flags) {
|
||||
final int vertices = drawMode == GL11.GL_TRIANGLES ? 3 : 4;
|
||||
int i = offset;
|
||||
for(int vi = 0; vi < vertices; vi++) {
|
||||
int i = offset + vi * 8;
|
||||
|
||||
xs[vi] = Float.intBitsToFloat(rawBuffer[i + 0]) + offsetX;
|
||||
ys[vi] = Float.intBitsToFloat(rawBuffer[i + 1]) + offsetY;
|
||||
@@ -157,15 +165,14 @@ public class Quad implements ModelQuadView {
|
||||
ns[vi] = flags.hasNormals ? rawBuffer[i + 6] : 0;
|
||||
bs[vi] = flags.hasBrightness ? rawBuffer[i + 7] : DEFAULT_BRIGHTNESS;
|
||||
|
||||
this.hasColor = flags.hasColor;
|
||||
this.hasShade = flags.hasBrightness;
|
||||
this.hasNormals = flags.hasNormals;
|
||||
|
||||
|
||||
i += 8;
|
||||
}
|
||||
|
||||
// sus
|
||||
this.shade = flags.hasBrightness;
|
||||
|
||||
if(vertices == 3) {
|
||||
|
||||
// Quadrangulate!
|
||||
xs[3] = xs[2];
|
||||
ys[3] = ys[2];
|
||||
@@ -195,8 +202,7 @@ public class Quad implements ModelQuadView {
|
||||
vectorB.set(xs[2] - xs[1], ys[2] - ys[1], zs[2] - zs[1]);
|
||||
vectorA.cross(vectorB, vectorC);
|
||||
|
||||
normal = ModelQuadFacing.fromVector(vectorC);
|
||||
this.face = ModelQuadFacing.toDirection(normal);
|
||||
this.face = ModelQuadFacing.toDirection(ModelQuadFacing.fromVector(vectorC));
|
||||
this.cachedFlags = ModelQuadFlags.getQuadFlags(this);
|
||||
}
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@ import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import com.gtnewhorizons.angelica.utils.ObjectPooler;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectImmutableList;
|
||||
import java.util.ArrayList;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
@@ -153,6 +153,7 @@ public class CubeModel implements QuadProvider {
|
||||
|
||||
|
||||
public static final ThreadLocal<CubeModel> INSTANCE = ThreadLocal.withInitial(() -> new CubeModel(false));
|
||||
private final NdQuadBuilder builder = new NdQuadBuilder();
|
||||
private final boolean[] colorized = new boolean[6];
|
||||
private final BlockRenderer.Flags flags = new BlockRenderer.Flags(true, true, false, false);
|
||||
private static final List<Quad> EMPTY = ObjectImmutableList.of();
|
||||
@@ -176,53 +177,14 @@ public class CubeModel implements QuadProvider {
|
||||
if (dir == ForgeDirection.UNKNOWN)
|
||||
return EMPTY;
|
||||
|
||||
final Quad face = quadPool.getInstance();
|
||||
final int[] buf = Arrays.copyOf(initBufs[dir.ordinal()], 32); // 8 ints per vertex, four vertices per quad. A cube only has one quad per side
|
||||
// Format:
|
||||
// x
|
||||
// y
|
||||
// z
|
||||
// u
|
||||
// v
|
||||
// color
|
||||
// normals
|
||||
// brightness
|
||||
// repeat
|
||||
// all are float bits as ints
|
||||
|
||||
this.builder.square(dir, 0, 0, 1, 1, 0);
|
||||
final IIcon tex = block.getIcon(dir.ordinal(), meta);
|
||||
final int color;
|
||||
if (this.colorized[dir.ordinal()]) {
|
||||
final int c = block.colorMultiplier(world, pos.x, pos.y, pos.z);
|
||||
final int r = (c >> 16) & 0xFF;
|
||||
final int g = (c >> 8) & 0xFF;
|
||||
final int b = c & 0xFF;
|
||||
color = 0xFF << 24 | b << 16 | g << 8 | r;
|
||||
} else { color = 0xFFFFFFFF; }
|
||||
this.flags.hasColor = this.colorized[dir.ordinal()];
|
||||
this.builder.spriteBake(tex, NdQuadBuilder.BAKE_LOCK_UV);
|
||||
|
||||
for (int vi = 0; vi < 4; ++vi) {
|
||||
final int i = vi * 8;
|
||||
int color = 0xFF << 24 | block.colorMultiplier(world, pos.x, pos.y, pos.z);
|
||||
this.builder.color(color, color, color, color);
|
||||
|
||||
// UV
|
||||
buf[i + 3] = Float.floatToIntBits(tex.getInterpolatedU(uv[vi][0] * 16));
|
||||
buf[i + 4] = Float.floatToIntBits(tex.getInterpolatedV(uv[vi][1] * 16));
|
||||
|
||||
// Color
|
||||
buf[i + 5] = color;
|
||||
}
|
||||
|
||||
face.setState(buf, 0, this.flags, GL_QUADS, 0, 0, 0);
|
||||
|
||||
// CubeModel is solid all over, and thus doesn't need to do this
|
||||
// However, you need to drop deleted quads in proper model code
|
||||
/*if (face.deleted) {
|
||||
|
||||
quadPool.releaseInstance(face);
|
||||
return EMPTY;
|
||||
}*/
|
||||
|
||||
ONE.set(0, face);
|
||||
ONE.set(0, this.builder.build(quadPool.getInstance()));
|
||||
return ONE;
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,7 @@ 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;
|
||||
|
||||
@@ -74,9 +75,9 @@ public abstract class EncodingFormat {
|
||||
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_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);
|
||||
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);
|
||||
@@ -123,11 +124,11 @@ public abstract class EncodingFormat {
|
||||
return (bits & GEOMETRY_INVERSE_MASK) | ((geometryFlags & GEOMETRY_MASK) << GEOMETRY_SHIFT);
|
||||
}
|
||||
|
||||
/*static RenderMaterialImpl material(int bits) {
|
||||
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);
|
||||
}*/
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,12 @@
|
||||
package com.gtnewhorizons.angelica.models;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.mojang.Axis;
|
||||
import com.gtnewhorizons.angelica.compat.nd.Quad;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import org.joml.Vector3f;
|
||||
|
||||
import static me.jellysquid.mods.sodium.client.util.MathUtil.fuzzy_eq;
|
||||
|
||||
/**
|
||||
* Static routines of general utility for renderer implementations.
|
||||
* Renderers are not required to use these helpers, but they were
|
||||
@@ -14,7 +18,7 @@ public abstract class GeometryHelper {
|
||||
/** set when a quad touches all four corners of a unit cube. */
|
||||
public static final int CUBIC_FLAG = 1;
|
||||
|
||||
/** set when a quad is parallel to (but not necessarily on) a its light face. */
|
||||
/** set when a quad is parallel to (but not necessarily on) its light face. */
|
||||
public static final int AXIS_ALIGNED_FLAG = CUBIC_FLAG << 1;
|
||||
|
||||
/** set when a quad is coplanar with its light face. Implies {@link #AXIS_ALIGNED_FLAG} */
|
||||
@@ -26,6 +30,147 @@ public abstract class GeometryHelper {
|
||||
private static final float EPS_MIN = 0.0001f;
|
||||
private static final float EPS_MAX = 1.0f - EPS_MIN;
|
||||
|
||||
/**
|
||||
* Analyzes the quad and returns a value with some combination
|
||||
* of {@link #AXIS_ALIGNED_FLAG}, {@link #LIGHT_FACE_FLAG} and {@link #CUBIC_FLAG}.
|
||||
* Intended use is to optimize lighting when the geometry is regular.
|
||||
* Expects convex quads with all points co-planar.
|
||||
*/
|
||||
public static int computeShapeFlags(NdQuadBuilder quad) {
|
||||
ForgeDirection lightFace = quad.lightFace();
|
||||
int bits = 0;
|
||||
|
||||
if (isQuadParallelToFace(lightFace, quad)) {
|
||||
bits |= AXIS_ALIGNED_FLAG;
|
||||
|
||||
if (isParallelQuadOnFace(lightFace, quad)) {
|
||||
bits |= LIGHT_FACE_FLAG;
|
||||
}
|
||||
}
|
||||
|
||||
if (isQuadCubic(lightFace, quad)) {
|
||||
bits |= CUBIC_FLAG;
|
||||
}
|
||||
|
||||
return bits;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if quad is parallel to the given face.
|
||||
* Does not validate quad winding order.
|
||||
* Expects convex quads with all points co-planar.
|
||||
*/
|
||||
public static boolean isQuadParallelToFace(ForgeDirection face, NdQuadBuilder quad) {
|
||||
int i = Axis.fromDirection(face).ordinal();
|
||||
final float val = quad.posByIndex(0, i);
|
||||
return fuzzy_eq(val, quad.posByIndex(1, i)) && fuzzy_eq(val, quad.posByIndex(2, i)) && fuzzy_eq(val, quad.posByIndex(3, i));
|
||||
}
|
||||
|
||||
/**
|
||||
* True if quad - already known to be parallel to a face - is actually coplanar with it.
|
||||
* For compatibility with vanilla resource packs, also true if quad is outside the face.
|
||||
*
|
||||
* <p>Test will be unreliable if not already parallel, use {@link #isQuadParallelToFace(ForgeDirection, NdQuadBuilder)}
|
||||
* for that purpose. Expects convex quads with all points co-planar.
|
||||
*/
|
||||
public static boolean isParallelQuadOnFace(ForgeDirection lightFace, NdQuadBuilder quad) {
|
||||
final float x = quad.posByIndex(0, Axis.fromDirection(lightFace).ordinal());
|
||||
return Axis.Direction.fromDirection(lightFace) == Axis.Direction.POSITIVE ? x >= EPS_MAX : x <= EPS_MIN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if quad is truly a quad (not a triangle) and fills a full block cross-section.
|
||||
* If known to be true, allows use of a simpler/faster AO lighting algorithm.
|
||||
*
|
||||
* <p>Does not check if quad is actually coplanar with the light face, nor does it check that all
|
||||
* quad vertices are coplanar with each other.
|
||||
*
|
||||
* <p>Expects convex quads with all points co-planar.
|
||||
*/
|
||||
public static boolean isQuadCubic(ForgeDirection lightFace, NdQuadBuilder quad) {
|
||||
int a, b;
|
||||
|
||||
switch (lightFace) {
|
||||
case EAST:
|
||||
case WEST:
|
||||
a = 1;
|
||||
b = 2;
|
||||
break;
|
||||
case UP:
|
||||
case DOWN:
|
||||
a = 0;
|
||||
b = 2;
|
||||
break;
|
||||
case SOUTH:
|
||||
case NORTH:
|
||||
a = 1;
|
||||
b = 0;
|
||||
break;
|
||||
default:
|
||||
// handle WTF case
|
||||
return false;
|
||||
}
|
||||
|
||||
return confirmSquareCorners(a, b, quad);
|
||||
}
|
||||
|
||||
/**
|
||||
* Used by {@link #isQuadCubic(ForgeDirection, NdQuadBuilder)}.
|
||||
* True if quad touches all four corners of unit square.
|
||||
*
|
||||
* <p>For compatibility with resource packs that contain models with quads exceeding
|
||||
* block boundaries, considers corners outside the block to be at the corners.
|
||||
*/
|
||||
private static boolean confirmSquareCorners(int aCoordinate, int bCoordinate, NdQuadBuilder quad) {
|
||||
int flags = 0;
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
final float a = quad.posByIndex(i, aCoordinate);
|
||||
final float b = quad.posByIndex(i, bCoordinate);
|
||||
|
||||
if (a <= EPS_MIN) {
|
||||
if (b <= EPS_MIN) {
|
||||
flags |= 1;
|
||||
} else if (b >= EPS_MAX) {
|
||||
flags |= 2;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else if (a >= EPS_MAX) {
|
||||
if (b <= EPS_MIN) {
|
||||
flags |= 4;
|
||||
} else if (b >= EPS_MAX) {
|
||||
flags |= 8;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return flags == 15;
|
||||
}
|
||||
|
||||
/**
|
||||
* Identifies the face to which the quad is most closely aligned.
|
||||
* This mimics the value that {@link Quad#getLightFace()} returns, and is
|
||||
* used in the vanilla renderer for all diffuse lighting.
|
||||
*
|
||||
* <p>Derived from the quad face normal and expects convex quads with all points co-planar.
|
||||
*/
|
||||
public static ForgeDirection lightFace(NdQuadBuilder quad) {
|
||||
final Vector3f normal = quad.faceNormal;
|
||||
return switch (GeometryHelper.longestAxis(normal)) {
|
||||
case X -> normal.x() > 0 ? ForgeDirection.EAST : ForgeDirection.WEST;
|
||||
case Y -> normal.y() > 0 ? ForgeDirection.UP : ForgeDirection.DOWN;
|
||||
case Z -> normal.z() > 0 ? ForgeDirection.SOUTH : ForgeDirection.NORTH;
|
||||
default ->
|
||||
// handle WTF case
|
||||
ForgeDirection.UP;
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Simple 4-way compare, doesn't handle NaN values.
|
||||
*/
|
||||
|
||||
@@ -2,16 +2,26 @@ 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;
|
||||
public static final int X_INDEX = 0;
|
||||
public static final int Y_INDEX = 1;
|
||||
public static final int Z_INDEX = 2;
|
||||
@@ -86,20 +96,20 @@ public class NdQuadBuilder {
|
||||
*/
|
||||
public static float CULL_FACE_EPSILON = 0.00001f;
|
||||
|
||||
private ForgeDirection cullFace = ForgeDirection.UNKNOWN;
|
||||
private ForgeDirection nominalFace = ForgeDirection.UNKNOWN;
|
||||
private int[] data = new int[INTS_PER_VERTEX * 4];
|
||||
private boolean isGeometryInvalid = false;
|
||||
private int bitFlags = 0;
|
||||
// It's called a header, but because I'm lazy it's at the end
|
||||
private final int[] data = new int[QUAD_STRIDE + HEADER_STRIDE];
|
||||
private boolean isGeometryInvalid = true;
|
||||
private int tag = 0;
|
||||
private int colorIndex = -1;
|
||||
final Vector3f faceNormal = new Vector3f();
|
||||
|
||||
/**
|
||||
* Dumps to {@param out} and returns it.
|
||||
*/
|
||||
public Quad build(Quad out) {
|
||||
|
||||
out.setState(
|
||||
/*out.setState(
|
||||
data,
|
||||
0,
|
||||
new BlockRenderer.Flags(true, false, this.colorIndex != -1, false),
|
||||
@@ -107,7 +117,10 @@ public class NdQuadBuilder {
|
||||
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]);
|
||||
this.clear();
|
||||
return out;
|
||||
}
|
||||
@@ -117,11 +130,11 @@ public class NdQuadBuilder {
|
||||
Arrays.fill(this.data, 0);
|
||||
this.isGeometryInvalid = true;
|
||||
this.nominalFace = ForgeDirection.UNKNOWN;
|
||||
normalFlags(0);
|
||||
tag(0);
|
||||
colorIndex(-1);
|
||||
cullFace(null);
|
||||
//material(IndigoRenderer.MATERIAL_STANDARD);
|
||||
this.normalFlags(0);
|
||||
this.tag(0);
|
||||
this.colorIndex(-1);
|
||||
this.cullFace(null);
|
||||
this.material(IndigoRenderer.MATERIAL_STANDARD);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -149,39 +162,87 @@ public class NdQuadBuilder {
|
||||
this.colorIndex = colorIndex;
|
||||
}
|
||||
|
||||
private void computeGeometry() {
|
||||
if (isGeometryInvalid) {
|
||||
isGeometryInvalid = false;
|
||||
|
||||
NormalHelper.computeFaceNormal(faceNormal, this);
|
||||
this.data[QUAD_STRIDE + HEADER_FACE_NORMAL] = 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));
|
||||
|
||||
// depends on light face
|
||||
this.data[QUAD_STRIDE +HEADER_BITS] = EncodingFormat.geometryFlags(this.data[QUAD_STRIDE +HEADER_BITS], GeometryHelper.computeShapeFlags(this));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* If not {@link ForgeDirection.UNKNOWN}, quad is coplanar with a block face which, if known, simplifies
|
||||
* If non-null, 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]);
|
||||
}
|
||||
|
||||
/**
|
||||
* If not {@link ForgeDirection#UNKNOWN}, quad is coplanar with a block face which, if known, simplifies
|
||||
* or shortcuts geometric analysis that might otherwise be needed.
|
||||
* Set to {@link ForgeDirection.UNKNOWN} if quad is not coplanar or if this is not known.
|
||||
* Set to {@link ForgeDirection#UNKNOWN} if quad is not coplanar or if this is not known.
|
||||
* Also controls face culling during block rendering.
|
||||
*
|
||||
* <p>{@link ForgeDirection.UNKNOWN} by default.
|
||||
* <p>{@link ForgeDirection#UNKNOWN} by default.
|
||||
*
|
||||
* <p>When called with a non-{@link ForgeDirection.UNKNOWN} value, also sets {@link #nominalFace(ForgeDirection)}
|
||||
* <p>When called with a non-{@link ForgeDirection#UNKNOWN} value, also sets {@link #nominalFace(ForgeDirection)}
|
||||
* to the same value.
|
||||
*
|
||||
* <p>This is different from the value reported by {@link Quad#getFace()}. That value
|
||||
* is computed based on face geometry and must be non-{@link ForgeDirection.UNKNOWN} in vanilla quads.
|
||||
* <p>This is different from the value reported by {@link Quad#getLightFace()}. That value
|
||||
* 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(ForgeDirection dir) {
|
||||
public void cullFace(@Nullable ForgeDirection dir) {
|
||||
|
||||
this.cullFace = dir;
|
||||
if (dir != ForgeDirection.UNKNOWN)
|
||||
this.nominalFace(dir);
|
||||
this.data[QUAD_STRIDE + HEADER_BITS] = EncodingFormat.cullFace(this.data[QUAD_STRIDE + HEADER_BITS], dir);
|
||||
this.nominalFace(dir);
|
||||
}
|
||||
|
||||
private boolean hasShade() {
|
||||
return !this.material().disableDiffuse();
|
||||
}
|
||||
|
||||
/**
|
||||
* Equivalent to {@link Quad#getLightFace()}. This is the face used for vanilla lighting
|
||||
* calculations and will be the block face to which the quad is most closely aligned. Always
|
||||
* the same as cull face for quads that are on a block face, but never
|
||||
* {@link ForgeDirection#UNKNOWN} or null.
|
||||
*/
|
||||
@NotNull
|
||||
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 void material(RenderMaterial material) {
|
||||
*/
|
||||
public final void material(RenderMaterial material) {
|
||||
if (material == null) {
|
||||
material = IndigoRenderer.MATERIAL_STANDARD;
|
||||
}
|
||||
|
||||
this.bitFlags = EncodingFormat.material(this.bitFlags, (RenderMaterialImpl) material);
|
||||
}*/
|
||||
this.data[QUAD_STRIDE + HEADER_BITS] = EncodingFormat.material(this.data[QUAD_STRIDE + HEADER_BITS], (RenderMaterialImpl) material);
|
||||
}
|
||||
|
||||
/**
|
||||
* Provides a hint to renderer about the facing of this quad. Not required,
|
||||
@@ -196,7 +257,7 @@ public class NdQuadBuilder {
|
||||
* <p>Note: This value is not persisted independently when the quad is encoded.
|
||||
* When reading encoded quads, this value will always be the same as {@link #lightFace()}.
|
||||
*/
|
||||
public void nominalFace(ForgeDirection face) {
|
||||
public void nominalFace(@Nullable ForgeDirection face) {
|
||||
nominalFace = face;
|
||||
}
|
||||
|
||||
@@ -211,7 +272,7 @@ public class NdQuadBuilder {
|
||||
* Sets the normal flags.
|
||||
*/
|
||||
private void normalFlags(int flags) {
|
||||
this.bitFlags = EncodingFormat.normalFlags(bitFlags, flags);
|
||||
this.data[QUAD_STRIDE + HEADER_BITS] = EncodingFormat.normalFlags(this.data[QUAD_STRIDE + HEADER_BITS], flags);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -238,6 +299,13 @@ public class NdQuadBuilder {
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convenience: access x, y, z by index 0-2.
|
||||
*/
|
||||
float posByIndex(int vertexIndex, int coordinateIndex) {
|
||||
return Float.intBitsToFloat(data[vertexIndex * INTS_PER_VERTEX + X_INDEX + coordinateIndex]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convienence, gets the icon from the block atlas. See {@link #spriteBake(IIcon, int)}
|
||||
*/
|
||||
@@ -370,7 +438,7 @@ public class NdQuadBuilder {
|
||||
}
|
||||
|
||||
/**
|
||||
* Modern Minecraft uses magic arrays to do this without breaking AO. Let's copy that.
|
||||
* Modern Minecraft uses magic arrays to do this without breaking AO. This is the same thing, but without arrays.
|
||||
*/
|
||||
public static Vector3f mapSideToVertex(Vector3f from, Vector3f to, int index, ForgeDirection side) {
|
||||
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
package com.gtnewhorizons.angelica.models;
|
||||
|
||||
import net.minecraft.util.MathHelper;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.joml.Vector3f;
|
||||
import org.joml.Vector3i;
|
||||
|
||||
import static me.jellysquid.mods.sodium.common.util.DirectionUtil.STEP;
|
||||
|
||||
public class NormalHelper {
|
||||
|
||||
private static final float PACK = 127.0f;
|
||||
private static final float UNPACK = 1.0f / PACK;
|
||||
|
||||
/**
|
||||
* Computes the face normal of the given quad and saves it in the provided non-null vector.
|
||||
* If {@link NdQuadBuilder#nominalFace()} is set will optimize by confirming quad is parallel to that
|
||||
* face and, if so, use the standard normal for that face direction.
|
||||
*
|
||||
* <p>Will work with triangles also. Assumes counter-clockwise winding order, which is the norm.
|
||||
* Expects convex quads with all points co-planar.
|
||||
*/
|
||||
public static void computeFaceNormal(@NotNull Vector3f saveTo, NdQuadBuilder q) {
|
||||
final ForgeDirection nominalFace = q.nominalFace();
|
||||
|
||||
if (nominalFace != null && GeometryHelper.isQuadParallelToFace(nominalFace, q)) {
|
||||
Vector3i vec = STEP[nominalFace.ordinal()];
|
||||
saveTo.set(vec.x, vec.y, vec.z);
|
||||
return;
|
||||
}
|
||||
|
||||
final float x0 = q.x(0);
|
||||
final float y0 = q.y(0);
|
||||
final float z0 = q.z(0);
|
||||
final float x1 = q.x(1);
|
||||
final float y1 = q.y(1);
|
||||
final float z1 = q.z(1);
|
||||
final float x2 = q.x(2);
|
||||
final float y2 = q.y(2);
|
||||
final float z2 = q.z(2);
|
||||
final float x3 = q.x(3);
|
||||
final float y3 = q.y(3);
|
||||
final float z3 = q.z(3);
|
||||
|
||||
final float dx0 = x2 - x0;
|
||||
final float dy0 = y2 - y0;
|
||||
final float dz0 = z2 - z0;
|
||||
final float dx1 = x3 - x1;
|
||||
final float dy1 = y3 - y1;
|
||||
final float dz1 = z3 - z1;
|
||||
|
||||
float normX = dy0 * dz1 - dz0 * dy1;
|
||||
float normY = dz0 * dx1 - dx0 * dz1;
|
||||
float normZ = dx0 * dy1 - dy0 * dx1;
|
||||
|
||||
float l = (float) Math.sqrt(normX * normX + normY * normY + normZ * normZ);
|
||||
|
||||
if (l != 0) {
|
||||
normX /= l;
|
||||
normY /= l;
|
||||
normZ /= l;
|
||||
}
|
||||
|
||||
saveTo.set(normX, normY, normZ);
|
||||
}
|
||||
|
||||
/**
|
||||
* Like {@link #packNormal(float, float, float, float)}, but without a {@code w} value.
|
||||
*/
|
||||
public static int packNormal(float x, float y, float z) {
|
||||
x = MathHelper.clamp_float(x, -1, 1);
|
||||
y = MathHelper.clamp_float(y, -1, 1);
|
||||
z = MathHelper.clamp_float(z, -1, 1);
|
||||
|
||||
return ((int) (x * PACK) & 0xFF) | (((int) (y * PACK) & 0xFF) << 8) | (((int) (z * PACK) & 0xFF) << 16);
|
||||
}
|
||||
|
||||
/**
|
||||
* Like {@link #packNormal(Vector3f, float)}, but without a {@code w} value.
|
||||
*/
|
||||
public static int packNormal(Vector3f normal) {
|
||||
return packNormal(normal.x, normal.y, normal.z);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
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);
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
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,6 +11,9 @@ 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;
|
||||
@@ -22,6 +25,8 @@ import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Random;
|
||||
|
||||
import lombok.Getter;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
@@ -42,10 +47,12 @@ public class JsonModel implements QuadProvider {
|
||||
private final ResourceLocation parentId;
|
||||
@Nullable
|
||||
private JsonModel parent;
|
||||
@Getter
|
||||
private final boolean useAO;
|
||||
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<>();
|
||||
|
||||
JsonModel(@Nullable ResourceLocation parentId, boolean useAO, Map<ModelDisplay.Position, ModelDisplay> display, Map<String, String> textures, List<ModelElement> elements) {
|
||||
@@ -74,6 +81,8 @@ 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) {
|
||||
@@ -127,6 +136,9 @@ public class JsonModel implements QuadProvider {
|
||||
final int tint = f.getTintIndex();
|
||||
builder.color(tint, tint, tint, tint);
|
||||
|
||||
// Set AO
|
||||
builder.material(mat);
|
||||
|
||||
// Bake and add it
|
||||
this.bakedQuadStore.add(builder.build(new Quad()));
|
||||
}
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,156 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
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();
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
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];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
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");
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -9,6 +9,7 @@ import com.gtnewhorizons.angelica.glsm.debug.OpenGLDebugging;
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import com.gtnewhorizons.angelica.models.json.Loader;
|
||||
import com.gtnewhorizons.angelica.render.CloudRenderer;
|
||||
import com.gtnewhorizons.angelica.rendering.AngelicaBlockSafetyRegistry;
|
||||
import cpw.mods.fml.client.registry.ClientRegistry;
|
||||
import cpw.mods.fml.common.FMLCommonHandler;
|
||||
import cpw.mods.fml.common.event.FMLInitializationEvent;
|
||||
@@ -17,9 +18,12 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
||||
import cpw.mods.fml.common.eventhandler.EventPriority;
|
||||
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
||||
import cpw.mods.fml.common.gameevent.TickEvent;
|
||||
import cpw.mods.fml.common.registry.GameData;
|
||||
import cpw.mods.fml.common.registry.GameRegistry;
|
||||
import cpw.mods.fml.relauncher.ReflectionHelper;
|
||||
import jss.notfine.core.Settings;
|
||||
import java.lang.management.ManagementFactory;
|
||||
import java.util.Iterator;
|
||||
import java.util.Locale;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import me.jellysquid.mods.sodium.client.SodiumDebugScreenHandler;
|
||||
@@ -68,6 +72,14 @@ public class ClientProxy extends CommonProxy {
|
||||
GLStateManager.setRunningSplash(false);
|
||||
LOGGER.info("World loaded - Enabling GLSM Cache");
|
||||
}
|
||||
|
||||
// Register all blocks. Because blockids are unique to a world, this must be done each load
|
||||
GameData.getBlockRegistry().forEach(o -> {
|
||||
|
||||
final Block b = (Block) o;
|
||||
AngelicaBlockSafetyRegistry.canBlockRenderOffThread(b, true, true);
|
||||
AngelicaBlockSafetyRegistry.canBlockRenderOffThread(b, false, true);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
|
||||
+8
-18
@@ -16,26 +16,16 @@ public class AngelicaBlockSafetyRegistry {
|
||||
private static final Reference2BooleanMap<Block> ISBRH_SAFETY_MAP = new Reference2BooleanOpenHashMap<>();
|
||||
private static final StampedLock LOCK = new StampedLock();
|
||||
|
||||
public static boolean canBlockRenderOffThread(Block block, boolean checkISBRH) {
|
||||
final long stamp = LOCK.readLock();
|
||||
/**
|
||||
* This method is threadsafe to read, and threadsafe to write, but NOT if both could happen at the same time.
|
||||
*/
|
||||
public static boolean canBlockRenderOffThread(Block block, boolean checkISBRH, boolean shouldPopulate) {
|
||||
|
||||
final Reference2BooleanMap<Block> map = checkISBRH ? ISBRH_SAFETY_MAP : BLOCK_SAFETY_MAP;
|
||||
boolean isOffThread, shouldPopulate;
|
||||
try {
|
||||
isOffThread = map.getBoolean(block);
|
||||
if (isOffThread) {
|
||||
return true; // no need to check if 'false' was due to not being populated
|
||||
}
|
||||
|
||||
shouldPopulate = !map.containsKey(block);
|
||||
} finally {
|
||||
LOCK.unlock(stamp);
|
||||
}
|
||||
|
||||
if(shouldPopulate) {
|
||||
isOffThread = populateCanRenderOffThread(block, map);
|
||||
}
|
||||
|
||||
return isOffThread;
|
||||
if (shouldPopulate)
|
||||
return populateCanRenderOffThread(block, map);
|
||||
return map.getBoolean(block);
|
||||
}
|
||||
|
||||
private static boolean populateCanRenderOffThread(Block block, Reference2BooleanMap<Block> map) {
|
||||
|
||||
Reference in new issue
Block a user