Compare commits

...
Author SHA1 Message Date
Jason Mitchell f41f27e706 Some misbehaving mods *cough GT5u cough* enjoy reallocating textures all the time, so try a normal hash set instead of a reference one... 2024-03-03 09:26:33 -08:00
ah-OOG-ah 346a305f1d Refactor Quad, BlockPos, and QuadProvider API
Also optimize static models
2024-02-29 21:17:46 -05:00
ah-OOG-ah da8f700068 Update LICENSE 2024-02-29 21:17:46 -05:00
ah-OOG-ah f2445fabba Minor patches + license rewording 2024-02-29 21:17:46 -05:00
makamys bc3ca5209f Clean up tags
Also fixes names of enum compound tags missing
2024-02-29 21:17:46 -05:00
makamys 00517079d2 Fix broken links 2024-02-29 21:17:46 -05:00
makamys 7b8a64ec94 Move model-spec.md to docs dir 2024-02-29 21:17:46 -05:00
ah-OOG-ah 794e59b6de Readd CapturingTesselator workaround 2024-02-29 21:17:46 -05:00
ah-OOG-ah 9710801cb1 Fix underwater lighting on QuadProviders 2024-02-29 21:17:46 -05:00
ah-OOG-ah c5bda3b19c Update JsonModel.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah f9678a3793 Batch colorizing 2024-02-29 21:17:46 -05:00
ah-OOG-ah 091290b218 Clean all the things 2024-02-29 21:17:46 -05:00
ah-OOG-ah d991b55af7 Update ClientProxy.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah 1530a8f6fe Clean up CubeModel 2024-02-29 21:17:46 -05:00
ah-OOG-ah 98156191fe Update Loader.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah 956914efa3 Delete ModelHelper.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah 51c3beea9e The purge continues 2024-02-29 21:17:46 -05:00
ah-OOG-ah 657ff921de Fix sided lighting on copied quads 2024-02-29 21:17:46 -05:00
ah-OOG-ah c9539faf44 Update JsonModel.java 2024-02-29 21:17:46 -05:00
ah-OOG-ah 2ca4d5338f Purge FRAPI code
Also use a baked stone model and fix a stupid in JSON
2024-02-29 21:17:46 -05:00
ah-OOG-ah 236a513705 FRAPI materials + NdQuadBuilder performance
Also speed up the offThreadSafety map
2024-02-29 21:17:46 -05:00
ah-OOG-ah 6d49e82a0c Revert "Set aside JSON model code for now"
This reverts commit 31fdf3383195b65a00e999a5634ed3ead8f060b2.
2024-02-29 21:17:46 -05:00
ah-OOG-ah 2fea614a45 Revert "Remove unready code, for now"
This reverts commit b626e3fa8f83013e5b4a68e787ffed9b75d8a679.
2024-02-29 21:17:46 -05:00
ah-OOG-ah 85ed121158 Remove unready code, for now 2024-02-29 21:17:46 -05:00
ah-OOG-ah 9316f42808 Set aside JSON model code for now
Item models my behated
2024-02-29 21:17:46 -05:00
ah-OOG-ah 74b66746eb Dual-license the model package for Fabric 2024-02-29 21:17:46 -05:00
ah-OOG-ah 5abeb9709e Credit FRAPI 2024-02-29 21:17:46 -05:00
ah-OOG-ah 5ec50f22d9 Remove Fabric license headers 2024-02-29 21:17:46 -05:00
ah-OOG-ah dfe3a4220b Add convenience methods 2024-02-29 21:17:46 -05:00
ah-OOG-ah 1e1e95f249 Variant handling 2024-02-29 21:17:46 -05:00
ah-OOG-ah 02b0d1b728 Update JsonModel.java
This fixes things and I don't know why
2024-02-29 21:17:46 -05:00
ah-OOG-ah 9c81c96bb3 Dang, BlockState is hard
YEET
2024-02-29 21:17:46 -05:00
ah-OOG-ah fff5b2cb01 Implement initial BlockState API 2024-02-29 21:17:46 -05:00
ah-OOG-ah 77f1e9b5a2 Support element rotation 2024-02-29 21:17:46 -05:00
ah-OOG-ah 3158a33a65 Texture loading 2024-02-29 21:17:46 -05:00
ah-OOG-ah f6f840235e Does everything but textures 2024-02-29 21:17:46 -05:00
ah-OOG-ah 793f668ef8 Copyright-clear model parsing 2024-02-29 21:17:46 -05:00
Jason Mitchell da01393799 Try an Int2ObjectMap instead of an ObjectList 2024-02-28 23:02:02 -08:00
94 changed files with 2891 additions and 698 deletions

No files matched your search

+3
View File
@@ -59,3 +59,6 @@
* IMS, jss2a98aj, || dbp ||, roadhog360 for advice and moral support
* Forge 1.12+
* Some files have been taken from Minecraft Forge under the LGPL 2.1 license and are marked as such
* FRAPI and Indigo
* Model building API heavily inspired by/copied from Fabric's; upstream may use it under the original Apache 2.0
license, see LICENSE in `com.gtnewhorizons.angelica.models`
+4
View File
@@ -2,6 +2,10 @@ plugins {
id("com.gtnewhorizons.gtnhconvention")
}
minecraft {
extraRunJvmArguments.add("-Dangelica.enableTestBlocks=true")
}
tasks.test {
useJUnitPlatform()
testLogging {
+2 -2
View File
@@ -67,8 +67,8 @@ dependencies {
compileOnly "org.apache.ant:ant:1.8.2"
// Because who doesn't want NEI
compileOnly('com.github.GTNewHorizons:NotEnoughItems:2.5.21-GTNH:dev')
compileOnly('com.github.GTNewHorizons:CodeChickenCore:1.2.1:dev')
devOnlyNonPublishable('com.github.GTNewHorizons:NotEnoughItems:2.4.9-GTNH:dev')
devOnlyNonPublishable('com.github.GTNewHorizons:CodeChickenCore:1.2.0:dev')
// Notfine Deps
compileOnly("thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev")
+34
View File
@@ -0,0 +1,34 @@
# A specification for models
This is borrowed from [the unofficial Minecraft wiki](https://minecraft.wiki/w/Tutorials/Models) under the CC BY-NC-SA 3.0.
The folder `assets/<namespace>/models/block` holds the model files for all the specified variants. The names of the files can be changed, but must always correspond with the names used in the variant files.
* `[TAG_compound]` The root tag
* `[TAG_string]` **parent**: Loads a different model from the given path, in form of a [resource location](https://minecraft.wiki/w/Tutorials/Models#File_path). If both `"parent"` and `"elements"` are set, the `"elements"` tag overrides the `"elements"` tag from the previous model.
* Can be set to `"builtin/generated"` to use a model that is created out of the specified icon. Note that only the first layer is supported, and rotation can be achieved only by using block states files.
* `[TAG_byte]` **ambientocclusion**: Whether to use [ambient occlusion](http://en.wikipedia.org/wiki/Ambient_occlusion) (`true` - default), or not (`false`). Note:only works on Parent file
* `[TAG_object]` **display**: Holds the different places where item models are displayed.
* `[TAG_compound]` ***Position***: Named `thirdperson_righthand`, `thirdperson_lefthand`, `firstperson_righthand`, `firstperson_lefthand`, `gui`, `head`, `ground`, or `fixed`. Place where an item model is displayed. Holds its rotation, translation and scale for the specified situation. '''fixed''' refers to item frames, while the rest are as their name states. Note that translations are applied to the model before rotations.
* `[TAG_list]` **rotation**: Specifies the rotation of the model according to the scheme `[x, y, z]`.
* `[TAG_list]` **translation**: Specifies the position of the model according to the scheme `[x, y, z]`. The values are clamped between -80 and 80.
* `[TAG_list]` **scale**: Specifies the scale of the model according to the scheme `[x, y, z]`. If the value is greater than 4, it is displayed as 4.
* `[TAG_compound]` **textures**: Holds the textures of the model, in form of a [resource location](https://minecraft.wiki/w/Tutorials/Models#File_path) or can be another texture variable.
* `[TAG_string]` **particle**: What texture to load particles from. This texture is also used as an overlay if you are in a [nether portal](https://minecraft.wiki/w/Nether_portal), and used for [water](https://minecraft.wiki/w/water) and [lava](https://minecraft.wiki/w/Lava)'s still textures.<sup>[[1]](https://bugs.mojang.com/browse/MC-240042)</sup> This texture is also considered a texture variable that can be referenced as `"#particle"`. Note: All breaking particles from non-model blocks are hard-coded, such as for [barriers](https://minecraft.wiki/w/Barrier).
* `[TAG_string]` ***Texture variable***: Defines a texture variable with `name` and assigns it to a texture or another variable.
* `[TAG_list]` **elements**: Contains all the elements of the model. They can have only cubic forms. If both `"parent"` and `"elements"` are set, the `"elements"` tag overrides the `"elements"` tag from the previous model.
* `[TAG_compound]` An element.
* `[TAG_list]` **from**: Start point of a cuboid according to the scheme `[x, y, z]`. Values must be between -16 and 32.
* `[TAG_list]` **to**: Stop point of a cuboid according to the scheme `[x, y, z]`. Values must be between -16 and 32.
* `[TAG_compound]` **rotation**: Defines the rotation of an element.
* `[TAG_list]` **origin**: Sets the center of the rotation according to the scheme `[x, y, z]`.
* `[TAG_string]` **axis**: Specifies the direction of rotation, can be `"x"`, `"y"` or `"z"`.
* `[TAG_float]` **angle**: Specifies the angle of rotation. Can be 45 through -45 degrees in 22.5 degree increments.
* `[TAG_byte]` **rescale**: Specifies whether or not to scale the faces across the whole block. Can be true or false. Defaults to false.
* `[TAG_byte]` **shade**: Defines if shadows are rendered (`true` - default), not (`false`).
* `[TAG_compound]` **faces**: Holds all the faces of the cuboid. If a face is left out, it does not render.
* `[TAG_compound]` ***Face***: Named `down`, `up`, `north`, `south`, `west` or `east`. Contains the properties of the specified face.
* `[TAG_list]` **uv**: Defines the area of the texture to use according to the scheme `[x1, y1, x2, y2]`. The texture behavior is inconsistent if UV extends below 0 or above 16. If the numbers of `x1` and `x2` are swapped (e.g. from `0, 0, 16, 16` to `16, 0, 0, 16`), the texture flips. UV is optional, and if not supplied it automatically generates based on the element's position.
* `[TAG_string]` **texture**: Specifies the texture in form of the texture variable prepended with a `#`.
* `[TAG_string]` **cullface**: Specifies whether a face does not need to be rendered when there is a block touching it in the specified position. The position can be: `down`, `up`, `north`, `south`, `west`, or `east`. It also determines the side of the block to use the light level from for lighting the face, and if unset, defaults to the side.
* `[TAG_int]` **rotation**: Rotates the texture clockwise by the specified number of degrees. Can be 0, 90, 180, or 270. Defaults to 0. Rotation does not affect which part of the texture is used. Instead, it amounts to permutation of the selected texture vertexes (selected implicitly, or explicitly though `uv`).
* `[TAG_int]` **tintindex**: Determines whether to tint the texture using a hardcoded tint index. The default value, -1, indicates not to use the tint. Any other number is provided to BlockColors to get the tint value corresponding to that index. However, most blocks do not have a tint value defined (in which case white is used). Furthermore, no vanilla block currently uses multiple tint values, and thus the tint index value is ignored (as long as it is set to something other than -1); it could be used for modded blocks that need multiple distinct tint values in the same block though.
@@ -0,0 +1,49 @@
package com.gtnewhorizons.angelica.api;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import net.minecraft.util.MathHelper;
import net.minecraftforge.common.util.ForgeDirection;
import java.math.RoundingMode;
import static com.google.common.math.IntMath.log2;
public interface BlockPos {
int SIZE_BITS_X = 1 + log2(MathHelper.roundUpToPowerOfTwo(30000000), RoundingMode.UNNECESSARY);
int SIZE_BITS_Z = SIZE_BITS_X;
int SIZE_BITS_Y = 64 - SIZE_BITS_X - SIZE_BITS_Z;
long BITS_X = (1L << SIZE_BITS_X) - 1L;
long BITS_Y = (1L << SIZE_BITS_Y) - 1L;
long BITS_Z = (1L << SIZE_BITS_Z) - 1L;
int BIT_SHIFT_Z = SIZE_BITS_Y;
int BIT_SHIFT_X = SIZE_BITS_Y + SIZE_BITS_Z;
int getX();
int getY();
int getZ();
BlockPosImpl offset(ForgeDirection d);
BlockPosImpl down();
BlockPosImpl up();
long asLong();
static long asLong(int x, int y, int z) {
long l = 0L;
l |= ((long) x & BITS_X) << BIT_SHIFT_X;
l |= ((long) y & BITS_Y) << 0;
l |= ((long) z & BITS_Z) << BIT_SHIFT_Z;
return l;
}
public static int unpackLongX(long packedPos) {
return (int)(packedPos << 64 - BIT_SHIFT_X - SIZE_BITS_X >> 64 - SIZE_BITS_X);
}
public static int unpackLongY(long packedPos) {
return (int)(packedPos << 64 - SIZE_BITS_Y >> 64 - SIZE_BITS_Y);
}
public static int unpackLongZ(long packedPos) {
return (int)(packedPos << 64 - BIT_SHIFT_Z - SIZE_BITS_Z >> 64 - SIZE_BITS_Z);
}
}
@@ -0,0 +1,8 @@
package com.gtnewhorizons.angelica.api;
public interface MutableBlockPos extends BlockPos {
MutableBlockPos set(int x, int y, int z);
MutableBlockPos set(long packedPos);
}
@@ -1,15 +1,43 @@
package com.gtnewhorizons.angelica.api;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import com.gtnewhorizons.angelica.utils.ObjectPooler;
import java.util.List;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public interface QuadProvider {
List<Quad> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, ObjectPooler<Quad> quadPool);
int R_MASK = 0xFF << 16;
int G_MASK = 0xFF << 8;
int B_MASK = 0xFF;
/**
* Returns the color packed as ABGR. If you want to vary colors within a block, just ignore the color passed into
* {@link #getQuads} and use whatever you want. You might want to override this to return a constant if you're
* extending a block with an expensive color call, like leaves.
*/
default int getColor(IBlockAccess world, BlockPos pos, Block block, int meta, Random random) {
final int cin = block.colorMultiplier(world, pos.getX(), pos.getY(), pos.getZ());
return (0xFF << 24) | ((cin & B_MASK) << 16) | (cin & G_MASK) | ((cin & R_MASK) >>> 16);
}
/**
* If you need to allocate new quads, set this to true. If true, the quads returned by {@link #getQuads} are
* recycled, and you should not keep a reference to them. Example: stone can return a static list every time, but a
* modded block which adds or removes quads based on location would need dynamic quads.
*/
default boolean isDynamic() {
return false;
}
/**
* Provide quads to render. If you need new quads, they should be obtained with the passed supplier and
* {@link #isDynamic} overridden to return true. If so, all quads in the list are recycled and references to them
* should not be kept.
*/
List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool);
}
@@ -0,0 +1,22 @@
package com.gtnewhorizons.angelica.api;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadViewMutable;
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
import net.minecraftforge.common.util.ForgeDirection;
import javax.annotation.Nullable;
public interface QuadView extends ModelQuadViewMutable {
boolean isShade();
boolean isDeleted();
ForgeDirection getFace();
void copyFrom(QuadView src);
void setRaw(int[] data, boolean shade, @Nullable ForgeDirection face, int colorIndex, int flags);
int[] getRawVertexes();
/**
* Present for compatibility with the Tesselator, not recommended for general use.
*/
void setState(int[] rawBuffer, int offset, BlockRenderer.Flags flags, int drawMode, float offsetX, float offsetY, float offsetZ);
}
@@ -1,8 +1,9 @@
package com.gtnewhorizons.angelica.client.renderer;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import com.gtnewhorizons.angelica.glsm.stacks.Vector3dStack;
import com.gtnewhorizons.angelica.mixins.interfaces.ITessellatorInstance;
import com.gtnewhorizons.angelica.utils.ObjectPooler;
@@ -39,15 +40,15 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
private static final MethodHandle sRawBufferSize;
private static final MethodHandle gRawBufferSize;
private final BlockRenderer.Flags FLAGS = new BlockRenderer.Flags(true, true, true, true);
private final ObjectPooler<Quad> quadBuf = new ObjectPooler<>(Quad::new);
private final List<Quad> collectedQuads = new ObjectArrayList<>();
private final ObjectPooler<QuadView> quadBuf = new ObjectPooler<>(Quad::new);
private final List<QuadView> collectedQuads = new ObjectArrayList<>();
// Any offset we need to the Tesselator's offset!
private final BlockPos offset = new BlockPos();
private final BlockPosImpl offset = new BlockPosImpl();
private final Vector3dStack storedTranslation = new Vector3dStack();
public void setOffset(BlockPos pos) {
public void setOffset(BlockPosImpl pos) {
this.offset.set(pos);
}
public void resetOffset() {
@@ -93,10 +94,10 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
for(int quadI = 0; quadI < this.vertexCount / verticesPerPrimitive; quadI++) {
final Quad quad = quadBuf.getInstance();
final QuadView quad = quadBuf.getInstance();
quad.setState(this.rawBuffer, quadI * (verticesPerPrimitive * 8), FLAGS, this.drawMode, -offset.x, -offset.y, -offset.z);
if(quad.deleted) {
if(quad.isDeleted()) {
quadBuf.releaseInstance(quad);
} else {
this.collectedQuads.add(quad);
@@ -115,7 +116,7 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
}
public List<Quad> getQuads() {
public List<QuadView> getQuads() {
return collectedQuads;
}
@@ -127,7 +128,7 @@ public class CapturingTessellator extends Tessellator implements ITessellatorIns
this.collectedQuads.clear();
}
public static ByteBuffer quadsToBuffer(List<Quad> quads, VertexFormat format) {
public static ByteBuffer quadsToBuffer(List<QuadView> quads, VertexFormat format) {
if(!format.canWriteQuads()) {
throw new IllegalStateException("Vertex format has no quad writer: " + format);
}
@@ -0,0 +1,102 @@
package com.gtnewhorizons.angelica.common;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
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.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.NotNull;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public class BlockTest extends Block implements QuadProvider {
public static final Variant[] modelId = {
new Variant(
new ResourceLocation("blocks/lectern"),
0,
0,
false
),
new Variant(
new ResourceLocation("blocks/lectern"),
180,
0,
false
),
new Variant(
new ResourceLocation("blocks/lectern"),
90,
0,
false
),
new Variant(
new ResourceLocation("blocks/lectern"),
270,
0,
false
),
};
private static final List<QuadView> EMPTY = ObjectImmutableList.of();
private static final JsonModel[] model = new JsonModel[4];
public BlockTest() {
super(Material.rock);
}
public static void loadModel() {
for (int i = 0; i < 4; ++i)
model[i] = Loader.getModel(modelId[i]);
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public void registerBlockIcons(IIconRegister reg) {
reg.registerIcon("angelica:test_block");
reg.registerIcon("lectern_base");
reg.registerIcon("lectern_front");
reg.registerIcon("lectern_sides");
reg.registerIcon("lectern_top");
reg.registerIcon("oak_planks");
}
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
if (meta < 2 || meta > 5) meta = 2;
return (model[meta - 2] != null) ? model[meta - 2].getQuads(world, pos, block, meta, dir, random, color, quadPool) : EMPTY;
}
/**
* Called when a block is placed using its ItemBlock. Args: World, X, Y, Z, side, hitX, hitY, hitZ, block metadata
*/
@Override
public int onBlockPlaced(@NotNull World worldIn, int x, int y, int z, int side, float subX, float subY, float subZ, int meta) {
// Face NORTH if placed up or down
final ForgeDirection s = ForgeDirection.values()[side];
if (s == ForgeDirection.UP || s == ForgeDirection.DOWN)
return 2;
// Face the placed side
return side;
}
}
@@ -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,6 +15,37 @@ 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) {
return switch (dir) {
case "y" -> Y;
case "z" -> Z;
case "x" -> X;
default -> null;
};
}
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,102 +0,0 @@
package com.gtnewhorizons.angelica.compat.mojang;
import net.minecraft.util.MathHelper;
import net.minecraft.world.ChunkPosition;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3i;
import java.math.RoundingMode;
import static com.google.common.math.IntMath.log2;
// Should we keep this?
public class BlockPos extends Vector3i {
private static final int SIZE_BITS_X = 1 + log2(MathHelper.roundUpToPowerOfTwo(30000000), RoundingMode.UNNECESSARY);
private static final int SIZE_BITS_Z = SIZE_BITS_X;
private static final int SIZE_BITS_Y = 64 - SIZE_BITS_X - SIZE_BITS_Z;
private static final long BITS_X = (1L << SIZE_BITS_X) - 1L;
private static final long BITS_Y = (1L << SIZE_BITS_Y) - 1L;
private static final long BITS_Z = (1L << SIZE_BITS_Z) - 1L;
private static final int BIT_SHIFT_Z = SIZE_BITS_Y;
private static final int BIT_SHIFT_X = SIZE_BITS_Y + SIZE_BITS_Z;
public BlockPos() {
super();
}
public BlockPos(int x, int y, int z) {
super(x, y, z);
}
public BlockPos(ChunkPosition chunkPosition) {
super(chunkPosition.chunkPosX, chunkPosition.chunkPosY, chunkPosition.chunkPosZ);
}
public int getX() {
return this.x;
}
public int getY() {
return this.y;
}
public int getZ() {
return this.z;
}
public BlockPos set(int x, int y, int z) {
super.set(x, y, z);
return this;
}
/**
* This method does NOT mutate the BlockPos
*/
public BlockPos offset(ForgeDirection d) {
return new BlockPos(this.x + d.offsetX, this.y + d.offsetY, this.z + d.offsetZ);
}
/**
* This method does NOT mutate the BlockPos
*/
public BlockPos down() {
return offset(ForgeDirection.DOWN);
}
/**
* This method does NOT mutate the BlockPos
*/
public BlockPos up() {
return offset(ForgeDirection.UP);
}
public long asLong() {
return asLong(this.x, this.y, this.z);
}
public static long asLong(int x, int y, int z) {
long l = 0L;
l |= ((long)x & BITS_X) << BIT_SHIFT_X;
l |= ((long)y & BITS_Y) << 0;
l |= ((long)z & BITS_Z) << BIT_SHIFT_Z;
return l;
}
public BlockPos set(long packedPos) {
return set(unpackLongX(packedPos), unpackLongY(packedPos), unpackLongZ(packedPos));
}
public static int unpackLongX(long packedPos) {
return (int)(packedPos << 64 - BIT_SHIFT_X - SIZE_BITS_X >> 64 - SIZE_BITS_X);
}
public static int unpackLongY(long packedPos) {
return (int)(packedPos << 64 - SIZE_BITS_Y >> 64 - SIZE_BITS_Y);
}
public static int unpackLongZ(long packedPos) {
return (int)(packedPos << 64 - BIT_SHIFT_Z - SIZE_BITS_Z >> 64 - SIZE_BITS_Z);
}
public static class Mutable extends BlockPos {
}
}
@@ -0,0 +1,70 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.MutableBlockPos;
import net.minecraft.world.ChunkPosition;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3i;
import static com.gtnewhorizons.angelica.api.BlockPos.unpackLongX;
import static com.gtnewhorizons.angelica.api.BlockPos.unpackLongY;
import static com.gtnewhorizons.angelica.api.BlockPos.unpackLongZ;
// Should we keep this?
public class BlockPosImpl extends Vector3i implements MutableBlockPos {
public BlockPosImpl() {
super();
}
public BlockPosImpl(int x, int y, int z) {
super(x, y, z);
}
public BlockPosImpl(ChunkPosition chunkPosition) {
super(chunkPosition.chunkPosX, chunkPosition.chunkPosY, chunkPosition.chunkPosZ);
}
@Override
public int getX() {
return this.x;
}
@Override
public int getY() {
return this.y;
}
@Override
public int getZ() {
return this.z;
}
@Override
public BlockPosImpl offset(ForgeDirection d) {
return new BlockPosImpl(this.x + d.offsetX, this.y + d.offsetY, this.z + d.offsetZ);
}
@Override
public BlockPosImpl down() {
return offset(ForgeDirection.DOWN);
}
@Override
public BlockPosImpl up() {
return offset(ForgeDirection.UP);
}
@Override
public long asLong() {
return BlockPos.asLong(this.x, this.y, this.z);
}
@Override
public BlockPosImpl set(int x, int y, int z) {
super.set(x, y, z);
return this;
}
@Override
public BlockPosImpl set(long packedPos) {
return set(unpackLongX(packedPos), unpackLongY(packedPos), unpackLongZ(packedPos));
}
}
@@ -13,7 +13,7 @@ import org.joml.Vector4f;
@Getter
public class Camera {
final Vector3d pos = new Vector3d();
final BlockPos.Mutable blockPos = new BlockPos.Mutable();
final BlockPosImpl blockPos = new BlockPosImpl();
float pitch;
float yaw;
EntityLivingBase entity;
@@ -36,12 +36,12 @@ public class ChunkOcclusionDataBuilder {
}
private int openCount = 4096;
public void markClosed(BlockPos pos) {
public void markClosed(BlockPosImpl pos) {
this.closed.set(pack(pos), true);
--this.openCount;
}
private static int pack(BlockPos pos) {
private static int pack(BlockPosImpl pos) {
return pack(pos.getX() & 15, pos.getY() & 15, pos.getZ() & 15);
}
@@ -12,7 +12,7 @@ public class ChunkPos {
this.z = z;
}
public ChunkPos(BlockPos pos) {
public ChunkPos(BlockPosImpl pos) {
this.x = pos.getX() >> 4;
this.z = pos.getZ() >> 4;
}
@@ -19,7 +19,7 @@ public class ChunkSectionPos extends Vector3i {
return new ChunkSectionPos(x, y, z);
}
public static ChunkSectionPos from(BlockPos pos) {
public static ChunkSectionPos from(BlockPosImpl pos) {
return new ChunkSectionPos(getSectionCoord(pos.getX()), getSectionCoord(pos.getY()), getSectionCoord(pos.getZ()));
}
@@ -1,8 +1,8 @@
package com.gtnewhorizons.angelica.compat.mojang;
import com.google.common.collect.ImmutableList;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import it.unimi.dsi.fastutil.ints.IntArrayList;
import it.unimi.dsi.fastutil.ints.IntList;
import lombok.Getter;
@@ -79,7 +79,7 @@ public class VertexFormat {
return quadWriter != null;
}
public void writeQuad(Quad quad, ByteBuffer byteBuffer) {
public void writeQuad(QuadView quad, ByteBuffer byteBuffer) {
if(quadWriter == null) {
throw new IllegalStateException("No quad writer set");
}
@@ -1,7 +1,9 @@
package com.gtnewhorizons.angelica.compat.nd;
import com.gtnewhorizons.angelica.api.QuadView;
import java.nio.ByteBuffer;
public interface IWriteQuads {
void writeQuad(Quad quad, ByteBuffer buf);
void writeQuad(QuadView quad, ByteBuffer buf);
}
@@ -1,187 +0,0 @@
package com.gtnewhorizons.angelica.compat.nd;
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;
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3f;
import org.lwjgl.opengl.GL11;
import java.util.Locale;
public class Quad implements ModelQuadView {
// Adapted from Neodymium
private final static int DEFAULT_BRIGHTNESS = 15 << 20 | 15 << 4;
private final static int DEFAULT_COLOR = 0xFFFFFFFF;
public float[] xs = new float[4];
public float[] ys = new float[4];
public float[] zs = new float[4];
public float[] us = new float[4];
public float[] vs = new float[4];
public int[] cs = new int[4];
public int[] ns = new int[4];
public int[] bs = new int[4];
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;
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() {
return this.face != ForgeDirection.UNKNOWN ? this.face : ForgeDirection.UP;
}
@Override
public float getX(int idx) {
return xs[idx];
}
@Override
public float getY(int idx) {
return ys[idx];
}
@Override
public float getZ(int idx) {
return zs[idx];
}
@Override
public int getColor(int idx) {
return cs[idx];
}
@Override
public float getTexU(int idx) {
return us[idx];
}
@Override
public float getTexV(int idx) {
return vs[idx];
}
@Override
public int getFlags() {
return this.cachedFlags;
}
@Override
public int getLight(int idx) {
return bs[idx];
}
@Override
public int getNormal(int idx) {
return ns[idx];
}
@Override
public int getColorIndex() {
return colorIndex;
}
@Override
public TextureAtlasSprite rubidium$getSprite() {
return null;
}
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;
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;
zs[vi] = Float.intBitsToFloat(rawBuffer[i + 2]) + offsetZ;
us[vi] = Float.intBitsToFloat(rawBuffer[i + 3]);
vs[vi] = Float.intBitsToFloat(rawBuffer[i + 4]);
cs[vi] = flags.hasColor ? rawBuffer[i + 5] : DEFAULT_COLOR;
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;
}
if(vertices == 3) {
// Quadrangulate!
xs[3] = xs[2];
ys[3] = ys[2];
zs[3] = zs[2];
us[3] = us[2];
vs[3] = vs[2];
bs[3] = bs[2];
cs[3] = cs[2];
ns[3] = ns[2];
}
}
public void setState(int[] rawBuffer, int offset, BlockRenderer.Flags flags, int drawMode, float offsetX, float offsetY, float offsetZ) {
deleted = false;
read(rawBuffer, offset, offsetX, offsetY, offsetZ, drawMode, flags);
if(xs[0] == xs[1] && xs[1] == xs[2] && xs[2] == xs[3] && ys[0] == ys[1] && ys[1] == ys[2] && ys[2] == ys[3]) {
// ignore empty quads (e.g. alpha pass of EnderIO item conduits)
deleted = true;
return;
}
vectorA.set(xs[1] - xs[0], ys[1] - ys[0], zs[1] - zs[0]);
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.cachedFlags = ModelQuadFlags.getQuadFlags(this);
}
public static boolean isValid(Quad q) {
return q != null && !q.deleted;
}
@Override
public String toString() {
return String.format(Locale.ENGLISH, "%s[(%.1f, %.1f, %.1f), (%.1f, %.1f, %.1f), (%.1f, %.1f, %.1f), (%.1f, %.1f, %.1f)]", deleted ? "XXX " : "", xs[0], ys[0], zs[0], xs[1], ys[1], zs[1], xs[2], ys[2], zs[2], xs[3], ys[3], zs[3]);
}
}
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class ItemVBOQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class ItemVBOQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class PositionColorTextureQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class PositionColorTextureQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class PositionQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class PositionQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class PositionTextureColorQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class PositionTextureColorQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -1,7 +1,7 @@
package com.gtnewhorizons.angelica.compat.nd.writers;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.nd.IWriteQuads;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import java.nio.ByteBuffer;
@@ -17,7 +17,7 @@ public class PositionTextureQuadWriter implements IWriteQuads {
this.direct = direct;
}
@Override
public void writeQuad(Quad quad, ByteBuffer buf) {
public void writeQuad(QuadView quad, ByteBuffer buf) {
if(direct) {
writeQuadDirect(quad, buf);
} else {
@@ -25,11 +25,11 @@ public class PositionTextureQuadWriter implements IWriteQuads {
}
}
protected void writeQuadDirect(Quad quad, ByteBuffer buf) {
protected void writeQuadDirect(QuadView quad, ByteBuffer buf) {
throw new UnsupportedOperationException("Direct mode not supported yet");
}
protected void writeQuadIndirect(Quad quad, ByteBuffer buf) {
protected void writeQuadIndirect(QuadView quad, ByteBuffer buf) {
for(int idx = 0; idx < 4; ++idx) {
// Position
buf.putFloat(quad.getX(idx));
@@ -23,6 +23,11 @@ public class AngelicaConfig {
@Config.RequiresMcRestart
public static boolean injectQPRendering;
@Config.Comment("Enable Angelica's test blocks")
@Config.DefaultBoolean(false)
@Config.Ignore()
public static boolean enableTestBlocks;
@Config.Comment("Enable Iris Shaders [Requires Sodium]")
@Config.DefaultBoolean(false)
@Config.RequiresMcRestart
@@ -1,16 +1,15 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.client.renderer.CapturingTessellator;
import com.gtnewhorizons.angelica.compat.mojang.VertexBuffer;
import com.gtnewhorizons.angelica.compat.mojang.VertexFormat;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import net.minecraft.client.renderer.Tessellator;
import org.lwjgl.opengl.GL11;
import java.nio.ByteBuffer;
import java.util.List;
import org.lwjgl.opengl.GL11;
@SuppressWarnings("unused")
public class TessellatorManager {
private static final ThreadLocal<CapturingTessellator> capturingTessellator = ThreadLocal.withInitial(CapturingTessellator::new);
@@ -51,7 +50,7 @@ public class TessellatorManager {
* Stop the CapturingTessellator and return the pooled quads. The quads are valid until clearQuads() is
* called on the CapturingTesselator, which must be done before starting capturing again.
*/
public static List<Quad> stopCapturingToPooledQuads() {
public static List<QuadView> stopCapturingToPooledQuads() {
if(!currentlyCapturing.get()) throw new IllegalStateException("Tried to stop capturing when not capturing!");
currentlyCapturing.set(false);
final CapturingTessellator tess = capturingTessellator.get();
@@ -59,7 +58,7 @@ public class TessellatorManager {
// Be sure we got all the quads
if(tess.isDrawing) tess.draw();
final List<Quad> quads = tess.getQuads();
final List<QuadView> quads = tess.getQuads();
tess.discard();
tess.restoreTranslation();
@@ -1,8 +1,8 @@
package com.gtnewhorizons.angelica.glsm;
import com.gtnewhorizons.angelica.compat.mojang.VertexBuffer;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.objects.ObjectList;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
public class VBOManager {
// Not thread safe, only expected to be called from the main thread
@@ -13,7 +13,7 @@ public class VBOManager {
return nextDisplayList++;
}
private static ObjectList<VertexBuffer> vertexBuffers = new ObjectArrayList<>(1);
private static Int2ObjectMap<VertexBuffer> vertexBuffers = new Int2ObjectOpenHashMap<>();
/*
* Allocate a (range) of "display list IDs" that will refer to a VBO in the arraylist of vertex buffers.
@@ -33,16 +33,13 @@ public class VBOManager {
public static VertexBuffer registerVBO(int displayList, VertexBuffer vertexBuffer) {
if(displayList > 0) throw new IllegalArgumentException("Display list must be negative!");
displayList -= Integer.MIN_VALUE;
final int requestedSize = displayList + 1;
if(requestedSize + 1 > vertexBuffers.size()) {
vertexBuffers.size(requestedSize);
}
vertexBuffers.set(displayList, vertexBuffer);
vertexBuffers.put(displayList, vertexBuffer);
return vertexBuffer;
}
public static VertexBuffer get(int list) {
list -= Integer.MIN_VALUE;
return vertexBuffers.get(list);
return vertexBuffers.getOrDefault(list, null);
}
}
@@ -50,6 +50,9 @@ public class AngelicaTweaker implements IFMLLoadingPlugin, IEarlyMixinLoader {
AngelicaConfig.enableIris = Boolean.parseBoolean(System.getProperty("angelica.enableShaders", "false"));
AngelicaConfig.enableMCPatcherForgeFeatures = Boolean.parseBoolean(System.getProperty("angelica.enableMCPatcherForgeFeatures", "false"));
// Debug features
AngelicaConfig.enableTestBlocks = Boolean.parseBoolean(System.getProperty("angelica.enableTestBlocks", "false"));
} catch (ConfigException e) {
throw new RuntimeException(e);
}
@@ -2,7 +2,7 @@ package com.gtnewhorizons.angelica.mixins.early.angelica.animation;
import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache;
import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils;
import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFire;
import net.minecraft.client.renderer.RenderBlocks;
@@ -27,7 +27,7 @@ public class MixinRenderBlocks implements ITexturesCache {
@Shadow
public IIcon overrideBlockTexture;
private Set<IIcon> renderedSprites = new ReferenceOpenHashSet<>();
private Set<IIcon> renderedSprites = new ObjectOpenHashSet<>();
/**
* @author laetansky Here where things get very tricky. We can't just mark blocks textures for update because this
@@ -66,7 +66,7 @@ public class MixinRenderBlocks implements ITexturesCache {
return icon;
}
@Inject(method = "drawCrossedSquares", at = @At("HEAD"))
public void angelica$markCrossedSquaresAnimationForUpdate(IIcon icon, double p_147765_2_, double p_147765_4_, double p_147765_6_, float p_147765_8_,
CallbackInfo ci) {
@@ -1,25 +1,28 @@
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.utils.ObjectPooler;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.objects.ObjectImmutableList;
import java.util.List;
import java.util.Random;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import it.unimi.dsi.fastutil.objects.ObjectImmutableList;
import net.minecraft.block.Block;
import net.minecraft.block.BlockAir;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Unique;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
@Mixin(BlockAir.class)
public abstract class MixinBlockAir implements QuadProvider {
private static List<Quad> quads = ObjectImmutableList.of();
@Unique
private static final List<QuadView> angelica$EMPTY = ObjectImmutableList.of();
public List<Quad> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, ObjectPooler<Quad> quadPool) {
return quads;
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return angelica$EMPTY;
}
}
@@ -1,12 +1,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.utils.ObjectPooler;
import java.util.List;
import java.util.Random;
import com.gtnewhorizons.angelica.models.CubeModel;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import net.minecraft.block.Block;
import net.minecraft.block.BlockLeaves;
import net.minecraft.block.material.Material;
@@ -14,14 +10,23 @@ import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.spongepowered.asm.mixin.Mixin;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
import static com.gtnewhorizons.angelica.models.CubeModel.INSTANCE;
@Mixin(BlockLeaves.class)
public abstract class MixinBlockLeaves extends Block implements QuadProvider {
// TODO: Use modern model API
private static final ThreadLocal<QuadProvider> model = ThreadLocal.withInitial(() -> new CubeModel(true));
@Override
public boolean isDynamic() {
return true;
}
public List<Quad> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, ObjectPooler<Quad> quadPool) {
return model.get().getQuads(world, pos, block, meta, dir, random, quadPool);
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return INSTANCE.get().getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
private MixinBlockLeaves(Material materialIn) {
@@ -1,23 +1,24 @@
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.utils.ObjectPooler;
import java.util.List;
import java.util.Random;
import com.gtnewhorizons.angelica.models.CubeModel;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.models.VanillaModels;
import net.minecraft.block.Block;
import net.minecraft.block.BlockStone;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.spongepowered.asm.mixin.Mixin;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
@Mixin(BlockStone.class)
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);
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return VanillaModels.stoneModel.getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
}
@@ -1,23 +1,24 @@
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.utils.ObjectPooler;
import java.util.List;
import java.util.Random;
import com.gtnewhorizons.angelica.models.CubeModel;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.models.CubeModel;
import net.minecraft.block.Block;
import net.minecraft.block.BlockWorkbench;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.spongepowered.asm.mixin.Mixin;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
@Mixin(BlockWorkbench.class)
public class MixinBlockWorkbench 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);
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return CubeModel.INSTANCE.get().getQuads(world, pos, block, meta, dir, random, color, quadPool);
}
}
@@ -1,228 +1,54 @@
package com.gtnewhorizons.angelica.models;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import com.gtnewhorizons.angelica.utils.ObjectPooler;
import com.gtnewhorizons.angelica.api.QuadView;
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;
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
import net.minecraft.block.Block;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import static org.lwjgl.opengl.GL11.GL_QUADS;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public class CubeModel implements QuadProvider {
/*
* GL only cares if the coords are clockwise or counterclockwise - not the specific order [1].
* Which mean I get to decide it! Behold, Omni's Standard Cube Vertex Order (TM)!
*
* SOUTH (+z)
* (x + 1, y + 1, z + 1)
* 5 - - - - - - - - - 6
* | \ | \
* | \ | \
* | \ | \
* | 4 - - - - - - - - - 7
* | | | |
* | | | |
* | | | |
* 1 - - - | - - - - - 2 |
* \ | \ |
* <- WEST (-x) \ | \ | EAST (+x) ->
* \ | \ |
* 0 - - - - - - - - - 3
* (x, y, z)
* NORTH (-z)
*
* The horizontal directions are labeled, up and down should be obvious (and would be annoying to add).
* Vertices are written in counterclockwise order, as viewed from outside the cube, to orient the quad properly.
* (x, y, z) is the world pos of the block. 0 and 6 have been labeled, you can figure out the rest.
*
* [1] So apparently I was a bit wrong. GL doesn't care, but Sodium does because that's how it applies AO.
* Change it if you dare!
* By the power of ~~theft~~ inspiration, this class is wayyy simpler.
* It's also a basic example of dynamic model building.
*/
// I'm sure the following constants could be condensed to a single magic array, but for clarity's sake they remain.
public static final ThreadLocal<CubeModel> INSTANCE = ThreadLocal.withInitial(CubeModel::new);
private final NdQuadBuilder builder = new NdQuadBuilder();
private static final List<QuadView> EMPTY = ObjectImmutableList.of();
private final List<QuadView> ONE = new ObjectArrayList<>(1);
// The (x, y, z) positions of the vertices
private static final int[][] vertices = {
{ 0, 0, 0 },
{ 0, 0, 1 },
{ 1, 0, 1 },
{ 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 1, 1 },
{ 1, 1, 1 },
{ 1, 1, 0 }
};
public CubeModel() {
private static final int[][] uv = {
{ 0, 0 },
{ 0, 1 },
{ 1, 1 },
{ 1, 0 }
};
// Add the UV.
private static final int[][][] shiftsByDirection = {
// DOWN 1 0 3 2
{
vertices[1],
vertices[0],
vertices[3],
vertices[2]
},
//UP 4 5 6 7
{
vertices[4],
vertices[5],
vertices[6],
vertices[7]
},
//NORTH 7 3 0 4
{
vertices[7],
vertices[3],
vertices[0],
vertices[4]
},
//SOUTH 5 1 2 6
{
vertices[5],
vertices[1],
vertices[2],
vertices[6]
},
//WEST 4 0 1 5
{
vertices[4],
vertices[0],
vertices[1],
vertices[5]
},
//EAST 6 2 3 7
{
vertices[6],
vertices[2],
vertices[3],
vertices[7]
}
};
private static final int[][] initBufs = new int[6][32];
static {
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
final int dirI = dir.ordinal();
int[][] shifts = shiftsByDirection[dirI];
for (int vi = 0; vi < 4; ++vi) {
final int i = vi * 8;
// XYZ
initBufs[dirI][i + 0] = Float.floatToIntBits(shifts[vi][0]);
initBufs[dirI][i + 1] = Float.floatToIntBits(shifts[vi][1]);
initBufs[dirI][i + 2] = Float.floatToIntBits(shifts[vi][2]);
// UV
initBufs[dirI][i + 3] = Float.floatToIntBits(0);
initBufs[dirI][i + 4] = Float.floatToIntBits(0);
// Color, normal, brightness
initBufs[dirI][i + 5] = 0xFFFFFFFF;
initBufs[dirI][i + 6] = 0;
initBufs[dirI][i + 7] = 15_728_880; // 15 sky 15 block
}
}
}
public static final ThreadLocal<CubeModel> INSTANCE = ThreadLocal.withInitial(() -> new CubeModel(false));
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();
private final List<Quad> ONE = new ObjectArrayList<>(1);
public CubeModel(boolean colorized) {
Arrays.fill(this.colorized, colorized);
this.ONE.add(null);
}
public CubeModel(boolean[] colorized) {
System.arraycopy(colorized, 0, this.colorized, 0, 6);
this.ONE.add(null);
}
@Override
public List<Quad> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, ObjectPooler<Quad> quadPool) {
public boolean isDynamic() {
return true;
}
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
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;
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.get()));
return ONE;
}
}
@@ -0,0 +1,68 @@
package com.gtnewhorizons.angelica.models;
import com.gtnewhorizons.angelica.compat.mojang.Axis;
import me.jellysquid.mods.sodium.client.model.quad.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
* designed to be usable without the default renderer.
*/
public abstract class GeometryHelper {
/**
* 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));
}
/**
* 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 -> ForgeDirection.UP; // handle WTF case
};
}
/**
* @see #longestAxis(float, float, float)
*/
public static Axis longestAxis(Vector3f vec) {
return longestAxis(vec.x(), vec.y(), vec.z());
}
/**
* Identifies the largest (max absolute magnitude) component (X, Y, Z) in the given vector.
*/
public static Axis longestAxis(float normalX, float normalY, float normalZ) {
Axis result = Axis.Y;
float longest = Math.abs(normalY);
float a = Math.abs(normalX);
if (a > longest) {
result = Axis.X;
longest = a;
}
return Math.abs(normalZ) > longest
? Axis.Z : result;
}
}
@@ -0,0 +1,208 @@
This package is licensed under the LGPLv3 for the general public, as noted in the main license file.
The original files were licensed under the Apache License, Version 2.0.
Copyright (c) 2016, 2017, 2018, 2019 FabricMC
Fabric may use this package under either the LGPLv3 or the Apache License, Version 2.0, reproduced below.
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
@@ -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,462 @@
package com.gtnewhorizons.angelica.models;
import com.gtnewhorizons.angelica.api.QuadView;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import lombok.Getter;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadView;
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFlags;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
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 java.util.Arrays;
public class NdQuadBuilder implements ModelQuadView {
/**
* Causes texture to appear with no rotation.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_ROTATE_NONE = 0;
/**
* Causes texture to appear rotated 90 deg. clockwise relative to nominal face.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_ROTATE_90 = 1;
/**
* Causes texture to appear rotated 180 deg. relative to nominal face.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_ROTATE_180 = 2;
/**
* Causes texture to appear rotated 270 deg. clockwise relative to nominal face.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_ROTATE_270 = 3;
/**
* When enabled, texture coordinate are assigned based on vertex position.
* Any existing UV coordinates will be replaced.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*
* <p>UV lock always derives texture coordinates based on nominal face, even
* when the quad is not co-planar with that face, and the result is
* the same as if the quad were projected onto the nominal face, which
* is usually the desired result.
*/
public static final int BAKE_LOCK_UV = 4;
/**
* When set, U texture coordinates for the given sprite are
* flipped as part of baking. Can be useful for some randomization
* and texture mapping scenarios. Results are different from what
* can be obtained via rotation and both can be applied.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_FLIP_U = 8;
/**
* Same as {@link #BAKE_FLIP_U} but for V coordinate.
*/
public static final int BAKE_FLIP_V = 16;
/**
* UV coordinates by default are assumed to be 0-16 scale for consistency
* with conventional Minecraft model format. This is scaled to 0-1 during
* baking before interpolation. Model loaders that already have 0-1 coordinates
* can avoid wasteful multiplication/division by passing 0-1 coordinates directly.
* Pass in bakeFlags parameter to {@link #spriteBake(IIcon, int)}.
*/
public static final int BAKE_NORMALIZED = 32;
/**
* Tolerance for determining if the depth parameter to {@link #square(ForgeDirection, float, float, float, float, float)}
* is effectively zero - meaning the face is a cull face.
*/
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.QUAD_STRIDE];
private int geometryFlags = 0;
private boolean isGeometryInvalid = true;
private int tag = 0;
@Getter
private int colorIndex = -1;
final Vector3f faceNormal = new Vector3f();
public final Material mat = new Material();
/**
* Dumps to {@param out} and returns it.
*/
public QuadView build(QuadView out) {
// 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.geometryFlags);
this.clear();
return out;
}
public void clear() {
Arrays.fill(this.data, 0);
this.cullFace = ForgeDirection.UNKNOWN;
this.nominalFace = ForgeDirection.UNKNOWN;
this.lightFace = ForgeDirection.UP;
this.geometryFlags = 0;
this.isGeometryInvalid = true;
this.tag(0);
this.colorIndex(-1);
this.mat.reset();
}
/**
* Set vertex color in ARGB format (0xAARRGGBB).
*/
public void color(int vertexIndex, int color) {
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.COLOR_INDEX] = color;
}
/**
* Convenience: set vertex color for all vertices at once.
*/
public void color(int c0, int c1, int c2, int c3) {
this.color(0, c0);
this.color(1, c1);
this.color(2, c2);
this.color(3, c3);
}
/**
* Value functions identically to {@link Quad#getColorIndex()} and is
* used by renderer / model builder in same way. Default value is -1.
*/
public void colorIndex(int colorIndex) {
this.colorIndex = colorIndex;
}
private void computeGeometry() {
if (this.isGeometryInvalid) {
this.isGeometryInvalid = false;
NormalHelper.computeFaceNormal(this.faceNormal, this);
// depends on face normal
this.lightFace = GeometryHelper.lightFace(this);
// depends on light face
this.geometryFlags = ModelQuadFlags.getQuadFlags(this);
}
}
/**
* 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)
*/
public final ForgeDirection cullFace() {
return this.cullFace;
}
/**
* 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.
* Also controls face culling during block rendering.
*
* <p>{@link ForgeDirection#UNKNOWN} by default.
*
* <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#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 #getLightFace()}.
*/
public void cullFace(ForgeDirection dir) {
this.cullFace = dir;
this.nominalFace(dir);
}
private boolean hasShade() {
return this.mat.getDiffuse();
}
@Override
@NotNull
public ForgeDirection getLightFace() {
this.computeGeometry();
return this.lightFace;
}
/**
* Provides a hint to renderer about the facing of this quad. Not required,
* but if provided can shortcut some geometric analysis if the quad is parallel to a block face.
* Should be the expected value of {@link #getLightFace()}. Value will be confirmed
* and if invalid the correct light face will be calculated.
*
* <p>Null by default, and set automatically by {@link #cullFace(ForgeDirection)}.
*
* <p>Models may also find this useful as the face for texture UV locking and rotation semantics.
*
* <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 #getLightFace()}.
*/
public void nominalFace(@Nullable ForgeDirection face) {
nominalFace = face;
}
/**
* See {@link #nominalFace(ForgeDirection)}
*/
public ForgeDirection nominalFace() {
return nominalFace;
}
/**
* Sets the geometric vertex position for the given vertex,
* relative to block origin, (0,0,0). Minecraft rendering is designed
* for models that fit within a single block space and is recommended
* that coordinates remain in the 0-1 range, with multi-block meshes
* split into multiple per-block models.
*/
public void pos(int vertexIndex, float x, float y, float z) {
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.X_INDEX] = Float.floatToRawIntBits(x);
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Y_INDEX] = Float.floatToRawIntBits(y);
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Z_INDEX] = Float.floatToRawIntBits(z);
isGeometryInvalid = true;
}
public Vector3f pos(int vertexIndex) {
return new Vector3f(
Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.X_INDEX]),
Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Y_INDEX]),
Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Z_INDEX])
);
}
/**
* Convenience: access x, y, z by index 0-2.
*/
float posByIndex(int vertexIndex, int coordinateIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.X_INDEX + coordinateIndex]);
}
/**
* Convienence, gets the icon from the block atlas. See {@link #spriteBake(IIcon, int)}
*/
public void spriteBake(String spriteName, int bakeFlags) {
final IIcon icon = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(spriteName);
TexHelper.bakeSprite(this, icon, bakeFlags);
}
/**
* Assigns sprite atlas u,v coordinates to this quad for the given sprite.
* Can handle UV locking, rotation, interpolation, etc. Control this behavior
* by passing additive combinations of the BAKE_ flags defined in this interface.
*/
public void spriteBake(IIcon sprite, int bakeFlags) {
TexHelper.bakeSprite(this, sprite, bakeFlags);
}
/**
* Helper method to assign vertex coordinates for a square aligned with the given face.
* Ensures that vertex order is consistent with vanilla convention. (Incorrect order can
* lead to bad AO lighting unless enhanced lighting logic is available/enabled.)
*
* <p>Square will be parallel to the given face and coplanar with the face (and culled if the
* face is occluded) if the depth parameter is approximately zero. See {@link #CULL_FACE_EPSILON}.
*
* <p>All coordinates should be normalized (0-1).
*
* <p>The directions for the faces assume you're looking at them. For top and bottom, they assume you're looking north.
*/
public void square(ForgeDirection nominalFace, float left, float bottom, float right, float top, float depth) {
if (Math.abs(depth) < CULL_FACE_EPSILON) {
cullFace(nominalFace);
depth = 0; // avoid any inconsistency for face quads
} else {
cullFace(ForgeDirection.UNKNOWN);
}
nominalFace(nominalFace);
switch (nominalFace) {
case UP:
depth = 1 - depth;
top = 1 - top;
bottom = 1 - bottom;
case DOWN:
pos(0, left, depth, top);
pos(1, left, depth, bottom);
pos(2, right, depth, bottom);
pos(3, right, depth, top);
break;
case EAST:
depth = 1 - depth;
left = 1 - left;
right = 1 - right;
case WEST:
pos(0, depth, top, left);
pos(1, depth, bottom, left);
pos(2, depth, bottom, right);
pos(3, depth, top, right);
break;
case SOUTH:
depth = 1 - depth;
left = 1 - left;
right = 1 - right;
case NORTH:
pos(0, 1 - left, top, depth);
pos(1, 1 - left, bottom, depth);
pos(2, 1 - right, bottom, depth);
pos(3, 1 - right, top, depth);
break;
}
}
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
* transformation or filtering on static meshes.
*/
public void tag(int tag) {
this.tag = tag;
}
/**
* Set texture coordinates.
*/
public void uv(int vertexIndex, float u, float v) {
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.U_INDEX] = Float.floatToRawIntBits(u);
data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.V_INDEX] = Float.floatToRawIntBits(v);
}
@Override
public float getX(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.X_INDEX]);
}
@Override
public float getY(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Y_INDEX]);
}
@Override
public float getZ(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.Z_INDEX]);
}
@Override
public float getTexU(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.U_INDEX]);
}
@Override
public float getTexV(int vertexIndex) {
return Float.intBitsToFloat(data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.V_INDEX]);
}
@Override
public int getColor(int vertexIndex) {
return this.data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.COLOR_INDEX];
}
@Override
public int getNormal(int vertexIndex) {
return this.data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.NORMAL_INDEX];
}
@Override
public int getLight(int vertexIndex) {
return this.data[vertexIndex * Quad.INTS_PER_VERTEX + Quad.LIGHTMAP_INDEX];
}
@Override
public int getFlags() {
return this.geometryFlags;
}
@Override
public TextureAtlasSprite rubidium$getSprite() {
return null;
}
/**
* 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) {
return switch (side) {
case DOWN -> switch (index) {
case 0 -> new Vector3f(from.x, from.y, to.z);
case 1 -> new Vector3f(from.x, from.y, from.z);
case 2 -> new Vector3f(to.x, from.y, from.z);
case 3 -> new Vector3f(to.x, from.y, to.z);
default -> throw new RuntimeException("Too many indices!");
};
case UP -> switch (index) {
case 0 -> new Vector3f(from.x, to.y, from.z);
case 1 -> new Vector3f(from.x, to.y, to.z);
case 2 -> new Vector3f(to.x, to.y, to.z);
case 3 -> new Vector3f(to.x, to.y, from.z);
default -> throw new RuntimeException("Too many indices!");
};
case NORTH -> switch (index) {
case 0 -> new Vector3f(to.x, to.y, from.z);
case 1 -> new Vector3f(to.x, from.y, from.z);
case 2 -> new Vector3f(from.x, from.y, from.z);
case 3 -> new Vector3f(from.x, to.y, from.z);
default -> throw new RuntimeException("Too many indices!");
};
case SOUTH -> switch (index) {
case 0 -> new Vector3f(from.x, to.y, to.z);
case 1 -> new Vector3f(from.x, from.y, to.z);
case 2 -> new Vector3f(to.x, from.y, to.z);
case 3 -> new Vector3f(to.x, to.y, to.z);
default -> throw new RuntimeException("Too many indices!");
};
case WEST -> switch (index) {
case 0 -> new Vector3f(from.x, to.y, from.z);
case 1 -> new Vector3f(from.x, from.y, from.z);
case 2 -> new Vector3f(from.x, from.y, to.z);
case 3 -> new Vector3f(from.x, to.y, to.z);
default -> throw new RuntimeException("Too many indices!");
};
case EAST -> switch (index) {
case 0 -> new Vector3f(to.x, to.y, to.z);
case 1 -> new Vector3f(to.x, from.y, to.z);
case 2 -> new Vector3f(to.x, from.y, from.z);
case 3 -> new Vector3f(to.x, to.y, from.z);
default -> throw new RuntimeException("Too many indices!");
};
case UNKNOWN -> null;
};
}
}
@@ -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.getX(0);
final float y0 = q.getY(0);
final float z0 = q.getZ(0);
final float x1 = q.getX(1);
final float y1 = q.getY(1);
final float z1 = q.getZ(1);
final float x2 = q.getX(2);
final float y2 = q.getY(2);
final float z2 = q.getZ(2);
final float x3 = q.getX(3);
final float y3 = q.getY(3);
final float z3 = q.getZ(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,86 @@
package com.gtnewhorizons.angelica.models;
import net.minecraft.util.IIcon;
import net.minecraftforge.common.util.ForgeDirection;
public class TexHelper {
private static final float NORMALIZER = 1f / 16f;
private static final VertexModifier[] UVLOCKERS = new VertexModifier[6];
static {
UVLOCKERS[ForgeDirection.EAST.ordinal()] = (q, i) -> q.uv(i, 1 - q.getZ(i), 1 - q.getY(i));
UVLOCKERS[ForgeDirection.WEST.ordinal()] = (q, i) -> q.uv(i, q.getZ(i), 1 - q.getY(i));
UVLOCKERS[ForgeDirection.NORTH.ordinal()] = (q, i) -> q.uv(i, 1 - q.getX(i), 1 - q.getY(i));
UVLOCKERS[ForgeDirection.SOUTH.ordinal()] = (q, i) -> q.uv(i, q.getX(i), 1 - q.getY(i));
UVLOCKERS[ForgeDirection.DOWN.ordinal()] = (q, i) -> q.uv(i, q.getX(i), 1 - q.getZ(i));
UVLOCKERS[ForgeDirection.UP.ordinal()] = (q, i) -> q.uv(i, q.getX(i), q.getZ(i));
}
private static final VertexModifier[] ROTATIONS = new VertexModifier[] {
null,
(q, i) -> q.uv(i, q.getTexV(i), 1 - q.getTexU(i)), //90
(q, i) -> q.uv(i, 1 - q.getTexU(i), 1 - q.getTexV(i)), //180
(q, i) -> q.uv(i, 1 - q.getTexV(i), q.getTexU(i)) // 270
};
private static void applyModifier(NdQuadBuilder quad, VertexModifier modifier) {
for (int i = 0; i < 4; i++) {
modifier.apply(quad, i);
}
}
/**
* Bakes textures in the provided vertex data, handling UV locking,
* rotation, interpolation, etc. Textures must not be already baked.
*/
public static void bakeSprite(NdQuadBuilder quad, IIcon sprite, int bakeFlags) {
if (quad.nominalFace() != ForgeDirection.UNKNOWN && (NdQuadBuilder.BAKE_LOCK_UV & bakeFlags) != 0) {
// Assigns normalized UV coordinates based on vertex positions
applyModifier(quad, UVLOCKERS[quad.nominalFace().ordinal()]);
} else if ((NdQuadBuilder.BAKE_NORMALIZED & bakeFlags) == 0) { // flag is NOT set, UVs are assumed to not be normalized yet as is the default, normalize through dividing by 16
// Scales from 0-16 to 0-1
applyModifier(quad, (q, i) -> q.uv(i, q.getTexU(i) * NORMALIZER, q.getTexV(i) * NORMALIZER));
}
final int rotation = bakeFlags & 3;
if (rotation != 0) {
// Rotates texture around the center of sprite.
// Assumes normalized coordinates.
applyModifier(quad, ROTATIONS[rotation]);
}
if ((NdQuadBuilder.BAKE_FLIP_U & bakeFlags) != 0) {
// Inverts U coordinates. Assumes normalized (0-1) values.
applyModifier(quad, (q, i) -> q.uv(i, 1 - q.getTexU(i), q.getTexV(i)));
}
if ((NdQuadBuilder.BAKE_FLIP_V & bakeFlags) != 0) {
// Inverts V coordinates. Assumes normalized (0-1) values.
applyModifier(quad, (q, i) -> q.uv(i, q.getTexU(i), 1 - q.getTexV(i)));
}
interpolate(quad, sprite);
}
/**
* Faster than sprite method. Sprite computes span and normalizes inputs each call,
* so we'd have to denormalize before we called, only to have the sprite renormalize immediately.
*/
private static void interpolate(NdQuadBuilder q, IIcon sprite) {
final float uMin = sprite.getMinU();
final float uSpan = sprite.getMaxU() - uMin;
final float vMin = sprite.getMinV();
final float vSpan = sprite.getMaxV() - vMin;
for (int i = 0; i < 4; i++) {
q.uv(i, uMin + q.getTexU(i) * uSpan, vMin + q.getTexV(i) * vSpan);
}
}
@FunctionalInterface
private interface VertexModifier {
void apply(NdQuadBuilder quad, int vertexIndex);
}
}
@@ -0,0 +1,22 @@
package com.gtnewhorizons.angelica.models;
import com.gtnewhorizons.angelica.models.json.JsonModel;
import com.gtnewhorizons.angelica.models.json.Loader;
import com.gtnewhorizons.angelica.models.json.Variant;
import net.minecraft.util.ResourceLocation;
public class VanillaModels {
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);
}
}
@@ -0,0 +1,365 @@
package com.gtnewhorizons.angelica.models.json;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.gtnewhorizons.angelica.api.BlockPos;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.compat.mojang.Axis;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import com.gtnewhorizons.angelica.models.NdQuadBuilder;
import com.gtnewhorizons.angelica.utils.DirUtil;
import it.unimi.dsi.fastutil.Function;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.objects.ObjectImmutableList;
import lombok.Getter;
import net.minecraft.block.Block;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.Nullable;
import org.joml.Matrix4f;
import org.joml.Vector3f;
import org.joml.Vector4f;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.function.Supplier;
import static com.gtnewhorizons.angelica.utils.JsonUtil.*;
import static me.jellysquid.mods.sodium.common.util.DirectionUtil.ALL_DIRECTIONS;
public class JsonModel implements QuadProvider {
@Nullable
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;
private List<QuadView> allQuadStore = new ObjectArrayList<>();
private final Map<ForgeDirection, List<QuadView>> sidedQuadStore = new Object2ObjectOpenHashMap<>();
private static final List<QuadView> EMPTY = ObjectImmutableList.of();
JsonModel(@Nullable ResourceLocation parentId, boolean useAO, Map<ModelDisplay.Position, ModelDisplay> display, Map<String, String> textures, List<ModelElement> elements) {
this.parentId = parentId;
this.useAO = useAO;
this.display = display;
this.textures = textures;
this.elements = elements;
}
/**
* Makes a shallow copy of og. This allows you to bake the same model multiple times with various transformations.
*/
JsonModel(JsonModel og) {
this.parentId = og.parentId;
this.parent = og.parent;
this.useAO = og.useAO;
this.display = og.display;
this.textures = og.textures;
this.elements = og.elements;
}
public void bake(Variant v) {
final Matrix4f vRot = v.getAffineMatrix();
final NdQuadBuilder builder = new NdQuadBuilder();
// Append faces from each element
for (ModelElement e : this.elements) {
final Matrix4f rot = (e.getRotation() == null)
? ModelElement.Rotation.NOOP.getAffineMatrix()
: e.getRotation().getAffineMatrix();
final Vector3f from = e.getFrom();
final Vector3f to = e.getTo();
for (ModelElement.Face f : e.getFaces()) {
// Assign vertexes
for (int i = 0; i < 4; ++i) {
final Vector3f vert =
rot.transformPosition(NdQuadBuilder.mapSideToVertex(from, to, i, f.getName()));
vRot.transformPosition(vert);
builder.pos(i, vert.x, vert.y, vert.z);
}
// Set culling and nominal faces
builder.cullFace(f.getCullFace());
builder.nominalFace(f.getName());
// Set bake flags
int flags = switch(f.getRotation()) {
case 90 -> NdQuadBuilder.BAKE_ROTATE_90;
case 180 -> NdQuadBuilder.BAKE_ROTATE_180;
case 270 -> NdQuadBuilder.BAKE_ROTATE_270;
default -> NdQuadBuilder.BAKE_ROTATE_NONE;
};
// Set UV
final Vector4f uv = f.getUv();
if (uv != null) {
builder.uv(0, uv.x, uv.y);
builder.uv(1, uv.x, uv.w);
builder.uv(2, uv.z, uv.w);
builder.uv(3, uv.z, uv.y);
} else {
// Not sure if this is correct, but it seems to fix things
flags |= NdQuadBuilder.BAKE_LOCK_UV;
}
// Set the sprite
builder.spriteBake(this.textures.get(f.getTexture()), flags);
// Set the tint index
final int tint = f.getTintIndex();
builder.color(tint, tint, tint, tint);
// Set AO
builder.mat.setAO(this.useAO);
// Bake and add it
final QuadView q = builder.build(new Quad());
this.allQuadStore.add(q);
this.sidedQuadStore.computeIfAbsent(f.getCullFace(),
o -> new ObjectArrayList<>()).add(q);
}
}
// Lock the lists.
this.allQuadStore = new ObjectImmutableList<>(this.allQuadStore);
for (ForgeDirection f : ALL_DIRECTIONS) {
List<QuadView> l = this.sidedQuadStore.computeIfAbsent(f, o -> EMPTY);
if (!l.isEmpty())
this.sidedQuadStore.put(f, new ObjectImmutableList<>(l));
}
}
public List<ResourceLocation> getParents() {
return Arrays.asList(parentId);
}
@Override
public List<QuadView> getQuads(IBlockAccess world, BlockPos pos, Block block, int meta, ForgeDirection dir, Random random, int color, Supplier<QuadView> quadPool) {
return this.sidedQuadStore.getOrDefault(dir, EMPTY);
}
public void resolveParents(Function<ResourceLocation, JsonModel> modelLoader) {
if (this.parentId != null && this.parent == null) {
final JsonModel p = modelLoader.apply(this.parentId);
p.resolveParents(modelLoader);
// Inherit properties
this.parent = p;
if (this.elements.isEmpty()) this.elements = this.parent.elements;
// Resolve texture variables
// Add parent texture mappings, but prioritize ours.
for (Map.Entry<String, String> e : this.parent.textures.entrySet()) {
this.textures.putIfAbsent(e.getKey(), e.getValue());
}
// Flatten them, merging s -> s1, s1 -> s2 to s -> s2, s1 -> s2.
boolean flat = false;
final Map<String, String> tmp = new Object2ObjectOpenHashMap<>();
while (!flat) {
flat = true;
for (Map.Entry<String, String> e : this.textures.entrySet()) {
// If there is a value in the key set, replace with the value it points to
// Also avoid adding a loop
if (this.textures.containsKey(e.getValue())) {
if (!e.getKey().equals(e.getValue()))
tmp.put(e.getKey(), this.textures.get(e.getValue()));
else tmp.put(e.getKey(), "");
flat = false;
} else {
tmp.put(e.getKey(), e.getValue());
}
}
this.textures.putAll(tmp);
}
}
}
static class Deserializer implements JsonDeserializer<JsonModel> {
private Vector3f loadVec3(JsonObject in, String name) {
final JsonArray arr = in.getAsJsonArray(name);
final Vector3f ret = new Vector3f();
for (int i = 0; i < 3; ++i) {
ret.setComponent(i, arr.get(i).getAsFloat());
}
return ret;
}
private Vector4f loadVec4(JsonObject in, String name) {
final JsonArray arr = in.getAsJsonArray(name);
final Vector4f ret = new Vector4f();
for (int i = 0; i < 4; ++i) {
ret.setComponent(i, arr.get(i).getAsFloat());
}
return ret;
}
private ModelDisplay loadADisplay(JsonObject in) {
final Vector3f rotation = loadVec3(in, "rotation");
final Vector3f translation = loadVec3(in, "translation");
final Vector3f scale = loadVec3(in, "scale");
return new ModelDisplay(rotation, translation, scale);
}
private Map<ModelDisplay.Position, ModelDisplay> loadDisplay(JsonObject in) {
// wow such long
final Map<ModelDisplay.Position, ModelDisplay> ret = new Object2ObjectOpenHashMap<>(ModelDisplay.Position.values().length);
if (in.has("display")) {
final JsonObject display = in.getAsJsonObject("display");
for (Map.Entry<String, JsonElement> j : display.entrySet()) {
final String name = j.getKey();
final ModelDisplay.Position pos = ModelDisplay.Position.getByName(name);
ret.put(pos, loadADisplay(j.getValue().getAsJsonObject()));
}
}
for (ModelDisplay.Position p : ModelDisplay.Position.values()) {
ret.putIfAbsent(p, ModelDisplay.DEFAULT);
}
return ret;
}
private Map<String, String> loadTextures(JsonObject in) {
final Map<String, String> textures = new Object2ObjectOpenHashMap<>();
if (in.has("textures")) {
for (Map.Entry<String, JsonElement> e : in.getAsJsonObject("textures").entrySet()) {
// Trim leading octothorpes. They indicate a texture variable, but I don't actually care.
String s = e.getValue().getAsString();
if (s.startsWith("#")) s = s.substring(1);
textures.put(e.getKey(), s);
}
}
return textures;
}
private ModelElement.Rotation loadRotation(JsonObject in) {
if (in.has("rotation")) {
final JsonObject json = in.getAsJsonObject("rotation");
final Vector3f origin = loadVec3(json, "origin").div(16);
final Axis axis = Axis.fromName(loadStr(json, "axis"));
final float angle = loadFloat(json, "angle");
final boolean rescale = loadBool(json, "rescale", false);
return new ModelElement.Rotation(origin, axis, angle, rescale);
} else {
return null;
}
}
private List<ModelElement.Face> loadFaces(JsonObject in) {
final List<ModelElement.Face> ret = new ObjectArrayList<>();
final JsonObject json = in.getAsJsonObject("faces");
for (Map.Entry<String, JsonElement> e : json.entrySet()) {
final ForgeDirection side = DirUtil.fromName(e.getKey());
final JsonObject face = e.getValue().getAsJsonObject();
final Vector4f uv = (face.has("uv")) ? loadVec4(face, "uv") : null;
String texture = loadStr(face, "texture");
if (texture.startsWith("#")) texture = texture.substring(1);
final ForgeDirection cullFace = DirUtil.fromName(loadStr(face, "cullface", "unknown"));
final int rotation = loadInt(face, "rotation", 0);
final int tintIndex = loadInt(face, "tintindex", -1);
ret.add(new ModelElement.Face(side, uv, texture, cullFace, rotation, tintIndex));
}
return ret;
}
private List<ModelElement> loadElements(JsonObject in) {
final List<ModelElement> ret = new ObjectArrayList<>();
if (in.has("elements")) {
final JsonArray arr = in.getAsJsonArray("elements");
for (JsonElement e : arr) {
final JsonObject json = e.getAsJsonObject();
final Vector3f from = loadVec3(json, "from").div(16);
final Vector3f to = loadVec3(json, "to").div(16);
final ModelElement.Rotation rotation = loadRotation(json);
final boolean shade = loadBool(json, "shade", true);
final List<ModelElement.Face> faces = loadFaces(json);
ret.add(new ModelElement(from, to, rotation, shade, faces));
}
}
return ret;
}
@Override
public JsonModel deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
final JsonObject in = json.getAsJsonObject();
final String parent = loadStr(in, "parent", "");
final ResourceLocation parentId = (parent.isEmpty()) ? null : new ResourceLocation(parent);
final boolean useAO = loadBool(in, "ambientocclusion", true);
final Map<ModelDisplay.Position, ModelDisplay> display = loadDisplay(in);
final Map<String, String> textures = loadTextures(in);
final List<ModelElement> elements = loadElements(in);
return new JsonModel(parentId, useAO, display, textures, elements);
}
}
}
@@ -0,0 +1,109 @@
package com.gtnewhorizons.angelica.models.json;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
import com.gtnewhorizons.angelica.utils.Callback;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import net.minecraft.block.Block;
import net.minecraft.util.ResourceLocation;
/**
* Model loading should proceed as follows: <ul>
* <li>Models to load are registered in PREINIT.</li>
* <li>All registered models are recursively loaded in INIT.</li>
* <li>Models registered for baking are baked on the first tick of the game.</li>
*</ul>
* <p>Alternatively, you can register blocks with blockstate variants in preinit, and the rest is handled by
* {@link Loader}.
* <p>As for icons, register them in {@link Block#registerBlockIcons}. Whatever gets them in the block texture atlas.
*/
public class Loader {
static final Gson GSON = new GsonBuilder()
.registerTypeAdapter(JsonModel.class, new JsonModel.Deserializer()).create();
private static final List<ResourceLocation> unloadedModels = new ObjectArrayList<>();
private static final Map<ResourceLocation, JsonModel> loadedModels = new Object2ObjectOpenHashMap<>();
private static final Map<Variant, JsonModel> modelsToBake = new Object2ObjectOpenHashMap<>();
private static final List<Callback> postBakeCallbacks = new ObjectArrayList<>();
/**
* Convenience method to register multiple variants. See {@link #registerModels(Callback, Collection)}.
*/
public static void registerModels(Callback loader, Variant... variants) {
registerModels(loader, Arrays.asList(variants));
}
/**
* Pass the variant(s) you want to load, and if needed a callback which puts the models in a useful place, e.g.
* saving them to a static field after baking.
*/
public static void registerModels(Callback loader, Collection<Variant> variants) {
for (Variant v : variants) {
unloadedModels.add(v.getModel());
modelsToBake.put(v, null);
}
postBakeCallbacks.add(loader);
}
public static void loadModels() {
for (ResourceLocation l : unloadedModels) {
if (l == null) continue;
if (loadedModels.containsKey(l)) continue;
final JsonModel model = loadJson(
"/assets/" + l.getResourceDomain() + "/models/" + l.getResourcePath() + ".json", JsonModel.class);
unloadedModels.addAll(model.getParents());
loadedModels.put(l, model);
}
}
private static <T> T loadJson(String path, Class<T> clazz) {
try (final InputStream is = Loader.class.getResourceAsStream(path)) {
return GSON.fromJson(new InputStreamReader(is), clazz);
} catch (IOException | NullPointerException e) {
AngelicaTweaker.LOGGER.fatal("Could not find " + path);
throw new RuntimeException(e);
}
}
public static void bakeModels() {
for (Map.Entry<Variant, JsonModel> l : modelsToBake.entrySet()) {
final JsonModel dough = new JsonModel(loadedModels.get(l.getKey().getModel()));
// Resolve the parent chain
dough.resolveParents(loadedModels::get);
// Bake
dough.bake(l.getKey());
l.setValue(dough);
}
for (Callback c : postBakeCallbacks)
c.run();
}
public static JsonModel getModel(Variant loc) {
return modelsToBake.get(loc);
}
}
@@ -0,0 +1,48 @@
package com.gtnewhorizons.angelica.models.json;
import org.joml.Vector3f;
public class ModelDisplay {
public static final ModelDisplay DEFAULT = new ModelDisplay(
new Vector3f(0, 0, 0),
new Vector3f(0, 0, 0),
new Vector3f(1, 1, 1)
);
private final Vector3f rotation;
private final Vector3f translation;
private final Vector3f scale;
public ModelDisplay(Vector3f rotation, Vector3f translation, Vector3f scale) {
this.rotation = rotation;
this.translation = translation;
this.scale = scale;
}
enum Position {
thirdperson_righthand,
thirdperson_lefthand,
firstperson_righthand,
firstperson_lefthand,
gui,
head,
ground,
fixed;
public static Position getByName(String name) {
return switch (name) {
case "thirdperson_righthand" -> thirdperson_righthand;
case "thirdperson_lefthand" -> thirdperson_lefthand;
case "firstperson_righthand" -> firstperson_righthand;
case "firstperson_lefthand" -> firstperson_lefthand;
case "gui" -> gui;
case "head" -> head;
case "ground" -> ground;
case "fixed" -> fixed;
default -> null;
};
}
}
}
@@ -0,0 +1,96 @@
package com.gtnewhorizons.angelica.models.json;
import com.gtnewhorizons.angelica.compat.mojang.Axis;
import java.util.List;
import lombok.Getter;
import net.minecraftforge.common.util.ForgeDirection;
import org.jetbrains.annotations.Nullable;
import org.joml.Matrix4f;
import org.joml.Vector3f;
import org.joml.Vector4f;
public class ModelElement {
@Getter
private final Vector3f from;
@Getter
private final Vector3f to;
@Nullable
@Getter
private final Rotation rotation;
private final boolean shade;
@Getter
private final List<Face> faces;
ModelElement(Vector3f from, Vector3f vector3f, @Nullable Rotation rotation, boolean shade, List<Face> faces) {
this.from = from;
to = vector3f;
this.rotation = rotation;
this.shade = shade;
this.faces = faces;
}
static class Face {
@Getter
private final ForgeDirection name;
@Getter
private final Vector4f uv;
@Getter
private final String texture;
@Getter
private final ForgeDirection cullFace;
@Getter
private final int rotation;
@Getter
private final int tintIndex;
Face(ForgeDirection name, Vector4f uv, String texture, ForgeDirection cullFace, int rotation, int tintIndex) {
this.name = name;
this.uv = uv;
this.texture = texture;
this.cullFace = cullFace;
this.rotation = rotation;
this.tintIndex = tintIndex;
}
}
static class Rotation {
static final Rotation NOOP = new Rotation(
new Vector3f(0, 0, 0),
Axis.X,
0,
false
);
private final Vector3f origin;
private final Axis axis;
private final float angle;
private final boolean rescale;
Rotation(Vector3f origin, Axis axis, float angle, boolean rescale) {
this.origin = origin;
this.axis = axis;
this.angle = (float) Math.toRadians(angle);
this.rescale = rescale;
}
Matrix4f getAffineMatrix() {
// Subtract origin
final Matrix4f ret = new Matrix4f().translation(-this.origin.x, -this.origin.y, -this.origin.z);
// Rotate
switch (this.axis) {
case X -> ret.rotateLocalX(angle);
case Y -> ret.rotateLocalY(angle);
case Z -> ret.rotateLocalZ(angle);
}
// Add the origin back in
return ret.translateLocal(this.origin.x, this.origin.y, this.origin.z);
}
}
}
@@ -0,0 +1,29 @@
package com.gtnewhorizons.angelica.models.json;
import lombok.Getter;
import net.minecraft.util.ResourceLocation;
import org.joml.Matrix4f;
import static java.lang.Math.toRadians;
public class Variant {
@Getter
private final ResourceLocation model;
private final float x;
private final float y;
private final boolean uvLock;
public Variant(ResourceLocation model, int x, int y, boolean uvLock) {
this.model = model;
this.x = (float) toRadians(x);
this.y = (float) toRadians(y);
this.uvLock = uvLock;
}
Matrix4f getAffineMatrix() {
return new Matrix4f()
.translation(-.5f, -.5f, -.5f).rotateLocalY(x).rotateLocalX(y).translateLocal(.5f, .5f, .5f);
}
}
@@ -1,12 +1,16 @@
package com.gtnewhorizons.angelica.proxy;
import com.google.common.base.Objects;
import com.gtnewhorizons.angelica.common.BlockTest;
import com.gtnewhorizons.angelica.compat.ModStatus;
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.VanillaModels;
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;
@@ -14,8 +18,8 @@ import cpw.mods.fml.common.event.FMLPostInitializationEvent;
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.InputEvent;
import cpw.mods.fml.common.gameevent.TickEvent;
import cpw.mods.fml.common.registry.GameData;
import cpw.mods.fml.relauncher.ReflectionHelper;
import jss.notfine.core.Settings;
import me.jellysquid.mods.sodium.client.SodiumDebugScreenHandler;
@@ -33,6 +37,8 @@ import net.minecraft.server.integrated.IntegratedServer;
import net.minecraft.util.Direction;
import net.minecraft.util.MathHelper;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.EnumSkyBlock;
import net.minecraft.world.chunk.Chunk;
import net.minecraftforge.client.event.EntityViewRenderEvent;
import net.minecraftforge.client.event.FOVUpdateEvent;
import net.minecraftforge.client.event.GuiOpenEvent;
@@ -49,26 +55,44 @@ import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
public class ClientProxy extends CommonProxy {
final Minecraft mc = Minecraft.getMinecraft();
private static boolean baked = false;
@Override
public void preInit(FMLPreInitializationEvent event) {
super.preInit(event);
FMLCommonHandler.instance().bus().register(this);
MinecraftForge.EVENT_BUS.register(this);
if (AngelicaConfig.enableTestBlocks)
Loader.registerModels(BlockTest::loadModel, BlockTest.modelId);
if (AngelicaConfig.injectQPRendering)
Loader.registerModels(VanillaModels::loadModels, VanillaModels.stoneVariant);
}
@SubscribeEvent
public void worldLoad(WorldEvent.Load event) {
if(GLStateManager.isRunningSplash()) {
if (GLStateManager.isRunningSplash()) {
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);
});
}
private static KeyBinding glsmKeyBinding;
@Override
public void init(FMLInitializationEvent event) {
super.init(event);
if(AngelicaConfig.enableHudCaching) {
FMLCommonHandler.instance().bus().register(HUDCaching.INSTANCE);
MinecraftForge.EVENT_BUS.register(HUDCaching.INSTANCE); // TODO remove debug stuff, unused registration}
@@ -91,6 +115,8 @@ public class ClientProxy extends CommonProxy {
glsmKeyBinding = new KeyBinding("Print GLSM Debug", Keyboard.KEY_NONE, "Angelica Keybinds");
ClientRegistry.registerKeyBinding(glsmKeyBinding);
Loader.loadModels();
}
private boolean wasGLSMKeyPressed;
@@ -105,6 +131,8 @@ public class ClientProxy extends CommonProxy {
@Override
public void postInit(FMLPostInitializationEvent event) {
super.postInit(event);
if (ModStatus.isLotrLoaded && AngelicaConfig.enableSodium && AngelicaConfig.fixLotrSodiumCompat) {
try {
Class<?> lotrRendering = Class.forName("lotr.common.coremod.LOTRReplacedMethods$BlockRendering");
@@ -171,12 +199,20 @@ public class ClientProxy extends CommonProxy {
default -> throw new RuntimeException();
};
event.left.set(i, String.format("XYZ: %.3f / %.5f / %.3f", mc.thePlayer.posX, mc.thePlayer.boundingBox.minY, mc.thePlayer.posZ));
int blockX = MathHelper.floor_double(mc.thePlayer.posX);
int blockY = MathHelper.floor_double(mc.thePlayer.boundingBox.minY);
int blockZ = MathHelper.floor_double(mc.thePlayer.posZ);
event.left.set(i + 1, String.format("Block: %d %d %d [%d %d %d]", blockX, blockY, blockZ, blockX & 15, blockY & 15, blockZ & 15));
event.left.set(i + 2, String.format("Chunk: %d %d %d", blockX >> 4, blockY >> 4, blockZ >> 4));
int bX = MathHelper.floor_double(mc.thePlayer.posX);
int bY = MathHelper.floor_double(mc.thePlayer.boundingBox.minY);
int bZ = MathHelper.floor_double(mc.thePlayer.posZ);
event.left.set(i + 1, String.format("Block: %d %d %d [%d %d %d]", bX, bY, bZ, bX & 15, bY & 15, bZ & 15));
event.left.set(i + 2, String.format("Chunk: %d %d %d", bX >> 4, bY >> 4, bZ >> 4));
event.left.set(i + 3, String.format("Facing: %s (%s) (%.1f / %.1f)", Direction.directions[heading].toLowerCase(Locale.ROOT), heading_str, MathHelper.wrapAngleTo180_float(mc.thePlayer.rotationYaw), MathHelper.wrapAngleTo180_float(mc.thePlayer.rotationPitch)));
Chunk chunk = this.mc.theWorld.getChunkFromBlockCoords(bX, bZ);
event.left.set(i + 4, String.format("lc: %d b: %s bl: %d sl: %d rl: %d",
chunk.getTopFilledSegment() + 15,
chunk.getBiomeGenForWorldCoords(bX & 15, bZ & 15, mc.theWorld.getWorldChunkManager()).biomeName,
chunk.getSavedLightValue(EnumSkyBlock.Block, bX & 15, bY, bZ & 15),
chunk.getSavedLightValue(EnumSkyBlock.Sky, bX & 15, bY, bZ & 15),
chunk.getBlockLightValue(bX & 15, bY, bZ & 15, 0)));
}
}
event.setCanceled(true);
@@ -233,6 +269,11 @@ public class ClientProxy extends CommonProxy {
if (event.phase == TickEvent.Phase.END && mc.theWorld != null) {
CloudRenderer.getCloudRenderer().checkSettings();
}
if (!baked) {
Loader.bakeModels();
baked = true;
}
}
@SubscribeEvent
@@ -241,6 +282,4 @@ public class ClientProxy extends CommonProxy {
event.newfov = 1.0F;
}
}
}
@@ -1,13 +1,19 @@
package com.gtnewhorizons.angelica.proxy;
import com.gtnewhorizons.angelica.common.BlockTest;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.registry.GameRegistry;
public class CommonProxy {
public void preInit(FMLPreInitializationEvent event) {
if (AngelicaConfig.enableTestBlocks){
GameRegistry.registerBlock(new BlockTest(), "test_block");
}
}
public void init(FMLInitializationEvent event) {}
@@ -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) {
@@ -0,0 +1,13 @@
package com.gtnewhorizons.angelica.utils;
import java.util.concurrent.Callable;
/**
* Both {@link Runnable} and {@link Callable} are meant for off-thread/concurrent execution. This is just a callback, no
* more, no less.
*/
@FunctionalInterface
public interface Callback {
void run();
}
@@ -0,0 +1,19 @@
package com.gtnewhorizons.angelica.utils;
import net.minecraftforge.common.util.ForgeDirection;
public class DirUtil {
public static ForgeDirection fromName(String name) {
return switch (name) {
case "up" -> ForgeDirection.UP;
case "down" -> ForgeDirection.DOWN;
case "north" -> ForgeDirection.NORTH;
case "south" -> ForgeDirection.SOUTH;
case "west" -> ForgeDirection.WEST;
case "east" -> ForgeDirection.EAST;
case "unknown" -> ForgeDirection.UNKNOWN;
default -> null;
};
}
}
@@ -0,0 +1,41 @@
package com.gtnewhorizons.angelica.utils;
import com.google.gson.JsonObject;
public class JsonUtil {
public static boolean loadBool(JsonObject in, String name, boolean defaul) {
if (in.has(name))
return in.getAsJsonPrimitive(name).getAsBoolean();
return defaul;
}
public static float loadFloat(JsonObject in, String name) {
if (in.has(name))
return in.getAsJsonPrimitive(name).getAsFloat();
throw new RuntimeException("Required field " + name + " not found in JsonObject " + in);
}
public static int loadInt(JsonObject in, String name, int defaul) {
if (in.has(name))
return in.getAsJsonPrimitive(name).getAsInt();
return defaul;
}
public static String loadStr(JsonObject in, String name) {
if (in.has(name))
return in.getAsJsonPrimitive(name).getAsString();
throw new RuntimeException("Required field " + name + " not found in JsonObject " + in);
}
public static String loadStr(JsonObject in, String name, String defaul) {
if (in.has(name))
return in.getAsJsonPrimitive(name).getAsString();
return defaul;
}
}
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.model.light;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import net.minecraft.util.MathHelper;
import net.minecraft.entity.Entity;
import net.minecraft.world.EnumSkyBlock;
@@ -46,7 +46,7 @@ public class EntityLighter {
double sl = 0;
double bl = 0;
BlockPos.Mutable pos = new BlockPos.Mutable();
BlockPosImpl pos = new BlockPosImpl();
// Iterate over every block in the sampling volume
for (int bX = bMinX; bX < bMaxX; bX++) {
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.model.light;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import me.jellysquid.mods.sodium.client.model.light.data.QuadLightData;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadView;
import net.minecraftforge.common.util.ForgeDirection;
@@ -18,5 +18,5 @@ public interface LightPipeline {
* @param face The pre-computed facing vector of the quad
* @param shade True if the block is shaded by ambient occlusion
*/
void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ForgeDirection cullFace, ForgeDirection face, boolean shade);
void calculate(ModelQuadView quad, BlockPosImpl pos, QuadLightData out, ForgeDirection cullFace, ForgeDirection face, boolean shade);
}
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.model.light.cache;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.api.BlockPos;
import it.unimi.dsi.fastutil.longs.Long2LongLinkedOpenHashMap;
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
import me.jellysquid.mods.sodium.client.world.WorldSlice;
@@ -1,6 +1,7 @@
package me.jellysquid.mods.sodium.client.model.light.data;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import me.jellysquid.mods.sodium.client.util.StateUtil;
import me.jellysquid.mods.sodium.client.world.WorldSlice;
import net.minecraft.block.Block;
import net.minecraftforge.common.util.ForgeDirection;
@@ -21,7 +22,7 @@ import net.minecraftforge.common.util.ForgeDirection;
* You can use the various static pack/unpack methods to extract these values in a usable format.
*/
public abstract class LightDataAccess {
private final BlockPos.Mutable pos = new BlockPos.Mutable();
private final BlockPosImpl pos = new BlockPosImpl();
protected WorldSlice world;
public long get(int x, int y, int z, ForgeDirection d1, ForgeDirection d2) {
@@ -32,11 +33,11 @@ public abstract class LightDataAccess {
return this.get(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ);
}
public long get(BlockPos pos, ForgeDirection dir) {
public long get(BlockPosImpl pos, ForgeDirection dir) {
return this.get(pos.x, pos.y, pos.z, dir);
}
public long get(BlockPos pos) {
public long get(BlockPosImpl pos) {
return this.get(pos.x, pos.y, pos.getZ());
}
@@ -63,11 +64,11 @@ public abstract class LightDataAccess {
em = true;
}
// First is shouldBlockVision, but I can't find if any transparent objects set it
final boolean op = /*state.shouldBlockVision(world, pos) ||*/ block.getLightOpacity() == 0;
// First is shouldBlockVision on modern
final boolean op = !block.isOpaqueCube() || block.getLightOpacity() == 0;
final boolean fo = block.isOpaqueCube();
// Should be isFullCube, but this is probably close enough
final boolean fc = block.renderAsNormalBlock();
final boolean fc = StateUtil.areBoundsFullCube(block);
// OPTIMIZE: Do not calculate lightmap data if the block is full and opaque.
// FIX: Calculate lightmap data for light-emitting or emissive blocks, even though they are full and opaque.
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.model.light.flat;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
@@ -27,7 +27,7 @@ public class FlatLightPipeline implements LightPipeline {
}
@Override
public void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ForgeDirection cullFace, ForgeDirection face, boolean shade) {
public void calculate(ModelQuadView quad, BlockPosImpl pos, QuadLightData out, ForgeDirection cullFace, ForgeDirection face, boolean shade) {
int lightmap;
// To match vanilla behavior, use the cull face if it exists/is available
@@ -57,7 +57,7 @@ public class FlatLightPipeline implements LightPipeline {
* behind tinted glass. {@link LightDataAccess} cannot efficiently store lightmaps computed with
* inconsistent values so this method exists to mirror vanilla behavior as closely as possible.
*/
private int getOffsetLightmap(BlockPos pos, ForgeDirection face) {
private int getOffsetLightmap(BlockPosImpl pos, ForgeDirection face) {
int lightmap = LightDataAccess.unpackLM(this.lightCache.get(pos, face));
// If the block light is not 15 (max)...
if ((lightmap & 0xF0) != 0xF0) {
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.model.light.smooth;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
import net.minecraftforge.common.util.ForgeDirection;
@@ -18,7 +18,7 @@ class AoFaceData {
private int flags;
public void initLightData(LightDataAccess cache, BlockPos pos, ForgeDirection direction, boolean offset) {
public void initLightData(LightDataAccess cache, BlockPosImpl pos, ForgeDirection direction, boolean offset) {
final int x = pos.x;
final int y = pos.y;
final int z = pos.z;
@@ -1,7 +1,7 @@
package me.jellysquid.mods.sodium.client.model.light.smooth;
import com.google.common.math.DoubleMath;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
import me.jellysquid.mods.sodium.client.model.light.data.LightDataAccess;
@@ -69,7 +69,7 @@ public class SmoothLightPipeline implements LightPipeline {
}
@Override
public void calculate(ModelQuadView quad, BlockPos pos, QuadLightData out, ForgeDirection cullFace, ForgeDirection face, boolean shade) {
public void calculate(ModelQuadView quad, BlockPosImpl pos, QuadLightData out, ForgeDirection cullFace, ForgeDirection face, boolean shade) {
this.updateCachedData(pos.asLong());
int flags = quad.getFlags();
@@ -101,7 +101,7 @@ public class SmoothLightPipeline implements LightPipeline {
* have two contributing sides.
* Flags: IS_ALIGNED, !IS_PARTIAL
*/
private void applyAlignedFullFace(AoNeighborInfo neighborInfo, BlockPos pos, ForgeDirection dir, QuadLightData out) {
private void applyAlignedFullFace(AoNeighborInfo neighborInfo, BlockPosImpl pos, ForgeDirection dir, QuadLightData out) {
AoFaceData faceData = this.getCachedFaceData(pos, dir, true);
neighborInfo.mapCorners(faceData.lm, faceData.ao, out.lm, out.br);
}
@@ -110,7 +110,7 @@ public class SmoothLightPipeline implements LightPipeline {
* Calculates the light data for a grid-aligned quad that does not cover the entire block volume's face.
* Flags: IS_ALIGNED, IS_PARTIAL
*/
private void applyAlignedPartialFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ForgeDirection dir, QuadLightData out) {
private void applyAlignedPartialFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPosImpl pos, ForgeDirection dir, QuadLightData out) {
for (int i = 0; i < 4; i++) {
// Clamp the vertex positions to the block's boundaries to prevent weird errors in lighting
float cx = clamp(quad.getX(i));
@@ -124,13 +124,13 @@ public class SmoothLightPipeline implements LightPipeline {
}
/**
* This method is the same as {@link #applyNonParallelFace(AoNeighborInfo, ModelQuadView, BlockPos, ForgeDirection,
* This method is the same as {@link #applyNonParallelFace(AoNeighborInfo, ModelQuadView, BlockPosImpl, ForgeDirection,
* QuadLightData)} but with the check for a depth of approximately 0 removed. If the quad is parallel but not
* aligned, all of its vertices will have the same depth and this depth must be approximately greater than 0,
* meaning the check for 0 will always return false.
* Flags: !IS_ALIGNED, IS_PARALLEL
*/
private void applyParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ForgeDirection dir, QuadLightData out) {
private void applyParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPosImpl pos, ForgeDirection dir, QuadLightData out) {
for (int i = 0; i < 4; i++) {
// Clamp the vertex positions to the block's boundaries to prevent weird errors in lighting
float cx = clamp(quad.getX(i));
@@ -157,7 +157,7 @@ public class SmoothLightPipeline implements LightPipeline {
/**
* Flags: !IS_ALIGNED, !IS_PARALLEL
*/
private void applyNonParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPos pos, ForgeDirection dir, QuadLightData out) {
private void applyNonParallelFace(AoNeighborInfo neighborInfo, ModelQuadView quad, BlockPosImpl pos, ForgeDirection dir, QuadLightData out) {
for (int i = 0; i < 4; i++) {
// Clamp the vertex positions to the block's boundaries to prevent weird errors in lighting
float cx = clamp(quad.getX(i));
@@ -182,7 +182,7 @@ public class SmoothLightPipeline implements LightPipeline {
}
}
private void applyAlignedPartialFaceVertex(BlockPos pos, ForgeDirection dir, float[] w, int i, QuadLightData out, boolean offset) {
private void applyAlignedPartialFaceVertex(BlockPosImpl pos, ForgeDirection dir, float[] w, int i, QuadLightData out, boolean offset) {
AoFaceData faceData = this.getCachedFaceData(pos, dir, offset);
if (!faceData.hasUnpackedLightData()) {
@@ -197,7 +197,7 @@ public class SmoothLightPipeline implements LightPipeline {
out.lm[i] = getLightMapCoord(sl, bl);
}
private void applyInsetPartialFaceVertex(BlockPos pos, ForgeDirection dir, float n1d, float n2d, float[] w, int i, QuadLightData out) {
private void applyInsetPartialFaceVertex(BlockPosImpl pos, ForgeDirection dir, float n1d, float n2d, float[] w, int i, QuadLightData out) {
AoFaceData n1 = this.getCachedFaceData(pos, dir, false);
if (!n1.hasUnpackedLightData()) {
@@ -235,7 +235,7 @@ public class SmoothLightPipeline implements LightPipeline {
/**
* Returns the cached data for a given facing or calculates it if it hasn't been cached.
*/
private AoFaceData getCachedFaceData(BlockPos pos, ForgeDirection face, boolean offset) {
private AoFaceData getCachedFaceData(BlockPosImpl pos, ForgeDirection face, boolean offset) {
AoFaceData data = this.cachedFaceData[offset ? face.ordinal() : face.ordinal() + 6];
if (!data.hasLightData()) {
@@ -1,6 +1,7 @@
package me.jellysquid.mods.sodium.client.model.quad;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraftforge.common.util.ForgeDirection;
import static me.jellysquid.mods.sodium.client.util.ModelQuadUtil.COLOR_INDEX;
import static me.jellysquid.mods.sodium.client.util.ModelQuadUtil.LIGHT_INDEX;
@@ -91,6 +92,14 @@ public class ModelQuad implements ModelQuadViewMutable {
return this.colorIdx;
}
/**
* Doesn't do anything useful, but I'm not sure if it has to anyways.
*/
@Override
public ForgeDirection getLightFace() {
return ForgeDirection.UP;
}
@Override
public float getX(int idx) {
return Float.intBitsToFloat(this.data[vertexOffset(idx) + POSITION_INDEX]);
@@ -2,6 +2,7 @@ package me.jellysquid.mods.sodium.client.model.quad;
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFlags;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraftforge.common.util.ForgeDirection;
import java.nio.ByteBuffer;
@@ -25,7 +26,7 @@ public interface ModelQuadView {
float getZ(int idx);
/**
* @return The integer-encoded color of the vertex at index {@param idx}
* @return The integer-encoded color (ABGR?) of the vertex at index {@param idx}
*/
int getColor(int idx);
@@ -59,6 +60,13 @@ public interface ModelQuadView {
*/
int getColorIndex();
/**
* 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.
*/
ForgeDirection getLightFace();
/**
* Copies this quad's data into the specified buffer starting at the given position.
* @param buf The buffer to write this quad's data to
@@ -0,0 +1,335 @@
package me.jellysquid.mods.sodium.client.model.quad;
import com.gtnewhorizons.angelica.api.QuadView;
import lombok.Getter;
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFacing;
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFlags;
import me.jellysquid.mods.sodium.client.render.pipeline.BlockRenderer;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3f;
import org.lwjgl.opengl.GL11;
import javax.annotation.Nullable;
import java.util.Locale;
/**
* Roughly equivalent to 16.5's BakedQuadView and BakedQuadMixin
*/
public class Quad implements QuadView {
// Adapted from Neodymium
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;
public static final int U_INDEX = 3;
public static final int V_INDEX = 4;
public static final int COLOR_INDEX = 5;
public static final int NORMAL_INDEX = 6;
public static final int LIGHTMAP_INDEX = 7;
private final static int DEFAULT_LIGHTMAP = 15 << 20 | 15 << 4;
private final static int DEFAULT_COLOR = 0xFFFFFFFF;
private final int[] data = new int[QUAD_STRIDE];
@Getter
private boolean deleted;
private final Vector3f vectorA = new Vector3f(), vectorB = new Vector3f(), vectorC = new Vector3f();
@Getter
private boolean shade;
private int cachedFlags;
@Getter
private ForgeDirection face;
private int colorIndex = -1;
private TextureAtlasSprite sprite = null;
/** Returns the face, forced to take one of 6 directions to mirror the behavior of baked quads in 1.16.5. */
@Override
public ForgeDirection getLightFace() {
return this.face != ForgeDirection.UNKNOWN ? this.face : ForgeDirection.UP;
}
@Override
public float getX(int idx) {
return Float.intBitsToFloat(this.data[idx * INTS_PER_VERTEX + X_INDEX]);
}
@Override
public float getY(int idx) {
return Float.intBitsToFloat(this.data[idx * INTS_PER_VERTEX + Y_INDEX]);
}
@Override
public float getZ(int idx) {
return Float.intBitsToFloat(this.data[idx * INTS_PER_VERTEX + Z_INDEX]);
}
@Override
public float getTexU(int idx) {
return Float.intBitsToFloat(this.data[idx * INTS_PER_VERTEX + U_INDEX]);
}
@Override
public float getTexV(int idx) {
return Float.intBitsToFloat(this.data[idx * INTS_PER_VERTEX + V_INDEX]);
}
@Override
public int getColor(int idx) {
return this.data[idx * INTS_PER_VERTEX + COLOR_INDEX];
}
@Override
public int getLight(int idx) {
return this.data[idx * INTS_PER_VERTEX + LIGHTMAP_INDEX];
}
@Override
public int getNormal(int idx) {
return this.data[idx * INTS_PER_VERTEX + NORMAL_INDEX];
}
@Override
public int getFlags() {
return this.cachedFlags;
}
@Override
public int getColorIndex() {
return this.colorIndex;
}
@Override
public TextureAtlasSprite rubidium$getSprite() {
return this.sprite;
}
@Override
public void setX(int idx, float x) {
this.data[idx * INTS_PER_VERTEX + X_INDEX] = Float.floatToRawIntBits(x);
}
@Override
public void setY(int idx, float y) {
this.data[idx * INTS_PER_VERTEX + Y_INDEX] = Float.floatToRawIntBits(y);
}
@Override
public void setZ(int idx, float z) {
this.data[idx * INTS_PER_VERTEX + Z_INDEX] = Float.floatToRawIntBits(z);
}
@Override
public void setTexU(int idx, float u) {
this.data[idx * INTS_PER_VERTEX + U_INDEX] = Float.floatToRawIntBits(u);
}
@Override
public void setTexV(int idx, float v) {
this.data[idx * INTS_PER_VERTEX + V_INDEX] = Float.floatToRawIntBits(v);
}
@Override
public void setColor(int idx, int c) {
this.data[idx * INTS_PER_VERTEX + COLOR_INDEX] = c;
}
@Override
public void setLight(int idx, int l) {
this.data[idx * INTS_PER_VERTEX + LIGHTMAP_INDEX] = l;
}
@Override
public void setNormal(int idx, int n) {
this.data[idx * INTS_PER_VERTEX + NORMAL_INDEX] = n;
}
@Override
public void setFlags(int flags) {
this.cachedFlags = flags;
}
@Override
public void setColorIndex(int i) {
this.colorIndex = i;
}
@Override
public void setSprite(TextureAtlasSprite sprite) {
this.sprite = sprite;
}
@Override
public int[] getRawVertexes() {
return this.data;
}
/**
* Convenience: access x, y, z by index 0-2.
*/
private float posByIndex(int vertexIndex, int coordinateIndex) {
return Float.intBitsToFloat(this.data[vertexIndex * INTS_PER_VERTEX + coordinateIndex]);
}
/**
* Convenience: access x, y, z by index 0-2.
*/
private void setPosByIndex(int vertexIndex, int coordinateIndex, float val) {
this.data[vertexIndex * INTS_PER_VERTEX + coordinateIndex] = Float.floatToRawIntBits(val);
}
/**
* Offset all xs, ys, or zs by index 0-2.
*/
private void offsetPos(int idx, float offset) {
this.setPosByIndex(0, idx, this.posByIndex(0, idx) + offset);
this.setPosByIndex(1, idx, this.posByIndex(1, idx) + offset);
this.setPosByIndex(2, idx, this.posByIndex(2, idx) + offset);
this.setPosByIndex(3, idx, this.posByIndex(3, idx) + offset);
}
private void clearColors() {
this.setColor(0, DEFAULT_COLOR);
this.setColor(1, DEFAULT_COLOR);
this.setColor(2, DEFAULT_COLOR);
this.setColor(3, DEFAULT_COLOR);
}
private void clearNormals() {
this.setNormal(0, 0);
this.setNormal(1, 0);
this.setNormal(2, 0);
this.setNormal(3, 0);
}
private void clearLight() {
this.setLight(0, DEFAULT_LIGHTMAP);
this.setLight(1, DEFAULT_LIGHTMAP);
this.setLight(2, DEFAULT_LIGHTMAP);
this.setLight(3, DEFAULT_LIGHTMAP);
}
private boolean isEmpty() {
return this.getX(0) == this.getX(1)
&& this.getX(1) == this.getX(2)
&& this.getX(2) == this.getX(3)
&& this.getY(0) == this.getY(1)
&& this.getY(1) == this.getY(2)
&& this.getY(2) == this.getY(3);
}
private void calcNormal() {
this.vectorA.set(
this.getX(1) - this.getX(0),
this.getY(1) - this.getY(0),
this.getZ(1) - this.getZ(0)
);
this.vectorB.set(
this.getX(2) - this.getX(1),
this.getY(2) - this.getY(1),
this.getZ(2) - this.getZ(1)
);
this.vectorA.cross(this.vectorB, this.vectorC);
}
@Override
public void copyFrom(QuadView quad) {
System.arraycopy(quad.getRawVertexes(), 0, this.data, 0, QUAD_STRIDE);
this.deleted = quad.isDeleted();
this.shade = quad.isShade();
this.face = quad.getFace();
this.colorIndex = quad.getColorIndex();
this.cachedFlags = quad.getFlags();
this.sprite = quad.rubidium$getSprite();
}
/**
* Unlike setState, setRaw assumes your quad is valid and does not compute normals, clear color/normal/lightmap
* values, or quadrangulate. Basically the same as copyFrom but without an input quad.
*/
public void setRaw(int[] data, boolean shade, @Nullable ForgeDirection face, int colorIndex, int flags) {
System.arraycopy(data, 0, this.data, 0, QUAD_STRIDE);
this.deleted = false;
this.shade = shade;
this.face = face;
this.colorIndex = colorIndex;
this.cachedFlags = flags;
}
private void read(int[] rawBuffer, int offset, float offsetX, float offsetY, float offsetZ, int drawMode, BlockRenderer.Flags flags) {
System.arraycopy(rawBuffer, offset, this.data, 0, QUAD_STRIDE);
if (offsetX != 0) this.offsetPos(0, offsetX);
if (offsetY != 0) this.offsetPos(1, offsetY);
if (offsetZ != 0) this.offsetPos(2, offsetZ);
if (!flags.hasColor) this.clearColors();
if (!flags.hasNormals) this.clearNormals();
if (!flags.hasBrightness) this.clearLight();
// sus
this.shade = flags.hasBrightness;
if (drawMode == GL11.GL_TRIANGLES) {
// Quadrangulate!
this.setX(3, this.getX(2));
this.setY(3, this.getY(2));
this.setZ(3, this.getZ(2));
this.setTexU(3, this.getTexU(2));
this.setTexV(3, this.getTexV(2));
this.setLight(3, this.getLight(2));
this.setColor(3, this.getColor(2));
this.setNormal(3, this.getNormal(2));
}
}
@Override
public void setState(int[] rawBuffer, int offset, BlockRenderer.Flags flags, int drawMode, float offsetX, float offsetY, float offsetZ) {
this.deleted = false;
read(rawBuffer, offset, offsetX, offsetY, offsetZ, drawMode, flags);
if (this.isEmpty()) {
// ignore empty quads (e.g. alpha pass of EnderIO item conduits)
this.deleted = true;
return;
}
this.calcNormal();
this.face = ModelQuadFacing.toDirection(ModelQuadFacing.fromVector(this.vectorC));
this.cachedFlags = ModelQuadFlags.getQuadFlags(this);
}
@Override
public String toString() {
return String.format(
Locale.ENGLISH,
"%s[(%.1f, %.1f, %.1f), (%.1f, %.1f, %.1f), (%.1f, %.1f, %.1f), (%.1f, %.1f, %.1f)]",
this.deleted ? "XXX " : "",
this.getX(0),
this.getY(0),
this.getZ(0),
this.getX(1),
this.getY(1),
this.getZ(1),
this.getX(2),
this.getY(2),
this.getZ(2),
this.getX(3),
this.getY(3),
this.getZ(3)
);
}
}
@@ -1,7 +1,7 @@
package me.jellysquid.mods.sodium.client.model.quad.properties;
import com.gtnewhorizons.angelica.compat.mojang.Axis;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import me.jellysquid.mods.sodium.client.model.quad.ModelQuadView;
import net.minecraftforge.common.util.ForgeDirection;
public class ModelQuadFlags {
@@ -32,8 +32,8 @@ public class ModelQuadFlags {
* Calculates the properties of the given quad. This data is used later by the light pipeline in order to make
* certain optimizations.
*/
public static int getQuadFlags(Quad quad) {
final ForgeDirection face = quad.getCoercedFace();
public static int getQuadFlags(ModelQuadView quad) {
final ForgeDirection face = quad.getLightFace();
final Axis axis = Axis.fromDirection(ModelQuadFacing.fromDirection(face));
float minX = 32.0F;
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos;
import com.gtnewhorizons.angelica.utils.AnimationsRenderUtils;
import lombok.Getter;
@@ -265,8 +265,8 @@ public class ChunkRenderContainer<T extends ChunkGraphicsState> {
return this.getOriginZ() + 8.0D;
}
public BlockPos getRenderOrigin() {
return new BlockPos(this.getRenderX(), this.getRenderY(), this.getRenderZ());
public BlockPosImpl getRenderOrigin() {
return new BlockPosImpl(this.getRenderX(), this.getRenderY(), this.getRenderZ());
}
public void setGraphicsState(BlockRenderPass pass, T state) {
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.cull.graph;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.compat.mojang.Camera;
import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionData;
import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos;
@@ -77,7 +77,7 @@ public class ChunkGraphCuller implements ChunkCuller {
this.visible.clear();
BlockPos origin = camera.getBlockPos();
BlockPosImpl origin = camera.getBlockPos();
int chunkX = origin.getX() >> 4;
int chunkY = origin.getY() >> 4;
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.cull.graph;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionData;
import me.jellysquid.mods.sodium.client.render.chunk.data.ChunkRenderData;
import me.jellysquid.mods.sodium.client.util.math.FrustumExtended;
@@ -146,7 +146,7 @@ public class ChunkGraphNode {
* @return The squared distance from the center of this chunk in the world to the center of the block position
* given by {@param pos}
*/
public double getSquaredDistance(BlockPos pos) {
public double getSquaredDistance(BlockPosImpl pos) {
return this.getSquaredDistance(pos.x + 0.5D, pos.y + 0.5D, pos.z + 0.5D);
}
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.tasks;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.compat.mojang.ChunkOcclusionDataBuilder;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.mixins.interfaces.ITexturesCache;
@@ -48,7 +48,7 @@ import java.util.concurrent.ExecutionException;
public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkRenderBuildTask<T> {
private final ChunkRenderContainer<T> render;
private final BlockPos offset;
private final BlockPosImpl offset;
private final ChunkRenderContext context;
@@ -56,7 +56,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
private final boolean translucencySorting;
public ChunkRenderRebuildTask(ChunkRenderContainer<T> render, ChunkRenderContext context, BlockPos offset) {
public ChunkRenderRebuildTask(ChunkRenderContainer<T> render, ChunkRenderContext context, BlockPosImpl offset) {
this.render = render;
this.offset = offset;
this.context = context;
@@ -91,7 +91,7 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
private boolean rendersOffThread(Block block) {
final int type = block.getRenderType();
return (type < 42 && type != 22 && AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block, false)) || AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block, true);
return (type < 42 && type != 22 && AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block, false, false)) || AngelicaBlockSafetyRegistry.canBlockRenderOffThread(block, true, false);
}
private void handleRenderBlocksTextures(RenderBlocks rb, ChunkRenderData.Builder builder) {
@@ -121,8 +121,8 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
final int baseY = this.render.getOriginY();
final int baseZ = this.render.getOriginZ();
final BlockPos pos = new BlockPos();
final BlockPos renderOffset = this.offset;
final BlockPosImpl pos = new BlockPosImpl();
final BlockPosImpl renderOffset = this.offset;
final LongArrayFIFOQueue mainThreadBlocks = new LongArrayFIFOQueue();
boolean hasMainThreadBlocks = false;
@@ -240,11 +240,11 @@ public class ChunkRenderRebuildTask<T extends ChunkGraphicsState> extends ChunkR
*/
private void performMainBuild(ChunkRenderCacheLocal cache, ChunkBuildBuffers buffers, CancellationSource cancellationSource, ChunkRenderBounds.Builder bounds, ChunkRenderData.Builder renderData, LongArrayFIFOQueue mainThreadBlocks) {
final WorldSlice slice = cache.getWorldSlice();
final BlockPos pos = new BlockPos();
final BlockPosImpl pos = new BlockPosImpl();
final int baseX = this.render.getOriginX();
final int baseY = this.render.getOriginY();
final int baseZ = this.render.getOriginZ();
final BlockPos renderOffset = this.offset;
final BlockPosImpl renderOffset = this.offset;
final RenderBlocks rb = new RenderBlocks(slice.getWorld());
while(!mainThreadBlocks.isEmpty()) {
final long longPos = mainThreadBlocks.dequeueLong();
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.chunk.tasks;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import me.jellysquid.mods.sodium.client.gl.buffer.VertexData;
import me.jellysquid.mods.sodium.client.gl.util.BufferSlice;
import me.jellysquid.mods.sodium.client.model.quad.properties.ModelQuadFacing;
@@ -32,10 +32,10 @@ public class ChunkRenderTranslucencySortTask<T extends ChunkGraphicsState> exten
private static final BlockRenderPass[] NO_PASSES = new BlockRenderPass[0];
private final ChunkRenderContainer<T> render;
private final BlockPos offset;
private final BlockPosImpl offset;
private final Vector3d camera;
public ChunkRenderTranslucencySortTask(ChunkRenderContainer<T> render, BlockPos offset, Vector3d camera) {
public ChunkRenderTranslucencySortTask(ChunkRenderContainer<T> render, BlockPosImpl offset, Vector3d camera) {
this.render = render;
this.offset = offset;
this.camera = camera;
@@ -1,10 +1,10 @@
package me.jellysquid.mods.sodium.client.render.entity;
import net.minecraft.entity.Entity;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
public interface EntityLightSampler<T extends Entity> {
int bridge$getBlockLight(T entity, BlockPos pos);
int bridge$getBlockLight(T entity, BlockPosImpl pos);
int bridge$getSkyLight(T entity, BlockPos pos);
int bridge$getSkyLight(T entity, BlockPosImpl pos);
}
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.occlusion;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import it.unimi.dsi.fastutil.objects.Object2ByteLinkedOpenHashMap;
import net.minecraft.block.Block;
import net.minecraft.world.IBlockAccess;
@@ -11,7 +11,7 @@ public class BlockOcclusionCache {
private final Object2ByteLinkedOpenHashMap<CachedOcclusionShapeTest> map;
private final CachedOcclusionShapeTest cachedTest = new CachedOcclusionShapeTest();
private final BlockPos cpos = new BlockPos();
private final BlockPosImpl cpos = new BlockPosImpl();
public BlockOcclusionCache() {
this.map = new Object2ByteLinkedOpenHashMap<>(2048, 0.5F);
@@ -26,11 +26,11 @@ public class BlockOcclusionCache {
* @param facing The facing direction of the side to check
* @return True if the block side facing {@param dir} is not occluded, otherwise false
*/
public boolean shouldDrawSide(Block block, int meta, IBlockAccess view, BlockPos pos, ForgeDirection facing) {
public boolean shouldDrawSide(Block block, int meta, IBlockAccess view, BlockPosImpl pos, ForgeDirection facing) {
if (facing == ForgeDirection.UNKNOWN)
return true;
BlockPos adjPos = this.cpos;
BlockPosImpl adjPos = this.cpos;
adjPos.set(pos.getX() + facing.offsetX, pos.getY() + facing.offsetY, pos.getZ() + facing.offsetZ);
Block adjState = view.getBlock(adjPos.x, adjPos.y, adjPos.z);
@@ -1,14 +1,13 @@
package me.jellysquid.mods.sodium.client.render.pipeline;
import com.gtnewhorizons.angelica.api.QuadProvider;
import com.gtnewhorizons.angelica.api.QuadView;
import com.gtnewhorizons.angelica.client.renderer.CapturingTessellator;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.nd.Quad;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import me.jellysquid.mods.sodium.client.model.quad.Quad;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import com.gtnewhorizons.angelica.glsm.TessellatorManager;
import com.gtnewhorizons.angelica.utils.ObjectPooler;
import java.util.List;
import java.util.Random;
import me.jellysquid.mods.sodium.client.model.light.LightMode;
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
import me.jellysquid.mods.sodium.client.model.light.LightPipelineProvider;
@@ -30,6 +29,9 @@ import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import java.util.List;
import java.util.Random;
public class BlockRenderer {
private final Random random = new XoRoShiRoRandom();
@@ -42,7 +44,7 @@ public class BlockRenderer {
private final LightPipelineProvider lighters;
private final BlockOcclusionCache occlusionCache;
private final ObjectPooler<Quad> quadPool = new ObjectPooler<>(Quad::new);
private final ObjectPooler<QuadView> quadPool = new ObjectPooler<>(Quad::new);
// TODO: Use modern model API, and store them here
@@ -53,7 +55,7 @@ public class BlockRenderer {
this.occlusionCache = new BlockOcclusionCache();
}
public boolean renderModel(IBlockAccess world, RenderBlocks renderBlocks, Block block, int meta, BlockPos pos, ChunkModelBuffers buffers, boolean cull, long seed) {
public boolean renderModel(IBlockAccess world, RenderBlocks renderBlocks, Block block, int meta, BlockPosImpl pos, ChunkModelBuffers buffers, boolean cull, long seed) {
final LightMode mode = this.getLightingMode(block);
final LightPipeline lighter = this.lighters.getLighter(mode);
@@ -63,20 +65,23 @@ public class BlockRenderer {
if (block instanceof QuadProvider qBlock) {
final int color = qBlock.getColor(world, pos, block, meta, random);
for (ForgeDirection dir : ForgeDirection.values()) {
this.random.setSeed(seed);
List<Quad> quads = qBlock.getQuads(world, pos, block, meta, dir, random, this.quadPool);
if (quads.isEmpty()) continue;
List<QuadView> quads;
if (!cull || this.occlusionCache.shouldDrawSide(block, meta, world, pos, dir)) {
quads = qBlock.getQuads(world, pos, block, meta, dir, random, color, this.quadPool::getInstance);
if (quads.isEmpty()) continue;
this.renderQuadList(pos, lighter, buffers, quads, ModelQuadFacing.fromDirection(dir), true);
rendered = true;
}
for (Quad q : quads) this.quadPool.releaseInstance(q);
if (qBlock.isDynamic())
for (QuadView q : quads) this.quadPool.releaseInstance(q);
}
}
} else {
@@ -88,7 +93,7 @@ public class BlockRenderer {
tess.setOffset(pos);
renderBlocks.renderBlockByRenderType(block, pos.x, pos.y, pos.z);
final List<Quad> quads = TessellatorManager.stopCapturingToPooledQuads();
final List<QuadView> quads = TessellatorManager.stopCapturingToPooledQuads();
tess.resetOffset();
for (ModelQuadFacing facing : ModelQuadFacing.VALUES) {
@@ -105,26 +110,28 @@ public class BlockRenderer {
return rendered;
}
private void renderQuadList(BlockPos pos, LightPipeline lighter, ChunkModelBuffers buffers, List<Quad> quads, ModelQuadFacing facing, boolean useSodiumLight) {
private void renderQuadList(BlockPosImpl pos, LightPipeline lighter, ChunkModelBuffers buffers, List<QuadView> quads, ModelQuadFacing facing, boolean useSodiumLight) {
final ForgeDirection cullFace = ModelQuadFacing.toDirection(facing);
final ModelVertexSink sink = buffers.getSink(facing);
sink.ensureCapacity(quads.size() * 4);
final ForgeDirection cullFace = ModelQuadFacing.toDirection(facing);
final ChunkRenderData.Builder renderData = buffers.getRenderData();
// This is a very hot allocation, iterate over it manually
// noinspection ForLoopReplaceableByForEach
for (int i = 0, quadsSize = quads.size(); i < quadsSize; i++) {
final Quad quad = quads.get(i);
final QuadView quad = quads.get(i);
if(quad.normal != facing)
// If we aren't using sodium light (i.e. it's the CapturingTesselator)
// manually filter quads by side
if (!useSodiumLight && quad.getFace() != cullFace)
continue;
final QuadLightData light = this.cachedQuadLightData;
if (useSodiumLight || this.useSeparateAo)
lighter.calculate(quad, pos, light, cullFace, quad.getCoercedFace(), quad.hasShade());
lighter.calculate(quad, pos, light, cullFace, quad.getLightFace(), quad.isShade());
this.renderQuad(sink, quad, light, renderData, useSodiumLight);
}
@@ -132,7 +139,7 @@ public class BlockRenderer {
sink.flush();
}
private void renderQuad(ModelVertexSink sink, Quad quad, QuadLightData light, ChunkRenderData.Builder renderData, boolean useSodiumLight) {
private void renderQuad(ModelVertexSink sink, QuadView quad, QuadLightData light, ChunkRenderData.Builder renderData, boolean useSodiumLight) {
final ModelQuadOrientation order = (useSodiumLight || this.useSeparateAo) ? ModelQuadOrientation.orient(light.br) : ModelQuadOrientation.NORMAL;
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.client.render.pipeline;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import com.gtnewhorizons.angelica.config.AngelicaConfig;
import me.jellysquid.mods.sodium.client.model.light.LightMode;
import me.jellysquid.mods.sodium.client.model.light.LightPipeline;
@@ -38,7 +38,7 @@ public class FluidRenderer {
private static final float EPSILON = 0.001f;
private final LightPipelineProvider lpp;
private final BlockPos.Mutable scratchPos = new BlockPos.Mutable();
private final BlockPosImpl scratchPos = new BlockPosImpl();
private final ModelQuadViewMutable quad = new ModelQuad();
@@ -69,7 +69,7 @@ public class FluidRenderer {
}
private boolean isSideExposed(IBlockAccess world, int x, int y, int z, ForgeDirection dir, float height) {
BlockPos pos = this.scratchPos.set(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ);
BlockPosImpl pos = this.scratchPos.set(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ);
Block block = world.getBlock(pos.x, pos.y, pos.z);
if (block.getMaterial().isOpaque()) {
@@ -87,7 +87,7 @@ public class FluidRenderer {
return true;
}
public boolean render(IBlockAccess world, WorldSlice slice, Block block, BlockPos pos, ChunkModelBuffers buffers) {
public boolean render(IBlockAccess world, WorldSlice slice, Block block, BlockPosImpl pos, ChunkModelBuffers buffers) {
this.useSeparateAo = AngelicaConfig.enableIris && BlockRenderingSettings.INSTANCE.shouldUseSeparateAo();
int posX = pos.x;
@@ -349,7 +349,7 @@ public class FluidRenderer {
return rendered;
}
private void calculateQuadColors(ModelQuadView quad, BlockPos pos, LightPipeline lighter, ForgeDirection dir, float brightness, boolean colorized, WorldSlice slice) {
private void calculateQuadColors(ModelQuadView quad, BlockPosImpl pos, LightPipeline lighter, ForgeDirection dir, float brightness, boolean colorized, WorldSlice slice) {
QuadLightData light = this.quadLightData;
lighter.calculate(quad, pos, light, null, dir, false);
@@ -437,7 +437,7 @@ public class FluidRenderer {
return 1.0F;
}
BlockPos pos = this.scratchPos.set(x2, y, z2);
BlockPosImpl pos = this.scratchPos.set(x2, y, z2);
block = world.getBlock(pos.x, pos.y, pos.z);
int meta = world.getBlockMetadata(pos.x, pos.y, pos.z);
@@ -23,4 +23,8 @@ public class MathUtil {
private static long cantor(long a, long b) {
return (a + b + 1) * (a + b) / 2 + b;
}
public static boolean fuzzy_eq(float a, float b) {
return Math.abs(a - b) < 1e-5;
}
}
@@ -0,0 +1,24 @@
package me.jellysquid.mods.sodium.client.util;
import net.minecraft.block.Block;
public class StateUtil {
public static boolean areBoundsFullCube(Block b) {
if (b.getBlockBoundsMaxX() < 1)
return false;
if (b.getBlockBoundsMinX() > 0)
return false;
if (b.getBlockBoundsMaxY() < 1)
return false;
if (b.getBlockBoundsMinY() > 0)
return false;
if (b.getBlockBoundsMaxZ() < 1)
return false;
if (b.getBlockBoundsMinZ() > 1)
return false;
return true;
}
}
@@ -387,7 +387,7 @@ public class WorldSlice implements IBlockAccess {
}
// Modern checks if the sky is darkened, which only happens in the nether. However, I think 1.7.10's hasNoSky is
// close enough and possibly a behavior change between versions. I also don't know why it's rotationally asymmetric
// close enough.
public float getBrightness(ForgeDirection direction, boolean shaded) {
if (!shaded) {
@@ -3,7 +3,6 @@ package me.jellysquid.mods.sodium.client.world.cloned;
import com.falsepattern.endlessids.mixin.helpers.ChunkBiomeHook;
import com.gtnewhorizons.angelica.compat.ExtendedBlockStorageExt;
import com.gtnewhorizons.angelica.compat.ModStatus;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos;
import it.unimi.dsi.fastutil.shorts.Short2ObjectMap;
import it.unimi.dsi.fastutil.shorts.Short2ObjectOpenHashMap;
@@ -1,6 +1,8 @@
package me.jellysquid.mods.sodium.common.util;
import net.minecraftforge.common.util.ForgeDirection;
import org.joml.Vector3f;
import org.joml.Vector3i;
/**
* Contains a number of cached arrays to avoid allocations since calling Enum#values() requires the backing array to
@@ -14,4 +16,21 @@ public class DirectionUtil {
// Provides the same order as enumerating ForgeDirection and checking the axis of each value
public static final ForgeDirection[] HORIZONTAL_DIRECTIONS = new ForgeDirection[] { ForgeDirection.NORTH, ForgeDirection.SOUTH, ForgeDirection.WEST, ForgeDirection.EAST };
public static final Vector3i[] STEP = {
//DOWN
new Vector3i(0, -1, 0),
// UP
new Vector3i(0, 1, 0),
// NORTH
new Vector3i(0, 0, -1),
// SOUTH
new Vector3i(0, 0, 1),
// WEST
new Vector3i(-1, 0, 0),
// EAST
new Vector3i(1, 0, 0),
// UNKNOWN
new Vector3i(0, 0, 0)
};
}
@@ -1,6 +1,6 @@
package me.jellysquid.mods.sodium.common.util;
import com.gtnewhorizons.angelica.compat.mojang.BlockPos;
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
import net.minecraft.block.Block;
import net.minecraft.block.BlockLiquid;
import net.minecraft.block.material.Material;
@@ -70,7 +70,7 @@ public class WorldUtil {
* Returns true if any block in a 3x3x3 cube is not the same fluid and not an opaque full cube.
* Equivalent to FluidState::method_15756 in modern.
*/
public static boolean method_15756(IBlockAccess world, BlockPos pos, Fluid fluid) {
public static boolean method_15756(IBlockAccess world, BlockPosImpl pos, Fluid fluid) {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
Block block = world.getBlock(pos.x, pos.y, pos.z);
@@ -126,7 +126,7 @@ public class WorldUtil {
/**
* Equivalent to method_15749 in 1.16.5
*/
public static boolean method_15749(IBlockAccess world, Fluid thiz, BlockPos pos, ForgeDirection dir) {
public static boolean method_15749(IBlockAccess world, Fluid thiz, BlockPosImpl pos, ForgeDirection dir) {
Block b = world.getBlock(pos.x, pos.y, pos.z);
Fluid f = getFluid(b);
if (f == thiz) {
@@ -47,3 +47,5 @@ public net.minecraft.client.gui.GuiSlot field_148165_u # hasListHeader
public net.minecraft.client.gui.GuiSlot field_148161_k # mc
public net.minecraft.client.gui.GuiSlot func_148121_k()V # void bindAmountScrolled()
public net.minecraft.client.gui.GuiSlot func_148136_c(IIII)V # void overlayBackground()
public net.minecraft.util.MathHelper func_151241_e(I)I # int calculateLogBaseTwoDeBruijn()
@@ -0,0 +1,5 @@
{
"variants": {
"": { "model": "angelica:blocks/test_block" }
}
}
@@ -0,0 +1,6 @@
{
"parent": "blocks/cube_all",
"textures": {
"all": "angelica:test_block"
}
}
@@ -0,0 +1,3 @@
{
"parent": "angelica:blocks/test_block"
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 874 B

@@ -0,0 +1,35 @@
{
"gui_light": "side",
"display": {
"gui": {
"rotation": [ 30, 225, 0 ],
"translation": [ 0, 0, 0],
"scale":[ 0.625, 0.625, 0.625 ]
},
"ground": {
"rotation": [ 0, 0, 0 ],
"translation": [ 0, 3, 0],
"scale":[ 0.25, 0.25, 0.25 ]
},
"fixed": {
"rotation": [ 0, 0, 0 ],
"translation": [ 0, 0, 0],
"scale":[ 0.5, 0.5, 0.5 ]
},
"thirdperson_righthand": {
"rotation": [ 75, 45, 0 ],
"translation": [ 0, 2.5, 0],
"scale": [ 0.375, 0.375, 0.375 ]
},
"firstperson_righthand": {
"rotation": [ 0, 45, 0 ],
"translation": [ 0, 0, 0 ],
"scale": [ 0.40, 0.40, 0.40 ]
},
"firstperson_lefthand": {
"rotation": [ 0, 225, 0 ],
"translation": [ 0, 0, 0 ],
"scale": [ 0.40, 0.40, 0.40 ]
}
}
}
@@ -0,0 +1,16 @@
{
"parent": "blocks/block",
"elements": [
{ "from": [ 0, 0, 0 ],
"to": [ 16, 16, 16 ],
"faces": {
"down": { "texture": "#down", "cullface": "down" },
"up": { "texture": "#up", "cullface": "up" },
"north": { "texture": "#north", "cullface": "north" },
"south": { "texture": "#south", "cullface": "south" },
"west": { "texture": "#west", "cullface": "west" },
"east": { "texture": "#east", "cullface": "east" }
}
}
]
}
@@ -0,0 +1,12 @@
{
"parent": "blocks/cube",
"textures": {
"particle": "#all",
"down": "#all",
"up": "#all",
"north": "#all",
"east": "#all",
"south": "#all",
"west": "#all"
}
}
@@ -0,0 +1,55 @@
{
"parent": "blocks/block",
"display": {
"firstperson_righthand": {
"rotation": [ 0, 135, 0 ],
"translation": [ 0, 0, 0 ],
"scale": [ 0.4, 0.4, 0.4 ]
}
},
"textures": {
"particle": "lectern_sides",
"bottom": "oak_planks",
"base": "lectern_base",
"front": "lectern_front",
"sides": "lectern_sides",
"top": "lectern_top"
},
"elements": [
{
"from": [ 0, 0, 0 ],
"to": [ 16, 2, 16 ],
"faces": {
"north": { "uv": [ 0, 14, 16, 16 ], "texture": "#base", "cullface": "north" },
"east": { "uv": [ 0, 6, 16, 8 ], "texture": "#base", "cullface": "east" },
"south": { "uv": [ 0, 6, 16, 8 ], "texture": "#base", "cullface": "south" },
"west": { "uv": [ 0, 6, 16, 8 ], "texture": "#base", "cullface": "west" },
"up": { "uv": [ 0, 0, 16, 16 ], "rotation": 180, "texture": "#base" },
"down": { "uv": [ 0, 0, 16, 16 ], "texture": "#bottom", "cullface": "down" }
}
},
{
"from": [4, 2, 4],
"to": [12, 15, 12],
"faces": {
"north": { "uv": [ 0, 0, 8, 13 ], "texture": "#front" },
"east": { "uv": [ 2, 16, 15, 8 ], "rotation": 90, "texture": "#sides" },
"south": { "uv": [ 8, 3, 16, 16 ], "texture": "#front" },
"west": { "uv": [ 2, 8, 15, 16 ], "rotation": 90, "texture": "#sides" }
}
},
{
"from": [ 0.01, 12, 3 ],
"to": [ 15.99, 16, 16 ],
"rotation": { "angle": -22.5, "axis": "x", "origin": [ 8, 8, 8 ] },
"faces": {
"north": { "uv": [ 0, 0, 16, 4 ], "texture": "#sides" },
"east": { "uv": [ 0, 4, 13, 8 ], "texture": "#sides" },
"south": { "uv": [ 0, 4, 16, 8 ], "texture": "#sides" },
"west": { "uv": [ 0, 4, 13, 8 ], "texture": "#sides" },
"up": { "uv": [ 0, 1, 16, 14 ], "rotation": 180, "texture": "#top" },
"down": { "uv": [ 0, 0, 16, 13 ], "texture": "#bottom" }
}
}
]
}
@@ -0,0 +1,6 @@
{
"parent": "blocks/cube_all",
"textures": {
"all": "stone"
}
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 269 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 312 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 202 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 254 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 268 B