I'm trying to run moderngl in Colab. I installed it and ran a virtual display:

!sudo apt-get update --fix-missing && apt-get -qqq install x11-utils > /dev/null
!sudo apt-get update --fix-missing && apt-get -qqq install xvfb > /dev/null
!python3 -m pip install -U -qqq moderngl
!python3 -m pip install -U -qqq moderngl-window
!python3 -m pip install -U -qqq pyvirtualdisplay

from pyvirtualdisplay import Display
display = Display(visible=0, size=(960, 540)).start()

import moderngl
ctx = moderngl.create_standalone_context()
buf = ctx.buffer(b'Hello World!')  # allocated on the GPU
buf.read()

b'Hello World!'

It printed as expected, but when I run an example I see the error:

!python3 /content/moderngl/examples/basic_alpha_blending.py --window pyglet

2020-03-28 10:25:48,312 - moderngl_window - INFO - Attempting to load window class: moderngl_window.context.pyglet.Window
Traceback (most recent call last):
  File "/content/moderngl/examples/basic_alpha_blending.py", line 74, in <module>
    AlphaBlending.run()
  File "/content/moderngl/examples/ported/_example.py", line 21, in run
    mglw.run_window_config(cls)
  File "/usr/local/lib/python3.6/dist-packages/moderngl_window/__init__.py", line 185, in run_window_config
    cursor=show_cursor if show_cursor is not None else True,
  File "/usr/local/lib/python3.6/dist-packages/moderngl_window/context/pyglet/window.py", line 54, in __init__
    config=config,
  File "/usr/local/lib/python3.6/dist-packages/pyglet/window/xlib/__init__.py", line 165, in __init__
    super(XlibWindow, self).__init__(*args, **kwargs)
  File "/usr/local/lib/python3.6/dist-packages/pyglet/window/__init__.py", line 588, in __init__
    config = screen.get_best_config(config)
  File "/usr/local/lib/python3.6/dist-packages/pyglet/canvas/base.py", line 194, in get_best_config
    raise window.NoSuchConfigException()
pyglet.window.NoSuchConfigException

I also tried with another virtual display, but the result is the same:

!python3 -m pip install -U -qqq  xvfbwrapper
from xvfbwrapper import Xvfb
display = Xvfb(width=960, height=540).start()

pyglet.window.NoSuchConfigException

A simple use-case of the new feature

In a compute shader it is often necessary to be able to write to a texture via an image2D uniform. A compute shader example for modifying an image2D texture is

#version 430
layout (local_size_x = 16, local_size_y = 16) in;
layout(rg32f,location=0) writeonly uniform image2D destTex;
uniform float time;
void main() {
    ivec2 ij = ivec2(gl_GlobalInvocationID.xy);
    float localCoef = length(vec2(ivec2(gl_LocalInvocationID.xy)-8)/8.0);
    float globalCoef = sin(float(gl_WorkGroupID.x+gl_WorkGroupID.y)*0.1 + time)*0.5;
    imageStore(destTex, ij, vec4(1.0-globalCoef*localCoef, 0.0, 0.0, 0.0));
}

Note that this requires on initialization an explicit call to bind the image texture in addition to the setting of it's uniform to 0

glGenTextures(1, &texHandle); glBindImageTexture(0, texHandle, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32F); glUniform1i(glGetUniformLocation(progHandle, "destTex"), 0);

when trying the equivalent of glUniform1i

self.destTex= self.computeprog['destTex'] self.destTex.value = 0

the getter is works fine but an error is thrown on the setter

  File "foo.py", line 204, in foo_execute()
    self.destTex.value = 0
  File "C:/msys64/mingw64/lib/python3.6/site-packages\moderngl\program_members\uniform.py", line 163, in value
    self.mglo.value = value
mgl.Error: cannot detect uniform type

This seems to be a bug where a uniform image2D type is not correctly handled when trying to set the uniform integer.

Describe the solution you'd like

Assuming the uniform image2D is corrected, there seems to be a larger missing API piece. Presently, the moderngl interface seems to be missing a way to do the equivalent of

glBindImageTexture(0, texHandle, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32F);

How does one bind the image texture to be writeonly with a format of GL_R32F? Note, this is required in addition to the standard texture glBindTexture(GL_TEXTURE_2D, texHandle). For example, when one inits the texture a complete working c-code is

GLuint genTexture() {
    GLuint texHandle;
    glGenTextures(1, &texHandle);

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texHandle);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 512, 512, 0, GL_RED, GL_FLOAT, NULL);

    // Because we're also using this tex as an image (in order to write to it),
    // we bind it to an image unit as well
    glBindImageTexture(0, texHandle, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32F);
    return texHandle;
}

The goal is to have an animated texture with compute shader like

Here's a an python-moderngl coding attempt at that goal but doesn't work, possibly due to missing API feature as described above. Note this is a slight change example 04. mixed_vertexshader_computeshader.py,txt

Version info

moderngl 5.3.0

vendor: NVIDIA Corporation renderer: Quadro M1200/PCIe/SSE2 version: 4.6.0 NVIDIA 388.16 python: 3.6.4 (default, Jan 23 2018, 13:17:37) [GCC 7.2.0 64 bit (AMD64)] platform: win32 code: 460

Description

In the blending example given in documentation:

For both rgb and alpha

ctx.blend_func = moderngl.SRC_ALPHA, moderngl.ONE_MINUS_SRC_ALPHA

Separate for rgb and alpha

ctx.blend_func = ( moderngl.SRC_ALPHA, moderngl.ONE_MINUS_SRC_ALPHA, moderngl.ONE, moderngl.ONE )

For both rgb and alpha mode works, while separate for rgb and alpha mode gives: SystemError: error return without exception set

Hi, Can the development team please add support for Python GUI toolkits like Tkinter Wxwidgets

These two toolkits work well on Linux osx, Mac osx, Windows. So if ModernGL supports tk and wxpython, I can develop a scientific app like molecular viewer using Python 3.4 and ModernGL for OpenGL 4.5 rendering.

Thank you for your efforts in this project

I was wondering if it is possible to share textures between contexts

As afar I know there is no way to create a texture from an existing texture right?

Describe the solution you'd like

Is it possible to do something like this?

# setup the first window ...
ctx1 = moderngl.create_context()
texture1 = ctx1.texture((H, W), 4)

# setup the second window ...
ctx2 = moderngl.create_context()
texture2 = ctx2.texture(texture1)
frame = ctx2.framebuffer((texture2,))

Where ctx2.texture function will check if texture1 can be shared and create a texture that is shared between ctx1 and ctx2.

Version info

moderngl 5.5.4
--------------
vendor: NVIDIA Corporation
renderer: GeForce GTX 1080 Ti/PCIe/SSE2
version: 4.6.0 NVIDIA 430.64
python: 3.6.9 (default, Nov  7 2019, 10:44:02)
[GCC 8.3.0]
platform: linux
code: 460

Hello,

I was trying to use this library on a remote server without a display. Thus, I got the error:

Cannot create context

Are there any solutions how to do headless / offline-rendering using ModernGL ?

Description

egl backend fails to initialize in docker container:

import moderngl
moderngl.create_standalone_context(backend="egl")

Traceback (most recent call last):
  File "egl_test.py", line 2, in <module>
    moderngl.create_standalone_context(backend="egl")
  File "/root/miniconda3/envs/env/lib/python3.7/site-packages/moderngl/context.py", line 1466, in create_standalone_context
    ctx.mglo, ctx.version_code = mgl.create_context(glversion=require, mode=mode, **settings)
  File "/root/miniconda3/envs/env/lib/python3.7/site-packages/glcontext/__init__.py", line 99, in create
    return egl.create_context(**kwargs)
Exception: eglInitialize failed (0x3001)

I might just be doing something wrong, but I'm not sure what it is. It works for my example program.

Proof of code

https://github.com/christopher-hesse/moderngl-issue

docker build . --tag egl_test
docker run -it --rm egl_test bash -c "gcc egl_test.c -lEGL -lOpenGL && ./a.out && tail out.ppm"
docker run -it --rm egl_test python egl_test.py

The first docker run runs a simple egl program which seems to be working because it outputs a PPM file. The second crashes with the above error.

Expected behavior

I expected it to work instead of crashing. Could this be some sort of gl version issue?

Version info

docker run -it --rm egl_test pip show moderngl glcontext
Name: moderngl
Version: 5.6.0
Summary: ModernGL: High performance rendering for Python 3
Home-page: https://github.com/moderngl/moderngl
Author: Szabolcs Dombi
Author-email: [email protected]
License: MIT
Location: /root/miniconda3/envs/env/lib/python3.7/site-packages
Requires: glcontext
Required-by:
---
Name: glcontext
Version: 2.1.0
Summary: Portable OpenGL Context
Home-page: https://github.com/moderngl/glcontext
Author: Szabolcs Dombi
Author-email: [email protected]
License: MIT
Location: /root/miniconda3/envs/env/lib/python3.7/site-packages
Requires:
Required-by: moderngl

Description

With reference to the following URLs, I wrote some headless-rendering codes. The codes worked on Windows 10, but didn't on Ubuntu 16.04. It seems that ctx.clear() works but vao.render() doesn't.

• https://github.com/cprogrammer1994/ubuntu-headless-ModernGL/blob/master/README.md
• https://github.com/cprogrammer1994/Headless-rendering-with-python

Proof of code

Here's a short version of my headless-rendering code:

http://kanamori.cs.tsukuba.ac.jp/tmp/moderngl/sample.py

$ export DISPLAY=:99.0
$ Xvfb :99 -screen 0 640x480x24 &
$ python sample.py

yields the following white image:

http://kanamori.cs.tsukuba.ac.jp/tmp/moderngl/output_ubuntu.png

Expected behavior

On Windows 10, I got the following image as expected.

http://kanamori.cs.tsukuba.ac.jp/tmp/moderngl/output_windows.png

Version info

$ python -m moderngl
moderngl 5.5.4
--------------
vendor: VMware, Inc.
renderer: llvmpipe (LLVM 6.0, 256 bits)
version: 3.3 (Core Profile) Mesa 18.0.5
python: 3.6.6 (default, Jul 23 2018, 14:41:45)
[GCC 5.4.0 20160609]
platform: linux
code: 330

Here's also a log of glxinfo:

http://kanamori.cs.tsukuba.ac.jp/tmp/moderngl/glxinfo_dump.txt

Description

Similarly to issue #17 of glcontext, moderngl lacks the manylinux wheels on pypi https://pypi.org/project/moderngl/#files

Proof of code

Please refer to the files listsing of pypi: https://pypi.org/project/moderngl/#files

Expected behavior

pip install moderngl shall not need to compile the module on Linux using python-3.9

Thanks in advance for looking into this.

I have been using moderngl for a while and have come to appreciate how simple it is to get things done. However, it seems that all rendering is done through the vertex_array Render call, and there is an expectation that the vertex buffer be non-zero in length. This is very different from OpenGL in C where you don't even need a vertex buffer to be bound prior to a draw call. You can call glDrawArrays(GL_POINTS, 0, numVerts), with an empty vertex shader, and the geometry shader will get invoked numVerts times, with a unique value of gl_PrimitiveIDIn. This is useful for creating geometry on the fly. I have not been able to replicate this functionality using moderngl. Is this a design flaw, or a gap in the example code?

Thanks.

Pypy is an alternative Python implementation with JIT.

Curretnly moderngl doesn't compile due to non-existence of following in pypy C API:

• 5.5.0:
  • PyException_HEAD macro
  • PyUnicode_Append
• next:
  • ob_base inside PyObject

A simple use-case of the new feature

Using SPIR-V, you may be able to use other languages then glsl, eg. HLSL. It should only be enabled if you have OpenGL 4.6 or higher. SPIR-V is also cross-api, meaning you can write a shader once and use it for all sorts of APIs (eg one can have moderngl support with other apis).

Describe the solution you'd like

Add SPIR-V shader support with preferably a similar way to load them. (eg. instead of ctx.program you could have ctx.spirv_program).

Version info

moderngl 5.7.3
--------------
vendor: Intel
renderer: Intel(R) UHD Graphics 600
version: 3.3.0 - Build 27.20.100.8681
python: 3.8.10 (tags/v3.8.10:3d8993a, May  3 2021, 11:48:03) [MSC v.1928 64 bit (AMD64)]
platform: win32
code: 330

Currently only Texture supports setting the internal format. I would like to be able to create cubemap (and possibly other kinds of) textures that are compressed.

Hello, I created a moderngl context in Python and called context.release(), but the memory never gets released. Here it is the code:

import gc
import moderngl.mgl as mgl
from moderngl.context import Context

ctx = Context.__new__(Context)
ctx.mglo, ctx.version_code = mgl.create_context(glversion=330, mode="standalone")
ctx.release()
del(ctx)
gc.collect()

There is approximately 50MB of memory that is not being released even after context.release(), del(context) or gc.collect(), so how can I retrieve this memory back? I would really appreciate any help on this!

Upgrading from moderngl 5.5.3 to 5.6.4

Traceback (most recent call last):
  File "/home/istvan/Work/Mollia/mollia_window_linux/test_main_window_mouse.py", line 7, in <module>
    ctx = mgl.create_context()
  File "/home/istvan/.local/lib/python3.10/site-packages/moderngl/context.py", line 1619, in create_context
    ctx.mglo, ctx.version_code = mgl.create_context(glversion=require, mode=mode, **settings)
  File "/home/istvan/.local/lib/python3.10/site-packages/glcontext/__init__.py", line 93, in create
    return x11.create_context(**kwargs)
Exception: (detect) glXGetCurrentContext: cannot detect OpenGL context

Linux fedora 5.17.12-300.fc36.x86_64 #1 SMP PREEMPT Mon May 30 16:56:53 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

The mesa drivers for the gpu on the Cortex-A72 is now supporting ES 3.1 with extensions for most of the 3.2 features. With recent mesa version you have geo shaders and compute shaders working.

Some differences in GLES:

• Primitive restart index can only be the max value of the index buffer size
• Does not support pixel data format conversion during write (format different from internalformat)
• Compute shader only allows textures with immutable storage. Textures will need an option for this.

Shaders on the raspi will need to look like the following.

// shader version
#version 310 es
// Enable geo shaders (3.2 feature)
#extension GL_EXT_geometry_shader : require
// We need precision qualifiers for floats
precision mediump float;
// We need precision qualifiers for images
precision mediump image2D;