Skip to content

Commit

Permalink
1.21 -> 1.21.4 (part 3)
Browse files Browse the repository at this point in the history
  • Loading branch information
@Sollace
Sollace committed Mar 6, 2025
1 parent 1862555 commit 6826ef3
Show file tree
Hide file tree
Showing 11 changed files with 184 additions and 234 deletions.
26 changes: 1 addition & 25 deletions src/main/java/ivorius/psychedelicraft/client/render/shader/BuiltGemoetryShader.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,8 +11,6 @@
import com.mojang.blaze3d.systems.RenderSystem;

import net.minecraft.client.gl.GlUniform;
import net.minecraft.client.gl.ShaderProgramSetupView;
import net.minecraft.client.gl.CompiledShader;

public class BuiltGemoetryShader {
private final int program;
Expand Down Expand Up @@ -59,7 +57,7 @@ public interface Holder {
void attachUniformData(@Nullable BuiltGemoetryShader shader);
}

public static class Builder implements ShaderProgramSetupView {
public static class Builder {
private final List<GlUniform> uniforms = new ArrayList<>();
private final List<Sampler> samplers = new ArrayList<>();

Expand All @@ -71,28 +69,6 @@ public Builder(int program, int lastAttributeId, int lastFragmentId) {
this.lastFragmentId = lastFragmentId;
}

@Override
public int getGlRef() {
return program;
}

@Override
public void markUniformsDirty() {
}

@Override
public CompiledShader getVertexShader() {
return null;
}

@Override
public CompiledShader getFragmentShader() {
return null;
}

@Override
public void attachReferencedShaders() {}

void addSampler(String name, Supplier<Integer> supplier) {
samplers.add(new Sampler(++lastFragmentId, name, supplier));
}
Expand Down
173 changes: 68 additions & 105 deletions src/main/java/ivorius/psychedelicraft/client/render/shader/LoadedShader.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@

import java.io.IOException;
import java.util.*;
import java.util.function.Consumer;

import org.joml.Vector3f;
import org.joml.Vector3fc;
Expand All @@ -10,165 +11,127 @@

import com.google.gson.JsonSyntaxException;

import it.unimi.dsi.fastutil.floats.FloatConsumer;
import ivorius.psychedelicraft.client.render.shader.UniformBinding.UniformSetter;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.gl.*;
import net.minecraft.client.render.DefaultFramebufferSet;
import net.minecraft.client.util.Pool;
import net.minecraft.util.Identifier;

class LoadedShader extends PostEffectProcessor {
class LoadedShader {
private final UniformBinding.Set bindings;

private int width;
private int height;
private float time;
private float lastTickDelta;
private final Identifier id;
private final MinecraftClient client;

private List<Pass> passes;
private final UpdateTracker updater = new UpdateTracker();
private final UniformValues uniformValues = new UniformValues();

public LoadedShader(MinecraftClient client, Identifier id, UniformBinding.Set bindings) throws IOException, JsonSyntaxException {
super(client.getTextureManager(), new ModdedResourceManager(client.getResourceManager(), id.getNamespace()), client.getFramebuffer(), id);
this.client = client;
this.id = id;
this.bindings = bindings;
if (passes == null) {
passes = new ArrayList<>();
}
setupDimensions(
client.getWindow().getFramebufferWidth(),
client.getWindow().getFramebufferHeight()
);
}

@Override
public void render(float tickDelta) {
if (tickDelta < lastTickDelta) {
time += 1 - lastTickDelta;
time += tickDelta;
} else {
time += tickDelta - lastTickDelta;
}
this.lastTickDelta = tickDelta;
while (time > 20) {
time -= 20;
}

boolean rendered = false;
final float passRenderFrame = time / 20F;
for (Pass pass : passes) {
rendered |= pass.render(passRenderFrame, tickDelta, rendered);
public void render(Pool pool, float tickDelta) {
PostEffectProcessor processor = client.getShaderLoader().loadPostEffect(id, DefaultFramebufferSet.MAIN_ONLY);
if (processor == null) {
return;
}
}

@Override
public void setupDimensions(int targetsWidth, int targetsHeight) {
this.width = targetsWidth;
this.height = targetsHeight;
super.setupDimensions(targetsWidth, targetsHeight);
}

@Override
public PostEffectPass addPass(String programName, Framebuffer source, Framebuffer dest, boolean linear) throws IOException {
PostEffectPass pass = super.addPass(programName, source, dest, linear);
if (passes == null) {
passes = new ArrayList<>();
if (updater.update(processor, tickDelta)) {
var original = ((PostEffectPassSupplier)processor).getPasses();
try {
((PostEffectPassSupplier)processor).setPasses(updater.passes);
processor.render(client.getFramebuffer(), pool);
} finally {
((PostEffectPassSupplier)processor).setPasses(original);
}
}
passes.add(new Pass(pass));
return pass;
}

class Pass implements UniformSetter {
private final JsonEffectShaderProgram program;
private final PostEffectPass pass;

private final List<FloatConsumer> replay = new ArrayList<>();
class UpdateTracker {
private int updateCount;

private boolean rendered;

public Pass(PostEffectPass pass) {
this.pass = pass;
this.program = pass.getProgram();
}

public boolean render(float passRenderTime, float tickDelta, boolean rendered) {
if (pass.getName().equals("blit")) {
return false;
}
private final List<PostEffectPass> passes = new ArrayList<>();

public boolean update(PostEffectProcessor processor, float tickDelta) {
if (updateCount == 0) {
replay.clear();
var programBindings = bindings.programBindings.getOrDefault(pass.getName(), UniformBinding.EMPTY);
bindings.global.bindUniforms(this, tickDelta, width, height, () -> {
programBindings.bindUniforms(this, tickDelta, width, height, () -> {
replay.add(this::renderPass);
});
});
passes.clear();
uniformValues.update(processor, tickDelta, passes);
}

updateCount = (updateCount + 1) % 2;
this.rendered = false;
if (replay.isEmpty()) {
return this.rendered;

if (uniformValues.values.isEmpty()) {
return false;
}

try {
for (FloatConsumer action : replay) {
action.accept(passRenderTime);
for (PostEffectPass pass : passes) {
try {
for (var update : uniformValues.values) {
update.accept(pass.getProgram());
}
} catch (Throwable t) {
throw new RuntimeException("Exception updating uniforms for shader " + id + " pass " + ((PostEffectPassSupplier.Pass)pass).getId(), t);
}
} catch (Throwable t) {
throw new RuntimeException("Exception rendering shader " + pass.getName(), t);
}
return this.rendered;
return true;
}
}


class UniformValues implements UniformSetter {
private final List<Consumer<ShaderProgram>> values = new ArrayList<>();

private void renderPass(float passRenderTime) {
pass.render(passRenderTime);
passes.get(passes.size() - 1).pass.render(passRenderTime);
rendered = true;
public void update(PostEffectProcessor postEffectProcessor, float tickDelta, List<PostEffectPass> retainedPasses) {
values.clear();
final int width = client.getWindow().getFramebufferWidth();
final int height = client.getWindow().getFramebufferHeight();

bindings.global.bindUniforms(this, tickDelta, width, height, () -> {
for (PostEffectPass pass : ((PostEffectPassSupplier)postEffectProcessor).getPasses()) {
var programBindings = bindings.programBindings.getOrDefault(((PostEffectPassSupplier.Pass)pass).getId(), UniformBinding.EMPTY);
programBindings.bindUniforms(this, tickDelta, width, height, () -> retainedPasses.add(pass));
}
});
}

@Override
public void set(String name, float value) {
var uniform = program.getUniformByName(name);
if (uniform != null) {
replay.add(uniformSetter(name, f -> uniform.set(value)));
}
values.add(uniformSetter(name, uniform -> uniform.set(value)));
}

@Override
public void set(String name, float... values) {
var uniform = program.getUniformByName(name);
if (uniform != null) {
var copy = Arrays.copyOf(values, values.length);
replay.add(uniformSetter(name, f -> uniform.set(copy)));
}
var copy = Arrays.copyOf(values, values.length);
this.values.add(uniformSetter(name, uniform -> uniform.set(copy)));
}

@Override
public void set(String name, Vector3fc values) {
var uniform = program.getUniformByName(name);
if (uniform != null) {
var copy = new Vector3f(values);
replay.add(uniformSetter(name, f -> uniform.set(copy)));
}
var copy = new Vector3f(values);
this.values.add(uniformSetter(name, uniform -> uniform.set(copy)));
}

@Override
public void set(String name, Vector4fc values) {
var uniform = program.getUniformByName(name);
if (uniform != null) {
var copy = new Vector4f(values);
replay.add(uniformSetter(name, f -> uniform.set(copy)));
}
var copy = new Vector4f(values);
this.values.add(uniformSetter(name, uniform -> uniform.set(copy)));
}

private static FloatConsumer uniformSetter(String name, FloatConsumer consumer) {
return f -> {
private static Consumer<ShaderProgram> uniformSetter(String name, Consumer<Uniform> consumer) {
return program -> {
try {
consumer.accept(f);
var uniform = program.getUniform(name);
if (uniform != null) {
consumer.accept(uniform);
}
} catch (Throwable t) {
throw new RuntimeException("Exception setting uniform: " + name, t);
}
};
}
}

}
22 changes: 8 additions & 14 deletions src/main/java/ivorius/psychedelicraft/client/render/shader/PSShaders.java
View file
Original file line number Diff line number Diff line change
@@ -1,26 +1,20 @@
package ivorius.psychedelicraft.client.render.shader;

import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;

import org.jetbrains.annotations.Nullable;

import ivorius.psychedelicraft.Psychedelicraft;
import net.minecraft.client.gl.ShaderProgram;
import net.minecraft.client.gl.Defines;
import net.minecraft.client.gl.ShaderProgramKey;
import net.minecraft.client.gl.ShaderProgramKeys;
import net.minecraft.client.render.VertexFormat;
import net.minecraft.client.render.VertexFormats;

public interface PSShaders {
@Nullable
Supplier<ShaderProgram> ZERO_MATTER = register("rendertype_zero_matter", VertexFormats.POSITION_COLOR);
ShaderProgramKey ZERO_MATTER = register("rendertype_zero_matter", VertexFormats.POSITION_COLOR);

static void bootstrap() {}

private static Supplier<ShaderProgram> register(String name, VertexFormat format) {
AtomicReference<ShaderProgram> program = new AtomicReference<>(null);
CoreShaderRegistrationCallback.EVENT.register(context -> {
context.register(Psychedelicraft.id(name), format, program::set);
});
return program::get;
private static ShaderProgramKey register(String name, VertexFormat format) {
ShaderProgramKey key = new ShaderProgramKey(Psychedelicraft.id("core/" + name), format, Defines.EMPTY);
ShaderProgramKeys.getAll().add(key);
return key;
}
}
15 changes: 15 additions & 0 deletions src/main/java/ivorius/psychedelicraft/client/render/shader/PostEffectPassSupplier.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,15 @@
package ivorius.psychedelicraft.client.render.shader;

import java.util.List;

import net.minecraft.client.gl.PostEffectPass;

public interface PostEffectPassSupplier {
List<PostEffectPass> getPasses();

void setPasses(List<PostEffectPass> passes);

interface Pass {
String getId();
}
}
14 changes: 4 additions & 10 deletions src/main/java/ivorius/psychedelicraft/client/render/shader/PostEffectRenderer.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,34 +6,28 @@

import ivorius.psychedelicraft.client.PsychedelicraftClient;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.gl.PostEffectProcessor;
import net.minecraft.client.util.Pool;

public class PostEffectRenderer {
private List<LoadedShader> shaders = new ArrayList<>();

public void render(float tickDelta) {
public void render(Pool pool, float tickDelta) {
if (PsychedelicraftClient.getConfig().visual.shader2DEnabled) {
RenderSystem.disableBlend();
RenderSystem.disableDepthTest();
RenderSystem.resetTextureMatrix();

if (shaders.size() == 1) {
shaders.get(0).render(tickDelta);
shaders.get(0).render(pool, tickDelta);
} else {
shaders.forEach(shader -> shader.render(tickDelta));
shaders.forEach(shader -> shader.render(pool, tickDelta));
}

MinecraftClient.getInstance().getFramebuffer().beginWrite(true);
}
}

public void setupDimensions(int width, int height) {
shaders.forEach(shader -> shader.setupDimensions(width, height));
}

public void onShadersLoaded(List<LoadedShader> shaders) {
List<LoadedShader> oldShaders = this.shaders;
this.shaders = shaders;
oldShaders.forEach(PostEffectProcessor::close);
}
}
Loading

0 comments on commit 6826ef3

Please sign in to comment.