def compile(self):
if not self.source:
return False
source = []
for import_lib in self.imports:
if not import_lib.source:
return False
source.extend( import_lib.source )
source.extend( self.source )
try:
if self.type == 'VERTEX':
shader = GL_shaders.compileShader(
source,
GL_VERTEX_SHADER
)
elif self.type == 'FRAGMENT':
shader = GL_shaders.compileShader(
source, GL_FRAGMENT_SHADER
)
else:
log.error(
'Unknown shader type: %s in %s',
self.type,
self,
)
return None
except RuntimeError, err:
self.compileLog = err.args[0]
return None
def __init__(self,
width = 25.0,
peak = 26.0,
vertShader = 'knotvertex.vs',
fragShader = 'knotfragment.fs',
shaderPositionName = 'position',
shaderNormalName = 'normal',
shaderTexcoordName = 'texcoord'):
self.peak = peak
self.width = width
with open(os.path.join(os.getcwd(), vertShader)) as fp:
vert = fp.read()
with open(os.path.join(os.getcwd(), fragShader)) as fp:
frag = fp.read()
try:
self.program = compileProgram(
compileShader(vert, GL_VERTEX_SHADER),
compileShader(frag, GL_FRAGMENT_SHADER))
except RuntimeError as rte:
print rte[0]
raise
self.positionLocation = glGetAttribLocation(self.program,
shaderPositionName)
self.normalLocation = glGetAttribLocation(self.program,
shaderNormalName)
self.texcoordLocation = glGetAttribLocation(self.program,
shaderTexcoordName)
self.makeDataBuffers()
def __init__(self):
self.vertexshader = shaders.compileShader("""
attribute vec2 position;
attribute vec4 color;
uniform vec2 resolution;
uniform vec2 scroll;
varying vec4 v_color;
void main() {
vec2 p = (position + scroll) / resolution * 2.0 - 1.0;
gl_Position = vec4(p.x, -p.y, 0.0, 1.0);
v_color = color;
}""", GL_VERTEX_SHADER)
self.fragmentshader = shaders.compileShader("""
varying vec4 v_color;
void main() {
gl_FragColor = v_color;
}""", GL_FRAGMENT_SHADER)
self.shader = shaders.compileProgram(
self.vertexshader,
self.fragmentshader)
self.vbo = glGenBuffers(1)
self.vertices = []
self.vertexcount = 0
self.dirty = True
def __init__ ( self, title="title", width=640, height=480, pos_x=50, pos_y=50, vertex_shader=None, fragment_shader=None ): # initialize GLUT library ( cf. window handling, user interactions ) glutInit( sys.argv ) glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH ) # glutFullScreen() # initialize and create window glutInitWindowPosition( pos_x, pos_y ) # set upper left corner on screen glutInitWindowSize( width, height ) self.window = glutCreateWindow( title ) # register callback functions glutDisplayFunc( self.display ) # glutIdleFunc( self.display ) glutReshapeFunc( self.reshape ) # called on window creation as well glutKeyboardFunc( self.keyboard ) glutMouseFunc( self.mouse ) # specify clear values for some buffers and the shading technique to use # ( noted for explicity only, values are the defaults ) glClearColor( 0.0, 0.0, 0.0, 0.0 ) # range [0;1] glClearDepth( 1.0 ) # range [0;1] glShadeModel( GL_SMOOTH ) # GL_FLAT or GL_SMOOTH # compile shaders if vertex_shader and fragment_shader: self.shader = shaders.compileProgram ( # uses OpenGL.GL.shaders shaders.compileShader( vertex_shader, GL_VERTEX_SHADER ), shaders.compileShader( fragment_shader, GL_FRAGMENT_SHADER ) ) glUseProgram( self.shader )
def init(self):
super(BasicWindow, self).init()
vert_shader = compileShader(vert_shader_source, GL.GL_VERTEX_SHADER)
frag_shader = compileShader(frag_shader_source, GL.GL_FRAGMENT_SHADER)
self.shader = game_core.ShaderProgram(vert_shader, frag_shader)
self.ndc_vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(self.ndc_vao)
vertex_buffer = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertex_buffer)
data = [
-1.0, -1.0, 0.0,
0.0, 1.0, 0.0,
1.0, -1.0, 0.0,
]
array_type = (GL.GLfloat*len(data))
GL.glBufferData(
GL.GL_ARRAY_BUFFER,
len(data)*game_core.FLOAT_SIZE,
array_type(*data),
GL.GL_STATIC_DRAW
)
GL.glEnableVertexAttribArray(0)
GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 0, None)
GL.glBindVertexArray(0)
def initializeShaders():
global theShaders, positionAttrib, normalAttrib, tangentAttrib,\
bitangentAttrib, uvAttrib, \
modelUnif, viewUnif, projUnif, lightUnif, \
colorSamplerUnif, normalSamplerUnif, scaleuvUnif, colorUnif
theShaders = compileProgram(
compileShader(strVertexShader, GL_VERTEX_SHADER),
compileShader(strFragmentShader, GL_FRAGMENT_SHADER)
)
positionAttrib = glGetAttribLocation(theShaders, "position")
normalAttrib = glGetAttribLocation(theShaders, "normal")
lightUnif = glGetUniformLocation(theShaders, "light")
modelUnif = glGetUniformLocation(theShaders, "model")
viewUnif = glGetUniformLocation(theShaders, "view")
projUnif = glGetUniformLocation(theShaders, "projection")
colorSamplerUnif = glGetUniformLocation(theShaders, "colorsampler")
normalSamplerUnif = glGetUniformLocation(theShaders, "normalsampler")
colorUnif = glGetUniformLocation(theShaders, "color")
check("positionAttrib", positionAttrib)
check("normalAttrib", normalAttrib)
check("modelUnif", modelUnif)
check("viewUnif", viewUnif)
check("projUnif", projUnif)
check("lightUnif", lightUnif)
check("colorUnif", colorUnif)
def OnInit(self):
VERTEX_SHADER = GLshaders.compileShader("""#version 120
void main(){
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}""", GL.GL_VERTEX_SHADER) #Defining the vertex shader
FRAGMENT_SHADER = GLshaders.compileShader("""#version 120
void main(){
gl_FragColor = vec4(0.2,1,0.5,1);
}""", GL.GL_FRAGMENT_SHADER) #Defining the fragment shader
myTriangle = np.array([
[ 0, 2, 0],
[-3, 0, 0],
[ 1, 0, 0],
[ 2, 1, 0],
[ 2,-2, 0],
[ 4,-2, 0],
[ 2, 1, 0],
[ 4,-2, 0],
[ 4, 1, 0]
], dtype='f')
self.myShader = GLshaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER)
self.vbo = GLvbo.VBO(myTriangle)
def init(self):
self.vertexbuffer = glGenBuffers(1)
vertex_shader = compileShader(VERTEX_SHADER, GL_VERTEX_SHADER)
fragment_shader = compileShader(FRAGMENT_SHADER, GL_FRAGMENT_SHADER)
self.program = compileProgram(vertex_shader, fragment_shader)
self.vertices_attr = glGetAttribLocation(self.program, b'vertices')
self.t_attr = glGetUniformLocation(self.program, b't')
def __compileShaders(self):
vertex_shader = shaders.compileShader("""
varying vec2 uv;
varying vec3 normal;
varying vec4 ecPos;
void main()
{
uv = gl_MultiTexCoord0;
ecPos = gl_ModelViewMatrix * gl_Vertex;
normal = normalize(gl_NormalMatrix * gl_Normal);
gl_Position = ftransform();
}
""", GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader("""
varying vec2 uv;
varying vec3 normal;
varying vec4 ecPos;
uniform sampler2D tex;
void main()
{
gl_FragColor = texture2D(tex, uv);
}
""", GL_FRAGMENT_SHADER)
self.__shaders = shaders.compileProgram(vertex_shader, fragment_shader)
self.__recompileShader = False
def __init__(self, vsrc, fsrc, csrc=None):
path = os.path.dirname(os.path.realpath(__file__)) + "/shaders/"
with open(path + fsrc, "r") as fin:
src = fin.read()
fragment = shaders.compileShader(src, GL_FRAGMENT_SHADER)
with open(path + vsrc, "r") as fin:
src = fin.read()
vertex = shaders.compileShader(src, GL_VERTEX_SHADER)
if csrc:
with open(path + csrc, "r") as fin:
src = fin.read()
print(src)
compute = shaders.compileShader(src, GL_COMPUTE_SHADER)
self.program = shaders.compileProgram(fragment, vertex, compute)
glDeleteShader(compute)
else:
self.program = shaders.compileProgram(fragment, vertex)
glDeleteShader(fragment)
glDeleteShader(vertex)
self._delete_prog = glDeleteProgram
self.locations = {}
def initializeProgram(self):
shaderList = []
shaderList.append(compileShader(VERTEX_SHADER, GL.GL_VERTEX_SHADER))
shaderList.append(compileShader(FRAGMENT_SHADER, GL.GL_FRAGMENT_SHADER))
self.theProgram = compileProgram(*shaderList)
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 compile(self):
vertexCode = self.getReturnOfFirstFunction("vertexin")
fragmentCode = self.getReturnOfFirstFunction("fragmentin")
if vertexCode is None:
vertexCode = self.defaultVertexShaderCode
if fragmentCode is None:
fragmentCode = self.defaultFragmentShaderCode
self.vertexShaderCode = vertexCode
self.fragmentShaderCode = fragmentCode
try:
self.fragmentShader = shaders.compileShader(self.fragmentShaderCode, GL_FRAGMENT_SHADER)
except:
print(traceback.print_exc())
self.fragmentShader = shaders.compileShader(self.defaultFragmentShaderCode, GL_FRAGMENT_SHADER)
try:
self.vertexShader = shaders.compileShader(self.vertexShaderCode, GL_VERTEX_SHADER)
except:
print(traceback.print_exc())
self.vertexShader = shaders.compileShader(self.defaultVertexShaderCode, GL_VERTEX_SHADER)
# -- Generate Shader program
if isinstance(self.fragmentShader, int) and isinstance(self.vertexShader, int):
self.shaderProgram = shaders.compileProgram(self.fragmentShader, self.vertexShader)
self.fireExec("execout")
def initializeProgram(self):
shaderList = []
shaderList.append(compileShader(VERTEX_SHADER, GL.GL_VERTEX_SHADER))
shaderList.append(compileShader(FRAGMENT_SHADER, GL.GL_FRAGMENT_SHADER))
self.theProgram = compileProgram(*shaderList)
self.positionAttrib = GL.glGetAttribLocation(self.theProgram, "position")
self.colorAttrib = GL.glGetAttribLocation(self.theProgram, "color")
self.modelToCameraMatrixUnif = GL.glGetUniformLocation(self.theProgram, "modelToCameraMatrix")
self.cameraToClipMatrixUnif = GL.glGetUniformLocation(self.theProgram, "cameraToClipMatrix")
fzNear = 1.0
fzFar = 61.0
self.cameraToClipMatrix[0, 0] = self.fFrustumScale
self.cameraToClipMatrix[1, 1] = self.fFrustumScale
self.cameraToClipMatrix[2, 2] = (fzFar+fzNear)/(fzNear-fzFar)
self.cameraToClipMatrix[2, 3] = -1.0
self.cameraToClipMatrix[3, 2] = (2*fzFar*fzNear)/(fzNear-fzFar)
GL.glUseProgram(self.theProgram)
GL.glUniformMatrix4fv(self.cameraToClipMatrixUnif,1,GL.GL_FALSE,self.cameraToClipMatrix.tolist())
GL.glUseProgram(0)
def __init__(self, vert_src, frag_src, attribs):
self.program = compileProgram(
compileShader(vert_src, GL.GL_VERTEX_SHADER), compileShader(frag_src, GL.GL_FRAGMENT_SHADER)
)
self.attrib = {}
for attrib in attribs:
self.attrib[attrib] = GL.glGetAttribLocation(self.program, attrib)
def load_shaders(self):
self.SetCurrent(self.context)
self.val = 0
# Show OpenGL Information
print "Vendor: " + glGetString(GL_VENDOR)
print "Renderer: " + glGetString(GL_RENDERER)
print "OpenGL Version: " + glGetString(GL_VERSION)
print "Shader Version: " + glGetString(GL_SHADING_LANGUAGE_VERSION)
VERTEX_SHADER = shaders.compileShader("""#version 330 core
layout(location = 0) in vec4 position;
uniform vec2 scale;
out vec2 uv;
void main() {
gl_Position = vec4(position.xy * scale, position.zw);
uv = position.xy/2 + 0.5f;
uv.y = 1 - uv.y;
}""", GL_VERTEX_SHADER)
FRAGMENT_SHADER = shaders.compileShader("""#version 330 core
uniform sampler2D myTexture;
in vec2 uv;
out vec4 outputColor;
void main() {
outputColor = texture2D(myTexture, uv );
}""", GL_FRAGMENT_SHADER)
self.program = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)
self.scale = glGetUniformLocation(self.program, "scale")
self.texture = glGetUniformLocation(self.program, "myTexture")
return
def compile_shader(self):
vertex = shaders.compileShader(self.VERTEX_SHADER,
GL_VERTEX_SHADER)
fragment = shaders.compileShader(self.FRAGMENT_SHADER,
GL_FRAGMENT_SHADER)
self.shader = shaders.compileProgram(vertex, fragment)
def OnInit(self):
vertex_shader = shaders.compileShader(
"""
void main()
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}
""",
GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader(
"""
void main()
{
gl_FragColor = vec4(0, 1, 0, 1);
}
""",
GL_FRAGMENT_SHADER)
self.shader = shaders.compileProgram(vertex_shader, fragment_shader)
self.vbo = vbo.VBO(
array([
[0, 1, 0],
[-1, -1, 0],
[1, -1, 0],
[2, -1, 0],
[4, -1, 0],
[4, 1, 0],
[2, -1, 0],
[4, 1, 0],
[2, 1, 0]
], "f"))
def initialize(self):
vertex_shader = shaders.compileShader("""#version 330
in vec3 vPosition;
uniform mat4 MVP;
void main()
{
gl_Position = MVP * vec4(vPosition, 1.0);
}""", gl.GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader("""#version 330
void main()
{
gl_FragColor = vec4( 0, 1, 1, 1 );
}""", gl.GL_FRAGMENT_SHADER)
self._shader = shaders.compileProgram(vertex_shader, fragment_shader)
self._position_handle = 0
gl.glBindAttribLocation(self._shader, self._position_handle, b"vPosition")
self._mvp_handle = gl.glGetUniformLocation(self._shader, b"MVP")
self._vertex_vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._vertex_vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, len(self._model._vertex_buffer), self._model._vertex_buffer, gl.GL_STATIC_DRAW)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
self._index_vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._index_vbo)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, len(self._model._index_buffer), self._model._index_buffer, gl.GL_STATIC_DRAW)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, 0)
def initialize_program():
global offsetUniform, perspectiveMatrixUnif, SCREENSIZE
"""
Instead of calling OpenGL's shader compilation functions directly
(glShaderSource, glCompileShader, etc), we use PyOpenGL's wrapper
functions, which are much simpler to use.
"""
global theProgram
theProgram = compileProgram(
compileShader(strVertexShader, GL.GL_VERTEX_SHADER),
compileShader(strFragmentShader, GL.GL_FRAGMENT_SHADER)
)
offsetUniform = GL.glGetUniformLocation(theProgram, 'offset')
perspectiveMatrixUnif = GL.glGetUniformLocation(theProgram, 'perspectiveMatrix')
fFrustumScale = 1.0
fzNear = 0.5
fzFar = 3.0
w,h = SCREENSIZE
theMatrix = N.zeros(16, dtype=N.float32)
theMatrix[0] = fFrustumScale*float(h)/float(w)
theMatrix[5] = fFrustumScale
theMatrix[10] = (fzFar + fzNear) / (fzNear - fzFar)
theMatrix[14] = (2 * fzFar * fzNear) / (fzNear - fzFar)
theMatrix[11] = -1.0
GL.glUseProgram(theProgram)
GL.glUniformMatrix4fv(perspectiveMatrixUnif, 1, GL.GL_FALSE, theMatrix)
GL.glUseProgram(0);
def OnInit(self):
VERTEX_SHADER = shaders.compileShader("""#version 120
void main() {
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}""", GL_VERTEX_SHADER)
FRAGMENT_SHADER = shaders.compileShader("""#version 120
void main(){
gl_FragColor = vec4(0,1,1,1);
}""",GL_FRAGMENT_SHADER)
self.shader = shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER)
self.vbo = vbo.VBO(
array([
[ 0, 2, 0],
[-1,-3, 0],
[ 1,-1, 0],
[ 2,-1, 0],
[ 4,-1, 0],
[ 4, 1, 0],
[ 2,-1, 0],
[ 4, 1, 0],
[ 2, 1, 0]
],'f')
)
def initializeShaders():
global theShaders, positionAttrib
theShaders = compileProgram(
compileShader(strVertexShader, GL_VERTEX_SHADER),
compileShader(strFragmentShader, GL_FRAGMENT_SHADER)
)
positionAttrib = glGetAttribLocation(theShaders, "position")
def __init__(self, size = 0.2): self.size = size self.vertexShader = shaders.compileShader(VERTEX_SOURCE, GL_VERTEX_SHADER) self.fragmentShader = shaders.compileShader(FRAGMENT_SOURCE, GL_FRAGMENT_SHADER) self.shader = shaders.compileProgram(self.vertexShader,self.fragmentShader) self.vao = glGenVertexArrays(1) glBindVertexArray(self.vao)
def __init__(self, resolution = (400,400), maxfps = 1):
#Here we set everything up initially.
#This will only be executed once.
#Variables with the self-prefix are variables that can be used by other functions
#within this particular class. I don't know if they span across other classes but
#that would be kinda wierd, no?
pg.init()
self.resolution, self.maxfps = resolution, maxfps
pg.display.set_mode(self.resolution, pg.OPENGL|pg.DOUBLEBUF)
self.running = True #Is the program running?
#We setup the shader. I think you later compile the shader in a
#seperate file so this won't be so cluttered
try:
with open("VERTEX_SHADER.txt", 'r') as fileInput: ##LOADING VERTEX_SHADER-specs FROM EXTERNAL FILE
VERTEX_SHADER = GLshaders.compileShader(fileInput.read(), GL.GL_VERTEX_SHADER)
del fileInput #Cleanup!
except(GL.GLError, RuntimeError) as err:
print("Shader compile error (VERTEX_SHADER)", err)
try:
with open("FRAGMENT_SHADER.txt", 'r') as fileInput: ##LOADING VERTEX_SHADER-specs FROM EXTERNAL FILE
FRAGMENT_SHADER = GLshaders.compileShader(fileInput.read(), GL.GL_FRAGMENT_SHADER)
del fileInput #Cleanup!
except(GL.GLError, RuntimeError) as err:
print("Shader compile error (FRAGMENT_SHADER)", err)
#The shader is compiled. Remember! This only happens once!
#So no more changes after this point!
self.GLEngineShader = GLshaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)
def initializeShaders():
global theShaders, positionAttrib, uvAttrib, \
modelUnif, viewUnif, projUnif, \
samplerUnif, scaleuvUnif
theShaders = compileProgram(
compileShader(strVertexShader, GL_VERTEX_SHADER),
compileShader(strFragmentShader, GL_FRAGMENT_SHADER)
)
positionAttrib = glGetAttribLocation(theShaders, "position")
uvAttrib = glGetAttribLocation(theShaders, "uv")
modelUnif = glGetUniformLocation(theShaders, "model")
viewUnif = glGetUniformLocation(theShaders, "view")
projUnif = glGetUniformLocation(theShaders, "projection")
samplerUnif = glGetUniformLocation(theShaders, "sampler")
scaleuvUnif = glGetUniformLocation(theShaders, "scaleuv")
check("positionAttrib", positionAttrib)
check("uvAttrib", uvAttrib)
check("modelUnif", modelUnif)
check("viewUnif", viewUnif)
check("projUnif", projUnif)
check("samplerUnif", samplerUnif)
check("scaleuvUnif", scaleuvUnif)
def initializeProgram(self):
shaderList = []
shaderList.append(compileShader(VERTEX_SHADER, GL.GL_VERTEX_SHADER))
shaderList.append(compileShader(FRAGMENT_SHADER, GL.GL_FRAGMENT_SHADER))
self.theProgram = compileProgram(*shaderList)
self.offsetUniform = GL.glGetUniformLocation(self.theProgram, "offset")
self.perspectiveMatrixUnif = GL.glGetUniformLocation(self.theProgram, "perspectiveMatrix")
fFrustumScale = 1.0
fzNear = 0.5
fzFar = 3.0
theMatrix = [0.0 for i in range(16)]
theMatrix[0] = fFrustumScale
theMatrix[5] = fFrustumScale
theMatrix[10] = (fzFar+fzNear)/(fzNear-fzFar)
theMatrix[14] = (2*fzFar*fzNear)/(fzNear-fzFar)
theMatrix[11] = -1.0
GL.glUseProgram(self.theProgram)
GL.glUniformMatrix4fv(self.perspectiveMatrixUnif,1,GL.GL_FALSE,theMatrix)
GL.glUseProgram(0)
def OnInit( self ):
VERTEX_SHADER = shaders.compileShader("""#version 120
void main() {
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}""", GL_VERTEX_SHADER)
FRAGMENT_SHADER = shaders.compileShader("""#version 120
uniform vec4 color;
void main() {
gl_FragColor = color;
}""", GL_FRAGMENT_SHADER)
self.shader = shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER)
self.vbo = vbo.VBO(
array( [
[ -2,-2, 0 ],
[ 2,-2, 0 ],
[ 2, 2, 0 ],
[ -2,-2, 0 ],
[ 2, 2, 0 ],
[ -2, 2, 0 ],
],'f')
)
def initializeGL(self):
vertexShader = shaders.compileShader(vertexShaderSource, GL_VERTEX_SHADER)
fragmentShader = shaders.compileShader(fragmentShaderSource, GL_FRAGMENT_SHADER)
self.__shaderProgram = shaders.compileProgram(vertexShader, fragmentShader)
vertices = ffi.new("float[]",
[0.5, 0.5, 0.0,
0.5, -0.5, 0.0,
-0.5, -0.5, 0.0,
-0.5, 0.5, 0.0])
indices = ffi.new("unsigned int[]",
[0, 1, 3, 1, 2, 3])
self.__vao = glGenVertexArrays(1)
vbo = glGenBuffers(1)
ebo = glGenBuffers(1)
glBindVertexArray(self.__vao)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
glBufferData(GL_ARRAY_BUFFER, ffi.sizeof(vertices), cffiToCtypeArray(vertices, ctypes.c_float), GL_STATIC_DRAW)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ffi.sizeof(indices), cffiToCtypeArray(indices, ctypes.c_uint), GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * ffi.sizeof("float"), None)
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(0)
def shades():
"""Set up the Vertex and Fragment Shaders."""
global shaderp
vertex_shader = shaders.compileShader("""#version 330 core
layout (location = 0) in vec3 position;
layout (location = 1) in vec3 normal;
layout (location = 2) in vec3 colour;
layout (location = 3) in vec2 texcord;
uniform mat4 projectmatrix;
uniform mat4 viewmatrix;
uniform mat4 modelmatrix;
out vec3 ourcolour;
out vec2 ourtex;
void main(){
gl_Position = projectmatrix * viewmatrix * modelmatrix * vec4(position, 1.0);
ourcolour = colour;
ourtex = texcord;
}""", GL.GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader("""#version 330 core
in vec3 ourcolour;
in vec2 ourtex;
out vec4 colour;
uniform sampler2D tex;
void main(){
colour = texture(tex, ourtex) * vec4(ourcolour, 1.0);
}""", GL.GL_FRAGMENT_SHADER)
shaderp = shaders.compileProgram(vertex_shader, fragment_shader)
GL.glUseProgram(shaderp)
def __init__(self, vertexProgram, fragmentProgram):
super(GLShader, self).__init__()
self._vertexString = vertexProgram
self._fragmentString = fragmentProgram
try:
vertexShader = shaders.compileShader(vertexProgram, GL_VERTEX_SHADER)
fragmentShader = shaders.compileShader(fragmentProgram, GL_FRAGMENT_SHADER)
#shader.compileProgram tries to return the shader program as a overloaded int. But the return value of a shader does not always fit in a int (needs to be a long). So we do raw OpenGL calls.
# This is to ensure that this works on intel GPU's
# self._program = shaders.compileProgram(self._vertexProgram, self._fragmentProgram)
self._program = glCreateProgram()
glAttachShader(self._program, vertexShader)
glAttachShader(self._program, fragmentShader)
glLinkProgram(self._program)
# Validation has to occur *after* linking
glValidateProgram(self._program)
if glGetProgramiv(self._program, GL_VALIDATE_STATUS) == GL_FALSE:
raise RuntimeError("Validation failure: %s"%(glGetProgramInfoLog(self._program)))
if glGetProgramiv(self._program, GL_LINK_STATUS) == GL_FALSE:
raise RuntimeError("Link failure: %s" % (glGetProgramInfoLog(self._program)))
glDeleteShader(vertexShader)
glDeleteShader(fragmentShader)
except RuntimeError, e:
print str(e)
self._program = None
def shaderFromFile(self, shaderType, shaderFile):
"""read shader from file and compile it"""
shaderSrc = ''
with open(shaderFile) as sf:
shaderSrc = sf.read()
return shaders.compileShader(shaderSrc, shaderType)
def gl_realize(self, area):
area.make_current()
if (area.get_error() is not None):
return
version = gl.glGetString(gl.GL_VERSION).decode().split(" ")[0]
if version < "3.3":
self.errorlabel.set_text(
_("Warning: OpenGL {} is unsupported. Plots supports OpenGL 3.3 or greater."
).format(version))
self.errorbar.props.revealed = True
self.vertex_shader = shaders.compileShader(
self.vertex_template.render(), gl.GL_VERTEX_SHADER)
self.update_shader()
self.vbo = vbo.VBO(np.array([[-1, -1, 0], [-1, 1, 0], [1, 1, 0],
[-1, -1, 0], [1, -1, 0], [1, 1, 0]], 'f'),
usage="GL_STATIC_DRAW_ARB")
self.vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(self.vao)
self.vbo.bind()
self.vbo.copy_data()
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE,
3 * self.vbo.data.itemsize, self.vbo)
gl.glEnableVertexAttribArray(0)
self.vbo.unbind()
gl.glBindVertexArray(0)
self.text_renderer = TextRenderer()
def get_shader(src, shader_type):
try:
with open(src) as file:
src_text = file.read()
return sh.compileShader(src_text, shader_type)
except Exception as exception:
print('Cannot open file {0}'.format(src))
def loadShader(filename, type):
shaderSource = ""
with open(filename) as f:
shaderSource = "".join(f.readlines())
shaderID = shaders.compileShader(shaderSource, type)
return shaderID
def __compileShaders(self, path_vertex: str, path_fragment: str):
"""
Read and compile .glsl shaders into a shader program
:param path_vertex: Path to vertex shader
:param path_fragment: Path to fragment shader
:return:
"""
with open(path_vertex, "r") as source:
vertex = compileShader(source.read(), GL_VERTEX_SHADER)
with open(path_fragment, "r") as source:
fragment = compileShader(source.read(), GL_FRAGMENT_SHADER)
shader_program = compileProgram(vertex, fragment)
return shader_program
def setShaders(self, vertexShader, fragShader):
if vertexShader is not None or fragShader is not None:
self.active_shader = compileProgram(compileShader(vertexShader, GL_VERTEX_SHADER), compileShader(fragShader, GL_FRAGMENT_SHADER), validate=False)
else:
self.active_shader = None
glUseProgram(self.active_shader)
def main():
if not glfw.init():
return
window = glfw.create_window(1280, 760, 'Shadings', None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glClearColor(0.2, 0.3, 0.2, 1.0)
glEnable(GL_DEPTH_TEST)
glCullFace(GL_BACK)
shader = shaders.compileProgram(shaders.compileShader(vertex_shader, GL_VERTEX_SHADER), shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER))
shape = Shape('cylinder', PhongMaterial(shader, 'flat', .0, .5, .5, 0.05)) # valores default iniciais
key_flags = [False, False]
while not glfw.window_should_close(window):
glfw.poll_events()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
get_input(window, shape, key_flags)
shape.render()
glfw.swap_buffers(window)
glfw.terminate()
def shader(self):
if self.compiled is None:
try:
self.compiled = shaders.compileShader(self.code, self.shaderType)
except RuntimeError as exc:
## Format compile errors a bit more nicely
if len(exc.args) == 3:
err, code, typ = exc.args
if not err.startswith('Shader compile failure'):
raise
code = code[0].split('\n')
err, c, msgs = err.partition(':')
err = err + '\n'
msgs = msgs.split('\n')
errNums = [()] * len(code)
for i, msg in enumerate(msgs):
msg = msg.strip()
if msg == '':
continue
m = re.match(r'(\d+\:)?\d+\((\d+)\)', msg)
if m is not None:
line = int(m.groups()[1])
errNums[line-1] = errNums[line-1] + (str(i+1),)
#code[line-1] = '%d\t%s' % (i+1, code[line-1])
err = err + "%d %s\n" % (i+1, msg)
errNums = [','.join(n) for n in errNums]
maxlen = max(map(len, errNums))
code = [errNums[i] + " "*(maxlen-len(errNums[i])) + line for i, line in enumerate(code)]
err = err + '\n'.join(code)
raise Exception(err)
else:
raise
return self.compiled
def init():
global _shader, _locations, _pdata
if _shader: return
# Generate shaders
vertex_shader = shaders.compileShader(_vertex_shader_source, GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader(_fragment_shader_source, GL_FRAGMENT_SHADER)
_shader = shaders.compileProgram(vertex_shader, fragment_shader)
_locations = {
"p": glGetAttribLocation(_shader, "p"),
"rect": glGetUniformLocation(_shader, "rect"),
"viewsize": glGetUniformLocation(_shader, "viewsize"),
"angle": glGetUniformLocation(_shader, "angle"),
"alpha": glGetUniformLocation(_shader, "alpha"),
"texture": glGetUniformLocation(_shader, "texture"),
}
_pdata = [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0]
def loadShaders(self, vertexShader, fragmentShader):
vertexShaderFile = os.path.join(abPath, vertexShader)
fragmentShaderFile = os.path.join(abPath, fragmentShader)
vertexShaderSource = ''
with open(vertexShaderFile) as vs:
vertexShaderSource = vs.read()
fragmentShaderSource = ''
with open(fragmentShaderFile) as fg:
fragmentShaderSource = fg.read()
vertexShader = shaders.compileShader(vertexShaderSource,
GL_VERTEX_SHADER)
fragmentShader = shaders.compileShader(fragmentShaderSource,
GL_FRAGMENT_SHADER)
shaderProgram = shaders.compileProgram(vertexShader, fragmentShader)
return shaderProgram
def __init__(self,vs,fs,uniforms,**kwds):
vertexShaderHandle = compileShader(vs,GL_VERTEX_SHADER)
fragmentShaderHandle = compileShader(fs,GL_FRAGMENT_SHADER)
self.program = mrvCompileProgramPreValidate(vertexShaderHandle,fragmentShaderHandle)
try:
self.vertex = glGetAttribLocation(self.program, "vertex")
except:
self.program = None
if not self.program: return
self.uniforms = {}
for key in uniforms:
self.uniforms[key] = glGetUniformLocation(self.program,key)
self.context = SharedContextState
self.preValidateConfig()
mrvCompileProgramPostValidate(self.program,vertexShaderHandle,fragmentShaderHandle)
super(Shader,self).__init__(**kwds)
def __init__(self, size=(1200, 900), connected=False):
self.size = size
self.connected = connected
GLUT.glutInit([])
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGB
| GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(*size)
GLUT.glutInitWindowPosition(0, 0)
GLUT.glutCreateWindow("Render")
self.vertex_shader = shaders.compileShader(PLAIN_VERTEX_SHADER,
GL.GL_VERTEX_SHADER)
self.fragment_shader = shaders.compileShader(CUBEMAP_FRAGMENT_SHADER,
GL.GL_FRAGMENT_SHADER)
def main():
glutInit(sys.argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
glutInitWindowSize(800, 800)
glutCreateWindow('fluid')
FRAGMENT_SHADER = shaders.compileShader(
"""#version 120
void main() {
gl_FragColor = vec4( 0, 1, 0, 1 );
}""", GL_FRAGMENT_SHADER
)
shader = shaders.compileProgram(FRAGMENT_SHADER)
shaders.glUseProgram(shader)
glutDisplayFunc(display)
glutIdleFunc(display)
glMatrixMode(GL_PROJECTION)
gluPerspective(40.0, 1.0, 1.0, 200.0)
glMatrixMode(GL_MODELVIEW)
gluLookAt(0, 0, 180,
0, 0, 0,
0, 1, 0)
glPushMatrix()
glutMainLoop()
return
def __init__(self, vertexShaderPath: str, fragmentShaderPath: str):
# Get the source code from the two files.
vertexShaderSource = self.readShaderFromFile(vertexShaderPath)
fragmentShaderSource = self.readShaderFromFile(fragmentShaderPath)
# Compile the shaders.
vertexShader = shaders.compileShader(vertexShaderSource,
GL_VERTEX_SHADER)
fragmentShader = shaders.compileShader(fragmentShaderSource,
GL_FRAGMENT_SHADER)
# Create the program.
self.shader = shaders.compileProgram(vertexShader, fragmentShader)
# Use shader.
gl.glUseProgram(self.shader)
def __init__(self):
pygame.init()
self.resolution = 800, 600
pygame.display.gl_set_attribute(pygame.GL_CONTEXT_PROFILE_MASK,
pygame.GL_CONTEXT_PROFILE_CORE)
pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MAJOR_VERSION, 3)
pygame.display.gl_set_attribute(pygame.GL_CONTEXT_MINOR_VERSION, 3)
pygame.display.set_mode(self.resolution, DOUBLEBUF | OPENGL)
pygame.display.set_caption('PyShadeToy')
# Shaders
self.vertex_shader = shaders.compileShader(VERTEX_SHADER,
GL_VERTEX_SHADER)
self.fragment_shader = shaders.compileShader(FRAGMENT_SHADER,
GL_FRAGMENT_SHADER)
self.shader = shaders.compileProgram(self.vertex_shader,
self.fragment_shader)
# Uniform variables
self.uni_mouse = glGetUniformLocation(self.shader, 'iMouse')
self.uni_ticks = glGetUniformLocation(self.shader, 'iTime')
glUseProgram(
self.shader
) # Shader program needs to be active if you send uniform variables
# Resolution doesn't change. Send it once
self.uni_resolution = glGetUniformLocation(self.shader, 'iResolution')
glUniform2f(self.uni_resolution, *self.resolution)
# Create the fullscreen quad for drawing
self.vertices = array(
[-1.0, -1.0, 0.0, 1.0, -1.0, 0.0, 1.0, 1.0, 0.0, -1.0, 1.0, 0.0],
dtype='float32')
# Generate VAO
self.vao = glGenVertexArrays(1)
glBindVertexArray(self.vao)
# Generate VBO which is stored in the VAO state
self.vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
glBufferData(GL_ARRAY_BUFFER, self.vertices, GL_STATIC_DRAW)
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
self.clock = pygame.time.Clock()
def initialize():
global VERTEX_SHADER
global FRAGMENT_SHADER
global shaderProgram
global VAO
# compile shaders and program
vertexShader = shaders.compileShader(VERTEX_SHADER, GL_VERTEX_SHADER)
fragmentShader = shaders.compileShader(FRAGMENT_SHADER, GL_FRAGMENT_SHADER)
shaderProgram = shaders.compileProgram(vertexShader, fragmentShader)
# triangle position and color
"""
vertexData = numpy.array([0.0, 0.5, 0.0, 1, #bovenste punt: x,y, geenideez?, ydelendoorditw?
0.5, -0.366, 0.0, 1.0,#rechtsonder: x,
-0.5, -0.366, 0.0, 1.0,#linksonder
1.0, 0.0, 0.0, 1.0,#kleur1? laatste is opacity
0.0, 1.0, 0.0, 1.0,#kleur2?
0.0, 0.0, 1.0, 1.0, ],#kleur3?
dtype=numpy.float32)
"""
vertexData = numpy.array(
[
-0.5, 0.366, 0.0, 1, 0.5, 0.366, 0.0, 1.0, 0.0, -0.5, 0.0, 1.0,
0.5, 0.7, 1.0
], #kleur3?
dtype=numpy.float32)
# create VAO
VAO = glGenVertexArrays(1)
glBindVertexArray(VAO)
# create VBO
VBO = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
glBufferData(GL_ARRAY_BUFFER, vertexData.nbytes, vertexData,
GL_STATIC_DRAW)
# enable array and set up data
glEnableVertexAttribArray(0)
glEnableVertexAttribArray(1)
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, None)
# the last parameter is a pointer
# python donot have pointer, have to using ctypes
glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(48))
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(0)
def OnInit(self):
VERTEX_SHADER = shaders.compileShader(
open("vert.glsl", "r").read(), GL_VERTEX_SHADER)
FRAGMENT_SHADER = shaders.compileShader(
open("frag.glsl", "r").read(), GL_FRAGMENT_SHADER)
self.shader = shaders.compileProgram(VERTEX_SHADER, FRAGMENT_SHADER)
self.vbo = vbo.VBO(
array([
[0, 1, 0],
[-1, -1, 0],
[1, -1, 0],
[2, -1, 0],
[4, -1, 0],
[4, 1, 0],
[2, -1, 0],
[4, 1, 0],
[2, 1, 0],
], 'f'))
self.UNIFORM_LOCATIONS = {
'viewport':
glGetUniformLocation(self.shader, 'viewport'),
'pointSizeThreshold':
glGetUniformLocation(self.shader, 'pointSizeThreshold'),
'MaxPixelSize':
glGetUniformLocation(self.shader, 'MaxPixelSize'),
'ConstantRadius':
glGetUniformLocation(self.shader, 'ConstantRadius'),
}
self.width = 512
self.height = 512
# glViewport( 0, 0, self.width, self.height )
glClearColor(0.0, 0.0, 0.0,
0.0) # This Will Clear The Background Color To Black
glClearDepth(1.0) # Enables Clearing Of The Depth Buffer
glDepthFunc(GL_LESS) # The Type Of Depth Test To Do
glEnable(GL_DEPTH_TEST) # Enables Depth Testing
glShadeModel(GL_SMOOTH) # Enables Smooth Color Shading
glMatrixMode(GL_PROJECTION)
glMatrixMode(GL_MODELVIEW)
def drawLines(box1):
global VERTEXT_SHADER
global FRAGMEN_SHADER_2
global shaderProgram
vertexshader = shaders.compileShader(VERTEX_SHADER, GL_VERTEX_SHADER)
fragmentshader = shaders.compileShader(FRAGMENT_SHADER_2, GL_FRAGMENT_SHADER)
shaderProgram = shaders.compileProgram(vertexshader, fragmentshader)
pointList=box1.pointsAsNumbersGivenPoints( box1.getLinePoints())
triangles = np.array(pointList, dtype=np.float32)
VBO = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
glBufferData(GL_ARRAY_BUFFER, triangles.nbytes, triangles, GL_STATIC_DRAW)
position = glGetAttribLocation(shaderProgram, 'position')
glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(position)
glUseProgram(shaderProgram)
# glClearColor(0, 0, 0, 1)
# glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
#
#
# glEnable(GL_DEPTH_TEST)
#glDepthFunc(GL_LESS)
glDrawArrays(GL_LINES, 0,len(pointList))
glUseProgram(0)
glutSwapBuffers()
def __init__(
self,
name,
vertex_shader_path,
fragment_shader_path,
excluded_attributes=[],
excluded_uniforms=[],
):
self.name = name
with open(vertex_shader_path, "r") as vertex_file:
vertex_shader_text = vertex_file.read()
vertex_shader = shaders.compileShader(vertex_shader_text,
gl.GL_VERTEX_SHADER)
with open(fragment_shader_path, "r") as fragment_file:
fragment_shader_text = fragment_file.read()
fragment_shader = shaders.compileShader(fragment_shader_text,
gl.GL_FRAGMENT_SHADER)
self.program = shaders.compileProgram(vertex_shader, fragment_shader)
count_attributes = gl.glGetProgramiv(self.program,
gl.GL_ACTIVE_ATTRIBUTES)
self.attributes = {}
for i in range(count_attributes):
bufsize = 256
length = (ctypes.c_int * 1)()
size = (ctypes.c_int * 1)()
type = (ctypes.c_uint * 1)()
name = ctypes.create_string_buffer(bufsize)
gl.glGetActiveAttrib(self.program, i, bufsize, length, size, type,
name)
name = name[:length[0]].decode("utf-8")
if name in excluded_attributes:
continue
attribute_location = gl.glGetAttribLocation(self.program, name)
self.attributes[name] = attribute_location
count_uniforms = gl.glGetProgramiv(self.program, gl.GL_ACTIVE_UNIFORMS)
self.uniforms = {}
for i in range(count_uniforms):
name, size, type = gl.glGetActiveUniform(self.program, i)
name = name.decode("utf-8")
if name in excluded_uniforms:
continue
uniform_location = gl.glGetUniformLocation(self.program, name)
self.uniforms[name] = uniform_location
def loadShaders(self):
currentFile = inspect.getframeinfo(inspect.currentframe()).filename
abPath = os.path.dirname(os.path.abspath(currentFile))
vertexShaderFile = os.path.join(abPath, '3.basic.vs')
fragmentShaderFile = os.path.join(abPath, '3.basic.frag')
vertexShaderSource = ''
with open(vertexShaderFile) as vs:
vertexShaderSource = vs.read()
fragmentShaderSource = ''
with open(fragmentShaderFile) as fg:
fragmentShaderSource = fg.read()
vertexShader = shaders.compileShader(vertexShaderSource,
GL_VERTEX_SHADER)
fragmentShader = shaders.compileShader(fragmentShaderSource,
GL_FRAGMENT_SHADER)
return vertexShader, fragmentShader
def init():
global shaderProgram
global vao
global vbo
glClearColor(0.7, 0.7, 0.7, 1)
vertex_code = readShaderFile('map.vp')
fragment_code = readShaderFile('map.fp')
# compile shaders and program
vertexShader = shaders.compileShader(vertex_code, GL_VERTEX_SHADER)
fragmentShader = shaders.compileShader(fragment_code, GL_FRAGMENT_SHADER)
shaderProgram = shaders.compileProgram(vertexShader, fragmentShader)
# Create and bind the Vertex Array Object
vao = GLuint(0)
glGenVertexArrays(1, vao)
glBindVertexArray(vao)
# Create and bind the Vertex Buffer Object
vertices = np.array(
[[0, 0, 0, 0, 0, 1], [-1, -1, 0, 1, 1, 0], [1, -1, 0, 0, 1, 0]],
dtype='f')
vet = []
square(-1.0, 0.5, 2.0, 1.5, vet) # streets
blocks(vet)
home(0.65, 0.34, 0.1, 0.1, vet)
vertices = np.array(vet, dtype='f')
vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
glBufferData(GL_ARRAY_BUFFER, vertices, GL_STATIC_DRAW)
glVertexAttribPointer(
0, 3, GL_FLOAT, False, 3 * sizeof(GLfloat),
ctypes.c_void_p(0)) # first 0 is the location in shader
glEnableVertexAttribArray(0)
# 0=location do atributo, tem que ativar todos os atributos inicialmente sao desabilitados por padrao
# Note that this is allowed, the call to glVertexAttribPointer registered VBO
# as the currently bound vertex buffer object so afterwards we can safely unbind
glBindBuffer(GL_ARRAY_BUFFER, 0)
# Unbind VAO (it's always a good thing to unbind any buffer/array to prevent strange bugs)
glBindVertexArray(0)
def plotpoints():
glClear(GL_COLOR_BUFFER_BIT)
vertices = [
0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0,
0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 2.0, 0.0, 0.0, 1.0,
1.0, 0.0, 2.0, 1.0, 0.0, 2.0, 0.0, 0.0
]
indices = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
vertices = np.array(vertices, dtype=np.float32)
indices = np.array(indices, dtype=np.uint32)
shader = compileProgram(compileShader(vertex_src, GL_VERTEX_SHADER),
compileShader(fragment_src, GL_FRAGMENT_SHADER))
# Vertex Buffer Object
VBO = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL_STATIC_DRAW)
# Element Buffer Object
EBO = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices,
GL_STATIC_DRAW)
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 12, ctypes.c_void_p(0))
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 12, ctypes.c_void_p(12))
glUseProgram(shader)
glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None)
# Draw points
glPointSize(6.0)
glBegin(GL_POINTS)
for i in range(0, len(vertices), 3):
glVertex3f(vertices[i], vertices[i + 1], vertices[i + 2])
glEnd()
glutSwapBuffers()
def compileProgram(self, vertCode, fragCode):
"""
A compileProgram version that ensures we don't recompile unnecessarily.
"""
program = self.__cache.get((vertCode, fragCode), None)
if program:
return program
# skip shader validation step on linux
validate = 'linux' not in sys.platform.lower()
program = compileProgram(
shaders.compileShader(vertCode, GL_VERTEX_SHADER),
shaders.compileShader(fragCode, GL_FRAGMENT_SHADER),
validate=validate
)
self.__cache[(vertCode, fragCode)] = program
return program
def setupLine():
global lineShader
VERTEX_SHADER = shaders.compileShader(
"""#version 120
varying vec4 vColour;
void main() {
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
vColour = gl_Color;
}""", GL_VERTEX_SHADER)
FRAGMENT_SHADER = shaders.compileShader("""#version 120
varying vec4 vColour;
void main() {
gl_FragColor = vColour;
}""", GL_FRAGMENT_SHADER)
lineShader = shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER)
def prepareToRender(self):
vertices = np.array([-0.6, -0.4, 0.0,
0.6, -0.4, 0.0,
0, 0.6, 0.0],
dtype=np.float32)
self.numberOfVertices = np.size(vertices) // floatsPerVertex
self.vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(self.vao)
#initialize shaders
with open(os.path.join(pwd, 'shaders', 'triangle.vert'), 'r') as f:
vs = shaders.compileShader(f.read() , gl.GL_VERTEX_SHADER)
with open(os.path.join(pwd, 'shaders', 'triangle.frag'), 'r') as f:
fs = shaders.compileShader(f.read(), gl.GL_FRAGMENT_SHADER)
self.shader = shaders.compileProgram(vs,fs)
self.mvpMatrixLoc = gl.glGetUniformLocation(self.shader,"mvpMatrix")
#send the modelspace data to the GPU
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
position = gl.glGetAttribLocation(self.shader, 'position')
gl.glEnableVertexAttribArray(position)
gl.glVertexAttribPointer(position,
floatsPerVertex,
gl.GL_FLOAT,
False,
0,
ctypes.c_void_p(0))
gl.glBufferData(gl.GL_ARRAY_BUFFER,
glfloat_size * np.size(vertices),
vertices,
gl.GL_STATIC_DRAW)
# reset VAO/VBO to default
gl.glBindVertexArray(0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER,0)
def __loadShader(fileName, type):
with open(fileName) as file:
shaderSource = file.read()
shaderID = compileShader(shaderSource, type)
if glGetShaderiv(shaderID, GL_COMPILE_STATUS) == GL_FALSE:
print(glGetShaderInfoLog(shaderID, 500))
print("Error: Could not compile shader", file=sys.stderr)
return shaderID
def paintGL(self):
program = compileProgram(compileShader(vertex_shaded, GL_VERTEX_SHADER),
compileShader(fragment_shaded, GL_FRAGMENT_SHADER))
glLinkProgram(program)
vertex_pos_model_space_ID = glGetAttribLocation(program, 'vertex_pos_model_space')
vertex_normal_model_space_ID = glGetAttribLocation(program, 'vertex_normal_model_space')
MVP_UID = glGetUniformLocation(program, 'MVP')
M_UID = glGetUniformLocation(program, 'M')
V_UID = glGetUniformLocation(program, 'V')
color_UID = glGetUniformLocation(program, 'color')
light_intensity_UID = glGetUniformLocation(program, 'light_intensity')
light_pos_world_space_UID = glGetUniformLocation(program, 'light_pos_world_space')
glEnable(GL_CULL_FACE)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LESS)
glClearColor(0.2, 0.3, 0.35, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
for data, indices, mesh, color in self.to_render:
try:
glUseProgram(program)
MVP = mmul(self.projection, self.view, mesh.transform.get_matrix())
glUniformMatrix4fv(MVP_UID, 1, GL_FALSE, MVP)
glUniformMatrix4fv(M_UID, 1, GL_FALSE, mesh.transform.get_matrix())
glUniformMatrix4fv(V_UID, 1, GL_FALSE, self.view)
glUniform1f(light_intensity_UID, np.single(30 * self.light_intensity))
glUniform3f(color_UID, *color)
glUniform3f(light_pos_world_space_UID, *np.array(self.light_pos, 'f'))
data.bind()
indices.bind()
try:
glEnableVertexAttribArray(vertex_pos_model_space_ID)
glVertexAttribPointer(vertex_pos_model_space_ID, 3, GL_FLOAT, GL_FALSE, 12, data)
glEnableVertexAttribArray(vertex_normal_model_space_ID)
glVertexAttribPointer(vertex_normal_model_space_ID, 3, GL_FLOAT, GL_FALSE, 12, data)
glDrawElements(GL_TRIANGLES, len(indices),
GL_UNSIGNED_INT, indices)
finally:
indices.unbind()
data.unbind()
glDisableVertexAttribArray(vertex_pos_model_space_ID)
glDisableVertexAttribArray(vertex_normal_model_space_ID)
finally:
glUseProgram(0)
def update_shader(self):
exprs = []
for f in self.formulae:
body, expr = f.expr.to_glsl()
if expr:
exprs.append((body, expr))
try:
fragment_shader = shaders.compileShader(
self.fragment_template.render(formulae=exprs),
GL_FRAGMENT_SHADER)
except shaders.ShaderCompilationError as e:
print(e.args[0])
fragment_shader = shaders.compileShader(
self.fragment_template.render(formulae=[]), GL_FRAGMENT_SHADER)
#print(e.args[1][0].decode())
self.shader = shaders.compileProgram(self.vertex_shader,
fragment_shader)
def make_shader_program(vertex_filename, fragment_filename):
def read_file(filename):
with open(filename) as fp:
return fp.readlines()
try:
shader_program = compileProgram(
compileShader(read_file(vertex_filename), gl.GL_VERTEX_SHADER),
compileShader(read_file(fragment_filename), gl.GL_FRAGMENT_SHADER))
except RuntimeError as exc:
args = list(exc.args)
sys.stderr.write(''.join(str(a) for a in args[:-2]))
# sys.stderr.write(''.join(str(a) for a in args[-2]))
# sys.stderr.write(args[-1])
sys.exit(1)
return shader_program
def make_program(vertex_code_file,
fragment_code_file,
geometry_code_file=None):
vertex_code = (SHADERS_PATH / vertex_code_file).read_text()
fragment_code = (SHADERS_PATH / fragment_code_file).read_text()
if geometry_code_file is not None:
geometry_code = (SHADERS_PATH / geometry_code_file).read_text()
return shaders.compileProgram(
shaders.compileShader(vertex_code, gl.GL_VERTEX_SHADER),
shaders.compileShader(fragment_code, gl.GL_FRAGMENT_SHADER),
shaders.compileShader(geometry_code, gl.GL_GEOMETRY_SHADER))
return shaders.compileProgram(
shaders.compileShader(vertex_code, gl.GL_VERTEX_SHADER),
shaders.compileShader(fragment_code, gl.GL_FRAGMENT_SHADER))
