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()
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)
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
