1586 lines
58 KiB
Java
1586 lines
58 KiB
Java
package com.mojang.blaze3d.platform;
|
|
|
|
import java.util.stream.IntStream;
|
|
import org.lwjgl.system.MemoryUtil;
|
|
import javax.annotation.Nullable;
|
|
import com.mojang.math.Vector4f;
|
|
import com.mojang.math.Matrix4f;
|
|
import com.mojang.math.Vector3f;
|
|
import org.lwjgl.opengl.GL13;
|
|
import org.lwjgl.opengl.EXTFramebufferBlit;
|
|
import org.lwjgl.opengl.EXTFramebufferObject;
|
|
import org.lwjgl.opengl.ARBFramebufferObject;
|
|
import org.lwjgl.opengl.GL30;
|
|
import java.nio.ByteBuffer;
|
|
import org.lwjgl.opengl.GL15;
|
|
import java.nio.IntBuffer;
|
|
import org.lwjgl.opengl.GL20;
|
|
import org.lwjgl.opengl.GLCapabilities;
|
|
import org.lwjgl.opengl.GL14;
|
|
import org.lwjgl.opengl.GL11;
|
|
import com.mojang.blaze3d.systems.RenderSystem;
|
|
import java.nio.FloatBuffer;
|
|
|
|
public class GlStateManager {
|
|
private static final FloatBuffer MATRIX_BUFFER;
|
|
private static final AlphaState ALPHA_TEST;
|
|
private static final BooleanState LIGHTING;
|
|
private static final BooleanState[] LIGHT_ENABLE;
|
|
private static final ColorMaterialState COLOR_MATERIAL;
|
|
private static final BlendState BLEND;
|
|
private static final DepthState DEPTH;
|
|
private static final FogState FOG;
|
|
private static final CullState CULL;
|
|
private static final PolygonOffsetState POLY_OFFSET;
|
|
private static final ColorLogicState COLOR_LOGIC;
|
|
private static final TexGenState TEX_GEN;
|
|
private static final StencilState STENCIL;
|
|
private static final FloatBuffer FLOAT_ARG_BUFFER;
|
|
private static int activeTexture;
|
|
private static final TextureState[] TEXTURES;
|
|
private static int shadeModel;
|
|
private static final BooleanState RESCALE_NORMAL;
|
|
private static final ColorMask COLOR_MASK;
|
|
private static final Color COLOR;
|
|
private static FboMode fboMode;
|
|
private static FboBlitMode fboBlitMode;
|
|
|
|
@Deprecated
|
|
public static void _pushLightingAttributes() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glPushAttrib(8256);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _pushTextureAttributes() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glPushAttrib(270336);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _popAttributes() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glPopAttrib();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _disableAlphaTest() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.ALPHA_TEST.mode.disable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _enableAlphaTest() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GlStateManager.ALPHA_TEST.mode.enable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _alphaFunc(final int integer, final float float2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
if (integer != GlStateManager.ALPHA_TEST.func || float2 != GlStateManager.ALPHA_TEST.reference) {
|
|
GL11.glAlphaFunc(GlStateManager.ALPHA_TEST.func = integer, GlStateManager.ALPHA_TEST.reference = float2);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _enableLighting() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.LIGHTING.enable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _disableLighting() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.LIGHTING.disable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _enableLight(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.LIGHT_ENABLE[integer].enable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _enableColorMaterial() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.COLOR_MATERIAL.enable.enable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _disableColorMaterial() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.COLOR_MATERIAL.enable.disable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _colorMaterial(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (integer1 != GlStateManager.COLOR_MATERIAL.face || integer2 != GlStateManager.COLOR_MATERIAL.mode) {
|
|
GL11.glColorMaterial(GlStateManager.COLOR_MATERIAL.face = integer1, GlStateManager.COLOR_MATERIAL.mode = integer2);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _light(final int integer1, final int integer2, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glLightfv(integer1, integer2, floatBuffer);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _lightModel(final int integer, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glLightModelfv(integer, floatBuffer);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _normal3f(final float float1, final float float2, final float float3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glNormal3f(float1, float2, float3);
|
|
}
|
|
|
|
public static void _disableDepthTest() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GlStateManager.DEPTH.mode.disable();
|
|
}
|
|
|
|
public static void _enableDepthTest() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GlStateManager.DEPTH.mode.enable();
|
|
}
|
|
|
|
public static void _depthFunc(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
if (integer != GlStateManager.DEPTH.func) {
|
|
GL11.glDepthFunc(GlStateManager.DEPTH.func = integer);
|
|
}
|
|
}
|
|
|
|
public static void _depthMask(final boolean boolean1) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (boolean1 != GlStateManager.DEPTH.mask) {
|
|
GL11.glDepthMask(GlStateManager.DEPTH.mask = boolean1);
|
|
}
|
|
}
|
|
|
|
public static void _disableBlend() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.BLEND.mode.disable();
|
|
}
|
|
|
|
public static void _enableBlend() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.BLEND.mode.enable();
|
|
}
|
|
|
|
public static void _blendFunc(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (integer1 != GlStateManager.BLEND.srcRgb || integer2 != GlStateManager.BLEND.dstRgb) {
|
|
GL11.glBlendFunc(GlStateManager.BLEND.srcRgb = integer1, GlStateManager.BLEND.dstRgb = integer2);
|
|
}
|
|
}
|
|
|
|
public static void _blendFuncSeparate(final int integer1, final int integer2, final int integer3, final int integer4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (integer1 != GlStateManager.BLEND.srcRgb || integer2 != GlStateManager.BLEND.dstRgb || integer3 != GlStateManager.BLEND.srcAlpha || integer4 != GlStateManager.BLEND.dstAlpha) {
|
|
glBlendFuncSeparate(GlStateManager.BLEND.srcRgb = integer1, GlStateManager.BLEND.dstRgb = integer2, GlStateManager.BLEND.srcAlpha = integer3, GlStateManager.BLEND.dstAlpha = integer4);
|
|
}
|
|
}
|
|
|
|
public static void _blendColor(final float float1, final float float2, final float float3, final float float4) {
|
|
GL14.glBlendColor(float1, float2, float3, float4);
|
|
}
|
|
|
|
public static void _blendEquation(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL14.glBlendEquation(integer);
|
|
}
|
|
|
|
public static String _init_fbo(final GLCapabilities gLCapabilities) {
|
|
RenderSystem.assertThread(RenderSystem::isInInitPhase);
|
|
if (gLCapabilities.OpenGL30) {
|
|
GlStateManager.fboBlitMode = FboBlitMode.BASE;
|
|
}
|
|
else if (gLCapabilities.GL_EXT_framebuffer_blit) {
|
|
GlStateManager.fboBlitMode = FboBlitMode.EXT;
|
|
}
|
|
else {
|
|
GlStateManager.fboBlitMode = FboBlitMode.NONE;
|
|
}
|
|
if (gLCapabilities.OpenGL30) {
|
|
GlStateManager.fboMode = FboMode.BASE;
|
|
GlConst.GL_FRAMEBUFFER = 36160;
|
|
GlConst.GL_RENDERBUFFER = 36161;
|
|
GlConst.GL_COLOR_ATTACHMENT0 = 36064;
|
|
GlConst.GL_DEPTH_ATTACHMENT = 36096;
|
|
GlConst.GL_FRAMEBUFFER_COMPLETE = 36053;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 36054;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 36055;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 36059;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 36060;
|
|
return "OpenGL 3.0";
|
|
}
|
|
if (gLCapabilities.GL_ARB_framebuffer_object) {
|
|
GlStateManager.fboMode = FboMode.ARB;
|
|
GlConst.GL_FRAMEBUFFER = 36160;
|
|
GlConst.GL_RENDERBUFFER = 36161;
|
|
GlConst.GL_COLOR_ATTACHMENT0 = 36064;
|
|
GlConst.GL_DEPTH_ATTACHMENT = 36096;
|
|
GlConst.GL_FRAMEBUFFER_COMPLETE = 36053;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 36055;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 36054;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 36059;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 36060;
|
|
return "ARB_framebuffer_object extension";
|
|
}
|
|
if (gLCapabilities.GL_EXT_framebuffer_object) {
|
|
GlStateManager.fboMode = FboMode.EXT;
|
|
GlConst.GL_FRAMEBUFFER = 36160;
|
|
GlConst.GL_RENDERBUFFER = 36161;
|
|
GlConst.GL_COLOR_ATTACHMENT0 = 36064;
|
|
GlConst.GL_DEPTH_ATTACHMENT = 36096;
|
|
GlConst.GL_FRAMEBUFFER_COMPLETE = 36053;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 36055;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 36054;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 36059;
|
|
GlConst.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 36060;
|
|
return "EXT_framebuffer_object extension";
|
|
}
|
|
throw new IllegalStateException("Could not initialize framebuffer support.");
|
|
}
|
|
|
|
public static int glGetProgrami(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL20.glGetProgrami(integer1, integer2);
|
|
}
|
|
|
|
public static void glAttachShader(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glAttachShader(integer1, integer2);
|
|
}
|
|
|
|
public static void glDeleteShader(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glDeleteShader(integer);
|
|
}
|
|
|
|
public static int glCreateShader(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL20.glCreateShader(integer);
|
|
}
|
|
|
|
public static void glShaderSource(final int integer, final CharSequence charSequence) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glShaderSource(integer, charSequence);
|
|
}
|
|
|
|
public static void glCompileShader(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glCompileShader(integer);
|
|
}
|
|
|
|
public static int glGetShaderi(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL20.glGetShaderi(integer1, integer2);
|
|
}
|
|
|
|
public static void _glUseProgram(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUseProgram(integer);
|
|
}
|
|
|
|
public static int glCreateProgram() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL20.glCreateProgram();
|
|
}
|
|
|
|
public static void glDeleteProgram(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glDeleteProgram(integer);
|
|
}
|
|
|
|
public static void glLinkProgram(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glLinkProgram(integer);
|
|
}
|
|
|
|
public static int _glGetUniformLocation(final int integer, final CharSequence charSequence) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL20.glGetUniformLocation(integer, charSequence);
|
|
}
|
|
|
|
public static void _glUniform1(final int integer, final IntBuffer intBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniform1iv(integer, intBuffer);
|
|
}
|
|
|
|
public static void _glUniform1i(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniform1i(integer1, integer2);
|
|
}
|
|
|
|
public static void _glUniform1(final int integer, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniform1fv(integer, floatBuffer);
|
|
}
|
|
|
|
public static void _glUniform2(final int integer, final IntBuffer intBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniform2iv(integer, intBuffer);
|
|
}
|
|
|
|
public static void _glUniform2(final int integer, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniform2fv(integer, floatBuffer);
|
|
}
|
|
|
|
public static void _glUniform3(final int integer, final IntBuffer intBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniform3iv(integer, intBuffer);
|
|
}
|
|
|
|
public static void _glUniform3(final int integer, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniform3fv(integer, floatBuffer);
|
|
}
|
|
|
|
public static void _glUniform4(final int integer, final IntBuffer intBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniform4iv(integer, intBuffer);
|
|
}
|
|
|
|
public static void _glUniform4(final int integer, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniform4fv(integer, floatBuffer);
|
|
}
|
|
|
|
public static void _glUniformMatrix2(final int integer, final boolean boolean2, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniformMatrix2fv(integer, boolean2, floatBuffer);
|
|
}
|
|
|
|
public static void _glUniformMatrix3(final int integer, final boolean boolean2, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniformMatrix3fv(integer, boolean2, floatBuffer);
|
|
}
|
|
|
|
public static void _glUniformMatrix4(final int integer, final boolean boolean2, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glUniformMatrix4fv(integer, boolean2, floatBuffer);
|
|
}
|
|
|
|
public static int _glGetAttribLocation(final int integer, final CharSequence charSequence) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL20.glGetAttribLocation(integer, charSequence);
|
|
}
|
|
|
|
public static int _glGenBuffers() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
return GL15.glGenBuffers();
|
|
}
|
|
|
|
public static void _glBindBuffer(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL15.glBindBuffer(integer1, integer2);
|
|
}
|
|
|
|
public static void _glBufferData(final int integer1, final ByteBuffer byteBuffer, final int integer3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL15.glBufferData(integer1, byteBuffer, integer3);
|
|
}
|
|
|
|
public static void _glDeleteBuffers(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL15.glDeleteBuffers(integer);
|
|
}
|
|
|
|
public static void _glCopyTexSubImage2D(final int integer1, final int integer2, final int integer3, final int integer4, final int integer5, final int integer6, final int integer7, final int integer8) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL20.glCopyTexSubImage2D(integer1, integer2, integer3, integer4, integer5, integer6, integer7, integer8);
|
|
}
|
|
|
|
public static void _glBindFramebuffer(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
switch (GlStateManager.fboMode) {
|
|
case BASE: {
|
|
GL30.glBindFramebuffer(integer1, integer2);
|
|
break;
|
|
}
|
|
case ARB: {
|
|
ARBFramebufferObject.glBindFramebuffer(integer1, integer2);
|
|
break;
|
|
}
|
|
case EXT: {
|
|
EXTFramebufferObject.glBindFramebufferEXT(integer1, integer2);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int getFramebufferDepthTexture() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
switch (GlStateManager.fboMode) {
|
|
case BASE: {
|
|
if (GL30.glGetFramebufferAttachmentParameteri(36160, 36096, 36048) == 5890) {
|
|
return GL30.glGetFramebufferAttachmentParameteri(36160, 36096, 36049);
|
|
}
|
|
break;
|
|
}
|
|
case ARB: {
|
|
if (ARBFramebufferObject.glGetFramebufferAttachmentParameteri(36160, 36096, 36048) == 5890) {
|
|
return ARBFramebufferObject.glGetFramebufferAttachmentParameteri(36160, 36096, 36049);
|
|
}
|
|
break;
|
|
}
|
|
case EXT: {
|
|
if (EXTFramebufferObject.glGetFramebufferAttachmentParameteriEXT(36160, 36096, 36048) == 5890) {
|
|
return EXTFramebufferObject.glGetFramebufferAttachmentParameteriEXT(36160, 36096, 36049);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static void _glBlitFrameBuffer(final int integer1, final int integer2, final int integer3, final int integer4, final int integer5, final int integer6, final int integer7, final int integer8, final int integer9, final int integer10) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
switch (GlStateManager.fboBlitMode) {
|
|
case BASE: {
|
|
GL30.glBlitFramebuffer(integer1, integer2, integer3, integer4, integer5, integer6, integer7, integer8, integer9, integer10);
|
|
break;
|
|
}
|
|
case EXT: {
|
|
EXTFramebufferBlit.glBlitFramebufferEXT(integer1, integer2, integer3, integer4, integer5, integer6, integer7, integer8, integer9, integer10);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void _glDeleteFramebuffers(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
switch (GlStateManager.fboMode) {
|
|
case BASE: {
|
|
GL30.glDeleteFramebuffers(integer);
|
|
break;
|
|
}
|
|
case ARB: {
|
|
ARBFramebufferObject.glDeleteFramebuffers(integer);
|
|
break;
|
|
}
|
|
case EXT: {
|
|
EXTFramebufferObject.glDeleteFramebuffersEXT(integer);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int glGenFramebuffers() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
switch (GlStateManager.fboMode) {
|
|
case BASE: {
|
|
return GL30.glGenFramebuffers();
|
|
}
|
|
case ARB: {
|
|
return ARBFramebufferObject.glGenFramebuffers();
|
|
}
|
|
case EXT: {
|
|
return EXTFramebufferObject.glGenFramebuffersEXT();
|
|
}
|
|
default: {
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int glCheckFramebufferStatus(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
switch (GlStateManager.fboMode) {
|
|
case BASE: {
|
|
return GL30.glCheckFramebufferStatus(integer);
|
|
}
|
|
case ARB: {
|
|
return ARBFramebufferObject.glCheckFramebufferStatus(integer);
|
|
}
|
|
case EXT: {
|
|
return EXTFramebufferObject.glCheckFramebufferStatusEXT(integer);
|
|
}
|
|
default: {
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void _glFramebufferTexture2D(final int integer1, final int integer2, final int integer3, final int integer4, final int integer5) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
switch (GlStateManager.fboMode) {
|
|
case BASE: {
|
|
GL30.glFramebufferTexture2D(integer1, integer2, integer3, integer4, integer5);
|
|
break;
|
|
}
|
|
case ARB: {
|
|
ARBFramebufferObject.glFramebufferTexture2D(integer1, integer2, integer3, integer4, integer5);
|
|
break;
|
|
}
|
|
case EXT: {
|
|
EXTFramebufferObject.glFramebufferTexture2DEXT(integer1, integer2, integer3, integer4, integer5);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static int getActiveTextureName() {
|
|
return GlStateManager.TEXTURES[GlStateManager.activeTexture].binding;
|
|
}
|
|
|
|
public static void glActiveTexture(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL13.glActiveTexture(integer);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _glClientActiveTexture(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL13.glClientActiveTexture(integer);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _glMultiTexCoord2f(final int integer, final float float2, final float float3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL13.glMultiTexCoord2f(integer, float2, float3);
|
|
}
|
|
|
|
public static void glBlendFuncSeparate(final int integer1, final int integer2, final int integer3, final int integer4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL14.glBlendFuncSeparate(integer1, integer2, integer3, integer4);
|
|
}
|
|
|
|
public static String glGetShaderInfoLog(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL20.glGetShaderInfoLog(integer1, integer2);
|
|
}
|
|
|
|
public static String glGetProgramInfoLog(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL20.glGetProgramInfoLog(integer1, integer2);
|
|
}
|
|
|
|
public static void setupOutline() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
_texEnv(8960, 8704, 34160);
|
|
color1arg(7681, 34168);
|
|
}
|
|
|
|
public static void teardownOutline() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
_texEnv(8960, 8704, 8448);
|
|
color3arg(8448, 5890, 34168, 34166);
|
|
}
|
|
|
|
public static void setupOverlayColor(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
_activeTexture(33985);
|
|
_enableTexture();
|
|
_matrixMode(5890);
|
|
_loadIdentity();
|
|
final float float3 = 1.0f / (integer2 - 1);
|
|
_scalef(float3, float3, float3);
|
|
_matrixMode(5888);
|
|
_bindTexture(integer1);
|
|
_texParameter(3553, 10241, 9728);
|
|
_texParameter(3553, 10240, 9728);
|
|
_texParameter(3553, 10242, 10496);
|
|
_texParameter(3553, 10243, 10496);
|
|
_texEnv(8960, 8704, 34160);
|
|
color3arg(34165, 34168, 5890, 5890);
|
|
alpha1arg(7681, 34168);
|
|
_activeTexture(33984);
|
|
}
|
|
|
|
public static void teardownOverlayColor() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
_activeTexture(33985);
|
|
_disableTexture();
|
|
_activeTexture(33984);
|
|
}
|
|
|
|
private static void color1arg(final int integer1, final int integer2) {
|
|
_texEnv(8960, 34161, integer1);
|
|
_texEnv(8960, 34176, integer2);
|
|
_texEnv(8960, 34192, 768);
|
|
}
|
|
|
|
private static void color3arg(final int integer1, final int integer2, final int integer3, final int integer4) {
|
|
_texEnv(8960, 34161, integer1);
|
|
_texEnv(8960, 34176, integer2);
|
|
_texEnv(8960, 34192, 768);
|
|
_texEnv(8960, 34177, integer3);
|
|
_texEnv(8960, 34193, 768);
|
|
_texEnv(8960, 34178, integer4);
|
|
_texEnv(8960, 34194, 770);
|
|
}
|
|
|
|
private static void alpha1arg(final int integer1, final int integer2) {
|
|
_texEnv(8960, 34162, integer1);
|
|
_texEnv(8960, 34184, integer2);
|
|
_texEnv(8960, 34200, 770);
|
|
}
|
|
|
|
public static void setupLevelDiffuseLighting(final Vector3f g1, final Vector3f g2, final Matrix4f b) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
_pushMatrix();
|
|
_loadIdentity();
|
|
_enableLight(0);
|
|
_enableLight(1);
|
|
final Vector4f h4 = new Vector4f(g1);
|
|
h4.transform(b);
|
|
_light(16384, 4611, getBuffer(h4.x(), h4.y(), h4.z(), 0.0f));
|
|
final float float5 = 0.6f;
|
|
_light(16384, 4609, getBuffer(0.6f, 0.6f, 0.6f, 1.0f));
|
|
_light(16384, 4608, getBuffer(0.0f, 0.0f, 0.0f, 1.0f));
|
|
_light(16384, 4610, getBuffer(0.0f, 0.0f, 0.0f, 1.0f));
|
|
final Vector4f h5 = new Vector4f(g2);
|
|
h5.transform(b);
|
|
_light(16385, 4611, getBuffer(h5.x(), h5.y(), h5.z(), 0.0f));
|
|
_light(16385, 4609, getBuffer(0.6f, 0.6f, 0.6f, 1.0f));
|
|
_light(16385, 4608, getBuffer(0.0f, 0.0f, 0.0f, 1.0f));
|
|
_light(16385, 4610, getBuffer(0.0f, 0.0f, 0.0f, 1.0f));
|
|
_shadeModel(7424);
|
|
final float float6 = 0.4f;
|
|
_lightModel(2899, getBuffer(0.4f, 0.4f, 0.4f, 1.0f));
|
|
_popMatrix();
|
|
}
|
|
|
|
public static void setupGuiFlatDiffuseLighting(final Vector3f g1, final Vector3f g2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
final Matrix4f b3 = new Matrix4f();
|
|
b3.setIdentity();
|
|
b3.multiply(Matrix4f.createScaleMatrix(1.0f, -1.0f, 1.0f));
|
|
b3.multiply(Vector3f.YP.rotationDegrees(-22.5f));
|
|
b3.multiply(Vector3f.XP.rotationDegrees(135.0f));
|
|
setupLevelDiffuseLighting(g1, g2, b3);
|
|
}
|
|
|
|
public static void setupGui3DDiffuseLighting(final Vector3f g1, final Vector3f g2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
final Matrix4f b3 = new Matrix4f();
|
|
b3.setIdentity();
|
|
b3.multiply(Vector3f.YP.rotationDegrees(62.0f));
|
|
b3.multiply(Vector3f.XP.rotationDegrees(185.5f));
|
|
b3.multiply(Matrix4f.createScaleMatrix(1.0f, -1.0f, 1.0f));
|
|
b3.multiply(Vector3f.YP.rotationDegrees(-22.5f));
|
|
b3.multiply(Vector3f.XP.rotationDegrees(135.0f));
|
|
setupLevelDiffuseLighting(g1, g2, b3);
|
|
}
|
|
|
|
private static FloatBuffer getBuffer(final float float1, final float float2, final float float3, final float float4) {
|
|
GlStateManager.FLOAT_ARG_BUFFER.clear();
|
|
GlStateManager.FLOAT_ARG_BUFFER.put(float1).put(float2).put(float3).put(float4);
|
|
GlStateManager.FLOAT_ARG_BUFFER.flip();
|
|
return GlStateManager.FLOAT_ARG_BUFFER;
|
|
}
|
|
|
|
public static void setupEndPortalTexGen() {
|
|
_texGenMode(TexGen.S, 9216);
|
|
_texGenMode(TexGen.T, 9216);
|
|
_texGenMode(TexGen.R, 9216);
|
|
_texGenParam(TexGen.S, 9474, getBuffer(1.0f, 0.0f, 0.0f, 0.0f));
|
|
_texGenParam(TexGen.T, 9474, getBuffer(0.0f, 1.0f, 0.0f, 0.0f));
|
|
_texGenParam(TexGen.R, 9474, getBuffer(0.0f, 0.0f, 1.0f, 0.0f));
|
|
_enableTexGen(TexGen.S);
|
|
_enableTexGen(TexGen.T);
|
|
_enableTexGen(TexGen.R);
|
|
}
|
|
|
|
public static void clearTexGen() {
|
|
_disableTexGen(TexGen.S);
|
|
_disableTexGen(TexGen.T);
|
|
_disableTexGen(TexGen.R);
|
|
}
|
|
|
|
public static void mulTextureByProjModelView() {
|
|
_getMatrix(2983, GlStateManager.MATRIX_BUFFER);
|
|
_multMatrix(GlStateManager.MATRIX_BUFFER);
|
|
_getMatrix(2982, GlStateManager.MATRIX_BUFFER);
|
|
_multMatrix(GlStateManager.MATRIX_BUFFER);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _enableFog() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.FOG.enable.enable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _disableFog() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.FOG.enable.disable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _fogMode(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (integer != GlStateManager.FOG.mode) {
|
|
_fogi(2917, GlStateManager.FOG.mode = integer);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _fogDensity(final float float1) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (float1 != GlStateManager.FOG.density) {
|
|
GL11.glFogf(2914, GlStateManager.FOG.density = float1);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _fogStart(final float float1) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (float1 != GlStateManager.FOG.start) {
|
|
GL11.glFogf(2915, GlStateManager.FOG.start = float1);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _fogEnd(final float float1) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (float1 != GlStateManager.FOG.end) {
|
|
GL11.glFogf(2916, GlStateManager.FOG.end = float1);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _fog(final int integer, final float[] arr) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glFogfv(integer, arr);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _fogi(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glFogi(integer1, integer2);
|
|
}
|
|
|
|
public static void _enableCull() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.CULL.enable.enable();
|
|
}
|
|
|
|
public static void _disableCull() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.CULL.enable.disable();
|
|
}
|
|
|
|
public static void _polygonMode(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glPolygonMode(integer1, integer2);
|
|
}
|
|
|
|
public static void _enablePolygonOffset() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.POLY_OFFSET.fill.enable();
|
|
}
|
|
|
|
public static void _disablePolygonOffset() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.POLY_OFFSET.fill.disable();
|
|
}
|
|
|
|
public static void _enableLineOffset() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.POLY_OFFSET.line.enable();
|
|
}
|
|
|
|
public static void _disableLineOffset() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.POLY_OFFSET.line.disable();
|
|
}
|
|
|
|
public static void _polygonOffset(final float float1, final float float2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (float1 != GlStateManager.POLY_OFFSET.factor || float2 != GlStateManager.POLY_OFFSET.units) {
|
|
GL11.glPolygonOffset(GlStateManager.POLY_OFFSET.factor = float1, GlStateManager.POLY_OFFSET.units = float2);
|
|
}
|
|
}
|
|
|
|
public static void _enableColorLogicOp() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.COLOR_LOGIC.enable.enable();
|
|
}
|
|
|
|
public static void _disableColorLogicOp() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.COLOR_LOGIC.enable.disable();
|
|
}
|
|
|
|
public static void _logicOp(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (integer != GlStateManager.COLOR_LOGIC.op) {
|
|
GL11.glLogicOp(GlStateManager.COLOR_LOGIC.op = integer);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _enableTexGen(final TexGen t) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
getTexGen(t).enable.enable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _disableTexGen(final TexGen t) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
getTexGen(t).enable.disable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _texGenMode(final TexGen t, final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
final TexGenCoord u3 = getTexGen(t);
|
|
if (integer != u3.mode) {
|
|
u3.mode = integer;
|
|
GL11.glTexGeni(u3.coord, 9472, integer);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _texGenParam(final TexGen t, final int integer, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glTexGenfv(getTexGen(t).coord, integer, floatBuffer);
|
|
}
|
|
|
|
@Deprecated
|
|
private static TexGenCoord getTexGen(final TexGen t) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
switch (t) {
|
|
case S: {
|
|
return GlStateManager.TEX_GEN.s;
|
|
}
|
|
case T: {
|
|
return GlStateManager.TEX_GEN.t;
|
|
}
|
|
case R: {
|
|
return GlStateManager.TEX_GEN.r;
|
|
}
|
|
case Q: {
|
|
return GlStateManager.TEX_GEN.q;
|
|
}
|
|
default: {
|
|
return GlStateManager.TEX_GEN.s;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void _activeTexture(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (GlStateManager.activeTexture != integer - 33984) {
|
|
GlStateManager.activeTexture = integer - 33984;
|
|
glActiveTexture(integer);
|
|
}
|
|
}
|
|
|
|
public static void _enableTexture() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GlStateManager.TEXTURES[GlStateManager.activeTexture].enable.enable();
|
|
}
|
|
|
|
public static void _disableTexture() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.TEXTURES[GlStateManager.activeTexture].enable.disable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _texEnv(final int integer1, final int integer2, final int integer3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glTexEnvi(integer1, integer2, integer3);
|
|
}
|
|
|
|
public static void _texParameter(final int integer1, final int integer2, final float float3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glTexParameterf(integer1, integer2, float3);
|
|
}
|
|
|
|
public static void _texParameter(final int integer1, final int integer2, final int integer3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glTexParameteri(integer1, integer2, integer3);
|
|
}
|
|
|
|
public static int _getTexLevelParameter(final int integer1, final int integer2, final int integer3) {
|
|
RenderSystem.assertThread(RenderSystem::isInInitPhase);
|
|
return GL11.glGetTexLevelParameteri(integer1, integer2, integer3);
|
|
}
|
|
|
|
public static int _genTexture() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
return GL11.glGenTextures();
|
|
}
|
|
|
|
public static void _deleteTexture(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glDeleteTextures(integer);
|
|
for (final TextureState w5 : GlStateManager.TEXTURES) {
|
|
if (w5.binding == integer) {
|
|
w5.binding = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void _bindTexture(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
if (integer != GlStateManager.TEXTURES[GlStateManager.activeTexture].binding) {
|
|
GL11.glBindTexture(3553, GlStateManager.TEXTURES[GlStateManager.activeTexture].binding = integer);
|
|
}
|
|
}
|
|
|
|
public static void _texImage2D(final int integer1, final int integer2, final int integer3, final int integer4, final int integer5, final int integer6, final int integer7, final int integer8, @Nullable final IntBuffer intBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glTexImage2D(integer1, integer2, integer3, integer4, integer5, integer6, integer7, integer8, intBuffer);
|
|
}
|
|
|
|
public static void _texSubImage2D(final int integer1, final int integer2, final int integer3, final int integer4, final int integer5, final int integer6, final int integer7, final int integer8, final long long9) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glTexSubImage2D(integer1, integer2, integer3, integer4, integer5, integer6, integer7, integer8, long9);
|
|
}
|
|
|
|
public static void _getTexImage(final int integer1, final int integer2, final int integer3, final int integer4, final long long5) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glGetTexImage(integer1, integer2, integer3, integer4, long5);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _shadeModel(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
if (integer != GlStateManager.shadeModel) {
|
|
GL11.glShadeModel(GlStateManager.shadeModel = integer);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _enableRescaleNormal() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.RESCALE_NORMAL.enable();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _disableRescaleNormal() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.RESCALE_NORMAL.disable();
|
|
}
|
|
|
|
public static void _viewport(final int integer1, final int integer2, final int integer3, final int integer4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glViewport(Viewport.INSTANCE.x = integer1, Viewport.INSTANCE.y = integer2, Viewport.INSTANCE.width = integer3, Viewport.INSTANCE.height = integer4);
|
|
}
|
|
|
|
public static void _colorMask(final boolean boolean1, final boolean boolean2, final boolean boolean3, final boolean boolean4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (boolean1 != GlStateManager.COLOR_MASK.red || boolean2 != GlStateManager.COLOR_MASK.green || boolean3 != GlStateManager.COLOR_MASK.blue || boolean4 != GlStateManager.COLOR_MASK.alpha) {
|
|
GL11.glColorMask(GlStateManager.COLOR_MASK.red = boolean1, GlStateManager.COLOR_MASK.green = boolean2, GlStateManager.COLOR_MASK.blue = boolean3, GlStateManager.COLOR_MASK.alpha = boolean4);
|
|
}
|
|
}
|
|
|
|
public static void _stencilFunc(final int integer1, final int integer2, final int integer3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (integer1 != GlStateManager.STENCIL.func.func || integer1 != GlStateManager.STENCIL.func.ref || integer1 != GlStateManager.STENCIL.func.mask) {
|
|
GL11.glStencilFunc(GlStateManager.STENCIL.func.func = integer1, GlStateManager.STENCIL.func.ref = integer2, GlStateManager.STENCIL.func.mask = integer3);
|
|
}
|
|
}
|
|
|
|
public static void _stencilMask(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (integer != GlStateManager.STENCIL.mask) {
|
|
GL11.glStencilMask(GlStateManager.STENCIL.mask = integer);
|
|
}
|
|
}
|
|
|
|
public static void _stencilOp(final int integer1, final int integer2, final int integer3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (integer1 != GlStateManager.STENCIL.fail || integer2 != GlStateManager.STENCIL.zfail || integer3 != GlStateManager.STENCIL.zpass) {
|
|
GL11.glStencilOp(GlStateManager.STENCIL.fail = integer1, GlStateManager.STENCIL.zfail = integer2, GlStateManager.STENCIL.zpass = integer3);
|
|
}
|
|
}
|
|
|
|
public static void _clearDepth(final double double1) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glClearDepth(double1);
|
|
}
|
|
|
|
public static void _clearColor(final float float1, final float float2, final float float3, final float float4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glClearColor(float1, float2, float3, float4);
|
|
}
|
|
|
|
public static void _clearStencil(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glClearStencil(integer);
|
|
}
|
|
|
|
public static void _clear(final int integer, final boolean boolean2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glClear(integer);
|
|
if (boolean2) {
|
|
_getError();
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _matrixMode(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glMatrixMode(integer);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _loadIdentity() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glLoadIdentity();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _pushMatrix() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glPushMatrix();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _popMatrix() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glPopMatrix();
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _getMatrix(final int integer, final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glGetFloatv(integer, floatBuffer);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _ortho(final double double1, final double double2, final double double3, final double double4, final double double5, final double double6) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glOrtho(double1, double2, double3, double4, double5, double6);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _rotatef(final float float1, final float float2, final float float3, final float float4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glRotatef(float1, float2, float3, float4);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _scalef(final float float1, final float float2, final float float3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glScalef(float1, float2, float3);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _scaled(final double double1, final double double2, final double double3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glScaled(double1, double2, double3);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _translatef(final float float1, final float float2, final float float3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glTranslatef(float1, float2, float3);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _translated(final double double1, final double double2, final double double3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glTranslated(double1, double2, double3);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _multMatrix(final FloatBuffer floatBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glMultMatrixf(floatBuffer);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _multMatrix(final Matrix4f b) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
b.store(GlStateManager.MATRIX_BUFFER);
|
|
GlStateManager.MATRIX_BUFFER.rewind();
|
|
_multMatrix(GlStateManager.MATRIX_BUFFER);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _color4f(final float float1, final float float2, final float float3, final float float4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
if (float1 != GlStateManager.COLOR.r || float2 != GlStateManager.COLOR.g || float3 != GlStateManager.COLOR.b || float4 != GlStateManager.COLOR.a) {
|
|
GL11.glColor4f(GlStateManager.COLOR.r = float1, GlStateManager.COLOR.g = float2, GlStateManager.COLOR.b = float3, GlStateManager.COLOR.a = float4);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _clearCurrentColor() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GlStateManager.COLOR.r = -1.0f;
|
|
GlStateManager.COLOR.g = -1.0f;
|
|
GlStateManager.COLOR.b = -1.0f;
|
|
GlStateManager.COLOR.a = -1.0f;
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _normalPointer(final int integer1, final int integer2, final long long3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glNormalPointer(integer1, integer2, long3);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _texCoordPointer(final int integer1, final int integer2, final int integer3, final long long4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glTexCoordPointer(integer1, integer2, integer3, long4);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _vertexPointer(final int integer1, final int integer2, final int integer3, final long long4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glVertexPointer(integer1, integer2, integer3, long4);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _colorPointer(final int integer1, final int integer2, final int integer3, final long long4) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glColorPointer(integer1, integer2, integer3, long4);
|
|
}
|
|
|
|
public static void _vertexAttribPointer(final int integer1, final int integer2, final int integer3, final boolean boolean4, final int integer5, final long long6) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glVertexAttribPointer(integer1, integer2, integer3, boolean4, integer5, long6);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _enableClientState(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glEnableClientState(integer);
|
|
}
|
|
|
|
@Deprecated
|
|
public static void _disableClientState(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glDisableClientState(integer);
|
|
}
|
|
|
|
public static void _enableVertexAttribArray(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glEnableVertexAttribArray(integer);
|
|
}
|
|
|
|
public static void _disableVertexAttribArray(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL20.glEnableVertexAttribArray(integer);
|
|
}
|
|
|
|
public static void _drawArrays(final int integer1, final int integer2, final int integer3) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glDrawArrays(integer1, integer2, integer3);
|
|
}
|
|
|
|
public static void _lineWidth(final float float1) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glLineWidth(float1);
|
|
}
|
|
|
|
public static void _pixelStore(final int integer1, final int integer2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
GL11.glPixelStorei(integer1, integer2);
|
|
}
|
|
|
|
public static void _pixelTransfer(final int integer, final float float2) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glPixelTransferf(integer, float2);
|
|
}
|
|
|
|
public static void _readPixels(final int integer1, final int integer2, final int integer3, final int integer4, final int integer5, final int integer6, final ByteBuffer byteBuffer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
GL11.glReadPixels(integer1, integer2, integer3, integer4, integer5, integer6, byteBuffer);
|
|
}
|
|
|
|
public static int _getError() {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL11.glGetError();
|
|
}
|
|
|
|
public static String _getString(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThread);
|
|
return GL11.glGetString(integer);
|
|
}
|
|
|
|
public static int _getInteger(final int integer) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
return GL11.glGetInteger(integer);
|
|
}
|
|
|
|
public static boolean supportsFramebufferBlit() {
|
|
return GlStateManager.fboBlitMode != FboBlitMode.NONE;
|
|
}
|
|
|
|
static {
|
|
MATRIX_BUFFER = GLX.<FloatBuffer>make(MemoryUtil.memAllocFloat(16), floatBuffer -> DebugMemoryUntracker.untrack(MemoryUtil.memAddress(floatBuffer)));
|
|
ALPHA_TEST = new AlphaState();
|
|
LIGHTING = new BooleanState(2896);
|
|
LIGHT_ENABLE = IntStream.range(0, 8).mapToObj(integer -> new BooleanState(16384 + integer)).<BooleanState>toArray(BooleanState[]::new);
|
|
COLOR_MATERIAL = new ColorMaterialState();
|
|
BLEND = new BlendState();
|
|
DEPTH = new DepthState();
|
|
FOG = new FogState();
|
|
CULL = new CullState();
|
|
POLY_OFFSET = new PolygonOffsetState();
|
|
COLOR_LOGIC = new ColorLogicState();
|
|
TEX_GEN = new TexGenState();
|
|
STENCIL = new StencilState();
|
|
FLOAT_ARG_BUFFER = MemoryTracker.createFloatBuffer(4);
|
|
TEXTURES = IntStream.range(0, 12).mapToObj(integer -> new TextureState()).<TextureState>toArray(TextureState[]::new);
|
|
GlStateManager.shadeModel = 7425;
|
|
RESCALE_NORMAL = new BooleanState(32826);
|
|
COLOR_MASK = new ColorMask();
|
|
COLOR = new Color();
|
|
}
|
|
|
|
@Deprecated
|
|
public enum FogMode {
|
|
LINEAR(9729),
|
|
EXP(2048),
|
|
EXP2(2049);
|
|
|
|
public final int value;
|
|
|
|
private FogMode(final int integer3) {
|
|
this.value = integer3;
|
|
}
|
|
}
|
|
|
|
public 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 integer3) {
|
|
this.value = integer3;
|
|
}
|
|
}
|
|
|
|
public enum Viewport {
|
|
INSTANCE;
|
|
|
|
protected int x;
|
|
protected int y;
|
|
protected int width;
|
|
protected int height;
|
|
}
|
|
|
|
public enum FboMode {
|
|
BASE,
|
|
ARB,
|
|
EXT;
|
|
}
|
|
|
|
public enum FboBlitMode {
|
|
BASE,
|
|
EXT,
|
|
NONE;
|
|
}
|
|
|
|
static class TextureState {
|
|
public final BooleanState enable;
|
|
public int binding;
|
|
|
|
private TextureState() {
|
|
this.enable = new BooleanState(3553);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
static class AlphaState {
|
|
public final BooleanState mode;
|
|
public int func;
|
|
public float reference;
|
|
|
|
private AlphaState() {
|
|
this.mode = new BooleanState(3008);
|
|
this.func = 519;
|
|
this.reference = -1.0f;
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
static class ColorMaterialState {
|
|
public final BooleanState enable;
|
|
public int face;
|
|
public int mode;
|
|
|
|
private ColorMaterialState() {
|
|
this.enable = new BooleanState(2903);
|
|
this.face = 1032;
|
|
this.mode = 5634;
|
|
}
|
|
}
|
|
|
|
static class BlendState {
|
|
public final BooleanState mode;
|
|
public int srcRgb;
|
|
public int dstRgb;
|
|
public int srcAlpha;
|
|
public int dstAlpha;
|
|
|
|
private BlendState() {
|
|
this.mode = new BooleanState(3042);
|
|
this.srcRgb = 1;
|
|
this.dstRgb = 0;
|
|
this.srcAlpha = 1;
|
|
this.dstAlpha = 0;
|
|
}
|
|
}
|
|
|
|
static class DepthState {
|
|
public final BooleanState mode;
|
|
public boolean mask;
|
|
public int func;
|
|
|
|
private DepthState() {
|
|
this.mode = new BooleanState(2929);
|
|
this.mask = true;
|
|
this.func = 513;
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
static class FogState {
|
|
public final BooleanState enable;
|
|
public int mode;
|
|
public float density;
|
|
public float start;
|
|
public float end;
|
|
|
|
private FogState() {
|
|
this.enable = new BooleanState(2912);
|
|
this.mode = 2048;
|
|
this.density = 1.0f;
|
|
this.end = 1.0f;
|
|
}
|
|
}
|
|
|
|
static class CullState {
|
|
public final BooleanState enable;
|
|
public int mode;
|
|
|
|
private CullState() {
|
|
this.enable = new BooleanState(2884);
|
|
this.mode = 1029;
|
|
}
|
|
}
|
|
|
|
static class PolygonOffsetState {
|
|
public final BooleanState fill;
|
|
public final BooleanState line;
|
|
public float factor;
|
|
public float units;
|
|
|
|
private PolygonOffsetState() {
|
|
this.fill = new BooleanState(32823);
|
|
this.line = new BooleanState(10754);
|
|
}
|
|
}
|
|
|
|
static class ColorLogicState {
|
|
public final BooleanState enable;
|
|
public int op;
|
|
|
|
private ColorLogicState() {
|
|
this.enable = new BooleanState(3058);
|
|
this.op = 5379;
|
|
}
|
|
}
|
|
|
|
static class StencilFunc {
|
|
public int func;
|
|
public int ref;
|
|
public int mask;
|
|
|
|
private StencilFunc() {
|
|
this.func = 519;
|
|
this.mask = -1;
|
|
}
|
|
}
|
|
|
|
static class StencilState {
|
|
public final StencilFunc func;
|
|
public int mask;
|
|
public int fail;
|
|
public int zfail;
|
|
public int zpass;
|
|
|
|
private StencilState() {
|
|
this.func = new StencilFunc();
|
|
this.mask = -1;
|
|
this.fail = 7680;
|
|
this.zfail = 7680;
|
|
this.zpass = 7680;
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
static class TexGenState {
|
|
public final TexGenCoord s;
|
|
public final TexGenCoord t;
|
|
public final TexGenCoord r;
|
|
public final TexGenCoord q;
|
|
|
|
private TexGenState() {
|
|
this.s = new TexGenCoord(8192, 3168);
|
|
this.t = new TexGenCoord(8193, 3169);
|
|
this.r = new TexGenCoord(8194, 3170);
|
|
this.q = new TexGenCoord(8195, 3171);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
static class TexGenCoord {
|
|
public final BooleanState enable;
|
|
public final int coord;
|
|
public int mode;
|
|
|
|
public TexGenCoord(final int integer1, final int integer2) {
|
|
this.mode = -1;
|
|
this.coord = integer1;
|
|
this.enable = new BooleanState(integer2);
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
public enum TexGen {
|
|
S,
|
|
T,
|
|
R,
|
|
Q;
|
|
}
|
|
|
|
static class ColorMask {
|
|
public boolean red;
|
|
public boolean green;
|
|
public boolean blue;
|
|
public boolean alpha;
|
|
|
|
private ColorMask() {
|
|
this.red = true;
|
|
this.green = true;
|
|
this.blue = true;
|
|
this.alpha = true;
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
static class Color {
|
|
public float r;
|
|
public float g;
|
|
public float b;
|
|
public float a;
|
|
|
|
public Color() {
|
|
this(1.0f, 1.0f, 1.0f, 1.0f);
|
|
}
|
|
|
|
public Color(final float float1, final float float2, final float float3, final float float4) {
|
|
this.r = 1.0f;
|
|
this.g = 1.0f;
|
|
this.b = 1.0f;
|
|
this.a = 1.0f;
|
|
this.r = float1;
|
|
this.g = float2;
|
|
this.b = float3;
|
|
this.a = float4;
|
|
}
|
|
}
|
|
|
|
static class BooleanState {
|
|
private final int state;
|
|
private boolean enabled;
|
|
|
|
public BooleanState(final int integer) {
|
|
this.state = integer;
|
|
}
|
|
|
|
public void disable() {
|
|
this.setEnabled(false);
|
|
}
|
|
|
|
public void enable() {
|
|
this.setEnabled(true);
|
|
}
|
|
|
|
public void setEnabled(final boolean boolean1) {
|
|
RenderSystem.assertThread(RenderSystem::isOnRenderThreadOrInit);
|
|
if (boolean1 != this.enabled) {
|
|
this.enabled = boolean1;
|
|
if (boolean1) {
|
|
GL11.glEnable(this.state);
|
|
}
|
|
else {
|
|
GL11.glDisable(this.state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public 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 integer3) {
|
|
this.value = integer3;
|
|
}
|
|
}
|
|
|
|
public 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 integer3) {
|
|
this.value = integer3;
|
|
}
|
|
}
|
|
}
|