mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-18 11:29:08 +00:00
Update to Celeritas 2.5.12 with translucency sorting v3 (#2151)
This commit is contained in:
1 parent
a8c29fa3f9
commit
c9d46e70e0
50 files changed
+870
-556
No files matched your search
@@ -5,6 +5,8 @@ import org.embeddedt.embeddium.impl.render.chunk.fog.FogService;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkFogMode;
|
||||
|
||||
public class AngelicaFogService implements FogService {
|
||||
public static final AngelicaFogService INSTANCE = new AngelicaFogService();
|
||||
|
||||
private final float[] fogColorArray = new float[4];
|
||||
|
||||
@Override
|
||||
|
||||
@@ -419,6 +419,10 @@ public class AngelicaConfig {
|
||||
@Config.DefaultBoolean(false)
|
||||
public static boolean disableF3Additions;
|
||||
|
||||
@Config.Comment("Shows developer counters (FFP, streaming, TESR, transfer) on the F3 screen. Toggle in game with F3+V.")
|
||||
@Config.DefaultBoolean(false)
|
||||
public static boolean verboseF3;
|
||||
|
||||
@Config.Comment("Replaces various FFP uploads with statically allocated VBO's.")
|
||||
@Config.DefaultBoolean(true)
|
||||
public static boolean replaceFFPUploads;
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
package com.gtnewhorizons.angelica.debug;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.GTNHLib;
|
||||
import com.gtnewhorizon.gtnhlib.config.ConfigurationManager;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.CeleritasDebugScreenHandler;
|
||||
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
||||
import cpw.mods.fml.common.gameevent.InputEvent;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
|
||||
/** F3+V toggles {@link AngelicaConfig#verboseF3} */
|
||||
public class DebugKeyHandler {
|
||||
|
||||
@SubscribeEvent
|
||||
public void onKey(InputEvent.KeyInputEvent event) {
|
||||
if (!Keyboard.getEventKeyState() || Keyboard.getEventKey() != Keyboard.KEY_V || !Keyboard.isKeyDown(Keyboard.KEY_F3)
|
||||
|| Minecraft.getMinecraft().currentScreen != null) {
|
||||
return;
|
||||
}
|
||||
|
||||
AngelicaConfig.verboseF3 = !AngelicaConfig.verboseF3;
|
||||
ConfigurationManager.save(AngelicaConfig.class);
|
||||
CeleritasDebugScreenHandler.invalidate();
|
||||
GTNHLib.proxy.addDebugToChat(StatCollector.translateToLocal(AngelicaConfig.verboseF3 ? "angelica.debug.verbose.on" : "angelica.debug.verbose.off"));
|
||||
}
|
||||
}
|
||||
@@ -419,7 +419,9 @@ public enum Mixins implements IMixins {
|
||||
, "celeritas.terrain.MixinWorld_AwaitingDescriptor"
|
||||
, "celeritas.terrain.MixinRenderRegion"
|
||||
, "celeritas.terrain.MixinSectionRenderDataStorage"
|
||||
, "celeritas.terrain.MixinDefaultChunkShaderInterface"
|
||||
, "celeritas.terrain.MixinSharedQuadIndexBuffer"
|
||||
, "celeritas.terrain.MixinRenderRegionManager"
|
||||
, "celeritas.terrain.MixinShaderLoader"
|
||||
)
|
||||
),
|
||||
|
||||
|
||||
-3
@@ -1,14 +1,11 @@
|
||||
package com.gtnewhorizons.angelica.mixins.interfaces;
|
||||
|
||||
import it.unimi.dsi.fastutil.longs.Long2ReferenceMap;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderSection;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkTaskOutput;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.compile.executor.ChunkJobResult;
|
||||
|
||||
import java.util.concurrent.ConcurrentLinkedDeque;
|
||||
|
||||
public interface RenderSectionManagerAccessor {
|
||||
Long2ReferenceMap<RenderSection> angelica$getSectionByPosition();
|
||||
ConcurrentLinkedDeque<Runnable> angelica$getAsyncSubmittedTasks();
|
||||
ConcurrentLinkedDeque<ChunkJobResult<? extends ChunkTaskOutput>> angelica$getBuildResults();
|
||||
}
|
||||
@@ -22,8 +22,6 @@ import com.gtnewhorizons.angelica.rendering.tesr.TesrBatchRenderer;
|
||||
import net.coderbot.iris.pipeline.ShadowRenderer;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.renderer.WorldRenderer;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.SharedQuadIndexBuffer;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.region.RenderRegionManager;
|
||||
|
||||
public final class TracyFramePlots {
|
||||
private static final long P_ALLOC_RATE = Tracy.plotHandle("allocRate", TracyBackend.PLOT_FORMAT_MEMORY);
|
||||
@@ -267,9 +265,9 @@ public final class TracyFramePlots {
|
||||
TESR_BAILS[reason.ordinal()].plot(batcher.statBail(reason));
|
||||
}
|
||||
|
||||
P_MESH_UPLOADED_SECTIONS.plot(RenderRegionManager.getSectionsUploaded());
|
||||
P_MESH_UPLOADED_BYTES.plot(RenderRegionManager.getBytesUploaded());
|
||||
P_DRAW_INDEX_BUFFER_GROWTHS.plot(SharedQuadIndexBuffer.getGrowths());
|
||||
P_MESH_UPLOADED_SECTIONS.plot(TerrainDrawStats.getSectionsUploaded());
|
||||
P_MESH_UPLOADED_BYTES.plot(TerrainDrawStats.getBytesUploaded());
|
||||
P_DRAW_INDEX_BUFFER_GROWTHS.plot(TerrainDrawStats.getIndexBufferGrowths());
|
||||
Tracy.plotInt(P_MESH_META_SLOTS, GpuCulling.sectionMeta().getHighWaterMark());
|
||||
Tracy.plotInt(P_MT_QUEUE_DEPTH, AngelicaRenderQueue.getQueueDepth());
|
||||
Tracy.plotInt(P_MT_QUEUE_TASKS, AngelicaRenderQueue.getLastFrameTasksRan());
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package com.gtnewhorizons.angelica.proxy;
|
||||
|
||||
import com.gtnewhorizons.angelica.debug.DebugKeyHandler;
|
||||
import com.gtnewhorizons.angelica.rendering.culling.GpuCulling;
|
||||
import static com.gtnewhorizons.angelica.AngelicaMod.MOD_ID;
|
||||
|
||||
@@ -185,6 +186,7 @@ public final class ClientProxy extends CommonProxy {
|
||||
Zoom.init();
|
||||
}
|
||||
FpsReducer.init();
|
||||
FMLCommonHandler.instance().bus().register(new DebugKeyHandler());
|
||||
AngelicaConfig.applyGpuCullingMode();
|
||||
if (AngelicaConfig.enableDynamicLights) {
|
||||
EntityLightConfig.init(new java.io.File(mc.mcDataDir, "config"));
|
||||
|
||||
+2
-2
@@ -299,7 +299,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
|
||||
final Reference2ReferenceMap<TerrainRenderPass, BuiltSectionMeshParts> meshes;
|
||||
try {
|
||||
meshes = BuiltSectionMeshParts.groupFromBuildBuffers(buffers,
|
||||
(float) camera.x - minX, (float) camera.y - minY, (float) camera.z - minZ);
|
||||
(float) (camera.x - minX), (float) (camera.y - minY), (float) (camera.z - minZ));
|
||||
} finally {
|
||||
if (Tracy.ENABLED) Tracy.endZone();
|
||||
}
|
||||
@@ -399,7 +399,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
|
||||
if (Tracy.ENABLED) Tracy.beginZone(Z_MESH_FINALIZE);
|
||||
final Reference2ReferenceMap<TerrainRenderPass, BuiltSectionMeshParts> meshes;
|
||||
try {
|
||||
meshes = BuiltSectionMeshParts.groupFromBuildBuffers(m.buffers, (float) camera.x - minX, (float) camera.y - minY, (float) camera.z - minZ);
|
||||
meshes = BuiltSectionMeshParts.groupFromBuildBuffers(m.buffers, (float) (camera.x - minX), (float) (camera.y - minY), (float) (camera.z - minZ));
|
||||
} finally {
|
||||
if (Tracy.ENABLED) Tracy.endZone();
|
||||
}
|
||||
|
||||
+10
-13
@@ -1,6 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.client.rendering.AngelicaFogService;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.backend.BackendManager;
|
||||
@@ -27,7 +28,6 @@ import org.embeddedt.embeddium.impl.gl.device.RenderDevice;
|
||||
import org.embeddedt.embeddium.impl.gl.shader.GlProgram;
|
||||
import org.embeddedt.embeddium.impl.gl.shader.GlShader;
|
||||
import org.embeddedt.embeddium.impl.gl.shader.ShaderConstants;
|
||||
import org.embeddedt.embeddium.impl.gl.shader.ShaderParser;
|
||||
import org.embeddedt.embeddium.impl.gl.shader.ShaderType;
|
||||
import org.embeddedt.embeddium.impl.gl.tessellation.GlPrimitiveType;
|
||||
import org.embeddedt.embeddium.impl.gl.tessellation.GlTessellation;
|
||||
@@ -81,7 +81,7 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
|
||||
private static MultiDrawMode installedBatchMode;
|
||||
|
||||
public AngelicaChunkRenderer(RenderDevice device, RenderPassConfiguration<?> renderPassConfiguration) {
|
||||
super(device, renderPassConfiguration);
|
||||
super(device, renderPassConfiguration, AngelicaFogService.INSTANCE);
|
||||
|
||||
installBatchFactory();
|
||||
this.culler = createCuller();
|
||||
@@ -148,11 +148,6 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
|
||||
return null;
|
||||
}
|
||||
|
||||
private static GlShader loadShader(ShaderType type, String path, ShaderConstants constants) {
|
||||
final String source = ShaderParser.parseShader(ShaderLoader.getShaderSource(path), ShaderLoader::getShaderSource, constants);
|
||||
return new GlShader(type, path, source);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void begin(TerrainRenderPass pass) {
|
||||
if (Tracy.ENABLED) Tracy.beginZone(Z_CHUNK_BEGIN);
|
||||
@@ -301,8 +296,8 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
|
||||
final List<GlShader> loadedShaders = new ArrayList<>();
|
||||
|
||||
try {
|
||||
loadedShaders.add(loadShader(ShaderType.VERTEX, "sodium:" + path + ".vsh", constants));
|
||||
loadedShaders.add(loadShader(ShaderType.FRAGMENT, "angelica:" + path + ".fsh", constants));
|
||||
loadedShaders.add(ShaderLoader.loadShader(ShaderType.VERTEX, "sodium:" + path + ".vsh", constants));
|
||||
loadedShaders.add(ShaderLoader.loadShader(ShaderType.FRAGMENT, "angelica:" + path + ".fsh", constants));
|
||||
|
||||
final var builder = GlProgram.builder("sodium:chunk_shader");
|
||||
loadedShaders.forEach(builder::attachShader);
|
||||
@@ -310,8 +305,10 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
|
||||
for (var attr : options.pass().vertexType().getVertexFormat().getAttributes()) {
|
||||
builder.bindAttribute(attr.getName(), i++);
|
||||
}
|
||||
builder.bindFragmentData("fragColor", ChunkShaderBindingPoints.FRAG_COLOR);
|
||||
return builder.link((shader) -> new DefaultChunkShaderInterface(shader, options));
|
||||
if (!this.enableLegacyGLPatches) {
|
||||
builder.bindFragmentData("fragColor", ChunkShaderBindingPoints.FRAG_COLOR);
|
||||
}
|
||||
return builder.link((shader) -> new DefaultChunkShaderInterface(shader, options, this.environment));
|
||||
} finally {
|
||||
loadedShaders.forEach(GlShader::delete);
|
||||
}
|
||||
@@ -351,12 +348,12 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
|
||||
useBlockFaceCulling, cacheParams);
|
||||
}
|
||||
|
||||
final long batchesCreatedBefore = BatchAssembler.getCachedBatchesCreated();
|
||||
final CachedBatch before = storage.getCachedMultiDrawBatch(cacheParams);
|
||||
Tracy.beginZone(Z_CHUNK_ASSEMBLE_REGION);
|
||||
try {
|
||||
final CachedBatch cached = super.getRegionBatch(commandList, region, storage, renderList, occlusionCamera,
|
||||
renderPass, useBlockFaceCulling, cacheParams);
|
||||
if (BatchAssembler.getCachedBatchesCreated() != batchesCreatedBefore) TerrainDrawStats.recordRebuild();
|
||||
if (cached != before) TerrainDrawStats.recordRebuild();
|
||||
final MultiDrawBatch batch = cached != null ? cached.getBatch() : null;
|
||||
if (batch != null && !batch.isEmpty()) TerrainDrawStats.recordBatch(batch.size());
|
||||
return cached;
|
||||
|
||||
-62
@@ -1,62 +0,0 @@
|
||||
/*
|
||||
* Adapated from: Beddium for usage in Angelica
|
||||
*
|
||||
* Copyright (C) 2025 Ven, FalsePattern
|
||||
* All Rights Reserved
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser General Public License as published by
|
||||
* the Free Software Foundation, only version 3 of the License.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderSectionManager;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.map.ChunkStatus;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTrackerImpl;
|
||||
import org.embeddedt.embeddium.impl.util.PositionUtil;
|
||||
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
|
||||
|
||||
/**
|
||||
* Configurable chunk tracker supporting "fast" and "aggressive" loading modes.
|
||||
* Based on Beddium's SafeChunkTracker by Ven and FalsePattern.
|
||||
*
|
||||
* Modes (controlled by {@link AngelicaConfig#useVanillaChunkTracking}):
|
||||
* - Fast (default): Only renders chunks when all 8 neighbors are loaded (better lighting/AO)
|
||||
* - Aggressive: Renders chunks immediately when loaded (faster perceived loading)
|
||||
*
|
||||
* Mode can be switched at runtime via options menu - triggers renderer reload.
|
||||
*/
|
||||
public class AngelicaChunkTracker extends ChunkTrackerImpl {
|
||||
|
||||
@Override
|
||||
public void forEachReady(RenderSectionManager sectionManager) {
|
||||
if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
|
||||
setFastMode(AngelicaConfig.useVanillaChunkTracking);
|
||||
}
|
||||
|
||||
super.forEachReady(sectionManager);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void forEachEvent(RenderSectionManager sectionManager) {
|
||||
if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
|
||||
setFastMode(AngelicaConfig.useVanillaChunkTracking);
|
||||
}
|
||||
|
||||
super.forEachEvent(sectionManager);
|
||||
}
|
||||
}
|
||||
+25
-16
@@ -3,6 +3,7 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
import com.google.common.collect.ImmutableListMultimap;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.StateSet;
|
||||
import com.gtnewhorizons.angelica.proxy.ClientProxy;
|
||||
import com.gtnewhorizons.angelica.utils.SpritePadding;
|
||||
import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
|
||||
import lombok.Getter;
|
||||
@@ -15,6 +16,7 @@ import org.embeddedt.embeddium.impl.render.chunk.terrain.material.parameters.Alp
|
||||
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.Map;
|
||||
|
||||
public class AngelicaRenderPassConfiguration {
|
||||
@@ -31,25 +33,32 @@ public class AngelicaRenderPassConfiguration {
|
||||
.vertexType(vertexType)
|
||||
.primitiveType(QuadPrimitiveType.TRIANGULATED);
|
||||
|
||||
final int mipmapLevels = SodiumGameOptions.terrainMipmapLevels();
|
||||
|
||||
if (rgssEnabled) {
|
||||
builder.extraDefine("USE_RGSS", "");
|
||||
}
|
||||
if (SodiumGameOptions.usesTerrainTexelSnap()) {
|
||||
builder.extraDefine("USE_TEXEL_SNAP", "");
|
||||
}
|
||||
if (SodiumGameOptions.effectiveTextureFilterMode().usesAnisotropy()) {
|
||||
builder.extraDefine("USE_ANISOTROPIC", "");
|
||||
builder.extraDefine("TERRAIN_GUTTER", SpritePadding.gutterFor(mipmapLevels, true) + ".0");
|
||||
}
|
||||
if (mipmapLevels <= 0) {
|
||||
builder.extraDefine("TERRAIN_NO_MIPS", "");
|
||||
}
|
||||
samplerDefines(rgssEnabled, SodiumGameOptions.usesTerrainTexelSnap(),
|
||||
SodiumGameOptions.effectiveTextureFilterMode().usesAnisotropy(), SodiumGameOptions.terrainMipmapLevels())
|
||||
.forEach(builder::extraDefine);
|
||||
|
||||
return builder;
|
||||
}
|
||||
|
||||
/** Defines selecting the terrain fragment shader's sampling path. */
|
||||
public static Map<String, String> samplerDefines(boolean rgss, boolean texelSnap, boolean anisotropic, int mipmapLevels) {
|
||||
final Map<String, String> defines = new LinkedHashMap<>();
|
||||
if (rgss) {
|
||||
defines.put("USE_RGSS", "");
|
||||
}
|
||||
if (texelSnap) {
|
||||
defines.put("USE_TEXEL_SNAP", "");
|
||||
}
|
||||
if (anisotropic) {
|
||||
defines.put("USE_ANISOTROPIC", "");
|
||||
defines.put("TERRAIN_GUTTER", SpritePadding.gutterFor(mipmapLevels, true) + ".0");
|
||||
}
|
||||
if (mipmapLevels <= 0) {
|
||||
defines.put("TERRAIN_NO_MIPS", "");
|
||||
}
|
||||
return defines;
|
||||
}
|
||||
|
||||
public static RenderPassConfiguration<BlockRenderLayer> build(ChunkVertexType vertexType) {
|
||||
rgssEnabled = SodiumGameOptions.effectiveTextureFilterMode().usesRgss();
|
||||
|
||||
@@ -69,7 +78,7 @@ public class AngelicaRenderPassConfiguration {
|
||||
.name("translucent")
|
||||
.fragmentDiscard(false)
|
||||
.useReverseOrder(true)
|
||||
.useTranslucencySorting(true)
|
||||
.useTranslucencySorting(ClientProxy.options().performance.translucencySorting)
|
||||
.build();
|
||||
|
||||
TRANSLUCENT_MATERIAL = new Material(TRANSLUCENT_PASS, AlphaCutoffParameter.ZERO, true);
|
||||
|
||||
+17
-46
@@ -1,6 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.cardinalstar.cubicchunks.world.ICubicWorld;
|
||||
import com.gtnewhorizons.angelica.client.rendering.AngelicaFogService;
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.compat.cubicchunks.CubicChunksAPI;
|
||||
import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
|
||||
@@ -20,22 +21,21 @@ import net.minecraft.client.multiplayer.WorldClient;
|
||||
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
||||
import net.minecraft.world.chunk.Chunk;
|
||||
import org.embeddedt.embeddium.impl.gl.device.CommandList;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.ChunkRenderMatrices;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.ChunkUpdateType;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderSection;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderSectionManager;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.compile.ChunkBuildOutput;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.compile.tasks.ChunkBuilderTask;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.fog.FogService;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.lists.SectionTicker;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.occlusion.AsyncOcclusionMode;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.sprite.GenericSectionSpriteTicker;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
|
||||
import org.embeddedt.embeddium.impl.render.viewport.CameraTransform;
|
||||
import org.embeddedt.embeddium.impl.render.viewport.Viewport;
|
||||
import org.embeddedt.embeddium.impl.util.PositionUtil;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import org.joml.Vector3d;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
@@ -58,15 +58,13 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
private static final Tracy.ZoneId Z_BIOME_REBUILDS = Tracy.zoneId("biomeRebuilds", Tracy.COLOR_TERRAIN);
|
||||
private static final Tracy.ZoneId Z_GRAPH_SEARCH = Tracy.zoneId("graphSearch", Tracy.COLOR_TERRAIN);
|
||||
private static final Tracy.ZoneId Z_SECTION_UPLOAD = Tracy.zoneId("sectionUpload", Tracy.COLOR_TERRAIN);
|
||||
private static final Tracy.ZoneId Z_SHADOW_GRAPH_WAIT = Tracy.zoneId("shadowGraphWait", Tracy.COLOR_TERRAIN);
|
||||
|
||||
private boolean initialCameraSectionReady = false;
|
||||
|
||||
private final WorldClient world;
|
||||
private final ClonedChunkSectionCache sectionCache;
|
||||
private final ChunkTaskProvider taskProvider;
|
||||
private final LongOpenHashSet biomeRebuildColumns = new LongOpenHashSet();
|
||||
private final DeferredMeshScheduler deferredScheduler;
|
||||
private int shadowSearchSubmissions;
|
||||
|
||||
public AngelicaRenderSectionManager(RenderPassConfiguration<?> configuration, WorldClient world, int renderDistance, CommandList commandList, int minSection, int maxSection, int requestedThreads, ChunkTaskProvider taskProvider) {
|
||||
super(configuration, () -> new AngelicaChunkBuildContext(configuration, world), AngelicaChunkRenderer::new, renderDistance, commandList, minSection, maxSection, requestedThreads, true /* hasShadowPass = true for Iris */);
|
||||
@@ -92,24 +90,9 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
return new AngelicaRenderSectionManager(AngelicaRenderPassConfiguration.build(vertexType), world, renderDistance, commandList, minSection, maxSection, provider.threadCount(), provider);
|
||||
}
|
||||
|
||||
public void setCameraPosition(double x, double y, double z) {
|
||||
this.cameraPosition.set(x, y, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void update(Viewport positionedViewport, int frame, boolean spectator) {
|
||||
if (isInShadowPass()) {
|
||||
return;
|
||||
}
|
||||
if (!initialCameraSectionReady) {
|
||||
var origin = positionedViewport.getChunkCoord();
|
||||
long key = PositionUtil.packSection(origin.x(), origin.y(), origin.z());
|
||||
if (!((RenderSectionManagerAccessor) this).angelica$getSectionByPosition().containsKey(key)) {
|
||||
return;
|
||||
}
|
||||
initialCameraSectionReady = true;
|
||||
}
|
||||
super.update(positionedViewport, frame, spectator);
|
||||
public FogService getFogService() {
|
||||
return AngelicaFogService.INSTANCE;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -173,7 +156,7 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
return null;
|
||||
}
|
||||
|
||||
final ChunkBuilderTask<ChunkBuildOutput> task = this.taskProvider.createRebuildTask(render, frame, this.cameraPosition, this.sectionCache);
|
||||
final ChunkBuilderTask<ChunkBuildOutput> task = this.taskProvider.createRebuildTask(render, frame, new Vector3d(this.cameraPosition), this.sectionCache);
|
||||
if (task instanceof AngelicaChunkBuilderMeshingTask t) {
|
||||
final ChunkUpdateType pending = render.getPendingUpdate();
|
||||
t.bindScheduler(this.deferredScheduler, pending != null && pending.isImportant());
|
||||
@@ -219,9 +202,6 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
|
||||
@Override
|
||||
public void updateChunks(boolean updateImmediately) {
|
||||
if (isInShadowPass()) {
|
||||
return;
|
||||
}
|
||||
this.sectionCache.cleanup();
|
||||
this.flushBiomeRebuilds();
|
||||
if (Tracy.ENABLED) Tracy.beginZone(Z_GRAPH_SEARCH);
|
||||
@@ -276,14 +256,19 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canSubmitShadowGraphSearch() {
|
||||
return super.canSubmitShadowGraphSearch() && this.shadowRenderListManager.isNeedsUpdate()
|
||||
&& !this.shadowRenderListManager.hasOcclusionFutureInFlight();
|
||||
protected boolean canSubmitShadowGraphSearch() {
|
||||
return super.canSubmitShadowGraphSearch() && this.shadowRenderListManager.isNeedsUpdate();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean submitShadowGraphSearch(Viewport viewport, int frame) {
|
||||
return super.submitShadowGraphSearch(viewport, frame);
|
||||
protected void submitShadowGraphSearch(Viewport viewport, int frame) {
|
||||
super.submitShadowGraphSearch(viewport, frame);
|
||||
this.shadowSearchSubmissions++;
|
||||
}
|
||||
|
||||
/** Running count of submitted shadow searches; a change across a shadow pass means new lists are pending. */
|
||||
public int getShadowSearchSubmissions() {
|
||||
return this.shadowSearchSubmissions;
|
||||
}
|
||||
|
||||
public boolean isShadowGraphDirty() {
|
||||
@@ -314,20 +299,6 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
|
||||
return list;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderLayer(ChunkRenderMatrices matrices, TerrainRenderPass pass, CameraTransform occlusionCamera, CameraTransform camera) {
|
||||
// Shadow pass graph update is async - must wait for it to complete before rendering
|
||||
if (IrisShaderProviderHolder.isShadowPass()) {
|
||||
if (Tracy.ENABLED) Tracy.beginZone(Z_SHADOW_GRAPH_WAIT);
|
||||
try {
|
||||
finishAllGraphUpdates();
|
||||
} finally {
|
||||
if (Tracy.ENABLED) Tracy.endZone();
|
||||
}
|
||||
}
|
||||
super.renderLayer(matrices, pass, occlusionCamera, camera);
|
||||
}
|
||||
|
||||
/**
|
||||
* Process both asyncSubmittedTasks and AngelicaRenderQueue.TASKS.
|
||||
*/
|
||||
|
||||
+20
-11
@@ -35,6 +35,15 @@ public class CeleritasDebugScreenHandler {
|
||||
private List<String> cachedRight;
|
||||
private long lastBuildNanos;
|
||||
|
||||
static boolean isVerbose() {
|
||||
return AngelicaConfig.verboseF3 || SystemProperties.DEBUG_F3_DETAIL;
|
||||
}
|
||||
|
||||
/** Drops the cached right-hand lines so a verbose toggle shows on the next frame. */
|
||||
public static void invalidate() {
|
||||
INSTANCE.cachedRight = null;
|
||||
}
|
||||
|
||||
@SubscribeEvent(priority = EventPriority.LOW)
|
||||
public void onRenderGameOverlayTextEvent(RenderGameOverlayEvent.Text event) {
|
||||
final Minecraft mc = Minecraft.getMinecraft();
|
||||
@@ -69,17 +78,17 @@ public class CeleritasDebugScreenHandler {
|
||||
lines.add("");
|
||||
lines.add(EnumChatFormatting.GREEN + "Angelica " + Tags.VERSION + " [Celeritas Renderer] [" + RENDER_BACKEND.getName() + "]");
|
||||
lines.addAll(renderer.getDebugStrings());
|
||||
final ShaderManager sm = ShaderManager.getInstance();
|
||||
if (sm != null) {
|
||||
lines.add(sm.getDebugInfo());
|
||||
}
|
||||
lines.add(TessellatorStreamingDrawer.getDebugInfo());
|
||||
lines.add(TesrBatchRenderer.INSTANCE.getDebugSummaryLine());
|
||||
final String transferInfo = RENDER_BACKEND.getTransferDebugInfo();
|
||||
if (transferInfo != null) {
|
||||
lines.add(transferInfo);
|
||||
}
|
||||
if (SystemProperties.DEBUG_F3_DETAIL) {
|
||||
if (isVerbose()) {
|
||||
final ShaderManager sm = ShaderManager.getInstance();
|
||||
if (sm != null) {
|
||||
lines.add(sm.getDebugInfo());
|
||||
}
|
||||
lines.add(TessellatorStreamingDrawer.getDebugInfo());
|
||||
lines.add(TesrBatchRenderer.INSTANCE.getDebugSummaryLine());
|
||||
final String transferInfo = RENDER_BACKEND.getTransferDebugInfo();
|
||||
if (transferInfo != null) {
|
||||
lines.add(transferInfo);
|
||||
}
|
||||
lines.addAll(TesrBatchRenderer.INSTANCE.getDebugDetailStrings());
|
||||
lines.add(ModelPartBatcher.INSTANCE.getDebugString());
|
||||
if (Tracy.ENABLED) {
|
||||
|
||||
@@ -2,17 +2,13 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.event.ChunkBiomeDataChangedEvent;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.loading.AngelicaClientTweaker;
|
||||
import org.embeddedt.embeddium.impl.gl.device.GLRenderDevice;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
|
||||
public class CeleritasSetup {
|
||||
private static boolean initialized = false;
|
||||
|
||||
public static void ensureInitialized() {
|
||||
if (!initialized) {
|
||||
GLRenderDevice.VANILLA_STATE_RESETTER = () -> GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
|
||||
ChunkBiomeDataChangedEvent.BUS.addListener(CeleritasSetup::onChunkBiomeDataChanged);
|
||||
AngelicaClientTweaker.LOGGER.debug("Celeritas init");
|
||||
initialized = true;
|
||||
|
||||
+91
-88
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Comparator;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.bop.FogBiomeCache;
|
||||
@@ -25,9 +24,8 @@ import org.embeddedt.embeddium.impl.gl.device.CommandList;
|
||||
import org.embeddedt.embeddium.impl.gl.device.RenderDevice;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.ChunkRenderMatrices;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.RenderSection;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.data.MinecraftBuiltRenderSectionData;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.lists.ChunkRenderList;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.lists.SortedRenderLists;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTracker;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTrackerHolder;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkMeshFormats;
|
||||
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
|
||||
import org.embeddedt.embeddium.impl.render.terrain.SimpleWorldRenderer;
|
||||
@@ -41,6 +39,7 @@ import org.lwjgl.opengl.GL11;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.compat.cubicchunks.CubicChunksAPI;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightWorldRenderer;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
@@ -78,7 +77,9 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
/** Debug flag for wireframe rendering mode. Toggle via /angelica wireframe */
|
||||
public static boolean DEBUG_WIREFRAME_MODE = false;
|
||||
|
||||
private final TileEntityRenderContext teRenderContext = new TileEntityRenderContext();
|
||||
private final TileEntityRenderContext teRenderContext = new TileEntityRenderContext(false);
|
||||
private final TileEntityRenderContext shadowCollectContext = new TileEntityRenderContext(true);
|
||||
private Viewport shadowPassPlayerViewport;
|
||||
private boolean useEntityCulling = true;
|
||||
|
||||
private FrustumIntersection teFrustum;
|
||||
@@ -86,9 +87,6 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
private int teCullEpoch;
|
||||
private double teCamX, teCamY, teCamZ;
|
||||
|
||||
// the volume of a section multiplied by the number of sections to be checked at most
|
||||
private static final double MAX_ENTITY_CHECK_VOLUME = 16 * 16 * 16 * 15;
|
||||
|
||||
private final ObjectArrayList<TileEntity> frameTEs = new ObjectArrayList<>();
|
||||
private final ObjectArrayList<TileEntity> frameOverride = new ObjectArrayList<>();
|
||||
|
||||
@@ -130,7 +128,7 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
|
||||
public void runFrameIdleWork(long deadlineNanos) {
|
||||
final AngelicaRenderSectionManager rsm = this.renderSectionManager;
|
||||
if (rsm == null || this.world == null) return;
|
||||
if (rsm == null || this.world == null || rsm.isInShadowPass()) return;
|
||||
RenderDevice.enterManagedCode();
|
||||
try {
|
||||
long start = System.nanoTime();
|
||||
@@ -264,104 +262,105 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
return count;
|
||||
}
|
||||
|
||||
private CameraState lastMainCameraState;
|
||||
|
||||
@Override
|
||||
public void setupTerrain(Viewport viewport, CameraState cameraState, int frame, boolean spectator, boolean updateChunksImmediately) {
|
||||
var transform = viewport.getTransform();
|
||||
this.shadowPassPlayerViewport = null;
|
||||
|
||||
final CameraTransform transform = viewport.getTransform();
|
||||
if (transform.x == 0 && transform.y == 0 && transform.z == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
renderSectionManager.setCameraPosition(transform.x, transform.y, transform.z);
|
||||
|
||||
this.useEntityCulling = ClientProxy.options().performance.useEntityCulling;
|
||||
|
||||
if (renderSectionManager.isInShadowPass()) {
|
||||
if (lastMainCameraState != null) {
|
||||
cameraState = lastMainCameraState;
|
||||
}
|
||||
} else {
|
||||
lastMainCameraState = cameraState;
|
||||
// Same inputs as the shadow pass's state; reusing it keeps a fog-end change made while rendering shadows from
|
||||
// dirtying the graph a second time this frame.
|
||||
if (renderSectionManager.didShadowPassRunThisFrame() && this.lastCameraState != null) {
|
||||
cameraState = this.lastCameraState;
|
||||
}
|
||||
|
||||
super.setupTerrain(viewport, cameraState, frame, spectator, updateChunksImmediately);
|
||||
|
||||
if (!renderSectionManager.isInShadowPass()) {
|
||||
final GpuTerrainCuller terrainCuller = GpuTerrainCuller.activeInstance();
|
||||
if (terrainCuller != null) {
|
||||
terrainCuller.prepareAllPasses(createChunkRenderMatrices(), renderSectionManager.getRenderLists(),
|
||||
viewport.getTransform(), cameraTransform(cameraState.x(), cameraState.y(), cameraState.z()),
|
||||
IrisShaderProviderHolder.shouldUseFaceCulling());
|
||||
}
|
||||
final GpuTerrainCuller terrainCuller = GpuTerrainCuller.activeInstance();
|
||||
if (terrainCuller != null) {
|
||||
terrainCuller.prepareAllPasses(createChunkRenderMatrices(), renderSectionManager.getRenderLists(),
|
||||
viewport.getTransform(), cameraTransform(cameraState.x(), cameraState.y(), cameraState.z()),
|
||||
IrisShaderProviderHolder.shouldUseFaceCulling());
|
||||
}
|
||||
|
||||
// Process deferred dynamic light chunk rebuilds with frustum culling
|
||||
if (DynamicLights.isEnabled() && DynamicLights.FrustumCullingEnabled) {
|
||||
DynamicLights.get().processChunkRebuilds(viewport);
|
||||
}
|
||||
}
|
||||
|
||||
if (renderSectionManager.isInShadowPass()) {
|
||||
if (IrisShaderProviderHolder.isActive()) {
|
||||
collectTileEntitiesForShadow();
|
||||
}
|
||||
} else if (IrisShaderProviderHolder.isActive()) {
|
||||
IrisShaderProviderHolder.getProvider().preSubmitShadowGraph(frame);
|
||||
/** Captured before the shadow pass; the shadow pass's clipRenderersByFrustum only sees the shadow frustum. */
|
||||
public void setShadowPassPlayerViewport(Viewport viewport) {
|
||||
this.shadowPassPlayerViewport = viewport;
|
||||
}
|
||||
|
||||
/** Shadow-pass entry from clipRenderersByFrustum; falls back to the last terrain viewport if none was captured. */
|
||||
public void setupShadowTerrain(Viewport shadowViewport, CameraState cameraState, int frame, boolean spectator) {
|
||||
Viewport playerViewport = this.shadowPassPlayerViewport;
|
||||
this.shadowPassPlayerViewport = null;
|
||||
if (playerViewport == null) {
|
||||
playerViewport = this.getLastViewport();
|
||||
}
|
||||
if (playerViewport != null) {
|
||||
this.setupShadowTerrain(playerViewport, shadowViewport, cameraState, frame, spectator);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setupShadowTerrain(Viewport playerViewport, Viewport shadowViewport, CameraState cameraState, int frame, boolean spectator) {
|
||||
final CameraTransform transform = playerViewport.getTransform();
|
||||
if (transform.x == 0 && transform.y == 0 && transform.z == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.useEntityCulling = ClientProxy.options().performance.useEntityCulling;
|
||||
|
||||
super.setupShadowTerrain(playerViewport, shadowViewport, cameraState, frame, spectator);
|
||||
|
||||
if (DynamicLights.isEnabled() && DynamicLights.FrustumCullingEnabled) {
|
||||
DynamicLights.get().processChunkRebuilds(shadowViewport);
|
||||
}
|
||||
|
||||
if (IrisShaderProviderHolder.isActive()) {
|
||||
super.renderBlockEntities(this.shadowCollectContext);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void processChunkEvents() {
|
||||
final ChunkTracker tracker = ChunkTrackerHolder.get(this.world);
|
||||
if (tracker instanceof CubeStatusTracker cubic) {
|
||||
cubic.forEachEvent(this.renderSectionManager);
|
||||
return;
|
||||
}
|
||||
syncChunkTrackingMode(tracker);
|
||||
super.processChunkEvents();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initRenderer(CommandList commandList) {
|
||||
final ChunkTracker tracker = ChunkTrackerHolder.get(this.world);
|
||||
if (!(tracker instanceof CubeStatusTracker)) {
|
||||
syncChunkTrackingMode(tracker);
|
||||
}
|
||||
super.initRenderer(commandList);
|
||||
if (tracker instanceof CubeStatusTracker cubic) {
|
||||
cubic.forEachReady(this.renderSectionManager);
|
||||
}
|
||||
}
|
||||
|
||||
private static void syncChunkTrackingMode(ChunkTracker tracker) {
|
||||
tracker.setRequiredNeighborRadius(AngelicaConfig.useVanillaChunkTracking ? 0 : 1);
|
||||
}
|
||||
|
||||
public void setCurrentViewport(Viewport viewport) {
|
||||
this.currentViewport = viewport;
|
||||
}
|
||||
|
||||
public Viewport getCurrentViewport() {
|
||||
return this.currentViewport;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private void collectTileEntitiesForShadow() {
|
||||
final SortedRenderLists renderLists = renderSectionManager.getRenderLists();
|
||||
final Iterator<ChunkRenderList> renderListIterator = renderLists.iterator();
|
||||
|
||||
while (renderListIterator.hasNext()) {
|
||||
final var renderList = renderListIterator.next();
|
||||
final var renderRegion = renderList.getRegion();
|
||||
final var renderSectionIterator = renderList.sectionsWithEntitiesIterator();
|
||||
|
||||
if (renderSectionIterator == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
while (renderSectionIterator.hasNext()) {
|
||||
final var renderSectionId = renderSectionIterator.nextByteAsInt();
|
||||
final var renderSection = renderRegion.getSection(renderSectionId);
|
||||
|
||||
if (renderSection == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
final var context = renderSection.getBuiltContext();
|
||||
if (context instanceof MinecraftBuiltRenderSectionData<?, ?> mcData) {
|
||||
final var culledEntities = (List<TileEntity>) mcData.culledBlockEntities;
|
||||
if (!culledEntities.isEmpty()) {
|
||||
ShadowRenderer.visibleTileEntities.add(culledEntities);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (var renderSection : renderSectionManager.getSectionsWithGlobalEntities()) {
|
||||
final var context = renderSection.getBuiltContext();
|
||||
if (context instanceof MinecraftBuiltRenderSectionData<?, ?> mcData) {
|
||||
final var globalEntities = (List<TileEntity>) mcData.globalBlockEntities;
|
||||
if (!globalEntities.isEmpty()) {
|
||||
ShadowRenderer.globalTileEntities.add(globalEntities);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private CameraTransform cachedCameraTransform;
|
||||
private double cachedCamX, cachedCamY, cachedCamZ;
|
||||
|
||||
@@ -481,6 +480,11 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
|
||||
@Override
|
||||
protected int renderSectionBlockEntities(RenderSection section, List<TileEntity> blockEntities, boolean culled, TileEntityRenderContext renderContext) {
|
||||
if (renderContext.shadowCollect) {
|
||||
(culled ? ShadowRenderer.visibleTileEntities : ShadowRenderer.globalTileEntities).add(blockEntities);
|
||||
return blockEntities.size();
|
||||
}
|
||||
|
||||
if (culled) {
|
||||
if (section.getBuiltContext() instanceof AngelicaBuiltRenderSectionData angelicaData) {
|
||||
if (TeDistanceMath.distSqToSection(teCamX, teCamY, teCamZ,
|
||||
@@ -625,20 +629,19 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
|
||||
return true;
|
||||
}
|
||||
|
||||
// bail on very large entities to avoid checking many sections
|
||||
final double entityVolume = (box.maxX - box.minX) * (box.maxY - box.minY) * (box.maxZ - box.minZ);
|
||||
if (entityVolume > MAX_ENTITY_CHECK_VOLUME) {
|
||||
// TODO: do a frustum check instead, even large entities aren't visible if they're outside the frustum
|
||||
return true;
|
||||
}
|
||||
|
||||
return this.isBoxVisible(box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ);
|
||||
}
|
||||
|
||||
public static class TileEntityRenderContext {
|
||||
/** Collects shadow-pass block entity lists for ShadowRenderer instead of rendering. */
|
||||
final boolean shadowCollect;
|
||||
public float partialTicks;
|
||||
public int pass;
|
||||
|
||||
TileEntityRenderContext(boolean shadowCollect) {
|
||||
this.shadowCollect = shadowCollect;
|
||||
}
|
||||
|
||||
public TileEntityRenderContext set(float partialTicks, int pass) {
|
||||
this.partialTicks = partialTicks;
|
||||
this.pass = pass;
|
||||
|
||||
@@ -7,7 +7,8 @@ import com.cardinalstar.cubicchunks.util.HashMap3D;
|
||||
import com.cardinalstar.cubicchunks.util.HashSet3D;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
|
||||
public class CubeStatusTracker implements ChunkTracker {
|
||||
/** Tracks 3D cubes instead of columns; the inherited 2D state stays empty. */
|
||||
public class CubeStatusTracker extends ChunkTracker {
|
||||
|
||||
/// Cubes that have been synced to the client and are currently loaded.
|
||||
private final HashSet3D loadedCubes = new HashSet3D();
|
||||
@@ -28,14 +29,12 @@ public class CubeStatusTracker implements ChunkTracker {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setFastMode(boolean fastMode) {
|
||||
this.fastMode = fastMode;
|
||||
|
||||
this.loadedCubes.forEach(this::pollCube);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isFastModeEnabled() {
|
||||
return fastMode;
|
||||
}
|
||||
@@ -107,7 +106,6 @@ public class CubeStatusTracker implements ChunkTracker {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
@Override
|
||||
public void forEachReady(RenderSectionManager renderSectionManager) {
|
||||
if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
|
||||
setFastMode(AngelicaConfig.useVanillaChunkTracking);
|
||||
@@ -134,7 +132,6 @@ public class CubeStatusTracker implements ChunkTracker {
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void forEachEvent(RenderSectionManager renderSectionManager) {
|
||||
if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
|
||||
setFastMode(AngelicaConfig.useVanillaChunkTracking);
|
||||
|
||||
@@ -1,27 +0,0 @@
|
||||
package com.gtnewhorizons.angelica.rendering.celeritas;
|
||||
|
||||
/** Decides when the section-age uniform upload can be skipped */
|
||||
public final class SectionAgeMath {
|
||||
|
||||
public static final long STEP_NANOS = 100_000_000L;
|
||||
|
||||
private SectionAgeMath() {}
|
||||
|
||||
public static long quantize(long timestampNanos) {
|
||||
return timestampNanos - Math.floorMod(timestampNanos, STEP_NANOS);
|
||||
}
|
||||
|
||||
public static long[] newState() {
|
||||
return new long[] { Long.MIN_VALUE, Long.MIN_VALUE, 0L };
|
||||
}
|
||||
|
||||
public static boolean canSkip(long[] state, long newestLoadTime, long quantizedTimestamp) {
|
||||
return state[0] == newestLoadTime && (state[2] == 1L || state[1] == quantizedTimestamp);
|
||||
}
|
||||
|
||||
public static void record(long[] state, long newestLoadTime, long quantizedTimestamp, boolean allSaturated) {
|
||||
state[0] = newestLoadTime;
|
||||
state[1] = quantizedTimestamp;
|
||||
state[2] = allSaturated ? 1L : 0L;
|
||||
}
|
||||
}
|
||||
@@ -14,6 +14,11 @@ public final class TerrainDrawStats {
|
||||
private static int cullMaxRegionCommands;
|
||||
private static long sectionMetaBytes;
|
||||
|
||||
// Running totals
|
||||
private static long indexBufferGrowths;
|
||||
private static long sectionsUploaded;
|
||||
private static long bytesUploaded;
|
||||
|
||||
private TerrainDrawStats() {
|
||||
}
|
||||
|
||||
@@ -44,6 +49,27 @@ public final class TerrainDrawStats {
|
||||
sectionMetaBytes += bytes;
|
||||
}
|
||||
|
||||
public static void recordIndexBufferGrowth() {
|
||||
indexBufferGrowths++;
|
||||
}
|
||||
|
||||
public static void recordSectionUpload(long bytes) {
|
||||
sectionsUploaded++;
|
||||
bytesUploaded += bytes;
|
||||
}
|
||||
|
||||
public static long getIndexBufferGrowths() {
|
||||
return indexBufferGrowths;
|
||||
}
|
||||
|
||||
public static long getSectionsUploaded() {
|
||||
return sectionsUploaded;
|
||||
}
|
||||
|
||||
public static long getBytesUploaded() {
|
||||
return bytesUploaded;
|
||||
}
|
||||
|
||||
public static int takeBatchRebuilds() {
|
||||
final int n = batchRebuilds;
|
||||
batchRebuilds = 0;
|
||||
|
||||
-2
@@ -27,6 +27,4 @@ public interface IrisShaderProvider {
|
||||
|
||||
/** Block render layer overrides from shader pack */
|
||||
@Nullable Map<Block, BlockRenderLayer> getBlockTypeIds();
|
||||
|
||||
default void preSubmitShadowGraph(int frame) {}
|
||||
}
|
||||
@@ -442,8 +442,9 @@ public final class GpuTerrainCuller {
|
||||
}
|
||||
|
||||
private void walkSortedGroup(ChunkRenderMatrices matrices, ChunkRenderListIterable renderLists, CameraTransform occlusionCamera, CameraTransform camera, boolean useBlockFaceCulling, boolean chained) {
|
||||
final int indexPointerMask = AngelicaRenderPassConfiguration.TRANSLUCENT_PASS.isSorted() ? 0xFFFFFFFF : 0;
|
||||
if (chained) {
|
||||
startSortedPass(0xFFFFFFFF);
|
||||
startSortedPass(indexPointerMask);
|
||||
} else {
|
||||
invalidatePreparedPasses();
|
||||
computeActiveThisPass = GpuCulling.mode().computeEnabled();
|
||||
@@ -452,7 +453,7 @@ public final class GpuTerrainCuller {
|
||||
passOutputBase = 0;
|
||||
walkPrimitiveType = null;
|
||||
primaryPass.reset(0, 0);
|
||||
sortedPass.reset(0xFFFFFFFF, 0);
|
||||
sortedPass.reset(indexPointerMask, 0);
|
||||
buildPass = sortedPass;
|
||||
current = sortedPass;
|
||||
}
|
||||
|
||||
@@ -766,6 +766,12 @@ public class SodiumGameOptionPages {
|
||||
.setControl(TickBoxControl::new)
|
||||
.setBinding((opts, value) -> AngelicaConfig.disableF3Additions = value, opts -> AngelicaConfig.disableF3Additions)
|
||||
.build())
|
||||
.add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
|
||||
.setName(I18n.format("options.angelica.verbosef3"))
|
||||
.setTooltip(I18n.format("options.angelica.verbosef3.tooltip"))
|
||||
.setControl(TickBoxControl::new)
|
||||
.setBinding((opts, value) -> AngelicaConfig.verboseF3 = value, opts -> AngelicaConfig.verboseF3)
|
||||
.build())
|
||||
.build());
|
||||
|
||||
if (AngelicaConfig.enableZoom) {
|
||||
|
||||
@@ -66,12 +66,6 @@ public class IrisCeleritasShaderProvider implements IrisShaderProvider {
|
||||
return BlockRenderingSettings.INSTANCE.getBlockTypeIds();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void preSubmitShadowGraph(int frame) {
|
||||
final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
|
||||
if (pipeline != null) pipeline.preSubmitShadowGraph(frame);
|
||||
}
|
||||
|
||||
public void deleteShaders() {
|
||||
overrides.deleteShaders();
|
||||
}
|
||||
|
||||
@@ -1958,11 +1958,6 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
|
||||
isRenderingFullScreenPass = false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void preSubmitShadowGraph(int frame) {
|
||||
if (shadowRenderer != null) shadowRenderer.preSubmitGraphUpdate(frame);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderShadows(EntityRenderer levelRenderer, Camera playerCamera) {
|
||||
if (shouldRenderPrepareBeforeShadow) {
|
||||
|
||||
@@ -81,6 +81,7 @@ public class ShadowRenderer {
|
||||
private static final Tracy.ZoneId Z_SHADOW_FRUSTUM = Tracy.zoneId("shadowFrustum", Tracy.COLOR_IRIS);
|
||||
private static final Tracy.ZoneId Z_SHADOW_VIEWPORT = Tracy.zoneId("shadowViewport", Tracy.COLOR_IRIS);
|
||||
private static final Tracy.ZoneId Z_SHADOW_MODEL_PARTS = Tracy.zoneId("shadowModelParts", Tracy.COLOR_IRIS);
|
||||
private static final Tracy.ZoneId Z_SHADOW_GRAPH_JOIN = Tracy.zoneId("shadowGraphJoin", Tracy.COLOR_IRIS);
|
||||
|
||||
public static final Matrix4f MODELVIEW = new Matrix4f();
|
||||
public static final FloatBuffer MODELVIEW_BUFFER = BufferUtils.createFloatBuffer(16);
|
||||
@@ -114,6 +115,7 @@ public class ShadowRenderer {
|
||||
private final boolean shouldRenderEntities;
|
||||
private final boolean shouldRenderPlayer;
|
||||
private final boolean shouldRenderBlockEntities;
|
||||
private final boolean shouldRenderLightBlockEntities;
|
||||
private final float sunPathRotation;
|
||||
private final List<MipmapPass> mipmapPasses = new ArrayList<>();
|
||||
private final String debugStringOverall;
|
||||
@@ -171,10 +173,9 @@ public class ShadowRenderer {
|
||||
private final FrustumCaches entityFrustumCaches = new FrustumCaches();
|
||||
private float lastGraphShadowAngle = Float.NaN;
|
||||
private float relayShadowAngle = Float.NaN;
|
||||
private FrustumHolder preSubmitFrustumHolder = new FrustumHolder("preSubmit");
|
||||
private final FrustumCaches preSubmitFrustumCaches = new FrustumCaches();
|
||||
private boolean preSubmitActive;
|
||||
private float preSubmittedShadowAngle = Float.NaN;
|
||||
/** A shadow search was submitted by the last shadow pass; with async occlusion its lists are published by this pass's join. */
|
||||
private boolean shadowSearchPending;
|
||||
private float searchedShadowAngle = Float.NaN;
|
||||
|
||||
private float shadowAngleDelta() {
|
||||
final Vector4f light = celestialUniforms.getShadowLightPositionInWorldSpace();
|
||||
@@ -185,25 +186,6 @@ public class ShadowRenderer {
|
||||
AngelicaConfig.shadowGraphHorizonScale);
|
||||
}
|
||||
|
||||
public void preSubmitGraphUpdate(int frame) {
|
||||
final AngelicaRenderSectionManager rsm = CeleritasWorldRenderer.getInstance().getRenderSectionManager();
|
||||
final float currentShadowAngle = getShadowAngle();
|
||||
if (ShadowGraphGate.shouldMarkDirty(lastGraphShadowAngle, currentShadowAngle, shadowAngleDelta())) {
|
||||
rsm.markShadowGraphDirty();
|
||||
lastGraphShadowAngle = currentShadowAngle;
|
||||
}
|
||||
if (!rsm.canSubmitShadowGraphSearch()) return;
|
||||
|
||||
preSubmitFrustumHolder = createShadowFrustum(renderDistanceMultiplier, preSubmitFrustumHolder, preSubmitFrustumCaches);
|
||||
if (!(preSubmitFrustumHolder.getFrustum() instanceof ViewportProvider provider)) return;
|
||||
final Vector3d entityPos = Camera.INSTANCE.getEntityPos();
|
||||
preSubmitFrustumHolder.getFrustum().setPosition(entityPos.x, entityPos.y, entityPos.z);
|
||||
|
||||
if (rsm.submitShadowGraphSearch(provider.sodium$createViewport(), frame)) {
|
||||
preSubmittedShadowAngle = lastGraphShadowAngle;
|
||||
preSubmitActive = true;
|
||||
}
|
||||
}
|
||||
private long lastRelayNanos;
|
||||
private final Vector3f shadowLightVectorCache = new Vector3f();
|
||||
private final MemoizedBoxCuller tileEntityCuller = new MemoizedBoxCuller();
|
||||
@@ -232,6 +214,7 @@ public class ShadowRenderer {
|
||||
this.shouldRenderEntities = shadowDirectives.shouldRenderEntities();
|
||||
this.shouldRenderPlayer = shadowDirectives.shouldRenderPlayer();
|
||||
this.shouldRenderBlockEntities = shadowDirectives.shouldRenderBlockEntities();
|
||||
this.shouldRenderLightBlockEntities = shadowDirectives.shouldRenderLightBlockEntities();
|
||||
this.shouldRenderDH = shadowDirectives.isDhShadowEnabled().orElse(false);
|
||||
this.packUsesShadowtex1 = packUsesShadowtex1;
|
||||
|
||||
@@ -797,7 +780,11 @@ public class ShadowRenderer {
|
||||
);
|
||||
}
|
||||
|
||||
private void renderTileEntities(Object bufferSource, MatrixStack modelView, double cameraX, double cameraY, double cameraZ, float partialTicks, boolean hasEntityFrustum) {
|
||||
private static boolean emitsLight(TileEntity tile) {
|
||||
return tile.getBlockType().getLightValue(tile.getWorldObj(), tile.xCoord, tile.yCoord, tile.zCoord) > 0;
|
||||
}
|
||||
|
||||
private void renderTileEntities(Object bufferSource, MatrixStack modelView, double cameraX, double cameraY, double cameraZ, float partialTicks, boolean hasEntityFrustum, boolean lightsOnly) {
|
||||
profiler.startSection("iris_shadow_build_blockentities");
|
||||
|
||||
int shadowTileEntities = 0;
|
||||
@@ -826,6 +813,9 @@ public class ShadowRenderer {
|
||||
if (hasEntityFrustum && (culler.isCulled(tileEntity.xCoord - 1, tileEntity.yCoord - 1, tileEntity.zCoord - 1, tileEntity.xCoord + 1, tileEntity.yCoord + 1, tileEntity.zCoord + 1))) {
|
||||
continue;
|
||||
}
|
||||
if (lightsOnly && !emitsLight(tileEntity)) {
|
||||
continue;
|
||||
}
|
||||
renderTileEntity(tileEntity, cameraX, cameraY, cameraZ, partialTicks);
|
||||
|
||||
shadowTileEntities++;
|
||||
@@ -838,6 +828,9 @@ public class ShadowRenderer {
|
||||
if (hasEntityFrustum && (culler.isCulled(tileEntity.xCoord - 1, tileEntity.yCoord - 1, tileEntity.zCoord - 1, tileEntity.xCoord + 1, tileEntity.yCoord + 1, tileEntity.zCoord + 1))) {
|
||||
continue;
|
||||
}
|
||||
if (lightsOnly && !emitsLight(tileEntity)) {
|
||||
continue;
|
||||
}
|
||||
renderTileEntity(tileEntity, cameraX, cameraY, cameraZ, partialTicks);
|
||||
|
||||
shadowTileEntities++;
|
||||
@@ -864,8 +857,20 @@ public class ShadowRenderer {
|
||||
this.profiler = Minecraft.getMinecraft().mcProfiler;
|
||||
|
||||
profiler.endStartSection("iris_shadows");
|
||||
|
||||
final AngelicaRenderSectionManager rsm = CeleritasWorldRenderer.getInstance().getRenderSectionManager();
|
||||
// The in-flight shadow search reads terrainFrustumHolder's frustum, which createShadowFrustum re-inits below.
|
||||
if (Tracy.ENABLED) Tracy.beginZone(Z_SHADOW_GRAPH_JOIN);
|
||||
try {
|
||||
rsm.finishAllGraphUpdates();
|
||||
} finally {
|
||||
if (Tracy.ENABLED) Tracy.endZone();
|
||||
}
|
||||
|
||||
ACTIVE = true;
|
||||
CURRENT_TARGETS = this.targets;
|
||||
// ACTIVE routes clipRenderersByFrustum into the shadow path; a leak would send every main pass there.
|
||||
try {
|
||||
|
||||
// NB: We store the previous player buffers in order to be able to allow mods rendering entities in the shadow pass (Flywheel) to use the shadow buffers instead.
|
||||
// TODO: Render
|
||||
@@ -875,25 +880,27 @@ public class ShadowRenderer {
|
||||
visibleTileEntities.clear();
|
||||
globalTileEntities.clear();
|
||||
|
||||
final boolean newShadowLists = shadowSearchPending;
|
||||
shadowSearchPending = false;
|
||||
|
||||
final float currentShadowAngle = getShadowAngle();
|
||||
if (ShadowGraphGate.shouldMarkDirty(lastGraphShadowAngle, currentShadowAngle, shadowAngleDelta())) {
|
||||
CeleritasWorldRenderer.getInstance().getRenderSectionManager().markShadowGraphDirty();
|
||||
rsm.markShadowGraphDirty();
|
||||
lastGraphShadowAngle = currentShadowAngle;
|
||||
}
|
||||
|
||||
final boolean deferActive = shouldRenderTerrain;
|
||||
final long frameNanos = System.nanoTime();
|
||||
final boolean consumePreSubmit = preSubmitActive;
|
||||
preSubmitActive = false;
|
||||
final boolean shadowGraphDirty = rsm.isShadowGraphDirty();
|
||||
|
||||
final boolean relayTerrain = shadowTerrainAlwaysRelays()
|
||||
|| !targets.isTerrainSnapshotValid()
|
||||
|| consumePreSubmit
|
||||
|| CeleritasWorldRenderer.getInstance().getRenderSectionManager().isShadowGraphDirty()
|
||||
|| newShadowLists
|
||||
|| shadowGraphDirty
|
||||
|| frameNanos - lastRelayNanos >= SHADOW_RELAY_MAX_AGE_NANOS;
|
||||
if (relayTerrain) {
|
||||
|
||||
relayShadowAngle = consumePreSubmit && !CeleritasWorldRenderer.getInstance().getRenderSectionManager().isShadowGraphDirty() ? preSubmittedShadowAngle : currentShadowAngle;
|
||||
// New lists draw at the angle they were searched at, unless the gate already wants a newer search.
|
||||
relayShadowAngle = newShadowLists && !shadowGraphDirty ? searchedShadowAngle : currentShadowAngle;
|
||||
}
|
||||
activeShadowAngle = relayShadowAngle;
|
||||
SHADOW_TERRAIN_RELAID = relayTerrain;
|
||||
@@ -934,11 +941,9 @@ public class ShadowRenderer {
|
||||
|
||||
profiler.endSection();
|
||||
|
||||
// Save the main camera viewport before shadow pass overwrites it.
|
||||
// clipRenderersByFrustum -> setupTerrain sets currentViewport to the shadow frustum.
|
||||
// If the shadow pass throws or the main setupTerrain doesn't run after us, the shadow
|
||||
// viewport would persist and corrupt entity culling in the main pass.
|
||||
final Viewport savedViewport = CeleritasWorldRenderer.getInstance().getCurrentViewport();
|
||||
// clipRenderersByFrustum -> setupShadowTerrain sets currentViewport to the shadow frustum; restore the last
|
||||
// terrain viewport so entity culling never sees the shadow one if the main setupTerrain doesn't run.
|
||||
final Viewport savedViewport = CeleritasWorldRenderer.getInstance().getLastViewport();
|
||||
|
||||
// Pair setupGlState / restoreGlState with try-finally so any throw between them
|
||||
// (translucent terrain, entity rendering, mipmaps, etc.) still unwinds the
|
||||
@@ -947,7 +952,13 @@ public class ShadowRenderer {
|
||||
boolean setupGlStateRan = false;
|
||||
try {
|
||||
// Execute the vanilla terrain setup / culling routines using our shadow frustum.
|
||||
final int shadowSearchesBefore = rsm.getShadowSearchSubmissions();
|
||||
mc.renderGlobal.clipRenderersByFrustum(terrainFrustumHolder.getFrustum(), playerCamera.getPartialTicks());
|
||||
if (rsm.getShadowSearchSubmissions() != shadowSearchesBefore) {
|
||||
shadowSearchPending = true;
|
||||
// createShadowFrustum built the search's light vector from the current light
|
||||
searchedShadowAngle = currentShadowAngle;
|
||||
}
|
||||
|
||||
// Don't forget to increment the frame counter! This variable is arbitrary and only used in terrain setup,
|
||||
// and if it's not incremented, the vanilla culling code will get confused and think that it's already seen
|
||||
@@ -983,9 +994,9 @@ public class ShadowRenderer {
|
||||
renderShadowEntitiesAndPlayer(levelRenderer, entityShadowFrustum, modelView, entityX, entityY, entityZ, tickDelta);
|
||||
}
|
||||
|
||||
if (shouldRenderBlockEntities) {
|
||||
if (shouldRenderBlockEntities || shouldRenderLightBlockEntities) {
|
||||
try (GLDebug.Scope s = GLDebug.scope("shadow:block_entities")) {
|
||||
renderTileEntities(null, modelView, entityX, entityY, entityZ, tickDelta, entityFrustumConstrained);
|
||||
renderTileEntities(null, modelView, entityX, entityY, entityZ, tickDelta, entityFrustumConstrained, !shouldRenderBlockEntities);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1036,9 +1047,10 @@ public class ShadowRenderer {
|
||||
profiler.endStartSection("iris_shadowcomp");
|
||||
|
||||
if (compositeRenderer != null) compositeRenderer.renderAll();
|
||||
|
||||
ACTIVE = false;
|
||||
CURRENT_TARGETS = null;
|
||||
} finally {
|
||||
ACTIVE = false;
|
||||
CURRENT_TARGETS = null;
|
||||
}
|
||||
profiler.endSection();
|
||||
profiler.endStartSection("culling");
|
||||
}
|
||||
@@ -1062,7 +1074,7 @@ public class ShadowRenderer {
|
||||
}
|
||||
|
||||
private String getTileEntitiesDebugString() {
|
||||
return shouldRenderBlockEntities ? (renderedShadowTileEntities + "/" + Minecraft.getMinecraft().theWorld.loadedTileEntityList.size()) : "disabled by pack";
|
||||
return (shouldRenderBlockEntities || shouldRenderLightBlockEntities) ? (renderedShadowTileEntities + "/" + Minecraft.getMinecraft().theWorld.loadedTileEntityList.size()) : "disabled by pack";
|
||||
}
|
||||
|
||||
private static class MipmapPass {
|
||||
|
||||
@@ -22,7 +22,6 @@ import java.util.OptionalInt;
|
||||
public interface WorldRenderingPipeline {
|
||||
void beginLevelRendering();
|
||||
void renderShadows(EntityRenderer levelRenderer, Camera camera);
|
||||
default void preSubmitShadowGraph(int frame) {}
|
||||
void addDebugText(List<String> messages);
|
||||
OptionalInt getForcedShadowRenderDistanceChunksForDisplay();
|
||||
|
||||
|
||||
@@ -611,16 +611,6 @@ public final class RwImageStoreExtractor {
|
||||
final Set<String> present = new HashSet<>();
|
||||
for (AttributeSlot slot : attrs) present.add(slot.name());
|
||||
|
||||
out.append("#ifdef USE_VERTEX_COMPRESSION\n");
|
||||
if (present.contains("a_PosId")) {
|
||||
out.append(" _vert_position = vec3(a_PosId.xyz) * VERT_POS_SCALE + VERT_POS_OFFSET;\n");
|
||||
out.append(" _draw_id = (a_PosId.w >> 8u) & 0xFFu;\n");
|
||||
out.append(" _material_params = (a_PosId.w >> 0u) & 0xFFu;\n");
|
||||
}
|
||||
if (present.contains("a_TexCoord")) out.append(" _vert_tex_diffuse_coord = a_TexCoord * VERT_TEX_SCALE;\n");
|
||||
if (present.contains("a_LightCoord")) out.append(" _vert_tex_light_coord = a_LightCoord;\n");
|
||||
if (present.contains("a_Color")) out.append(" _vert_color = a_Color;\n");
|
||||
out.append("#else\n");
|
||||
if (present.contains("a_PosId")) out.append(" _vert_position = a_PosId;\n");
|
||||
if (present.contains("a_TexCoord")) out.append(" _vert_tex_diffuse_coord = a_TexCoord;\n");
|
||||
if (present.contains("a_Color")) out.append(" _vert_color = a_Color;\n");
|
||||
@@ -630,7 +620,6 @@ public final class RwImageStoreExtractor {
|
||||
out.append(" _draw_id = (_vg_draw_params >> 8) & 0xFFu;\n");
|
||||
out.append(" _vert_tex_light_coord = ivec2((uvec2((a_LightCoord >> 16) & 0xFFFFu) >> uvec2(0, 8)) & uvec2(0xFFu));\n");
|
||||
}
|
||||
out.append("#endif\n");
|
||||
}
|
||||
|
||||
private static void emitDispatchMain(StringBuilder out, RwExtractMode mode, List<AttributeSlot> attrs) {
|
||||
@@ -788,11 +777,6 @@ public final class RwImageStoreExtractor {
|
||||
addAttr(m, new AttributeSlot("a_LightCoord", "uint", 24,
|
||||
"_vg_vbuf.data[base + 6u]"));
|
||||
|
||||
addAttr(m, new AttributeSlot("a_PosId", "uvec4", 0,
|
||||
"uvec4(0u, 0u, 0u, 0u)", false));
|
||||
addAttr(m, new AttributeSlot("a_LightCoord", "ivec2", 24,
|
||||
"ivec2(0, 0)", false));
|
||||
|
||||
final LinkedHashMap<String, Map<String, AttributeSlot>> immutable = new LinkedHashMap<>();
|
||||
for (var e : m.entrySet()) immutable.put(e.getKey(), Map.copyOf(e.getValue()));
|
||||
return Map.copyOf(immutable);
|
||||
|
||||
@@ -29,6 +29,7 @@ public class PackShadowDirectives {
|
||||
private final boolean shouldRenderEntities;
|
||||
private final boolean shouldRenderPlayer;
|
||||
private final boolean shouldRenderBlockEntities;
|
||||
private final boolean shouldRenderLightBlockEntities;
|
||||
@Getter private final ShadowCullState cullingState;
|
||||
private final OptionalBoolean dhShadowEnabled;
|
||||
private float nearPlane, farPlane;
|
||||
@@ -83,6 +84,7 @@ public class PackShadowDirectives {
|
||||
this.shouldRenderEntities = properties.getShadowEntities().orElse(true);
|
||||
this.shouldRenderPlayer = properties.getShadowPlayer().orElse(false);
|
||||
this.shouldRenderBlockEntities = properties.getShadowBlockEntities().orElse(true);
|
||||
this.shouldRenderLightBlockEntities = properties.getShadowLightBlockEntities().orElse(false);
|
||||
this.cullingState = properties.getShadowCulling();
|
||||
this.shadowEnabled = properties.getShadowEnabled();
|
||||
this.dhShadowEnabled = properties.getDhShadowEnabled();
|
||||
@@ -114,6 +116,7 @@ public class PackShadowDirectives {
|
||||
this.shouldRenderEntities = shadowDirectives.shouldRenderEntities;
|
||||
this.shouldRenderPlayer = shadowDirectives.shouldRenderPlayer;
|
||||
this.shouldRenderBlockEntities = shadowDirectives.shouldRenderBlockEntities;
|
||||
this.shouldRenderLightBlockEntities = shadowDirectives.shouldRenderLightBlockEntities;
|
||||
this.cullingState = shadowDirectives.cullingState;
|
||||
this.depthSamplingSettings = shadowDirectives.depthSamplingSettings;
|
||||
this.colorSamplingSettings = shadowDirectives.colorSamplingSettings;
|
||||
@@ -185,6 +188,10 @@ public class PackShadowDirectives {
|
||||
return shouldRenderBlockEntities;
|
||||
}
|
||||
|
||||
public boolean shouldRenderLightBlockEntities() {
|
||||
return shouldRenderLightBlockEntities;
|
||||
}
|
||||
|
||||
public OptionalBoolean isShadowEnabled() {
|
||||
return shadowEnabled;
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user