mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-16 02:04:59 +00:00
218 lines
9.6 KiB
Java
218 lines
9.6 KiB
Java
package net.coderbot.iris.celeritas;
|
|
|
|
import com.gtnewhorizons.angelica.glsm.GLDebug;
|
|
import com.gtnewhorizons.angelica.glsm.shader.ProgramBinaryCache;
|
|
import net.coderbot.iris.Iris;
|
|
import net.coderbot.iris.gl.blending.BlendModeOverride;
|
|
import net.coderbot.iris.gl.blending.BufferBlendOverride;
|
|
import net.coderbot.iris.pipeline.WorldRenderingPipeline;
|
|
import net.coderbot.iris.pipeline.transform.PatchShaderType;
|
|
import net.coderbot.iris.shadows.ShadowRenderingState;
|
|
import org.embeddedt.embeddium.impl.gl.GlObject;
|
|
import org.embeddedt.embeddium.impl.gl.shader.GlProgram;
|
|
import org.embeddedt.embeddium.impl.gl.shader.GlShader;
|
|
import org.embeddedt.embeddium.impl.gl.shader.ShaderType;
|
|
import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
|
|
import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface;
|
|
import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
|
|
import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
|
|
import org.embeddedt.embeddium.impl.gl.shader.ShaderBindingContext;
|
|
import org.jetbrains.annotations.Nullable;
|
|
import org.lwjgl.opengl.KHRDebug;
|
|
|
|
import java.util.EnumMap;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Optional;
|
|
import java.util.function.Function;
|
|
|
|
public class IrisCeleritasChunkProgramOverrides {
|
|
private final EnumMap<IrisTerrainPass, GlProgram<IrisCeleritasChunkShaderInterface>> programs = new EnumMap<>(IrisTerrainPass.class);
|
|
private boolean shadersCreated = false;
|
|
private int versionCounterForShaderReload = -1;
|
|
|
|
@Nullable
|
|
private GlShader createVertexShader(IrisTerrainPass pass, CeleritasTerrainPipeline pipeline) {
|
|
final CeleritasTerrainPipeline.PassInfo info = pipeline.getPassInfo(pass);
|
|
final Optional<String> source = info.sources().get(PatchShaderType.VERTEX);
|
|
|
|
return source.map(s -> new GlShader(ShaderType.VERTEX,
|
|
"iris:celeritas-terrain-" + pass.toString().toLowerCase(Locale.ROOT) + ".vsh", s))
|
|
.orElse(null);
|
|
}
|
|
|
|
@Nullable
|
|
private GlShader createGeometryShader(IrisTerrainPass pass, CeleritasTerrainPipeline pipeline) {
|
|
final CeleritasTerrainPipeline.PassInfo info = pipeline.getPassInfo(pass);
|
|
final Optional<String> source = info.sources().get(PatchShaderType.GEOMETRY);
|
|
|
|
return source.map(s -> new GlShader(ShaderType.GEOM,
|
|
"iris:celeritas-terrain-" + pass.toString().toLowerCase(Locale.ROOT) + ".gsh", s))
|
|
.orElse(null);
|
|
}
|
|
|
|
@Nullable
|
|
private GlShader createFragmentShader(IrisTerrainPass pass, CeleritasTerrainPipeline pipeline) {
|
|
final CeleritasTerrainPipeline.PassInfo info = pipeline.getPassInfo(pass);
|
|
final Optional<String> source = info.sources().get(PatchShaderType.FRAGMENT);
|
|
|
|
return source.map(s -> new GlShader(ShaderType.FRAGMENT,
|
|
"iris:celeritas-terrain-" + pass.toString().toLowerCase(Locale.ROOT) + ".fsh", s))
|
|
.orElse(null);
|
|
}
|
|
|
|
@Nullable
|
|
private static ProgramBinaryCache.Key cacheKey(CeleritasTerrainPipeline.PassInfo passInfo, ChunkVertexType vertexType) {
|
|
if (!ProgramBinaryCache.isEnabled()) return null;
|
|
final String vertex = passInfo.sources().get(PatchShaderType.VERTEX).orElse(null);
|
|
final String geometry = passInfo.sources().get(PatchShaderType.GEOMETRY).orElse(null);
|
|
final String fragment = passInfo.sources().get(PatchShaderType.FRAGMENT).orElse(null);
|
|
if (vertex == null || fragment == null) return null;
|
|
|
|
final ProgramBinaryCache.Key key = ProgramBinaryCache.key();
|
|
int attrIndex = 0;
|
|
for (var attr : vertexType.getVertexFormat().getAttributes()) {
|
|
key.attribute(attr.getName(), attrIndex++);
|
|
}
|
|
key.stage(ShaderType.VERTEX.id, vertex);
|
|
if (geometry != null) key.stage(ShaderType.GEOM.id, geometry);
|
|
key.stage(ShaderType.FRAGMENT.id, fragment);
|
|
return key;
|
|
}
|
|
|
|
private static final class SavedProgram extends GlProgram<IrisCeleritasChunkShaderInterface> {
|
|
SavedProgram(int program, Function<ShaderBindingContext, IrisCeleritasChunkShaderInterface> factory) {
|
|
super(program, factory);
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
private GlProgram<IrisCeleritasChunkShaderInterface> createShader(IrisTerrainPass pass, CeleritasTerrainPipeline pipeline, ChunkVertexType vertexType) {
|
|
final CeleritasTerrainPipeline.PassInfo passInfo = pipeline.getPassInfo(pass);
|
|
final String name = "iris:celeritas-chunk-" + pass.getName();
|
|
final BlendModeOverride blendOverride = passInfo.blendModeOverride();
|
|
final List<BufferBlendOverride> bufferOverrides = passInfo.bufferBlendOverrides();
|
|
final Function<ShaderBindingContext, IrisCeleritasChunkShaderInterface> factory = context -> new IrisCeleritasChunkShaderInterface(
|
|
((GlObject) context).handle(), context, pipeline, pass.isShadow(), blendOverride, bufferOverrides, pipeline.getCustomUniforms());
|
|
|
|
final ProgramBinaryCache.Key cacheKey = cacheKey(passInfo, vertexType);
|
|
if (cacheKey != null) {
|
|
final int saved = ProgramBinaryCache.load(cacheKey);
|
|
if (saved != 0) {
|
|
GLDebug.nameObject(KHRDebug.GL_PROGRAM, saved, name);
|
|
return new SavedProgram(saved, factory);
|
|
}
|
|
}
|
|
|
|
final GlShader vertShader = createVertexShader(pass, pipeline);
|
|
final GlShader geomShader = createGeometryShader(pass, pipeline);
|
|
final GlShader fragShader = createFragmentShader(pass, pipeline);
|
|
|
|
if (vertShader == null || fragShader == null) {
|
|
if (vertShader != null) vertShader.delete();
|
|
if (geomShader != null) geomShader.delete();
|
|
if (fragShader != null) fragShader.delete();
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
final GlProgram.Builder builder = GlProgram.builder(name);
|
|
|
|
builder.attachShader(vertShader);
|
|
if (geomShader != null) {
|
|
builder.attachShader(geomShader);
|
|
}
|
|
builder.attachShader(fragShader);
|
|
|
|
// Bind all attributes from the vertex format (includes base + Iris extended attributes)
|
|
int attrIndex = 0;
|
|
for (var attr : vertexType.getVertexFormat().getAttributes()) {
|
|
builder.bindAttribute(attr.getName(), attrIndex++);
|
|
}
|
|
|
|
final GlProgram<IrisCeleritasChunkShaderInterface> program = builder.link(factory);
|
|
if (cacheKey != null) {
|
|
ProgramBinaryCache.save(cacheKey, program.handle());
|
|
}
|
|
return program;
|
|
} finally {
|
|
vertShader.delete();
|
|
if (geomShader != null) geomShader.delete();
|
|
fragShader.delete();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create shaders for all Iris terrain passes.
|
|
*/
|
|
public void createShaders(CeleritasTerrainPipeline pipeline, RenderPassConfiguration<?> configuration) {
|
|
createShaders(pipeline, pass -> pass.toTerrainPass(configuration).vertexType());
|
|
}
|
|
|
|
public void createShaders(CeleritasTerrainPipeline pipeline, ChunkVertexType vertexType) {
|
|
createShaders(pipeline, pass -> vertexType);
|
|
}
|
|
|
|
private void createShaders(CeleritasTerrainPipeline pipeline, Function<IrisTerrainPass, ChunkVertexType> vertexTypeOf) {
|
|
if (pipeline != null) {
|
|
for (IrisTerrainPass pass : IrisTerrainPass.VALUES) {
|
|
if (pass.isShadow() && !pipeline.hasShadowPass()) {
|
|
this.programs.put(pass, null);
|
|
continue;
|
|
}
|
|
this.programs.put(pass, createShader(pass, pipeline, vertexTypeOf.apply(pass)));
|
|
}
|
|
} else {
|
|
deleteShaders();
|
|
}
|
|
shadersCreated = true;
|
|
}
|
|
|
|
@Nullable
|
|
public GlProgram<? extends ChunkShaderInterface> getProgramOverride(TerrainRenderPass pass, RenderPassConfiguration<?> configuration) {
|
|
// Check for shader pack reload
|
|
if (versionCounterForShaderReload != Iris.getPipelineManager().getVersionCounterForSodiumShaderReload()) {
|
|
versionCounterForShaderReload = Iris.getPipelineManager().getVersionCounterForSodiumShaderReload();
|
|
deleteShaders();
|
|
}
|
|
|
|
final WorldRenderingPipeline worldPipeline = Iris.getPipelineManager().getPipelineNullable();
|
|
CeleritasTerrainPipeline celeritasPipeline = null;
|
|
if (worldPipeline != null) {
|
|
celeritasPipeline = worldPipeline.getCeleritasTerrainPipeline();
|
|
}
|
|
|
|
if (!shadersCreated) {
|
|
createShaders(celeritasPipeline, configuration);
|
|
}
|
|
|
|
if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) {
|
|
if (celeritasPipeline != null && !celeritasPipeline.hasShadowPass()) {
|
|
throw new IllegalStateException("Shadow program requested, but shader pack has no shadow pass");
|
|
}
|
|
if (pass.isReverseOrder()) {
|
|
return programs.get(IrisTerrainPass.SHADOW_TRANSLUCENT);
|
|
}
|
|
return programs.get(pass.supportsFragmentDiscard() ? IrisTerrainPass.SHADOW_CUTOUT : IrisTerrainPass.SHADOW);
|
|
} else {
|
|
if (pass.supportsFragmentDiscard()) {
|
|
return programs.get(IrisTerrainPass.GBUFFER_CUTOUT);
|
|
} else if (pass.isReverseOrder()) {
|
|
return programs.get(IrisTerrainPass.GBUFFER_TRANSLUCENT);
|
|
} else {
|
|
return programs.get(IrisTerrainPass.GBUFFER_SOLID);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void deleteShaders() {
|
|
for (GlProgram<?> program : programs.values()) {
|
|
if (program != null) {
|
|
program.delete();
|
|
}
|
|
}
|
|
programs.clear();
|
|
shadersCreated = false;
|
|
}
|
|
}
|