diff --git a/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java b/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java index 572f0650f..71e47e5ac 100644 --- a/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java +++ b/src/main/java/com/gtnewhorizons/angelica/glsm/RenderSystem.java @@ -97,6 +97,8 @@ public class RenderSystem { GL20.glUniform3f(location, v0, v1, v2); } + public static void uniform3i(int location, int v0, int v1, int v2) { GL20.glUniform3i(location, v0, v1, v2); } + public static void uniform4f(int location, float v0, float v1, float v2, float v3) { GL20.glUniform4f(location, v0, v1, v2, v3); } diff --git a/src/main/java/kroppeb/stareval/Util.java b/src/main/java/kroppeb/stareval/Util.java new file mode 100644 index 000000000..a8368be1b --- /dev/null +++ b/src/main/java/kroppeb/stareval/Util.java @@ -0,0 +1,13 @@ +package kroppeb.stareval; + +import java.util.function.Consumer; + +public class Util { + public static T make(T item, Consumer init) { + init.accept(item); + return item; + } + +} + + diff --git a/src/main/java/kroppeb/stareval/element/tree/AccessExpressionElement.java b/src/main/java/kroppeb/stareval/element/tree/AccessExpressionElement.java index 033303a2a..9cbc77784 100644 --- a/src/main/java/kroppeb/stareval/element/tree/AccessExpressionElement.java +++ b/src/main/java/kroppeb/stareval/element/tree/AccessExpressionElement.java @@ -1,23 +1,12 @@ package kroppeb.stareval.element.tree; +import com.github.bsideup.jabel.Desugar; import kroppeb.stareval.element.AccessibleExpressionElement; -public class AccessExpressionElement implements AccessibleExpressionElement { - private final AccessibleExpressionElement base; - private final String index; +@Desugar +public record AccessExpressionElement(AccessibleExpressionElement base, + String index) implements AccessibleExpressionElement { - public AccessExpressionElement(AccessibleExpressionElement base, String index) { - this.base = base; - this.index = index; - } - - public AccessibleExpressionElement getBase() { - return this.base; - } - - public String getIndex() { - return this.index; - } @Override public String toString() { diff --git a/src/main/java/kroppeb/stareval/element/tree/BinaryExpressionElement.java b/src/main/java/kroppeb/stareval/element/tree/BinaryExpressionElement.java index ded159e6f..40111ebca 100644 --- a/src/main/java/kroppeb/stareval/element/tree/BinaryExpressionElement.java +++ b/src/main/java/kroppeb/stareval/element/tree/BinaryExpressionElement.java @@ -1,30 +1,13 @@ package kroppeb.stareval.element.tree; +import com.github.bsideup.jabel.Desugar; import kroppeb.stareval.element.ExpressionElement; import kroppeb.stareval.parser.BinaryOp; -public class BinaryExpressionElement implements ExpressionElement { - private final BinaryOp op; - private final ExpressionElement left; - private final ExpressionElement right; +@Desugar +public record BinaryExpressionElement(BinaryOp op, ExpressionElement left, + ExpressionElement right) implements ExpressionElement { - public BinaryExpressionElement(BinaryOp op, ExpressionElement left, ExpressionElement right) { - this.op = op; - this.left = left; - this.right = right; - } - - public BinaryOp getOp() { - return this.op; - } - - public ExpressionElement getLeft() { - return this.left; - } - - public ExpressionElement getRight() { - return this.right; - } @Override public String toString() { diff --git a/src/main/java/kroppeb/stareval/element/tree/FunctionCall.java b/src/main/java/kroppeb/stareval/element/tree/FunctionCall.java index 12bb8ab07..068e1c887 100644 --- a/src/main/java/kroppeb/stareval/element/tree/FunctionCall.java +++ b/src/main/java/kroppeb/stareval/element/tree/FunctionCall.java @@ -1,25 +1,13 @@ package kroppeb.stareval.element.tree; +import com.github.bsideup.jabel.Desugar; import kroppeb.stareval.element.ExpressionElement; import java.util.List; -public class FunctionCall implements ExpressionElement { - private final String id; - private final List args; +@Desugar +public record FunctionCall(String id, List args) implements ExpressionElement { - public FunctionCall(String id, List args) { - this.id = id; - this.args = args; - } - - public String getId() { - return this.id; - } - - public List getArgs() { - return this.args; - } @Override public String toString() { diff --git a/src/main/java/kroppeb/stareval/element/tree/UnaryExpressionElement.java b/src/main/java/kroppeb/stareval/element/tree/UnaryExpressionElement.java index 4126b549a..e35a06eb2 100644 --- a/src/main/java/kroppeb/stareval/element/tree/UnaryExpressionElement.java +++ b/src/main/java/kroppeb/stareval/element/tree/UnaryExpressionElement.java @@ -1,24 +1,12 @@ package kroppeb.stareval.element.tree; +import com.github.bsideup.jabel.Desugar; import kroppeb.stareval.element.ExpressionElement; import kroppeb.stareval.parser.UnaryOp; -public class UnaryExpressionElement implements ExpressionElement { - private final UnaryOp op; - private final ExpressionElement inner; +@Desugar +public record UnaryExpressionElement(UnaryOp op, ExpressionElement inner) implements ExpressionElement { - public UnaryExpressionElement(UnaryOp op, ExpressionElement inner) { - this.op = op; - this.inner = inner; - } - - public UnaryOp getOp() { - return op; - } - - public ExpressionElement getInner() { - return inner; - } @Override public String toString() { diff --git a/src/main/java/kroppeb/stareval/element/tree/partial/PartialBinaryExpression.java b/src/main/java/kroppeb/stareval/element/tree/partial/PartialBinaryExpression.java index ae6041c37..fdc156c2e 100644 --- a/src/main/java/kroppeb/stareval/element/tree/partial/PartialBinaryExpression.java +++ b/src/main/java/kroppeb/stareval/element/tree/partial/PartialBinaryExpression.java @@ -21,7 +21,7 @@ public class PartialBinaryExpression extends PartialExpression implements Priori @Override public int getPriority() { - return this.op.getPriority(); + return this.op.priority(); } @Override diff --git a/src/main/java/kroppeb/stareval/exception/MissingTokenException.java b/src/main/java/kroppeb/stareval/exception/MissingTokenException.java index 388f1eed2..ade5fbf04 100644 --- a/src/main/java/kroppeb/stareval/exception/MissingTokenException.java +++ b/src/main/java/kroppeb/stareval/exception/MissingTokenException.java @@ -1,10 +1,7 @@ package kroppeb.stareval.exception; public class MissingTokenException extends ParseException { - - private static final long serialVersionUID = -2096321911994168858L; - - public MissingTokenException(String message, int index) { + public MissingTokenException(String message, int index) { super(message + " at index " + index); } } diff --git a/src/main/java/kroppeb/stareval/exception/ParseException.java b/src/main/java/kroppeb/stareval/exception/ParseException.java index d1773012e..5dd9d6b14 100644 --- a/src/main/java/kroppeb/stareval/exception/ParseException.java +++ b/src/main/java/kroppeb/stareval/exception/ParseException.java @@ -1,10 +1,7 @@ package kroppeb.stareval.exception; -public abstract class ParseException extends Exception{ - - private static final long serialVersionUID = -5014053641238717471L; - - public ParseException() { +public abstract class ParseException extends Exception { + public ParseException() { } public ParseException(String message) { diff --git a/src/main/java/kroppeb/stareval/exception/UnexpectedCharacterException.java b/src/main/java/kroppeb/stareval/exception/UnexpectedCharacterException.java index 7cbb45efd..9de12af20 100644 --- a/src/main/java/kroppeb/stareval/exception/UnexpectedCharacterException.java +++ b/src/main/java/kroppeb/stareval/exception/UnexpectedCharacterException.java @@ -1,10 +1,7 @@ package kroppeb.stareval.exception; public class UnexpectedCharacterException extends ParseException { - - private static final long serialVersionUID = -3886198952263126846L; - - public UnexpectedCharacterException(char expected, char actual, int index) { + public UnexpectedCharacterException(char expected, char actual, int index) { this("Expected to read '" + expected + "' but got '" + actual + "' at index " + index); } diff --git a/src/main/java/kroppeb/stareval/exception/UnexpectedEndingException.java b/src/main/java/kroppeb/stareval/exception/UnexpectedEndingException.java index 71d6a3434..1b2135bbd 100644 --- a/src/main/java/kroppeb/stareval/exception/UnexpectedEndingException.java +++ b/src/main/java/kroppeb/stareval/exception/UnexpectedEndingException.java @@ -1,10 +1,7 @@ package kroppeb.stareval.exception; public class UnexpectedEndingException extends ParseException { - - private static final long serialVersionUID = -3704913315979481520L; - - public UnexpectedEndingException() { + public UnexpectedEndingException() { this("Expected to read more text, but the string has ended"); } diff --git a/src/main/java/kroppeb/stareval/exception/UnexpectedTokenException.java b/src/main/java/kroppeb/stareval/exception/UnexpectedTokenException.java index acde97145..d395cc498 100644 --- a/src/main/java/kroppeb/stareval/exception/UnexpectedTokenException.java +++ b/src/main/java/kroppeb/stareval/exception/UnexpectedTokenException.java @@ -1,10 +1,7 @@ package kroppeb.stareval.exception; public class UnexpectedTokenException extends ParseException { - - private static final long serialVersionUID = 689385399380177588L; - - public UnexpectedTokenException(String message, int index) { + public UnexpectedTokenException(String message, int index) { super(message + " at index " + index); } } diff --git a/src/main/java/kroppeb/stareval/expression/BasicVariableExpression.java b/src/main/java/kroppeb/stareval/expression/BasicVariableExpression.java new file mode 100644 index 000000000..c05056534 --- /dev/null +++ b/src/main/java/kroppeb/stareval/expression/BasicVariableExpression.java @@ -0,0 +1,31 @@ +package kroppeb.stareval.expression; + +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; + +public class BasicVariableExpression implements VariableExpression { + final private String name; + final private Type type; + + public BasicVariableExpression(String name, Type type) { + this.name = name; + this.type = type; + } + + @Override + public void evaluateTo(FunctionContext c, FunctionReturn r) { + c.getVariable(name).evaluateTo(c, r); + } + + @Override + public Expression partialEval(FunctionContext context, FunctionReturn functionReturn) { + if (context.hasVariable(this.name)) { + context.getVariable(this.name).evaluateTo(context, functionReturn); + return type.createConstant(functionReturn); + } else { + return this; + } + } + +} diff --git a/src/main/java/kroppeb/stareval/expression/CallExpression.java b/src/main/java/kroppeb/stareval/expression/CallExpression.java new file mode 100644 index 000000000..311653a5d --- /dev/null +++ b/src/main/java/kroppeb/stareval/expression/CallExpression.java @@ -0,0 +1,84 @@ +package kroppeb.stareval.expression; + +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.TypedFunction; + +import java.util.Collection; + +public class CallExpression implements Expression { + private final TypedFunction function; + private final Expression[] arguments; + + public CallExpression(TypedFunction function, Expression[] arguments) { + this.function = function; + this.arguments = arguments; + } + + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + this.function.evaluateTo(this.arguments, context, functionReturn); + } + + @Override + public void listVariables(Collection variables) { + for (Expression argument : this.arguments) { + argument.listVariables(variables); + } + } + + private boolean isConstant() { + for (Expression i : arguments) { + if (!(i instanceof ConstantExpression)) { + return false; + } + } + return true; + } + + @Override + public Expression partialEval(FunctionContext context, FunctionReturn functionReturn) { + // the dirty way would be this + /* + try{ + this.evaluateTo(context, functionReturn); + return this.function.getReturnType().createConstant(functionReturn); + }catch(Exception e){ + return this; + } + */ + + if (this.function.isPure() && isConstant()) { + this.evaluateTo(context, functionReturn); + return function.getReturnType().createConstant(functionReturn); + } + + Expression[] partialEvaluatedParams = new Expression[this.arguments.length]; + boolean allFullySimplified = true; + boolean noneSimplified = true; + for (int i = 0; i < this.arguments.length; i++) { + Expression simplified = this.arguments[i].partialEval(context, functionReturn); + if (simplified instanceof ConstantExpression) { + noneSimplified = false; + } else { + allFullySimplified = false; + if (simplified != this.arguments[i]) { + noneSimplified = false; + } + } + partialEvaluatedParams[i] = simplified; + } + + if (this.function.isPure() && allFullySimplified) { + this.function.evaluateTo(partialEvaluatedParams, context, functionReturn); + return this.function.getReturnType().createConstant(functionReturn); + } + + if (noneSimplified) { + return this; + } + + return new CallExpression(this.function, partialEvaluatedParams); + + } +} diff --git a/src/main/java/kroppeb/stareval/expression/ConstantExpression.java b/src/main/java/kroppeb/stareval/expression/ConstantExpression.java new file mode 100644 index 000000000..100d74588 --- /dev/null +++ b/src/main/java/kroppeb/stareval/expression/ConstantExpression.java @@ -0,0 +1,21 @@ +package kroppeb.stareval.expression; + +import kroppeb.stareval.function.Type; + +import java.util.Collection; + +public abstract class ConstantExpression implements Expression { + private final Type type; + + protected ConstantExpression(Type type) { + this.type = type; + } + + public Type getType() { + return this.type; + } + + @Override + public void listVariables(Collection variables) { + } +} diff --git a/src/main/java/kroppeb/stareval/expression/Expression.java b/src/main/java/kroppeb/stareval/expression/Expression.java new file mode 100644 index 000000000..66c2a2e41 --- /dev/null +++ b/src/main/java/kroppeb/stareval/expression/Expression.java @@ -0,0 +1,16 @@ +package kroppeb.stareval.expression; + +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionReturn; + +import java.util.Collection; + +public interface Expression { + void evaluateTo(FunctionContext context, FunctionReturn functionReturn); + + default Expression partialEval(FunctionContext context, FunctionReturn functionReturn) { + return this; + } + + void listVariables(Collection variables); +} diff --git a/src/main/java/kroppeb/stareval/expression/VariableExpression.java b/src/main/java/kroppeb/stareval/expression/VariableExpression.java new file mode 100644 index 000000000..620ab583e --- /dev/null +++ b/src/main/java/kroppeb/stareval/expression/VariableExpression.java @@ -0,0 +1,10 @@ +package kroppeb.stareval.expression; + +import java.util.Collection; + +public interface VariableExpression extends Expression { + @Override + default void listVariables(Collection variables) { + variables.add(this); + } +} diff --git a/src/main/java/kroppeb/stareval/function/AbstractTypedFunction.java b/src/main/java/kroppeb/stareval/function/AbstractTypedFunction.java new file mode 100644 index 000000000..516fe8166 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/AbstractTypedFunction.java @@ -0,0 +1,67 @@ +package kroppeb.stareval.function; + +import java.util.Arrays; +import java.util.Objects; + +public abstract class AbstractTypedFunction implements TypedFunction { + private final Type returnType; + private final Parameter[] parameters; + private final int priority; + private final boolean isPure; + + public AbstractTypedFunction(Type returnType, Parameter[] parameters, int priority, boolean isPure) { + this.returnType = returnType; + this.parameters = parameters; + this.priority = priority; + this.isPure = isPure; + } + + public AbstractTypedFunction(Type returnType, Type[] parameterType) { + this.returnType = returnType; + this.parameters = Arrays.stream(parameterType).map(Parameter::new).toArray(Parameter[]::new); + this.priority = 0; + this.isPure = true; + } + + @Override + public Type getReturnType() { + return this.returnType; + } + + @Override + public Parameter[] getParameters() { + return this.parameters; + } + + @Override + public boolean isPure() { + return this.isPure; + } + + @Override + public int priority() { + return this.priority; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof AbstractTypedFunction func) { + return Objects.equals(returnType, func.returnType) && + Arrays.equals(parameters, func.parameters) && + priority == func.priority && + isPure == func.isPure; + } + + return false; + } + + @Override + public int hashCode() { + return Objects.hash(returnType, Arrays.hashCode(parameters), priority, isPure); + } + + @Override + public String toString() { + return TypedFunction.format(this, "unknown"); + } +} diff --git a/src/main/java/kroppeb/stareval/function/B2BFunction.java b/src/main/java/kroppeb/stareval/function/B2BFunction.java new file mode 100644 index 000000000..e1a829611 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/B2BFunction.java @@ -0,0 +1,26 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface B2BFunction extends TypedFunction { + boolean eval(boolean a); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + boolean a = functionReturn.booleanReturn; + + functionReturn.booleanReturn = this.eval(a); + } + + @Override + default Type getReturnType() { + return Type.Boolean; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.BooleanParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/BB2BFunction.java b/src/main/java/kroppeb/stareval/function/BB2BFunction.java new file mode 100644 index 000000000..5a0159c4c --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/BB2BFunction.java @@ -0,0 +1,29 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface BB2BFunction extends TypedFunction { + boolean eval(boolean a, boolean b); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + boolean a = functionReturn.booleanReturn; + + params[1].evaluateTo(context, functionReturn); + boolean b = functionReturn.booleanReturn; + + functionReturn.booleanReturn = this.eval(a, b); + } + + @Override + default Type getReturnType() { + return Type.Boolean; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.BooleanParameter, Type.BooleanParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/BasicFunctionContext.java b/src/main/java/kroppeb/stareval/function/BasicFunctionContext.java new file mode 100644 index 000000000..1e9d7f5b8 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/BasicFunctionContext.java @@ -0,0 +1,36 @@ +package kroppeb.stareval.function; + +import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; +import kroppeb.stareval.expression.Expression; +import kroppeb.stareval.expression.VariableExpression; + +import java.util.Map; + +public class BasicFunctionContext implements FunctionContext { + final private Map variables = new Object2ObjectOpenHashMap<>(); + + public void setVariable(String name, Expression value) { + variables.put(name, value); + } + + public void setIntVariable(String name, int value) { + setVariable(name, (VariableExpression) (c, r) -> r.intReturn = value); + } + + public void setFloatVariable(String name, float value) { + setVariable(name, (VariableExpression) (c, r) -> r.floatReturn = value); + } + + @Override + public Expression getVariable(String name) { + Expression expression = variables.get(name); + if (expression == null) + throw new RuntimeException("Variable hasn't been set: " + name); + return expression; + } + + @Override + public boolean hasVariable(String name) { + return variables.containsKey(name); + } +} diff --git a/src/main/java/kroppeb/stareval/function/F2FFunction.java b/src/main/java/kroppeb/stareval/function/F2FFunction.java new file mode 100644 index 000000000..307f72152 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/F2FFunction.java @@ -0,0 +1,24 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface F2FFunction extends TypedFunction { + float eval(float a); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = this.eval(functionReturn.floatReturn); + } + + @Override + default Type getReturnType() { + return Type.Float; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.FloatParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/F2IFunction.java b/src/main/java/kroppeb/stareval/function/F2IFunction.java new file mode 100644 index 000000000..89c3e4cf2 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/F2IFunction.java @@ -0,0 +1,24 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface F2IFunction extends TypedFunction { + int eval(float a); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = this.eval(functionReturn.floatReturn); + } + + @Override + default Type getReturnType() { + return Type.Int; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.FloatParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/FF2BFunction.java b/src/main/java/kroppeb/stareval/function/FF2BFunction.java new file mode 100644 index 000000000..b8f01d3e3 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/FF2BFunction.java @@ -0,0 +1,29 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface FF2BFunction extends TypedFunction { + boolean eval(float a, float b); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float a = functionReturn.floatReturn; + + params[1].evaluateTo(context, functionReturn); + float b = functionReturn.floatReturn; + + functionReturn.booleanReturn = this.eval(a, b); + } + + @Override + default Type getReturnType() { + return Type.Boolean; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.FloatParameter, Type.FloatParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/FF2FFunction.java b/src/main/java/kroppeb/stareval/function/FF2FFunction.java new file mode 100644 index 000000000..e40a2ea39 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/FF2FFunction.java @@ -0,0 +1,29 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface FF2FFunction extends TypedFunction { + float eval(float a, float b); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float a = functionReturn.floatReturn; + + params[1].evaluateTo(context, functionReturn); + float b = functionReturn.floatReturn; + + functionReturn.floatReturn = this.eval(a, b); + } + + @Override + default Type getReturnType() { + return Type.Float; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.FloatParameter, Type.FloatParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/FFF2BFunction.java b/src/main/java/kroppeb/stareval/function/FFF2BFunction.java new file mode 100644 index 000000000..0c6091322 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/FFF2BFunction.java @@ -0,0 +1,32 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface FFF2BFunction extends TypedFunction { + boolean eval(float a, float b, float c); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float a = functionReturn.floatReturn; + + params[1].evaluateTo(context, functionReturn); + float b = functionReturn.floatReturn; + + params[2].evaluateTo(context, functionReturn); + float c = functionReturn.floatReturn; + + functionReturn.booleanReturn = this.eval(a, b, c); + } + + @Override + default Type getReturnType() { + return Type.Boolean; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.FloatParameter, Type.FloatParameter, Type.FloatParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/FFF2FFunction.java b/src/main/java/kroppeb/stareval/function/FFF2FFunction.java new file mode 100644 index 000000000..c75573197 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/FFF2FFunction.java @@ -0,0 +1,32 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface FFF2FFunction extends TypedFunction { + float eval(float a, float b, float c); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float a = functionReturn.floatReturn; + + params[1].evaluateTo(context, functionReturn); + float b = functionReturn.floatReturn; + + params[2].evaluateTo(context, functionReturn); + float c = functionReturn.floatReturn; + + functionReturn.floatReturn = this.eval(a, b, c); + } + + @Override + default Type getReturnType() { + return Type.Float; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.FloatParameter, Type.FloatParameter, Type.FloatParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/FunctionContext.java b/src/main/java/kroppeb/stareval/function/FunctionContext.java new file mode 100644 index 000000000..ae924554b --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/FunctionContext.java @@ -0,0 +1,9 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +public interface FunctionContext { + Expression getVariable(String name); + + boolean hasVariable(String name); +} diff --git a/src/main/java/kroppeb/stareval/function/FunctionResolver.java b/src/main/java/kroppeb/stareval/function/FunctionResolver.java new file mode 100644 index 000000000..c6b4769ed --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/FunctionResolver.java @@ -0,0 +1,131 @@ +package kroppeb.stareval.function; + +import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap; +import it.unimi.dsi.fastutil.objects.ObjectArrayList; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.Supplier; +import java.util.stream.Collectors; + +public class FunctionResolver { + private final Map>> functions; + // TODO: instead of a suplier we could use an int->function to make varargs + private final Map>>> dynamicFunctions; + + public FunctionResolver( + Map>> functions, + Map>>> dynamicFunctions) { + this.functions = functions; + this.dynamicFunctions = dynamicFunctions; + } + + public List resolve(String name, Type returnType) { + Map> normal = this.functions.get(name); + Map>> dynamic = this.dynamicFunctions.get(name); + List u = null; + + if (normal == null && dynamic == null) + throw new RuntimeException("No such function: " + name); + if (normal != null) + u = normal.get(returnType); + if (dynamic != null) { + List> p = dynamic.get(returnType); + if (p != null) { + List uDynamic = p.stream().map(Supplier::get).collect(Collectors.toList()); + if (u == null) { + u = uDynamic; + } else { + List newU = new ArrayList<>(u.size() + uDynamic.size()); + newU.addAll(u); + newU.addAll(uDynamic); + u = newU; + } + } + + } + + if (u == null) + return Collections.emptyList(); + return u; + } + + public void logAllFunctions() { + final Set names = new LinkedHashSet<>(); + names.addAll(this.functions.keySet()); + names.addAll(this.dynamicFunctions.keySet()); + for (final String name : names) { + final Map> overloads = new Object2ObjectLinkedOpenHashMap<>(); + Map> normal = this.functions.get(name); + if (normal != null) + overloads.putAll(normal); + + Map>> dynamic = this.dynamicFunctions.get(name); + if (dynamic != null) + overloads.putAll( + dynamic + .entrySet() + .stream() + .collect(Collectors.toMap( + Map.Entry::getKey, + entry -> entry.getValue() + .stream() + .map(Supplier::get) + .collect(Collectors.toList()) + ) + ) + ); + + for (Map.Entry> returnTypeOverloads : overloads.entrySet()) { + for (TypedFunction typedFunction : returnTypeOverloads.getValue()) { + System.out.println(TypedFunction.format(typedFunction, name)); + } + System.out.println(); + } + System.out.println(); + } + } + + public static class Builder { + private final Map> functions = new Object2ObjectLinkedOpenHashMap<>(); + private final Map>>> dynamicFunctions = new Object2ObjectLinkedOpenHashMap<>(); + + public void add(String name, T function) { + this.addFunction(name, function); + } + + public void addDynamic(String name, Type returnType, Supplier function) { + this.addDynamicFunction(name, returnType, function); + } + + public void addDynamicFunction(String name, Type returnType, Supplier function) { + this.dynamicFunctions + .computeIfAbsent(name, (n) -> new Object2ObjectLinkedOpenHashMap<>()) + .computeIfAbsent(returnType, (n) -> new ObjectArrayList<>()) + .add(function); + } + + public void addFunction(String name, TypedFunction function) { + this.functions.computeIfAbsent(name, (n) -> new ObjectArrayList<>()).add(function); + } + + public FunctionResolver build() { + Map>> functions = new Object2ObjectLinkedOpenHashMap<>(); + for (Map.Entry> entry : this.functions.entrySet()) { + Map> typeMap = new Object2ObjectLinkedOpenHashMap<>(); + for (TypedFunction function : entry.getValue()) { + typeMap.computeIfAbsent(function.getReturnType(), i -> new ObjectArrayList<>()) + .add(function); + } + functions.put(entry.getKey(), typeMap); + } + + return new FunctionResolver(functions, this.dynamicFunctions); + } + } + +} diff --git a/src/main/java/kroppeb/stareval/function/FunctionReturn.java b/src/main/java/kroppeb/stareval/function/FunctionReturn.java new file mode 100644 index 000000000..5bf14af47 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/FunctionReturn.java @@ -0,0 +1,12 @@ +package kroppeb.stareval.function; + +public class FunctionReturn { + public boolean booleanReturn; + public byte byteReturn; + public short shortReturn; + public int intReturn; + public long longReturn; + public float floatReturn; + public double doubleReturn; + public Object objectReturn; +} diff --git a/src/main/java/kroppeb/stareval/function/I2FFunction.java b/src/main/java/kroppeb/stareval/function/I2FFunction.java new file mode 100644 index 000000000..fa73f9259 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/I2FFunction.java @@ -0,0 +1,24 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface I2FFunction extends TypedFunction { + float eval(int a); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = this.eval(functionReturn.intReturn); + } + + @Override + default Type getReturnType() { + return Type.Float; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.IntParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/I2IFunction.java b/src/main/java/kroppeb/stareval/function/I2IFunction.java new file mode 100644 index 000000000..94135c212 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/I2IFunction.java @@ -0,0 +1,24 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface I2IFunction extends TypedFunction { + int eval(int a); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = this.eval(functionReturn.intReturn); + } + + @Override + default Type getReturnType() { + return Type.Int; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.IntParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/II2BFunction.java b/src/main/java/kroppeb/stareval/function/II2BFunction.java new file mode 100644 index 000000000..7e1d229bd --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/II2BFunction.java @@ -0,0 +1,29 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface II2BFunction extends TypedFunction { + boolean eval(int a, int b); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + int a = functionReturn.intReturn; + + params[1].evaluateTo(context, functionReturn); + int b = functionReturn.intReturn; + + functionReturn.booleanReturn = this.eval(a, b); + } + + @Override + default Type getReturnType() { + return Type.Boolean; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.IntParameter, Type.IntParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/II2IFunction.java b/src/main/java/kroppeb/stareval/function/II2IFunction.java new file mode 100644 index 000000000..1e056d31c --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/II2IFunction.java @@ -0,0 +1,29 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface II2IFunction extends TypedFunction { + int eval(int a, int b); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + int a = functionReturn.intReturn; + + params[1].evaluateTo(context, functionReturn); + int b = functionReturn.intReturn; + + functionReturn.intReturn = this.eval(a, b); + } + + @Override + default Type getReturnType() { + return Type.Int; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.IntParameter, Type.IntParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/III2BFunction.java b/src/main/java/kroppeb/stareval/function/III2BFunction.java new file mode 100644 index 000000000..ed8478f1e --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/III2BFunction.java @@ -0,0 +1,32 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface III2BFunction extends TypedFunction { + boolean eval(int a, int b, int c); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + int a = functionReturn.intReturn; + + params[1].evaluateTo(context, functionReturn); + int b = functionReturn.intReturn; + + params[2].evaluateTo(context, functionReturn); + int c = functionReturn.intReturn; + + functionReturn.booleanReturn = this.eval(a, b, c); + } + + @Override + default Type getReturnType() { + return Type.Boolean; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.IntParameter, Type.IntParameter, Type.IntParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/III2IFunction.java b/src/main/java/kroppeb/stareval/function/III2IFunction.java new file mode 100644 index 000000000..f53c28d92 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/III2IFunction.java @@ -0,0 +1,32 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface III2IFunction extends TypedFunction { + int eval(int a, int b, int c); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + int a = functionReturn.intReturn; + + params[1].evaluateTo(context, functionReturn); + int b = functionReturn.intReturn; + + params[2].evaluateTo(context, functionReturn); + int c = functionReturn.intReturn; + + functionReturn.intReturn = this.eval(a, b, c); + } + + @Override + default Type getReturnType() { + return Type.Int; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{Type.IntParameter, Type.IntParameter, Type.IntParameter}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/Type.java b/src/main/java/kroppeb/stareval/function/Type.java new file mode 100644 index 000000000..3b0cfeee4 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/Type.java @@ -0,0 +1,182 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.ConstantExpression; +import kroppeb.stareval.function.TypedFunction.Parameter; +import net.coderbot.iris.gl.uniform.UniformType; +import net.coderbot.iris.parsing.MatrixType; +import net.coderbot.iris.parsing.VectorType; + +public abstract class Type { + public static final Boolean Boolean = new Boolean(); + public static final Int Int = new Int(); + public static final Float Float = new Float(); + public static final Parameter BooleanParameter = new Parameter(Boolean); + public static final Parameter IntParameter = new Parameter(Int); + public static final Parameter FloatParameter = new Parameter(Float); + public static final Primitive[] AllPrimitives = {Type.Boolean, Type.Int, Type.Float}; + + public static UniformType convert(Type type) { + if (type == Type.Int || type == Type.Boolean) return UniformType.INT; + else if (type == Type.Float) return UniformType.FLOAT; + else if (type == VectorType.VEC2) return UniformType.VEC2; + else if (type == VectorType.VEC3) return UniformType.VEC3; + else if (type == VectorType.VEC4) return UniformType.VEC4; + else if (type == VectorType.I_VEC2) return UniformType.VEC2I; + else if (type == VectorType.I_VEC3) return UniformType.VEC3I; + else if (type == MatrixType.MAT4) return UniformType.MAT4; + else throw new IllegalArgumentException("Unsupported custom uniform type: " + type); + } + + public abstract ConstantExpression createConstant(FunctionReturn functionReturn); + + public abstract Object createArray(int length); + + public abstract void setValueFromReturn(Object array, int index, FunctionReturn value); + + public abstract void getValueFromArray(Object array, int index, FunctionReturn value); + + public abstract String toString(); + + public abstract static class Primitive extends Type { + } + + public static class ObjectType extends Type { + @Override + public ConstantExpression createConstant(FunctionReturn functionReturn) { + Object object = functionReturn.objectReturn; + return new ConstantExpression(this) { + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + functionReturn.objectReturn = object; + } + }; + } + + @Override + public Object createArray(int length) { + return new Object[length]; + } + + @Override + public void setValueFromReturn(Object array, int index, FunctionReturn value) { + Object[] arr = (Object[]) array; + arr[index] = value.objectReturn; + } + + @Override + public void getValueFromArray(Object array, int index, FunctionReturn value) { + Object[] arr = (Object[]) array; + value.objectReturn = arr[index]; + } + + @Override + public String toString() { + return "Object"; + } + } + + public static class Boolean extends Primitive { + @Override + public ConstantExpression createConstant(FunctionReturn functionReturn) { + boolean value = functionReturn.booleanReturn; + return new ConstantExpression(this) { + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + functionReturn.booleanReturn = value; + } + }; + } + + @Override + public Object createArray(int length) { + return new boolean[length]; + } + + @Override + public void setValueFromReturn(Object array, int index, FunctionReturn value) { + boolean[] arr = (boolean[]) array; + arr[index] = value.booleanReturn; + } + + @Override + public void getValueFromArray(Object array, int index, FunctionReturn value) { + boolean[] arr = (boolean[]) array; + value.booleanReturn = arr[index]; + } + + @Override + public String toString() { + return "bool"; + } + } + + public static class Int extends Primitive { + @Override + public ConstantExpression createConstant(FunctionReturn functionReturn) { + int value = functionReturn.intReturn; + return new ConstantExpression(this) { + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + functionReturn.intReturn = value; + } + }; + } + + @Override + public Object createArray(int length) { + return new int[length]; + } + + @Override + public void setValueFromReturn(Object array, int index, FunctionReturn value) { + int[] arr = (int[]) array; + arr[index] = value.intReturn; + } + + @Override + public void getValueFromArray(Object array, int index, FunctionReturn value) { + int[] arr = (int[]) array; + value.intReturn = arr[index]; + } + + @Override + public String toString() { + return "int"; + } + } + + public static class Float extends Primitive { + @Override + public ConstantExpression createConstant(FunctionReturn functionReturn) { + float value = functionReturn.floatReturn; + return new ConstantExpression(this) { + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + functionReturn.floatReturn = value; + } + }; + } + + @Override + public Object createArray(int length) { + return new float[length]; + } + + @Override + public void setValueFromReturn(Object array, int index, FunctionReturn value) { + float[] arr = (float[]) array; + arr[index] = value.floatReturn; + } + + @Override + public void getValueFromArray(Object array, int index, FunctionReturn value) { + float[] arr = (float[]) array; + value.floatReturn = arr[index]; + } + + @Override + public String toString() { + return "float"; + } + } +} diff --git a/src/main/java/kroppeb/stareval/function/TypedFunction.java b/src/main/java/kroppeb/stareval/function/TypedFunction.java new file mode 100644 index 000000000..bed05058e --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/TypedFunction.java @@ -0,0 +1,72 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +import java.util.Arrays; +import java.util.Objects; +import java.util.stream.Collectors; + +public interface TypedFunction { + + static String format(TypedFunction function, String name) { + return String.format("%s %s(%s) (priority: %d, pure:%s)", + function.getReturnType().toString(), + name, + Arrays.stream(function.getParameters()) + .map(param -> param.constant() ? "const " + param.type() : param.type().toString()) + .collect(Collectors.joining(", ")), + function.priority(), + function.isPure() ? "yes" : "no" + ); + } + + Type getReturnType(); + + Parameter[] getParameters(); + + void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn); + + default boolean isPure() { + return true; + } + + default int priority() { + return 0; + } + + class Parameter { + private final Type type; + private final boolean isConstant; + + public Parameter(Type type, boolean isConstant) { + this.type = type; + this.isConstant = isConstant; + } + + public Parameter(Type type) { + this(type, false); + } + + public Type type() { + return this.type; + } + + public boolean constant() { + return this.isConstant; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof Parameter p) { + return Objects.equals(type, p.type) && Objects.equals(isConstant, p.isConstant); + } + return false; + } + + @Override + public int hashCode() { + return Objects.hashCode(type) + 3192 + Objects.hashCode(isConstant); + } + } +} + diff --git a/src/main/java/kroppeb/stareval/function/V2FFunction.java b/src/main/java/kroppeb/stareval/function/V2FFunction.java new file mode 100644 index 000000000..0733ceb36 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/V2FFunction.java @@ -0,0 +1,23 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface V2FFunction extends TypedFunction { + float eval(); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + functionReturn.floatReturn = this.eval(); + } + + @Override + default Type getReturnType() { + return Type.Float; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{}; + } +} diff --git a/src/main/java/kroppeb/stareval/function/V2IFunction.java b/src/main/java/kroppeb/stareval/function/V2IFunction.java new file mode 100644 index 000000000..6dacfc544 --- /dev/null +++ b/src/main/java/kroppeb/stareval/function/V2IFunction.java @@ -0,0 +1,23 @@ +package kroppeb.stareval.function; + +import kroppeb.stareval.expression.Expression; + +@FunctionalInterface +public interface V2IFunction extends TypedFunction { + int eval(); + + @Override + default void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + functionReturn.intReturn = this.eval(); + } + + @Override + default Type getReturnType() { + return Type.Int; + } + + @Override + default Parameter[] getParameters() { + return new Parameter[]{}; + } +} diff --git a/src/main/java/kroppeb/stareval/parser/BinaryOp.java b/src/main/java/kroppeb/stareval/parser/BinaryOp.java index 41bf081a7..c3a4f6a45 100644 --- a/src/main/java/kroppeb/stareval/parser/BinaryOp.java +++ b/src/main/java/kroppeb/stareval/parser/BinaryOp.java @@ -1,20 +1,15 @@ package kroppeb.stareval.parser; -public class BinaryOp { - private final String name; - private final int priority; +import com.github.bsideup.jabel.Desugar; + +@Desugar +public record BinaryOp(String name, int priority) { - public BinaryOp(String name, int priority) { - this.name = name; - this.priority = priority; - } @Override public String toString() { return this.name + "{" + this.priority + "}"; } - public int getPriority() { - return this.priority; - } + } diff --git a/src/main/java/kroppeb/stareval/parser/OpResolver.java b/src/main/java/kroppeb/stareval/parser/OpResolver.java index e9ada48bd..bd2337862 100644 --- a/src/main/java/kroppeb/stareval/parser/OpResolver.java +++ b/src/main/java/kroppeb/stareval/parser/OpResolver.java @@ -7,6 +7,7 @@ import java.util.Map; /** * OpResolver maps the trailing characters identifying an operator to an actual operator. + * * @param */ abstract class OpResolver { @@ -27,7 +28,7 @@ abstract class OpResolver { * Adds a new multi-character operator. Calling this with an empty string is equivalent to calling singleChar. * * @param trailing every character after the first character of the operator. - * @param op the operator + * @param op the operator */ public void multiChar(String trailing, T op) { T previous = map.put(trailing, op); @@ -40,14 +41,14 @@ abstract class OpResolver { public OpResolver build() { if (map.size() > 2) { throw new RuntimeException("unimplemented: Cannot currently build an optimized operator resolver " + - "tree when more than two operators start with the same character"); + "tree when more than two operators start with the same character"); } T singleChar = map.get(""); if (singleChar != null) { if (map.size() == 1) { - return new SingleChar<>(singleChar); + return new OpResolver.SingleChar<>(singleChar); } else { for (Map.Entry subEntry : map.entrySet()) { if ("".equals(subEntry.getKey())) { @@ -57,33 +58,33 @@ abstract class OpResolver { if (subEntry.getKey().length() != 1) { throw new RuntimeException("unimplemented: Optimized operator resolver trees can " + - "currently only be built of operators that contain one or two characters."); + "currently only be built of operators that contain one or two characters."); } // We can assume that this is the only other entry in the map due to the size check above - return new SingleDualChar<>( - singleChar, - subEntry.getValue(), - subEntry.getKey().charAt(0) + return new OpResolver.SingleDualChar<>( + singleChar, + subEntry.getValue(), + subEntry.getKey().charAt(0) ); } } } else { if (map.size() > 1) { throw new RuntimeException("unimplemented: Optimized operator resolver trees can currently only " + - "handle two operators starting with the same character if one operator is a single character"); + "handle two operators starting with the same character if one operator is a single character"); } for (Map.Entry subEntry : map.entrySet()) { if (subEntry.getKey().length() != 1) { throw new RuntimeException("unimplemented: Optimized operator resolver trees can " + - "currently only be built of operators that contain one or two characters."); + "currently only be built of operators that contain one or two characters."); } // We can assume that this is the only entry in the map due to the size check above. - return new DualChar<>( - subEntry.getValue(), - subEntry.getKey().charAt(0) + return new OpResolver.DualChar<>( + subEntry.getValue(), + subEntry.getKey().charAt(0) ); } } diff --git a/src/main/java/kroppeb/stareval/parser/Parser.java b/src/main/java/kroppeb/stareval/parser/Parser.java index 4824c6f48..5da7a06b4 100644 --- a/src/main/java/kroppeb/stareval/parser/Parser.java +++ b/src/main/java/kroppeb/stareval/parser/Parser.java @@ -60,9 +60,13 @@ public class Parser { Parser() { } + public static ExpressionElement parse(String input, ParserOptions options) throws ParseException { + return Tokenizer.parse(input, options); + } + private Element peek() { if (!this.stack.isEmpty()) { - return this.stack.get(this.stack.size() - 1); + return this.stack.get(this.stack.size() - 1); } return null; @@ -115,6 +119,8 @@ public class Parser { return token; } + // visitor methods + /** * Executes following reduce step: *
    @@ -134,8 +140,8 @@ public class Parser { if (args == null) { throw new MissingTokenException( - "Expected an opening bracket '(' before seeing a comma ',' or closing bracket ')'", - index + "Expected an opening bracket '(' before seeing a comma ',' or closing bracket ')'", + index ); } @@ -143,13 +149,11 @@ public class Parser { ((UnfinishedArgsExpression) args).tokens.add(expr); } else { throw new UnexpectedTokenException( - "Expected to see an opening bracket '(' or a comma ',' right before an expression followed by a " + - "closing bracket ')' or a comma ','", index); + "Expected to see an opening bracket '(' or a comma ',' right before an expression followed by a " + + "closing bracket ')' or a comma ','", index); } } - // visitor methods - void visitId(String id) { this.push(new IdToken(id)); } @@ -213,8 +217,8 @@ public class Parser { if (!(pop instanceof UnfinishedArgsExpression)) { throw new UnexpectedTokenException( - "Expected to see an opening bracket '(' or a comma ',' right before an expression followed by a " + - "closing bracket ')' or a comma ','", index); + "Expected to see an opening bracket '(' or a comma ',' right before an expression followed by a " + + "closing bracket ')' or a comma ','", index); } args = (UnfinishedArgsExpression) pop; } @@ -256,7 +260,7 @@ public class Parser { */ void visitBinaryOperator(BinaryOp binaryOp) { // reduce the expressions to the needed priority level - ExpressionElement left = this.expressionReducePop(binaryOp.getPriority()); + ExpressionElement left = this.expressionReducePop(binaryOp.priority()); // stack[ {'a', '*'}, 'b'], token = '+' -> stack[], left = {'a', '*', 'b'} // -> stack[{{'a', '*', 'b'}, '+'}] // stack[ {'a', '+'}, 'b'], token = '+' -> stack[], left = {'a', '+', 'b'} @@ -287,8 +291,8 @@ public class Parser { throw new MissingTokenException("Expected a closing bracket", endIndex); } else { throw new UnexpectedTokenException( - "The stack of tokens isn't empty at the end of the expression: " + this.stack + - " top: " + result, endIndex); + "The stack of tokens isn't empty at the end of the expression: " + this.stack + + " top: " + result, endIndex); } } else { Element top = this.peek(); @@ -296,20 +300,16 @@ public class Parser { throw new MissingTokenException("Expected a closing bracket", endIndex); } else if (top instanceof PriorityOperatorElement) { throw new MissingTokenException( - "Expected a identifier, constant or subexpression on the right side of the operator", - endIndex); + "Expected a identifier, constant or subexpression on the right side of the operator", + endIndex); } else { throw new UnexpectedTokenException( - "The stack of tokens contains an unexpected token at the top: " + this.stack, - endIndex); + "The stack of tokens contains an unexpected token at the top: " + this.stack, + endIndex); } } } else { throw new MissingTokenException("The input seems to be empty", endIndex); } } - - public static ExpressionElement parse(String input, ParserOptions options) throws ParseException { - return Tokenizer.parse(input, options); - } } diff --git a/src/main/java/kroppeb/stareval/parser/ParserOptions.java b/src/main/java/kroppeb/stareval/parser/ParserOptions.java index 2c3ee04ed..b21fc20ec 100644 --- a/src/main/java/kroppeb/stareval/parser/ParserOptions.java +++ b/src/main/java/kroppeb/stareval/parser/ParserOptions.java @@ -9,9 +9,9 @@ public final class ParserOptions { private final TokenRules tokenRules; private ParserOptions( - Char2ObjectMap> unaryOpResolvers, - Char2ObjectMap> binaryOpResolvers, - TokenRules tokenRules) { + Char2ObjectMap> unaryOpResolvers, + Char2ObjectMap> binaryOpResolvers, + TokenRules tokenRules) { this.unaryOpResolvers = unaryOpResolvers; this.binaryOpResolvers = binaryOpResolvers; this.tokenRules = tokenRules; @@ -29,52 +29,12 @@ public final class ParserOptions { return this.binaryOpResolvers.get(c); } - public static class Builder { - private final Char2ObjectMap> unaryOpResolvers = new Char2ObjectOpenHashMap<>(); - private final Char2ObjectMap> binaryOpResolvers = new Char2ObjectOpenHashMap<>(); - private TokenRules tokenRules = TokenRules.DEFAULT; - - public void addUnaryOp(String s, UnaryOp op) { - char first = s.charAt(0); - String trailing = s.substring(1); - - this.unaryOpResolvers.computeIfAbsent(first, (c) -> new OpResolver.Builder<>()).multiChar(trailing, op); - } - - public void addBinaryOp(String s, BinaryOp op) { - char first = s.charAt(0); - String trailing = s.substring(1); - - this.binaryOpResolvers.computeIfAbsent(first, (c) -> new OpResolver.Builder<>()).multiChar(trailing, op); - } - - public void setTokenRules(TokenRules tokenRules) { - this.tokenRules = tokenRules; - } - - private static Char2ObjectMap> buildOpResolvers( - Char2ObjectMap> ops) { - Char2ObjectMap> result = new Char2ObjectOpenHashMap<>(); - - ops.char2ObjectEntrySet().forEach( - entry -> result.put(entry.getCharKey(), entry.getValue().build())); - - return result; - } - - public ParserOptions build() { - return new ParserOptions( - buildOpResolvers(this.unaryOpResolvers), - buildOpResolvers(this.binaryOpResolvers), - this.tokenRules); - } - } - /** * Defines a set of rules that allows the tokenizer to identify tokens within a string. */ public interface TokenRules { - TokenRules DEFAULT = new TokenRules() {}; + TokenRules DEFAULT = new TokenRules() { + }; static boolean isNumber(final char c) { return c >= '0' && c <= '9'; @@ -116,4 +76,45 @@ public final class ParserOptions { return this.isAccessStart(c); } } + + public static class Builder { + private final Char2ObjectMap> unaryOpResolvers = new Char2ObjectOpenHashMap<>(); + private final Char2ObjectMap> binaryOpResolvers = new Char2ObjectOpenHashMap<>(); + private TokenRules tokenRules = TokenRules.DEFAULT; + + private static Char2ObjectMap> buildOpResolvers( + Char2ObjectMap> ops) { + Char2ObjectMap> result = new Char2ObjectOpenHashMap<>(); + + ops.char2ObjectEntrySet().forEach( + entry -> result.put(entry.getCharKey(), entry.getValue().build())); + + return result; + } + + public void addUnaryOp(String s, UnaryOp op) { + char first = s.charAt(0); + String trailing = s.substring(1); + + this.unaryOpResolvers.computeIfAbsent(first, (c) -> new OpResolver.Builder<>()).multiChar(trailing, op); + } + + public void addBinaryOp(String s, BinaryOp op) { + char first = s.charAt(0); + String trailing = s.substring(1); + + this.binaryOpResolvers.computeIfAbsent(first, (c) -> new OpResolver.Builder<>()).multiChar(trailing, op); + } + + public void setTokenRules(TokenRules tokenRules) { + this.tokenRules = tokenRules; + } + + public ParserOptions build() { + return new ParserOptions( + buildOpResolvers(this.unaryOpResolvers), + buildOpResolvers(this.binaryOpResolvers), + this.tokenRules); + } + } } diff --git a/src/main/java/kroppeb/stareval/parser/UnaryOp.java b/src/main/java/kroppeb/stareval/parser/UnaryOp.java index 150110288..182e833e8 100644 --- a/src/main/java/kroppeb/stareval/parser/UnaryOp.java +++ b/src/main/java/kroppeb/stareval/parser/UnaryOp.java @@ -1,11 +1,10 @@ package kroppeb.stareval.parser; -public class UnaryOp { - private final String name; +import com.github.bsideup.jabel.Desugar; + +@Desugar +public record UnaryOp(String name) { - public UnaryOp(String name) { - this.name = name; - } @Override public String toString() { diff --git a/src/main/java/kroppeb/stareval/resolver/ExpressionResolver.java b/src/main/java/kroppeb/stareval/resolver/ExpressionResolver.java new file mode 100644 index 000000000..9ac814705 --- /dev/null +++ b/src/main/java/kroppeb/stareval/resolver/ExpressionResolver.java @@ -0,0 +1,320 @@ +package kroppeb.stareval.resolver; + +import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; +import kroppeb.stareval.element.ExpressionElement; +import kroppeb.stareval.element.token.IdToken; +import kroppeb.stareval.element.token.NumberToken; +import kroppeb.stareval.element.tree.AccessExpressionElement; +import kroppeb.stareval.element.tree.BinaryExpressionElement; +import kroppeb.stareval.element.tree.FunctionCall; +import kroppeb.stareval.element.tree.UnaryExpressionElement; +import kroppeb.stareval.expression.CallExpression; +import kroppeb.stareval.expression.ConstantExpression; +import kroppeb.stareval.expression.Expression; +import kroppeb.stareval.expression.VariableExpression; +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionResolver; +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import kroppeb.stareval.function.TypedFunction; +import kroppeb.stareval.function.TypedFunction.Parameter; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.function.Supplier; + +public class ExpressionResolver { + private final FunctionResolver functionResolver; + private final Function variableTypeMap; + private final boolean enableDebugging; + private final Map numbers = new Object2ObjectOpenHashMap<>(); + private List logs; + + public ExpressionResolver(FunctionResolver functionResolver, Function variableTypeMap) { + this(functionResolver, variableTypeMap, false); + } + + + public ExpressionResolver(FunctionResolver functionResolver, Function variableTypeMap, boolean enableDebugging) { + this.functionResolver = functionResolver; + this.variableTypeMap = variableTypeMap; + this.enableDebugging = enableDebugging; + } + + public Expression resolveExpression(Type targetType, ExpressionElement expression) { + this.clearLogs(); + Expression result = this.resolveExpressionInternal(targetType, expression, true, true); + if (result != null) { + return result; + } + throw new RuntimeException("Couldn't resolve: \n" + String.join("\n", this.extractLogs())); + } + + Expression resolveCallExpressionInternal( + Type targetType, + String name, + List inner, + boolean implicit + ) { + int innerLength = inner.size(); + Expression result = null; + TypedFunction resultFunction = null; + functions: + for (TypedFunction f : this.functionResolver.resolve(name, targetType)) { + Parameter[] paramTypes = f.getParameters(); + if (paramTypes.length != innerLength) + continue; + + Expression[] params = new Expression[innerLength]; + for (int i = 0; i < innerLength; i++) { + ExpressionElement paramExpression = inner.get(i); + Parameter param = paramTypes[i]; + if (param.constant() && !(paramExpression instanceof NumberToken)) { + // not a constant + continue functions; + } + + Expression expression = this.resolveExpressionInternal(param.type(), paramExpression, + !implicit || innerLength > 1, implicit); + if (expression == null) + continue functions; + params[i] = expression; + } + // FIXME + if (result != null && f.priority() == resultFunction.priority()) { + throw new RuntimeException("Ambiguity, \n\told: " + TypedFunction.format(resultFunction, "") + "\n\tnew: " + TypedFunction.format(f, "")); + } else if (resultFunction == null || f.priority() >= resultFunction.priority()) { + result = new CallExpression(f, params); + resultFunction = f; + } + } + return result; + } + + private Expression resolveCallExpression( + Type targetType, + String name, + List inner, + boolean allowNonImplicit, + boolean allowImplicit) { + + this.log("[DEBUG] resolving function %s with args %s to type %s", + name, inner, targetType); + + Expression result = null; + + if (allowNonImplicit) { + result = this.resolveCallExpressionInternal(targetType, name, inner, false); + } + + if (result != null) { + this.log("[DEBUG] resolved function %s with args %s to type %s directly", + name, inner, targetType); + return result; + } else if (!allowImplicit) { + this.log("[DEBUG] Failed to resolve function %s with args %s to type %s directly", + name, inner, targetType); + return null; + } + + List casts = this.functionResolver.resolve("", targetType); + + for (TypedFunction f : casts) { + Expression u = this.resolveCallExpression(f.getParameters()[0].type(), name, inner, true, true); + if (u == null) + continue; + if (result != null) + throw new RuntimeException("Ambiguity"); + result = new CallExpression(f, new Expression[]{u}); + } + if (result != null) { + this.log("[DEBUG] resolved function %s with args %s to type %s using only final cast", + name, inner, targetType); + return result; + } + + result = this.resolveCallExpressionInternal(targetType, name, inner, true); + if (result != null) { + this.log("[DEBUG] resolved function %s with args %s to type %s using implicit inner casts", + name, inner, targetType); + } else { + this.log("[DEBUG] failed to resolve function %s with args %s to type %s", + name, inner, targetType); + } + return result; + } + + public List extractLogs() { + List old = this.logs; + this.clearLogs(); + return old; + } + + public void clearLogs() { + this.logs = new ArrayList<>(); + } + + private void log(String str) { + if (this.enableDebugging) + this.logs.add(str); + } + + private void log(String str, Object... args) { + if (this.enableDebugging) + this.logs.add(String.format(str, args)); + } + + private void log(Supplier str) { + if (this.enableDebugging) + this.log(str.get()); + } + + private Expression resolveExpressionInternal( + Type targetType, + ExpressionElement expression, + boolean allowNonImplicit, + boolean allowImplicit) { + Expression castable; + Type innerType; + + this.log("[DEBUG] resolving %s to type %s (%d%d)", + expression, targetType, allowNonImplicit ? 1 : 0, allowImplicit ? 1 : 0); + + if (expression instanceof UnaryExpressionElement token) { + return this.resolveCallExpression(targetType, token.op().name(), Collections.singletonList(token.inner()), + allowNonImplicit, allowImplicit); + } else if (expression instanceof BinaryExpressionElement token) { + return this.resolveCallExpression(targetType, token.op().name(), Arrays.asList(token.left(), token.right()), + allowNonImplicit, allowImplicit); + } else if (expression instanceof FunctionCall token) { + return this.resolveCallExpression(targetType, token.id(), token.args(), + allowNonImplicit, allowImplicit); + } else if (expression instanceof AccessExpressionElement token) { + return this.resolveCallExpression(targetType, "", + Collections.singletonList(token.base()), + allowNonImplicit, allowImplicit); + } else if (expression instanceof NumberToken token) { + ConstantExpression exp = this.resolveNumber(token.getNumber()); + if (exp.getType().equals(targetType)) { + this.log("[DEBUG] resolved constant %s to type %s", token.getNumber(), targetType); + return exp; + } + // TODO: implicit casting is split up too much + if (!allowImplicit) { + this.log("[DEBUG] failed to resolve constant %s (of type %s) to type %s without implicit casts", + token.getNumber(), exp.getType(), targetType); + return null; + } + this.log("[DEBUG] trying implicit casts to resolve constant %s (of type %s) to type %s", + token.getNumber(), exp.getType(), targetType); + castable = exp; + innerType = exp.getType(); + } else if (expression instanceof IdToken token) { + final String name = token.getId(); + Type type = this.variableTypeMap.apply(name); + if (type == null) + throw new RuntimeException("Unknown variable: " + name); + if (type.equals(targetType)) { + log("[DEBUG] resolved variable %s to type %s", name, targetType); + // TODO: We should add a variable provider (and have this as default) + // doing so would remove the need for a FunctionContext. + return new VariableExpression() { + @Override + public void evaluateTo(FunctionContext c, FunctionReturn r) { + c.getVariable(name).evaluateTo(c, r); + } + + @Override + public Expression partialEval(FunctionContext context, FunctionReturn functionReturn) { + return context.hasVariable(name) ? context.getVariable(name) : this; + } + }; + } + if (!allowImplicit) { + log("[DEBUG] failed to resolve variable %s (of type %s) to type %s without implicit casts", + name, type, targetType); + return null; + } + // TODO duplicate of above + castable = new VariableExpression() { + @Override + public void evaluateTo(FunctionContext c, FunctionReturn r) { + c.getVariable(name).evaluateTo(c, r); + } + + @Override + public Expression partialEval(FunctionContext context, FunctionReturn functionReturn) { + return context.hasVariable(name) ? context.getVariable(name) : this; + } + }; + innerType = type; + } else { + throw new RuntimeException("unexpected token: " + expression.toString()); + } + + List casts = this.functionResolver.resolve("", targetType); + + for (TypedFunction f : casts) { + if (f.getParameters()[0].type().equals(innerType)) { + this.log("[DEBUG] resolved %s to type %s using implicit casts", + expression, targetType); + return new CallExpression(f, new Expression[]{castable}); + } + } + this.log("[DEBUG] failed to resolved %s to type %s, even using implicit casts", expression, targetType); + return null; + } + + private ConstantExpression resolveNumber(String s) { + return this.numbers.computeIfAbsent(s, str -> { + NumberFormatException p; + try { + final int val; + if (str.length() >= 2 && str.charAt(0) == '0') { + switch (str.charAt(1)) { + case 'b': { + val = Integer.parseInt(str.substring(2), 2); + break; + } + case 'x': { + val = Integer.parseInt(str.substring(2), 16); + break; + } + default: { + val = Integer.parseInt(str.substring(1), 8); + break; + } + } + } else + val = Integer.parseInt(str); + + return new ConstantExpression(Type.Int) { + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + functionReturn.intReturn = val; + } + }; + } catch (NumberFormatException ex) { + p = ex; + } + + try { + final float res = Float.parseFloat(str); + return new ConstantExpression(Type.Float) { + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + functionReturn.floatReturn = res; + } + }; + } catch (NumberFormatException ex) { + RuntimeException exception = new RuntimeException("Illegal number: " + str, ex); + exception.addSuppressed(p); + throw exception; + } + }); + } +} diff --git a/src/main/java/net/coderbot/iris/gl/program/ComputeProgram.java b/src/main/java/net/coderbot/iris/gl/program/ComputeProgram.java index 6f97e10d1..830d669a7 100644 --- a/src/main/java/net/coderbot/iris/gl/program/ComputeProgram.java +++ b/src/main/java/net/coderbot/iris/gl/program/ComputeProgram.java @@ -57,12 +57,15 @@ public final class ComputeProgram extends GlResource { return cachedWorkGroups; } - public void dispatch(float width, float height) { - GL20.glUseProgram(getGlId()); - uniforms.update(); - samplers.update(); - images.update(); + public void use() { + GL20.glUseProgram(getGlId()); + uniforms.update(); + samplers.update(); + images.update(); + } + + public void dispatch(float width, float height) { if (!Iris.getPipelineManager().getPipeline().map(WorldRenderingPipeline::allowConcurrentCompute).orElse(false)) { RenderSystem.memoryBarrier(40); } diff --git a/src/main/java/net/coderbot/iris/gl/program/ProgramUniforms.java b/src/main/java/net/coderbot/iris/gl/program/ProgramUniforms.java index 2eb54f2a0..72d0b13c9 100644 --- a/src/main/java/net/coderbot/iris/gl/program/ProgramUniforms.java +++ b/src/main/java/net/coderbot/iris/gl/program/ProgramUniforms.java @@ -10,6 +10,8 @@ import java.util.List; import java.util.Map; import java.util.Objects; import java.util.OptionalInt; +import java.util.function.Supplier; + import net.coderbot.iris.Iris; import net.coderbot.iris.gl.state.ValueUpdateNotifier; import net.coderbot.iris.gl.uniform.DynamicLocationalUniformHolder; @@ -20,6 +22,7 @@ import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; import net.coderbot.iris.uniforms.SystemTimeUniforms; import net.minecraft.client.Minecraft; import net.minecraft.client.multiplayer.WorldClient; +import org.joml.Vector3i; import org.lwjgl.BufferUtils; import org.lwjgl.opengl.ARBShaderImageLoadStore; import org.lwjgl.opengl.GL11; @@ -172,8 +175,7 @@ public class ProgramUniforms { return OptionalInt.empty(); } - // TODO: Temporary hack until custom uniforms are merged. - if ((!locations.containsKey(id) && !uniformNames.containsKey(name)) || name.equals("framemod8")) { + if ((!locations.containsKey(id) && !uniformNames.containsKey(name))) { locations.put(id, name); uniformNames.put(name, type); } else { @@ -240,12 +242,6 @@ public class ProgramUniforms { continue; } - // TODO: This is an absolutely horrific hack, but is needed until custom uniforms work. - if ("framemod8".equals(name) && expected == UniformType.FLOAT && provided == UniformType.INT) { - SystemTimeUniforms.addFloatFrameMod8Uniform(this); - provided = UniformType.FLOAT; - } - if (provided != null && provided != expected) { String expectedName; @@ -283,7 +279,7 @@ public class ProgramUniforms { return this; } - @Override + @Override public UniformHolder externallyManagedUniform(String name, UniformType type) { externalUniformNames.put(name, type); diff --git a/src/main/java/net/coderbot/iris/gl/uniform/DynamicLocationalUniformHolder.java b/src/main/java/net/coderbot/iris/gl/uniform/DynamicLocationalUniformHolder.java index 12c678b0d..e96058edc 100644 --- a/src/main/java/net/coderbot/iris/gl/uniform/DynamicLocationalUniformHolder.java +++ b/src/main/java/net/coderbot/iris/gl/uniform/DynamicLocationalUniformHolder.java @@ -2,6 +2,7 @@ package net.coderbot.iris.gl.uniform; import net.coderbot.iris.gl.state.ValueUpdateNotifier; import org.joml.Vector2i; +import org.joml.Vector3i; import org.joml.Vector4f; import org.joml.Vector4i; @@ -42,12 +43,23 @@ public interface DynamicLocationalUniformHolder extends LocationalUniformHolder, return this; } + default DynamicUniformHolder uniform3i(String name, Supplier value, ValueUpdateNotifier notifier) { + location(name, UniformType.VEC3I).ifPresent(id -> addDynamicUniform(new Vector3IntegerJomlUniform(id, value, notifier), notifier)); + + return this; + } + default DynamicUniformHolder uniform4f(String name, Supplier value, ValueUpdateNotifier notifier) { location(name, UniformType.VEC4).ifPresent(id -> addDynamicUniform(new Vector4Uniform(id, value, notifier), notifier)); return this; } + default DynamicUniformHolder uniform4fArray(String name, Supplier value, ValueUpdateNotifier notifier) { + location(name, UniformType.VEC4).ifPresent(id -> addDynamicUniform(new Vector4ArrayUniform(id, value, notifier), notifier)); + return this; + } + default DynamicUniformHolder uniform4i(String name, Supplier value, ValueUpdateNotifier notifier) { location(name, UniformType.VEC4I).ifPresent(id -> addDynamicUniform(new Vector4IntegerJomlUniform(id, value, notifier), notifier)); diff --git a/src/main/java/net/coderbot/iris/gl/uniform/DynamicUniformHolder.java b/src/main/java/net/coderbot/iris/gl/uniform/DynamicUniformHolder.java index c921ef6b2..c130bd9d0 100644 --- a/src/main/java/net/coderbot/iris/gl/uniform/DynamicUniformHolder.java +++ b/src/main/java/net/coderbot/iris/gl/uniform/DynamicUniformHolder.java @@ -2,6 +2,7 @@ package net.coderbot.iris.gl.uniform; import net.coderbot.iris.gl.state.ValueUpdateNotifier; import org.joml.Vector2i; +import org.joml.Vector3i; import org.joml.Vector4f; import org.joml.Vector4i; @@ -15,6 +16,8 @@ public interface DynamicUniformHolder extends UniformHolder { DynamicUniformHolder uniform1f(String name, DoubleSupplier value, ValueUpdateNotifier notifier); DynamicUniformHolder uniform1i(String name, IntSupplier value, ValueUpdateNotifier notifier); DynamicUniformHolder uniform2i(String name, Supplier value, ValueUpdateNotifier notifier); + DynamicUniformHolder uniform3i(String name, Supplier value, ValueUpdateNotifier notifier); DynamicUniformHolder uniform4f(String name, Supplier value, ValueUpdateNotifier notifier); + DynamicUniformHolder uniform4fArray(String name, Supplier value, ValueUpdateNotifier notifier); DynamicUniformHolder uniform4i(String name, Supplier value, ValueUpdateNotifier notifier); } diff --git a/src/main/java/net/coderbot/iris/gl/uniform/LocationalUniformHolder.java b/src/main/java/net/coderbot/iris/gl/uniform/LocationalUniformHolder.java index a0afb3f50..bf2046c52 100644 --- a/src/main/java/net/coderbot/iris/gl/uniform/LocationalUniformHolder.java +++ b/src/main/java/net/coderbot/iris/gl/uniform/LocationalUniformHolder.java @@ -6,6 +6,7 @@ import org.joml.Vector2f; import org.joml.Vector2i; import org.joml.Vector3d; import org.joml.Vector3f; +import org.joml.Vector3i; import org.joml.Vector4f; import java.util.OptionalInt; @@ -75,6 +76,13 @@ public interface LocationalUniformHolder extends UniformHolder { return this; } + @Override + default LocationalUniformHolder uniform3i(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + location(name, UniformType.VEC3I).ifPresent(id -> addUniform(updateFrequency, new Vector3IntegerJomlUniform(id, value))); + + return this; + } + @Override default LocationalUniformHolder uniformVanilla3f(UniformUpdateFrequency updateFrequency, String name, Supplier value) { location(name, UniformType.VEC3).ifPresent(id -> addUniform(updateFrequency, new VanillaVector3Uniform(id, value))); @@ -103,6 +111,13 @@ public interface LocationalUniformHolder extends UniformHolder { return this; } + @Override + default LocationalUniformHolder uniform4fArray(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + location(name, UniformType.VEC4).ifPresent(id -> addUniform(updateFrequency, new Vector4ArrayUniform(id, value))); + + return this; + } + @Override default LocationalUniformHolder uniformMatrix(UniformUpdateFrequency updateFrequency, String name, Supplier value) { location(name, UniformType.MAT4).ifPresent(id -> addUniform(updateFrequency, new MatrixUniform(id, value))); diff --git a/src/main/java/net/coderbot/iris/gl/uniform/UniformHolder.java b/src/main/java/net/coderbot/iris/gl/uniform/UniformHolder.java index 05f339a09..de6891d69 100644 --- a/src/main/java/net/coderbot/iris/gl/uniform/UniformHolder.java +++ b/src/main/java/net/coderbot/iris/gl/uniform/UniformHolder.java @@ -6,6 +6,7 @@ import org.joml.Vector2f; import org.joml.Vector2i; import org.joml.Vector3d; import org.joml.Vector3f; +import org.joml.Vector3i; import org.joml.Vector4f; import java.util.function.BooleanSupplier; @@ -30,6 +31,8 @@ public interface UniformHolder { UniformHolder uniform3f(UniformUpdateFrequency updateFrequency, String name, Supplier value); + UniformHolder uniform3i(UniformUpdateFrequency updateFrequency, String name, Supplier value); + UniformHolder uniformVanilla3f(UniformUpdateFrequency updateFrequency, String name, Supplier value); UniformHolder uniformTruncated3f(UniformUpdateFrequency updateFrequency, String name, Supplier value); @@ -38,6 +41,8 @@ public interface UniformHolder { UniformHolder uniform4f(UniformUpdateFrequency updateFrequency, String name, Supplier value); + UniformHolder uniform4fArray(UniformUpdateFrequency updateFrequency, String name, Supplier value); + UniformHolder uniformMatrix(UniformUpdateFrequency updateFrequency, String name, Supplier value); UniformHolder uniformMatrixFromArray(UniformUpdateFrequency updateFrequency, String name, Supplier value); diff --git a/src/main/java/net/coderbot/iris/gl/uniform/UniformType.java b/src/main/java/net/coderbot/iris/gl/uniform/UniformType.java index 0bc4f20fd..6933943dd 100644 --- a/src/main/java/net/coderbot/iris/gl/uniform/UniformType.java +++ b/src/main/java/net/coderbot/iris/gl/uniform/UniformType.java @@ -7,6 +7,7 @@ public enum UniformType { VEC2, VEC2I, VEC3, + VEC3I, VEC4, VEC4I } diff --git a/src/main/java/net/coderbot/iris/gl/uniform/UniformUpdateFrequency.java b/src/main/java/net/coderbot/iris/gl/uniform/UniformUpdateFrequency.java index e6b76acce..20a1fd5e7 100644 --- a/src/main/java/net/coderbot/iris/gl/uniform/UniformUpdateFrequency.java +++ b/src/main/java/net/coderbot/iris/gl/uniform/UniformUpdateFrequency.java @@ -3,5 +3,6 @@ package net.coderbot.iris.gl.uniform; public enum UniformUpdateFrequency { ONCE, PER_TICK, - PER_FRAME + PER_FRAME, + CUSTOM } diff --git a/src/main/java/net/coderbot/iris/gl/uniform/Vector3IntegerJomlUniform.java b/src/main/java/net/coderbot/iris/gl/uniform/Vector3IntegerJomlUniform.java new file mode 100644 index 000000000..2ab719d83 --- /dev/null +++ b/src/main/java/net/coderbot/iris/gl/uniform/Vector3IntegerJomlUniform.java @@ -0,0 +1,41 @@ +package net.coderbot.iris.gl.uniform; + +import com.gtnewhorizons.angelica.glsm.RenderSystem; +import net.coderbot.iris.gl.state.ValueUpdateNotifier; +import org.joml.Vector3i; + +import java.util.function.Supplier; + +public class Vector3IntegerJomlUniform extends Uniform { + private Vector3i cachedValue; + private final Supplier value; + + Vector3IntegerJomlUniform(int location, Supplier value) { + this(location, value, null); + } + + Vector3IntegerJomlUniform(int location, Supplier value, ValueUpdateNotifier notifier) { + super(location, notifier); + + this.cachedValue = null; + this.value = value; + } + + @Override + public void update() { + updateValue(); + + if (notifier != null) { + notifier.setListener(this::updateValue); + } + } + + private void updateValue() { + Vector3i newValue = value.get(); + + if (cachedValue == null || !newValue.equals(cachedValue)) { + cachedValue = newValue; + RenderSystem.uniform3i(this.location, newValue.x, newValue.y, newValue.z); + } + } +} diff --git a/src/main/java/net/coderbot/iris/gl/uniform/Vector4ArrayUniform.java b/src/main/java/net/coderbot/iris/gl/uniform/Vector4ArrayUniform.java new file mode 100644 index 000000000..63029b1d7 --- /dev/null +++ b/src/main/java/net/coderbot/iris/gl/uniform/Vector4ArrayUniform.java @@ -0,0 +1,41 @@ +package net.coderbot.iris.gl.uniform; + +import com.gtnewhorizons.angelica.glsm.RenderSystem; +import net.coderbot.iris.gl.state.ValueUpdateNotifier; + +import java.util.Arrays; +import java.util.function.Supplier; + +public class Vector4ArrayUniform extends Uniform { + private final Supplier value; + private float[] cachedValue; + + Vector4ArrayUniform(int location, Supplier value) { + this(location, value, null); + } + + Vector4ArrayUniform(int location, Supplier value, ValueUpdateNotifier notifier) { + super(location, notifier); + + this.cachedValue = new float[4]; + this.value = value; + } + + @Override + public void update() { + updateValue(); + + if (notifier != null) { + notifier.setListener(this::updateValue); + } + } + + private void updateValue() { + float[] newValue = value.get(); + + if (!Arrays.equals(newValue, cachedValue)) { + cachedValue = newValue; + RenderSystem.uniform4f(location, cachedValue[0], cachedValue[1], cachedValue[2], cachedValue[3]); + } + } +} diff --git a/src/main/java/net/coderbot/iris/parsing/BiomeCategories.java b/src/main/java/net/coderbot/iris/parsing/BiomeCategories.java new file mode 100644 index 000000000..22fe37181 --- /dev/null +++ b/src/main/java/net/coderbot/iris/parsing/BiomeCategories.java @@ -0,0 +1,25 @@ +package net.coderbot.iris.parsing; + +public enum BiomeCategories { + NONE, + TAIGA, + EXTREME_HILLS, + JUNGLE, + MESA, + PLAINS, + SAVANNA, + ICY, + THE_END, + BEACH, + FOREST, + OCEAN, + DESERT, + RIVER, + SWAMP, + MUSHROOM, + NETHER, + + // TODO: This is in Optifine, but undocumented... + MOUNTAIN, + UNDERGROUND +} diff --git a/src/main/java/net/coderbot/iris/parsing/BooleanVectorizedFunction.java b/src/main/java/net/coderbot/iris/parsing/BooleanVectorizedFunction.java new file mode 100644 index 000000000..f7c03e981 --- /dev/null +++ b/src/main/java/net/coderbot/iris/parsing/BooleanVectorizedFunction.java @@ -0,0 +1,81 @@ +package net.coderbot.iris.parsing; + +import kroppeb.stareval.expression.Expression; +import kroppeb.stareval.expression.VariableExpression; +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import kroppeb.stareval.function.TypedFunction; + +import java.util.Collection; + +public class BooleanVectorizedFunction implements TypedFunction { + final TypedFunction inner; + final int size; + final Parameter[] parameters; + + private final ElementAccessExpression[] vectorAccessors; + private int index; + + public BooleanVectorizedFunction(TypedFunction inner, int size) { + this.inner = inner; + this.size = size; + + Parameter[] innerTypes = inner.getParameters(); + this.parameters = new Parameter[innerTypes.length]; + this.vectorAccessors = new ElementAccessExpression[innerTypes.length]; + + for (int i = 0; i < innerTypes.length; i++) { + this.parameters[i] = new Parameter(VectorType.of((Type.Primitive) innerTypes[i].type(), size)); + this.vectorAccessors[i] = new ElementAccessExpression(innerTypes[i].type()); + } + } + + @Override + public Type getReturnType() { + return Type.Boolean; + } + + @Override + public Parameter[] getParameters() { + return this.parameters; + } + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + for (int p = 0; p < params.length; p++) { + final Expression param = params[p]; + param.evaluateTo(context, functionReturn); + this.vectorAccessors[p].vector = functionReturn.objectReturn; + } + + for (int i = 0; i < this.size; i++) { + this.index = i; + this.inner.evaluateTo(this.vectorAccessors, context, functionReturn); + if (!functionReturn.booleanReturn) + return; // if false -> return false + } + + // if all true (and thus the last one was true) -> return true + } + + class ElementAccessExpression implements Expression { + final Type parameterType; + Object vector; + + + ElementAccessExpression(Type parameterType) { + this.parameterType = parameterType; + } + + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + parameterType.getValueFromArray(vector, index, functionReturn); + } + + @Override + public void listVariables(Collection variables) { + throw new IllegalStateException(); + } + } +} diff --git a/src/main/java/net/coderbot/iris/parsing/IrisFunctions.java b/src/main/java/net/coderbot/iris/parsing/IrisFunctions.java new file mode 100644 index 000000000..7882c947e --- /dev/null +++ b/src/main/java/net/coderbot/iris/parsing/IrisFunctions.java @@ -0,0 +1,1212 @@ +package net.coderbot.iris.parsing; + +import kroppeb.stareval.expression.Expression; +import kroppeb.stareval.function.AbstractTypedFunction; +import kroppeb.stareval.function.B2BFunction; +import kroppeb.stareval.function.BB2BFunction; +import kroppeb.stareval.function.F2FFunction; +import kroppeb.stareval.function.F2IFunction; +import kroppeb.stareval.function.FF2BFunction; +import kroppeb.stareval.function.FF2FFunction; +import kroppeb.stareval.function.FFF2BFunction; +import kroppeb.stareval.function.FFF2FFunction; +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionResolver; +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.I2IFunction; +import kroppeb.stareval.function.II2BFunction; +import kroppeb.stareval.function.II2IFunction; +import kroppeb.stareval.function.III2BFunction; +import kroppeb.stareval.function.III2IFunction; +import kroppeb.stareval.function.Type; +import kroppeb.stareval.function.TypedFunction; +import kroppeb.stareval.function.TypedFunction.Parameter; +import kroppeb.stareval.function.V2FFunction; +import kroppeb.stareval.function.V2IFunction; +import org.joml.Matrix4f; +import org.joml.Vector2f; +import org.joml.Vector2i; +import org.joml.Vector3f; +import org.joml.Vector3i; +import org.joml.Vector4f; +import org.joml.Vector4i; + +import java.util.Arrays; +import java.util.Random; +import java.util.function.BiConsumer; +import java.util.function.Consumer; + +/** + * # sin(x) + * # cos(x) + * # asin(x) + * # acos(x) + * # tan(x) + * # atan(x) + * # atan2(y, x) + * # torad(deg) + * # todeg(rad) + * # min(x, y ,...) + * # max(x, y, ...) + * # clamp(x, min, max) Limits a value to be between min and max values + * # abs(x) + * # floor(x) + * # ceil(x) + * # exp(x) + * # frac(x) + * # log(x) + * # pow(x) + * # random() + * # round(x) + * # signum(x) + * # sqrt(x) + * # fmod(x, y) Similar to Math.floorMod() + * # if(cond, val, [cond2, val2, ...], val_else) Select a value based one or more conditions + * # smooth([id], val, [fadeInTime, [fadeOutTime]]) Smooths a variable with custom fade-in time. + * # The "id" must be unique, if not specified it is generated automatically + * # Default fade time is 1 sec. + *

    + * # Boolean functions + * # between(x, min, max) Check if a value is between min and max values + * # equals(x, y, epsilon) Compare two float values with error margin + * # in(x, val1, val2, ...) Check if a value equals one of several values + */ +public class IrisFunctions { + public static final FunctionResolver functions; + static final FunctionResolver.Builder builder = new FunctionResolver.Builder(); + + static { + { + // Unary ops + { + // negate + IrisFunctions.addVectorizable("negate", (a) -> -a); + IrisFunctions.add("negate", (a) -> -a); + + IrisFunctions.addUnaryOpJOML("negate", VectorType.VEC2, Vector2f::negate); + IrisFunctions.addUnaryOpJOML("negate", VectorType.VEC3, Vector3f::negate); + IrisFunctions.addUnaryOpJOML("negate", VectorType.VEC4, Vector4f::negate); + } + } + { + // binary ops + { + // add + IrisFunctions.addVectorizable("add", Integer::sum); + IrisFunctions.add("add", Float::sum); + + IrisFunctions.addBinaryOpJOML("add", VectorType.VEC2, Vector2f::add); + IrisFunctions.addBinaryOpJOML("add", VectorType.VEC3, Vector3f::add); + IrisFunctions.addBinaryOpJOML("add", VectorType.VEC4, Vector4f::add); + } + + { + // subtract + IrisFunctions.addVectorizable("subtract", (a, b) -> a - b); + IrisFunctions.add("subtract", (a, b) -> a - b); + + IrisFunctions.addBinaryOpJOML("subtract", VectorType.VEC2, Vector2f::sub); + IrisFunctions.addBinaryOpJOML("subtract", VectorType.VEC3, Vector3f::sub); + IrisFunctions.addBinaryOpJOML("subtract", VectorType.VEC4, Vector4f::sub); + } + + { + // multiply + IrisFunctions.addVectorizable("multiply", (a, b) -> a * b); + IrisFunctions.add("multiply", (a, b) -> a * b); + + IrisFunctions.addBinaryOpJOML("multiply", VectorType.VEC2, Vector2f::mul); + IrisFunctions.addBinaryOpJOML("multiply", VectorType.VEC3, Vector3f::mul); + IrisFunctions.addBinaryOpJOML("multiply", VectorType.VEC4, Vector4f::mul); + } + + { + // divide + IrisFunctions.add("divide", (a, b) -> a / b); + + IrisFunctions.addBinaryOpJOML("divide", VectorType.VEC2, Vector2f::div); + IrisFunctions.addBinaryOpJOML("divide", VectorType.VEC3, Vector3f::div); + IrisFunctions.addBinaryOpJOML("divide", VectorType.VEC4, Vector4f::div); + } + + { + // remainder + IrisFunctions.addVectorizable("remainder", (a, b) -> a % b); + IrisFunctions.add("remainder", (a, b) -> a % b); + + // IrisFunctions.addBinaryOpJOML("multiply", VectorType.VEC2, Vector2f::??); + // IrisFunctions.addBinaryOpJOML("multiply", VectorType.VEC3, Vector3f::??); + // IrisFunctions.addBinaryOpJOML("multiply", VectorType.VEC4, Vector4f::??); + } + } + { + IrisFunctions.addBooleanVectorizable("equals", (a, b) -> a == b); + IrisFunctions.add("equals", (a, b) -> a == b); + + IrisFunctions.addBinaryToBooleanOpJOML("equal", VectorType.VEC2, false, Vector2f::equals); + IrisFunctions.addBinaryToBooleanOpJOML("equal", VectorType.VEC3, false, Vector3f::equals); + IrisFunctions.addBinaryToBooleanOpJOML("equal", VectorType.VEC4, false, Vector4f::equals); + + IrisFunctions.addBooleanVectorizable("notEquals", (a, b) -> a != b); + IrisFunctions.add("notEquals", (a, b) -> a != b); + + IrisFunctions.addBinaryToBooleanOpJOML("equal", VectorType.VEC2, true, Vector2f::equals); + IrisFunctions.addBinaryToBooleanOpJOML("equal", VectorType.VEC3, true, Vector3f::equals); + IrisFunctions.addBinaryToBooleanOpJOML("equal", VectorType.VEC4, true, Vector4f::equals); + + IrisFunctions.add("lessThanOrEquals", (a, b) -> a <= b); + IrisFunctions.add("lessThanOrEquals", (a, b) -> a <= b); + + IrisFunctions.add("moreThanOrEquals", (a, b) -> a >= b); + IrisFunctions.add("moreThanOrEquals", (a, b) -> a >= b); + + IrisFunctions.add("lessThan", (a, b) -> a < b); + IrisFunctions.add("lessThan", (a, b) -> a < b); + + IrisFunctions.add("moreThan", (a, b) -> a > b); + IrisFunctions.add("moreThan", (a, b) -> a > b); + } + { + + IrisFunctions.addVectorizable("equals", (a, b) -> a == b); + IrisFunctions.addVectorizable("notEquals", (a, b) -> a != b); + IrisFunctions.addVectorizable("and", (a, b) -> a && b); + IrisFunctions.addVectorizable("or", (a, b) -> a || b); + IrisFunctions.addVectorizable("not", (a) -> !a); + } + + { + // these are also vectorizable in glsl + // http://learnwebgl.brown37.net/12_shader_language/documents/webgl-reference-card-1_0.pdf + // page 4 + + { + // Angle & Trigonometry Functions + + // optifine + IrisFunctions.add("torad", (a) -> (float) Math.toRadians(a)); + IrisFunctions.add("todeg", (a) -> (float) Math.toDegrees(a)); + + IrisFunctions.add("radians", (a) -> (float) Math.toRadians(a)); + IrisFunctions.add("degrees", (a) -> (float) Math.toDegrees(a)); + + + IrisFunctions.add("sin", (a) -> (float) Math.sin(a)); + IrisFunctions.add("cos", (a) -> (float) Math.cos(a)); + IrisFunctions.add("tan", (a) -> (float) Math.tan(a)); + IrisFunctions.add("asin", (a) -> (float) Math.asin(a)); + IrisFunctions.add("acos", (a) -> (float) Math.acos(a)); + IrisFunctions.add("atan", (a) -> (float) Math.atan(a)); + IrisFunctions.add("atan", (y, x) -> (float) Math.atan2(y, x)); + // optifine + IrisFunctions.add("atan2", (y, x) -> (float) Math.atan2(y, x)); + } + { + // Exponential Functions + IrisFunctions.add("pow", (a, b) -> (float) Math.pow(a, b)); + IrisFunctions.add("exp", (a) -> (float) Math.exp(a)); + IrisFunctions.add("log", (a) -> (float) Math.log(a)); + // java does not have built ins: https://bugs.java.com/bugdatabase/view_bug.do?bug_id=4851627 + IrisFunctions.add("exp2", (a) -> (float) Math.pow(2, a)); + IrisFunctions.add("log2", (a) -> (float) (Math.log(a) / Math.log(2))); + + IrisFunctions.add("sqrt", (a) -> (float) Math.sqrt(a)); + // IrisFunctions.addVectorizable("inversesqrt", (a) -> (float) Math.(a)); + + // optifine + IrisFunctions.add("log10", (a) -> (float) Math.log10(a)); + + // TODO the base may be static so doing `log(2, x)` would be slower than `log(x)/log(2)` + IrisFunctions.add("log", + (base, value) -> (float) (Math.log(value) / Math.log(base))); + + // cause I want consistency + IrisFunctions.add("exp10", (a) -> (float) Math.pow(10, a)); + + } + + { + // Common Functions + IrisFunctions.addVectorizable("abs", Math::abs); + IrisFunctions.add("abs", Math::abs); + + IrisFunctions.addUnaryOpJOML("abs", VectorType.VEC2, Vector2f::absolute); + IrisFunctions.addUnaryOpJOML("abs", VectorType.VEC3, Vector3f::absolute); + IrisFunctions.addUnaryOpJOML("abs", VectorType.VEC4, Vector4f::absolute); + + + IrisFunctions.add("sign", Math::signum); + // IrisFunctions.addUnaryOpJOML("abs", VectorType.VEC2, Vector2f::??); + // IrisFunctions.addUnaryOpJOML("abs", VectorType.VEC3, Vector3f::??); + // IrisFunctions.addUnaryOpJOML("abs", VectorType.VEC4, Vector4f::??); + + // optifine + IrisFunctions.add("signum", Math::signum); + // IrisFunctions.addUnaryOpJOML("abs", VectorType.VEC2, Vector2f::??); + // IrisFunctions.addUnaryOpJOML("abs", VectorType.VEC3, Vector3f::??); + // IrisFunctions.addUnaryOpJOML("abs", VectorType.VEC4, Vector4f::??); + + // because my type checker can handle (float) -> float and (float) -> int, + // floor doesn't require a cast to int, but does not cause issues if the float is too big and + // casting to float and back would change the result + + IrisFunctions.add("floor", (a) -> (float) Math.floor(a)); + IrisFunctions.add("floor", (a) -> (int) Math.floor(a)); + + IrisFunctions.addUnaryOpJOML("floor", VectorType.VEC2, Vector2f::floor); + IrisFunctions.addUnaryOpJOML("floor", VectorType.VEC3, Vector3f::floor); + IrisFunctions.addUnaryOpJOML("floor", VectorType.VEC4, Vector4f::floor); + + IrisFunctions.add("ceil", (a) -> (float) Math.ceil(a)); + IrisFunctions.add("ceil", (a) -> (int) Math.ceil(a)); + + IrisFunctions.addUnaryOpJOML("ceil", VectorType.VEC2, Vector2f::ceil); + IrisFunctions.addUnaryOpJOML("ceil", VectorType.VEC3, Vector3f::ceil); + IrisFunctions.addUnaryOpJOML("ceil", VectorType.VEC4, Vector4f::ceil); + + IrisFunctions.add("frac", (a) -> (float) (a - Math.floor(a))); + + // IrisFunctions.addUnaryOpJOML("frac", VectorType.VEC2, Vector2f::??); + // IrisFunctions.addUnaryOpJOML("frac", VectorType.VEC3, Vector3f::??); + // IrisFunctions.addUnaryOpJOML("frac", VectorType.VEC4, Vector4f::??); + + // optifine + // TODO: why does Math.round give an int? + // IrisFunctions.addVectorizable("round", (a) -> (float) Math.round(a)); + // TODO maybe add round with a specifyable precission? + // IrisFunctions.addVectorizable("round", (a) -> (int) Math.round(a)); + + + // mod is also already an operator + + // TODO: min and max require vararg for optifine compat + // TODO: glsl has vecn min(vecn a, float b) + IrisFunctions.addVectorizable("min", Math::min); + IrisFunctions.add("min", Math::min); + + IrisFunctions.addBinaryOpJOML("min", VectorType.VEC2, Vector2f::min); + IrisFunctions.addBinaryOpJOML("min", VectorType.VEC3, Vector3f::min); + IrisFunctions.addBinaryOpJOML("min", VectorType.VEC4, Vector4f::min); + + IrisFunctions.addVectorizable("max", Math::max); + IrisFunctions.add("max", Math::max); + + IrisFunctions.addBinaryOpJOML("max", VectorType.VEC2, Vector2f::max); + IrisFunctions.addBinaryOpJOML("max", VectorType.VEC3, Vector3f::max); + IrisFunctions.addBinaryOpJOML("max", VectorType.VEC4, Vector4f::max); + + { + // Fake vararg + for (int length = 3; length <= 16; length++) { + { + // min float + Type[] inputs = new Type[length]; + Arrays.fill(inputs, Type.Float); + IrisFunctions.add("min", new AbstractTypedFunction(Type.Float, inputs) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float min = functionReturn.floatReturn; + for (int i = 1; i < params.length; i++) { + params[1].evaluateTo(context, functionReturn); + min = Math.min(min, functionReturn.floatReturn); + } + functionReturn.floatReturn = min; + } + }); + } + { + // max float + Type[] inputs = new Type[length]; + Arrays.fill(inputs, Type.Float); + IrisFunctions.add("max", new AbstractTypedFunction(Type.Float, inputs) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float max = functionReturn.floatReturn; + for (int i = 1; i < params.length; i++) { + params[1].evaluateTo(context, functionReturn); + max = Math.max(max, functionReturn.floatReturn); + } + functionReturn.floatReturn = max; + } + }); + } + { + // min int + Type[] inputs = new Type[length]; + Arrays.fill(inputs, Type.Int); + IrisFunctions.addVectorizable("min", new AbstractTypedFunction(Type.Int, inputs) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + int min = functionReturn.intReturn; + for (int i = 1; i < params.length; i++) { + params[1].evaluateTo(context, functionReturn); + min = Math.min(min, functionReturn.intReturn); + } + functionReturn.intReturn = min; + } + }); + } + { + // max int + Type[] inputs = new Type[length]; + Arrays.fill(inputs, Type.Int); + IrisFunctions.addVectorizable("max", new AbstractTypedFunction(Type.Int, inputs) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + int max = functionReturn.intReturn; + for (int i = 1; i < params.length; i++) { + params[1].evaluateTo(context, functionReturn); + max = Math.max(max, functionReturn.intReturn); + } + functionReturn.intReturn = max; + } + }); + } + } + } + + // if max < min => undefined behaviour + // TODO: glsl has vecn mix(vecn x, float min, float max) + IrisFunctions.addVectorizable("clamp", + (val, min, max) -> Math.max(min, Math.min(max, val))); + IrisFunctions.add("clamp", + (val, min, max) -> Math.max(min, Math.min(max, val))); + IrisFunctions.addTernaryOpJOML("clamp", VectorType.VEC2, (val, min, max, dest) -> { + val.min(max, dest); + dest.max(min); + }); + IrisFunctions.addTernaryOpJOML("clamp", VectorType.VEC3, (val, min, max, dest) -> { + val.min(max, dest); + dest.max(min); + }); + IrisFunctions.addTernaryOpJOML("clamp", VectorType.VEC4, (val, min, max, dest) -> { + val.min(max, dest); + dest.max(min); + }); + + // TODO: glsl has vecn mix(vecn x, vecn y, float a) + IrisFunctions.add("mix", (x, y, a) -> x + (y - x) * a); + // TODO flaot vector lerp + + // TODO: glsl has vecn step(float edge, vecn x) + IrisFunctions.addVectorizable("edge", (edge, x) -> (x < edge) ? 0 : 1); + IrisFunctions.add("edge", (edge, x) -> (x < edge) ? 0 : 1); + // TODO float vector step + // TODO: smooth step + } + + { + // Geometric Functions + // TODO: Geometric Functions + } + + { + // Matrix Functions + // TODO: Add matrices + } + + { + // Vector Relational Functions + // TODO: These might clash with the operators + // Although we can have multiple return values so + } + + + { + { + // fmod + IrisFunctions.addVectorizable("fmod", Math::floorMod); + IrisFunctions.add("fmod", (a, b) -> (a % b + b) % b); + } + { + Random random = new Random(); + // randomInt(), randomInt(int bound), randomInt(int inclusiveMin, int exclusiveMax) + IrisFunctions.addVectorizable("randomInt", random::nextInt); + IrisFunctions.addVectorizable("randomInt", random::nextInt); + IrisFunctions.addVectorizable("randomInt", (a, b) -> random.nextInt(b - a) + a); + + // random, random(float min, float max) + IrisFunctions.add("random", random::nextFloat); + IrisFunctions.add("random", (min, max) -> + min + random.nextFloat() * (max - min)); + } + { + // IF + // if(boolean, primitive, primitive) -> primitive + // if(boolean, xvec, xvec) -> xvec + // TODO: REDO: if(bvec, xvec, xvec) -> xvec + // TODO: optifine requires vararg + for (Type.Primitive type : Type.AllPrimitives) { + add("if", new AbstractTypedFunction(type, new Type[]{Type.Boolean, type, type}) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + + params[ + functionReturn.booleanReturn ? 1 : 2 + ].evaluateTo(context, functionReturn); + + } + }); + } + + for (Type type : VectorType.AllVectorTypes) { + add("if", new AbstractTypedFunction(type, new Type[]{Type.Boolean, type, type}) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + + params[ + functionReturn.booleanReturn ? 1 : 2 + ].evaluateTo(context, functionReturn); + + } + }); + } + + { + // FAKE vararg + for (int length = 2; length <= 16; length++) { + for (Type.Primitive type : Type.AllPrimitives) { + Type[] params = new Type[length * 2 + 1]; + for (int i = 0; i < length * 2; i += 2) { + params[i] = Type.Boolean; + params[i + 1] = type; + } + params[length * 2] = type; + int finalLength = length * 2; + add("if", new AbstractTypedFunction(type, params) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + for (int i = 0; i < finalLength; i += 2) { + params[i].evaluateTo(context, functionReturn); + if (functionReturn.booleanReturn) { + params[i + 1].evaluateTo(context, functionReturn); + return; + } + params[finalLength].evaluateTo(context, functionReturn); + } + } + }); + } + } + } + } + { + // smooth + + // smooth(target) + builder.addDynamicFunction("smooth", Type.Float, () -> + new AbstractTypedFunction( + Type.Float, + new Parameter[]{ + new Parameter(Type.Float, false), // target + }, + 0, + false + ) { + private final SmoothFloat smoothFloat = new SmoothFloat(); + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float target = functionReturn.floatReturn; + functionReturn.floatReturn = smoothFloat.updateAndGet( + target, + 1, + 1 + ); + } + }); + + // smooth(id, target) + builder.addDynamicFunction("smooth", Type.Float, () -> + new AbstractTypedFunction( + Type.Float, + new Parameter[]{ + new Parameter(Type.Float, true), // id for backward compat with optifine + new Parameter(Type.Float, false), // target + }, + 1, + false + ) { + private final SmoothFloat smoothFloat = new SmoothFloat(); + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[1].evaluateTo(context, functionReturn); + float target = functionReturn.floatReturn; + functionReturn.floatReturn = smoothFloat.updateAndGet( + target, + 1, + 1 + ); + } + }); + + // smooth(target, fadeTime) + builder.addDynamicFunction("smooth", Type.Float, () -> + new AbstractTypedFunction( + Type.Float, + new Parameter[]{ + new Parameter(Type.Float, false), // target + new Parameter(Type.Float, false), // fadeTime + }, + 0, + false + ) { + private final SmoothFloat smoothFloat = new SmoothFloat(); + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float target = functionReturn.floatReturn; + + params[1].evaluateTo(context, functionReturn); + float fadeTime = functionReturn.floatReturn; + + functionReturn.floatReturn = smoothFloat.updateAndGet( + target, + fadeTime, + fadeTime + ); + } + }); + + // smooth(id, target, fadeTime) + builder.addDynamicFunction("smooth", Type.Float, () -> + new AbstractTypedFunction( + Type.Float, + new Parameter[]{ + new Parameter(Type.Float, true), // id for backward compat with optifine + new Parameter(Type.Float, false), // target + new Parameter(Type.Float, false), // fadeTime + }, + 1, + false + ) { + private final SmoothFloat smoothFloat = new SmoothFloat(); + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[1].evaluateTo(context, functionReturn); + float target = functionReturn.floatReturn; + + params[2].evaluateTo(context, functionReturn); + float fadeTime = functionReturn.floatReturn; + + functionReturn.floatReturn = smoothFloat.updateAndGet( + target, + fadeTime, + fadeTime + ); + } + }); + + // smooth(target, fadeUpTime, fadeDownTime) + builder.addDynamicFunction("smooth", Type.Float, () -> + new AbstractTypedFunction( + Type.Float, + new Parameter[]{ + new Parameter(Type.Float, false), // target + new Parameter(Type.Float, false), // fadeUpTime + new Parameter(Type.Float, false), // fadeDownTime + }, + 0, + false + ) { + private final SmoothFloat smoothFloat = new SmoothFloat(); + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float target = functionReturn.floatReturn; + + params[1].evaluateTo(context, functionReturn); + float fadeUpTime = functionReturn.floatReturn; + params[2].evaluateTo(context, functionReturn); + float fadeDownTime = functionReturn.floatReturn; + + functionReturn.floatReturn = smoothFloat.updateAndGet( + target, + fadeUpTime, + fadeDownTime + ); + } + }); + + // smooth(id, target, fadeUpTime, fadeDownTime) + builder.addDynamicFunction("smooth", Type.Float, () -> + new AbstractTypedFunction( + Type.Float, + new Parameter[]{ + new Parameter(Type.Float, true), // id for backward compat with optifine + new Parameter(Type.Float, false), // target + new Parameter(Type.Float, false), // fadeUpTime + new Parameter(Type.Float, false), // fadeDownTime + }, + 1, + false + ) { + private final SmoothFloat smoothFloat = new SmoothFloat(); + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[1].evaluateTo(context, functionReturn); + float target = functionReturn.floatReturn; + + params[2].evaluateTo(context, functionReturn); + float fadeUpTime = functionReturn.floatReturn; + params[3].evaluateTo(context, functionReturn); + float fadeDownTime = functionReturn.floatReturn; + + functionReturn.floatReturn = smoothFloat.updateAndGet( + target, + fadeUpTime, + fadeDownTime + ); + } + }); + } + } + } + + // casts + { + addImplicitCast(Type.Int, Type.Float, r -> r.floatReturn = r.intReturn); + // this is actually done by round i think + addExplicitCast(Type.Float, Type.Int, r -> r.intReturn = (int) r.floatReturn); + } + + // boolean functions + { + IrisFunctions.add("between", (a, min, max) -> a >= min && a <= max); + IrisFunctions.add("between", (a, min, max) -> a >= min && a <= max); + + IrisFunctions.add("equals", (a, b, epsilon) -> Math.abs(a - b) <= epsilon); + + // TODO: varargs + // TODO also for other types + { + // FAKE vararg + for (int length = 2; length <= 32; length++) { + Type[] params = new Type[length]; + Arrays.fill(params, Type.Float); + int finalLength = length; + IrisFunctions.add("in", new AbstractTypedFunction( + Type.Boolean, + params + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float value = functionReturn.floatReturn; + for (int i = 1; i < finalLength; i++) { + params[i].evaluateTo(context, functionReturn); + if (functionReturn.floatReturn == value) { + functionReturn.booleanReturn = true; + return; + } + } + functionReturn.booleanReturn = false; + } + }); + } + } + } + + // create vectors + { + for (Type.Primitive type : new Type.Primitive[]{Type.Boolean, Type.Int}) { + for (int size = 2; size <= 4; size++) { + TypedFunction function = new VectorConstructor(type, size); + // TODO make it possible to do `vec3(vec2(0),0)` + add( + Character.toLowerCase( + type.getClass().getSimpleName().charAt(0) + ) + "vec" + size, function); + } + } + + add("vec2", new AbstractTypedFunction( + VectorType.VEC2, + new Type[]{Type.Float, Type.Float} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float x = functionReturn.floatReturn; + + params[1].evaluateTo(context, functionReturn); + float y = functionReturn.floatReturn; + + // TODO: this can't be cached atm. If we swap this to a function provider we could + functionReturn.objectReturn = new Vector2f(x, y); + } + }); + + add("vec3", new AbstractTypedFunction( + VectorType.VEC3, + new Type[]{Type.Float, Type.Float, Type.Float} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float x = functionReturn.floatReturn; + + params[1].evaluateTo(context, functionReturn); + float y = functionReturn.floatReturn; + + params[2].evaluateTo(context, functionReturn); + float z = functionReturn.floatReturn; + + // TODO: this can't be cached atm. If we swap this to a function provider we could + functionReturn.objectReturn = new Vector3f(x, y, z); + } + }); + + add("vec4", new AbstractTypedFunction( + VectorType.VEC4, + new Type[]{Type.Float, Type.Float, Type.Float, Type.Float} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + float x = functionReturn.floatReturn; + + params[1].evaluateTo(context, functionReturn); + float y = functionReturn.floatReturn; + + params[2].evaluateTo(context, functionReturn); + float z = functionReturn.floatReturn; + + params[3].evaluateTo(context, functionReturn); + float w = functionReturn.floatReturn; + + // TODO: this can't be cached atm. If we swap this to a function provider we could + functionReturn.objectReturn = new Vector4f(x, y, z, w); + } + }); + } + + // accessors + { + // is this the best way to do these? + String[][] accessNames = new String[][]{ + new String[]{"0", "r", "x", "s"}, + new String[]{"1", "g", "y", "t"}, + new String[]{"2", "b", "z", "p"}, + new String[]{"3", "a", "w", "q"} + }; + + { + // access$0 + for (String access : accessNames[0]) { + IrisFunctions.add("", new AbstractTypedFunction( + Type.Float, + new Type[]{VectorType.VEC2} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = ((Vector2f) functionReturn.objectReturn).x; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Int, + new Type[]{VectorType.I_VEC2} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = ((Vector2i) functionReturn.objectReturn).x; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Float, + new Type[]{VectorType.VEC3} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = ((Vector3f) functionReturn.objectReturn).x; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Int, + new Type[]{VectorType.I_VEC3} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = ((Vector3i) functionReturn.objectReturn).x; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Float, + new Type[]{VectorType.VEC4} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = ((Vector4f) functionReturn.objectReturn).x; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Int, + new Type[]{VectorType.I_VEC4} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = ((Vector4i) functionReturn.objectReturn).x; + } + }); + } + } + + { + // access$1 + for (String access : accessNames[1]) { + IrisFunctions.add("", new AbstractTypedFunction( + Type.Float, + new Type[]{VectorType.VEC2} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = ((Vector2f) functionReturn.objectReturn).y; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Int, + new Type[]{VectorType.I_VEC2} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = ((Vector2i) functionReturn.objectReturn).y; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Float, + new Type[]{VectorType.VEC3} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = ((Vector3f) functionReturn.objectReturn).y; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Int, + new Type[]{VectorType.I_VEC3} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = ((Vector3i) functionReturn.objectReturn).y; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Float, + new Type[]{VectorType.VEC4} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = ((Vector4f) functionReturn.objectReturn).y; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Int, + new Type[]{VectorType.I_VEC4} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = ((Vector4i) functionReturn.objectReturn).y; + } + }); + } + } + + { + // access$2 + for (String access : accessNames[2]) { + IrisFunctions.add("", new AbstractTypedFunction( + Type.Float, + new Type[]{VectorType.VEC3} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = ((Vector3f) functionReturn.objectReturn).z; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Int, + new Type[]{VectorType.I_VEC3} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = ((Vector3i) functionReturn.objectReturn).z; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Float, + new Type[]{VectorType.VEC4} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = ((Vector4f) functionReturn.objectReturn).z; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Int, + new Type[]{VectorType.I_VEC4} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = ((Vector4i) functionReturn.objectReturn).z; + } + }); + } + } + + { + // access$3 + for (String access : accessNames[3]) { + IrisFunctions.add("", new AbstractTypedFunction( + Type.Float, + new Type[]{VectorType.VEC4} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.floatReturn = ((Vector4f) functionReturn.objectReturn).w; + } + }); + + IrisFunctions.add("", new AbstractTypedFunction( + Type.Int, + new Type[]{VectorType.I_VEC4} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.intReturn = ((Vector4i) functionReturn.objectReturn).w; + } + }); + } + } + + { + // matrix access + for (int i = 0; i < 4; i++) { + for (String access : accessNames[i]) { + int finalI = i; + IrisFunctions.add("", new AbstractTypedFunction( + VectorType.VEC4, + new Type[]{MatrixType.MAT4} + ) { + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + functionReturn.objectReturn = ((Matrix4f) functionReturn.objectReturn).getColumn(finalI, new Vector4f()); + } + }); + } + } + } + } + + functions = builder.build(); + } + + static void addVectorized(String name, T function) { + if (function.getReturnType() instanceof Type.Primitive) { + add(name, new VectorizedFunction(function, 2)); + add(name, new VectorizedFunction(function, 3)); + add(name, new VectorizedFunction(function, 4)); + } else { + throw new IllegalArgumentException(name + " is not vectorizable"); + } + } + + static void addVectorizable(String name, T function) { + add(name, function); + addVectorized(name, function); + } + + static void addBooleanVectorizable(String name, T function) { + assert function.getReturnType().equals(Type.Boolean); + add(name, function); + if (function.getReturnType() instanceof Type.Primitive) { + add(name, new BooleanVectorizedFunction(function, 2)); + add(name, new BooleanVectorizedFunction(function, 3)); + add(name, new BooleanVectorizedFunction(function, 4)); + } else { + throw new IllegalArgumentException(name + " is not vectorizable"); + } + } + + static void addUnaryOpJOML(String name, VectorType.JOMLVector type, BiConsumer function) { + builder.add(name, new AbstractTypedFunction( + type, + new Type[]{type} + ) { + final private T vector = type.create(); + + @SuppressWarnings("unchecked") + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + T a = (T) functionReturn.objectReturn; + + function.accept(a, this.vector); + functionReturn.objectReturn = this.vector; + } + }); + } + + static void addBinaryOpJOML(String name, VectorType.JOMLVector type, TriConsumer function) { + builder.add(name, new AbstractTypedFunction( + type, + new Type[]{type, type} + ) { + final private T vector = type.create(); + + @SuppressWarnings("unchecked") + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + T a = (T) functionReturn.objectReturn; + + params[1].evaluateTo(context, functionReturn); + T b = (T) functionReturn.objectReturn; + + function.accept(a, b, this.vector); + functionReturn.objectReturn = this.vector; + } + }); + } + + static void addTernaryOpJOML(String name, VectorType.JOMLVector type, QuadConsumer function) { + builder.add(name, new AbstractTypedFunction( + type, + new Type[]{type, type, type} + ) { + final private T vector = type.create(); + + @SuppressWarnings("unchecked") + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + T a = (T) functionReturn.objectReturn; + + params[1].evaluateTo(context, functionReturn); + T b = (T) functionReturn.objectReturn; + + params[2].evaluateTo(context, functionReturn); + T c = (T) functionReturn.objectReturn; + + function.accept(a, b, c, this.vector); + functionReturn.objectReturn = this.vector; + } + }); + } + + static void addBinaryToBooleanOpJOML( + String name, + VectorType.JOMLVector type, + boolean inverted, + ObjectObject2BooleanFunction function) { + builder.add(name, new AbstractTypedFunction( + type, + new Type[]{type, type} + ) { + @SuppressWarnings("unchecked") + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + T a = (T) functionReturn.objectReturn; + + params[1].evaluateTo(context, functionReturn); + T b = (T) functionReturn.objectReturn; + + functionReturn.objectReturn = function.apply(a, b) != inverted; + } + }); + } + + static void add(String name, T function) { + builder.add(name, function); + } + + static void addCast(final String name, final Type from, final Type to, final Consumer function) { + add(name, new TypedFunction() { + @Override + public Type getReturnType() { + return to; + } + + @Override + public Parameter[] getParameters() { + return new Parameter[]{new Parameter(from)}; + } + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + params[0].evaluateTo(context, functionReturn); + function.accept(functionReturn); + } + }); + } + + static void addImplicitCast(final Type from, final Type to, final Consumer function) { + addCast("", from, to, function); + addExplicitCast(from, to, function); + } + + static void addExplicitCast(final Type from, final Type to, final Consumer function) { + addCast("to" + to.getClass().getSimpleName(), from, to, function); + } + + public static void main(String[] args) { + functions.logAllFunctions(); + } + + interface ObjectObject2BooleanFunction { + boolean apply(T t, U u); + } + + interface TriConsumer { + void accept(T t, U u, V v); + } + + interface QuadConsumer { + void accept(T t, U u, V v, W w); + } +} + diff --git a/src/main/java/net/coderbot/iris/parsing/IrisOptions.java b/src/main/java/net/coderbot/iris/parsing/IrisOptions.java new file mode 100644 index 000000000..8fc515ea8 --- /dev/null +++ b/src/main/java/net/coderbot/iris/parsing/IrisOptions.java @@ -0,0 +1,53 @@ +package net.coderbot.iris.parsing; + +import kroppeb.stareval.parser.BinaryOp; +import kroppeb.stareval.parser.ParserOptions; +import kroppeb.stareval.parser.UnaryOp; + +public class IrisOptions { + public static final ParserOptions options; + static final BinaryOp Multiply = new BinaryOp("multiply", 0); + static final BinaryOp Divide = new BinaryOp("divide", 0); + static final BinaryOp Remainder = new BinaryOp("remainder", 0); + static final BinaryOp Add = new BinaryOp("add", 1); + static final BinaryOp Subtract = new BinaryOp("subtract", 1); + static final BinaryOp Equals = new BinaryOp("equals", 2); + static final BinaryOp NotEquals = new BinaryOp("notEquals", 2); + static final BinaryOp LessThan = new BinaryOp("lessThan", 2); + static final BinaryOp MoreThan = new BinaryOp("moreThan", 2); + static final BinaryOp LessThanOrEquals = new BinaryOp("lessThanOrEquals", 2); + static final BinaryOp MoreThanOrEquals = new BinaryOp("moreThanOrEquals", 2); + static final BinaryOp And = new BinaryOp("and", 3); + static final BinaryOp Or = new BinaryOp("or", 3); + static final UnaryOp Not = new UnaryOp("not"); + static final UnaryOp Negate = new UnaryOp("negate"); + + static { + final ParserOptions.Builder builder = new ParserOptions.Builder(); + builder.addBinaryOp("*", Multiply); + builder.addBinaryOp("/", Divide); + builder.addBinaryOp("%", Remainder); + + builder.addBinaryOp("+", Add); + builder.addBinaryOp("-", Subtract); + + builder.addBinaryOp("==", Equals); + builder.addBinaryOp("!=", NotEquals); + builder.addBinaryOp("<", LessThan); + builder.addBinaryOp(">", MoreThan); + builder.addBinaryOp("<=", LessThanOrEquals); + builder.addBinaryOp(">=", MoreThanOrEquals); + + builder.addBinaryOp("≠", NotEquals); + builder.addBinaryOp("≤", LessThanOrEquals); + builder.addBinaryOp("≥", MoreThanOrEquals); + + builder.addBinaryOp("&&", And); + builder.addBinaryOp("||", Or); + + builder.addUnaryOp("!", Not); + builder.addUnaryOp("-", Negate); + + options = builder.build(); + } +} diff --git a/src/main/java/net/coderbot/iris/parsing/MatrixType.java b/src/main/java/net/coderbot/iris/parsing/MatrixType.java new file mode 100644 index 000000000..1bf12e723 --- /dev/null +++ b/src/main/java/net/coderbot/iris/parsing/MatrixType.java @@ -0,0 +1,24 @@ +package net.coderbot.iris.parsing; + +import kroppeb.stareval.function.Type; +import org.joml.Matrix2f; +import org.joml.Matrix3f; +import org.joml.Matrix4f; + +import java.util.function.Supplier; + +public class MatrixType extends Type.ObjectType { + public static final MatrixType MAT4 = new MatrixType<>("mat4", Matrix4f::new); + public static MatrixType MAT2 = new MatrixType<>("mat2", Matrix2f::new); + public static MatrixType MAT3 = new MatrixType<>("mat3", Matrix3f::new); + final String name; + + public MatrixType(String name, Supplier supplier) { + this.name = name; + } + + @Override + public String toString() { + return name; + } +} diff --git a/src/main/java/net/coderbot/iris/parsing/SmoothFloat.java b/src/main/java/net/coderbot/iris/parsing/SmoothFloat.java new file mode 100644 index 000000000..804cc7562 --- /dev/null +++ b/src/main/java/net/coderbot/iris/parsing/SmoothFloat.java @@ -0,0 +1,121 @@ +package net.coderbot.iris.parsing; + +import net.coderbot.iris.uniforms.SystemTimeUniforms; + +/** + * An implementation of basic exponential smoothing that converts a sequence of unsmoothed values into a sequence of + * smoothed values. + * + * @see + * Wikipedia: Basic (simple) exponential smoothing (Holt linear) + */ +public class SmoothFloat { + /** + * Natural logarithm of 2, ie. {@code ln(2)} + */ + private static final double LN_OF_2 = Math.log(2.0); + + /** + * An accumulator for smoothed values. + */ + private float accumulator; + + /** + * Tracks whether an initial value has already been generated, because otherwise there will be nothing to smooth + * with. + */ + private boolean hasInitialValue; + private float cachedHalfLifeUp; + private float cachedDecayUp; + private float cachedHalfLifeDown; + private float cachedDecayDown; + + /** + * Computes an exponential decay factor based on the given decay constant and time value + * + * @param k the decay constant, derived from the half life + * @param t the time that has passed since the decay started + */ + private static float exponentialDecayFactor(float k, float t) { + // https://en.wikipedia.org/wiki/Exponential_decay + // e^(-kt) + return (float) Math.exp(-k * t); + } + + /** + * Computes a linearly interpolated value between v0 and v1 + * + * @param v0 the starting value (t = 0) + * @param v1 the ending value (t = 1) + * @param t the time/progress value - should be in the range of 0.0 to 1.0 + */ + private static float lerp(float v0, float v1, float t) { + // https://en.wikipedia.org/wiki/Linear_interpolation + return (1 - t) * v0 + t * v1; + } + + /** + * Takes one value from the unsmoothed value sequence, and smooths it into our accumulator + */ + public float updateAndGet(float value, float halfLifeUp, float halfLifeDown) { + if (halfLifeUp != cachedHalfLifeUp) { + cachedHalfLifeUp = halfLifeUp; + if (halfLifeUp == 0.0f) { + cachedDecayUp = 0; + } else { + cachedDecayUp = computeDecay(halfLifeUp * 0.1F); + } + } + + if (halfLifeDown != cachedHalfLifeDown) { + cachedHalfLifeDown = halfLifeDown; + if (halfLifeDown == 0.0f) { + cachedDecayDown = 0; + } else { + cachedDecayDown = computeDecay(halfLifeDown * 0.1F); + } + } + + if (!hasInitialValue) { + // There is no smoothing on the first value. + // This is not an optimal approach to choosing the initial value: + // https://en.wikipedia.org/wiki/Exponential_smoothing#Choosing_the_initial_smoothed_value + // + // However, it works well enough for now. + accumulator = value; + hasInitialValue = true; + + return accumulator; + } + + // Implements the basic variant of exponential smoothing + // https://en.wikipedia.org/wiki/Exponential_smoothing#Basic_(simple)_exponential_smoothing_(Holt_linear) + + // 𝚫t + float lastFrameTime = SystemTimeUniforms.TIMER.getLastFrameTime(); + + float decay = value > this.accumulator ? cachedDecayUp : cachedDecayDown; + + if (decay == 0.0f) { + accumulator = value; + return accumulator; + } + + // Compute the smoothing factor based on our + // α = 1 - e^(-𝚫t/τ) = 1 - e^(-k𝚫t) + float smoothingFactor = 1.0f - exponentialDecayFactor(decay, lastFrameTime); + + // sₜ = αxₜ + (1 - α)sₜ₋₁ + accumulator = lerp(accumulator, value, smoothingFactor); + + return accumulator; + } + + private float computeDecay(float halfLife) { + // Compute the decay constant from the half life + // https://en.wikipedia.org/wiki/Exponential_decay#Measuring_rates_of_decay + // https://en.wikipedia.org/wiki/Exponential_smoothing#Time_constant + // k = 1 / τ + return (float) (1.0f / (halfLife / LN_OF_2)); + } +} diff --git a/src/main/java/net/coderbot/iris/parsing/VectorConstructor.java b/src/main/java/net/coderbot/iris/parsing/VectorConstructor.java new file mode 100644 index 000000000..a9fca6b76 --- /dev/null +++ b/src/main/java/net/coderbot/iris/parsing/VectorConstructor.java @@ -0,0 +1,32 @@ +package net.coderbot.iris.parsing; + +import kroppeb.stareval.Util; +import kroppeb.stareval.expression.Expression; +import kroppeb.stareval.function.AbstractTypedFunction; +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; + +import java.util.Arrays; + +public class VectorConstructor extends AbstractTypedFunction { + + public VectorConstructor(Type inner, int size) { + super( + new VectorType.ArrayVector(inner, size), + Util.make(new Type[size], params -> Arrays.fill(params, inner)) + ); + } + + @Override + public VectorType.ArrayVector getReturnType() { + return (VectorType.ArrayVector) super.getReturnType(); + } + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn + functionReturn) { + VectorType.ArrayVector vectorType = this.getReturnType(); + vectorType.map(params, context, functionReturn, (i, p, ctx, fr) -> p[i].evaluateTo(ctx, fr)); + } +} diff --git a/src/main/java/net/coderbot/iris/parsing/VectorType.java b/src/main/java/net/coderbot/iris/parsing/VectorType.java new file mode 100644 index 000000000..a781dd787 --- /dev/null +++ b/src/main/java/net/coderbot/iris/parsing/VectorType.java @@ -0,0 +1,125 @@ +package net.coderbot.iris.parsing; + +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import org.joml.Vector2f; +import org.joml.Vector2i; +import org.joml.Vector3f; +import org.joml.Vector3i; +import org.joml.Vector4f; +import org.joml.Vector4i; + +import java.util.Arrays; +import java.util.Objects; +import java.util.function.Supplier; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +abstract public class VectorType extends Type.ObjectType { + public static final JOMLVector VEC2 = new JOMLVector<>("vec2", Vector2f::new); + public static final JOMLVector VEC3 = new JOMLVector<>("vec3", Vector3f::new); + public static final JOMLVector VEC4 = new JOMLVector<>("vec4", Vector4f::new); + public static final JOMLVector I_VEC2 = new JOMLVector<>("ivec2", Vector2i::new); + public static final JOMLVector I_VEC3 = new JOMLVector<>("ivec3", Vector3i::new); + public static final JOMLVector I_VEC4 = new JOMLVector<>("ivec4", Vector4i::new); + public static final VectorType B_VEC2 = new ArrayVector(Type.Boolean, 2); + public static final VectorType B_VEC3 = new ArrayVector(Type.Boolean, 3); + public static final VectorType B_VEC4 = new ArrayVector(Type.Boolean, 4); + public static final ArrayVector[] AllArrayVectorTypes = Stream.of(Type.Int, Type.Boolean) + .flatMap(type -> + IntStream + .rangeClosed(2, 4) + .mapToObj(i -> new ArrayVector(type, i)) + ).toArray(ArrayVector[]::new); + public static final VectorType[] AllVectorTypes = Arrays.stream(Type.AllPrimitives) + .flatMap(type -> + IntStream + .rangeClosed(2, 4) + .mapToObj(i -> VectorType.of(type, i)) + ).toArray(VectorType[]::new); + + public static VectorType of(Type.Primitive primitive, int size) { + if (primitive.equals(Type.Float)) { + return switch (size) { + case 2 -> VEC2; + case 3 -> VEC3; + case 4 -> VEC4; + default -> throw new IllegalArgumentException("not a valid vector"); + }; + } else { + return new ArrayVector(primitive, size); + } + } + + public static class ArrayVector extends VectorType { + private final Type inner; + private final int size; + + public ArrayVector(Type inner, int size) { + this.inner = inner; + this.size = size; + } + + public Object createObject() { + return this.inner.createArray(this.size); + } + + public void setValue(Object vector, int index, FunctionReturn functionReturn) { + this.inner.setValueFromReturn(vector, index, functionReturn); + } + + public void getValue(Object vector, int index, FunctionReturn functionReturn) { + this.inner.getValueFromArray(vector, index, functionReturn); + } + + public void map(T1 item1, T2 item2, FunctionReturn functionReturn, IntObjectObjectObjectConsumer mapper) { + Object array = this.createObject(); + for (int i = 0; i < this.size; i++) { + mapper.accept(i, item1, item2, functionReturn); + this.setValue(array, i, functionReturn); + } + functionReturn.objectReturn = array; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof ArrayVector that)) return false; + return size == that.size && inner.equals(that.inner); + } + + @Override + public int hashCode() { + return Objects.hash(inner, size); + } + + @Override + public String toString() { + String base = this.inner.equals(Type.Float) ? "" : this.inner.toString().substring(0, 1); + return "__" + base + "vec" + this.size; + } + + public interface IntObjectObjectObjectConsumer { + void accept(int a, TB b, TC c, TD d); + } + } + + public static class JOMLVector extends VectorType { + private final String name; + private final Supplier supplier; + + public JOMLVector(String name, Supplier supplier) { + this.name = name; + this.supplier = supplier; + } + + @Override + public String toString() { + return this.name; + } + + public T create() { + return this.supplier.get(); + } + } +} diff --git a/src/main/java/net/coderbot/iris/parsing/VectorizedFunction.java b/src/main/java/net/coderbot/iris/parsing/VectorizedFunction.java new file mode 100644 index 000000000..d43e67ab6 --- /dev/null +++ b/src/main/java/net/coderbot/iris/parsing/VectorizedFunction.java @@ -0,0 +1,83 @@ +package net.coderbot.iris.parsing; + +import kroppeb.stareval.expression.Expression; +import kroppeb.stareval.expression.VariableExpression; +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import kroppeb.stareval.function.TypedFunction; + +import java.util.Collection; + +public class VectorizedFunction implements TypedFunction { + final TypedFunction inner; + final int size; + final VectorType.ArrayVector returnType; + final Parameter[] parameters; + + private final ElementAccessExpression[] vectorAccessors; + private int index; + private final VectorType.ArrayVector.IntObjectObjectObjectConsumer mapper = + (i, self, ctx, fr) -> { + self.index = i; + self.inner.evaluateTo(self.vectorAccessors, ctx, fr); + }; + + public VectorizedFunction(TypedFunction inner, int size) { + this.inner = inner; + this.size = size; + + this.returnType = new VectorType.ArrayVector(inner.getReturnType(), size); + + Parameter[] innerTypes = inner.getParameters(); + this.parameters = new Parameter[innerTypes.length]; + this.vectorAccessors = new ElementAccessExpression[innerTypes.length]; + + for (int i = 0; i < innerTypes.length; i++) { + this.parameters[i] = new Parameter(new VectorType.ArrayVector(innerTypes[i].type(), size)); + this.vectorAccessors[i] = new ElementAccessExpression(innerTypes[i].type()); + } + } + + @Override + public Type getReturnType() { + return this.returnType; + } + + @Override + public Parameter[] getParameters() { + return this.parameters; + } + + @Override + public void evaluateTo(Expression[] params, FunctionContext context, FunctionReturn functionReturn) { + for (int p = 0; p < params.length; p++) { + final Expression param = params[p]; + param.evaluateTo(context, functionReturn); + this.vectorAccessors[p].vector = functionReturn.objectReturn; + } + + returnType.map(this, context, functionReturn, this.mapper); + } + + class ElementAccessExpression implements Expression { + final Type parameterType; + Object vector; + + + ElementAccessExpression(Type parameterType) { + this.parameterType = parameterType; + } + + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + parameterType.getValueFromArray(vector, index, functionReturn); + } + + + @Override + public void listVariables(Collection variables) { + throw new IllegalStateException(); + } + } +} diff --git a/src/main/java/net/coderbot/iris/pipeline/DeferredWorldRenderingPipeline.java b/src/main/java/net/coderbot/iris/pipeline/DeferredWorldRenderingPipeline.java index 440ea7dea..0c50b41ce 100644 --- a/src/main/java/net/coderbot/iris/pipeline/DeferredWorldRenderingPipeline.java +++ b/src/main/java/net/coderbot/iris/pipeline/DeferredWorldRenderingPipeline.java @@ -57,6 +57,7 @@ import net.coderbot.iris.texture.pbr.PBRTextureManager; import net.coderbot.iris.texture.pbr.PBRType; import net.coderbot.iris.uniforms.CommonUniforms; import net.coderbot.iris.uniforms.FrameUpdateNotifier; +import net.coderbot.iris.uniforms.custom.CustomUniforms; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.EntityRenderer; import net.minecraft.client.renderer.OpenGlHelper; @@ -109,6 +110,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R @Nullable private final ShadowRenderer shadowRenderer; + private final CustomUniforms customUniforms; + private final int shadowMapResolution; private final CompositeRenderer deferredRenderer; private final CompositeRenderer compositeRenderer; @@ -195,6 +198,10 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R forcedShadowRenderDistanceChunks = OptionalInt.empty(); } + this.customUniforms = programs.getPack().customUniforms.build( + holder -> CommonUniforms.addNonDynamicUniforms(holder, programs.getPack().getIdMap(), programs.getPackDirectives(), this.updateNotifier) + ); + // TODO: BlockStateIdMap BlockRenderingSettings.INSTANCE.setBlockMatches(BlockMaterialMapping.createBlockStateIdMap(programs.getPack().getIdMap().getBlockProperties())); BlockRenderingSettings.INSTANCE.setBlockTypeIds(BlockMaterialMapping.createBlockTypeMap(programs.getPack().getIdMap().getBlockRenderTypeMap())); @@ -235,25 +242,25 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R this.prepareRenderer = new CompositeRenderer(programs.getPackDirectives(), programs.getPrepare(), programs.getPrepareCompute(), renderTargets, customTextureManager.getNoiseTexture(), updateNotifier, centerDepthSampler, flipper, shadowTargetsSupplier, customTextureManager.getCustomTextureIdMap(TextureStage.PREPARE), - programs.getPackDirectives().getExplicitFlips("prepare_pre")); + programs.getPackDirectives().getExplicitFlips("prepare_pre"), customUniforms); flippedAfterPrepare = flipper.snapshot(); this.deferredRenderer = new CompositeRenderer(programs.getPackDirectives(), programs.getDeferred(), programs.getDeferredCompute(), renderTargets, customTextureManager.getNoiseTexture(), updateNotifier, centerDepthSampler, flipper, shadowTargetsSupplier, customTextureManager.getCustomTextureIdMap(TextureStage.DEFERRED), - programs.getPackDirectives().getExplicitFlips("deferred_pre")); + programs.getPackDirectives().getExplicitFlips("deferred_pre"), customUniforms); flippedAfterTranslucent = flipper.snapshot(); this.compositeRenderer = new CompositeRenderer(programs.getPackDirectives(), programs.getComposite(), programs.getCompositeCompute(), renderTargets, customTextureManager.getNoiseTexture(), updateNotifier, centerDepthSampler, flipper, shadowTargetsSupplier, customTextureManager.getCustomTextureIdMap(TextureStage.COMPOSITE_AND_FINAL), - programs.getPackDirectives().getExplicitFlips("composite_pre")); + programs.getPackDirectives().getExplicitFlips("composite_pre"), customUniforms); this.finalPassRenderer = new FinalPassRenderer(programs, renderTargets, customTextureManager.getNoiseTexture(), updateNotifier, flipper.snapshot(), centerDepthSampler, shadowTargetsSupplier, customTextureManager.getCustomTextureIdMap(TextureStage.COMPOSITE_AND_FINAL), - this.compositeRenderer.getFlippedAtLeastOnceFinal()); + this.compositeRenderer.getFlippedAtLeastOnceFinal(), customUniforms); // [(textured=false,lightmap=false), (textured=true,lightmap=false), (textured=true,lightmap=true)] ProgramId[] ids = new ProgramId[] { @@ -285,7 +292,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R Map, Pass> cachedPasses = new HashMap<>(); - this.shadowComputes = createShadowComputes(programs.getShadowCompute(), programs); + this.shadowComputes = createShadowComputes(programs.getShadowCompute()); this.table = new ProgramTable<>((condition, availability) -> { int idx; @@ -355,6 +362,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R this.shadowRenderer = null; } + this.customUniforms.optimise(); + this.clearPassesFull = ClearPassCreator.createClearPasses(renderTargets, true, programs.getPackDirectives().getRenderTargetDirectives()); this.clearPasses = ClearPassCreator.createClearPasses(renderTargets, false, programs.getPackDirectives().getRenderTargetDirectives()); @@ -418,7 +427,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R }; this.sodiumTerrainPipeline = new SodiumTerrainPipeline(this, programs, createTerrainSamplers, shadowRenderer == null ? null : createShadowTerrainSamplers, createTerrainImages, - shadowRenderer == null ? null : createShadowTerrainImages); + shadowRenderer == null ? null : createShadowTerrainImages, this.customUniforms); } private RenderTargets getRenderTargets() { @@ -598,13 +607,13 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R ProgramBuilder builder = ProgramBuilder.begin(source.getName(), vertex, geometry, fragment, IrisSamplers.WORLD_RESERVED_TEXTURE_UNITS); - return createPassInner(builder, source.getParent().getPack().getIdMap(), source.getDirectives(), source.getParent().getPackDirectives(), availability, shadow, id); + return createPassInner(builder, source.getDirectives(), availability, shadow, id); } - private Pass createPassInner(ProgramBuilder builder, IdMap map, ProgramDirectives programDirectives, - PackDirectives packDirectives, InputAvailability availability, boolean shadow, ProgramId id) { + private Pass createPassInner(ProgramBuilder builder, ProgramDirectives programDirectives, InputAvailability availability, boolean shadow, ProgramId id) { - CommonUniforms.addCommonUniforms(builder, map, packDirectives, updateNotifier); + CommonUniforms.addDynamicUniforms(builder); + this.customUniforms.assignTo(builder); Supplier> flipped; @@ -674,8 +683,12 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R } }); - return new Pass(builder.build(), framebufferBeforeTranslucents, framebufferAfterTranslucents, alphaTestOverride, - programDirectives.getBlendModeOverride().orElse(id.getBlendModeOverride()), bufferOverrides, shadow); + Pass pass = new Pass(builder.build(), framebufferBeforeTranslucents, framebufferAfterTranslucents, alphaTestOverride, + programDirectives.getBlendModeOverride().orElse(id.getBlendModeOverride()), bufferOverrides, shadow); + + this.customUniforms.mapholderToPass(builder, pass); + + return pass; } private boolean isPostChain; @@ -751,6 +764,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R program.use(); } + DeferredWorldRenderingPipeline.this.customUniforms.push(this); + if (alphaTestOverride != null) { alphaTestOverride.apply(); } else { @@ -875,6 +890,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R for (ComputeProgram computeProgram : shadowComputes) { if (computeProgram != null) { + computeProgram.use(); + this.customUniforms.push(computeProgram); computeProgram.dispatch(shadowMapResolution, shadowMapResolution); } } @@ -937,7 +954,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R Minecraft.getMinecraft().getFramebuffer().bindFramebuffer(true); } - private ComputeProgram[] createShadowComputes(ComputeSource[] compute, ProgramSet programSet) { + private ComputeProgram[] createShadowComputes(ComputeSource[] compute) { ComputeProgram[] programs = new ComputeProgram[compute.length]; for (int i = 0; i < programs.length; i++) { ComputeSource source = compute[i]; @@ -953,7 +970,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R throw new RuntimeException("Shader compilation failed!", e); } - CommonUniforms.addCommonUniforms(builder, programSet.getPack().getIdMap(), programSet.getPackDirectives(), updateNotifier); + CommonUniforms.addDynamicUniforms(builder); + this.customUniforms.assignTo(builder); Supplier> flipped; @@ -980,6 +998,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R programs[i] = builder.buildCompute(); + this.customUniforms.mapholderToPass(builder, programs[i]); + programs[i].setWorkGroupInfo(source.getWorkGroupRelative(), source.getWorkGroups()); } } @@ -1099,6 +1119,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R updateNotifier.onNewFrame(); + this.customUniforms.update(); + // Get ready for world rendering prepareRenderTargets(); diff --git a/src/main/java/net/coderbot/iris/pipeline/SodiumTerrainPipeline.java b/src/main/java/net/coderbot/iris/pipeline/SodiumTerrainPipeline.java index 946bf78ab..500a2e2dd 100644 --- a/src/main/java/net/coderbot/iris/pipeline/SodiumTerrainPipeline.java +++ b/src/main/java/net/coderbot/iris/pipeline/SodiumTerrainPipeline.java @@ -1,5 +1,6 @@ package net.coderbot.iris.pipeline; +import lombok.Getter; import net.coderbot.iris.gl.program.ProgramImages; import net.coderbot.iris.gl.program.ProgramSamplers; import net.coderbot.iris.gl.program.ProgramUniforms; @@ -9,6 +10,7 @@ import net.coderbot.iris.shaderpack.ProgramSet; import net.coderbot.iris.shaderpack.ProgramSource; import net.coderbot.iris.uniforms.CommonUniforms; import net.coderbot.iris.uniforms.builtin.BuiltinReplacementUniforms; +import net.coderbot.iris.uniforms.custom.CustomUniforms; import java.util.Map; import java.util.Objects; @@ -28,6 +30,9 @@ public class SodiumTerrainPipeline { //GlFramebuffer framebuffer; ProgramSet programSet; + @Getter + private final CustomUniforms customUniforms; + private final WorldRenderingPipeline parent; private final IntFunction createTerrainSamplers; @@ -40,7 +45,7 @@ public class SodiumTerrainPipeline { ProgramSet programSet, IntFunction createTerrainSamplers, IntFunction createShadowSamplers, IntFunction createTerrainImages, - IntFunction createShadowImages) { + IntFunction createShadowImages, CustomUniforms customUniforms) { this.parent = Objects.requireNonNull(parent); Optional terrainSource = first(programSet.getGbuffersTerrain(), programSet.getGbuffersTexturedLit(), programSet.getGbuffersTextured(), programSet.getGbuffersBasic()); @@ -49,6 +54,8 @@ public class SodiumTerrainPipeline { this.programSet = programSet; + this.customUniforms = customUniforms; + terrainSource.ifPresent(sources -> { Map result = TransformPatcher.patchSodiumTerrain( sources.getVertexSource().orElse(null), @@ -130,13 +137,14 @@ public class SodiumTerrainPipeline { return shadowFragment; } - public ProgramUniforms initUniforms(int programId) { + public ProgramUniforms.Builder initUniforms(int programId) { ProgramUniforms.Builder uniforms = ProgramUniforms.builder("", programId); - CommonUniforms.addCommonUniforms(uniforms, programSet.getPack().getIdMap(), programSet.getPackDirectives(), parent.getFrameUpdateNotifier()); - BuiltinReplacementUniforms.addBuiltinReplacementUniforms(uniforms); + CommonUniforms.addDynamicUniforms(uniforms); + customUniforms.assignTo(uniforms); - return uniforms.buildUniforms(); + BuiltinReplacementUniforms.addBuiltinReplacementUniforms(uniforms); + return uniforms; } public boolean hasShadowPass() { diff --git a/src/main/java/net/coderbot/iris/postprocess/CompositeRenderer.java b/src/main/java/net/coderbot/iris/postprocess/CompositeRenderer.java index cd3c9dddb..d4cd1e241 100644 --- a/src/main/java/net/coderbot/iris/postprocess/CompositeRenderer.java +++ b/src/main/java/net/coderbot/iris/postprocess/CompositeRenderer.java @@ -28,6 +28,7 @@ import net.coderbot.iris.shaderpack.ProgramSource; import net.coderbot.iris.shadows.ShadowRenderTargets; import net.coderbot.iris.uniforms.CommonUniforms; import net.coderbot.iris.uniforms.FrameUpdateNotifier; +import net.coderbot.iris.uniforms.custom.CustomUniforms; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.OpenGlHelper; import net.minecraft.client.shader.Framebuffer; @@ -48,6 +49,7 @@ public class CompositeRenderer { private final IntSupplier noiseTexture; private final FrameUpdateNotifier updateNotifier; private final CenterDepthSampler centerDepthSampler; + private final CustomUniforms customUniforms; private final Object2ObjectMap customTextureIds; @Getter private final ImmutableSet flippedAtLeastOnceFinal; @@ -56,12 +58,13 @@ public class CompositeRenderer { IntSupplier noiseTexture, FrameUpdateNotifier updateNotifier, CenterDepthSampler centerDepthSampler, BufferFlipper bufferFlipper, Supplier shadowTargetsSupplier, - Object2ObjectMap customTextureIds, ImmutableMap explicitPreFlips) { + Object2ObjectMap customTextureIds, ImmutableMap explicitPreFlips, CustomUniforms customUniforms) { this.noiseTexture = noiseTexture; this.updateNotifier = updateNotifier; this.centerDepthSampler = centerDepthSampler; this.renderTargets = renderTargets; this.customTextureIds = customTextureIds; + this.customUniforms = customUniforms; final ImmutableList.Builder passes = ImmutableList.builder(); final ImmutableSet.Builder flippedAtLeastOnce = new ImmutableSet.Builder<>(); @@ -207,6 +210,8 @@ public class CompositeRenderer { if (computeProgram != null) { ranCompute = true; final Framebuffer main = Minecraft.getMinecraft().getFramebuffer(); + computeProgram.use(); + this.customUniforms.push(computeProgram); computeProgram.dispatch(main.framebufferWidth, main.framebufferHeight); } } @@ -236,6 +241,8 @@ public class CompositeRenderer { renderPass.framebuffer.bind(); renderPass.program.use(); + this.customUniforms.push(renderPass.program); + FullScreenQuadRenderer.INSTANCE.renderQuad(); } @@ -307,9 +314,11 @@ public class CompositeRenderer { throw new RuntimeException("Shader compilation failed!", e); } + CommonUniforms.addDynamicUniforms(builder); + this.customUniforms.assignTo(builder); + ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureIds, flippedAtLeastOnceSnapshot); - CommonUniforms.addCommonUniforms(builder, source.getParent().getPack().getIdMap(), source.getParent().getPackDirectives(), updateNotifier); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, () -> flipped, renderTargets, true); IrisImages.addRenderTargetImages(builder, () -> flipped, renderTargets); @@ -324,8 +333,12 @@ public class CompositeRenderer { // TODO: Don't duplicate this with FinalPassRenderer centerDepthSampler.setUsage(builder.addDynamicSampler(centerDepthSampler::getCenterDepthTexture, "iris_centerDepthSmooth")); - return builder.build(); - } + Program build = builder.build(); + + this.customUniforms.mapholderToPass(builder, build); + + return build; + } private ComputeProgram[] createComputes(ComputeSource[] compute, ImmutableSet flipped, ImmutableSet flippedAtLeastOnceSnapshot, Supplier shadowTargetsSupplier) { ComputeProgram[] programs = new ComputeProgram[compute.length]; @@ -347,7 +360,10 @@ public class CompositeRenderer { ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureIds, flippedAtLeastOnceSnapshot); - CommonUniforms.addCommonUniforms(builder, source.getParent().getPack().getIdMap(), source.getParent().getPackDirectives(), updateNotifier); + CommonUniforms.addDynamicUniforms(builder); + + this.customUniforms.assignTo(builder); + IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, () -> flipped, renderTargets, true); IrisImages.addRenderTargetImages(builder, () -> flipped, renderTargets); @@ -364,6 +380,8 @@ public class CompositeRenderer { programs[i] = builder.buildCompute(); + customUniforms.mapholderToPass(builder, programs[i]); + programs[i].setWorkGroupInfo(source.getWorkGroupRelative(), source.getWorkGroups()); } } diff --git a/src/main/java/net/coderbot/iris/postprocess/FinalPassRenderer.java b/src/main/java/net/coderbot/iris/postprocess/FinalPassRenderer.java index 37260f371..ac70dda69 100644 --- a/src/main/java/net/coderbot/iris/postprocess/FinalPassRenderer.java +++ b/src/main/java/net/coderbot/iris/postprocess/FinalPassRenderer.java @@ -28,6 +28,7 @@ import net.coderbot.iris.shaderpack.ProgramSource; import net.coderbot.iris.shadows.ShadowRenderTargets; import net.coderbot.iris.uniforms.CommonUniforms; import net.coderbot.iris.uniforms.FrameUpdateNotifier; +import net.coderbot.iris.uniforms.custom.CustomUniforms; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.OpenGlHelper; import net.minecraft.client.shader.Framebuffer; @@ -56,6 +57,7 @@ public class FinalPassRenderer { private final FrameUpdateNotifier updateNotifier; private final CenterDepthSampler centerDepthSampler; private final Object2ObjectMap customTextureIds; + private final CustomUniforms customUniforms; // TODO: The length of this argument list is getting a bit ridiculous public FinalPassRenderer(ProgramSet pack, RenderTargets renderTargets, IntSupplier noiseTexture, @@ -63,13 +65,14 @@ public class FinalPassRenderer { CenterDepthSampler centerDepthSampler, Supplier shadowTargetsSupplier, Object2ObjectMap customTextureIds, - ImmutableSet flippedAtLeastOnce) { + ImmutableSet flippedAtLeastOnce, CustomUniforms customUniforms) { this.updateNotifier = updateNotifier; this.centerDepthSampler = centerDepthSampler; this.customTextureIds = customTextureIds; this.noiseTexture = noiseTexture; this.renderTargets = renderTargets; + this.customUniforms = customUniforms; this.finalPass = pack.getCompositeFinal().map(source -> { Pass pass = new Pass(); ProgramDirectives directives = source.getDirectives(); @@ -181,6 +184,8 @@ public class FinalPassRenderer { for (ComputeProgram computeProgram : finalPass.computes) { if (computeProgram != null) { + computeProgram.use(); + this.customUniforms.push(computeProgram); computeProgram.dispatch(baseWidth, baseHeight); } } @@ -196,6 +201,9 @@ public class FinalPassRenderer { } finalPass.program.use(); + + this.customUniforms.push(finalPass.program); + FullScreenQuadRenderer.INSTANCE.renderQuad(); FullScreenQuadRenderer.end(); @@ -327,9 +335,11 @@ public class FinalPassRenderer { throw new RuntimeException("Shader compilation failed!", e); } + this.customUniforms.assignTo(builder); + ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureIds, flippedAtLeastOnceSnapshot); - CommonUniforms.addCommonUniforms(builder, source.getParent().getPack().getIdMap(), source.getParent().getPackDirectives(), updateNotifier); + CommonUniforms.addDynamicUniforms(builder); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, () -> flipped, renderTargets, true); IrisImages.addRenderTargetImages(builder, () -> flipped, renderTargets); IrisSamplers.addNoiseSampler(customTextureSamplerInterceptor, noiseTexture); @@ -343,7 +353,11 @@ public class FinalPassRenderer { // TODO: Don't duplicate this with CompositeRenderer centerDepthSampler.setUsage(builder.addDynamicSampler(centerDepthSampler::getCenterDepthTexture, "iris_centerDepthSmooth")); - return builder.build(); + Program build = builder.build(); + + this.customUniforms.mapholderToPass(builder, build); + + return build; } private ComputeProgram[] createComputes(ComputeSource[] compute, ImmutableSet flipped, ImmutableSet flippedAtLeastOnceSnapshot, Supplier shadowTargetsSupplier) { @@ -364,9 +378,11 @@ public class FinalPassRenderer { throw new RuntimeException("Shader compilation failed!", e); } - ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureIds, flippedAtLeastOnceSnapshot); + ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureIds, flippedAtLeastOnceSnapshot); - CommonUniforms.addCommonUniforms(builder, source.getParent().getPack().getIdMap(), source.getParent().getPackDirectives(), updateNotifier); + customUniforms.assignTo(builder); + + CommonUniforms.addDynamicUniforms(builder); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, () -> flipped, renderTargets, true); IrisImages.addRenderTargetImages(builder, () -> flipped, renderTargets); @@ -383,6 +399,8 @@ public class FinalPassRenderer { programs[i] = builder.buildCompute(); + this.customUniforms.mapholderToPass(builder, programs[i]); + programs[i].setWorkGroupInfo(source.getWorkGroupRelative(), source.getWorkGroups()); } } diff --git a/src/main/java/net/coderbot/iris/shaderpack/ShaderPack.java b/src/main/java/net/coderbot/iris/shaderpack/ShaderPack.java index 0371dff8a..64dcd9591 100644 --- a/src/main/java/net/coderbot/iris/shaderpack/ShaderPack.java +++ b/src/main/java/net/coderbot/iris/shaderpack/ShaderPack.java @@ -23,6 +23,7 @@ import net.coderbot.iris.shaderpack.preprocessor.JcppProcessor; import net.coderbot.iris.shaderpack.texture.CustomTextureData; import net.coderbot.iris.shaderpack.texture.TextureFilteringData; import net.coderbot.iris.shaderpack.texture.TextureStage; +import net.coderbot.iris.uniforms.custom.CustomUniforms; import net.irisshaders.iris.api.v0.IrisApi; import org.jetbrains.annotations.Nullable; @@ -47,6 +48,8 @@ import java.util.stream.Collectors; public class ShaderPack { private static final Gson GSON = new Gson(); + public final CustomUniforms.Builder customUniforms; + private final ProgramSet base; @Nullable private final ProgramSet overworld; @@ -243,6 +246,8 @@ public class ShaderPack { customTextureDataMap.put(textureStage, innerCustomTextureDataMap); }); + + this.customUniforms = shaderProperties.getCustomUniforms(); } private String getCurrentProfileName() { diff --git a/src/main/java/net/coderbot/iris/shaderpack/ShaderProperties.java b/src/main/java/net/coderbot/iris/shaderpack/ShaderProperties.java index 966381d3c..cc22ea47b 100644 --- a/src/main/java/net/coderbot/iris/shaderpack/ShaderProperties.java +++ b/src/main/java/net/coderbot/iris/shaderpack/ShaderProperties.java @@ -21,6 +21,7 @@ import net.coderbot.iris.gl.texture.TextureScaleOverride; import net.coderbot.iris.shaderpack.option.ShaderPackOptions; import net.coderbot.iris.shaderpack.preprocessor.PropertiesPreprocessor; import net.coderbot.iris.shaderpack.texture.TextureStage; +import net.coderbot.iris.uniforms.custom.CustomUniforms; import java.io.IOException; import java.io.StringReader; @@ -42,6 +43,7 @@ import java.util.function.Consumer; * values in here & the values parsed from shader source code. */ public class ShaderProperties { + @Getter private final CustomUniforms.Builder customUniforms = new CustomUniforms.Builder(); @Getter private CloudSetting cloudSetting = CloudSetting.DEFAULT; @Getter private OptionalBoolean oldHandLight = OptionalBoolean.DEFAULT; @Getter private OptionalBoolean dynamicHandLight = OptionalBoolean.DEFAULT; @@ -309,6 +311,26 @@ public class ShaderProperties { handleWhitespacedListDirective(key, value, "iris.features.required", options -> requiredFeatureFlags = options); handleWhitespacedListDirective(key, value, "iris.features.optional", options -> optionalFeatureFlags = options); + handlePassDirective("variable.", key, value, pass -> { + String[] parts = pass.split("\\."); + if (parts.length != 2) { + Iris.logger.warn("Custom variables should take the form of `variable.. = . Ignoring " + key); + return; + } + + customUniforms.addVariable(parts[0], parts[1], value, false); + }); + + handlePassDirective("uniform.", key, value, pass -> { + String[] parts = pass.split("\\."); + if (parts.length != 2) { + Iris.logger.warn("Custom uniforms sould take the form of `uniform.. = . Ignoring " + key); + return; + } + + customUniforms.addVariable(parts[0], parts[1], value, true); + }); + // TODO: Buffer size directives // TODO: Conditional program enabling directives }); diff --git a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java index 3f4714269..4a935bb52 100644 --- a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java +++ b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgram.java @@ -12,6 +12,8 @@ import me.jellysquid.mods.sodium.client.render.chunk.shader.ChunkShaderFogCompon import net.coderbot.iris.gl.program.ProgramImages; import net.coderbot.iris.gl.program.ProgramSamplers; import net.coderbot.iris.gl.program.ProgramUniforms; +import net.coderbot.iris.pipeline.SodiumTerrainPipeline; +import net.coderbot.iris.uniforms.custom.CustomUniforms; import net.minecraft.util.ResourceLocation; import org.jetbrains.annotations.Nullable; import org.joml.Matrix4f; @@ -30,15 +32,20 @@ public class IrisChunkProgram extends ChunkProgram { @Nullable private final ProgramImages irisProgramImages; - public IrisChunkProgram(RenderDevice owner, ResourceLocation name, int handle, - @Nullable ProgramUniforms irisProgramUniforms, @Nullable ProgramSamplers irisProgramSamplers, - @Nullable ProgramImages irisProgramImages) { + private CustomUniforms customUniforms; + + public IrisChunkProgram(RenderDevice owner, ResourceLocation name, int handle, boolean isShadowPass, SodiumTerrainPipeline pipeline, CustomUniforms customUniforms) { super(owner, name, handle, ChunkShaderFogComponent.None::new); this.uModelViewMatrix = this.getUniformLocation("iris_ModelViewMatrix"); this.uNormalMatrix = this.getUniformLocation("iris_NormalMatrix"); - this.irisProgramUniforms = irisProgramUniforms; - this.irisProgramSamplers = irisProgramSamplers; - this.irisProgramImages = irisProgramImages; + this.customUniforms = customUniforms; + + ProgramUniforms.Builder builder = pipeline.initUniforms(handle); + customUniforms.mapholderToPass(builder, this); + this.irisProgramUniforms = builder.buildUniforms(); + this.irisProgramSamplers + = isShadowPass? pipeline.initShadowSamplers(handle) : pipeline.initTerrainSamplers(handle); + this.irisProgramImages = isShadowPass ? pipeline.initShadowImages(handle) : pipeline.initTerrainImages(handle); } @Override @@ -64,6 +71,8 @@ public class IrisChunkProgram extends ChunkProgram { uniformMatrix(uModelViewMatrix, modelViewMatrix); uniformMatrix(uNormalMatrix, normalMatrix); + + customUniforms.push(this); } @Override diff --git a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgramOverrides.java b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgramOverrides.java index 97b26ff4c..d099c56da 100644 --- a/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgramOverrides.java +++ b/src/main/java/net/coderbot/iris/sodium/shader_overrides/IrisChunkProgramOverrides.java @@ -142,21 +142,7 @@ public class IrisChunkProgramOverrides { .bindAttribute("mc_Entity", IrisChunkShaderBindingPoints.BLOCK_ID) .bindAttribute("at_midBlock", IrisChunkShaderBindingPoints.MID_BLOCK) .bindAttribute("iris_ModelOffset", ChunkShaderBindingPoints.MODEL_OFFSET) - .build((program, name) -> { - ProgramUniforms uniforms = pipeline.initUniforms(name); - ProgramSamplers samplers; - ProgramImages images; - - if (pass == IrisTerrainPass.SHADOW) { - samplers = pipeline.initShadowSamplers(name); - images = pipeline.initShadowImages(name); - } else { - samplers = pipeline.initTerrainSamplers(name); - images = pipeline.initTerrainImages(name); - } - - return new IrisChunkProgram(device, program, name, uniforms, samplers, images); - }); + .build((program, name) -> new IrisChunkProgram(device, program, name, pass == IrisTerrainPass.SHADOW, pipeline, pipeline.getCustomUniforms())); } finally { vertShader.delete(); if (geomShader != null) { diff --git a/src/main/java/net/coderbot/iris/uniforms/CommonUniforms.java b/src/main/java/net/coderbot/iris/uniforms/CommonUniforms.java index 30f08d5fe..ccec18cd9 100644 --- a/src/main/java/net/coderbot/iris/uniforms/CommonUniforms.java +++ b/src/main/java/net/coderbot/iris/uniforms/CommonUniforms.java @@ -44,17 +44,22 @@ public final class CommonUniforms { // no construction allowed } + public static void addNonDynamicUniforms(UniformHolder uniforms, IdMap idMap, PackDirectives directives, FrameUpdateNotifier updateNotifier) { + CameraUniforms.addCameraUniforms(uniforms, updateNotifier); + ViewportUniforms.addViewportUniforms(uniforms); + WorldTimeUniforms.addWorldTimeUniforms(uniforms); + SystemTimeUniforms.addSystemTimeUniforms(uniforms); + new CelestialUniforms(directives.getSunPathRotation()).addCelestialUniforms(uniforms); + IrisExclusiveUniforms.addIrisExclusiveUniforms(uniforms); + IdMapUniforms.addIdMapUniforms(updateNotifier, uniforms, idMap, directives.isOldHandLight()); + MatrixUniforms.addMatrixUniforms(uniforms, directives); + HardcodedCustomUniforms.addHardcodedCustomUniforms(uniforms, updateNotifier); + CommonUniforms.generalCommonUniforms(uniforms, updateNotifier, directives); + } + // Needs to use a LocationalUniformHolder as we need it for the common uniforms - public static void addCommonUniforms(DynamicUniformHolder uniforms, IdMap idMap, PackDirectives directives, FrameUpdateNotifier updateNotifier) { - CameraUniforms.addCameraUniforms(uniforms, updateNotifier); - ViewportUniforms.addViewportUniforms(uniforms); - WorldTimeUniforms.addWorldTimeUniforms(uniforms); - SystemTimeUniforms.addSystemTimeUniforms(uniforms); - new CelestialUniforms(directives.getSunPathRotation()).addCelestialUniforms(uniforms); - IdMapUniforms.addIdMapUniforms(updateNotifier, uniforms, idMap, directives.isOldHandLight()); - IrisExclusiveUniforms.addIrisExclusiveUniforms(uniforms); - MatrixUniforms.addMatrixUniforms(uniforms, directives); - HardcodedCustomUniforms.addHardcodedCustomUniforms(uniforms, updateNotifier); + public static void addDynamicUniforms(DynamicUniformHolder uniforms) { + IdMapUniforms.addEntityIdMapUniforms(uniforms); FogUniforms.addFogUniforms(uniforms); // TODO: OptiFine doesn't think that atlasSize is a "dynamic" uniform, @@ -91,7 +96,6 @@ public final class CommonUniforms { uniforms.uniform4f("entityColor", CapturedRenderingState.INSTANCE::getCurrentEntityColor, CapturedRenderingState.INSTANCE.getEntityColorNotifier()); - CommonUniforms.generalCommonUniforms(uniforms, updateNotifier, directives); } public static void generalCommonUniforms(UniformHolder uniforms, FrameUpdateNotifier updateNotifier, PackDirectives directives) { diff --git a/src/main/java/net/coderbot/iris/uniforms/IdMapUniforms.java b/src/main/java/net/coderbot/iris/uniforms/IdMapUniforms.java index 082a88b82..d6aad3fc7 100644 --- a/src/main/java/net/coderbot/iris/uniforms/IdMapUniforms.java +++ b/src/main/java/net/coderbot/iris/uniforms/IdMapUniforms.java @@ -3,6 +3,7 @@ package net.coderbot.iris.uniforms; import it.unimi.dsi.fastutil.objects.Object2IntFunction; import com.gtnewhorizons.angelica.compat.mojang.InteractionHand; import net.coderbot.iris.gl.uniform.DynamicUniformHolder; +import net.coderbot.iris.gl.uniform.UniformHolder; import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; import net.coderbot.iris.shaderpack.IdMap; import net.coderbot.iris.shaderpack.materialmap.NamespacedId; @@ -21,7 +22,7 @@ public final class IdMapUniforms { private IdMapUniforms() { } - public static void addIdMapUniforms(FrameUpdateNotifier notifier, DynamicUniformHolder uniforms, IdMap idMap, boolean isOldHandLight) { + public static void addIdMapUniforms(FrameUpdateNotifier notifier, UniformHolder uniforms, IdMap idMap, boolean isOldHandLight) { HeldItemSupplier mainHandSupplier = new HeldItemSupplier(InteractionHand.MAIN_HAND, idMap.getItemIdMap(), isOldHandLight); HeldItemSupplier offHandSupplier = new HeldItemSupplier(InteractionHand.OFF_HAND, idMap.getItemIdMap(), false); notifier.addListener(mainHandSupplier::update); @@ -35,14 +36,16 @@ public final class IdMapUniforms { // TODO: Figure out API. //.uniformVanilla3f(PER_FRAME, "heldBlockLightColor", mainHandSupplier::getLightColor) //.uniformVanilla3f(PER_FRAME, "heldBlockLightColor2", offHandSupplier::getLightColor); - - uniforms.uniform1i("entityId", CapturedRenderingState.INSTANCE::getCurrentRenderedEntity, - CapturedRenderingState.INSTANCE.getEntityIdNotifier()); - - uniforms.uniform1i("blockEntityId", CapturedRenderingState.INSTANCE::getCurrentRenderedBlockEntity, - CapturedRenderingState.INSTANCE.getBlockEntityIdNotifier()); } + public static void addEntityIdMapUniforms(DynamicUniformHolder uniforms) { + uniforms.uniform1i("entityId", CapturedRenderingState.INSTANCE::getCurrentRenderedEntity, + CapturedRenderingState.INSTANCE.getEntityIdNotifier()); + + uniforms.uniform1i("blockEntityId", CapturedRenderingState.INSTANCE::getCurrentRenderedBlockEntity, + CapturedRenderingState.INSTANCE.getBlockEntityIdNotifier()); + } + /** * Provides the currently held item, and it's light value, in the given hand as a uniform. Uses the item.properties ID map to map the item * to an integer, and the old hand light value to map offhand to main hand. diff --git a/src/main/java/net/coderbot/iris/uniforms/SystemTimeUniforms.java b/src/main/java/net/coderbot/iris/uniforms/SystemTimeUniforms.java index 4bf8ce6d1..fcf8195a4 100644 --- a/src/main/java/net/coderbot/iris/uniforms/SystemTimeUniforms.java +++ b/src/main/java/net/coderbot/iris/uniforms/SystemTimeUniforms.java @@ -27,8 +27,6 @@ public final class SystemTimeUniforms { public static void addSystemTimeUniforms(UniformHolder uniforms) { uniforms .uniform1i(UniformUpdateFrequency.PER_FRAME, "frameCounter", COUNTER) - // TODO: Don't hardcode framemod8 here for Sildur's Vibrant Shaders - .uniform1i(UniformUpdateFrequency.PER_FRAME, "framemod8", () -> COUNTER.getAsInt() % 8) .uniform1f(UniformUpdateFrequency.PER_FRAME, "frameTime", TIMER::getLastFrameTime) .uniform1f(UniformUpdateFrequency.PER_FRAME, "frameTimeCounter", TIMER::getFrameTimeCounter); } diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/CustomUniformFixedInputUniformsHolder.java b/src/main/java/net/coderbot/iris/uniforms/custom/CustomUniformFixedInputUniformsHolder.java new file mode 100644 index 000000000..ea9487800 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/CustomUniformFixedInputUniformsHolder.java @@ -0,0 +1,200 @@ +package net.coderbot.iris.uniforms.custom; + +import com.google.common.collect.ImmutableMap; +import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; +import kroppeb.stareval.function.Type; +import net.coderbot.iris.Iris; +import net.coderbot.iris.gl.uniform.FloatSupplier; +import net.coderbot.iris.gl.uniform.UniformHolder; +import net.coderbot.iris.gl.uniform.UniformType; +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import net.coderbot.iris.uniforms.custom.cached.BooleanCachedUniform; +import net.coderbot.iris.uniforms.custom.cached.CachedUniform; +import net.coderbot.iris.uniforms.custom.cached.Float2VectorCachedUniform; +import net.coderbot.iris.uniforms.custom.cached.Float3VectorCachedUniform; +import net.coderbot.iris.uniforms.custom.cached.Float4MatrixCachedUniform; +import net.coderbot.iris.uniforms.custom.cached.Float4VectorCachedUniform; +import net.coderbot.iris.uniforms.custom.cached.FloatCachedUniform; +import net.coderbot.iris.uniforms.custom.cached.Int2VectorCachedUniform; +import net.coderbot.iris.uniforms.custom.cached.Int3VectorCachedUniform; +import net.coderbot.iris.uniforms.custom.cached.IntCachedUniform; +import net.minecraft.util.Vec3; +import org.joml.Matrix4f; +import org.joml.Matrix4fc; +import org.joml.Vector2f; +import org.joml.Vector2i; +import org.joml.Vector3d; +import org.joml.Vector3f; +import org.joml.Vector3i; +import org.joml.Vector4f; + +import java.util.Collection; +import java.util.Map; +import java.util.function.BooleanSupplier; +import java.util.function.DoubleSupplier; +import java.util.function.IntSupplier; +import java.util.function.Supplier; + +public class CustomUniformFixedInputUniformsHolder { + final private ImmutableMap inputVariables; + + public CustomUniformFixedInputUniformsHolder( + ImmutableMap inputVariables) { + this.inputVariables = inputVariables; + } + + public Type getType(String name) { + CachedUniform uniform = this.inputVariables.get(name); + if (uniform == null) + return null; + return uniform.getType(); + } + + public boolean containsKey(String name) { + return this.inputVariables.containsKey(name); + } + + public CachedUniform getUniform(String name) { + return this.inputVariables.get(name); + } + + public void updateAll() { + for (CachedUniform value : this.inputVariables.values()) { + value.update(); + } + } + + public Collection getAll() { + return this.inputVariables.values(); + } + + public static class Builder implements UniformHolder { + final private Map inputVariables = new Object2ObjectOpenHashMap<>(); + + private Builder put(String name, CachedUniform uniform) { + if (inputVariables.containsKey(name)) { + Iris.logger.warn("Duplicated fixed uniform supplied as inputs to the Custom uniform holder: " + name); + return this; + } + inputVariables.put(name, uniform); + return this; + } + + @Override + public Builder uniform1f(UniformUpdateFrequency updateFrequency, String name, FloatSupplier value) { + return this.put(name, new FloatCachedUniform(name, updateFrequency, value)); + } + + @Override + public Builder uniform1f(UniformUpdateFrequency updateFrequency, String name, IntSupplier value) { + return this.put(name, new FloatCachedUniform(name, updateFrequency, value::getAsInt)); + } + + @Override + public Builder uniform1f(UniformUpdateFrequency updateFrequency, String name, DoubleSupplier value) { + return this.put(name, new FloatCachedUniform(name, updateFrequency, () -> (float) value.getAsDouble())); + } + + @Override + public Builder uniform1i(UniformUpdateFrequency updateFrequency, String name, IntSupplier value) { + return this.put(name, new IntCachedUniform(name, updateFrequency, value)); + } + + @Override + public Builder uniform1b(UniformUpdateFrequency updateFrequency, String name, BooleanSupplier value) { + return this.put(name, new BooleanCachedUniform(name, updateFrequency, value)); + } + + @Override + public Builder uniform2f(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + return this.put(name, new Float2VectorCachedUniform(name, updateFrequency, value)); + } + + @Override + public Builder uniform2i(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + return this.put(name, new Int2VectorCachedUniform(name, updateFrequency, value)); + } + + @Override + public Builder uniform3f(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + return this.put(name, new Float3VectorCachedUniform(name, updateFrequency, value)); + } + + @Override + public Builder uniform3i(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + return this.put(name, new Int3VectorCachedUniform(name, updateFrequency, value)); + } + + @Override + public UniformHolder uniformVanilla3f(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + throw new RuntimeException("Exception from Custom Uniform UniformHolder implementation. This should never be reached, please send help"); + } + + @Override + public Builder uniformTruncated3f(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + Vector3f held = new Vector3f(); + return this.put(name, new Float3VectorCachedUniform(name, updateFrequency, () -> { + Vector4f vec = value.get(); + held.set(vec.x(), vec.y(), vec.z()); + return held; + })); + } + + @Override + public UniformHolder uniform3d(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + Vector3f held = new Vector3f(); + return this.put(name, new Float3VectorCachedUniform(name, updateFrequency, () -> { + Vector3d vec = value.get(); + held.set(vec.x(), vec.y(), vec.z()); + return held; + })); + } + + @Override + public UniformHolder uniform4f(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + Vector4f held = new Vector4f(); + return this.put(name, new Float4VectorCachedUniform(name, updateFrequency, () -> { + Vector4f vec = value.get(); + held.set(vec.x(), vec.y(), vec.z(), vec.w()); + return held; + })); + } + + @Override + public UniformHolder uniform4fArray(UniformUpdateFrequency updateFrequency, String name, Supplier value) { + Vector4f held = new Vector4f(); + return this.put(name, new Float4VectorCachedUniform(name, updateFrequency, () -> { + float[] vec = value.get(); + held.set(vec); + return held; + })); + } + + @Override + public UniformHolder uniformMatrix( + UniformUpdateFrequency updateFrequency, String name, Supplier value) { + return this.put(name, new Float4MatrixCachedUniform(name, updateFrequency, value)); + } + + @Override + public UniformHolder uniformMatrixFromArray( + UniformUpdateFrequency updateFrequency, String name, Supplier value) { + Matrix4f held = new Matrix4f(); + + return this.put(name, new Float4MatrixCachedUniform(name, updateFrequency, () -> { + held.set(value.get()); + return held; + })); + } + + @Override + public UniformHolder externallyManagedUniform(String name, UniformType type) { + // TODO: what is this function for? + return this; + } + + public CustomUniformFixedInputUniformsHolder build() { + return new CustomUniformFixedInputUniformsHolder(ImmutableMap.copyOf(this.inputVariables)); + } + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/CustomUniforms.java b/src/main/java/net/coderbot/iris/uniforms/custom/CustomUniforms.java new file mode 100644 index 000000000..6050d8d10 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/CustomUniforms.java @@ -0,0 +1,353 @@ +package net.coderbot.iris.uniforms.custom; + +import com.github.bsideup.jabel.Desugar; +import com.google.common.collect.ImmutableMap; +import it.unimi.dsi.fastutil.objects.Object2IntMap; +import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; +import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap; +import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; +import it.unimi.dsi.fastutil.objects.ObjectArrayList; +import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet; +import kroppeb.stareval.element.ExpressionElement; +import kroppeb.stareval.expression.Expression; +import kroppeb.stareval.expression.VariableExpression; +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import kroppeb.stareval.parser.Parser; +import kroppeb.stareval.resolver.ExpressionResolver; +import net.coderbot.iris.Iris; +import net.coderbot.iris.gl.uniform.LocationalUniformHolder; +import net.coderbot.iris.gl.uniform.UniformHolder; +import net.coderbot.iris.parsing.IrisFunctions; +import net.coderbot.iris.parsing.IrisOptions; +import net.coderbot.iris.parsing.VectorType; +import net.coderbot.iris.uniforms.custom.cached.CachedUniform; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.OptionalInt; +import java.util.Set; +import java.util.function.Consumer; +import java.util.stream.Collectors; + + +public class CustomUniforms implements FunctionContext { + private final Map variables = new Object2ObjectLinkedOpenHashMap<>(); + private final Map variablesExpressions = new Object2ObjectLinkedOpenHashMap<>(); + private final CustomUniformFixedInputUniformsHolder inputHolder; + private final List uniformOrder; + private final Map> locationMap = new Object2ObjectOpenHashMap<>(); + private final Map> dependsOn; + + private CustomUniforms(CustomUniformFixedInputUniformsHolder inputHolder, Map variables) { + this.inputHolder = inputHolder; + ExpressionResolver resolver = new ExpressionResolver( + IrisFunctions.functions, + (name) -> { + Type type = this.inputHolder.getType(name); + if (type != null) + return type; + Builder.Variable variable = variables.get(name); + if (variable != null) + return variable.type; + return null; + }, + true); + + for (Builder.Variable variable : variables.values()) { + try { + Expression expression = resolver.resolveExpression(variable.type, variable.expression); + CachedUniform cachedUniform = CachedUniform + .forExpression(variable.name, variable.type, expression, this); + this.addVariable(expression, cachedUniform); + if (variable.uniform) { + List uniforms = new ArrayList<>(); + uniforms.add(cachedUniform); + } + //Iris.logger.info("Was able to resolve uniform " + variable.name + " = " + variable.expression); + } catch (Exception e) { + Iris.logger + .warn("Failed to resolve uniform " + variable.name + ", reason: " + e + .getMessage() + " ( = " + variable.expression + ")", e); + } + } + + { + // toposort + + this.dependsOn = new Object2ObjectOpenHashMap<>(); + Map> requiredBy = new Object2ObjectOpenHashMap<>(); + Object2IntMap dependsOnCount = new Object2IntOpenHashMap<>(); + + for (CachedUniform input : this.inputHolder.getAll()) { + requiredBy.put(input, new ObjectArrayList<>()); + } + + for (CachedUniform input : this.variables.values()) { + requiredBy.put(input, new ObjectArrayList<>()); + } + + FunctionReturn functionReturn = new FunctionReturn(); + Set requires = new ObjectOpenHashSet<>(); + Set brokenUniforms = new ObjectOpenHashSet<>(); + + for (Map.Entry entry : this.variablesExpressions.entrySet()) { + requires.clear(); + + entry.getValue().listVariables(requires); + if (requires.isEmpty()) { + continue; + } + + CachedUniform uniform = this.variables.get(entry.getKey()); + + List dependencies = new ArrayList<>(); + for (VariableExpression v : requires) { + Expression evaluated = v.partialEval(this, functionReturn); + if (evaluated instanceof CachedUniform) { + dependencies.add((CachedUniform) evaluated); + } else { + // we are depending on a broken uniform + brokenUniforms.add(uniform); + } + } + + if (dependencies.isEmpty()) { + // can be empty if we rely on broken uniforms + continue; + } + + dependsOn.put(uniform, dependencies); + dependsOnCount.put(uniform, dependencies.size()); + + for (CachedUniform dependency : dependencies) { + requiredBy.get(dependency).add(uniform); + } + } + + // actual toposort: + List ordered = new ObjectArrayList<>(); + List free = new ObjectArrayList<>(); + + // init + for (CachedUniform entry : requiredBy.keySet()) { + if (!dependsOnCount.containsKey(entry)) { + free.add(entry); + } + } + + while (!free.isEmpty()) { + CachedUniform pop = free.remove(free.size() - 1); + if (!brokenUniforms.contains(pop)) { + // only add those that aren't broken + ordered.add(pop); + } else { + // mark all those that rely on use as broken too + brokenUniforms.addAll(requiredBy.get(pop)); + } + for (CachedUniform dependent : requiredBy.get(pop)) { + int count = dependsOnCount.mergeInt(dependent, -1, Integer::sum); + assert count >= 0; + if (count == 0) { + free.add(dependent); + dependsOnCount.removeInt(dependent); + } + } + } + + if (!brokenUniforms.isEmpty()) { + Iris.logger.warn( + "The following uniforms won't work, either because they are broken, or reference a broken uniform: \n" + + brokenUniforms.stream().map(CachedUniform::getName).collect(Collectors.joining(", "))); + } + + if (!dependsOnCount.isEmpty()) { + throw new IllegalStateException("Circular reference detected between: " + + dependsOnCount.object2IntEntrySet() + .stream() + .map(entry -> entry.getKey().getName() + " (" + entry.getIntValue() + ")") + .collect(Collectors.joining(", ")) + ); + } + + this.uniformOrder = ordered; + } + } + + private void addVariable(Expression expression, CachedUniform uniform) throws Exception { + String name = uniform.getName(); + if (this.variables.containsKey(name)) + throw new Exception("Duplicated variable: " + name); + if (this.inputHolder.containsKey(name)) + throw new Exception("Variable shadows build in uniform: " + name); + + this.variables.put(name, uniform); + this.variablesExpressions.put(name, expression); + } + + public void assignTo(LocationalUniformHolder targetHolder) { + Object2IntMap locations = new Object2IntOpenHashMap<>(); + for (CachedUniform uniform : this.uniformOrder) { + try { + OptionalInt location = targetHolder.location(uniform.getName(), Type.convert(uniform.getType())); + if (location.isPresent()) { + locations.put(uniform, location.getAsInt()); + } + } catch (Exception e) { + throw new RuntimeException(uniform.getName(), e); + } + } + this.locationMap.put(targetHolder, locations); + } + + public void mapholderToPass(LocationalUniformHolder holder, Object pass) { + locationMap.put(pass, locationMap.remove(holder)); + } + + + public void update() { + for (CachedUniform value : this.uniformOrder) { + value.update(); + } + } + + public void push(Object pass) { + Object2IntMap uniforms = this.locationMap.get(pass); + if (uniforms != null) { + uniforms.forEach(CachedUniform::pushIfChanged); + } + } + + /** + * This function will do the following: + *

      + *
    • + * Remove unused uniforms + *
    • + *
    • + * TODO: Create separate push lists for each renderpass + *
    • + *
    • + * TODO: Sort the others in the correct execution line

      + * note: that if a `EVERY_FRAME` depends on a `EVERY_TICK`, it has to correctly now that it's + * dependency hasn't updated
      + * suggestion: set a boolean in the `EVERY_TICK` execution line saying this is a tick + * and have it set to false in the `EVERY_FRAME`. Depending on the value, `frameDependencies` or + * `allDependencies` lists are used + *

    • + *
    + */ + public void optimise() { + + Object2IntMap dependedByCount = new Object2IntOpenHashMap<>(); + + // Count the times a uniform is depended on + for (List dependencies : this.dependsOn.values()) { + for (CachedUniform dependency : dependencies) { + dependedByCount.mergeInt(dependency, 1, Integer::sum); + } + } + + // Count the times a pass depends on a uniform + // ensures they wont ever be removed + for (Object2IntMap map : this.locationMap.values()) { + for (CachedUniform cachedUniform : map.keySet()) { + dependedByCount.mergeInt(cachedUniform, 1, Integer::sum); + } + } + + + Set unused = new ObjectOpenHashSet<>(); + for (int i = this.uniformOrder.size() - 1; i >= 0; i--) { + CachedUniform uniform = this.uniformOrder.get(i); + if (!dependedByCount.containsKey(uniform)) { + // not used + unused.add(uniform); + // remove dependencies + List dependencies = this.dependsOn.get(uniform); + if (dependencies != null) { + for (CachedUniform dependency : dependencies) { + // reduce count by 1 + dependedByCount.computeIntIfPresent(dependency, (key, value) -> value - 1); + } + } + } + } + + this.uniformOrder.removeAll(unused); + } + + @Override + public boolean hasVariable(String name) { + return this.inputHolder.containsKey(name) || this.variables.containsKey(name); + } + + @Override + public Expression getVariable(String name) { + // TODO: Make the simplify just return these ones + final CachedUniform inputUniform = this.inputHolder.getUniform(name); + if (inputUniform != null) + return inputUniform; + final CachedUniform customUniform = this.variables.get(name); + if (customUniform != null) + return customUniform; + throw new RuntimeException("Unknown variable: " + name); + } + + public static class Builder { + final private static Map types = new ImmutableMap.Builder() + .put("bool", Type.Boolean) + .put("float", Type.Float) + .put("int", Type.Int) + .put("vec2", VectorType.VEC2) + .put("vec3", VectorType.VEC3) + .put("vec4", VectorType.VEC4) + .build(); + final Map variables = new Object2ObjectLinkedOpenHashMap<>(); + + public void addVariable(String type, String name, String expression, boolean isUniform) { + if (variables.containsKey(name)) { + Iris.logger.warn("Ignoring duplicated custom uniform name: " + name); + return; + } + + Type parsedType = types.get(type); + if (parsedType == null) { + Iris.logger.warn("Ignoring invalid uniform type: " + type + " of " + name); + return; + } + + try { + ExpressionElement ast = Parser.parse(expression, IrisOptions.options); + variables.put(name, new Variable(parsedType, name, ast, isUniform)); + } catch (Exception e) { + Iris.logger.warn("Failed to parse custom variable/uniform " + name + " with expression " + expression, e); + } + } + + public CustomUniforms build( + CustomUniformFixedInputUniformsHolder inputHolder + ) { + return new CustomUniforms(inputHolder, this.variables); + } + + @SafeVarargs + public final CustomUniforms build( + Consumer... uniforms + ) { + CustomUniformFixedInputUniformsHolder.Builder inputs = new CustomUniformFixedInputUniformsHolder.Builder(); + for (Consumer uniform : uniforms) { + uniform.accept(inputs); + } + return this.build(inputs.build()); + } + + @Desugar + private record Variable(Type type, String name, ExpressionElement expression, boolean uniform) { + } + + + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/BooleanCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/BooleanCachedUniform.java new file mode 100644 index 000000000..8d83d1dcc --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/BooleanCachedUniform.java @@ -0,0 +1,41 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import org.lwjgl.opengl.GL20; + +import java.util.function.BooleanSupplier; + +public class BooleanCachedUniform extends CachedUniform { + + final private BooleanSupplier supplier; + private boolean cached; + + public BooleanCachedUniform(String name, UniformUpdateFrequency updateFrequency, BooleanSupplier supplier) { + super(name, updateFrequency); + this.supplier = supplier; + } + + @Override + protected boolean doUpdate() { + boolean prev = this.cached; + this.cached = this.supplier.getAsBoolean(); + return prev != cached; + } + + @Override + public void push(int location) { + GL20.glUniform1i(location, this.cached ? 1 : 0); + } + + @Override + public void writeTo(FunctionReturn functionReturn) { + functionReturn.booleanReturn = this.cached; + } + + @Override + public Type getType() { + return Type.Boolean; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/CachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/CachedUniform.java new file mode 100644 index 000000000..83183df36 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/CachedUniform.java @@ -0,0 +1,99 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import kroppeb.stareval.expression.Expression; +import kroppeb.stareval.expression.VariableExpression; +import kroppeb.stareval.function.FunctionContext; +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import net.coderbot.iris.parsing.VectorType; +import org.joml.Vector2f; +import org.joml.Vector3f; +import org.joml.Vector4f; + +public abstract class CachedUniform implements VariableExpression { + private final String name; + private final UniformUpdateFrequency updateFrequency; + private boolean changed = true; + + public CachedUniform(String name, UniformUpdateFrequency updateFrequency) { + this.name = name; + this.updateFrequency = updateFrequency; + } + + static public CachedUniform forExpression(String name, Type type, Expression expression, FunctionContext context) { + final FunctionReturn held = new FunctionReturn(); + final UniformUpdateFrequency frequency = UniformUpdateFrequency.CUSTOM; + if (type.equals(Type.Boolean)) { + return new BooleanCachedUniform(name, frequency, () -> { + expression.evaluateTo(context, held); + return held.booleanReturn; + }); + } else if (type.equals(Type.Int)) { + return new IntCachedUniform(name, frequency, () -> { + expression.evaluateTo(context, held); + return held.intReturn; + }); + } else if (type.equals(Type.Float)) { + return new FloatCachedUniform(name, frequency, () -> { + expression.evaluateTo(context, held); + return held.floatReturn; + }); + } else if (type.equals(VectorType.VEC2)) { + return new Float2VectorCachedUniform(name, frequency, () -> { + expression.evaluateTo(context, held); + return (Vector2f) held.objectReturn; + }); + } else if (type.equals(VectorType.VEC3)) { + return new Float3VectorCachedUniform(name, frequency, () -> { + expression.evaluateTo(context, held); + return (Vector3f) held.objectReturn; + }); + } else if (type.equals(VectorType.VEC4)) { + return new Float4VectorCachedUniform(name, frequency, () -> { + expression.evaluateTo(context, held); + return (Vector4f) held.objectReturn; + }); + } else { + throw new IllegalArgumentException("Custom uniforms of type: " + type + " are currently not supported"); + } + } + + public void markUnchanged() { + this.changed = false; + } + + public void update() { + doUpdate(); + // TODO: Works around a logic error / architectural flaw - there's no way to + // know when a uniform has been uploaded to all programs, so we can never + // safely change this to false with the current design. + this.changed = true; + } + + protected abstract boolean doUpdate(); + + public abstract void push(int location); + + public void pushIfChanged(int location) { + if (this.changed) + push(location); + } + + @Override + public void evaluateTo(FunctionContext context, FunctionReturn functionReturn) { + this.writeTo(functionReturn); + } + + public abstract void writeTo(FunctionReturn functionReturn); + + public abstract Type getType(); + + public String getName() { + return name; + } + + public UniformUpdateFrequency getUpdateFrequency() { + return updateFrequency; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float2VectorCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float2VectorCachedUniform.java new file mode 100644 index 000000000..9e0c5487e --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float2VectorCachedUniform.java @@ -0,0 +1,30 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import net.coderbot.iris.parsing.VectorType; +import org.joml.Vector2f; +import org.lwjgl.opengl.GL20; + +import java.util.function.Supplier; + +public class Float2VectorCachedUniform extends VectorCachedUniform { + + public Float2VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier supplier) { + super(name, updateFrequency, new Vector2f(), supplier); + } + + @Override + protected void setFrom(Vector2f other) { + this.cached.set(other); + } + + @Override + public void push(int location) { + GL20.glUniform2f(location, this.cached.x, this.cached.y); + } + + @Override + public VectorType getType() { + return VectorType.VEC2; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float3VectorCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float3VectorCachedUniform.java new file mode 100644 index 000000000..5b782fd25 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float3VectorCachedUniform.java @@ -0,0 +1,30 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import net.coderbot.iris.parsing.VectorType; +import org.joml.Vector3f; +import org.lwjgl.opengl.GL20; + +import java.util.function.Supplier; + +public class Float3VectorCachedUniform extends VectorCachedUniform { + + public Float3VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier supplier) { + super(name, updateFrequency, new Vector3f(), supplier); + } + + @Override + protected void setFrom(Vector3f other) { + this.cached.set(other); + } + + @Override + public void push(int location) { + GL20.glUniform3f(location, this.cached.x, this.cached.y, this.cached.z); + } + + @Override + public VectorType getType() { + return VectorType.VEC3; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float4MatrixCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float4MatrixCachedUniform.java new file mode 100644 index 000000000..86527c36b --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float4MatrixCachedUniform.java @@ -0,0 +1,36 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import net.coderbot.iris.parsing.MatrixType; +import org.joml.Matrix4f; +import org.lwjgl.opengl.GL20; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.FloatBuffer; +import java.util.function.Supplier; + +public class Float4MatrixCachedUniform extends VectorCachedUniform { + final private FloatBuffer buffer = ByteBuffer.allocateDirect(16 << 2).order(ByteOrder.nativeOrder()).asFloatBuffer(); + + public Float4MatrixCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier supplier) { + super(name, updateFrequency, new Matrix4f(), supplier); + } + + @Override + protected void setFrom(Matrix4f other) { + ((Matrix4f) this.cached).set(other); + } + + @Override + public void push(int location) { + // `gets` the values from the matrix and put's them into a buffer + this.cached.get(buffer); + GL20.glUniformMatrix4(location, false, buffer); + } + + @Override + public MatrixType getType() { + return MatrixType.MAT4; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float4VectorCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float4VectorCachedUniform.java new file mode 100644 index 000000000..5c9557775 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Float4VectorCachedUniform.java @@ -0,0 +1,30 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import net.coderbot.iris.parsing.VectorType; +import org.joml.Vector4f; +import org.lwjgl.opengl.GL20; + +import java.util.function.Supplier; + +public class Float4VectorCachedUniform extends VectorCachedUniform { + + public Float4VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier supplier) { + super(name, updateFrequency, new Vector4f(), supplier); + } + + @Override + protected void setFrom(Vector4f other) { + this.cached.set(other); + } + + @Override + public void push(int location) { + GL20.glUniform4f(location, this.cached.x, this.cached.y, this.cached.z, this.cached.w); + } + + @Override + public VectorType getType() { + return VectorType.VEC4; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/FloatCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/FloatCachedUniform.java new file mode 100644 index 000000000..1eab25302 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/FloatCachedUniform.java @@ -0,0 +1,40 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import net.coderbot.iris.gl.uniform.FloatSupplier; +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import org.lwjgl.opengl.GL20; + +public class FloatCachedUniform extends CachedUniform { + + final private FloatSupplier supplier; + private float cached; + + public FloatCachedUniform(String name, UniformUpdateFrequency updateFrequency, FloatSupplier supplier) { + super(name, updateFrequency); + this.supplier = supplier; + } + + @Override + protected boolean doUpdate() { + float prev = this.cached; + this.cached = this.supplier.getAsFloat(); + return prev != cached; + } + + @Override + public void push(int location) { + GL20.glUniform1f(location, this.cached); + } + + @Override + public void writeTo(FunctionReturn functionReturn) { + functionReturn.floatReturn = this.cached; + } + + @Override + public Type getType() { + return Type.Float; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/Int2VectorCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Int2VectorCachedUniform.java new file mode 100644 index 000000000..ba2ef6b46 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Int2VectorCachedUniform.java @@ -0,0 +1,36 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import kroppeb.stareval.function.FunctionReturn; +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import net.coderbot.iris.parsing.VectorType; +import org.joml.Vector2i; +import org.lwjgl.opengl.GL20; + +import java.util.function.Supplier; + +public class Int2VectorCachedUniform extends VectorCachedUniform { + + public Int2VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier supplier) { + super(name, updateFrequency, new Vector2i(), supplier); + } + + @Override + protected void setFrom(Vector2i other) { + this.cached.set(other); + } + + @Override + public void push(int location) { + GL20.glUniform2i(location, this.cached.x, this.cached.y); + } + + @Override + public void writeTo(FunctionReturn functionReturn) { + functionReturn.objectReturn = this.cached; + } + + @Override + public VectorType getType() { + return VectorType.I_VEC2; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/Int3VectorCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Int3VectorCachedUniform.java new file mode 100644 index 000000000..6ab5e1027 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/Int3VectorCachedUniform.java @@ -0,0 +1,30 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import net.coderbot.iris.parsing.VectorType; +import org.joml.Vector3i; +import org.lwjgl.opengl.GL20; + +import java.util.function.Supplier; + +public class Int3VectorCachedUniform extends VectorCachedUniform { + + public Int3VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier supplier) { + super(name, updateFrequency, new Vector3i(), supplier); + } + + @Override + protected void setFrom(Vector3i other) { + this.cached.set(other); + } + + @Override + public void push(int location) { + GL20.glUniform3i(location, this.cached.x, this.cached.y, this.cached.z); + } + + @Override + public VectorType getType() { + return VectorType.I_VEC3; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/IntCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/IntCachedUniform.java new file mode 100644 index 000000000..e4acfee43 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/IntCachedUniform.java @@ -0,0 +1,41 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import org.lwjgl.opengl.GL20; + +import java.util.function.IntSupplier; + +public class IntCachedUniform extends CachedUniform { + + final private IntSupplier supplier; + private int cached; + + public IntCachedUniform(String name, UniformUpdateFrequency updateFrequency, IntSupplier supplier) { + super(name, updateFrequency); + this.supplier = supplier; + } + + @Override + protected boolean doUpdate() { + int prev = this.cached; + this.cached = this.supplier.getAsInt(); + return prev != cached; + } + + @Override + public void push(int location) { + GL20.glUniform1i(location, this.cached); + } + + @Override + public void writeTo(FunctionReturn functionReturn) { + functionReturn.intReturn = this.cached; + } + + @Override + public Type getType() { + return Type.Int; + } +} diff --git a/src/main/java/net/coderbot/iris/uniforms/custom/cached/VectorCachedUniform.java b/src/main/java/net/coderbot/iris/uniforms/custom/cached/VectorCachedUniform.java new file mode 100644 index 000000000..4c8cf04a9 --- /dev/null +++ b/src/main/java/net/coderbot/iris/uniforms/custom/cached/VectorCachedUniform.java @@ -0,0 +1,47 @@ +package net.coderbot.iris.uniforms.custom.cached; + +import kroppeb.stareval.function.FunctionReturn; +import kroppeb.stareval.function.Type; +import net.coderbot.iris.Iris; +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import org.jetbrains.annotations.NotNull; + +import java.util.function.Supplier; + +public abstract class VectorCachedUniform extends CachedUniform { + + final protected T cached; + final private Supplier supplier; + + public VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, T cache, Supplier<@NotNull T> supplier) { + super(name, updateFrequency); + this.supplier = supplier; + this.cached = cache; + } + + abstract protected void setFrom(T other); + + @Override + protected boolean doUpdate() { + T other = this.supplier.get(); + if (other == null) { + Iris.logger.warn("Cached Uniform supplier gave null back"); + return false; + } + if (!this.cached.equals(other)) { + this.setFrom(other); + return true; + } else return false; + } + + @Override + public void writeTo(FunctionReturn functionReturn) { + + functionReturn.objectReturn = this.cached; + } + + @Override + public Type getType() { + return Type.Float; + } +}