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]>
This commit is contained in:
942 files changed
+65828 -8640

No files matched your search

@@ -0,0 +1,450 @@
package net.coderbot.iris.shaderpack;
import com.google.common.collect.ImmutableList;
import net.coderbot.iris.Iris;
import net.coderbot.iris.gl.texture.InternalTextureFormat;
import org.joml.Vector4f;
import java.util.Optional;
public class PackShadowDirectives {
// Bump this up if you want more shadow color buffers!
// This is currently set at 2 for ShadersMod / OptiFine parity but can theoretically be bumped up to 8.
// TODO: Make this configurable?
public static final int MAX_SHADOW_COLOR_BUFFERS = 2;
private final OptionalBoolean shadowEnabled;
private int resolution;
// Use a boxed form so we can use null to indicate that there is not an FOV specified.
private Float fov;
private float distance;
private float distanceRenderMul;
private float entityShadowDistanceMul;
private boolean explicitRenderDistance;
private float intervalSize;
private final boolean shouldRenderTerrain;
private final boolean shouldRenderTranslucent;
private final boolean shouldRenderEntities;
private final boolean shouldRenderPlayer;
private final boolean shouldRenderBlockEntities;
private final OptionalBoolean cullingState;
private final ImmutableList<DepthSamplingSettings> depthSamplingSettings;
private final ImmutableList<SamplingSettings> colorSamplingSettings;
public PackShadowDirectives(ShaderProperties properties) {
// By default, the shadow map has a resolution of 1024x1024. It's recommended to increase this for better
// quality.
this.resolution = 1024;
// By default, shadows do not use FOV, and instead use an orthographic projection controlled by shadowDistance
//
// If FOV is defined, shadows will use a perspective projection controlled by the FOV, and shadowDistance will
// be disregarded for the purposes of creating the projection matrix. However, it will still be used to figure
// out the render distance for shadows if shadowRenderDistanceMul is greater than zero.
this.fov = null;
// By default, an orthographic projection with a half plane of 160 meters is used, corresponding to a render
// distance of 10 chunks.
//
// It's recommended for shader pack authors to lower this setting to meet their needs in addition to setting
// shadowRenderDistanceMul to a nonzero value, since having a high shadow render distance will impact
// performance quite heavily on most systems.
this.distance = 160.0f;
// By default, shadows are not culled based on distance from the player. However, pack authors may
// enable this by setting shadowRenderDistanceMul to a nonzero value.
//
// Culling shadows based on the shadow matrices is often infeasible because shader packs frequently
// employ non-linear transformations that end up fitting more far away chunks into the shadow map,
// as well as giving higher detail to close up chunks.
//
// However, Iris does still does cull shadows whenever it can - but, it does so by analyzing
// whether or not shadows can possibly be cast into the player's view, instead of just checking
// the shadow matrices.
this.distanceRenderMul = -1.0f;
this.entityShadowDistanceMul = 1.0f;
this.explicitRenderDistance = false;
// By default, a shadow interval size of 2 meters is used. This means that the shadow camera will be snapped to
// a grid where each grid cell is 2 meters by 2 meters by 2 meters, and it will only move either when the sun /
// moon move, or when the player camera moves into a different grid cell.
this.intervalSize = 2.0f;
this.shouldRenderTerrain = properties.getShadowTerrain().orElse(true);
this.shouldRenderTranslucent = properties.getShadowTranslucent().orElse(true);
this.shouldRenderEntities = properties.getShadowEntities().orElse(true);
this.shouldRenderPlayer = properties.getShadowPlayer().orElse(false);
this.shouldRenderBlockEntities = properties.getShadowBlockEntities().orElse(true);
this.cullingState = properties.getShadowCulling();
this.shadowEnabled = properties.getShadowEnabled();
this.depthSamplingSettings = ImmutableList.of(new DepthSamplingSettings(), new DepthSamplingSettings());
ImmutableList.Builder<SamplingSettings> colorSamplingSettings = ImmutableList.builder();
for (int i = 0; i < MAX_SHADOW_COLOR_BUFFERS; i++) {
colorSamplingSettings.add(new SamplingSettings());
}
this.colorSamplingSettings = colorSamplingSettings.build();
}
public PackShadowDirectives(PackShadowDirectives shadowDirectives) {
this.resolution = shadowDirectives.resolution;
this.fov = shadowDirectives.fov;
this.distance = shadowDirectives.distance;
this.distanceRenderMul = shadowDirectives.distanceRenderMul;
this.entityShadowDistanceMul = shadowDirectives.entityShadowDistanceMul;
this.explicitRenderDistance = shadowDirectives.explicitRenderDistance;
this.intervalSize = shadowDirectives.intervalSize;
this.shouldRenderTerrain = shadowDirectives.shouldRenderTerrain;
this.shouldRenderTranslucent = shadowDirectives.shouldRenderTranslucent;
this.shouldRenderEntities = shadowDirectives.shouldRenderEntities;
this.shouldRenderPlayer = shadowDirectives.shouldRenderPlayer;
this.shouldRenderBlockEntities = shadowDirectives.shouldRenderBlockEntities;
this.cullingState = shadowDirectives.cullingState;
this.depthSamplingSettings = shadowDirectives.depthSamplingSettings;
this.colorSamplingSettings = shadowDirectives.colorSamplingSettings;
this.shadowEnabled = shadowDirectives.shadowEnabled;
}
public int getResolution() {
return resolution;
}
public Float getFov() {
return fov;
}
public float getDistance() {
return distance;
}
public float getDistanceRenderMul() {
return distanceRenderMul;
}
public float getEntityShadowDistanceMul() {
return entityShadowDistanceMul;
}
public boolean isDistanceRenderMulExplicit() {
return explicitRenderDistance;
}
public float getIntervalSize() {
return intervalSize;
}
public boolean shouldRenderTerrain() {
return shouldRenderTerrain;
}
public boolean shouldRenderTranslucent() {
return shouldRenderTranslucent;
}
public boolean shouldRenderEntities() {
return shouldRenderEntities;
}
public boolean shouldRenderPlayer() {
return shouldRenderPlayer;
}
public boolean shouldRenderBlockEntities() {
return shouldRenderBlockEntities;
}
public OptionalBoolean getCullingState() {
return cullingState;
}
public OptionalBoolean isShadowEnabled() {
return shadowEnabled;
}
public ImmutableList<DepthSamplingSettings> getDepthSamplingSettings() {
return depthSamplingSettings;
}
public ImmutableList<SamplingSettings> getColorSamplingSettings() {
return colorSamplingSettings;
}
public void acceptDirectives(DirectiveHolder directives) {
directives.acceptCommentIntDirective("SHADOWRES", resolution -> this.resolution = resolution);
directives.acceptConstIntDirective("shadowMapResolution", resolution -> this.resolution = resolution);
directives.acceptCommentFloatDirective("SHADOWFOV", fov -> this.fov = fov);
directives.acceptConstFloatDirective("shadowMapFov", fov -> this.fov = fov);
directives.acceptCommentFloatDirective("SHADOWHPL", distance -> this.distance = distance);
directives.acceptConstFloatDirective("shadowDistance", distance -> this.distance = distance);
directives.acceptConstFloatDirective("entityShadowDistanceMul", distance -> this.entityShadowDistanceMul = distance);
directives.acceptConstFloatDirective("shadowDistanceRenderMul", distanceRenderMul -> {
this.distanceRenderMul = distanceRenderMul;
this.explicitRenderDistance = true;
});
directives.acceptConstFloatDirective("shadowIntervalSize",
intervalSize -> this.intervalSize = intervalSize);
acceptHardwareFilteringSettings(directives, depthSamplingSettings);
acceptDepthMipmapSettings(directives, depthSamplingSettings);
acceptColorMipmapSettings(directives, colorSamplingSettings);
acceptDepthFilteringSettings(directives, depthSamplingSettings);
acceptColorFilteringSettings(directives, colorSamplingSettings);
acceptBufferDirectives(directives, colorSamplingSettings);
}
/**
* Handles shadowHardwareFiltering* directives
*/
private static void acceptHardwareFilteringSettings(DirectiveHolder directives, ImmutableList<DepthSamplingSettings> samplers) {
// Get the default base value for the hardware filtering setting
directives.acceptConstBooleanDirective("shadowHardwareFiltering", hardwareFiltering -> {
for (DepthSamplingSettings samplerSettings : samplers) {
samplerSettings.setHardwareFiltering(hardwareFiltering);
}
});
// Find any per-sampler overrides for the hardware filtering setting
for (int i = 0; i < samplers.size(); i++) {
String name = "shadowHardwareFiltering" + i;
directives.acceptConstBooleanDirective(name, samplers.get(i)::setHardwareFiltering);
}
}
private static void acceptDepthMipmapSettings(DirectiveHolder directives, ImmutableList<DepthSamplingSettings> samplers) {
// Get the default base value for the shadow depth mipmap setting
directives.acceptConstBooleanDirective("generateShadowMipmap", mipmap -> {
for (SamplingSettings samplerSettings : samplers) {
samplerSettings.setMipmap(mipmap);
}
});
// Find any per-sampler overrides for the shadow depth mipmap setting
// Legacy override option: shadowtexMipmap, an alias for shadowtex0Mipmap
if (samplers.size() >= 1) {
directives.acceptConstBooleanDirective("shadowtexMipmap", samplers.get(0)::setMipmap);
}
// Standard override option: shadowtex0Mipmap and shadowtex1Mipmap
for (int i = 0; i < samplers.size(); i++) {
String name = "shadowtex" + i + "Mipmap";
directives.acceptConstBooleanDirective(name, samplers.get(i)::setMipmap);
}
}
private static void acceptColorMipmapSettings(DirectiveHolder directives, ImmutableList<SamplingSettings> samplers) {
// Get the default base value for the shadow depth mipmap setting
directives.acceptConstBooleanDirective("generateShadowColorMipmap", mipmap -> {
for (SamplingSettings samplerSettings : samplers) {
samplerSettings.setMipmap(mipmap);
}
});
// Find any per-sampler overrides for the shadow depth mipmap setting
for (int i = 0; i < samplers.size(); i++) {
String name = "shadowcolor" + i + "Mipmap";
directives.acceptConstBooleanDirective(name, samplers.get(i)::setMipmap);
name = "shadowColor" + i + "Mipmap";
directives.acceptConstBooleanDirective(name, samplers.get(i)::setMipmap);
}
}
private static void acceptDepthFilteringSettings(DirectiveHolder directives, ImmutableList<DepthSamplingSettings> samplers) {
if (samplers.size() >= 1) {
directives.acceptConstBooleanDirective("shadowtexNearest", samplers.get(0)::setNearest);
}
for (int i = 0; i < samplers.size(); i++) {
String name = "shadowtex" + i + "Nearest";
directives.acceptConstBooleanDirective(name, samplers.get(i)::setNearest);
name = "shadow" + i + "MinMagNearest";
directives.acceptConstBooleanDirective(name, samplers.get(i)::setNearest);
}
}
private static void acceptColorFilteringSettings(DirectiveHolder directives, ImmutableList<SamplingSettings> samplers) {
for (int i = 0; i < samplers.size(); i++) {
String name = "shadowcolor" + i + "Nearest";
directives.acceptConstBooleanDirective(name, samplers.get(i)::setNearest);
name = "shadowColor" + i + "Nearest";
directives.acceptConstBooleanDirective(name, samplers.get(i)::setNearest);
name = "shadowColor" + i + "MinMagNearest";
directives.acceptConstBooleanDirective(name, samplers.get(i)::setNearest);
}
}
private void acceptBufferDirectives(DirectiveHolder directives, ImmutableList<SamplingSettings> settings) {
for (int i = 0; i < settings.size(); i++) {
String bufferName = "shadowcolor" + i;
int finalI = i;
directives.acceptConstStringDirective(bufferName + "Format", format -> {
Optional<InternalTextureFormat> internalFormat = InternalTextureFormat.fromString(format);
if (internalFormat.isPresent()) {
settings.get(finalI).setFormat(internalFormat.get());
} else {
Iris.logger.warn("Unrecognized internal texture format " + format + " specified for " + bufferName + "Format, ignoring.");
}
});
// TODO: Only for composite and deferred
directives.acceptConstBooleanDirective(bufferName + "Clear",
shouldClear -> settings.get(finalI).setClear(shouldClear));
// TODO: Only for composite, deferred, and final
// Note: This is still relevant even if shouldClear is false,
// since this will be the initial color of the buffer.
directives.acceptConstVec4Directive(bufferName + "ClearColor",
clearColor -> settings.get(finalI).setClearColor(clearColor));
}
}
@Override
public String toString() {
return "PackShadowDirectives{" +
"resolution=" + resolution +
", fov=" + fov +
", distance=" + distance +
", distanceRenderMul=" + distanceRenderMul +
", entityDistanceRenderMul=" + entityShadowDistanceMul +
", intervalSize=" + intervalSize +
", depthSamplingSettings=" + depthSamplingSettings +
", colorSamplingSettings=" + colorSamplingSettings +
'}';
}
public static class SamplingSettings {
/**
* Whether mipmaps should be generated before sampling. Disabled by default.
*/
private boolean mipmap;
/**
* Whether nearest texture filtering should be used in place of linear filtering. By default, linear filtering
* is used, which applies some blur, but if this is not desired behavior, nearest filtering can be used.
*/
private boolean nearest;
/**
* Whether to clear the buffer every frame.
*/
private boolean clear;
/**
* The color to clear the buffer to. If {@code clear} is false, this has no effect.
*/
private Vector4f clearColor;
/**
* The internal format to use for the color buffer.
*/
private InternalTextureFormat format;
public SamplingSettings() {
mipmap = false;
nearest = false;
clear = true;
clearColor = new Vector4f(1.0F);
format = InternalTextureFormat.RGBA;
}
protected void setMipmap(boolean mipmap) {
this.mipmap = mipmap;
}
protected void setNearest(boolean nearest) {
this.nearest = nearest;
}
protected void setClear(boolean clear) {
this.clear = clear;
}
protected void setClearColor(Vector4f clearColor) {
this.clearColor = clearColor;
}
protected void setFormat(InternalTextureFormat format) {
this.format = format;
}
public boolean getMipmap() {
return this.mipmap;
}
public boolean getNearest() {
return this.nearest;
}
public boolean getClear() {
return clear;
}
public Vector4f getClearColor() {
return clearColor;
}
public InternalTextureFormat getFormat() {
return this.format;
}
@Override
public String toString() {
return "SamplingSettings{" +
"mipmap=" + mipmap +
", nearest=" + nearest +
", clear=" + clear +
", clearColor=" + clearColor +
", format=" + format.name() +
'}';
}
}
public static class DepthSamplingSettings extends SamplingSettings {
private boolean hardwareFiltering;
public DepthSamplingSettings() {
hardwareFiltering = false;
}
private void setHardwareFiltering(boolean hardwareFiltering) {
this.hardwareFiltering = hardwareFiltering;
}
public boolean getHardwareFiltering() {
return hardwareFiltering;
}
@Override
public String toString() {
return "DepthSamplingSettings{" +
"mipmap=" + getMipmap() +
", nearest=" + getNearest() +
", hardwareFiltering=" + hardwareFiltering +
'}';
}
}
}