Вопрос Помощь с шейдерным рендером

[n3xrot]

пытался перенести из своего клиента 1.16.5 в 1.21.1 версию рендер (шрифты получилось) а вот ректы и прочее нет

вот шейдер класс из 1.16.5

Спойлер: *1.16.5 тык*

public class Shader implements Wrapper {

    public static final int VERTEX_SHADER;
    private int programId;

    static {
        VERTEX_SHADER = GlStateManager.createShader(GL30.GL_VERTEX_SHADER);
        GlStateManager.shaderSource(VERTEX_SHADER, getShaderSource("vertex.vert"));
        GlStateManager.compileShader(VERTEX_SHADER);
    }

    public Shader(String fragmentShaderName) {
        int programId = GlStateManager.createProgram();
        try {
            int fragmentShader = GlStateManager.createShader(GL30.GL_FRAGMENT_SHADER);
            GlStateManager.shaderSource(fragmentShader, getShaderSource(fragmentShaderName));
            GlStateManager.compileShader(fragmentShader);

            int isFragmentCompiled = GL30.glGetShaderi(fragmentShader, GL30.GL_COMPILE_STATUS);
            if(isFragmentCompiled == 0) {
                GlStateManager.deleteShader(fragmentShader);
            }

            GlStateManager.attachShader(programId, VERTEX_SHADER);
            GlStateManager.attachShader(programId, fragmentShader);
            GlStateManager.linkProgram(programId);
        } catch(Exception e) {
            e.printStackTrace();
        }
        this.programId = programId;
    }

    public void load() {
        GlStateManager.useProgram(programId);
    }

    public void unload() {
        GlStateManager.useProgram(0);
    }

    public void setUniformf(String name, float... args) {
        int loc = GL30.glGetUniformLocation(programId, name);
        switch (args.length) {
            case 1:
                GL30.glUniform1f(loc, args[0]);
                break;
            case 2:
                GL30.glUniform2f(loc, args[0], args[1]);
                break;
            case 3:
                GL30.glUniform3f(loc, args[0], args[1], args[2]);
                break;
            case 4:
                GL30.glUniform4f(loc, args[0], args[1], args[2], args[3]);
                break;
        }
    }

    public static void draw(double x, double y, double width, double height) {
        GL30.glBegin(GL_QUADS);
        GL30.glTexCoord2d(0, 0);
        GL30.glVertex2d(x, y);
        GL30.glTexCoord2d(0, 1);
        GL30.glVertex2d(x, y + height);
        GL30.glTexCoord2d(1, 1);
        GL30.glVertex2d(x + width, y + height);
        GL30.glTexCoord2d(1, 0);
        GL30.glVertex2d(x + width, y);
        GL30.glEnd();
    }

    public static String getShaderSource(String fileName) {
        String source = "";
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(Client.class
                .getResourceAsStream("/client/shaders/" + fileName)));
        source = bufferedReader.lines().filter(str -> !str.isEmpty()).map(str -> str = str.replace("\t", "")).collect(Collectors.joining("\n"));
        try {
            bufferedReader.close();
        } catch (IOException ignored) {

        }
        return source;
    }
}

и вот как я перенес в новую версию:

Спойлер: *1.21.1 тык*

public class Shader implements Wrapper {

    public static final int VERTEX_SHADER;
    private int programId;

    static {
        VERTEX_SHADER = GL20.glCreateShader(GL20.GL_VERTEX_SHADER);
        GL20.glShaderSource(VERTEX_SHADER, getShaderSource("vertex.vert"));
        GL20.glCompileShader(VERTEX_SHADER);
    }

    public Shader(String fragmentShaderName) {
        int programId = GL20.glCreateProgram();
        try {
            int fragmentShader = GL20.glCreateShader(GL20.GL_FRAGMENT_SHADER);
            GL20.glShaderSource(fragmentShader, getShaderSource(fragmentShaderName));
            GL20.glCompileShader(fragmentShader);

            int isFragmentCompiled = GL20.glGetShaderi(fragmentShader, GL20.GL_COMPILE_STATUS);
            if(isFragmentCompiled == 0) {
                GL20.glDeleteShader(fragmentShader);
                throw new RuntimeException("Failed to compile fragment shader: " + fragmentShaderName);
            }

            GL20.glAttachShader(programId, VERTEX_SHADER);
            GL20.glAttachShader(programId, fragmentShader);
            GL20.glLinkProgram(programId);

            int isLinked = GL20.glGetProgrami(programId, GL20.GL_LINK_STATUS);
            if(isLinked == 0) {
                throw new RuntimeException("Failed to link shader program: " + GL20.glGetProgramInfoLog(programId));
            }

            GL20.glDeleteShader(fragmentShader);

        } catch(Exception e) {
            e.printStackTrace();
            if(programId != 0) {
                GL20.glDeleteProgram(programId);
            }
            throw new RuntimeException("Failed to create shader", e);
        }
        this.programId = programId;
    }

    public void load() {
        GL20.glUseProgram(programId);
    }

    public void unload() {
        GL20.glUseProgram(0);
    }

    public void setUniformf(String name, float... args) {
        int loc = GL20.glGetUniformLocation(programId, name);
        switch (args.length) {
            case 1:
                GL20.glUniform1f(loc, args[0]);
                break;
            case 2:
                GL20.glUniform2f(loc, args[0], args[1]);
                break;
            case 3:
                GL20.glUniform3f(loc, args[0], args[1], args[2]);
                break;
            case 4:
                GL20.glUniform4f(loc, args[0], args[1], args[2], args[3]);
                break;
        }
    }

    public static void draw(double x, double y, double width, double height) {
        RenderSystem.setShader(GameRenderer::getPositionTexShader);
        Tesselator tessellator = Tesselator.getInstance();
        BufferBuilder buffer = tessellator.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX);

        float fX = (float)x;
        float fY = (float)y;
        float fWidth = (float)width;
        float fHeight = (float)height;

        buffer.addVertex(fX, fY + fHeight, 0).setUv(0, 1);
        buffer.addVertex(fX + fWidth, fY + fHeight, 0).setUv(1, 1);
        buffer.addVertex(fX + fWidth, fY, 0).setUv(1, 0);
        buffer.addVertex(fX, fY, 0).setUv(0, 0);

        BufferUploader.drawWithShader(buffer.build());
    }

    public static String getShaderSource(String fileName) {
        String source = "";
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(Client.class
                .getResourceAsStream("/client/shaders/" + fileName)));
        source = bufferedReader.lines().filter(str -> !str.isEmpty()).map(str -> str = str.replace("\t", "")).collect(Collectors.joining("\n"));
        try {
            bufferedReader.close();
        } catch (IOException ignored) {

        }
        return source;
    }
}

ну и класс рендер-утилки где функция ректа

Спойлер: renderutil

public class Render {
    private static final Shader ROUNDED = new Shader("rounded.frag");

    public static void drawSetup() {
        RenderSystem.enableBlend();
        RenderSystem.defaultBlendFunc();
    }

    public static void drawFinish() {
        RenderSystem.disableBlend();
        RenderSystem.setShaderColor(1.0f, 1.0f, 1.0f, 1.0f);
    }

    public static void rect(float x, float y, float width, float height, Vector4f radius, Color color) {
        float[] c = ColorUtil.comps(color);

        drawSetup();
        ROUNDED.load();

        ROUNDED.setUniformf("size", width, height);
        ROUNDED.setUniformf("round", radius.x * 2, radius.y * 2, radius.z * 2, radius.w * 2);
        ROUNDED.setUniformf("color", c[0], c[1], c[2], c[3]);

        Shader.draw(x, y, width, height);

        ROUNDED.unload();
        drawFinish();
    }
}

вызываю его так:
Render.rect(this.width / 2, this.height / 2 - 100, 200, 200, 4, new Color(255, 255, 0));
но это не рект или что то подобное, а просто атлас текстур из игры, иногда это шрифты иногда текстуры блоков и вещей, в чем проблема? не могу уже решить 2 часа
и зависит это от самого шейдера? если что там стоит #version 120