def init_context(name, modelview_matrix, projection_matrix):
state = get_state()
with open(state["shaders"][name]['vertex_shader_path']) as f:
vertex_shader_text = f.read()
vertex_shader = shaders.compileShader(vertex_shader_text, GL_VERTEX_SHADER)
with open(state["shaders"][name]['fragment_shader_path']) as f:
fragment_shader_text = f.read()
fragment_shader = shaders.compileShader(fragment_shader_text, GL_FRAGMENT_SHADER)
shader = shaders.compileProgram(vertex_shader, fragment_shader)
#print "init interface state: ", state
position_location = glGetAttribLocation(shader, 'position')
normal_location = glGetAttribLocation(shader, 'normal')
color_location = glGetAttribLocation(shader, 'color')
modelview_location = glGetUniformLocation(shader, 'modelViewMatrix')
projection_location = glGetUniformLocation(shader, 'projectionMatrix')
contexts[name] = {
'shader': shader,
'modelview': {
'location': modelview_location,
'matrix': modelview_matrix
},
'projection': {
'location': projection_location,
'matrix': projection_matrix
},
'position_location': position_location,
'color_location': color_location,
'normal_location': normal_location,
'thing': state[name]
}
def __init__(self, graphics: Graphics, display_ratio: float, staff: Staff):
self.staff = staff
self.calibration = False
self.display_ratio = 1.0 / display_ratio
self.ref_c4_pos = [Staff.Pos[0], staff.note_positions[60]]
self.note_width = Staff.NoteWidth32nd
self.reset()
# Notation shader draws from 0->1 on XY, left->right, down->up
shader_substitutes = {
"NUM_NOTES": NoteRender.NumNotes,
"NUM_KEY_SIG": KeySignature.NumAccidentals,
"#define staff_pos_x 0.0": f"#define staff_pos_x {0.5 + Staff.Pos[0] * 0.5}",
"#define staff_pos_y 0.5": f"#define staff_pos_y {0.5 + Staff.Pos[1] * 0.5}",
"#define staff_width 1.0": f"#define staff_width {Staff.Width * 0.5}",
"#define staff_note_spacing 0.03": f"#define staff_note_spacing {Staff.NoteSpacing * 0.5}"
}
note_shader_path = Path(__file__).parent / "ext" / "shaders" / "notes.frag"
note_shader = Graphics.process_shader_source(Graphics.load_shader(note_shader_path), shader_substitutes)
self.shader = Graphics.create_shader(graphics.builtin_shader(Shader.TEXTURE, ShaderType.VERTEX), note_shader)
self.texture = Texture("")
self.sprite = SpriteTexture(graphics, self.texture, [1.0, 1.0, 1.0, 1.0], [0.0, 0.0], [2.0, 2.0], self.shader)
self.display_ratio_id = glGetUniformLocation(self.shader, "DisplayRatio")
self.music_time_id = glGetUniformLocation(self.shader, "MusicTime")
self.key_positions_id = glGetUniformLocation(self.shader, "KeyPositions")
self.note_positions_id = glGetUniformLocation(self.shader, "NotePositions")
self.note_colours_id = glGetUniformLocation(self.shader, "NoteColours")
self.note_types_id = glGetUniformLocation(self.shader, "NoteTypes")
self.note_decoration_id = glGetUniformLocation(self.shader, "NoteDecoration")
self.note_hats_id = glGetUniformLocation(self.shader, "NoteHats")
self.note_ties_id = glGetUniformLocation(self.shader, "NoteTies")
self.note_extra_id = glGetUniformLocation(self.shader, "NoteExtra")
def __init__(self): super(ImageShader, self).__init__(ImageShader.imageVertex, ImageShader.imageFragment) # Get our shader entry points self.attrib_position = glGetAttribLocation(self.program, 'position') self.uniform_modelCamera = glGetUniformLocation(self.program, 'modelToCameraMatrix') self.uniform_projection = glGetUniformLocation(self.program, 'projectionMatrix') self.uniform_alpha = glGetUniformLocation(self.program, 'alpha')
def __init__(self): super(TextShader, self).__init__(TextShader.textVertex, TextShader.textFragment) # Get our shader entry points self.attrib_position = glGetAttribLocation(self.program, 'position') self.uniform_modelCamera = glGetUniformLocation(self.program, 'modelToCameraMatrix') self.uniform_projection = glGetUniformLocation(self.program, 'projectionMatrix') self.uniform_color = glGetUniformLocation(self.program, 'color') self.uniform_tex = glGetUniformLocation(self.program, 'tex') self.uniform_alpha = glGetUniformLocation(self.program, 'alpha')
def setUpC48gammaCorrection(window, monitor, gamma_grid=None):
"""Sets up the gamma correction for C48
Args:
window (PsychoPy.Window object): A PsychoPy Window object
monitor (PsychoPy.Monitor object): The current monitor being used
gamma_grid (list, optional): The gamma information if it is not contained in the monitor. (gamma_rgb; b_rgb, k_rgb)
"""
if not hasattr(window, '_DPShaderProg'):
raise Warning(
"Shader not set up! make sure you call setUpShaderAndWindow before setting up gamma correction."
)
return
from OpenGL.GL import glUseProgram, glUniform3f, glGetUniformLocation, glUniform1i
glUseProgram(window._DPShaderProg)
loc = glGetUniformLocation(window._DPShaderProg, "gamma_rgb")
if loc == -1:
raise Warning(
"The current shader is not the right shader, are you sure you are in M16 mode?"
)
return
if gamma_grid is None:
gamma_grid = monitor.getGammaGrid()
if gamma_grid is None:
raise Warning(
"You did not provide gamma information and your monitor does not have any."
)
return
gamma_rgb = [gamma_grid[1][2], gamma_grid[2][2],
gamma_grid[3][2]] # gamma
b_rgb = [gamma_grid[1][4], gamma_grid[2][4], gamma_grid[3][4]] # b
k_rgb = [gamma_grid[1][5], gamma_grid[2][5], gamma_grid[3][5]] # k
else:
gamma_rgb = [gamma_grid[0][0], gamma_grid[0][1],
gamma_grid[0][2]] # gamma
b_rgb = [gamma_grid[1][0], gamma_grid[1][1], gamma_grid[1][2]] # b
k_rgb = [gamma_grid[2][0], gamma_grid[2][1], gamma_grid[2][2]] # k
glUniform3f(glGetUniformLocation(window._DPShaderProg, "b_rgb"), b_rgb[0],
b_rgb[1], b_rgb[2])
glUniform3f(glGetUniformLocation(window._DPShaderProg, "k_rgb"), k_rgb[0],
k_rgb[1], k_rgb[2])
glUniform3f(glGetUniformLocation(window._DPShaderProg, "gamma_rgb"),
gamma_rgb[0], gamma_rgb[1], gamma_rgb[2])
glUniform1i(
glGetUniformLocation(window._DPShaderProg, "gamma_correction_flag"), 1)
def draw(self, reset, modelview):
"""Binds the shaders and things to draw the lamp itself.
Takes a reference to the 'matrix reset' function, and a modelview matrix to draw by."""
glUseProgram(shaderl)
reset(shaderl)
glUniformMatrix4fv(glGetUniformLocation(shaderl, 'modelmatrix'), 1, False, modelview)
self.model.draw()
def GetUniformLocation(self, name):
if name in self.m_UniformLocationCache:
return self.m_UniformLocationCache[name]
location = glGetUniformLocation(self.m_RendererID, name)
if location == -1:
print(f"Warning: Uniform {name} does not exist!")
self.m_UniformLocationCache[name] = location
return location
def bind_uniform_array(self, data, name):
"""Bind uniform array."""
if data.dtype.kind == 'i':
uniform_binder = glUniform1iv
elif data.dtype.kind == 'f':
uniform_binder = glUniform1fv
location = glGetUniformLocation(self.__program, name)
assert location >= 0
uniform_binder(location, data.size, data.flatten())
def __init__(self, vert_path, frag_path, uniform=()):
self.vert_shader = open(path.join(SHADER_DIR, vert_path)).read()
self.frag_shader = open(path.join(SHADER_DIR, frag_path)).read()
vert = shaders.compileShader(self.vert_shader, GL_VERTEX_SHADER)
frag = shaders.compileShader(self.frag_shader, GL_FRAGMENT_SHADER)
self.program = shaders.compileProgram(vert, frag)
uniform = uniform if isinstance(uniform, tuple) else (uniform,)
self.uniform = { i: glGetUniformLocation(self.program, i) for i in uniform }
def _setup(self):
"""Setup OpenGL attributes if required"""
if self._vao is None: # if the opengl state has not been set
self._shader = get_shader(self.context_identifier, self.shader_name)
glUseProgram(self._shader)
self._transform_location = glGetUniformLocation(
self._shader, "transformation_matrix"
)
self._texture_location = glGetUniformLocation(self._shader, "image")
self._vao = glGenVertexArrays(1) # create the array
glBindVertexArray(self._vao)
self._vbo = glGenBuffers(1) # and the buffer
glBindBuffer(GL_ARRAY_BUFFER, self._vbo)
self._setup_opengl_attrs()
self._change_verts()
glBindVertexArray(0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
glUseProgram(0)
def get_location(self, variable: str) -> int:
"""Get location of a given variable within the shader"""
if variable in self._stack:
return self._stack[variable]
location = glGetUniformLocation(self.program, variable)
if location == -1:
return False
self._stack[variable] = location
return location
def __init__(self, graphics: Graphics, textures: TextureManager, texture: str):
self.time = 0.0
self.shader = Graphics.create_shader(
graphics.builtin_shader(Shader.TEXTURE_ANIM, ShaderType.VERTEX),
graphics.builtin_shader(Shader.TEXTURE_ANIM, ShaderType.PIXEL)
)
self.time_id = glGetUniformLocation(self.shader, "Time")
self.bg = textures.create_sprite_texture(texture, [0, 0], [2, 2], self.shader)
def init_shader(self, vertex=None, fragment=None):
if self.gls_pgr:
glUseProgram(0)
if self.gls_pgr.shader_id:
glDeleteShader(self.gls_pgr.shader_id)
if vertex is None:
vertex = """
#version 330
attribute vec2 xy_pos;
uniform vec4 xy_color;
uniform vec4 xy_color1;
varying vec4 frg_color;
void main(void)
{
frg_color = xy_color;
gl_Position = vec4(xy_pos,0, 1.0);
}
"""
print vertex
if fragment is None:
fragment = """
#version 330
varying vec4 frg_color;
void main(void)
{
gl_FragColor = frg_color;
}
"""
print fragment
self.gls_pgr = ShaderProgram(vertex,fragment)
glUseProgram(self.gls_pgr.program_id)
self.vertIndex = self.gls_pgr.attribute_location('xy_pos')
#glVertexAttribPointer(self.gls_pgr.attribute_location('xy_pos'), 2, GL_FLOAT, GL_FALSE, 0, None)
# Turn on this vertex attribute in the shader
#glEnableVertexAttribArray(0)
self.gls_id_xy_color = self.gls_pgr.uniform_location("xy_color")
print self.gls_id_xy_color
cid=glGetUniformLocation(self.gls_pgr.program_id,"xy_color1")
print cid
glUniform4fv(self.gls_id_xy_color,1, self.color)
def enableGammaCorrection(window):
"""Enables M16 or C48 shader gamma correction"""
from OpenGL.GL import glUseProgram, glUniform3f, glGetUniformLocation, glUniform1i
if not hasattr(window, '_DPShaderProg'):
raise Warning(
"Shader not set up! make sure you call setUpShaderAndWindow before setting up gamma correction."
)
return
glUseProgram(window._DPShaderProg)
glUniform1i(
glGetUniformLocation(window._DPShaderProg, "gamma_correction_flag"), 1)
def init_shader(self, vertex=None, fragment=None):
if self.gls_pgr:
glUseProgram(0)
if self.gls_pgr.shader_id:
glDeleteShader(self.gls_pgr.shader_id)
if vertex is None:
vertex = """
#version 330
attribute vec2 xy_pos;
uniform vec4 xy_color;
uniform vec4 xy_color1;
varying vec4 frg_color;
void main(void)
{
frg_color = xy_color;
gl_Position = vec4(xy_pos,0, 1.0);
}
"""
print vertex
if fragment is None:
fragment = """
#version 330
varying vec4 frg_color;
void main(void)
{
gl_FragColor = frg_color;
}
"""
print fragment
self.gls_pgr = ShaderProgram(vertex, fragment)
glUseProgram(self.gls_pgr.program_id)
self.vertIndex = self.gls_pgr.attribute_location('xy_pos')
#glVertexAttribPointer(self.gls_pgr.attribute_location('xy_pos'), 2, GL_FLOAT, GL_FALSE, 0, None)
# Turn on this vertex attribute in the shader
#glEnableVertexAttribArray(0)
self.gls_id_xy_color = self.gls_pgr.uniform_location("xy_color")
print self.gls_id_xy_color
cid = glGetUniformLocation(self.gls_pgr.program_id, "xy_color1")
print cid
glUniform4fv(self.gls_id_xy_color, 1, self.color)
def uniform_location(self, name):
""" Helper function to get location of an OpenGL uniform variable
Parameters
----------
name : str
Name of the variable for which location is to be returned
Returns
-------
value : int
Integer describing location
"""
return glGetUniformLocation(self.program_id, name)
def level5_init(level, program):
# 1.59 - approximate position of the eyes of a person who is 1.69 meters tall
level.position = array([0, 0, 1.59, 1], dtype='float32')
# looking forward in Y-axis positive direction
level.orientation = array([0, 1, 0, 0], dtype='float32')
level.time_start = time()
level.time_checkpoint = level.time_start
# get position for view matrix
level.view_pos = glGetUniformLocation(program, 'view')
# get position for rotating model matrix
level.rotating_model_pos = glGetUniformLocation(program, 'rotating_model')
# sun
level.sun_color = array([1.0, 1.0, 1.0], dtype='float32')
level.sun_color_pos = glGetUniformLocation(program, 'sunColor')
glUniform3fv(level.sun_color_pos, 1, level.sun_color)
level.sun_direction_pos = glGetUniformLocation(program, 'sunDirection')
glUniform3fv(level.sun_direction_pos, 1, level.sun_direction)
level.ambient_intensity = 0.2
level.ambient_intensity_pos = glGetUniformLocation(program, 'ambientIntensity')
glUniform1f(level.ambient_intensity_pos, level.ambient_intensity)
# initialize projection matrix once
level.projection = perspective(pi / 3.5, level.screen_w / level.screen_h, 0.005, 1000000.0)
level.projection_pos = glGetUniformLocation(program, 'projection')
glUniformMatrix4fv(level.projection_pos, 1, GL_FALSE, level.projection)
def __init__(self, vertex_shader, fragment_shader):
self.vert = vertex_shader
self.frag = fragment_shader
self._models_and_VAOs = []
self._program = shaders.compileProgram(self.vert.shader,
self.frag.shader)
self.VAOs = []
# get uniform locations
self.uniforms = {}
self.ins = {}
for var in self.vert.vars:
if var.cls == "uniform":
loc = glGetUniformLocation(self._program, var.name)
if loc == -1:
print(
"WARNING: Uniform " + var.name +
" returned -1; this indicates that the var is not being used by the program."
)
else:
self.uniforms[var.name] = (loc, var.type)
if var.cls == "in" or var.cls == "inout" or var.cls == "varying":
loc = glGetAttribLocation(self._program, var.name)
if loc == -1:
print(
"WARNING: Attribute " + var.name +
" returned -1; this indicates that the var is not being used by the program."
)
self.ins[var.name] = (loc, var.type)
for var in self.frag.vars:
if var.cls == "uniform" and var.name not in self.uniforms:
loc = glGetUniformLocation(self._program, var.name)
if loc == -1:
print(
"WARNING: Attribute " + var.name +
" location returned -1; this indicates that the var is not being used by the program."
)
self.uniforms[var.name] = [loc, var.type]
def compileShader(self):
create_opengl_context((self.width, self.height))
glClear(GL_COLOR_BUFFER_BIT)
self.shader = shaders.compileProgram(self.compileVertexShader(), self.compileFragmentShader())
self.xpos = glGetUniformLocation(self.shader, 'xpos')
self.ypos = glGetUniformLocation(self.shader, 'ypos')
self.vdir_x = glGetUniformLocation(self.shader, 'vdir_x')
self.vdir_y = glGetUniformLocation(self.shader, 'vdir_y')
self.vdir_z = glGetUniformLocation(self.shader, 'vdir_z')
self.arrow_size = glGetUniformLocation(self.shader, 'size')
self.res_loc = glGetUniformLocation(self.shader, 'iResolution')
def orthogonalPass(self, debugShadows=False):
"""
draw stuff in orthogonal projection.
mainly the scene can be post processed here
and some gui elements could be drawn.
"""
### DRAW THE SCENE ###
# TODO: post shader magic !
glUseProgram(0)
# enable the scene texture
# Note that texture unit 0 should be active now.
glEnable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, self.sceneTexture.glID)
# make sure texture matrix is set to identity
glMatrixMode(GL_TEXTURE)
glLoadIdentity()
glMatrixMode(GL_MODELVIEW)
glBegin(GL_QUADS)
glTexCoord2f(0.0, 0.0)
glVertex3f(0.0, 0.0, -1.0)
glTexCoord2f(1.0, 0.0)
glVertex3f(self.winSize[0], 0.0, -1.0)
glTexCoord2f(1.0, 1.0)
glVertex3f(self.winSize[0], self.winSize[1], -1.0)
glTexCoord2f(0.0, 1.0)
glVertex3f(0.0, self.winSize[1], -1.0)
glEnd()
### DEBUG DRAWINGS ###
# debug shadow maps
if debugShadows:
# draw the shadow maps
self.visualizeDepthShader.enable()
layerLoc = glGetUniformLocation(self.visualizeDepthShader.program, "layer")
drawShadowMaps(self.lights, layerLoc)
# reset viewport and reset to ffp
glViewport(0, 0, self.winSize[0], self.winSize[1])
glUseProgram(0)
glBindTexture(GL_TEXTURE_2D, 0)
glDisable(GL_TEXTURE_2D)
GLApp.orthogonalPass(self)
def uniform_location(self, name):
""" Helper function to get location of an OpenGL uniform variable
Parameters
----------
name : str
Name of the variable for which location is to be returned
Returns
-------
value : int
Integer describing location
"""
return glGetUniformLocation(self.program_id, name)
def __init__(self, vertex_shader: Union[str, None] = None, fragment_shader: Union[str, None] = None,
geometry_shader: Union[str, None] = None, view_matrix_name: str = 'view_matrix',
projection_matrix_name: str = 'projection_matrix', model_matrix_name: str = 'model_matrix',
instanced_attribs=(), obj=None):
super().__init__('Material', obj)
self.__vertex_shader = vertex_shader
self.__fragment_shader = fragment_shader
self.__geometry_shader = geometry_shader
self.__attributes: Dict[str, int] = {}
self.__uniforms: Dict[str, int] = {}
self.view_matrix_name = view_matrix_name
self.projection_matrix_name = projection_matrix_name
self.model_matrix_name = model_matrix_name
self.__instanced_attribs = set(instanced_attribs)
self.__attributes_values: Union[Dict[str, np.ndarray]] = {}
self.__uniforms_values: Union[Dict[str, np.ndarray]] = {}
self.__attributes_types = {}
self.__uniforms_types = {}
if self.__vertex_shader and self.__fragment_shader:
program = compileProgram(
*[compileShader(shader, const) for shader, const in [(self.__vertex_shader, GL_VERTEX_SHADER),
(self.__fragment_shader, GL_FRAGMENT_SHADER),
(self.__geometry_shader, GL_GEOMETRY_SHADER)] if shader]
)
self.__program = program
num_active_attribs = glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES)
for u in range(num_active_attribs):
name, size, type_ = glGetActiveAttrib(program, u)
location = glGetAttribLocation(program, name)
name = name.decode("utf-8")
self.__attributes_types[name] = type_
self.__attributes[name] = location
self.__attributes_values[name] = np.array([])
num_active_uniforms = glGetProgramiv(program, GL_ACTIVE_UNIFORMS)
for u in range(num_active_uniforms):
name, size, type_ = glGetActiveUniform(program, u)
location = glGetUniformLocation(program, name)
name = name.decode("utf-8")
self.__uniforms_types[name] = type_
self.__uniforms[name] = location
self.__uniforms_values[name] = np.array([])
def setUniformValue(self, name, *value):
# 1-4 values of floats or ints(value[0] used to check the type)
# or one numpy.array of floats or ints with shape (1,1)-(1,4)
un_id = glGetUniformLocation(self.program_id, name)
if self.__DEBUG:
print "Set Uniform Vertex : ", self.vertpath
print "Set Uniform Fragment : ", self.fragpath
print "For '%s' name ID is %i" % (name, un_id)
m = len(value)
if m > 1:
if isinstance(value[0], float):
value = numpy.array(value, numpy.float32)
else:
value = numpy.array(value, numpy.int32)
else:
if m < 1:
raise RuntimeError(
"Empty uniform value! Uniform variables in shader can only have 1-4 int32/float32 elements."
)
value = value[0]
if isinstance(value, float):
execution_command = 'GL.glUniform1f(%i, %s)' % (un_id, str(value))
exec(execution_command)
return
elif value.shape[0] < 1 or value.shape[0] > 4:
raise RuntimeError(
"Uniform variables in shader can only have 1-4 int32/float32 elements."
)
if un_id >= 0 and isinstance(value, np.ndarray):
# please, don't try to do it at production and be carefully at home ;)
n = value.shape[0]
type_label = str(value[0].dtype)
type_symb = 'i' if 'int' in type_label else 'f'
line = ', '.join(map(str, value))
execution_command = 'GL.glUniform%i%s(%i, %s)' % (n, type_symb,
un_id, line)
exec(execution_command)
else:
raise RuntimeError(
"Uniform id: %i, \n value type : %s \n Use int32/float32 numpy arrays only!"
% (un_id, str(type(value))))
def build(self, variables: Optional[List[str]] = None) -> int:
"""Build GLSL Shader
Compile shaders and compile glsl program
Args:
variables: List of in/out/uniform variable names.
Return:
self.program
"""
vertex_shader = shaders.compileShader(self.vertex_shader_source,
GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader(self.fragment_shader_source,
GL_FRAGMENT_SHADER)
self.program = shaders.compileProgram(vertex_shader, fragment_shader)
if variables:
self.variables = variables
for v in self.variables:
location = glGetUniformLocation(self.program, v)
self._stack[v] = location
return self.program
def update(self, *shaders):
# TODO: for now this is actually create, not update
self._shaders += shaders
for shader in self._shaders:
glAttachShader(self._hnd, shader.hnd)
logging.info('glLinkProgram(%d)', self._hnd)
glLinkProgram(self._hnd)
logging.info('glGetProgramInfoLog(%d) -> %s', self._hnd,
glGetProgramInfoLog(self._hnd).decode().strip())
self._uniforms = {}
self._attributes = bidict()
for shader in self._shaders:
for name in shader.uniforms():
self._uniforms[name] = glGetUniformLocation(self._hnd, name)
for name, location in shader.attributes():
if location in self._attributes.inv:
raise KeyError('duplication attribute location', location,
name)
self._attributes[name] = location
def update(self, *shaders):
# TODO: for now this is actually create, not update
self._shaders += shaders
for shader in self._shaders:
glAttachShader(self._hnd, shader.hnd)
logging.info('glLinkProgram(%d)', self._hnd)
glLinkProgram(self._hnd)
logging.info('glGetProgramInfoLog(%d) -> %s', self._hnd,
glGetProgramInfoLog(self._hnd).decode().strip())
self._uniforms = {}
self._attributes = bidict()
for shader in self._shaders:
for name in shader.uniforms():
self._uniforms[name] = glGetUniformLocation(self._hnd, name)
for name, location in shader.attributes():
if location in self._attributes.inv:
raise KeyError('duplication attribute location', location,
name)
self._attributes[name] = location
def on_realize(self, area):
# We need to make the context current if we want to
# call GL API
area.make_current()
context = area.get_context()
if (area.get_error() != None):
return
fragment_shader = shaders.compileShader(FRAGMENT_SOURCE,
GL_FRAGMENT_SHADER)
vertex_shader = shaders.compileShader(VERTEX_SOURCE, GL_VERTEX_SHADER)
self.shaderContent.shader_prog = shaders.compileProgram(
fragment_shader, vertex_shader)
glLinkProgram(self.shaderContent.shader_prog)
self.vertex_array_object = glGenVertexArrays(1)
glBindVertexArray(self.vertex_array_object)
# Generate buffers to hold our vertices
self.vertex_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.vertex_buffer)
self.position = glGetAttribLocation(self.shaderContent.shader_prog,
'position')
self.time_l = glGetUniformLocation(self.shaderContent.shader_prog,
'time')
print(self.time_l)
# glBindAttribLocation(self.shaderContent.shader_prog, self.time, 'time')
glEnableVertexAttribArray(self.position)
glVertexAttribPointer(index=self.position,
size=4,
type=GL_FLOAT,
normalized=False,
stride=0,
pointer=ctypes.c_void_p(0))
glBufferData(GL_ARRAY_BUFFER, 192, self.vertices, GL_STATIC_DRAW)
glBindVertexArray(0)
glDisableVertexAttribArray(self.position)
glBindBuffer(GL_ARRAY_BUFFER, 0)
self.on_render(self.shaderContent)
return True
def reload(self):
"""
Reload or build for the first time the uniforms cache.
This can be quite expensive so it is only done on shader linking.
If the shader was linked outside the api, you have to call this manually.
"""
prog = self.prog()
if prog is None:
raise RuntimeError('Shader was freed')
maxlength = getattr(prog, 'max_uniform_length')
name_buf = (c_char * maxlength)()
name_buf_ptr = cast(name_buf, POINTER(c_char))
type_buf = GLenum(0)
name_buf_length = GLint(0)
buf_size = GLint(0)
self.cache = {}
for i in range(getattr(prog, 'uniforms_count')):
name, size, type = glGetActiveUniform(prog.pid, i)
name = name.decode('UTF-8')
loc = glGetUniformLocation(prog.pid, name)
self.cache_item_build(loc, size, name, type)
def getUniformLocation(self, name):
return glGetUniformLocation(self.__programId, name)
def link_texture(self, name, number):
"""Link the texture to shaders."""
location = glGetUniformLocation(self.__program, name)
assert location >= 0
glUniform1i(location, number)
def uniform(self, name):
"""Return the location integer for a uniform variable in this program"""
return glGetUniformLocation(self.program, name.encode("utf_8"))
def setVec4(self, name, value):
location = glGetUniformLocation(self.program, name)
glUniform4fv(location, value)
def get_uniforms(program, names):
return dict((name, glGetUniformLocation(program, name)) for name in names)
def uniformlocation(self, name):
if name not in self.uniformlocs:
self.uniformlocs[name] = glGetUniformLocation(self.program, name)
return self.uniformlocs[name]
def bind_uniform_matrix(self, data, name):
"""Bind uniform matrix parameter."""
location = glGetUniformLocation(self.__program, name)
assert location >= 0
glUniformMatrix4fv(location, 1, GL_FALSE, data.flatten())
def ubicacion(self, uniforme): """Retorna la ubicación de la vaiable uniforme en el programa. uniforme = texto del nombre de la variable""" return glGetUniformLocation(self.programa, uniforme)
def bind(self):
"""Bind the light values to the shader. Not the lamp shader, the other one."""
glUniform3f(glGetUniformLocation(self.model.shader, 'light.position'), *self.pos)
glUniform3f(glGetUniformLocation(self.model.shader, 'light.ambient'), *self.ambient)
glUniform3f(glGetUniformLocation(self.model.shader, 'light.diffuse'), *self.diffuse)
glUniform3f(glGetUniformLocation(self.model.shader, 'light.specular'), *self.specular)
def setUInt(self, name, value):
location = glGetUniformLocation(self.program, name)
glUniform1ui(location, value)
def setFloat(self, name, value):
location = glGetUniformLocation(self.program, name)
glUniform1f(location, value)
def set_uniform_i(self, name, value):
location = glGetUniformLocation(self.program, name)
glUniform1i(location, value)
def setMat4(self, name, value):
location = glGetUniformLocation(self.program, name)
glUniformMatrix4fv(location, 1, GL_FALSE, value.data())
def setMat3(self, name, value):
location = glGetUniformLocation(self.program, name)
glUniformMatrix3fv(location, value)
def __get__(self, inst, owner):
if inst not in self._values:
self._values[inst] = glGetUniformLocation(inst.program, self.name)
return self._values[inst]
def bind(self, shader):
"""Binds a bunch of GLSL Uniforms. Do try not to change their names or anything."""
glUniform3f(glGetUniformLocation(shader, 'material.ambient'), *self.ambient)
glUniform3f(glGetUniformLocation(shader, 'material.diffuse'), *self.diffuse)
glUniform3f(glGetUniformLocation(shader, 'material.specular'), *self.specular)
glUniform1f(glGetUniformLocation(shader, 'material.shininess'), self.shininess)
def uniformLocation(self, name): return glGetUniformLocation(self.program_id, name)
def run():
#Start OpenGL and ask it for an OpenGL context
pygame.init()
clock = pygame.time.Clock()
screen = pygame.display.set_mode(SCREEN_SIZE, pygame.HWSURFACE|pygame.OPENGL|pygame.DOUBLEBUF)
#The first thing we do is print some OpenGL details and check that we have a good enough version
print("OpenGL Implementation Details:")
if glGetString(GL_VENDOR):
print("\tGL_VENDOR: {}".format(glGetString(GL_VENDOR).decode()))
if glGetString(GL_RENDERER):
print("\tGL_RENDERER: {}".format(glGetString(GL_RENDERER).decode()))
if glGetString(GL_VERSION):
print("\tGL_VERSION: {}".format(glGetString(GL_VERSION).decode()))
if glGetString(GL_SHADING_LANGUAGE_VERSION):
print("\tGL_SHADING_LANGUAGE_VERSION: {}".format(glGetString(GL_SHADING_LANGUAGE_VERSION).decode()))
major_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[0])
minor_version = int(glGetString(GL_VERSION).decode().split()[0].split('.')[1])
if major_version < 3 or (major_version < 3 and minor_version < 0):
print("OpenGL version must be at least 3.0 (found {0})".format(glGetString(GL_VERSION).decode().split()[0]))
#Now onto the OpenGL initialisation
#Set up depth culling
glEnable(GL_CULL_FACE)
glEnable(GL_DEPTH_TEST)
glDepthMask(GL_TRUE)
glDepthFunc(GL_LEQUAL)
glDepthRange(0.0, 1.0)
#We create out shaders which do little more than set a flat colour for each face
VERTEX_SHADER = shaders.compileShader(b"""
#version 130
in vec4 position;
in vec4 normal;
uniform mat4 projectionMatrix;
uniform mat4 viewMatrix;
uniform mat4 modelMatrix;
flat out float theColor;
void main()
{
vec4 temp = modelMatrix * position;
temp = viewMatrix * temp;
gl_Position = projectionMatrix * temp;
theColor = clamp(abs(dot(normalize(normal.xyz), normalize(vec3(0.9,0.1,0.5)))), 0, 1);
}
""", GL_VERTEX_SHADER)
FRAGMENT_SHADER = shaders.compileShader(b"""
#version 130
flat in float theColor;
out vec4 outputColor;
void main()
{
outputColor = vec4(1.0, 0.5, theColor, 1.0);
}
""", GL_FRAGMENT_SHADER)
shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)
#And then grab our attribute locations from it
glBindAttribLocation(shader, 0, b"position")
glBindAttribLocation(shader, 1, b"normal")
#Create the Vertex Array Object to hold our volume mesh
vertexArrayObject = GLuint(0)
glGenVertexArrays(1, vertexArrayObject)
glBindVertexArray(vertexArrayObject)
#Create the index buffer object
indexPositions = vbo.VBO(indices, target=GL_ELEMENT_ARRAY_BUFFER, usage=GL_STATIC_DRAW)
#Create the VBO
vertexPositions = vbo.VBO(vertices, usage=GL_STATIC_DRAW)
#Bind our VBOs and set up our data layout specifications
with indexPositions, vertexPositions:
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(0*vertices.dtype.itemsize))
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 3, GL_FLOAT, False, 6*vertices.dtype.itemsize, vertexPositions+(3*vertices.dtype.itemsize))
glBindVertexArray(0)
glDisableVertexAttribArray(0)
#Now grab out transformation martix locations
modelMatrixUnif = glGetUniformLocation(shader, b"modelMatrix")
viewMatrixUnif = glGetUniformLocation(shader, b"viewMatrix")
projectionMatrixUnif = glGetUniformLocation(shader, b"projectionMatrix")
modelMatrix = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f')
viewMatrix = np.array([[1.0,0.0,0.0,0.0],[0.0,1.0,0.0,0.0],[0.0,0.0,1.0,-50.0],[0.0,0.0,0.0,1.0]], dtype='f')
projectionMatrix = np.array([[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], dtype='f')
#These next few lines just set up our camera frustum
fovDeg = 45.0
frustumScale = 1.0 / tan(radians(fovDeg) / 2.0)
zNear = 1.0
zFar = 1000.0
projectionMatrix[0][0] = frustumScale
projectionMatrix[1][1] = frustumScale
projectionMatrix[2][2] = (zFar + zNear) / (zNear - zFar)
projectionMatrix[2][3] = -1.0
projectionMatrix[3][2] = (2 * zFar * zNear) / (zNear - zFar)
#viewMatrix and projectionMatrix don't change ever so just set them once here
with shader:
glUniformMatrix4fv(projectionMatrixUnif, 1, GL_TRUE, projectionMatrix)
glUniformMatrix4fv(viewMatrixUnif, 1, GL_TRUE, viewMatrix)
#These are used to track the rotation of the volume
LastFrameMousePos = (0,0)
CurrentMousePos = (0,0)
xRotation = 0
yRotation = 0
while True:
clock.tick()
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE:
return
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
CurrentMousePos = event.pos
LastFrameMousePos = CurrentMousePos
if event.type == pygame.MOUSEMOTION and 1 in event.buttons:
CurrentMousePos = event.pos
diff = (CurrentMousePos[0] - LastFrameMousePos[0], CurrentMousePos[1] - LastFrameMousePos[1])
xRotation += event.rel[0]
yRotation += event.rel[1]
LastFrameMousePos = CurrentMousePos
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
#Perform the rotation of the mesh
moveToOrigin = np.array([[1.0,0.0,0.0,-32.0],[0.0,1.0,0.0,-32.0],[0.0,0.0,1.0,-32.0],[0.0,0.0,0.0,1.0]], dtype='f')
rotateAroundX = np.array([[1.0,0.0,0.0,0.0],[0.0,cos(radians(yRotation)),-sin(radians(yRotation)),0.0],[0.0,sin(radians(yRotation)),cos(radians(yRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f')
rotateAroundY = np.array([[cos(radians(xRotation)),0.0,sin(radians(xRotation)),0.0],[0.0,1.0,0.0,0.0],[-sin(radians(xRotation)),0.0,cos(radians(xRotation)),0.0],[0.0,0.0,0.0,1.0]], dtype='f')
modelMatrix = rotateAroundY.dot(rotateAroundX.dot(moveToOrigin))
with shader:
glUniformMatrix4fv(modelMatrixUnif, 1, GL_TRUE, modelMatrix)
glBindVertexArray(vertexArrayObject)
glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None)
glBindVertexArray(0)
# Show the screen
pygame.display.flip()
def bind_uniform_vector(self, data, name):
"""Bind uniform vector parameter."""
location = glGetUniformLocation(self.__program, name)
assert location >= 0
glUniform4f(location, *data.flatten())
def uloc(self,n):
return glGetUniformLocation(self.program_id, n)
def _find_uniforms(self):
from OpenGL.GL import glGetUniformLocation
self._uniform_handles = { \
name: glGetUniformLocation(self._gl_handle, str(name)) \
for name in self.uniforms.keys() }
def set_uniform_i(self, name, value):
location = glGetUniformLocation(self.program, name)
glUniform1i(location, value)
