I got a problem with drawing circles with the GL_POINTS operation.
I’m was using Vispy’s gloo module, but because of Vispy not supporting geometry shaders i changed to raw PyOpenGL.
I copied the fragment shader from vispy’s examples and it worked under vispy but now it won’t work in pure PyOpenGL.
When just only setting the gl_FragColor with “gl_FragColor = v_bg_color;” inside the fragment shader i see the squares so the vertex shader and everything else works.
Am i missing some glEnable() stuff or what is going on? Do i need more blend functions or even any at all? And how do i know what i need for my shaders in the future?
Here is the vertex shader:
#version 330
layout(location = 0) in vec3 a_position;
layout(location = 1) in vec4 a_fg_color;
layout(location = 2) in vec4 a_bg_color;
layout(location = 3) in float a_size;
uniform mat4 model;
uniform mat4 projection;
uniform mat4 view;
uniform float u_linewidth;
uniform float u_antialias;
uniform float u_size;
varying vec4 v_fg_color;
varying vec4 v_bg_color;
varying float v_size;
varying float v_linewidth;
varying float v_antialias;
void main (void) {
v_size = a_size * u_size;
v_linewidth = u_linewidth;
v_antialias = u_antialias;
v_fg_color = a_fg_color;
v_bg_color = a_bg_color;
gl_Position = projection * view * model * vec4(a_position,1.0);
gl_PointSize = (v_size + 2) * (v_linewidth + 1.5 * v_antialias) / gl_Position.w;
}
Here is the fragment shader:
#version 330
varying vec4 v_fg_color;
varying vec4 v_bg_color;
varying float v_size;
varying float v_linewidth;
varying float v_antialias;
float disc(vec2 P, float size)
{
float r = length((P.xy - vec2(0.5,0.5))*size);
r -= v_size/2;
return r;
}
void main()
{
float size = v_size +2*(v_linewidth + 1.5*v_antialias);
float t = v_linewidth/2.0-v_antialias;
float r = disc(gl_PointCoord, size);
float d = abs(r) - t;
if( r > (v_linewidth/2.0+v_antialias))
{
discard;
}
else if( d < 0.0 )
{
gl_FragColor = v_fg_color;
}
else
{
float alpha = d/v_antialias;
alpha = exp(-alpha*alpha);
if (r > 0)
gl_FragColor = vec4(v_fg_color.rgb, alpha*v_fg_color.a);
else
gl_FragColor = mix(v_bg_color, v_fg_color, alpha);
}
}
Here is the paintGL function:
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glUseProgram(self.program)
glEnable(GL_PROGRAM_POINT_SIZE)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glUniformMatrix4fv(self.UNIFORM_LOCATIONS['model'], 1, GL_FALSE, self.model)
glUniformMatrix4fv(self.UNIFORM_LOCATIONS['projection'], 1, GL_FALSE, self.projection)
glUniformMatrix4fv(self.UNIFORM_LOCATIONS['view'], 1, GL_FALSE, self.view)
glUniform1f(self.UNIFORM_LOCATIONS['u_linewidth'], self.u_linewidth)
glUniform1f(self.UNIFORM_LOCATIONS['u_antialias'], self.u_antialias)
glUniform1f(self.UNIFORM_LOCATIONS['u_size'], self.u_size)
self.vbo.bind()
glEnableVertexAttribArray(self.ATTRIBUTE_LOCATIONS['a_position'])
glEnableVertexAttribArray(self.ATTRIBUTE_LOCATIONS['a_fg_color'])
glEnableVertexAttribArray(self.ATTRIBUTE_LOCATIONS['a_bg_color'])
glEnableVertexAttribArray(self.ATTRIBUTE_LOCATIONS['a_size'])
stride = 48
glVertexAttribPointer(
self.ATTRIBUTE_LOCATIONS['a_position'],
3, GL_FLOAT, False, stride, self.vbo
)
glVertexAttribPointer(
self.ATTRIBUTE_LOCATIONS['a_fg_color'],
4, GL_FLOAT, False, stride, self.vbo + 12
)
glVertexAttribPointer(
self.ATTRIBUTE_LOCATIONS['a_bg_color'],
4, GL_FLOAT, False, stride, self.vbo + 28
)
glVertexAttribPointer(
self.ATTRIBUTE_LOCATIONS['a_size'],
1, GL_FLOAT, False, stride, self.vbo + 44
)
glDrawArrays(GL_POINTS, 0, 100000)
self.vbo.unbind()
glDisableVertexAttribArray(self.ATTRIBUTE_LOCATIONS['a_position'])
glDisableVertexAttribArray(self.ATTRIBUTE_LOCATIONS['a_fg_color'])
glDisableVertexAttribArray(self.ATTRIBUTE_LOCATIONS['a_bg_color'])
glDisableVertexAttribArray(self.ATTRIBUTE_LOCATIONS['a_size'])
glDisable(GL_PROGRAM_POINT_SIZE)
glDisable(GL_BLEND)
glUseProgram(0)
Thanks if anyone cares to help