Files
Angelica/src/main/java/net/coderbot/iris/rendertarget/RenderTargets.java
T
+4 992644c20f The Mergening (#13)
* 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]>
2023-12-24 21:49:28 -08:00

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;
}
}