mirror of
https://github.com/GTNewHorizons/CodeChickenCore.git
synced 2026-11-18 19:39:09 +00:00
Angelica Support - Static -> Instanced (#14)
Static -> Instanced * Now significantly more thread safe
This commit is contained in:
1 parent
e8dab57101
commit
14983449e8
20 files changed
+742
-236
No files matched your search
+9
-21
@@ -1,4 +1,4 @@
|
||||
//version: 1700844281
|
||||
//version: 1702141377
|
||||
/*
|
||||
DO NOT CHANGE THIS FILE!
|
||||
Also, you may replace this file at any time if there is an update available.
|
||||
@@ -28,27 +28,12 @@ import java.util.concurrent.TimeUnit
|
||||
|
||||
buildscript {
|
||||
repositories {
|
||||
mavenCentral()
|
||||
|
||||
maven {
|
||||
name 'forge'
|
||||
url 'https://maven.minecraftforge.net'
|
||||
}
|
||||
maven {
|
||||
// GTNH RetroFuturaGradle and ASM Fork
|
||||
name "GTNH Maven"
|
||||
url "http://jenkins.usrv.eu:8081/nexus/content/groups/public/"
|
||||
allowInsecureProtocol = true
|
||||
}
|
||||
maven {
|
||||
name 'sonatype'
|
||||
url 'https://oss.sonatype.org/content/repositories/snapshots/'
|
||||
}
|
||||
maven {
|
||||
name 'Scala CI dependencies'
|
||||
url 'https://repo1.maven.org/maven2/'
|
||||
}
|
||||
|
||||
mavenLocal()
|
||||
}
|
||||
}
|
||||
@@ -69,7 +54,7 @@ plugins {
|
||||
id 'com.diffplug.spotless' version '6.13.0' apply false // 6.13.0 is the last jvm8 supporting version
|
||||
id 'com.modrinth.minotaur' version '2.+' apply false
|
||||
id 'com.matthewprenger.cursegradle' version '1.4.0' apply false
|
||||
id 'com.gtnewhorizons.retrofuturagradle' version '1.3.24'
|
||||
id 'com.gtnewhorizons.retrofuturagradle' version '1.3.26'
|
||||
}
|
||||
|
||||
print("You might want to check out './gradlew :faq' if your build fails.\n")
|
||||
@@ -628,7 +613,7 @@ repositories {
|
||||
}
|
||||
maven {
|
||||
name = "ic2"
|
||||
url = getURL("https://maven.ic2.player.to/", "https://maven2.ic2.player.to/")
|
||||
url = getURL("https://maven2.ic2.player.to/", "https://maven.ic2.player.to/")
|
||||
content {
|
||||
includeGroup "net.industrial-craft"
|
||||
}
|
||||
@@ -687,6 +672,8 @@ configurations.all {
|
||||
substitute module('com.github.GTNewHorizons:SpongePoweredMixin') using module(mixinProviderSpecNoClassifer) withClassifier("dev") because("Unimixins replaces other mixin mods")
|
||||
substitute module('com.github.GTNewHorizons:SpongeMixins') using module(mixinProviderSpecNoClassifer) withClassifier("dev") because("Unimixins replaces other mixin mods")
|
||||
substitute module('io.github.legacymoddingmc:unimixins') using module(mixinProviderSpecNoClassifer) withClassifier("dev") because("Our previous unimixins upload was missing the dev classifier")
|
||||
|
||||
substitute module('org.scala-lang:scala-library:2.11.1') using module('org.scala-lang:scala-library:2.11.5') because('To allow mixing with Java 8 targets')
|
||||
}
|
||||
}
|
||||
|
||||
@@ -793,12 +780,12 @@ ext.java17PatchDependenciesCfg = configurations.create("java17PatchDependencies"
|
||||
}
|
||||
|
||||
dependencies {
|
||||
def lwjgl3ifyVersion = '1.5.1'
|
||||
def lwjgl3ifyVersion = '1.5.7'
|
||||
if (modId != 'lwjgl3ify') {
|
||||
java17Dependencies("com.github.GTNewHorizons:lwjgl3ify:${lwjgl3ifyVersion}")
|
||||
}
|
||||
if (modId != 'hodgepodge') {
|
||||
java17Dependencies('com.github.GTNewHorizons:Hodgepodge:2.3.17')
|
||||
java17Dependencies('com.github.GTNewHorizons:Hodgepodge:2.3.35')
|
||||
}
|
||||
|
||||
java17PatchDependencies("com.github.GTNewHorizons:lwjgl3ify:${lwjgl3ifyVersion}:forgePatches") {transitive = false}
|
||||
@@ -1310,7 +1297,7 @@ def addCurseForgeRelation(String type, String name) {
|
||||
|
||||
// Updating
|
||||
|
||||
def buildscriptGradleVersion = "8.2.1"
|
||||
def buildscriptGradleVersion = "8.5"
|
||||
|
||||
tasks.named('wrapper', Wrapper).configure {
|
||||
gradleVersion = buildscriptGradleVersion
|
||||
@@ -1621,3 +1608,4 @@ if (file('addon.late.local.gradle.kts').exists()) {
|
||||
} else if (file('addon.late.local.gradle').exists()) {
|
||||
apply from: 'addon.late.local.gradle'
|
||||
}
|
||||
|
||||
+9
-1
@@ -21,6 +21,15 @@ forgeVersion = 10.13.4.1614
|
||||
# Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
|
||||
developmentEnvironmentUserName = Developer
|
||||
|
||||
# Enables using modern java syntax (up to version 17) via Jabel, while still targetting JVM 8.
|
||||
# See https://github.com/bsideup/jabel for details on how this works.
|
||||
enableModernJavaSyntax = true
|
||||
|
||||
# Enables injecting missing generics into the decompiled source code for a better coding experience
|
||||
# Turns most publically visible List, Map, etc. into proper List<Type>, Map<K, V> types
|
||||
enableGenericInjection = true
|
||||
|
||||
|
||||
# Define a source file of your project with:
|
||||
# public static final String VERSION = "GRADLETOKEN_VERSION";
|
||||
# The string's content will be replaced with your mod's version when compiled. You should use this to specify your mod's
|
||||
@@ -87,4 +96,3 @@ modrinthProjectId = codechickenlib-unofficial
|
||||
# and the name is the Modrinth project or version slug/id of the other mod.
|
||||
|
||||
# modrinthRelations =
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
package codechicken.lib.asm;
|
||||
|
||||
/***
|
||||
* This Class is derived from the ASM ClassReader
|
||||
* <p>
|
||||
* ASM: a very small and fast Java bytecode manipulation framework Copyright (c) 2000-2011 INRIA, France Telecom All
|
||||
* rights reserved.
|
||||
* <p>
|
||||
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
|
||||
* following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation and/or other materials provided with the
|
||||
* distribution. 3. Neither the name of the copyright holders nor the names of its contributors may be used to endorse
|
||||
* or promote products derived from this software without specific prior written permission.
|
||||
* <p>
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
||||
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
import java.nio.charset.StandardCharsets;
|
||||
|
||||
import org.objectweb.asm.Opcodes;
|
||||
|
||||
/**
|
||||
* Using this class to search for a (single) String reference is > 40 times faster than parsing a class with a
|
||||
* ClassReader + ClassNode while using way less RAM
|
||||
*/
|
||||
public class ClassConstantPoolParser {
|
||||
|
||||
private static final int UTF8 = 1;
|
||||
private static final int INT = 3;
|
||||
private static final int FLOAT = 4;
|
||||
private static final int LONG = 5;
|
||||
private static final int DOUBLE = 6;
|
||||
private static final int FIELD = 9;
|
||||
private static final int METH = 10;
|
||||
private static final int IMETH = 11;
|
||||
private static final int NAME_TYPE = 12;
|
||||
private static final int HANDLE = 15;
|
||||
private static final int INDY = 18;
|
||||
|
||||
private final byte[][] BYTES_TO_SEARCH;
|
||||
|
||||
public ClassConstantPoolParser(String... strings) {
|
||||
BYTES_TO_SEARCH = new byte[strings.length][];
|
||||
for (int i = 0; i < BYTES_TO_SEARCH.length; i++) {
|
||||
BYTES_TO_SEARCH[i] = strings[i].getBytes(StandardCharsets.UTF_8);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the constant pool of the class represented by this byte array contains one of the Strings we are
|
||||
* looking for
|
||||
*/
|
||||
public boolean find(byte[] basicClass) {
|
||||
if (basicClass == null || basicClass.length == 0) {
|
||||
return false;
|
||||
}
|
||||
// checks the class version
|
||||
if (readShort(6, basicClass) > Opcodes.V1_8) {
|
||||
return false;
|
||||
}
|
||||
// parses the constant pool
|
||||
int n = readUnsignedShort(8, basicClass);
|
||||
int index = 10;
|
||||
for (int i = 1; i < n; ++i) {
|
||||
int size;
|
||||
switch (basicClass[index]) {
|
||||
case FIELD, METH, IMETH, INT, FLOAT, NAME_TYPE, INDY -> size = 5;
|
||||
case LONG, DOUBLE -> {
|
||||
size = 9;
|
||||
++i;
|
||||
}
|
||||
case UTF8 -> {
|
||||
final int strLen = readUnsignedShort(index + 1, basicClass);
|
||||
size = 3 + strLen;
|
||||
label: for (byte[] bytes : BYTES_TO_SEARCH) {
|
||||
if (strLen == bytes.length) {
|
||||
for (int j = index + 3; j < index + 3 + strLen; j++) {
|
||||
if (basicClass[j] != bytes[j - (index + 3)]) {
|
||||
break label;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
case HANDLE -> size = 4;
|
||||
default -> size = 3;
|
||||
}
|
||||
index += size;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private static short readShort(final int index, byte[] basicClass) {
|
||||
return (short) (((basicClass[index] & 0xFF) << 8) | (basicClass[index + 1] & 0xFF));
|
||||
}
|
||||
|
||||
private static int readUnsignedShort(final int index, byte[] basicClass) {
|
||||
return ((basicClass[index] & 0xFF) << 8) | (basicClass[index + 1] & 0xFF);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -36,8 +36,8 @@ public class ObfMapping {
|
||||
|
||||
public static class ObfRemapper extends Remapper {
|
||||
|
||||
private HashMap<String, String> fields = new HashMap<String, String>();
|
||||
private HashMap<String, String> funcs = new HashMap<String, String>();
|
||||
private final HashMap<String, String> fields = new HashMap<>();
|
||||
private final HashMap<String, String> funcs = new HashMap<>();
|
||||
|
||||
public ObfRemapper() {
|
||||
try {
|
||||
@@ -174,8 +174,8 @@ public class ObfMapping {
|
||||
return new File[] { srgs, methods, fields };
|
||||
}
|
||||
|
||||
private HashMap<String, String> fields = new HashMap<String, String>();
|
||||
private HashMap<String, String> funcs = new HashMap<String, String>();
|
||||
private final HashMap<String, String> fields = new HashMap<>();
|
||||
private final HashMap<String, String> funcs = new HashMap<>();
|
||||
|
||||
public MCPRemapper() {
|
||||
File[] mappings = getConfFiles();
|
||||
|
||||
@@ -0,0 +1,207 @@
|
||||
package codechicken.lib.asm;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import java.io.PrintWriter;
|
||||
import java.nio.file.Files;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import net.minecraft.launchwrapper.IClassTransformer;
|
||||
import net.minecraft.launchwrapper.Launch;
|
||||
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.objectweb.asm.ClassReader;
|
||||
import org.objectweb.asm.ClassWriter;
|
||||
import org.objectweb.asm.Opcodes;
|
||||
import org.objectweb.asm.tree.AbstractInsnNode;
|
||||
import org.objectweb.asm.tree.ClassNode;
|
||||
import org.objectweb.asm.tree.FieldInsnNode;
|
||||
import org.objectweb.asm.tree.InsnList;
|
||||
import org.objectweb.asm.tree.InsnNode;
|
||||
import org.objectweb.asm.tree.MethodInsnNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
import org.objectweb.asm.util.ASMifier;
|
||||
import org.objectweb.asm.util.Textifier;
|
||||
import org.objectweb.asm.util.TraceClassVisitor;
|
||||
|
||||
public class RedirectorTransformer implements IClassTransformer {
|
||||
|
||||
private static final boolean DUMP_CLASSES = Boolean.parseBoolean(System.getProperty("ccl.dumpClass", "false"));
|
||||
private static final String RenderStateClass = "codechicken/lib/render/CCRenderState";
|
||||
private static final Set<String> redirectedFields = new HashSet<>();
|
||||
private static final Set<String> redirectedSimpleMethods = new HashSet<>();
|
||||
private static final Set<String> redirectedMethods = new HashSet<>();
|
||||
private static final ClassConstantPoolParser cstPoolParser;
|
||||
|
||||
static {
|
||||
Collections.addAll(
|
||||
redirectedFields,
|
||||
"pipeline",
|
||||
"model",
|
||||
"firstVertexIndex",
|
||||
"lastVertexIndex",
|
||||
"vertexIndex",
|
||||
"baseColour",
|
||||
"alphaOverride",
|
||||
"useNormals",
|
||||
"computeLighting",
|
||||
"useColour",
|
||||
"lightMatrix",
|
||||
"vert",
|
||||
"hasNormal",
|
||||
"normal",
|
||||
"hasColour",
|
||||
"colour",
|
||||
"hasBrightness",
|
||||
"brightness",
|
||||
"side",
|
||||
"lc"
|
||||
|
||||
);
|
||||
Collections.addAll(redirectedSimpleMethods, "reset", "pullLightmap", "pushLightmap", "setDynamic", "draw");
|
||||
Collections.addAll(
|
||||
redirectedMethods,
|
||||
"setPipeline",
|
||||
"bindModel",
|
||||
"setModel",
|
||||
"setVertexRange",
|
||||
"render",
|
||||
"runPipeline",
|
||||
"writeVert",
|
||||
"setNormal",
|
||||
"setColour",
|
||||
"setBrightness",
|
||||
"startDrawing");
|
||||
|
||||
cstPoolParser = new ClassConstantPoolParser(RenderStateClass);
|
||||
}
|
||||
|
||||
@Override
|
||||
public byte[] transform(String name, String transformedName, byte[] basicClass) {
|
||||
if (!cstPoolParser.find(basicClass)) {
|
||||
return basicClass;
|
||||
}
|
||||
|
||||
final ClassReader cr = new ClassReader(basicClass);
|
||||
final ClassNode cn = new ClassNode();
|
||||
cr.accept(cn, 0);
|
||||
boolean changed = false;
|
||||
|
||||
for (MethodNode mn : cn.methods) {
|
||||
for (AbstractInsnNode node : mn.instructions.toArray()) {
|
||||
if (node instanceof FieldInsnNode fNode) {
|
||||
if (node.getOpcode() == Opcodes.GETSTATIC && redirectedFields.contains(fNode.name)
|
||||
&& fNode.owner.equals(RenderStateClass)) {
|
||||
mn.instructions.insertBefore(
|
||||
fNode,
|
||||
new MethodInsnNode(
|
||||
Opcodes.INVOKESTATIC,
|
||||
fNode.owner,
|
||||
"instance",
|
||||
"()Lcodechicken/lib/render/CCRenderState;"));
|
||||
fNode.setOpcode(Opcodes.GETFIELD);
|
||||
changed = true;
|
||||
} else if (node.getOpcode() == Opcodes.PUTSTATIC
|
||||
&& (redirectedFields.contains(fNode.name) && fNode.owner.equals(RenderStateClass))) {
|
||||
InsnList beforePut = new InsnList();
|
||||
beforePut.add(
|
||||
new MethodInsnNode(
|
||||
Opcodes.INVOKESTATIC,
|
||||
fNode.owner,
|
||||
"instance",
|
||||
"()Lcodechicken/lib/render/CCRenderState;"));
|
||||
beforePut.add(new InsnNode(Opcodes.SWAP));
|
||||
mn.instructions.insertBefore(fNode, beforePut);
|
||||
fNode.setOpcode(Opcodes.PUTFIELD);
|
||||
changed = true;
|
||||
|
||||
}
|
||||
} else if (node.getOpcode() == Opcodes.INVOKESTATIC && node instanceof MethodInsnNode mNode) {
|
||||
if (redirectedMethods.contains(mNode.name) && mNode.owner.equals(RenderStateClass)) {
|
||||
mNode.name = mNode.name + "Static";
|
||||
changed = true;
|
||||
} else if (redirectedSimpleMethods.contains(mNode.name) && mNode.owner.equals(RenderStateClass)) {
|
||||
mn.instructions.insertBefore(
|
||||
mNode,
|
||||
new MethodInsnNode(
|
||||
Opcodes.INVOKESTATIC,
|
||||
mNode.owner,
|
||||
"instance",
|
||||
"()Lcodechicken/lib/render/CCRenderState;"));
|
||||
mNode.setOpcode(Opcodes.INVOKEVIRTUAL);
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (changed) {
|
||||
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
|
||||
cn.accept(cw);
|
||||
final byte[] bytes = cw.toByteArray();
|
||||
if (DUMP_CLASSES) {
|
||||
saveTransformedClass(bytes, transformedName);
|
||||
saveTransformedClass(basicClass, transformedName + "_original");
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
return basicClass;
|
||||
}
|
||||
|
||||
private File outputDir = null;
|
||||
|
||||
private void saveTransformedClass(final byte[] data, final String transformedName) {
|
||||
if (!DUMP_CLASSES) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (outputDir == null) {
|
||||
outputDir = new File(Launch.minecraftHome, "ASM_REDIRECTOR");
|
||||
try {
|
||||
FileUtils.deleteDirectory(outputDir);
|
||||
} catch (IOException ignored) {}
|
||||
if (!outputDir.exists()) {
|
||||
// noinspection ResultOfMethodCallIgnored
|
||||
outputDir.mkdirs();
|
||||
}
|
||||
}
|
||||
|
||||
final String fileName = transformedName.replace('.', File.separatorChar);
|
||||
final File classFile = new File(outputDir, fileName + ".class");
|
||||
final File bytecodeFile = new File(outputDir, fileName + "_BYTE.txt");
|
||||
final File asmifiedFile = new File(outputDir, fileName + "_ASM.txt");
|
||||
final File outDir = classFile.getParentFile();
|
||||
if (!outDir.exists()) {
|
||||
outDir.mkdirs();
|
||||
}
|
||||
if (classFile.exists()) {
|
||||
classFile.delete();
|
||||
}
|
||||
try (final OutputStream output = Files.newOutputStream(classFile.toPath())) {
|
||||
output.write(data);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
if (bytecodeFile.exists()) {
|
||||
bytecodeFile.delete();
|
||||
}
|
||||
try (final OutputStream output = Files.newOutputStream(bytecodeFile.toPath())) {
|
||||
final ClassReader classReader = new ClassReader(data);
|
||||
classReader.accept(new TraceClassVisitor(null, new Textifier(), new PrintWriter(output)), 0);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
if (asmifiedFile.exists()) {
|
||||
asmifiedFile.delete();
|
||||
}
|
||||
try (final OutputStream output = Files.newOutputStream(asmifiedFile.toPath())) {
|
||||
final ClassReader classReader = new ClassReader(data);
|
||||
classReader.accept(new TraceClassVisitor(null, new ASMifier(), new PrintWriter(output)), 0);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -62,16 +62,20 @@ public class Canvas9Seg {
|
||||
t.addVertexWithUV(sw[u + 1], sh[v], 0, seg_u[u + 1], seg_v[v]);
|
||||
}
|
||||
|
||||
public void draw(int x, int y, int w, int h) {
|
||||
public void draw(CCRenderState state, int x, int y, int w, int h) {
|
||||
CCRenderState.changeTexture(tex);
|
||||
CCRenderState.reset();
|
||||
CCRenderState.startDrawing();
|
||||
state.reset();
|
||||
state.startDrawing();
|
||||
|
||||
int[] sw = new int[] { x, x + seg_w[0], x + w - seg_w[2], x + w };
|
||||
int[] sh = new int[] { y, y + seg_h[0], y + h - seg_h[2], y + h };
|
||||
|
||||
for (int seg = 0; seg < 9; seg++) drawSeg(sw, sh, seg);
|
||||
|
||||
CCRenderState.draw();
|
||||
state.draw();
|
||||
}
|
||||
|
||||
public void draw(int x, int y, int w, int h) {
|
||||
draw(CCRenderState.instance(), x, y, w, h);
|
||||
}
|
||||
}
|
||||
@@ -114,22 +114,22 @@ public class LightMatrix implements CCRenderState.IVertexOperation {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
if (!CCRenderState.computeLighting) return false;
|
||||
public boolean load(CCRenderState state) {
|
||||
if (!state.computeLighting) return false;
|
||||
|
||||
CCRenderState.pipeline.addDependency(CCRenderState.colourAttrib);
|
||||
CCRenderState.pipeline.addDependency(CCRenderState.lightCoordAttrib);
|
||||
state.pipeline.addDependency(state.colourAttrib);
|
||||
state.pipeline.addDependency(state.lightCoordAttrib);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
LC lc = CCRenderState.lc;
|
||||
public void operate(CCRenderState state) {
|
||||
LC lc = state.lc;
|
||||
float[] a = ao(lc.side);
|
||||
float f = (a[0] * lc.fa + a[1] * lc.fb + a[2] * lc.fc + a[3] * lc.fd);
|
||||
int[] b = brightness(lc.side);
|
||||
CCRenderState.setColour(ColourRGBA.multiplyC(CCRenderState.colour, f));
|
||||
CCRenderState.setBrightness((int) (b[0] * lc.fa + b[1] * lc.fb + b[2] * lc.fc + b[3] * lc.fd) & 0xFF00FF);
|
||||
state.setColour(ColourRGBA.multiplyC(state.colour, f));
|
||||
state.setBrightness((int) (b[0] * lc.fa + b[1] * lc.fb + b[2] * lc.fc + b[3] * lc.fd) & 0xFF00FF);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -78,17 +78,17 @@ public class LightModel implements CCRenderState.IVertexOperation {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
if (!CCRenderState.computeLighting) return false;
|
||||
public boolean load(CCRenderState state) {
|
||||
if (!state.computeLighting) return false;
|
||||
|
||||
CCRenderState.pipeline.addDependency(CCRenderState.normalAttrib);
|
||||
CCRenderState.pipeline.addDependency(CCRenderState.colourAttrib);
|
||||
state.pipeline.addDependency(CCRenderState.normalAttrib);
|
||||
state.pipeline.addDependency(CCRenderState.colourAttrib);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
CCRenderState.setColour(apply(CCRenderState.colour, CCRenderState.normal));
|
||||
public void operate(CCRenderState state) {
|
||||
state.setColour(apply(state.colour, state.normal));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -39,15 +39,15 @@ public class PlanarLightMatrix extends PlanarLightModel {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
CCRenderState.pipeline.addDependency(CCRenderState.sideAttrib);
|
||||
public boolean load(CCRenderState state) {
|
||||
state.pipeline.addDependency(CCRenderState.sideAttrib);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
super.operate();
|
||||
CCRenderState.setBrightness(brightness(CCRenderState.side));
|
||||
public void operate(CCRenderState state) {
|
||||
super.operate(state);
|
||||
state.setBrightness(brightness(state.side));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -17,17 +17,17 @@ public class PlanarLightModel implements CCRenderState.IVertexOperation {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
if (!CCRenderState.computeLighting) return false;
|
||||
public boolean load(CCRenderState state) {
|
||||
if (!state.computeLighting) return false;
|
||||
|
||||
CCRenderState.pipeline.addDependency(CCRenderState.sideAttrib);
|
||||
CCRenderState.pipeline.addDependency(CCRenderState.colourAttrib);
|
||||
state.pipeline.addDependency(CCRenderState.sideAttrib);
|
||||
state.pipeline.addDependency(CCRenderState.colourAttrib);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
CCRenderState.setColour(ColourRGBA.multiply(CCRenderState.colour, colours[CCRenderState.side]));
|
||||
public void operate(CCRenderState state) {
|
||||
state.setColour(ColourRGBA.multiply(state.colour, colours[state.side]));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -18,8 +18,8 @@ public class SimpleBrightnessModel implements CCRenderState.IVertexOperation {
|
||||
public BlockCoord pos = new BlockCoord();
|
||||
|
||||
private int sampled = 0;
|
||||
private int[] samples = new int[6];
|
||||
private BlockCoord c = new BlockCoord();
|
||||
private final int[] samples = new int[6];
|
||||
private final BlockCoord c = new BlockCoord();
|
||||
|
||||
public void locate(IBlockAccess a, int x, int y, int z) {
|
||||
access = a;
|
||||
@@ -39,14 +39,14 @@ public class SimpleBrightnessModel implements CCRenderState.IVertexOperation {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
CCRenderState.pipeline.addDependency(CCRenderState.sideAttrib);
|
||||
public boolean load(CCRenderState state) {
|
||||
state.pipeline.addDependency(CCRenderState.sideAttrib);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
CCRenderState.setBrightness(sample(CCRenderState.side));
|
||||
public void operate(CCRenderState state) {
|
||||
state.setBrightness(sample(state.side));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -29,8 +29,8 @@ public class BlockRenderer {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void prepareVertex() {
|
||||
CCRenderState.side = side;
|
||||
public void prepareVertex(CCRenderState state) {
|
||||
state.side = side;
|
||||
}
|
||||
|
||||
public BlockFace computeLightCoords() {
|
||||
@@ -145,16 +145,21 @@ public class BlockRenderer {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void prepareVertex() {
|
||||
CCRenderState.side = CCRenderState.vertexIndex >> 2;
|
||||
public void prepareVertex(CCRenderState state) {
|
||||
state.side = state.vertexIndex >> 2;
|
||||
}
|
||||
}
|
||||
|
||||
public static FullBlock fullBlock = new FullBlock();
|
||||
|
||||
// public static void renderFullBlock(int sideMask) {
|
||||
public static void renderFullBlock(CCRenderState state, int sideMask) {
|
||||
state.setModel(fullBlock);
|
||||
renderFaces(state, sideMask);
|
||||
}
|
||||
|
||||
public static void renderFullBlock(int sideMask) {
|
||||
CCRenderState.setModel(fullBlock);
|
||||
renderFaces(sideMask);
|
||||
renderFullBlock(CCRenderState.instance(), sideMask);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -162,15 +167,20 @@ public class BlockRenderer {
|
||||
*
|
||||
* @param sideMask A mask of faces not to render
|
||||
*/
|
||||
public static void renderFaces(int sideMask) {
|
||||
// public static void renderFaces(int sideMask) {
|
||||
public static void renderFaces(CCRenderState state, int sideMask) {
|
||||
if (sideMask == 0x3F) return;
|
||||
for (int s = 0; s < 6; s++) if ((sideMask & 1 << s) == 0) {
|
||||
CCRenderState.setVertexRange(s * 4, (s + 1) * 4);
|
||||
CCRenderState.render();
|
||||
state.setVertexRange(s * 4, (s + 1) * 4);
|
||||
state.render();
|
||||
}
|
||||
}
|
||||
|
||||
private static BlockFace face = new BlockFace();
|
||||
public static void renderFaces(int sideMask) {
|
||||
renderFaces(CCRenderState.instance(), sideMask);
|
||||
}
|
||||
|
||||
private static final BlockFace face = new BlockFace();
|
||||
|
||||
/**
|
||||
* Renders faces of a cuboid with texture coordinates mapped to match a standard minecraft block
|
||||
@@ -178,13 +188,17 @@ public class BlockRenderer {
|
||||
* @param bounds The bounding cuboid to render
|
||||
* @param sideMask A mask of faces not to render
|
||||
*/
|
||||
public static void renderCuboid(Cuboid6 bounds, int sideMask) {
|
||||
public static void renderCuboid(CCRenderState state, Cuboid6 bounds, int sideMask) {
|
||||
if (sideMask == 0x3F) return;
|
||||
|
||||
CCRenderState.setModel(face);
|
||||
state.setModel(face);
|
||||
for (int s = 0; s < 6; s++) if ((sideMask & 1 << s) == 0) {
|
||||
face.loadCuboidFace(bounds, s);
|
||||
CCRenderState.render();
|
||||
state.render();
|
||||
}
|
||||
}
|
||||
|
||||
public static void renderCuboid(Cuboid6 bounds, int sideMask) {
|
||||
renderCuboid(CCRenderState.instance(), bounds, sideMask);
|
||||
}
|
||||
}
|
||||
@@ -32,6 +32,7 @@ import codechicken.lib.vec.Transformation;
|
||||
import codechicken.lib.vec.TransformationList;
|
||||
import codechicken.lib.vec.Vector3;
|
||||
|
||||
@SuppressWarnings("ForLoopReplaceableByForEach")
|
||||
public class CCModel implements CCRenderState.IVertexSource, Copyable<CCModel> {
|
||||
|
||||
private static class PositionNormalEntry {
|
||||
@@ -88,7 +89,7 @@ public class CCModel implements CCRenderState.IVertexSource, Copyable<CCModel> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void prepareVertex() {}
|
||||
public void prepareVertex(CCRenderState state) {}
|
||||
|
||||
public <T> T getOrAllocate(CCRenderState.VertexAttribute<T> attrib) {
|
||||
T array = getAttributes(attrib);
|
||||
@@ -426,20 +427,36 @@ public class CCModel implements CCRenderState.IVertexSource, Copyable<CCModel> {
|
||||
return this;
|
||||
}
|
||||
|
||||
public void render(CCRenderState state, double x, double y, double z, double u, double v) {
|
||||
render(state, new Vector3(x, y, z).translation(), new UVTranslation(u, v));
|
||||
}
|
||||
|
||||
public void render(double x, double y, double z, double u, double v) {
|
||||
render(new Vector3(x, y, z).translation(), new UVTranslation(u, v));
|
||||
render(CCRenderState.instance(), new Vector3(x, y, z).translation(), new UVTranslation(u, v));
|
||||
}
|
||||
|
||||
public void render(CCRenderState state, double x, double y, double z, UVTransformation u) {
|
||||
render(state, new Vector3(x, y, z).translation(), u);
|
||||
}
|
||||
|
||||
public void render(double x, double y, double z, UVTransformation u) {
|
||||
render(new Vector3(x, y, z).translation(), u);
|
||||
render(CCRenderState.instance(), new Vector3(x, y, z).translation(), u);
|
||||
}
|
||||
|
||||
public void render(CCRenderState state, Transformation t, double u, double v) {
|
||||
render(state, t, new UVTranslation(u, v));
|
||||
}
|
||||
|
||||
public void render(Transformation t, double u, double v) {
|
||||
render(t, new UVTranslation(u, v));
|
||||
render(CCRenderState.instance(), t, new UVTranslation(u, v));
|
||||
}
|
||||
|
||||
public void render(CCRenderState state, CCRenderState.IVertexOperation... ops) {
|
||||
render(state, 0, verts.length, ops);
|
||||
}
|
||||
|
||||
public void render(CCRenderState.IVertexOperation... ops) {
|
||||
render(0, verts.length, ops);
|
||||
render(CCRenderState.instance(), 0, verts.length, ops);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -449,9 +466,13 @@ public class CCModel implements CCRenderState.IVertexSource, Copyable<CCModel> {
|
||||
* @param end The vertex index to render until
|
||||
* @param ops Operations to apply
|
||||
*/
|
||||
public void render(CCRenderState state, int start, int end, CCRenderState.IVertexOperation... ops) {
|
||||
state.setPipeline(this, start, end, ops);
|
||||
state.render();
|
||||
}
|
||||
|
||||
public void render(int start, int end, CCRenderState.IVertexOperation... ops) {
|
||||
CCRenderState.setPipeline(this, start, end, ops);
|
||||
CCRenderState.render();
|
||||
render(CCRenderState.instance(), start, end, ops);
|
||||
}
|
||||
|
||||
public static CCModel quadModel(int numVerts) {
|
||||
|
||||
@@ -1,21 +1,45 @@
|
||||
package codechicken.lib.render;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
|
||||
import codechicken.lib.render.CCRenderState.IVertexOperation;
|
||||
import codechicken.lib.render.CCRenderState.VertexAttribute;
|
||||
|
||||
@SuppressWarnings("ForLoopReplaceableByForEach")
|
||||
public class CCRenderPipeline {
|
||||
|
||||
private final CCRenderState renderState;
|
||||
private final PipelineBuilder builder;
|
||||
|
||||
public CCRenderPipeline(CCRenderState renderState) {
|
||||
this.renderState = renderState;
|
||||
builder = new PipelineBuilder(renderState);
|
||||
}
|
||||
|
||||
public CCRenderPipeline() {
|
||||
this(CCRenderState.instance());
|
||||
}
|
||||
|
||||
public class PipelineBuilder {
|
||||
|
||||
private final CCRenderState renderState;
|
||||
|
||||
public PipelineBuilder(CCRenderState renderState) {
|
||||
this.renderState = renderState;
|
||||
}
|
||||
|
||||
public PipelineBuilder() {
|
||||
this(CCRenderState.instance());
|
||||
}
|
||||
|
||||
public PipelineBuilder add(IVertexOperation op) {
|
||||
ops.add(op);
|
||||
return this;
|
||||
}
|
||||
|
||||
public PipelineBuilder add(IVertexOperation... ops) {
|
||||
for (int i = 0; i < ops.length; i++) CCRenderPipeline.this.ops.add(ops[i]);
|
||||
Collections.addAll(CCRenderPipeline.this.ops, ops);
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -25,13 +49,13 @@ public class CCRenderPipeline {
|
||||
|
||||
public void render() {
|
||||
rebuild();
|
||||
CCRenderState.render();
|
||||
renderState.render();
|
||||
}
|
||||
}
|
||||
|
||||
private class PipelineNode {
|
||||
|
||||
public ArrayList<PipelineNode> deps = new ArrayList<PipelineNode>();
|
||||
public ArrayList<PipelineNode> deps = new ArrayList<>();
|
||||
public IVertexOperation op;
|
||||
|
||||
public void add() {
|
||||
@@ -44,12 +68,11 @@ public class CCRenderPipeline {
|
||||
}
|
||||
}
|
||||
|
||||
private ArrayList<VertexAttribute> attribs = new ArrayList<VertexAttribute>();
|
||||
private ArrayList<IVertexOperation> ops = new ArrayList<IVertexOperation>();
|
||||
private ArrayList<PipelineNode> nodes = new ArrayList<PipelineNode>();
|
||||
private ArrayList<IVertexOperation> sorted = new ArrayList<IVertexOperation>();
|
||||
private final ArrayList<VertexAttribute> attribs = new ArrayList<>();
|
||||
private final ArrayList<IVertexOperation> ops = new ArrayList<>();
|
||||
private final ArrayList<PipelineNode> nodes = new ArrayList<>();
|
||||
private final ArrayList<IVertexOperation> sorted = new ArrayList<>();
|
||||
private PipelineNode loading;
|
||||
private PipelineBuilder builder = new PipelineBuilder();
|
||||
|
||||
public void setPipeline(IVertexOperation... ops) {
|
||||
this.ops.clear();
|
||||
@@ -69,20 +92,20 @@ public class CCRenderPipeline {
|
||||
}
|
||||
|
||||
public void rebuild() {
|
||||
if (ops.isEmpty() || CCRenderState.model == null) return;
|
||||
if (ops.isEmpty() || this.renderState.model == null) return;
|
||||
|
||||
// ensure enough nodes for all ops
|
||||
while (nodes.size() < CCRenderState.operationCount()) nodes.add(new PipelineNode());
|
||||
while (nodes.size() < this.renderState.operationCount()) nodes.add(new PipelineNode());
|
||||
unbuild();
|
||||
|
||||
if (CCRenderState.useNormals) addAttribute(CCRenderState.normalAttrib);
|
||||
if (CCRenderState.useColour) addAttribute(CCRenderState.colourAttrib);
|
||||
if (CCRenderState.computeLighting) addAttribute(CCRenderState.lightingAttrib);
|
||||
if (this.renderState.useNormals) addAttribute(this.renderState.normalAttrib);
|
||||
if (this.renderState.useColour) addAttribute(this.renderState.colourAttrib);
|
||||
if (this.renderState.computeLighting) addAttribute(this.renderState.lightingAttrib);
|
||||
|
||||
for (int i = 0; i < ops.size(); i++) {
|
||||
IVertexOperation op = ops.get(i);
|
||||
loading = nodes.get(op.operationID());
|
||||
boolean loaded = op.load();
|
||||
boolean loaded = op.load(renderState);
|
||||
if (loaded) loading.op = op;
|
||||
|
||||
if (op instanceof VertexAttribute) if (loaded) attribs.add((VertexAttribute) op);
|
||||
@@ -109,7 +132,7 @@ public class CCRenderPipeline {
|
||||
}
|
||||
|
||||
public void operate() {
|
||||
for (int i = 0; i < sorted.size(); i++) sorted.get(i).operate();
|
||||
for (int i = 0; i < sorted.size(); i++) sorted.get(i).operate(renderState);
|
||||
}
|
||||
|
||||
public PipelineBuilder builder() {
|
||||
|
||||
@@ -17,11 +17,27 @@ import codechicken.lib.vec.Transformation;
|
||||
import codechicken.lib.vec.Vector3;
|
||||
|
||||
/**
|
||||
* The core of the CodeChickenLib render system. Rendering operations are written to avoid object allocations by reusing
|
||||
* static variables.
|
||||
* The core of the CodeChickenLib render system. Where possible assign a local var of CCRenderState to avoid millions of
|
||||
* calls to instance(); Uses a ThreadLocal system to assign each thread their own CCRenderState so we can use it in
|
||||
* Multithreaded chunk batching.
|
||||
* <p>
|
||||
* Backported from CCL - 1.16.x
|
||||
*/
|
||||
|
||||
public class CCRenderState {
|
||||
|
||||
public final CCRenderPipeline pipeline;
|
||||
|
||||
private static final ThreadLocal<CCRenderState> instances = ThreadLocal.withInitial(CCRenderState::new);
|
||||
|
||||
private CCRenderState() {
|
||||
pipeline = new CCRenderPipeline(this);
|
||||
}
|
||||
|
||||
public static CCRenderState instance() {
|
||||
return instances.get();
|
||||
}
|
||||
|
||||
private static int nextOperationIndex;
|
||||
|
||||
public static int registerOperation() {
|
||||
@@ -35,28 +51,43 @@ public class CCRenderState {
|
||||
/**
|
||||
* Represents an operation to be run for each vertex that operates on and modifies the current state
|
||||
*/
|
||||
public static interface IVertexOperation {
|
||||
public interface IVertexOperation {
|
||||
|
||||
/**
|
||||
* Load any required references and add dependencies to the pipeline based on the current model (may be null)
|
||||
* Return false if this operation is redundant in the pipeline with the given model
|
||||
*/
|
||||
public boolean load();
|
||||
default boolean load() {
|
||||
// Existing code will will override this method so it shouldn't infinite loop
|
||||
// Default it only for new state aware code
|
||||
return load(CCRenderState.instance());
|
||||
}
|
||||
|
||||
default boolean load(CCRenderState state) {
|
||||
// New code will override this and not inplement load() so we shouldn't infinite loop
|
||||
return load();
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform the operation on the current render state
|
||||
*/
|
||||
public void operate();
|
||||
default void operate() {
|
||||
operate(CCRenderState.instance());
|
||||
}
|
||||
|
||||
default void operate(CCRenderState state) {
|
||||
operate();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the unique id representing this type of operation. Duplicate operation IDs within the pipeline may have
|
||||
* unexpected results. ID shoulld be obtained from CCRenderState.registerOperation() and stored in a static
|
||||
* variable
|
||||
*/
|
||||
public int operationID();
|
||||
int operationID();
|
||||
}
|
||||
|
||||
private static ArrayList<VertexAttribute<?>> vertexAttributes = new ArrayList<VertexAttribute<?>>();
|
||||
private static ArrayList<VertexAttribute<?>> vertexAttributes = new ArrayList<>();
|
||||
|
||||
private static int registerVertexAttribute(VertexAttribute<?> attr) {
|
||||
vertexAttributes.add(attr);
|
||||
@@ -109,9 +140,9 @@ public class CCRenderState {
|
||||
return dst;
|
||||
}
|
||||
|
||||
public static interface IVertexSource {
|
||||
public interface IVertexSource {
|
||||
|
||||
public Vertex5[] getVertices();
|
||||
Vertex5[] getVertices();
|
||||
|
||||
/**
|
||||
* Gets an array of vertex attrutes
|
||||
@@ -120,21 +151,25 @@ public class CCRenderState {
|
||||
* @param <T> The attrute array type
|
||||
* @return An array, or null if not computed
|
||||
*/
|
||||
public <T> T getAttributes(VertexAttribute<T> attr);
|
||||
<T> T getAttributes(VertexAttribute<T> attr);
|
||||
|
||||
/**
|
||||
* @return True if the specified attrute is provided by this model, either by returning an array from
|
||||
* getAttributes or by setting the state in prepareVertex
|
||||
*/
|
||||
public boolean hasAttribute(VertexAttribute<?> attr);
|
||||
boolean hasAttribute(VertexAttribute<?> attr);
|
||||
|
||||
/**
|
||||
* Callback to set CCRenderState for a vertex before the pipeline runs
|
||||
*/
|
||||
public void prepareVertex();
|
||||
void prepareVertex(CCRenderState state);
|
||||
|
||||
default void prepareVertex() {
|
||||
prepareVertex(CCRenderState.instance());
|
||||
}
|
||||
}
|
||||
|
||||
public static VertexAttribute<Vector3[]> normalAttrib = new VertexAttribute<Vector3[]>() {
|
||||
public static VertexAttribute<Vector3[]> normalAttrib = new VertexAttribute<>() {
|
||||
|
||||
private Vector3[] normalRef;
|
||||
|
||||
@@ -144,12 +179,12 @@ public class CCRenderState {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
normalRef = model.getAttributes(this);
|
||||
if (model.hasAttribute(this)) return normalRef != null;
|
||||
public boolean load(CCRenderState state) {
|
||||
normalRef = state.model.getAttributes(this);
|
||||
if (state.model.hasAttribute(this)) return normalRef != null;
|
||||
|
||||
if (model.hasAttribute(sideAttrib)) {
|
||||
pipeline.addDependency(sideAttrib);
|
||||
if (state.model.hasAttribute(sideAttrib)) {
|
||||
state.pipeline.addDependency(sideAttrib);
|
||||
return true;
|
||||
}
|
||||
throw new IllegalStateException(
|
||||
@@ -157,12 +192,12 @@ public class CCRenderState {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
if (normalRef != null) setNormal(normalRef[vertexIndex]);
|
||||
else setNormal(Rotation.axes[side]);
|
||||
public void operate(CCRenderState state) {
|
||||
if (normalRef != null) state.setNormal(normalRef[state.vertexIndex]);
|
||||
else state.setNormal(Rotation.axes[state.side]);
|
||||
}
|
||||
};
|
||||
public static VertexAttribute<int[]> colourAttrib = new VertexAttribute<int[]>() {
|
||||
public static VertexAttribute<int[]> colourAttrib = new VertexAttribute<>() {
|
||||
|
||||
private int[] colourRef;
|
||||
|
||||
@@ -172,18 +207,18 @@ public class CCRenderState {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
colourRef = model.getAttributes(this);
|
||||
return colourRef != null || !model.hasAttribute(this);
|
||||
public boolean load(CCRenderState state) {
|
||||
colourRef = state.model.getAttributes(this);
|
||||
return colourRef != null || !state.model.hasAttribute(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
if (colourRef != null) setColour(ColourRGBA.multiply(baseColour, colourRef[vertexIndex]));
|
||||
else setColour(baseColour);
|
||||
public void operate(CCRenderState state) {
|
||||
if (colourRef != null) state.setColour(ColourRGBA.multiply(state.baseColour, colourRef[state.vertexIndex]));
|
||||
else state.setColour(state.baseColour);
|
||||
}
|
||||
};
|
||||
public static VertexAttribute<int[]> lightingAttrib = new VertexAttribute<int[]>() {
|
||||
public static VertexAttribute<int[]> lightingAttrib = new VertexAttribute<>() {
|
||||
|
||||
private int[] colourRef;
|
||||
|
||||
@@ -193,23 +228,23 @@ public class CCRenderState {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
if (!computeLighting || !useColour || !model.hasAttribute(this)) return false;
|
||||
public boolean load(CCRenderState state) {
|
||||
if (!state.computeLighting || !state.useColour || !state.model.hasAttribute(this)) return false;
|
||||
|
||||
colourRef = model.getAttributes(this);
|
||||
colourRef = state.model.getAttributes(this);
|
||||
if (colourRef != null) {
|
||||
pipeline.addDependency(colourAttrib);
|
||||
state.pipeline.addDependency(colourAttrib);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
setColour(ColourRGBA.multiply(colour, colourRef[vertexIndex]));
|
||||
public void operate(CCRenderState state) {
|
||||
state.setColour(ColourRGBA.multiply(state.colour, colourRef[state.vertexIndex]));
|
||||
}
|
||||
};
|
||||
public static VertexAttribute<int[]> sideAttrib = new VertexAttribute<int[]>() {
|
||||
public static VertexAttribute<int[]> sideAttrib = new VertexAttribute<>() {
|
||||
|
||||
private int[] sideRef;
|
||||
|
||||
@@ -219,28 +254,28 @@ public class CCRenderState {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
sideRef = model.getAttributes(this);
|
||||
if (model.hasAttribute(this)) return sideRef != null;
|
||||
public boolean load(CCRenderState state) {
|
||||
sideRef = state.model.getAttributes(this);
|
||||
if (state.model.hasAttribute(this)) return sideRef != null;
|
||||
|
||||
pipeline.addDependency(normalAttrib);
|
||||
state.pipeline.addDependency(normalAttrib);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
if (sideRef != null) side = sideRef[vertexIndex];
|
||||
else side = CCModel.findSide(normal);
|
||||
public void operate(CCRenderState state) {
|
||||
if (sideRef != null) state.side = sideRef[state.vertexIndex];
|
||||
else state.side = CCModel.findSide(state.normal);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Uses the position of the lightmatrix to compute LC if not provided
|
||||
*/
|
||||
public static VertexAttribute<LC[]> lightCoordAttrib = new VertexAttribute<LC[]>() {
|
||||
public static VertexAttribute<LC[]> lightCoordAttrib = new VertexAttribute<>() {
|
||||
|
||||
private LC[] lcRef;
|
||||
private Vector3 vec = new Vector3(); // for computation
|
||||
private Vector3 pos = new Vector3();
|
||||
private final Vector3 vec = new Vector3(); // for computation
|
||||
private final Vector3 pos = new Vector3();
|
||||
|
||||
@Override
|
||||
public LC[] newArray(int length) {
|
||||
@@ -248,52 +283,54 @@ public class CCRenderState {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
lcRef = model.getAttributes(this);
|
||||
if (model.hasAttribute(this)) return lcRef != null;
|
||||
public boolean load(CCRenderState state) {
|
||||
lcRef = state.model.getAttributes(this);
|
||||
if (state.model.hasAttribute(this)) return lcRef != null;
|
||||
|
||||
pos.set(lightMatrix.pos.x, lightMatrix.pos.y, lightMatrix.pos.z);
|
||||
pipeline.addDependency(sideAttrib);
|
||||
pipeline.addRequirement(Transformation.operationIndex);
|
||||
pos.set(state.lightMatrix.pos.x, state.lightMatrix.pos.y, state.lightMatrix.pos.z);
|
||||
state.pipeline.addDependency(sideAttrib);
|
||||
state.pipeline.addRequirement(Transformation.operationIndex);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
if (lcRef != null) lc.set(lcRef[vertexIndex]);
|
||||
else lc.compute(vec.set(vert.vec).sub(pos), side);
|
||||
public void operate(CCRenderState state) {
|
||||
if (lcRef != null) state.lc.set(lcRef[state.vertexIndex]);
|
||||
else state.lc.compute(vec.set(state.vert.vec).sub(pos), state.side);
|
||||
}
|
||||
};
|
||||
|
||||
// pipeline state
|
||||
public static IVertexSource model;
|
||||
public static int firstVertexIndex;
|
||||
public static int lastVertexIndex;
|
||||
public static int vertexIndex;
|
||||
public static CCRenderPipeline pipeline = new CCRenderPipeline();
|
||||
public IVertexSource model;
|
||||
|
||||
public int firstVertexIndex;
|
||||
public int lastVertexIndex;
|
||||
public int vertexIndex;
|
||||
|
||||
// context
|
||||
public static int baseColour;
|
||||
public static int alphaOverride;
|
||||
public static boolean useNormals;
|
||||
public static boolean computeLighting;
|
||||
public static boolean useColour;
|
||||
public static LightMatrix lightMatrix = new LightMatrix();
|
||||
public int baseColour;
|
||||
public int alphaOverride;
|
||||
public boolean useNormals;
|
||||
public boolean computeLighting;
|
||||
public boolean useColour;
|
||||
public LightMatrix lightMatrix = new LightMatrix();
|
||||
|
||||
// vertex outputs
|
||||
public static Vertex5 vert = new Vertex5();
|
||||
public static boolean hasNormal;
|
||||
public static Vector3 normal = new Vector3();
|
||||
public static boolean hasColour;
|
||||
public static int colour;
|
||||
public static boolean hasBrightness;
|
||||
public static int brightness;
|
||||
public Vertex5 vert = new Vertex5();
|
||||
public boolean hasNormal;
|
||||
public Vector3 normal = new Vector3();
|
||||
|
||||
public boolean hasColour;
|
||||
public int colour;
|
||||
|
||||
public boolean hasBrightness;
|
||||
public int brightness;
|
||||
|
||||
// attrute storage
|
||||
public static int side;
|
||||
public static LC lc = new LC();
|
||||
public int side;
|
||||
public LC lc = new LC();
|
||||
|
||||
public static void reset() {
|
||||
public void reset() {
|
||||
model = null;
|
||||
pipeline.reset();
|
||||
useNormals = hasNormal = hasBrightness = hasColour = false;
|
||||
@@ -301,57 +338,102 @@ public class CCRenderState {
|
||||
baseColour = alphaOverride = -1;
|
||||
}
|
||||
|
||||
public static void setPipeline(IVertexOperation... ops) {
|
||||
public void setPipeline(IVertexOperation... ops) {
|
||||
pipeline.setPipeline(ops);
|
||||
}
|
||||
|
||||
public static void setPipeline(IVertexSource model, int start, int end, IVertexOperation... ops) {
|
||||
@Deprecated
|
||||
public static void setPipelineStatic(IVertexOperation... ops) {
|
||||
instance().setPipeline(ops);
|
||||
}
|
||||
|
||||
public void setPipeline(IVertexSource model, int start, int end, IVertexOperation... ops) {
|
||||
pipeline.reset();
|
||||
setModel(model, start, end);
|
||||
pipeline.setPipeline(ops);
|
||||
}
|
||||
|
||||
public static void bindModel(IVertexSource model) {
|
||||
if (CCRenderState.model != model) {
|
||||
CCRenderState.model = model;
|
||||
@Deprecated
|
||||
public static void setPipelineStatic(IVertexSource model, int start, int end, IVertexOperation... ops) {
|
||||
instance().setPipeline(model, start, end, ops);
|
||||
}
|
||||
|
||||
public void bindModel(IVertexSource model) {
|
||||
if (this.model != model) {
|
||||
this.model = model;
|
||||
pipeline.rebuild();
|
||||
}
|
||||
}
|
||||
|
||||
public static void setModel(IVertexSource source) {
|
||||
@Deprecated
|
||||
public static void bindModelStatic(IVertexSource model) {
|
||||
instance().bindModel(model);
|
||||
}
|
||||
|
||||
public void setModel(IVertexSource source) {
|
||||
setModel(source, 0, source.getVertices().length);
|
||||
}
|
||||
|
||||
public static void setModel(IVertexSource source, int start, int end) {
|
||||
@Deprecated
|
||||
public static void setModelStatic(IVertexSource source) {
|
||||
instance().setModel(source);
|
||||
}
|
||||
|
||||
public void setModel(IVertexSource source, int start, int end) {
|
||||
bindModel(source);
|
||||
setVertexRange(start, end);
|
||||
}
|
||||
|
||||
public static void setVertexRange(int start, int end) {
|
||||
@Deprecated
|
||||
public static void setModelStatic(IVertexSource source, int start, int end) {
|
||||
instance().setModel(source, start, end);
|
||||
}
|
||||
|
||||
public void setVertexRange(int start, int end) {
|
||||
firstVertexIndex = start;
|
||||
lastVertexIndex = end;
|
||||
}
|
||||
|
||||
public static void render(IVertexOperation... ops) {
|
||||
@Deprecated
|
||||
public static void setVertexRangeStatic(int start, int end) {
|
||||
instance().setVertexRange(start, end);
|
||||
}
|
||||
|
||||
public void render(IVertexOperation... ops) {
|
||||
setPipeline(ops);
|
||||
render();
|
||||
}
|
||||
|
||||
public static void render() {
|
||||
@Deprecated
|
||||
public static void renderStatic(IVertexOperation... ops) {
|
||||
instance().render(ops);
|
||||
}
|
||||
|
||||
public void render() {
|
||||
Vertex5[] verts = model.getVertices();
|
||||
for (vertexIndex = firstVertexIndex; vertexIndex < lastVertexIndex; vertexIndex++) {
|
||||
model.prepareVertex();
|
||||
model.prepareVertex(this);
|
||||
vert.set(verts[vertexIndex]);
|
||||
runPipeline();
|
||||
writeVert();
|
||||
}
|
||||
}
|
||||
|
||||
public static void runPipeline() {
|
||||
@Deprecated
|
||||
public static void renderStatic() {
|
||||
instance().render();
|
||||
}
|
||||
|
||||
public void runPipeline() {
|
||||
pipeline.operate();
|
||||
}
|
||||
|
||||
public static void writeVert() {
|
||||
@Deprecated
|
||||
public static void runPipelineStatic() {
|
||||
instance().runPipeline();
|
||||
}
|
||||
|
||||
public void writeVert() {
|
||||
if (hasNormal) Tessellator.instance.setNormal((float) normal.x, (float) normal.y, (float) normal.z);
|
||||
if (hasColour) Tessellator.instance.setColorRGBA(
|
||||
colour >>> 24,
|
||||
@@ -362,42 +444,72 @@ public class CCRenderState {
|
||||
Tessellator.instance.addVertexWithUV(vert.vec.x, vert.vec.y, vert.vec.z, vert.uv.u, vert.uv.v);
|
||||
}
|
||||
|
||||
public static void setNormal(double x, double y, double z) {
|
||||
@Deprecated
|
||||
public static void writeVertStatic() {
|
||||
instance().writeVert();
|
||||
}
|
||||
|
||||
public void setNormal(double x, double y, double z) {
|
||||
hasNormal = true;
|
||||
normal.set(x, y, z);
|
||||
}
|
||||
|
||||
public static void setNormal(Vector3 n) {
|
||||
@Deprecated
|
||||
public static void setNormalStatic(double x, double y, double z) {
|
||||
instance().setNormal(x, y, z);
|
||||
}
|
||||
|
||||
public void setNormal(Vector3 n) {
|
||||
hasNormal = true;
|
||||
normal.set(n);
|
||||
}
|
||||
|
||||
public static void setColour(int c) {
|
||||
@Deprecated
|
||||
public static void setNormalStatic(Vector3 n) {
|
||||
instance().setNormal(n);
|
||||
}
|
||||
|
||||
public void setColour(int c) {
|
||||
hasColour = true;
|
||||
colour = c;
|
||||
}
|
||||
|
||||
public static void setBrightness(int b) {
|
||||
@Deprecated
|
||||
public static void setColourStatic(int c) {
|
||||
instance().setColour(c);
|
||||
}
|
||||
|
||||
public void setBrightness(int b) {
|
||||
hasBrightness = true;
|
||||
brightness = b;
|
||||
}
|
||||
|
||||
public static void setBrightness(IBlockAccess world, int x, int y, int z) {
|
||||
@Deprecated
|
||||
public static void setBrightnessStatic(int b) {
|
||||
instance().setBrightness(b);
|
||||
}
|
||||
|
||||
public void setBrightness(IBlockAccess world, int x, int y, int z) {
|
||||
setBrightness(world.getBlock(x, y, z).getMixedBrightnessForBlock(world, x, y, z));
|
||||
}
|
||||
|
||||
public static void pullLightmap() {
|
||||
@Deprecated
|
||||
public static void setBrightnessStatic(IBlockAccess world, int x, int y, int z) {
|
||||
instance().setBrightness(world, x, y, z);
|
||||
}
|
||||
|
||||
public void pullLightmap() {
|
||||
setBrightness((int) OpenGlHelper.lastBrightnessY << 16 | (int) OpenGlHelper.lastBrightnessX);
|
||||
}
|
||||
|
||||
public static void pushLightmap() {
|
||||
public void pushLightmap() {
|
||||
OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, brightness & 0xFFFF, brightness >>> 16);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compact helper for setting dynamic rendering context. Uses normals and doesn't compute lighting
|
||||
*/
|
||||
public static void setDynamic() {
|
||||
public void setDynamic() {
|
||||
useNormals = true;
|
||||
computeLighting = false;
|
||||
}
|
||||
@@ -410,11 +522,16 @@ public class CCRenderState {
|
||||
Minecraft.getMinecraft().renderEngine.bindTexture(texture);
|
||||
}
|
||||
|
||||
public static void startDrawing() {
|
||||
public void startDrawing() {
|
||||
startDrawing(7);
|
||||
}
|
||||
|
||||
public static void startDrawing(int mode) {
|
||||
@Deprecated
|
||||
public static void startDrawingStatic() {
|
||||
instance().startDrawing();
|
||||
}
|
||||
|
||||
public void startDrawing(int mode) {
|
||||
Tessellator.instance.startDrawing(mode);
|
||||
if (hasColour) Tessellator.instance.setColorRGBA(
|
||||
colour >>> 24,
|
||||
@@ -424,7 +541,12 @@ public class CCRenderState {
|
||||
if (hasBrightness) Tessellator.instance.setBrightness(brightness);
|
||||
}
|
||||
|
||||
public static void draw() {
|
||||
@Deprecated
|
||||
public static void startDrawingStatic(int mode) {
|
||||
instance().startDrawing(mode);
|
||||
}
|
||||
|
||||
public void draw() {
|
||||
Tessellator.instance.draw();
|
||||
}
|
||||
}
|
||||
@@ -4,9 +4,11 @@ import codechicken.lib.colour.ColourRGBA;
|
||||
|
||||
public class ColourMultiplier implements CCRenderState.IVertexOperation {
|
||||
|
||||
private static ColourMultiplier instance = new ColourMultiplier(-1);
|
||||
private static final ThreadLocal<ColourMultiplier> instances = ThreadLocal
|
||||
.withInitial(() -> new ColourMultiplier(-1));
|
||||
|
||||
public static ColourMultiplier instance(int colour) {
|
||||
ColourMultiplier instance = instances.get();
|
||||
instance.colour = colour;
|
||||
return instance;
|
||||
}
|
||||
@@ -19,19 +21,19 @@ public class ColourMultiplier implements CCRenderState.IVertexOperation {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
public boolean load(CCRenderState state) {
|
||||
if (colour == -1) {
|
||||
CCRenderState.setColour(-1);
|
||||
state.setColour(-1);
|
||||
return false;
|
||||
}
|
||||
|
||||
CCRenderState.pipeline.addDependency(CCRenderState.colourAttrib);
|
||||
state.pipeline.addDependency(state.colourAttrib);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
CCRenderState.setColour(ColourRGBA.multiply(CCRenderState.colour, colour));
|
||||
public void operate(CCRenderState state) {
|
||||
state.setColour(ColourRGBA.multiply(state.colour, colour));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -151,7 +151,7 @@ public class RenderUtils {
|
||||
var2.draw();
|
||||
}
|
||||
|
||||
public static void renderFluidCuboid(Cuboid6 bound, IIcon tex, double res) {
|
||||
public static void renderFluidCuboid(CCRenderState state, Cuboid6 bound, IIcon tex, double res) {
|
||||
renderFluidQuad( // bottom
|
||||
new Vector3(bound.min.x, bound.min.y, bound.min.z),
|
||||
new Vector3(bound.max.x, bound.min.y, bound.min.z),
|
||||
@@ -196,6 +196,10 @@ public class RenderUtils {
|
||||
res);
|
||||
}
|
||||
|
||||
public static void renderFluidCuboid(Cuboid6 bound, IIcon tex, double res) {
|
||||
renderFluidCuboid(CCRenderState.instance(), bound, tex, res);
|
||||
}
|
||||
|
||||
public static void renderBlockOverlaySide(int x, int y, int z, int side, double tx1, double tx2, double ty1,
|
||||
double ty2) {
|
||||
double[] points = new double[] { x - 0.009, x + 1.009, y - 0.009, y + 1.009, z - 0.009, z + 1.009 };
|
||||
@@ -249,17 +253,21 @@ public class RenderUtils {
|
||||
* @param stack The fluid stack to render
|
||||
* @return The icon of the fluid
|
||||
*/
|
||||
public static IIcon prepareFluidRender(FluidStack stack, int alpha) {
|
||||
public static IIcon prepareFluidRender(CCRenderState state, FluidStack stack, int alpha) {
|
||||
GL11.glDisable(GL11.GL_LIGHTING);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
|
||||
Fluid fluid = stack.getFluid();
|
||||
CCRenderState.setColour(fluid.getColor(stack) << 8 | alpha);
|
||||
state.setColour(fluid.getColor(stack) << 8 | alpha);
|
||||
TextureUtils.bindAtlas(fluid.getSpriteNumber());
|
||||
return TextureUtils.safeIcon(fluid.getIcon(stack));
|
||||
}
|
||||
|
||||
public static IIcon prepareFluidRender(FluidStack stack, int alpha) {
|
||||
return prepareFluidRender(CCRenderState.instance(), stack, alpha);
|
||||
}
|
||||
|
||||
/**
|
||||
* Re-enables lighting and disables blending.
|
||||
*/
|
||||
@@ -283,21 +291,27 @@ public class RenderUtils {
|
||||
* this determines the height.
|
||||
* @param res The resolution to render at.
|
||||
*/
|
||||
public static void renderFluidCuboid(FluidStack stack, Cuboid6 bound, double density, double res) {
|
||||
public static void renderFluidCuboid(CCRenderState state, FluidStack stack, Cuboid6 bound, double density,
|
||||
double res) {
|
||||
if (!shouldRenderFluid(stack)) return;
|
||||
|
||||
int alpha = 255;
|
||||
if (stack.getFluid().isGaseous()) alpha = (int) (fluidDensityToAlpha(density) * 255);
|
||||
else bound.max.y = bound.min.y + (bound.max.y - bound.min.y) * density;
|
||||
|
||||
IIcon tex = prepareFluidRender(stack, alpha);
|
||||
CCRenderState.startDrawing();
|
||||
renderFluidCuboid(bound, tex, res);
|
||||
CCRenderState.draw();
|
||||
IIcon tex = prepareFluidRender(state, stack, alpha);
|
||||
state.startDrawing();
|
||||
renderFluidCuboid(state, bound, tex, res);
|
||||
state.draw();
|
||||
postFluidRender();
|
||||
}
|
||||
|
||||
public static void renderFluidGauge(FluidStack stack, Rectangle4i rect, double density, double res) {
|
||||
public static void renderFluidCuboid(FluidStack stack, Cuboid6 bound, double density, double res) {
|
||||
renderFluidCuboid(CCRenderState.instance(), stack, bound, density, res);
|
||||
}
|
||||
|
||||
public static void renderFluidGauge(CCRenderState state, FluidStack stack, Rectangle4i rect, double density,
|
||||
double res) {
|
||||
if (!shouldRenderFluid(stack)) return;
|
||||
|
||||
int alpha = 255;
|
||||
@@ -308,18 +322,22 @@ public class RenderUtils {
|
||||
rect.h = height;
|
||||
}
|
||||
|
||||
IIcon tex = prepareFluidRender(stack, alpha);
|
||||
CCRenderState.startDrawing();
|
||||
IIcon tex = prepareFluidRender(state, stack, alpha);
|
||||
state.startDrawing();
|
||||
renderFluidQuad(
|
||||
new Vector3(rect.x, rect.y + rect.h, 0),
|
||||
new Vector3(rect.w, 0, 0),
|
||||
new Vector3(0, -rect.h, 0),
|
||||
tex,
|
||||
res);
|
||||
CCRenderState.draw();
|
||||
state.draw();
|
||||
postFluidRender();
|
||||
}
|
||||
|
||||
public static void renderFluidGauge(FluidStack stack, Rectangle4i rect, double density, double res) {
|
||||
renderFluidGauge(CCRenderState.instance(), stack, rect, density, res);
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders items and blocks in the world at 0,0,0 with transformations that size them appropriately
|
||||
*/
|
||||
|
||||
@@ -23,13 +23,13 @@ public abstract class UVTransformation extends ITransformation<UV, UVTransformat
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
public boolean load(CCRenderState state) {
|
||||
return !isRedundant();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
apply(CCRenderState.vert.uv);
|
||||
public void operate(CCRenderState state) {
|
||||
apply(state.vert.uv);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -146,20 +146,10 @@ public class BlockCoord implements Comparable<BlockCoord>, Copyable<BlockCoord>
|
||||
|
||||
public BlockCoord setSide(int s, int v) {
|
||||
switch (s) {
|
||||
case 0:
|
||||
case 1:
|
||||
y = v;
|
||||
break;
|
||||
case 2:
|
||||
case 3:
|
||||
z = v;
|
||||
break;
|
||||
case 4:
|
||||
case 5:
|
||||
x = v;
|
||||
break;
|
||||
default:
|
||||
throw new IndexOutOfBoundsException("Switch Falloff");
|
||||
case 0, 1 -> y = v;
|
||||
case 2, 3 -> z = v;
|
||||
case 4, 5 -> x = v;
|
||||
default -> throw new IndexOutOfBoundsException("Switch Falloff");
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -38,15 +38,15 @@ public abstract class Transformation extends ITransformation<Vector3, Transforma
|
||||
public abstract void glApply();
|
||||
|
||||
@Override
|
||||
public boolean load() {
|
||||
CCRenderState.pipeline.addRequirement(CCRenderState.normalAttrib.operationID());
|
||||
public boolean load(CCRenderState state) {
|
||||
state.pipeline.addRequirement(CCRenderState.normalAttrib.operationID());
|
||||
return !isRedundant();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void operate() {
|
||||
apply(CCRenderState.vert.vec);
|
||||
if (CCRenderState.normalAttrib.active) applyN(CCRenderState.normal);
|
||||
public void operate(CCRenderState state) {
|
||||
apply(state.vert.vec);
|
||||
if (CCRenderState.normalAttrib.active) applyN(state.normal);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
Reference in new issue
Block a user