//
// Decompiled by Procyon v0.5.36
//

package com.mojang.blaze3d.systems;

import com.google.common.collect.Queues;
import org.apache.logging.log4j.LogManager;
import org.lwjgl.glfw.GLFW;
import org.lwjgl.glfw.GLFWErrorCallbackI;
import java.util.function.LongSupplier;
import com.mojang.blaze3d.platform.GLX;
import java.nio.ByteBuffer;
import java.util.function.Consumer;
import javax.annotation.Nullable;
import java.nio.IntBuffer;
import java.nio.FloatBuffer;
import java.util.function.Supplier;
import java.util.concurrent.ConcurrentLinkedQueue;
import org.apache.logging.log4j.Logger;

public class RenderSystem
{
    private static final Logger LOGGER;
    private static final ConcurrentLinkedQueue<cvy> recordingQueue;
    private static final cxh RENDER_THREAD_TESSELATOR;
    private static final float DEFAULTALPHACUTOFF = 0.1f;
    private static boolean isReplayingQueue;
    private static Thread gameThread;
    private static Thread renderThread;
    private static int MAX_SUPPORTED_TEXTURE_SIZE;
    private static boolean isInInit;

    public static void initRenderThread() {
        if (RenderSystem.renderThread != null || RenderSystem.gameThread == Thread.currentThread()) {
            throw new IllegalStateException("Could not initialize render thread");
        }
        RenderSystem.renderThread = Thread.currentThread();
    }

    public static boolean isOnRenderThread() {
        return Thread.currentThread() == RenderSystem.renderThread;
    }

    public static boolean isOnRenderThreadOrInit() {
        return RenderSystem.isInInit || isOnRenderThread();
    }

    public static void initGameThread(final boolean \u2603) {
        final boolean b = RenderSystem.renderThread == Thread.currentThread();
        if (RenderSystem.gameThread != null || RenderSystem.renderThread == null || b == \u2603) {
            throw new IllegalStateException("Could not initialize tick thread");
        }
        RenderSystem.gameThread = Thread.currentThread();
    }

    public static boolean isOnGameThread() {
        return true;
    }

    public static boolean isOnGameThreadOrInit() {
        return RenderSystem.isInInit || isOnGameThread();
    }

    public static void assertThread(final Supplier<Boolean> \u2603) {
        if (!\u2603.get()) {
            throw new IllegalStateException("Rendersystem called from wrong thread");
        }
    }

    public static boolean isInInitPhase() {
        return true;
    }

    public static void pushLightingAttributes() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b();
    }

    public static void pushTextureAttributes() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.c();
    }

    public static void popAttributes() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.d();
    }

    public static void disableAlphaTest() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.e();
    }

    public static void enableAlphaTest() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.f();
    }

    public static void alphaFunc(final int \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603);
    }

    public static void enableLighting() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.g();
    }

    public static void disableLighting() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.h();
    }

    public static void enableColorMaterial() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.i();
    }

    public static void disableColorMaterial() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.j();
    }

    public static void colorMaterial(final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603);
    }

    public static void normal3f(final float \u2603, final float \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603);
    }

    public static void disableDepthTest() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.k();
    }

    public static void enableDepthTest() {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.l();
    }

    public static void depthFunc(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.c(\u2603);
    }

    public static void depthMask(final boolean \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603);
    }

    public static void enableBlend() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.n();
    }

    public static void disableBlend() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.m();
    }

    public static void blendFunc(final cwi.r \u2603, final cwi.l \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603.p, \u2603.o);
    }

    public static void blendFunc(final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603, \u2603);
    }

    public static void blendFuncSeparate(final cwi.r \u2603, final cwi.l \u2603, final cwi.r \u2603, final cwi.l \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603.p, \u2603.o, \u2603.p, \u2603.o);
    }

    public static void blendFuncSeparate(final int \u2603, final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603, \u2603);
    }

    public static void blendEquation(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.d(\u2603);
    }

    public static void setupSolidRenderingTextureCombine(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.e(\u2603);
    }

    public static void tearDownSolidRenderingTextureCombine() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.o();
    }

    public static void enableFog() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.y();
    }

    public static void disableFog() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.z();
    }

    public static void fogMode(final cwi.n \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.r(\u2603.d);
    }

    public static void fogMode(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.r(\u2603);
    }

    public static void fogDensity(final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603);
    }

    public static void fogStart(final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603);
    }

    public static void fogEnd(final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.c(\u2603);
    }

    public static void fog(final int \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.f(\u2603, \u2603);
    }

    public static void fogi(final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.l(\u2603, \u2603);
    }

    public static void enableCull() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.A();
    }

    public static void disableCull() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.B();
    }

    public static void cullFace(final cwi.i \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.s(\u2603.d);
    }

    public static void cullFace(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.s(\u2603);
    }

    public static void polygonMode(final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.m(\u2603, \u2603);
    }

    public static void enablePolygonOffset() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.C();
    }

    public static void disablePolygonOffset() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.D();
    }

    public static void enableLineOffset() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.E();
    }

    public static void disableLineOffset() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.F();
    }

    public static void polygonOffset(final float \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603);
    }

    public static void enableColorLogicOp() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.G();
    }

    public static void disableColorLogicOp() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.H();
    }

    public static void logicOp(final cwi.p \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.t(\u2603.q);
    }

    public static void logicOp(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.t(\u2603);
    }

    public static void enableTexGen(final cwi.u \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603);
    }

    public static void disableTexGen(final cwi.u \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603);
    }

    public static void texGenMode(final cwi.u \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603);
    }

    public static void texGenParam(final cwi.u \u2603, final int \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603);
    }

    public static void activeTexture(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.u(\u2603);
    }

    public static void enableTexture() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.I();
    }

    public static void disableTexture() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.J();
    }

    public static void texParameter(final int \u2603, final int \u2603, final int \u2603) {
        cwi.b(\u2603, \u2603, \u2603);
    }

    public static void deleteTexture(final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.v(\u2603);
    }

    public static void bindTexture(final int \u2603) {
        cwi.w(\u2603);
    }

    public static void texImage2D(final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, @Nullable final IntBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.a(\u2603, \u2603, \u2603, \u2603, \u2603, \u2603, \u2603, \u2603, \u2603);
    }

    public static void texSubImage2D(final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final long \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.a(\u2603, \u2603, \u2603, \u2603, \u2603, \u2603, \u2603, \u2603, \u2603);
    }

    public static void copyTexSubImage2D(final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603, \u2603, \u2603, \u2603, \u2603, \u2603);
    }

    public static void getTexImage(final int \u2603, final int \u2603, final int \u2603, final int \u2603, final long \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603, \u2603, \u2603);
    }

    public static void enableNormalize() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.L();
    }

    public static void disableNormalize() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.M();
    }

    public static void shadeModel(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.x(\u2603);
    }

    public static void enableRescaleNormal() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.N();
    }

    public static void disableRescaleNormal() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.O();
    }

    public static void viewport(final int \u2603, final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.e(\u2603, \u2603, \u2603, \u2603);
    }

    public static void colorMask(final boolean \u2603, final boolean \u2603, final boolean \u2603, final boolean \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603, \u2603);
    }

    public static void stencilFunc(final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.d(\u2603, \u2603, \u2603);
    }

    public static void stencilMask(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.y(\u2603);
    }

    public static void stencilOp(final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.e(\u2603, \u2603, \u2603);
    }

    public static void clearDepth(final double \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.a(\u2603);
    }

    public static void clearColor(final float \u2603, final float \u2603, final float \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.a(\u2603, \u2603, \u2603, \u2603);
    }

    public static void clearStencil(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.z(\u2603);
    }

    public static void clear(final int \u2603, final boolean \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.b(\u2603, \u2603);
    }

    public static void matrixMode(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.A(\u2603);
    }

    public static void loadIdentity() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.P();
    }

    public static void pushMatrix() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.Q();
    }

    public static void popMatrix() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.R();
    }

    public static void getMatrix(final int \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.g(\u2603, \u2603);
    }

    public static void getMatrix4f(final int \u2603, final Consumer<cxl> \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        \u2603.accept(cwi.B(\u2603));
    }

    public static void ortho(final double \u2603, final double \u2603, final double \u2603, final double \u2603, final double \u2603, final double \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603, \u2603, \u2603, \u2603);
    }

    public static void rotatef(final float \u2603, final float \u2603, final float \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603, \u2603, \u2603, \u2603);
    }

    public static void rotated(final double \u2603, final double \u2603, final double \u2603, final double \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603, \u2603);
    }

    public static void scalef(final float \u2603, final float \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603, \u2603, \u2603);
    }

    public static void scaled(final double \u2603, final double \u2603, final double \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603);
    }

    public static void translatef(final float \u2603, final float \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.c(\u2603, \u2603, \u2603);
    }

    public static void translated(final double \u2603, final double \u2603, final double \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603, \u2603, \u2603);
    }

    public static void multMatrix(final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603);
    }

    public static void multMatrix(final cxl \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603);
    }

    public static void color4f(final float \u2603, final float \u2603, final float \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.c(\u2603, \u2603, \u2603, \u2603);
    }

    public static void color3f(final float \u2603, final float \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.c(\u2603, \u2603, \u2603, 1.0f);
    }

    public static void clearCurrentColor() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.S();
    }

    public static void drawArrays(final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.f(\u2603, \u2603, \u2603);
    }

    public static void lineWidth(final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.d(\u2603);
    }

    public static void pixelStore(final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.n(\u2603, \u2603);
    }

    public static void pixelTransfer(final int \u2603, final float \u2603) {
        cwi.b(\u2603, \u2603);
    }

    public static void readPixels(final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603, final ByteBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603, \u2603, \u2603, \u2603, \u2603);
    }

    public static void getError(final Consumer<Integer> \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        \u2603.accept(cwi.T());
    }

    public static void getString(final int \u2603, final Consumer<String> \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        \u2603.accept(cwi.G(\u2603));
    }

    public static String getBackendDescription() {
        assertThread(RenderSystem::isInInitPhase);
        return String.format("LWJGL version %s", GLX._getLWJGLVersion());
    }

    public static String getApiDescription() {
        assertThread(RenderSystem::isInInitPhase);
        return GLX.getOpenGLVersionString();
    }

    public static LongSupplier initBackendSystem() {
        assertThread(RenderSystem::isInInitPhase);
        return GLX._initGlfw();
    }

    public static void initRenderer(final int \u2603, final boolean \u2603) {
        assertThread(RenderSystem::isInInitPhase);
        GLX._init(\u2603, \u2603);
    }

    public static void setErrorCallback(final GLFWErrorCallbackI \u2603) {
        assertThread(RenderSystem::isInInitPhase);
        GLX._setGlfwErrorCallback(\u2603);
    }

    public static void pollEvents() {
    }

    public static void recordRenderCall(final cvy \u2603) {
        RenderSystem.recordingQueue.add(\u2603);
    }

    public static void glClientActiveTexture(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.q(\u2603);
    }

    public static void renderCrosshair(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        GLX._renderCrosshair(\u2603, true, true, true);
    }

    public static void setupNvFogDistance() {
        assertThread(RenderSystem::isOnGameThread);
        GLX._setupNvFogDistance();
    }

    public static void glMultiTexCoord2f(final int \u2603, final float \u2603, final float \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603);
    }

    public static String getCapsString() {
        assertThread(RenderSystem::isOnGameThread);
        return GLX._getCapsString();
    }

    public static void setupDefaultState(final int \u2603, final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isInInitPhase);
        cwi.I();
        cwi.x(7425);
        cwi.a(1.0);
        cwi.l();
        cwi.c(515);
        cwi.f();
        cwi.a(516, 0.1f);
        cwi.s(cwi.i.b.d);
        cwi.A(5889);
        cwi.P();
        cwi.A(5888);
        cwi.e(\u2603, \u2603, \u2603, \u2603);
    }

    public static int maxSupportedTextureSize() {
        assertThread(RenderSystem::isInInitPhase);
        if (RenderSystem.MAX_SUPPORTED_TEXTURE_SIZE == -1) {
            for (int i = 16384; i > 0; i >>= 1) {
                cwi.a(32868, 0, 6408, i, i, 0, 6408, 5121, (IntBuffer)null);
                final int c = cwi.c(32868, 0, 4096);
                if (c != 0) {
                    return RenderSystem.MAX_SUPPORTED_TEXTURE_SIZE = i;
                }
            }
            RenderSystem.MAX_SUPPORTED_TEXTURE_SIZE = abe.a(cwi.H(3379), 1024, 16384);
            RenderSystem.LOGGER.info("Failed to determine maximum texture size by probing, trying GL_MAX_TEXTURE_SIZE = {}", (Object)RenderSystem.MAX_SUPPORTED_TEXTURE_SIZE);
        }
        return RenderSystem.MAX_SUPPORTED_TEXTURE_SIZE;
    }

    public static void flipFrame() {
        GLFW.glfwPollEvents();
        RenderSystem.isReplayingQueue = true;
        while (!RenderSystem.recordingQueue.isEmpty()) {
            final cvy cvy = RenderSystem.recordingQueue.poll();
            cvy.execute();
        }
        RenderSystem.isReplayingQueue = false;
        cxh.a().c().j();
    }

    public static void glBindFramebuffer(final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.h(\u2603, \u2603);
    }

    public static void glDeleteRenderbuffers(final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.m(\u2603);
    }

    public static void glDeleteFramebuffers(final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.n(\u2603);
    }

    public static void glFramebufferTexture2D(final int \u2603, final int \u2603, final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.a(\u2603, \u2603, \u2603, \u2603, \u2603);
    }

    public static void glBindRenderbuffer(final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.i(\u2603, \u2603);
    }

    public static void glRenderbufferStorage(final int \u2603, final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.b(\u2603, \u2603, \u2603, \u2603);
    }

    public static void glFramebufferRenderbuffer(final int \u2603, final int \u2603, final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThreadOrInit);
        cwi.c(\u2603, \u2603, \u2603, \u2603);
    }

    public static void glBindBuffer(final int \u2603, final Supplier<Integer> \u2603) {
        cwi.g(\u2603, (int)\u2603.get());
    }

    public static void glBufferData(final int \u2603, final ByteBuffer \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnRenderThreadOrInit);
        cwi.a(\u2603, \u2603, \u2603);
    }

    public static void glDeleteBuffers(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.l(\u2603);
    }

    public static void glUniform1i(final int \u2603, final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.f(\u2603, \u2603);
    }

    public static void glUniform1(final int \u2603, final IntBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603);
    }

    public static void glUniform2(final int \u2603, final IntBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603, \u2603);
    }

    public static void glUniform3(final int \u2603, final IntBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.c(\u2603, \u2603);
    }

    public static void glUniform4(final int \u2603, final IntBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.d(\u2603, \u2603);
    }

    public static void glUniform1(final int \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603, \u2603);
    }

    public static void glUniform2(final int \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.c(\u2603, \u2603);
    }

    public static void glUniform3(final int \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.d(\u2603, \u2603);
    }

    public static void glUniform4(final int \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.e(\u2603, \u2603);
    }

    public static void glUniformMatrix2(final int \u2603, final boolean \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603, \u2603);
    }

    public static void glUniformMatrix3(final int \u2603, final boolean \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.b(\u2603, \u2603, \u2603);
    }

    public static void glUniformMatrix4(final int \u2603, final boolean \u2603, final FloatBuffer \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.c(\u2603, \u2603, \u2603);
    }

    public static void glUseProgram(final int \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.i(\u2603);
    }

    public static void setupOverlayColor(final int \u2603, final boolean \u2603) {
        assertThread(RenderSystem::isOnGameThread);
        cwi.a(\u2603, \u2603);
    }

    public static void teardownOverlayColor() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.t();
    }

    public static void enableUsualDiffuseLighting() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.v();
    }

    public static void enableGuiDiffuseLighting() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.w();
    }

    public static void disableDiffuseLighting() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.x();
    }

    public static void setProfile(final RenderSystem.a \u2603) {
        \u2603.a();
    }

    public static void unsetProfile(final RenderSystem.a \u2603) {
        \u2603.b();
    }

    public static void beginInitialization() {
        RenderSystem.isInInit = true;
    }

    public static void finishInitialization() {
        RenderSystem.isInInit = false;
        if (!RenderSystem.recordingQueue.isEmpty()) {
            flipFrame();
        }
        if (!RenderSystem.recordingQueue.isEmpty()) {
            throw new IllegalStateException("Recorded to render queue during initialization");
        }
    }

    public static void glGenBuffers(final Consumer<Integer> \u2603) {
        if (!isOnRenderThread()) {
            recordRenderCall(() -> \u2603.accept(cwi.q()));
        }
        else {
            \u2603.accept(cwi.q());
        }
    }

    public static cxh renderThreadTesselator() {
        assertThread(RenderSystem::isOnRenderThread);
        return RenderSystem.RENDER_THREAD_TESSELATOR;
    }

    public static void defaultBlendFunc() {
        blendFuncSeparate(cwi.r.l, cwi.l.j, cwi.r.e, cwi.l.n);
    }

    public static void defaultAlphaFunc() {
        alphaFunc(516, 0.1f);
    }

    private static void setupDefaultGlState() {
        assertThread(RenderSystem::isOnGameThread);
        cwi.u();
    }

    static {
        LOGGER = LogManager.getLogger();
        recordingQueue = Queues.newConcurrentLinkedQueue();
        RENDER_THREAD_TESSELATOR = new cxh();
        RenderSystem.MAX_SUPPORTED_TEXTURE_SIZE = -1;
    }
}