[Python] i have python out of resourse problem, can someone fix the code? [closed]

i have this code in main:, if someone knows how to fix it, please help,

from settings import *
import moderngl as mgl
import pygame as pygm
import sys
from shader_program import ShaderProgram
from scene import Scene


class VoxelEngine:
def __init__(self):
pygm.init()
pygm.display.gl_set_attribute(pygm.GL_CONTEXT_MAJOR_VERSION, 3)
pygm.display.gl_set_attribute(pygm.GL_CONTEXT_MINOR_VERSION, 3)
pygm.display.gl_set_attribute(pygm.GL_CONTEXT_PROFILE_MASK, pygm.GL_CONTEXT_PROFILE_CORE)
pygm.display.gl_set_attribute(pygm.GL_DEPTH_SIZE, 24)

pygm.display.set_mode(WIN_RES, flags=pygm.OPENGL | pygm.DOUBLEBUF)
self.ctx = mgl.create_context()

self.ctx.enable(flags=mgl.DEPTH_TEST | mgl.CULL_FACE | mgl.BLEND)
self.ctx.gc_mode = 'auto'

self.clock = pygm.time.Clock()
self.delta_time = 0
self.time = 0

self.is_running = True
self.on_init()

def on_init(self):
self.shader_program = ShaderProgram(self)
self.scene = Scene(self)

def update(self):
self.shader_program.update()
self.scene.update()

self.delta_time = self.clock.tick()
self.time = pygm.time.get_ticks() * 0.001
pygm.display.set_caption(f'{self.clock.get_fps() :.0f}')

def render(self):
self.ctx.clear(color=BG_COLR)
self.scene.render()
pygm.display.flip()

def handle_events(self):
for event in pygm.event.get():
if event.type == pygm.QUIT or (event.type == pygm.KEYDOWN and event.key == pygm.K_ESCAPE):
self.is_running = False

def run(self):
while self.is_running:
self.handle_events()
self.update()
self.render()
pygm.quit()
sys.exit()


if __name__ == '__main__':
app = VoxelEngine()
app.run()

***also this code in shader_program***

from settings import *


class ShaderProgram:
def __init__(self, app):
self.app = app
self.ctx = app.ctx
# - - - - - shadeeers... - - - - - #
self.quad = self.get_program(shader_name='quad')
# eeeeeeeeeeeeee wtf eeeeeeeeeeeeeeeeee#
self.set_uniforms_on_init()

def set_uniforms_on_init(self):
pass

def update(self):
pass

def get_program(self, shader_name):
with open(f'shaders/{shader_name}.frag') as file:
vertex_shader = file.read()

with open(f'shaders/{shader_name}.frag') as file:
fragment_shader = file.read()

program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)
return program

***this in quad_mesh***
from settings import *
from meshes.base_mesh import BaseMesh


class QuadMesh(BaseMesh):
def __init__(self, app):
super().__init__()

self.app = app
self.ctx = app.ctx
self.program = app.shader_program.quad

self.vbo_format = '3f 3f'
self.attrs = ('in_position', 'in_color')
self.vao = self.get_vao()

def get_vertex_data(self):
verices = [
(0.5, 0.5, 0.0), (-0.5, 0.5, 0.0), (-0.5, -0.5, 0.0),
(0.5, 0.5, 0.0), (-0.5, -0.5, 0.0), (0.5, -0.5, 0.0)
]
colors = [
(0, 1, 0), (1, 0, 0), (1, 1, 0),
(0, 1, 0), (1, 1, 0), (0, 0, 1)
]
vertex_data = nump.hstack([vertices, colors], dtype='float32')

***this in base_mesh***

import numpy as nump


class BaseMesh:
def __init__(self):
#OpEnGl_CoNtExT
self.ctx = None
#ShAdEr_aS_pRoGrAm
self.programm = None
#vErTeX_BUTTER_datas_tupe_frmt: "3f 3f" to the bone
self.vbo_frmt = None
#attributt namse acsording to the format(bone): ("in_position", "in color")
self.attrs: tuple[str, ...] = None
#vertex arrow/array object
self.vao = None

def get_vertex_data(self) -> nump.array: ...

def get_vao(self):
vertex_data = self.get_vertex_data()
vbo = self.ctx.buffer(vertex_data)
vao = self.ctx.vertex_array(
self.program, [(vbo, self.vbo_format, *self.attrs)], skip_errors=True
)
return vao

def render(self):
self.vao.render()

***this in scene***

from settings import *
from meshes.quad_mesh import QuadMesh


class Scene:
def __init__(self, app):
self.app = app
self.quad = QuadMesh(self.app)

def update(self):
pass

def render(self):
self.quad.render()

***this code in settings:***

from numba import njit
import numpy as nump
import glm
import math

# resolution / revolution
WIN_RES = glm.vec2(1600, 900)

# som colrs
BG_COLR = glm.vec3(0.1, 0.16, 0.25)

***this code in quad.vert***

#version 330 core

layout (location = 0) out vec4 fragColor;

in vec3 color;


void main() {
fragColor = vec4(color, 1.0);
}

***and this in quad.frag:

***#version 330 core

layout (location = 0) out vec4 fragColor;

in vec3 color;


void main() {
fragColor = vec4(color, 1.0);
}



***and python gives me this problem:***
[Running] python -u "c:VoxelEngine\main.py"
pygame 2.6.1 (SDL 2.28.4, Python 3.13.2)
Hello from the pygame community. https://www.pygame.org/contribute.html
Traceback (most recent call last):
File "c:\VoxelEngine\main.py", line 62, in <module>
app = VoxelEngine()
File "c:\VoxelEngine\main.py", line 28, in __init__
self.on_init()
~~~~~~~~~~~~^^
File "c:\VoxelEngine\main.py", line 31, in on_init
self.shader_program = ShaderProgram(self)
~~~~~~~~~~~~~^^^^^^
File "c:\VoxelEngine\shader_program.py", line 9, in __init__
self.quad = self.get_program(shader_name='quad')
~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^
File "c:\VoxelEngine\shader_program.py", line 26, in get_program
program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)
File "C:\Programs\Python\Python313\Lib\site-packages\moderngl\__init__.py", line 1978, in program
res.mglo, _members, res._subroutines, res._geom, res._glo = self.mglo.program(
~~~~~~~~~~~~~~~~~^
vertex_shader,
^^^^^^^^^^^^^^
...<7 lines>...
varyings_capture_mode == "interleaved",
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
)
^
_moderngl.Error: GLSL Linker failed

Program
=======
The shader uses varying color, but previous shader does not write to it.
Out of resource error.



[Done] exited with code=1 in 3.82 seconds

***also i am using Pygame, ModernGL, Numpy, PyGLM, Numba, OpenSimplex as libraries, please someone help.***


also, it looks like this:[1]: https://i.sstatic.net/EDJJ5pJZ.png

i dont know how to make this rule work It looks like your post is mostly code; please add some more details. so i will just add more words.f f f f f f ff f ff ff f f f f

Continue reading...