mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-16 02:04:59 +00:00
+4








992644c20f
* ThreadedTessellator -> RenderBlocks instance Tessellator * Plus a CME workaround until I can figure out why it's happening * One inject with multiple methods instead of two injects * Add AF's Tessellator#reset mixin Fixes screen flashing when chunks are being built * Thread Saftey * Make each tesselator use its own ByteBuffer * Don't make RecyclingList a static variable 🤦 * Add some additions via ITessellatorInstance * Stop using builtin updateRenderers * Remove a few unused things in MixinTessellator * Remove useless casting due to implementing the interface * Overwrite some more rendering methods to ensure they're not used * Implement IBlockAccess on WorldSlice * Currently just proxies to the World... need to get it to use the local cache * Make WorldSlice use its copied values instead of using the world * block, meta, and light. Still need TODO biome * Finish making WorldSlice thread safe * Remove last unsafe this.world accesses * Copy biomeData * Implement getTileEntity(), and getBiomeGenForCoords() * Remove unused 1.16+ classes - Biome, Colorizer, and ColorBlender related * Cache worldHeight instead of asking the provider every time * Debug Screen updates * Disable Culling for now (until it works) * Tessellator Updates * Use one instance on the main thread, and individual instances on every other thread * Prevent draw() and buffer.reset() on non singleton instance * Misc cleanup, maybe better growBuffer? * Fixing splash screen and GUI issues by excluding SplashProgress from GLStateManager transformer * Update docs * Fixing a one line in SodiumWorldRenderer that allows the game setting for the distance at which entities will render. Hope it's not too bad mitch :) * TileEntites now render * Less silly transparency * Removing clamp implementation because I missed the one in mathhelper * Initial sodium entity smooth lighting * Fix entity smooth lighting * Fix lerp uses and use render layers properly (#17) * Remove some uses of blockstate + patch FluidState * Fix lerp * Enable Sodium fluid rendering * Update FluidRenderer.java * Rewind buffers when copying * Fix multidraw * Force cutout on all non-translucent blocks * Let vanilla handle render pass state * Rewrite render layer check to use Forge 1.7 hook * Fix skylight handling * Fix flickering * Clone TEs correctly * Fixing entityDistMulti (I think) * Fix TEs rendering on the wrong pass * Buff max render distance to 32 Pretty useless since the integrated server stalls instantly, but our renderer supports it * Fix fog * Fix render distance changes being ignored * Implement entity culling * Block face culling * Re-enable occlusion culling * Fix x/z coordinate mixup when indexing biome arrays Partially fixes wrong biome colors, but at chunk edges it's still wrong because neighboring chunks aren't accessed * Make a copy of biome data The old code seemed to work fine but this should be safer * Make CompatMemoryUtil#memReallocDirect preserve buffer position LWJGL3's MemoryUtil#memRealloc does this, see its javadoc. Fixes screen flashing and this error getting printed when indirect buffer grows: GL_INVALID_OPERATION error generated. Bound draw indirect buffer is not large enough. * Use biome data of neighboring chunk sections Fixes wrong colors at chunk edges * Re-enable fog culling * Tile entity culling * Remove some unneeded Sodium code * Massive code cleanup * Avoids errors when usin lwjglxdebug * Bump hodgepodge dep * Add AngelicaConfig * Add Mixin to disable MC's builtin checkGLError * Add configs for iris/sodium * Iris work * Move some StateNotifiers to GLStateManager * Remove some redundant mixins based on sodium/angelica work and rendering state captures * Add Iris DebugScreenHandler * rm archaicfix's occlusion renderer and threaded updates * Implemented Sodium's GUI and a couple of setting fixes (#20) * Ported Sodium's GUI * Correct AO * Fixed Vignette * Re-enable DirectMemoryAccess * Adds some code from lwjgl3 in CompatMemoryUtil.java * Re-add *Unsafe classes * Remove MixinWorldRenderer * Add NEID (mixin pr) support * Only shadow runtime module of antlr4 Reduces jar size by 11 mb * Update NotFine * Make LongHashMap actually perform like a hash map * Options GUI Fixes and some option implementations (#22) * Correct useNoErrorGLContext option * Added translucency sorting option * Implemented Particle Culling gives real fps boost, however, it's not as big as i thought * Begin implementing animateOnlyVisibleTextures * Correct Donation page opening * Fixed Shift + P Now it uses NotFine's GUI, but it think that NotFine's GUI should be rewrited for using other config options * Correct URL's for Linux * second code cleanup in particle culling * Fix incorrect TE map population * Add optional assertMainThread behind `-Dangelica.assertMainThread=true` * Add back air optimization, but only apply to vanilla air * Implement more options (#23) * Combine free regions in GlBufferArena * Clear global block entity list when initializing renderer * AF, CompileStubs, and SplashProgress Remove most of ArchaicFix * Move a few mixins over to angelica * Disable if org.lwjgl.util.Debug is set * Only enable Iris/lwjgl debug callbacks if org.lwjgl.util.Debug is set * Rewrite Tessellator hacks - now using a ThreadLocal instead of only patching RenderBlocks * Reenable AF mixins, switch to cached debug var, disable incompatible mixins * Remove AF deps and a late mixin that was missed * Add Iris Sodium Compat impl * Fix Sodium GLProgram to use ResourceLocation instead of Identifier * Start applying Iris -> Sodium Mixins * Make NotFine menu open if holding shift * Fixed Tessellators in production env * Finish Sodium Fluid Renderer (#24) * Init and pass Sodium LightPipelines * Remove registry lookup and refactor WorldUtil * Hook up lighting pipeline * Patch fluid velocity * It's alive! Sodium Fluid Renderer is alive! * Fix face culling not taking third person camera offset into account * rewrite ACTEntityRenderer to stop transforming ALL the classes * use ClassConstantPoolParser in TessellatorTransformer to speed up search for Tessellator references * use ClassConstantPoolParser in GLStateManagerTransformer to speed up search for class references * rewrite GLStateManagerTransformer and TessellatorTransformer * merge GLStateManagerTransfor and TessellatorTransformer into one Transformer * Fixed smooth lighting rendering * Iris block_id Mixins & BlockStateIdMap initial impl for 1.7.10 * Fix running with lwjgl debug flag & Cleanup old ShadersMod transformers * Initialize GLStateManager via Mixins instead of all in the static block * Clean up chunk load/unload tracking, fix chunks rendering without neighbors sometimes * Fix occlusion culler not re-running after important uploads Backport of https://github.com/CaffeineMC/sodium-fabric/pull/755 * Add chunks to queues without going through occlusion culler Partially reverts the previous chunk tracking commit, because that logic will reintroduce https://github.com/CaffeineMC/sodium-fabric/issues/605 As long as we only rebuild with neighbors present, we shouldn't see the visual seams * Extremely primitive synchronization approach for ISBRH * Use factory for Spdium menu createElement outputs This will allow NotFine to use Sodium menu elements and vice versa in a future commit. * Splash Screen Compat * Separate remaining NamedState enums * NotFine but it loads Sodium pages * Hook up NotFine optimizations * Hook up some NotFine features * copy over hud caching code from hodgepodge * backport glstatemanager mixin * Track thread that currently owns the GL Context in addition to the main thread. * First pass over FontRenderer, 1300->1400 FPS on my GPU when showing F3 Done: - A batching vertex buffer builder for font output - Reduction in drawcalls from 1-3 per character to 1 per font atlas switch - Mixin to draw the entire F3 screen in one batch, instead of separate batches per line TODO: - Switch drawing to a VBO - Cache string meshes across frames - Cache string width calculations used for layouts - Multidraw to reduce draw calls even further * Add JVM flag to bypass GL state caching * Push/Pop Attrib Hacks -- to be evolved later * Fix FontRenderer+SplashScreen combo * HUDCaching tweaks * Add license * Jabba Compat, and reset tesselator state even if the chunk render thread blows up * Initial Xaero's World Map + Minimap Support * Disable Fastcraft & Optifine if present * Iris Progress * Wire up more Iris mixins, informing pipeline stages. Still not rendering anything visible. * Don't try to transform the server * Avoid running biome generator on client in singleplayer * Call world biome retrieval methods instead of copying array directly (#25) * Shaders now do something! * Shadow Pass work * First shadow pass renders; however it moves all around when moving the camera... * Second shadow pass not running because it makes everything very very dark instead of just rendering translucents * Actually use the ShadowRenderer Model View when running the shadow pass... * Enable Sodium SmoothLightPipeline & Iris useSeparateAo * Avoid repeatedly copying biome data on each Y level (#27) * Celestial Rotation fixes * Water progress * Uniforms audit * Lightmap workaround * PBR compiling, stuck on Normal and Specular textures being added in * Shaderpack selection "works"; ShaderOptions TODO * Hud caching angelica (#28) * Potential hud-caching fix * Shader Options almost working ** Clicking on everything doesn't yet work, and the visuals are slightly off * Entity shadows seem to be working * Move glint fix to Mixin * Rework mouse handling for ShaderPackConfig * Stop centering shader options vertically * Angelica pbr (#31) * Only use Sodium light pipeline if useSeparateAo is on Sodium pipeline is still very buggy, so isolate it to Iris-only for now * Fix region sorting for translucency * Open Shaderpack now works on Linux * RM Shadersmod * Initial iris scrollbar clicking * Punt unsupported ISBRHs to the main thread * Delete the ISBRH lock, shouldn't be needed anymore * Render GT blocks on main thread * Require CCC 1.2.0+ * Depend on CCC 1.2 * Fix TESRs not being tracked for blocks rendered on main thread * Cut down number of runtime dependencies, enable CoreTweaks in dev by default * Add modern F3 background * Pull over some hodgepodge mixins --------- Co-authored-by: makamys <[email protected]> Co-authored-by: embeddedt <[email protected]> Co-authored-by: rjnasers <[email protected]> Co-authored-by: ah-OOG-ah <[email protected]> Co-authored-by: Ryan Nasers <[email protected]> Co-authored-by: Rad <[email protected]> Co-authored-by: Bogdan <[email protected]> Co-authored-by: Caedis <[email protected]> Co-authored-by: jss2a98aj <[email protected]> Co-authored-by: Alexdoru <[email protected]> Co-authored-by: Raven Szewczyk <[email protected]> Co-authored-by: mist475 <[email protected]> Co-authored-by: Ryan Nasers <[email protected]>
326 lines
11 KiB
Java
326 lines
11 KiB
Java
package net.coderbot.iris.rendertarget;
|
|
|
|
import com.google.common.collect.ImmutableSet;
|
|
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
|
import lombok.Getter;
|
|
import net.coderbot.iris.gl.IrisRenderSystem;
|
|
import net.coderbot.iris.gl.framebuffer.GlFramebuffer;
|
|
import net.coderbot.iris.gl.texture.DepthBufferFormat;
|
|
import net.coderbot.iris.gl.texture.DepthCopyStrategy;
|
|
import net.coderbot.iris.shaderpack.PackDirectives;
|
|
import net.coderbot.iris.shaderpack.PackRenderTargetDirectives;
|
|
import org.joml.Vector2i;
|
|
import org.lwjgl.opengl.GL11;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
public class RenderTargets {
|
|
private final RenderTarget[] targets;
|
|
private int currentDepthTexture;
|
|
private DepthBufferFormat currentDepthFormat;
|
|
|
|
@Getter
|
|
private final DepthTexture noTranslucents;
|
|
private final DepthTexture noHand;
|
|
private final GlFramebuffer depthSourceFb;
|
|
private final GlFramebuffer noTranslucentsDestFb;
|
|
private final GlFramebuffer noHandDestFb;
|
|
private DepthCopyStrategy copyStrategy;
|
|
|
|
private final List<GlFramebuffer> ownedFramebuffers;
|
|
|
|
private int cachedWidth;
|
|
private int cachedHeight;
|
|
@Getter
|
|
private boolean fullClearRequired;
|
|
private boolean translucentDepthDirty;
|
|
private boolean handDepthDirty;
|
|
|
|
private int cachedDepthBufferVersion;
|
|
|
|
public RenderTargets(int width, int height, int depthTexture, int depthBufferVersion, DepthBufferFormat depthFormat, Map<Integer, PackRenderTargetDirectives.RenderTargetSettings> renderTargets, PackDirectives packDirectives) {
|
|
targets = new RenderTarget[renderTargets.size()];
|
|
|
|
renderTargets.forEach((index, settings) -> {
|
|
// TODO: Handle mipmapping?
|
|
Vector2i dimensions = packDirectives.getTextureScaleOverride(index, width, height);
|
|
targets[index] = RenderTarget.builder().setDimensions(dimensions.x, dimensions.y)
|
|
.setInternalFormat(settings.getInternalFormat())
|
|
.setPixelFormat(settings.getInternalFormat().getPixelFormat()).build();
|
|
});
|
|
this.currentDepthTexture = depthTexture;
|
|
this.currentDepthFormat = depthFormat;
|
|
this.copyStrategy = DepthCopyStrategy.fastest(currentDepthFormat.isCombinedStencil());
|
|
|
|
this.cachedWidth = width;
|
|
this.cachedHeight = height;
|
|
this.cachedDepthBufferVersion = depthBufferVersion;
|
|
|
|
this.ownedFramebuffers = new ArrayList<>();
|
|
|
|
// NB: Make sure all buffers are cleared so that they don't contain undefined
|
|
// data. Otherwise very weird things can happen.
|
|
fullClearRequired = true;
|
|
|
|
this.depthSourceFb = createFramebufferWritingToMain(new int[] {0});
|
|
|
|
this.noTranslucents = new DepthTexture(width, height, currentDepthFormat);
|
|
this.noHand = new DepthTexture(width, height, currentDepthFormat);
|
|
|
|
this.noTranslucentsDestFb = createFramebufferWritingToMain(new int[] {0});
|
|
this.noTranslucentsDestFb.addDepthAttachment(this.noTranslucents.getTextureId());
|
|
|
|
this.noHandDestFb = createFramebufferWritingToMain(new int[] {0});
|
|
this.noHandDestFb.addDepthAttachment(this.noHand.getTextureId());
|
|
|
|
this.translucentDepthDirty = true;
|
|
this.handDepthDirty = true;
|
|
}
|
|
|
|
public void destroy() {
|
|
for (GlFramebuffer owned : ownedFramebuffers) {
|
|
owned.destroy();
|
|
}
|
|
|
|
for (RenderTarget target : targets) {
|
|
target.destroy();
|
|
}
|
|
|
|
noTranslucents.destroy();
|
|
noHand.destroy();
|
|
}
|
|
|
|
public int getRenderTargetCount() {
|
|
return targets.length;
|
|
}
|
|
|
|
public RenderTarget get(int index) {
|
|
return targets[index];
|
|
}
|
|
|
|
public int getDepthTexture() {
|
|
return currentDepthTexture;
|
|
}
|
|
|
|
public DepthTexture getDepthTextureNoTranslucents() {
|
|
return noTranslucents;
|
|
}
|
|
|
|
public DepthTexture getDepthTextureNoHand() {
|
|
return noHand;
|
|
}
|
|
|
|
public boolean resizeIfNeeded(int newDepthBufferVersion, int newDepthTextureId, int newWidth, int newHeight, DepthBufferFormat newDepthFormat, PackDirectives packDirectives) {
|
|
boolean recreateDepth = false;
|
|
if (cachedDepthBufferVersion != newDepthBufferVersion) {
|
|
recreateDepth = true;
|
|
currentDepthTexture = newDepthTextureId;
|
|
cachedDepthBufferVersion = newDepthBufferVersion;
|
|
}
|
|
|
|
boolean sizeChanged = newWidth != cachedWidth || newHeight != cachedHeight;
|
|
boolean depthFormatChanged = newDepthFormat != currentDepthFormat;
|
|
|
|
if (depthFormatChanged) {
|
|
currentDepthFormat = newDepthFormat;
|
|
// Might need a new copy strategy
|
|
copyStrategy = DepthCopyStrategy.fastest(currentDepthFormat.isCombinedStencil());
|
|
}
|
|
|
|
if (recreateDepth) {
|
|
// Re-attach the depth textures with the new depth texture ID, since Minecraft re-creates
|
|
// the depth texture when resizing its render targets.
|
|
//
|
|
// I'm not sure if our framebuffers holding on to the old depth texture between frames
|
|
// could be a concern, in the case of resizing and similar. I think it should work
|
|
// based on what I've seen of the spec, though - it seems like deleting a texture
|
|
// automatically detaches it from its framebuffers.
|
|
for (GlFramebuffer framebuffer : ownedFramebuffers) {
|
|
if (framebuffer == noHandDestFb || framebuffer == noTranslucentsDestFb) {
|
|
// NB: Do not change the depth attachment of these framebuffers
|
|
// as it is intentionally different
|
|
continue;
|
|
}
|
|
|
|
if (framebuffer.hasDepthAttachment()) {
|
|
framebuffer.addDepthAttachment(newDepthTextureId);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (depthFormatChanged || sizeChanged) {
|
|
// Reallocate depth buffers
|
|
noTranslucents.resize(newWidth, newHeight, newDepthFormat);
|
|
noHand.resize(newWidth, newHeight, newDepthFormat);
|
|
this.translucentDepthDirty = true;
|
|
this.handDepthDirty = true;
|
|
}
|
|
|
|
if (sizeChanged) {
|
|
cachedWidth = newWidth;
|
|
cachedHeight = newHeight;
|
|
|
|
for (int i = 0; i < targets.length; i++) {
|
|
targets[i].resize(packDirectives.getTextureScaleOverride(i, newWidth, newHeight));
|
|
}
|
|
|
|
fullClearRequired = true;
|
|
}
|
|
|
|
return sizeChanged;
|
|
}
|
|
|
|
public void copyPreTranslucentDepth() {
|
|
if (translucentDepthDirty) {
|
|
translucentDepthDirty = false;
|
|
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, noTranslucents.getTextureId());
|
|
depthSourceFb.bindAsReadBuffer();
|
|
IrisRenderSystem.copyTexImage2D(GL11.GL_TEXTURE_2D, 0, currentDepthFormat.getGlInternalFormat(), 0, 0, cachedWidth, cachedHeight, 0);
|
|
} else {
|
|
copyStrategy.copy(depthSourceFb, getDepthTexture(), noTranslucentsDestFb, noTranslucents.getTextureId(), getCurrentWidth(), getCurrentHeight());
|
|
}
|
|
}
|
|
|
|
public void copyPreHandDepth() {
|
|
if (handDepthDirty) {
|
|
handDepthDirty = false;
|
|
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, noHand.getTextureId());
|
|
depthSourceFb.bindAsReadBuffer();
|
|
IrisRenderSystem.copyTexImage2D(GL11.GL_TEXTURE_2D, 0, currentDepthFormat.getGlInternalFormat(), 0, 0, cachedWidth, cachedHeight, 0);
|
|
} else {
|
|
copyStrategy.copy(depthSourceFb, getDepthTexture(), noHandDestFb, noHand.getTextureId(), getCurrentWidth(), getCurrentHeight());
|
|
}
|
|
}
|
|
|
|
public void onFullClear() {
|
|
fullClearRequired = false;
|
|
}
|
|
|
|
public GlFramebuffer createFramebufferWritingToMain(int[] drawBuffers) {
|
|
return createFullFramebuffer(false, drawBuffers);
|
|
}
|
|
|
|
public GlFramebuffer createFramebufferWritingToAlt(int[] drawBuffers) {
|
|
return createFullFramebuffer(true, drawBuffers);
|
|
}
|
|
|
|
public GlFramebuffer createClearFramebuffer(boolean alt, int[] clearBuffers) {
|
|
ImmutableSet<Integer> stageWritesToMain = ImmutableSet.of();
|
|
|
|
if (!alt) {
|
|
stageWritesToMain = invert(ImmutableSet.of(), clearBuffers);
|
|
}
|
|
|
|
return createColorFramebuffer(stageWritesToMain, clearBuffers);
|
|
}
|
|
|
|
private ImmutableSet<Integer> invert(ImmutableSet<Integer> base, int[] relevant) {
|
|
ImmutableSet.Builder<Integer> inverted = ImmutableSet.builder();
|
|
|
|
for (int i : relevant) {
|
|
if (!base.contains(i)) {
|
|
inverted.add(i);
|
|
}
|
|
}
|
|
|
|
return inverted.build();
|
|
}
|
|
|
|
private GlFramebuffer createEmptyFramebuffer() {
|
|
GlFramebuffer framebuffer = new GlFramebuffer();
|
|
ownedFramebuffers.add(framebuffer);
|
|
|
|
framebuffer.addDepthAttachment(currentDepthTexture);
|
|
|
|
// NB: Before OpenGL 3.0, all framebuffers are required to have a color attachment no matter what.
|
|
framebuffer.addColorAttachment(0, get(0).getMainTexture());
|
|
framebuffer.noDrawBuffers();
|
|
|
|
return framebuffer;
|
|
}
|
|
|
|
public GlFramebuffer createGbufferFramebuffer(ImmutableSet<Integer> stageWritesToAlt, int[] drawBuffers) {
|
|
if (drawBuffers.length == 0) {
|
|
return createEmptyFramebuffer();
|
|
}
|
|
|
|
ImmutableSet<Integer> stageWritesToMain = invert(stageWritesToAlt, drawBuffers);
|
|
GlFramebuffer framebuffer = createColorFramebuffer(stageWritesToMain, drawBuffers);
|
|
framebuffer.addDepthAttachment(currentDepthTexture);
|
|
|
|
return framebuffer;
|
|
}
|
|
|
|
private GlFramebuffer createFullFramebuffer(boolean clearsAlt, int[] drawBuffers) {
|
|
if (drawBuffers.length == 0) {
|
|
return createEmptyFramebuffer();
|
|
}
|
|
|
|
ImmutableSet<Integer> stageWritesToMain = ImmutableSet.of();
|
|
|
|
if (!clearsAlt) {
|
|
stageWritesToMain = invert(ImmutableSet.of(), drawBuffers);
|
|
}
|
|
|
|
return createColorFramebufferWithDepth(stageWritesToMain, drawBuffers);
|
|
}
|
|
|
|
public GlFramebuffer createColorFramebufferWithDepth(ImmutableSet<Integer> stageWritesToMain, int[] drawBuffers) {
|
|
final GlFramebuffer framebuffer = createColorFramebuffer(stageWritesToMain, drawBuffers);
|
|
framebuffer.addDepthAttachment(currentDepthTexture);
|
|
|
|
return framebuffer;
|
|
}
|
|
|
|
public GlFramebuffer createColorFramebuffer(ImmutableSet<Integer> stageWritesToMain, int[] drawBuffers) {
|
|
if (drawBuffers.length == 0) {
|
|
throw new IllegalArgumentException("Framebuffer must have at least one color buffer");
|
|
}
|
|
|
|
final GlFramebuffer framebuffer = new GlFramebuffer();
|
|
ownedFramebuffers.add(framebuffer);
|
|
|
|
final int[] actualDrawBuffers = new int[drawBuffers.length];
|
|
|
|
for (int i = 0; i < drawBuffers.length; i++) {
|
|
actualDrawBuffers[i] = i;
|
|
|
|
if (drawBuffers[i] >= getRenderTargetCount()) {
|
|
// TODO: This causes resource leaks, also we should really verify this in the shaderpack parser...
|
|
throw new IllegalStateException("Render target with index " + drawBuffers[i] + " is not supported, only "
|
|
+ getRenderTargetCount() + " render targets are supported.");
|
|
}
|
|
|
|
final RenderTarget target = this.get(drawBuffers[i]);
|
|
|
|
final int textureId = stageWritesToMain.contains(drawBuffers[i]) ? target.getMainTexture() : target.getAltTexture();
|
|
|
|
framebuffer.addColorAttachment(i, textureId);
|
|
}
|
|
|
|
framebuffer.drawBuffers(actualDrawBuffers);
|
|
framebuffer.readBuffer(0);
|
|
|
|
if (!framebuffer.isComplete()) {
|
|
throw new IllegalStateException("Unexpected error while creating framebuffer");
|
|
}
|
|
|
|
return framebuffer;
|
|
}
|
|
|
|
public void destroyFramebuffer(GlFramebuffer framebuffer) {
|
|
framebuffer.destroy();
|
|
ownedFramebuffers.remove(framebuffer);
|
|
}
|
|
|
|
public int getCurrentWidth() {
|
|
return cachedWidth;
|
|
}
|
|
|
|
public int getCurrentHeight() {
|
|
return cachedHeight;
|
|
}
|
|
}
|