minecraft-src/com/mojang/blaze3d/platform/GlStateManager.java
2025-07-04 02:49:36 +03:00

988 lines
27 KiB
Java

package com.mojang.blaze3d.platform;
import com.google.common.base.Charsets;
import com.mojang.blaze3d.DontObfuscate;
import com.mojang.blaze3d.systems.RenderSystem;
import com.mojang.jtracy.Plot;
import com.mojang.jtracy.TracyClient;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.function.Consumer;
import java.util.stream.IntStream;
import net.fabricmc.api.EnvType;
import net.fabricmc.api.Environment;
import net.minecraft.Util;
import org.jetbrains.annotations.Nullable;
import org.joml.Matrix4f;
import org.joml.Vector3f;
import org.lwjgl.PointerBuffer;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL13;
import org.lwjgl.opengl.GL14;
import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL20C;
import org.lwjgl.opengl.GL30;
import org.lwjgl.opengl.GL32;
import org.lwjgl.opengl.GL32C;
import org.lwjgl.system.MemoryStack;
import org.lwjgl.system.MemoryUtil;
@Environment(EnvType.CLIENT)
@DontObfuscate
public class GlStateManager {
private static final boolean ON_LINUX = Util.getPlatform() == Util.OS.LINUX;
private static final Plot PLOT_TEXTURES = TracyClient.createPlot("GPU Textures");
private static int numTextures = 0;
private static final Plot PLOT_BUFFERS = TracyClient.createPlot("GPU Buffers");
private static int numBuffers = 0;
public static final int TEXTURE_COUNT = 12;
private static final GlStateManager.BlendState BLEND = new GlStateManager.BlendState();
private static final GlStateManager.DepthState DEPTH = new GlStateManager.DepthState();
private static final GlStateManager.CullState CULL = new GlStateManager.CullState();
private static final GlStateManager.PolygonOffsetState POLY_OFFSET = new GlStateManager.PolygonOffsetState();
private static final GlStateManager.ColorLogicState COLOR_LOGIC = new GlStateManager.ColorLogicState();
private static final GlStateManager.StencilState STENCIL = new GlStateManager.StencilState();
private static final GlStateManager.ScissorState SCISSOR = new GlStateManager.ScissorState();
private static final GlStateManager.FramebufferState READ_FRAMEBUFFER = new GlStateManager.FramebufferState();
private static final GlStateManager.FramebufferState DRAW_FRAMEBUFFER = new GlStateManager.FramebufferState();
private static int activeTexture;
private static final GlStateManager.TextureState[] TEXTURES = (GlStateManager.TextureState[])IntStream.range(0, 12)
.mapToObj(i -> new GlStateManager.TextureState())
.toArray(GlStateManager.TextureState[]::new);
private static final GlStateManager.ColorMask COLOR_MASK = new GlStateManager.ColorMask();
public static void _disableScissorTest() {
RenderSystem.assertOnRenderThreadOrInit();
SCISSOR.mode.disable();
}
public static void _enableScissorTest() {
RenderSystem.assertOnRenderThreadOrInit();
SCISSOR.mode.enable();
}
public static void _scissorBox(int i, int j, int k, int l) {
RenderSystem.assertOnRenderThreadOrInit();
GL20.glScissor(i, j, k, l);
}
public static void _disableDepthTest() {
RenderSystem.assertOnRenderThreadOrInit();
DEPTH.mode.disable();
}
public static void _enableDepthTest() {
RenderSystem.assertOnRenderThreadOrInit();
DEPTH.mode.enable();
}
public static void _depthFunc(int i) {
RenderSystem.assertOnRenderThreadOrInit();
if (i != DEPTH.func) {
DEPTH.func = i;
GL11.glDepthFunc(i);
}
}
public static void _depthMask(boolean bl) {
RenderSystem.assertOnRenderThread();
if (bl != DEPTH.mask) {
DEPTH.mask = bl;
GL11.glDepthMask(bl);
}
}
public static void _disableBlend() {
RenderSystem.assertOnRenderThread();
BLEND.mode.disable();
}
public static void _enableBlend() {
RenderSystem.assertOnRenderThread();
BLEND.mode.enable();
}
public static void _blendFunc(int i, int j) {
RenderSystem.assertOnRenderThread();
if (i != BLEND.srcRgb || j != BLEND.dstRgb) {
BLEND.srcRgb = i;
BLEND.dstRgb = j;
GL11.glBlendFunc(i, j);
}
}
public static void _blendFuncSeparate(int i, int j, int k, int l) {
RenderSystem.assertOnRenderThread();
if (i != BLEND.srcRgb || j != BLEND.dstRgb || k != BLEND.srcAlpha || l != BLEND.dstAlpha) {
BLEND.srcRgb = i;
BLEND.dstRgb = j;
BLEND.srcAlpha = k;
BLEND.dstAlpha = l;
glBlendFuncSeparate(i, j, k, l);
}
}
public static void _blendEquation(int i) {
RenderSystem.assertOnRenderThread();
GL14.glBlendEquation(i);
}
public static int glGetProgrami(int i, int j) {
RenderSystem.assertOnRenderThread();
return GL20.glGetProgrami(i, j);
}
public static void glAttachShader(int i, int j) {
RenderSystem.assertOnRenderThread();
GL20.glAttachShader(i, j);
}
public static void glDeleteShader(int i) {
RenderSystem.assertOnRenderThread();
GL20.glDeleteShader(i);
}
public static int glCreateShader(int i) {
RenderSystem.assertOnRenderThread();
return GL20.glCreateShader(i);
}
public static void glShaderSource(int i, String string) {
RenderSystem.assertOnRenderThread();
byte[] bs = string.getBytes(Charsets.UTF_8);
ByteBuffer byteBuffer = MemoryUtil.memAlloc(bs.length + 1);
byteBuffer.put(bs);
byteBuffer.put((byte)0);
byteBuffer.flip();
try (MemoryStack memoryStack = MemoryStack.stackPush()) {
PointerBuffer pointerBuffer = memoryStack.mallocPointer(1);
pointerBuffer.put(byteBuffer);
GL20C.nglShaderSource(i, 1, pointerBuffer.address0(), 0L);
} finally {
MemoryUtil.memFree(byteBuffer);
}
}
public static void glCompileShader(int i) {
RenderSystem.assertOnRenderThread();
GL20.glCompileShader(i);
}
public static int glGetShaderi(int i, int j) {
RenderSystem.assertOnRenderThread();
return GL20.glGetShaderi(i, j);
}
public static void _glUseProgram(int i) {
RenderSystem.assertOnRenderThread();
GL20.glUseProgram(i);
}
public static int glCreateProgram() {
RenderSystem.assertOnRenderThread();
return GL20.glCreateProgram();
}
public static void glDeleteProgram(int i) {
RenderSystem.assertOnRenderThread();
GL20.glDeleteProgram(i);
}
public static void glLinkProgram(int i) {
RenderSystem.assertOnRenderThread();
GL20.glLinkProgram(i);
}
public static int _glGetUniformLocation(int i, CharSequence charSequence) {
RenderSystem.assertOnRenderThread();
return GL20.glGetUniformLocation(i, charSequence);
}
public static void _glUniform1(int i, IntBuffer intBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniform1iv(i, intBuffer);
}
public static void _glUniform1i(int i, int j) {
RenderSystem.assertOnRenderThread();
GL20.glUniform1i(i, j);
}
public static void _glUniform1(int i, FloatBuffer floatBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniform1fv(i, floatBuffer);
}
public static void _glUniform2(int i, IntBuffer intBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniform2iv(i, intBuffer);
}
public static void _glUniform2(int i, FloatBuffer floatBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniform2fv(i, floatBuffer);
}
public static void _glUniform3(int i, IntBuffer intBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniform3iv(i, intBuffer);
}
public static void _glUniform3(int i, FloatBuffer floatBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniform3fv(i, floatBuffer);
}
public static void _glUniform4(int i, IntBuffer intBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniform4iv(i, intBuffer);
}
public static void _glUniform4(int i, FloatBuffer floatBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniform4fv(i, floatBuffer);
}
public static void _glUniformMatrix2(int i, boolean bl, FloatBuffer floatBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniformMatrix2fv(i, bl, floatBuffer);
}
public static void _glUniformMatrix3(int i, boolean bl, FloatBuffer floatBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniformMatrix3fv(i, bl, floatBuffer);
}
public static void _glUniformMatrix4(int i, boolean bl, FloatBuffer floatBuffer) {
RenderSystem.assertOnRenderThread();
GL20.glUniformMatrix4fv(i, bl, floatBuffer);
}
public static int _glGetAttribLocation(int i, CharSequence charSequence) {
RenderSystem.assertOnRenderThread();
return GL20.glGetAttribLocation(i, charSequence);
}
public static void _glBindAttribLocation(int i, int j, CharSequence charSequence) {
RenderSystem.assertOnRenderThread();
GL20.glBindAttribLocation(i, j, charSequence);
}
public static int _glGenBuffers() {
RenderSystem.assertOnRenderThreadOrInit();
numBuffers++;
PLOT_BUFFERS.setValue(numBuffers);
return GL15.glGenBuffers();
}
public static int _glGenVertexArrays() {
RenderSystem.assertOnRenderThreadOrInit();
return GL30.glGenVertexArrays();
}
public static void _glBindBuffer(int i, int j) {
RenderSystem.assertOnRenderThreadOrInit();
GL15.glBindBuffer(i, j);
}
public static void _glBindVertexArray(int i) {
RenderSystem.assertOnRenderThreadOrInit();
GL30.glBindVertexArray(i);
}
public static void _glBufferData(int i, ByteBuffer byteBuffer, int j) {
RenderSystem.assertOnRenderThreadOrInit();
GL15.glBufferData(i, byteBuffer, j);
}
public static void _glBufferSubData(int i, int j, ByteBuffer byteBuffer) {
RenderSystem.assertOnRenderThreadOrInit();
GL15.glBufferSubData(i, (long)j, byteBuffer);
}
public static void _glBufferData(int i, long l, int j) {
RenderSystem.assertOnRenderThreadOrInit();
GL15.glBufferData(i, l, j);
}
@Nullable
public static ByteBuffer _glMapBuffer(int i, int j) {
RenderSystem.assertOnRenderThreadOrInit();
return GL15.glMapBuffer(i, j);
}
@Nullable
public static ByteBuffer _glMapBufferRange(int i, int j, int k, int l) {
RenderSystem.assertOnRenderThreadOrInit();
return GL30.glMapBufferRange(i, j, k, l);
}
public static void _glUnmapBuffer(int i) {
RenderSystem.assertOnRenderThreadOrInit();
GL15.glUnmapBuffer(i);
}
public static void _glDeleteBuffers(int i) {
RenderSystem.assertOnRenderThread();
if (ON_LINUX) {
GL32C.glBindBuffer(34962, i);
GL32C.glBufferData(34962, 0L, 35048);
GL32C.glBindBuffer(34962, 0);
}
numBuffers--;
PLOT_BUFFERS.setValue(numBuffers);
GL15.glDeleteBuffers(i);
}
public static void _glCopyTexSubImage2D(int i, int j, int k, int l, int m, int n, int o, int p) {
RenderSystem.assertOnRenderThreadOrInit();
GL20.glCopyTexSubImage2D(i, j, k, l, m, n, o, p);
}
public static void _glDeleteVertexArrays(int i) {
RenderSystem.assertOnRenderThread();
GL30.glDeleteVertexArrays(i);
}
public static void _glBindFramebuffer(int i, int j) {
RenderSystem.assertOnRenderThreadOrInit();
boolean bl = switch (i) {
case 36008 -> READ_FRAMEBUFFER.update(j);
case 36009 -> DRAW_FRAMEBUFFER.update(j);
case 36160 -> READ_FRAMEBUFFER.update(j) | DRAW_FRAMEBUFFER.update(j);
default -> true;
};
if (bl) {
GL30.glBindFramebuffer(i, j);
}
}
public static void _glBlitFrameBuffer(int i, int j, int k, int l, int m, int n, int o, int p, int q, int r) {
RenderSystem.assertOnRenderThreadOrInit();
GL30.glBlitFramebuffer(i, j, k, l, m, n, o, p, q, r);
}
public static void _glBindRenderbuffer(int i, int j) {
RenderSystem.assertOnRenderThreadOrInit();
GL30.glBindRenderbuffer(i, j);
}
public static void _glDeleteRenderbuffers(int i) {
RenderSystem.assertOnRenderThreadOrInit();
GL30.glDeleteRenderbuffers(i);
}
public static void _glDeleteFramebuffers(int i) {
RenderSystem.assertOnRenderThreadOrInit();
GL30.glDeleteFramebuffers(i);
}
public static int glGenFramebuffers() {
RenderSystem.assertOnRenderThreadOrInit();
return GL30.glGenFramebuffers();
}
public static int glGenRenderbuffers() {
RenderSystem.assertOnRenderThreadOrInit();
return GL30.glGenRenderbuffers();
}
public static void _glRenderbufferStorage(int i, int j, int k, int l) {
RenderSystem.assertOnRenderThreadOrInit();
GL30.glRenderbufferStorage(i, j, k, l);
}
public static void _glFramebufferRenderbuffer(int i, int j, int k, int l) {
RenderSystem.assertOnRenderThreadOrInit();
GL30.glFramebufferRenderbuffer(i, j, k, l);
}
public static int glCheckFramebufferStatus(int i) {
RenderSystem.assertOnRenderThreadOrInit();
return GL30.glCheckFramebufferStatus(i);
}
public static void _glFramebufferTexture2D(int i, int j, int k, int l, int m) {
RenderSystem.assertOnRenderThreadOrInit();
GL30.glFramebufferTexture2D(i, j, k, l, m);
}
public static int getBoundFramebuffer() {
RenderSystem.assertOnRenderThread();
return _getInteger(36006);
}
public static void glActiveTexture(int i) {
RenderSystem.assertOnRenderThread();
GL13.glActiveTexture(i);
}
public static void glBlendFuncSeparate(int i, int j, int k, int l) {
RenderSystem.assertOnRenderThread();
GL14.glBlendFuncSeparate(i, j, k, l);
}
public static String glGetShaderInfoLog(int i, int j) {
RenderSystem.assertOnRenderThread();
return GL20.glGetShaderInfoLog(i, j);
}
public static String glGetProgramInfoLog(int i, int j) {
RenderSystem.assertOnRenderThread();
return GL20.glGetProgramInfoLog(i, j);
}
public static void setupLevelDiffuseLighting(Vector3f vector3f, Vector3f vector3f2, Matrix4f matrix4f) {
RenderSystem.assertOnRenderThread();
RenderSystem.setShaderLights(matrix4f.transformDirection(vector3f, new Vector3f()), matrix4f.transformDirection(vector3f2, new Vector3f()));
}
public static void setupGuiFlatDiffuseLighting(Vector3f vector3f, Vector3f vector3f2) {
RenderSystem.assertOnRenderThread();
Matrix4f matrix4f = new Matrix4f().rotationY((float) (-Math.PI / 8)).rotateX((float) (Math.PI * 3.0 / 4.0));
setupLevelDiffuseLighting(vector3f, vector3f2, matrix4f);
}
public static void setupGui3DDiffuseLighting(Vector3f vector3f, Vector3f vector3f2) {
RenderSystem.assertOnRenderThread();
Matrix4f matrix4f = new Matrix4f()
.scaling(1.0F, -1.0F, 1.0F)
.rotateYXZ(1.0821041F, 3.2375858F, 0.0F)
.rotateYXZ((float) (-Math.PI / 8), (float) (Math.PI * 3.0 / 4.0), 0.0F);
setupLevelDiffuseLighting(vector3f, vector3f2, matrix4f);
}
public static void _enableCull() {
RenderSystem.assertOnRenderThread();
CULL.enable.enable();
}
public static void _disableCull() {
RenderSystem.assertOnRenderThread();
CULL.enable.disable();
}
public static void _polygonMode(int i, int j) {
RenderSystem.assertOnRenderThread();
GL11.glPolygonMode(i, j);
}
public static void _enablePolygonOffset() {
RenderSystem.assertOnRenderThread();
POLY_OFFSET.fill.enable();
}
public static void _disablePolygonOffset() {
RenderSystem.assertOnRenderThread();
POLY_OFFSET.fill.disable();
}
public static void _polygonOffset(float f, float g) {
RenderSystem.assertOnRenderThread();
if (f != POLY_OFFSET.factor || g != POLY_OFFSET.units) {
POLY_OFFSET.factor = f;
POLY_OFFSET.units = g;
GL11.glPolygonOffset(f, g);
}
}
public static void _enableColorLogicOp() {
RenderSystem.assertOnRenderThread();
COLOR_LOGIC.enable.enable();
}
public static void _disableColorLogicOp() {
RenderSystem.assertOnRenderThread();
COLOR_LOGIC.enable.disable();
}
public static void _logicOp(int i) {
RenderSystem.assertOnRenderThread();
if (i != COLOR_LOGIC.op) {
COLOR_LOGIC.op = i;
GL11.glLogicOp(i);
}
}
public static void _activeTexture(int i) {
RenderSystem.assertOnRenderThread();
if (activeTexture != i - 33984) {
activeTexture = i - 33984;
glActiveTexture(i);
}
}
public static void _texParameter(int i, int j, float f) {
RenderSystem.assertOnRenderThreadOrInit();
GL11.glTexParameterf(i, j, f);
}
public static void _texParameter(int i, int j, int k) {
RenderSystem.assertOnRenderThreadOrInit();
GL11.glTexParameteri(i, j, k);
}
public static int _getTexLevelParameter(int i, int j, int k) {
return GL11.glGetTexLevelParameteri(i, j, k);
}
public static int _genTexture() {
RenderSystem.assertOnRenderThreadOrInit();
numTextures++;
PLOT_TEXTURES.setValue(numTextures);
return GL11.glGenTextures();
}
public static void _genTextures(int[] is) {
RenderSystem.assertOnRenderThreadOrInit();
numTextures += is.length;
PLOT_TEXTURES.setValue(numTextures);
GL11.glGenTextures(is);
}
public static void _deleteTexture(int i) {
RenderSystem.assertOnRenderThreadOrInit();
GL11.glDeleteTextures(i);
for (GlStateManager.TextureState textureState : TEXTURES) {
if (textureState.binding == i) {
textureState.binding = -1;
}
}
numTextures--;
PLOT_TEXTURES.setValue(numTextures);
}
public static void _deleteTextures(int[] is) {
RenderSystem.assertOnRenderThreadOrInit();
for (GlStateManager.TextureState textureState : TEXTURES) {
for (int i : is) {
if (textureState.binding == i) {
textureState.binding = -1;
}
}
}
GL11.glDeleteTextures(is);
numTextures -= is.length;
PLOT_TEXTURES.setValue(numTextures);
}
public static void _bindTexture(int i) {
RenderSystem.assertOnRenderThreadOrInit();
if (i != TEXTURES[activeTexture].binding) {
TEXTURES[activeTexture].binding = i;
GL11.glBindTexture(3553, i);
}
}
public static int _getActiveTexture() {
return activeTexture + 33984;
}
public static void _texImage2D(int i, int j, int k, int l, int m, int n, int o, int p, @Nullable IntBuffer intBuffer) {
RenderSystem.assertOnRenderThreadOrInit();
GL11.glTexImage2D(i, j, k, l, m, n, o, p, intBuffer);
}
public static void _texSubImage2D(int i, int j, int k, int l, int m, int n, int o, int p, long q) {
RenderSystem.assertOnRenderThreadOrInit();
GL11.glTexSubImage2D(i, j, k, l, m, n, o, p, q);
}
public static void upload(int i, int j, int k, int l, int m, NativeImage.Format format, IntBuffer intBuffer, Consumer<IntBuffer> consumer) {
if (!RenderSystem.isOnRenderThreadOrInit()) {
RenderSystem.recordRenderCall(() -> _upload(i, j, k, l, m, format, intBuffer, consumer));
} else {
_upload(i, j, k, l, m, format, intBuffer, consumer);
}
}
private static void _upload(int i, int j, int k, int l, int m, NativeImage.Format format, IntBuffer intBuffer, Consumer<IntBuffer> consumer) {
try {
RenderSystem.assertOnRenderThreadOrInit();
_pixelStore(3314, l);
_pixelStore(3316, 0);
_pixelStore(3315, 0);
format.setUnpackPixelStoreState();
GL11.glTexSubImage2D(3553, i, j, k, l, m, format.glFormat(), 5121, intBuffer);
} finally {
consumer.accept(intBuffer);
}
}
public static void _getTexImage(int i, int j, int k, int l, long m) {
RenderSystem.assertOnRenderThread();
GL11.glGetTexImage(i, j, k, l, m);
}
public static void _viewport(int i, int j, int k, int l) {
RenderSystem.assertOnRenderThreadOrInit();
GlStateManager.Viewport.INSTANCE.x = i;
GlStateManager.Viewport.INSTANCE.y = j;
GlStateManager.Viewport.INSTANCE.width = k;
GlStateManager.Viewport.INSTANCE.height = l;
GL11.glViewport(i, j, k, l);
}
public static void _colorMask(boolean bl, boolean bl2, boolean bl3, boolean bl4) {
RenderSystem.assertOnRenderThread();
if (bl != COLOR_MASK.red || bl2 != COLOR_MASK.green || bl3 != COLOR_MASK.blue || bl4 != COLOR_MASK.alpha) {
COLOR_MASK.red = bl;
COLOR_MASK.green = bl2;
COLOR_MASK.blue = bl3;
COLOR_MASK.alpha = bl4;
GL11.glColorMask(bl, bl2, bl3, bl4);
}
}
public static void _stencilFunc(int i, int j, int k) {
RenderSystem.assertOnRenderThread();
if (i != STENCIL.func.func || i != STENCIL.func.ref || i != STENCIL.func.mask) {
STENCIL.func.func = i;
STENCIL.func.ref = j;
STENCIL.func.mask = k;
GL11.glStencilFunc(i, j, k);
}
}
public static void _stencilMask(int i) {
RenderSystem.assertOnRenderThread();
if (i != STENCIL.mask) {
STENCIL.mask = i;
GL11.glStencilMask(i);
}
}
public static void _stencilOp(int i, int j, int k) {
RenderSystem.assertOnRenderThread();
if (i != STENCIL.fail || j != STENCIL.zfail || k != STENCIL.zpass) {
STENCIL.fail = i;
STENCIL.zfail = j;
STENCIL.zpass = k;
GL11.glStencilOp(i, j, k);
}
}
public static void _clearDepth(double d) {
RenderSystem.assertOnRenderThreadOrInit();
GL11.glClearDepth(d);
}
public static void _clearColor(float f, float g, float h, float i) {
RenderSystem.assertOnRenderThreadOrInit();
GL11.glClearColor(f, g, h, i);
}
public static void _clearStencil(int i) {
RenderSystem.assertOnRenderThread();
GL11.glClearStencil(i);
}
public static void _clear(int i) {
RenderSystem.assertOnRenderThreadOrInit();
GL11.glClear(i);
if (MacosUtil.IS_MACOS) {
_getError();
}
}
public static void _glDrawPixels(int i, int j, int k, int l, long m) {
RenderSystem.assertOnRenderThread();
GL11.glDrawPixels(i, j, k, l, m);
}
public static void _vertexAttribPointer(int i, int j, int k, boolean bl, int l, long m) {
RenderSystem.assertOnRenderThread();
GL20.glVertexAttribPointer(i, j, k, bl, l, m);
}
public static void _vertexAttribIPointer(int i, int j, int k, int l, long m) {
RenderSystem.assertOnRenderThread();
GL30.glVertexAttribIPointer(i, j, k, l, m);
}
public static void _enableVertexAttribArray(int i) {
RenderSystem.assertOnRenderThread();
GL20.glEnableVertexAttribArray(i);
}
public static void _disableVertexAttribArray(int i) {
RenderSystem.assertOnRenderThread();
GL20.glDisableVertexAttribArray(i);
}
public static void _drawElements(int i, int j, int k, long l) {
RenderSystem.assertOnRenderThread();
GL11.glDrawElements(i, j, k, l);
}
public static void _pixelStore(int i, int j) {
RenderSystem.assertOnRenderThreadOrInit();
GL11.glPixelStorei(i, j);
}
public static void _readPixels(int i, int j, int k, int l, int m, int n, ByteBuffer byteBuffer) {
RenderSystem.assertOnRenderThread();
GL11.glReadPixels(i, j, k, l, m, n, byteBuffer);
}
public static void _readPixels(int i, int j, int k, int l, int m, int n, long o) {
RenderSystem.assertOnRenderThread();
GL11.glReadPixels(i, j, k, l, m, n, o);
}
public static int _getError() {
RenderSystem.assertOnRenderThread();
return GL11.glGetError();
}
public static String _getString(int i) {
RenderSystem.assertOnRenderThread();
return GL11.glGetString(i);
}
public static int _getInteger(int i) {
RenderSystem.assertOnRenderThreadOrInit();
return GL11.glGetInteger(i);
}
public static long _glFenceSync(int i, int j) {
RenderSystem.assertOnRenderThreadOrInit();
return GL32.glFenceSync(i, j);
}
public static int _glClientWaitSync(long l, int i, long m) {
RenderSystem.assertOnRenderThreadOrInit();
return GL32.glClientWaitSync(l, i, m);
}
public static void _glDeleteSync(long l) {
RenderSystem.assertOnRenderThreadOrInit();
GL32.glDeleteSync(l);
}
@Environment(EnvType.CLIENT)
static class BlendState {
public final GlStateManager.BooleanState mode = new GlStateManager.BooleanState(3042);
public int srcRgb = 1;
public int dstRgb = 0;
public int srcAlpha = 1;
public int dstAlpha = 0;
}
@Environment(EnvType.CLIENT)
static class BooleanState {
private final int state;
private boolean enabled;
public BooleanState(int state) {
this.state = state;
}
public void disable() {
this.setEnabled(false);
}
public void enable() {
this.setEnabled(true);
}
public void setEnabled(boolean enabled) {
RenderSystem.assertOnRenderThreadOrInit();
if (enabled != this.enabled) {
this.enabled = enabled;
if (enabled) {
GL11.glEnable(this.state);
} else {
GL11.glDisable(this.state);
}
}
}
}
@Environment(EnvType.CLIENT)
static class ColorLogicState {
public final GlStateManager.BooleanState enable = new GlStateManager.BooleanState(3058);
public int op = 5379;
}
@Environment(EnvType.CLIENT)
static class ColorMask {
public boolean red = true;
public boolean green = true;
public boolean blue = true;
public boolean alpha = true;
}
@Environment(EnvType.CLIENT)
static class CullState {
public final GlStateManager.BooleanState enable = new GlStateManager.BooleanState(2884);
public int mode = 1029;
}
@Environment(EnvType.CLIENT)
static class DepthState {
public final GlStateManager.BooleanState mode = new GlStateManager.BooleanState(2929);
public boolean mask = true;
public int func = 513;
}
@Environment(EnvType.CLIENT)
@DontObfuscate
public static enum DestFactor {
CONSTANT_ALPHA(32771),
CONSTANT_COLOR(32769),
DST_ALPHA(772),
DST_COLOR(774),
ONE(1),
ONE_MINUS_CONSTANT_ALPHA(32772),
ONE_MINUS_CONSTANT_COLOR(32770),
ONE_MINUS_DST_ALPHA(773),
ONE_MINUS_DST_COLOR(775),
ONE_MINUS_SRC_ALPHA(771),
ONE_MINUS_SRC_COLOR(769),
SRC_ALPHA(770),
SRC_COLOR(768),
ZERO(0);
public final int value;
private DestFactor(final int value) {
this.value = value;
}
}
@Environment(EnvType.CLIENT)
static class FramebufferState {
public int binding;
public boolean update(int binding) {
if (binding != this.binding) {
this.binding = binding;
return true;
} else {
return false;
}
}
}
@Environment(EnvType.CLIENT)
public static enum LogicOp {
AND(5377),
AND_INVERTED(5380),
AND_REVERSE(5378),
CLEAR(5376),
COPY(5379),
COPY_INVERTED(5388),
EQUIV(5385),
INVERT(5386),
NAND(5390),
NOOP(5381),
NOR(5384),
OR(5383),
OR_INVERTED(5389),
OR_REVERSE(5387),
SET(5391),
XOR(5382);
public final int value;
private LogicOp(final int value) {
this.value = value;
}
}
@Environment(EnvType.CLIENT)
static class PolygonOffsetState {
public final GlStateManager.BooleanState fill = new GlStateManager.BooleanState(32823);
public final GlStateManager.BooleanState line = new GlStateManager.BooleanState(10754);
public float factor;
public float units;
}
@Environment(EnvType.CLIENT)
static class ScissorState {
public final GlStateManager.BooleanState mode = new GlStateManager.BooleanState(3089);
}
@Environment(EnvType.CLIENT)
@DontObfuscate
public static enum SourceFactor {
CONSTANT_ALPHA(32771),
CONSTANT_COLOR(32769),
DST_ALPHA(772),
DST_COLOR(774),
ONE(1),
ONE_MINUS_CONSTANT_ALPHA(32772),
ONE_MINUS_CONSTANT_COLOR(32770),
ONE_MINUS_DST_ALPHA(773),
ONE_MINUS_DST_COLOR(775),
ONE_MINUS_SRC_ALPHA(771),
ONE_MINUS_SRC_COLOR(769),
SRC_ALPHA(770),
SRC_ALPHA_SATURATE(776),
SRC_COLOR(768),
ZERO(0);
public final int value;
private SourceFactor(final int value) {
this.value = value;
}
}
@Environment(EnvType.CLIENT)
static class StencilFunc {
public int func = 519;
public int ref;
public int mask = -1;
}
@Environment(EnvType.CLIENT)
static class StencilState {
public final GlStateManager.StencilFunc func = new GlStateManager.StencilFunc();
public int mask = -1;
public int fail = 7680;
public int zfail = 7680;
public int zpass = 7680;
}
@Environment(EnvType.CLIENT)
static class TextureState {
public int binding;
}
@Environment(EnvType.CLIENT)
public static enum Viewport {
INSTANCE;
protected int x;
protected int y;
protected int width;
protected int height;
public static int x() {
return INSTANCE.x;
}
public static int y() {
return INSTANCE.y;
}
public static int width() {
return INSTANCE.width;
}
public static int height() {
return INSTANCE.height;
}
}
}