def main(argv=None): ''' main ''' version = 'moderngl %s' % moderngl.__version__ if os.path.isfile(os.path.join(os.path.dirname(__file__), 'README.md')): try: head = subprocess.check_output(['git', 'rev-parse', 'HEAD'], stderr=subprocess.DEVNULL) version += ' (%s)' % head.decode()[:8] except Exception: version += ' (archive)' parser = argparse.ArgumentParser(prog='moderngl') parser.add_argument('-v', '--version', action='version', version=version) parser.add_argument('--info', action='store_true', default=False) args = parser.parse_args(argv) ctx = moderngl.create_standalone_context() if args.info: print(json.dumps(ctx.info, sort_keys=True, indent=4)) else: print(version) print('-' * len(version)) print('vendor:', ctx.info['GL_VENDOR']) print('renderer:', ctx.info['GL_RENDERER']) print('version:', ctx.info['GL_VERSION']) print('python:', sys.version) print('platform:', sys.platform) print('code:', ctx.version_code)
def create(cls, width, height): ctx = moderngl.create_standalone_context() color_rbo = ctx.renderbuffer((width, height), samples=ctx.max_samples) fbo = ctx.framebuffer([color_rbo]) fbo.use() prog = ctx.program( vertex_shader=''' #version 330 in vec3 in_vert; in vec4 in_color; out vec4 v_color; uniform mat4 mvp; void main() { gl_Position = mvp * vec4(in_vert, 1.0); v_color = in_color; } ''', fragment_shader=''' #version 330 in vec4 v_color; out vec4 f_color; void main() { f_color = v_color; } ''' ) ctx.enable(moderngl.BLEND) return cls(width, height, ctx, prog, fbo)
def get_context() -> moderngl.Context: ctx = _static.get('context') if ctx is None: ctx = moderngl.create_standalone_context(size=(100, 100)) _static['context'] = ctx return ctx
def get_default_context(allow_fallback_standalone_context=True) -> moderngl.Context: ''' Default context ''' if ContextManager.ctx is None: try: ContextManager.ctx = moderngl.create_context() except moderngl.Error: if allow_fallback_standalone_context: ContextManager.ctx = moderngl.create_standalone_context() else: raise return ContextManager.ctx
def _imposter_gen_buffers(res, vs, fs, n_row=9, dist=10): context = mg.create_standalone_context() vs = _read(vs) fs = _read(fs) program = context.program(vertex_shader=vs, fragment_shader=fs) vao = _screen_quad(program, context) u_campos = program['u_campos'] if "u_drawbg" in program: program["u_drawbg"].value = False atlas_albedo = Image.new("RGBA", (res, res)) atlas_normal = Image.new("RGBA", (res, res)) winw, winh = int(res / n_row), int(res / n_row) albedo_tex = context.texture((winw, winh), 4, dtype="f4") normal_tex = context.texture((winw, winh), 4, dtype="f4") frame = context.framebuffer([albedo_tex, normal_tex]) frame.use() for pos, uv in _rotate_around(n_row, dist): u_campos.value = pos vao.render() u = uv[0] * winw v = uv[1] * winh data = np.frombuffer(albedo_tex.read(), dtype="f4") data = data.reshape((winw, winh, 4)) data = _flatten_array(data) img_albedo = Image.fromarray(data) data = np.frombuffer(normal_tex.read(), dtype="f4") data = data.reshape((winw, winh, 4)) data = _flatten_array(data) img_normal = Image.fromarray(data) atlas_albedo.paste(img_albedo, (u, v)) atlas_normal.paste(img_normal, (u, v)) return atlas_albedo, atlas_normal
def __init__(self, ctx=None): if ctx is None: self.ctx = moderngl.create_standalone_context() else: self.ctx = ctx self.prog = self.ctx.program( vertex_shader=''' #version 330 uniform mat4 Mvp; in vec3 in_vert; in vec3 in_norm; out vec3 v_vert; out vec3 v_norm; void main() { v_vert = in_vert; v_norm = in_norm; gl_Position = Mvp*vec4(v_vert, 1.0); } ''', fragment_shader=''' #version 330 uniform vec3 Light; in vec3 v_vert; in vec3 v_norm; out vec4 f_color; void main() { vec3 light = Light - v_vert; float d_light = length(light); float lum = abs(dot(normalize(light), normalize(v_norm))); lum = clamp(45.0/(d_light*(d_light+0.02)) * lum, 0.0,1.0)* 0.6 +0.3; f_color = vec4(lum * vec3(1.0, 1.0, 1.0), 0.0); } ''', ) self.vbo_vertices = None self.vbo_normals = None self.vao = None self.fbo = None # uniform variables self.light = self.prog['Light'] self.mvp = self.prog['Mvp']
def init_context(self, ctx=None): if ctx is None: ctx = moderngl.create_standalone_context() fbo = self.get_fbo(ctx, 0) else: fbo = ctx.detect_framebuffer() # For multisample antialiasing fbo_msaa = self.get_fbo(ctx, self.samples) fbo_msaa.use() ctx.enable(moderngl.BLEND) ctx.blend_func = ( moderngl.SRC_ALPHA, moderngl.ONE_MINUS_SRC_ALPHA, moderngl.ONE, moderngl.ONE ) self.ctx = ctx self.fbo = fbo self.fbo_msaa = fbo_msaa
def __init__(self, consts, compute_npart=None): self.npart = consts["NPART"] self.compute_npart = compute_npart or consts["NPART"] max_layout_size = 256 # Probablement optimal (en tout cas d'après essais et guides de bonnes pratiques) self.groups_number = int(np.ceil(self.compute_npart / max_layout_size)) self.layout_size = int(np.ceil(self.compute_npart / self.groups_number)) consts["LAYOUT_SIZE"] = self.layout_size self.compute_npart = min(self.compute_npart, self.npart) self.compute_offset = 0 self.context = moderngl.create_standalone_context(require=430) self.compute_shader = self.context.compute_shader(gl_util.source(os.path.dirname(__file__)+'/templates/moldyn.glsl', consts)) self.consts = consts # Buffer de positions 1 self._BUFFER_P = self.context.buffer(reserve=2 * 4 * self.npart) self._BUFFER_P.bind_to_storage_buffer(0) # Buffer de forces self._BUFFER_F = self.context.buffer(reserve=2 * 4 * self.npart) self._BUFFER_F.bind_to_storage_buffer(1) # Buffer d'énergies potentielles self._BUFFER_E = self.context.buffer(reserve=4 * self.npart) self._BUFFER_E.bind_to_storage_buffer(2) # Buffer de compteurs de liaisons self._BUFFER_COUNT = self.context.buffer(reserve=4 * self.npart) self._BUFFER_COUNT.bind_to_storage_buffer(3) # Buffer de paramètres, inutilisé pour l'instant self._BUFFER_PARAMS = self.context.buffer(reserve=4 * 5) self._BUFFER_PARAMS.bind_to_storage_buffer(4) self.array_shape = (self.npart, 2)
def main(): start_time = time.time() gl = mg.create_standalone_context() out_height = gl.buffer(reserve=width * height * 1 * 4) out_height.bind_to_storage_buffer(0) out_normal_sobel = gl.buffer(reserve=width * height * 4 * 4) out_normal_sobel.bind_to_storage_buffer(1) out_normal_offset = gl.buffer(reserve=width * height * 4 * 4) out_normal_offset.bind_to_storage_buffer(2) cs_height = gl.compute_shader(read("./gl/height_texture_generation.comp")) cs_normal = gl.compute_shader(read("./gl/normal_texture_generation.comp")) uniform_data = {"u_width": width, "u_height": height} list(map(lambda p: uniform(p, uniform_data), [cs_height, cs_normal])) print(f"setting up compute shader took: {time.time() - start_time}s") start_time = time.time() gx, gy = int(width / 8), int(height / 8) cs_height.run(gx, gy) cs_normal.run(gx, gy) print(f"running compute shader took: {time.time() - start_time}s") start_time = time.time() serialize("out_height.jpg", out_height, 1) print(f"encoding height map took: {time.time() - start_time}s") start_time = time.time() serialize("out_normal_sobel.jpg", out_normal_sobel, 4) serialize("out_normal_offset.jpg", out_normal_offset, 4) print(f"encoding normal maps took: {time.time() - start_time}s")
def main(): gl = mg.create_standalone_context() compute = gl.compute_shader(read("./gl/compute.glsl")) set_uniform(compute, "u_width", u_width) set_uniform(compute, "u_height", u_height) buffer_0 = gl.buffer(reserve=u_width * u_height * 4 * 4) buffer_0.bind_to_storage_buffer(0) gx, gy = int(u_width / 8), int(u_height / 8) recorder = Recorder() recorder.start() for i in range(20): set_uniform(compute, "u_time", i) compute.run(gx, gy) recorder.put(buffer_0.read()) ii.imwrite("output_2.png", serialize(buffer_0.read())) recorder.done_event.set()
def __init__(self): super().__init__() self.headless_frames = getattr(settings, 'HEADLESS_FRAMES', 0) self.headless_duration = getattr(settings, 'HEADLESS_DURATION', 0) if not self.headless_frames and not self.headless_duration: raise ImproperlyConfigured( "HEADLESS_DURATION or HEADLESS_FRAMES not present in settings") self._close = False self.ctx = moderngl.create_standalone_context( require=self.gl_version.code) context.WINDOW = self self.fbo = self.ctx.framebuffer( color_attachments=self.ctx.texture(self.size, 4), depth_attachment=self.ctx.depth_texture(self.size), ) self.set_default_viewport() self.fbo.use()
def __init__(self): super().__init__() self.headless_frames = getattr(settings, 'HEADLESS_FRAMES', 0) self.headless_duration = getattr(settings, 'HEADLESS_DURATION', 0) if not self.headless_frames and not self.headless_duration: raise ImproperlyConfigured( "HEADLESS_DURATION or HEADLESS_FRAMES not present in settings") self._close = False self.ctx = moderngl.create_standalone_context() self.fbo = FBO() self.fbo.ctx = self.ctx self.fbo.fbo = self.ctx.framebuffer( color_attachments=self.ctx.texture((self.width, self.height), 4), depth_attachment=self.ctx.depth_texture((self.width, self.height)), ) # self.fbo.default_framebuffer = True context.WINDOW = self self.set_default_viewport()
def main(): buffer_width, buffer_height = 64, 64 render_width, render_height = 1024, 1024 gl = mg.create_standalone_context(require=460) cs_game_of_life_init = gl.compute_shader( open("./cs_game_of_life_init.glsl").read()) cs_game_of_life_update = gl.compute_shader( open("./cs_game_of_life_update.glsl").read()) cs_render = gl.compute_shader(open("./cs_render.glsl").read()) b0 = gl.buffer(reserve=buffer_width * buffer_height * 4) b1 = gl.buffer(reserve=buffer_width * buffer_height * 4) b2 = gl.buffer(reserve=render_width * render_height * 4 * 4) b2.bind_to_storage_buffer(2) writer = ii.get_writer("./record.mp4", fps=12) def read_render(b): return np.multiply( np.frombuffer(b.read(), dtype=np.float32).reshape( (render_height, render_width, 4)), 255.0).astype(np.uint8) gx, gy = buffer_width // 8, buffer_height // 8 b0.bind_to_storage_buffer(0) cs_game_of_life_init.run(gx, gy) for i in range(60): b0.bind_to_storage_buffer(i % 2) b1.bind_to_storage_buffer((i + 1) % 2) cs_game_of_life_update.run(gx, gy) cs_render.run(render_width // 8, render_height // 8) writer.append_data(read_render(b2)) writer.close()
def __init__(self, consts): """ Parameters ---------- consts : dict Dictionary containing constants used for calculations. """ self.npart = consts["npart"] max_layout_size = 256 # Probablement optimal (en tout cas d'après essais et guides de bonnes pratiques) self.groups_number = int(np.ceil(self.npart / max_layout_size)) self.layout_size = int(np.ceil(self.npart / self.groups_number)) consts["LAYOUT_SIZE"] = self.layout_size self.context = moderngl.create_standalone_context(require=430) #print(gl_util.source(os.path.dirname(__file__) + '/strain.glsl', consts)) self.compute_shader = self.context.compute_shader( gl_util.source(os.path.dirname(__file__) + '/strain.glsl', consts)) self.consts = consts # Buffer de positions au temps t self._BUFFER_P_T = self.context.buffer(reserve=2 * 4 * self.npart) self._BUFFER_P_T.bind_to_storage_buffer(0) # Buffer de positions au temps t - dt self._BUFFER_P_DT = self.context.buffer(reserve=2 * 4 * self.npart) self._BUFFER_P_DT.bind_to_storage_buffer(1) # Buffer d'epsilon self._BUFFER_E = self.context.buffer(reserve=4 * 4 * self.npart) self._BUFFER_E.bind_to_storage_buffer(2) self.array_shape = (self.npart, 2, 2)
def __init__(self, width=1024, height=768, model_matrix=None, view_matrix=None, projection_matrix=None): # Make a single OpenGL context that will be managed by the lifetime of # this class. We will dynamically create two default "pass through" # programs based on the type of the input mesh self.opengl_ctx = moderngl.create_standalone_context() self.width = width self.height = height self._model_matrix = model_matrix if model_matrix is not None else np.eye( 4) self._view_matrix = view_matrix if view_matrix is not None else np.eye( 4) self._projection_matrix = projection_matrix if projection_matrix is not None else np.eye( 4) self._vertex_shader = None self._fragment_shader = None self._shader_type = None # We will dynamically build the program based on the mesh type self._active_program = None self._texture_program = None self._per_vertex_program = None self._f3v_renderbuffer = self.opengl_ctx.renderbuffer(self.size, components=3, dtype='f4') self._rgba_renderbuffer = self.opengl_ctx.renderbuffer(self.size, components=4, dtype='f4') self._depth_renderbuffer = self.opengl_ctx.depth_renderbuffer( self.size) self._fbo = self.opengl_ctx.framebuffer( [self._f3v_renderbuffer, self._rgba_renderbuffer], self._depth_renderbuffer)
def init(): global ctx, prog if ctx is None: # Context creation ctx = moderngl.create_standalone_context() ctx.enable(moderngl.DEPTH_TEST) prog = ctx.program( vertex_shader=''' #version 330 uniform mat4 proj; uniform mat4 modelview; in vec3 in_vert; in vec3 in_color; out vec3 v_color; void main() { v_color = in_color; gl_Position = proj * modelview * vec4(in_vert, 1.0); } ''', fragment_shader=''' #version 330 in vec3 v_color; out vec3 f_color; void main() { f_color = v_color; } ''', )
def __init__(self, image_size=128, num_vertices=778): """ Class for rendering a hand from parameters or manifold :param image_size: size of a single hand image """ self.image_size = image_size self.num_vertices = num_vertices # graphics self.ctx = moderngl.create_standalone_context() self.ctx.enable(moderngl.DEPTH_TEST) self.ctx.enable(moderngl.CULL_FACE) self.prog = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader, geometry_shader=geometry_shader) self.vboPos = self.ctx.buffer(reserve=num_vertices * 3 * 4, dynamic=True) self.ibo = self.ctx.buffer(get_mano_faces().astype('i4').tobytes()) vao_content = [ # 3 floats are assigned to the 'in' variable named 'in_vert' in the shader code (self.vboPos, '3f', 'in_vert') ] self.vao = self.ctx.vertex_array(self.prog, vao_content, self.ibo) # Framebuffers self.fbo1 = self.ctx.framebuffer( [self.ctx.renderbuffer((image_size, image_size), samples=8)]) self.fbo2 = self.ctx.framebuffer( [self.ctx.renderbuffer((image_size, image_size))])
def init_scene(self, scene): self.partial_movie_files = [] self.file_writer = SceneFileWriter( self, scene.__class__.__name__, ) self.scene = scene if config["preview"]: self.window = Window(self) self.context = self.window.ctx self.frame_buffer_object = self.context.detect_framebuffer() else: self.window = None self.context = moderngl.create_standalone_context() self.frame_buffer_object = self.get_frame_buffer_object( self.context, 0) self.frame_buffer_object.use() self.context.enable(moderngl.BLEND) self.context.blend_func = ( moderngl.SRC_ALPHA, moderngl.ONE_MINUS_SRC_ALPHA, moderngl.ONE, moderngl.ONE, )
def make_3dimage_frame(draw, width, height, background=Color(0), channels=3): ''' Create a numpy frame file using moderngl :param draw: the draw function :param width: width in pixels, int :param height: height in pixels, int :param background: background colour :param channels: 3 for rgb, 4 for rgba :return: ''' ctx = moderngl.create_standalone_context() fbo = ctx.simple_framebuffer((width, height)) fbo.use() fbo.clear(*background) draw(ctx, width, height, 0, 1) data = fbo.read() frame = np.frombuffer(data, dtype=np.uint8) frame = frame.reshape((height, width, 3)) frame = frame[::-1] ctx.release() return frame
author: minu jeong """ import moderngl as mg import numpy as np import imageio as ii u_width, u_height = 512, 512 def set_uniform(p, n, v): if p and n in p: p[n].value = v gl = mg.create_standalone_context() cs = gl.compute_shader(""" #version 460 layout(local_size_x=8, local_size_y=8) in; layout(binding=0) buffer bind_0 { vec4 data_0[]; }; uniform uint u_width; void main() {
def standalone_context(): # HACK for CI if os.environ.get("CI"): return None return mgl.create_standalone_context()
Z = 1 consts = { "W": W, "H": H, "X": X + 1, "Y": Y, "Z": Z, } FRAMES = 50 OUTPUT_DIRPATH = "./output" if not os.path.isdir(OUTPUT_DIRPATH): os.makedirs(OUTPUT_DIRPATH) context = moderngl.create_standalone_context(require=430) compute_shader = context.compute_shader(source('./gl/median_5x5.gl', consts)) # init buffers buffer_a_data = np.random.uniform(0.0, 1.0, (H, W, 4)).astype('f4') buffer_a = context.buffer(buffer_a_data) buffer_b_data = np.zeros((H, W, 4)).astype('f4') buffer_b = context.buffer(buffer_b_data) imgs = [] last_buffer = buffer_b for i in range(FRAMES): toggle = True if i % 2 else False buffer_a.bind_to_storage_buffer(1 if toggle else 0) buffer_b.bind_to_storage_buffer(0 if toggle else 1)
import moderngl as ModernGL from ModernGL.ext.obj import Obj from PIL import Image from pyrr import Matrix44 # Data files vertex_data = Obj.open('data/sitting.obj').pack() texture_image = Image.open('data/wood.jpg') vertex_shader_source = open('data/shader.vert').read() fragment_shader_source = open('data/shader.frag').read() # Context creation ctx = ModernGL.create_standalone_context() # Shaders prog = ctx.program(vertex_shader=vertex_shader_source, fragment_shader=fragment_shader_source) # Matrices and Uniforms perspective = Matrix44.perspective_projection(45.0, 1.0, 0.1, 1000.0) lookat = Matrix44.look_at( (-85, -180, 140), (0.0, 0.0, 65.0), (0.0, 0.0, 1.0), ) mvp = perspective * lookat
import moderngl as mg import numpy as np import imageio as ii WIDTH, HEIGHT = 512, 512 CHANNELS = 4 SIZE_BYTE = 4 gl = mg.create_standalone_context(require=460) cs = gl.compute_shader(""" #version 460 layout(local_size_x=8, local_size_y=8) in; layout(binding=0) buffer in_buffer { vec4 colour[]; }; uniform uint u_width; uniform uint u_height; void main() { uvec2 xy = gl_LocalInvocationID.xy + gl_WorkGroupID.xy * gl_WorkGroupSize.xy; uint i = xy.x + xy.y * u_width; vec2 uv = vec2(xy) / vec2(u_width, u_height); colour[i] = vec4(uv, 0.0, 1.0);
def __init__(self, view_width, view_height, antialias_samples=0, enable_extra_data=False): if RenderEngine._ctx is None: RenderEngine._ctx = moderngl.create_standalone_context() self._ctx = RenderEngine._ctx self._width = view_width self._height = view_height self._samples = antialias_samples self._enable_extra_data = enable_extra_data self._wireframe_prog = self._load_prog('wireframe.vert', 'wireframe.frag', 'wireframe2.geom') self._shadow_prog = self._load_prog('shadow.vert', 'shadow.frag') if self._enable_extra_data: self._extra_data_prog = self._load_prog('extra_data.vert', 'extra_data.frag') self._prog = self._load_prog('shader_v400.vert', 'shader_v400.frag') self._cbo = self._ctx.renderbuffer((view_width, view_height), samples=antialias_samples, dtype='f4') self._dbo = self._ctx.depth_texture((view_width, view_height), samples=antialias_samples, alignment=1) self._fbo = self._ctx.framebuffer([self._cbo], self._dbo) if self._samples > 0: self._cbo2 = self._ctx.renderbuffer((view_width, view_height), dtype='f4') self._dbo2 = self._ctx.depth_texture((view_width, view_height), alignment=1) self._fbo2 = self._ctx.framebuffer([self._cbo2], self._dbo2) # for shadows n = int(math.sqrt(self._samples or 1)) self._scbo = self._ctx.renderbuffer((view_width * n, view_height * n)) self._sdbo = self._ctx.depth_texture((view_width * n, view_height * n), alignment=1) self._sfbo = self._ctx.framebuffer([self._scbo], self._sdbo) self._vbos = [] self._objs = [] self._s_vbos = [] self._s_objs = [] self._e_vbos = [] self._e_objs = [] self._w_vbos = [] self._w_objs = [] self._raw_objs = [] self._textures = [] self._proj_mx = None self._view_mx = np.identity(4) self._model_mx = None self._frustum_near = None self._frustum_far = None self._persp_proj = False
# This file is a part of the Heat2D Project and # # distributed under the GPL 3 license # # # # HEAT2D Game Engine Project # # Copyright © Kadir Aksoy # # https://github.com/kadir014/heat2d # import pygame import moderngl HEAT2D_VERSION = "0.0.5" HEAT2D_VERSION_TUPLE = (0, 0, 5) HEAT2D_VERSION_STATE = "alpha" HEAT2D_LICENSE = "GNU General Public License v3.0" PYGAME_VERSION = pygame.version.ver PYGAME_VERSION_TUPLE = pygame.version.vernum SDL_VERSION = pygame.get_sdl_version() MODERNGL_VERSION = moderngl.__version__ ctx = moderngl.create_standalone_context(size=(1, 1), require=None) OPENGL_VERSION = ctx.version_code ctx.release() del pygame, moderngl, ctx
def with_standalone_ctx( output_size: Tuple[int, int]) -> "UVTrianglesRenderer": return UVTrianglesRenderer(MGL.create_standalone_context(require=330), output_size)
def __init__( self, obj_f, mtl_f, background_f=None, camera_distance=2.0, angle_of_view=16.426 ): # Initialize OpenGL context. self.ctx = moderngl.create_standalone_context() # Render depth appropriately. self.ctx.enable(moderngl.DEPTH_TEST) # Setting for rendering transparent objects. # See: https://learnopengl.com/Advanced-OpenGL/Blending # and: https://github.com/cprogrammer1994/ModernGL/blob/master/moderngl/context.py#L129. self.ctx.enable(moderngl.BLEND) # Define OpenGL program. prog = self.ctx.program( vertex_shader=""" #version 330 uniform float x; uniform float y; uniform float z; uniform mat3 R_obj; uniform mat3 R_light; uniform vec3 DirLight; uniform mat4 VP; uniform int mode; in vec3 in_vert; in vec3 in_norm; in vec2 in_text; out vec3 v_pos; out vec3 v_norm; out vec2 v_text; out vec3 v_light; void main() { if (mode == 0) { v_pos = R_obj * in_vert + vec3(x, y, z); gl_Position = VP * vec4(v_pos, 1.0); v_norm = R_obj * in_norm; v_text = in_text; v_light = R_light * DirLight; } else { gl_Position = vec4(in_vert, 1.0); v_text = in_text; } } """, fragment_shader=""" #version 330 uniform float amb_int; uniform float dif_int; uniform vec3 cam_pos; uniform sampler2D Texture; uniform int mode; uniform bool use_texture; uniform bool has_image; uniform vec3 box_rgb; uniform vec3 amb_rgb; uniform vec3 dif_rgb; uniform vec3 spc_rgb; uniform float spec_exp; uniform float trans; in vec3 v_pos; in vec3 v_norm; in vec2 v_text; in vec3 v_light; out vec4 f_color; void main() { if (mode == 0) { float dif = clamp(dot(v_light, v_norm), 0.0, 1.0) * dif_int; if (use_texture) { vec3 surface_rgb = dif_rgb; vec3 diffuse = dif * surface_rgb; if (has_image) { surface_rgb = texture(Texture, v_text).rgb; diffuse = dif * dif_rgb * surface_rgb; } vec3 ambient = amb_int * amb_rgb * surface_rgb; float spec = 0.0; if (dif > 0.0) { vec3 reflected = reflect(-v_light, v_norm); vec3 surface_to_camera = normalize(cam_pos - v_pos); spec = pow(clamp(dot(surface_to_camera, reflected), 0.0, 1.0), spec_exp); } vec3 specular = spec * spc_rgb * surface_rgb; vec3 linear = ambient + diffuse + specular; f_color = vec4(linear, trans); } else { f_color = vec4(vec3(1.0, 1.0, 1.0) * dif + amb_int, 1.0); } } else if (mode == 1) { f_color = vec4(texture(Texture, v_text).rgba); } else { f_color = vec4(box_rgb, 1.0); } } """, ) # Lighting uniform variables. prog["R_light"].write(np.eye(3).astype("f4").tobytes()) prog["DirLight"].value = (0, 1, 0) prog["dif_int"].value = 0.7 prog["amb_int"].value = 0.5 prog["amb_rgb"].value = (1.0, 1.0, 1.0) prog["dif_rgb"].value = (1.0, 1.0, 1.0) prog["spc_rgb"].value = (1.0, 1.0, 1.0) prog["spec_exp"].value = 0.0 self.use_spec = True # Mode uniform variables. prog["mode"].value = 0 prog["use_texture"].value = True prog["has_image"].value = False # Model transformation uniform variables. prog["R_obj"].write(np.eye(3).astype("f4").tobytes()) prog["x"].value = 0 prog["y"].value = 0 prog["z"].value = 0 # Set up background. self.prog = prog (window_width, window_height) = self.set_up_background(background_f) # Look at origin matrix. eye = np.array([0.0, 0.0, camera_distance]) prog["cam_pos"].value = tuple(eye) target = np.zeros(3) up = np.array([0.0, 1.0, 0.0]) self.look_at = Matrix44.look_at(eye, target, up) # Perspective projection matrix. ratio = window_width / window_height self.perspective = Matrix44.perspective_projection( angle_of_view, ratio, 0.1, 1000.0 ) # View-Projection uniform variable. self.prog["VP"].write((self.look_at @ self.perspective).astype("f4").tobytes()) # Set up object. self.mtl_infos = None self.cull_faces = False self.render_objs = [] self.vbos = None self.vaos = None self.textures = None self.set_up_obj(obj_f, mtl_f) # Initialize frame buffer. size = (window_width, window_height) self.window_size = size # Set up multisample anti-aliasing. self.ctx.multisample = True color_rbo = self.ctx.renderbuffer(size, samples=self.ctx.max_samples) depth_rbo = self.ctx.depth_renderbuffer(size, samples=self.ctx.max_samples) self.fbo = self.ctx.framebuffer(color_rbo, depth_rbo) color_rbo2 = self.ctx.renderbuffer(size) depth_rbo2 = self.ctx.depth_renderbuffer(size) self.fbo2 = self.ctx.framebuffer(color_rbo2, depth_rbo2) self.fbo.use()
def CreateContext(): return moderngl.create_standalone_context()
import moderngl ctx = moderngl.create_standalone_context()
def main(): W = 400 H = 400 X = W Y = 1 Z = 1 triangles = read_obj("smoothMonkey.obj") print("constructed triangles") camera = Camera(Vector(0, 0, 3), Vector(0, 0, -1)) consts = { "W": W, "H": H, "X": X + 1, "Y": Y, "Z": Z, "numTriangles": len(triangles), } context = moderngl.create_standalone_context(require=430) compute_shader = context.compute_shader(source('raytracing.gl', consts)) triangle_data = np.asarray([]).astype('f4') for x in triangles: triangle_data = np.concatenate((triangle_data, (x.get_data()))) triangle_buffer = context.buffer(triangle_data) triangle_buffer.bind_to_storage_buffer(0) pixel_buffer_data = np.zeros((H, W, 4)).astype('f4') pixel_buffer = context.buffer(pixel_buffer_data) pixel_buffer.bind_to_storage_buffer(1) camera_buffer_data = np.zeros(8).astype('f4') camera.get_data(camera_buffer_data) camera_buffer = context.buffer(camera_buffer_data) camera_buffer.bind_to_storage_buffer(2) pygame.init() screen = pygame.display.set_mode((1600, 1600)) pixel_data_bytes = pixel_buffer.read() compute_shader.run(group_x=W, group_y=H) output = np.frombuffer(pixel_buffer.mglo, dtype=np.float32) output = output.reshape((H, W, 4)) output = output[:,:,:3] for x in output: for y in x: for z in y: if z != 0: print(y) continue output = np.multiply(output, 255).astype(np.uint8) surf = pygame.surfarray.make_surface(output) pygame.transform.scale(surf, (1600, 1600), screen) pygame.display.flip() print("done") running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False sleep(0.1) pygame.quit()
def __init__(self, width, height, algo='/Anime4K_Upscale_CNN_L_x2.glsl'): d = os.path.dirname(os.path.realpath(__file__)) self.width = width self.height = height context = moderngl.create_standalone_context(require=430) self.buffer = context.buffer(reserve=8) self.buffer.bind_to_storage_buffer(20) tex = context.texture((self.width, self.height), 4) tex.bind_to_image(0) with open(d + "/Anime4K_Upscale_CNN_L_x2.glsl", 'r') as fp: content = fp.read() glsl = content.split( '//////////////////////////////////////////////////////////////////' ) self.shader_list = [] self.tex_list = [tex] self.shader_list.append( context.compute_shader(''' #version 430 layout (local_size_x = 16, local_size_y = 16) in; layout(rgba8, binding=0) readonly uniform image2D inTex; layout(rgba16f, binding=1) writeonly uniform image2D destTex; layout(binding = 20) buffer pos { ivec2 p; }; #define Kb 0.0722 #define Kr 0.2126 #define Kg 1.0 - Kr - Kb #define YUV(rgb) ( mat3(0.2126,-0.09991,0.615,0.7152,-0.33609,-0.55861,0.0722,0.436,-0.05639)*rgb ) #define InvYUV(yuv) ( mat3(1,1,1,0,-0.21482,2.12798,1.28033,-0.38059,0)*yuv ) void main() { ivec2 pt = ivec2(gl_GlobalInvocationID.xy); vec3 yuv = YUV(imageLoad(inTex,pt+p).rgb); imageStore(destTex,pt,vec4(yuv,1)); }''')) self.tex_list.append( context.texture((self.width, self.height), 4, dtype='f2')) self.tex_list[-1].bind_to_image(1) for x in range(len(glsl) - 1): self.shader_list.append(context.compute_shader(glsl[x])) self.tex_list.append( context.texture((self.width, self.height), 4, dtype='f2')) self.tex_list[-1].bind_to_image(2 + x) self.shader_list.append(context.compute_shader(glsl[-1])) self.tex_list.append( context.texture((self.width * 2, self.height * 2), 4, dtype='f2')) self.tex_list[-1].bind_to_image(len(glsl) + 1) self.shader_list.append( context.compute_shader(''' #version 430 layout (local_size_x = 16, local_size_y = 16) in; layout(rgba16f, binding=''' + str(len(glsl) + 1) + ''') uniform image2D inTex; layout(rgba8, binding=''' + str(len(glsl) + 2) + ''') uniform image2D destTex; #define Kb 0.0722 #define Kr 0.2126 #define Kg 1.0 - Kr - Kb #define YUV(rgb) ( mat3(0.2126,-0.09991,0.615,0.7152,-0.33609,-0.55861,0.0722,0.436,-0.05639)*rgb ) #define InvYUV(yuv) ( mat3(1,1,1,0,-0.21482,2.12798,1.28033,-0.38059,0)*yuv ) void main() { ivec2 pt = ivec2(gl_GlobalInvocationID.xy); vec3 rgb = InvYUV(imageLoad(inTex,pt).rgb); imageStore(destTex,pt,vec4(rgb,1)); }''')) self.tex_list.append( context.texture((self.width * 2, self.height * 2), 4)) self.tex_list[-1].bind_to_image(len(glsl) + 2)
#define SPEC_COLOR vec3(0.85, 0.75, 0.5) vec3 h = normalize(o + l); float ndh = clamp(dot(n, h), 0.0, 1.0); float ndv = clamp(dot(n, -o), 0.0, 1.0); float spec = pow((ndh + ndv) + 0.01, 64.0) * 0.25; color = c * lambert + SPEC_COLOR * spec; } // add simple fog color = mix(FOG_COLOR, color, clamp(pow(FOG_DIST / abs(d), FOG_DENSITY), 0.0, 1.0)); out_color = vec4(color, 1.0); } ''' ctx = mg.create_standalone_context(require=430) #vert = ctx.vertex_shader(vertex_shader) #frag = ctx.fragment_shader(fragment_shader) prog = ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader) # Matrices and Uniforms # perspective = Matrix44.perspective_projection(45.0, 1.0, 0.1, 1000.0) # lookat = Matrix44.look_at( # (-85, -180, 140), # (0.0, 0.0, 65.0), # (0.0, 0.0, 1.0), # ) # mvp = perspective * lookat
def _make_context(self, width, height): ctx = moderngl.create_standalone_context(require=410) screen = ctx._screen = ctx.simple_framebuffer((width, height), ) screen.use() return ctx