def loadShader(self):
self.shader = Shader()
self.shader.initShaderFromGLSL(["glsl/tu02/vertex.glsl"],
["glsl/tu02/fragment.glsl"])
self.MVP_ID = glGetUniformLocation(self.shader.program, "MVP")
self.OFFSET_ID = glGetUniformLocation(self.shader.program, "OFFSET")
self.Texture_ID = glGetUniformLocation(self.shader.program,
"myTextureSampler")
def loadShader(self):
self.shader = Shader()
self.shader.initShaderFromGLSL(
["glsl/tu09/TextVertexShader.vertexshader.glsl"],
["glsl/tu09/TextVertexShader.fragmentshader.glsl"])
self.HALFSCREENSIZE_ID = glGetUniformLocation(self.shader.program,
"HALFSCREENSIZE")
self.Texture_ID = glGetUniformLocation(self.shader.program,
"myTextureSampler")
def loadShader(self):
self.shader = Shader()
self.shader.initShaderFromGLSL(
["glsl/tu07/StandardShading.vertexshader.glsl"], ["glsl/tu07/StandardShading.fragmentshader.glsl"])
self.MVP_ID = glGetUniformLocation(self.shader.program, "MVP")
self.ModelMatrix_ID = glGetUniformLocation(self.shader.program, "M")
self.ViewMatrix_ID = glGetUniformLocation(self.shader.program, "V")
self.Texture_ID = glGetUniformLocation(self.shader.program, "myTextureSampler")
self.Light_ID = glGetUniformLocation(self.shader.program, "LightPosition_worldspace")
self.OFFSET_ID = glGetUniformLocation(self.shader.program, "LOCATION_OFFSET")
def init_context(self):
self.context = self.GLContext()
self.shader = shader = Shader()
shader.initShaderFromGLSL(["glsl/tu02/vertex.glsl"],
["glsl/tu02/fragment.glsl"])
self.context.MVP_ID = glGetUniformLocation(shader.program, "MVP")
self.context.TextureID = glGetUniformLocation(shader.program,
"myTextureSampler")
texture = textureLoader("resources/tu03/uvmap.dds")
#texture = textureLoader("opengl_tutorial/models/tu02/uvtemplate.dds")
self.context.textureGLID = texture.textureGLID
model = objLoader("resources/tu03/cube.obj").to_array_style()
self.context.vertexbuffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.context.vertexbuffer)
glBufferData(GL_ARRAY_BUFFER,
len(model.vertexs) * 4,
(GLfloat * len(model.vertexs))(*model.vertexs),
GL_STATIC_DRAW)
if (texture.inversedVCoords):
for index in range(0, len(model.texcoords)):
if (index % 2):
model.texcoords[index] = 1.0 - model.texcoords[index]
self.context.uvbuffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.context.uvbuffer)
glBufferData(GL_ARRAY_BUFFER,
len(model.texcoords) * 4,
(GLfloat * len(model.texcoords))(*model.texcoords),
GL_STATIC_DRAW)
def loadShader(self):
self.shader = Shader()
self.shader.initShaderFromGLSL(
["glsl/tu10/NormalMapping.vertexshader.glsl"],
["glsl/tu10/NormalMapping.fragmentshader.glsl"])
self.MatrixID = glGetUniformLocation(self.shader.program, "MVP")
self.ViewMatrixID = glGetUniformLocation(self.shader.program, "V")
self.ModelMatrixID = glGetUniformLocation(self.shader.program, "M")
self.ModelView3x3MatrixID = glGetUniformLocation(
self.shader.program, "MV3x3")
self.DiffuseTextureID = glGetUniformLocation(self.shader.program,
"DiffuseTextureSampler")
self.NormalTextureID = glGetUniformLocation(self.shader.program,
"NormalTextureSampler")
self.SpecularTextureID = glGetUniformLocation(
self.shader.program, "SpecularTextureSampler")
self.LightID = glGetUniformLocation(self.shader.program,
"LightPosition_worldspace")
def init_context(self):
self.context = self.GLContext()
self.shader = shader = Shader()
self.UV2d = UV2D()
shader.initShaderFromGLSL(["glsl/tu02/vertex.glsl"],
["glsl/tu02/fragment.glsl"])
# shader var ids
self.context.MVP_ID = glGetUniformLocation(shader.program, "MVP")
self.context.Texture_ID = glGetUniformLocation(shader.program,
"myTextureSampler")
# texture = textureLoader("resources/tu03/uvmap.dds")
# model = objLoader("resources/tu03/cube.obj").to_single_index_style()
texture = textureLoader("resources/tu04/uvmap.dds")
model = objLoader("resources/tu04/suzanne.obj").to_single_index_style()
self.context.texturebuffer = texture.textureGLID
if (texture.inversedVCoords):
for index in range(0, len(model.texcoords)):
if (index % 2):
model.texcoords[index] = 1.0 - model.texcoords[index]
#print "ccc",len(model.texcoords)
self.context.vertexbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.context.vertexbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.vertexs) * 4,
(GLfloat * len(model.vertexs))(*model.vertexs),
GL_STATIC_DRAW)
self.context.uvbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.context.uvbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.texcoords) * 4,
(GLfloat * len(model.texcoords))(*model.texcoords),
GL_STATIC_DRAW)
self.context.elementbuffer = glGenBuffers(1)
self.context.elementbufferSize = len(model.indices)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.context.elementbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.indices) * 2,
(GLushort * len(model.indices))(*model.indices),
GL_STATIC_DRAW)
self.UV2d.bindUV(self.context.uvbuffer, self.context.elementbuffer,
self.context.elementbufferSize)
class meshFromArray(meshWithRender):
def __init__(self, vertex_array, color_array):
self.vertex_data = vertex_array
self.color_data = color_array
def loadShader(self):
self.shader = Shader()
self.shader.initShaderFromGLSL(["glsl/tu01/vertex.glsl"],
["glsl/tu01/fragment.glsl"])
self.MVP_ID = glGetUniformLocation(self.shader.program, "MVP")
def loadObject(self):
self.vertexbuffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.vertexbuffer)
glBufferData(GL_ARRAY_BUFFER,
len(self.vertex_data) * 4,
(GLfloat * len(self.vertex_data))(*self.vertex_data),
GL_STATIC_DRAW)
self.vertexLen = len(self.vertex_data)
self.colorbuffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.colorbuffer)
glBufferData(GL_ARRAY_BUFFER,
len(self.color_data) * 4,
(GLfloat * len(self.color_data))(*self.color_data),
GL_STATIC_DRAW)
def loadTexture(self):
self.texture = None
def rendering(self, MVP, View, Projection):
self.shader.begin()
glUniformMatrix4fv(self.MVP_ID, 1, GL_FALSE, glm.value_ptr(MVP))
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, self.vertexbuffer)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(1)
glBindBuffer(GL_ARRAY_BUFFER, self.colorbuffer)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, None)
glDrawArrays(GL_TRIANGLES, 0, self.vertexLen)
glDisableVertexAttribArray(0)
glDisableVertexAttribArray(1)
self.shader.end()
def init_context(self):
self.context = self.GLContext()
# vertex = glGenVertexArrays(1) # pylint: disable=W0612
# glBindVertexArray(vertex)
self.shader = shader = Shader()
shader.initShaderFromGLSL(["glsl/tu02/vertex.glsl"],
["glsl/tu02/fragment.glsl"])
self.context.MVP_ID = glGetUniformLocation(shader.program, "MVP")
self.context.TextureID = glGetUniformLocation(shader.program,
"myTextureSampler")
texture = textureLoader("resources/tu02/uvtemplate.tga")
#texture = textureLoader("resources/tu02/uvtemplate.dds")
self.context.textureGLID = texture.textureGLID
self.context.vertexbuffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.context.vertexbuffer)
glBufferData(GL_ARRAY_BUFFER,
len(g_vertex_buffer_data) * 4,
(GLfloat *
len(g_vertex_buffer_data))(*g_vertex_buffer_data),
GL_STATIC_DRAW)
if (texture.inversedVCoords):
for index in range(0, len(g_uv_buffer_data)):
if (index % 2):
g_uv_buffer_data[index] = 1.0 - g_uv_buffer_data[index]
self.context.uvbuffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.context.uvbuffer)
glBufferData(GL_ARRAY_BUFFER,
len(g_uv_buffer_data) * 4,
(GLfloat * len(g_uv_buffer_data))(*g_uv_buffer_data),
GL_STATIC_DRAW)
def init_context(self):
self.context = self.GLContext()
self.shader = shader = Shader()
shader.initShaderFromGLSL(["glsl/tu01/vertex.glsl"],
["glsl/tu01/fragment.glsl"])
self.context.MVP_ID = glGetUniformLocation(shader.program, "MVP")
self.context.vertexbuffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.context.vertexbuffer)
glBufferData(GL_ARRAY_BUFFER,
len(g_vertex_buffer_data) * 4,
(GLfloat *
len(g_vertex_buffer_data))(*g_vertex_buffer_data),
GL_STATIC_DRAW)
self.context.colorbuffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.context.colorbuffer)
glBufferData(GL_ARRAY_BUFFER,
len(g_color_buffer_data) * 4,
(GLfloat *
len(g_color_buffer_data))(*g_color_buffer_data),
GL_STATIC_DRAW)
def init_context(self):
self.context = self.GLContext()
self.shader = shader = Shader()
shader.initShaderFromGLSL(["glsl/tu02/vertex.glsl"],
["glsl/tu02/fragment.glsl"])
# shader var ids
self.context.MVP_ID = glGetUniformLocation(shader.program, "MVP")
self.context.Texture_ID = glGetUniformLocation(shader.program,
"myTextureSampler")
texture = textureLoader("resources/tu05/AK-47_01_D_Fix.png")
self.context.texturebuffer = texture.textureGLID
model = MeshUE4().getMesh()
self.context.vertexbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.context.vertexbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.vertexs) * 4,
(GLfloat * len(model.vertexs))(*model.vertexs),
GL_STATIC_DRAW)
self.context.uvbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.context.uvbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.texcoords) * 4,
(GLfloat * len(model.texcoords))(*model.texcoords),
GL_STATIC_DRAW)
self.context.indices = glGenBuffers(1)
self.context.indicesSize = len(model.indices)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.context.indices)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.indices) * 2,
(GLushort * len(model.indices))(*model.indices),
GL_STATIC_DRAW)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(1024, 768, "title of the window", None, None)
glfw.make_context_current(window)
glClearColor(0.0, 0, 0.4, 0)
glDepthFunc(GL_LESS)
glEnable(GL_DEPTH_TEST)
vertex = glGenVertexArrays(1) # pylint: disable=W0612
glBindVertexArray(vertex)
shader = Shader()
shader.initShaderFromGLSL(["glsl/tu01/vertex.glsl"],
["glsl/tu01/fragment.glsl"])
MVP_ID = glGetUniformLocation(shader.program, "MVP")
Projection = Matrix44.perspective_projection(math.radians(45.0), 800.0 / 480.0,
0.1, 100.0)
View = Matrix44.look_at(
(4, 3, -3), # Camera is at (4,3,-3), in World Space
(0, 0, 0), #and looks at the (0.0.0))
(0, 1, 0)) #Head is up (set to 0,-1,0 to look upside-down)
Model = Matrix44.identity()
MVP = Projection * View * Model
#print context.MVP
def loadShader(self):
self.shader = Shader()
class NormalMapping(meshWithRender):
def __init__(self, meshName, textureName, location=[0.0, 0.0, 0.0]):
self.meshName = meshName
self.textureName = textureName
self.location = location
def indexVBO_TBN(self, vertex, uv, normal, tangents, bitangents):
class Container(object):
pass
indices = []
out_vertexs = []
out_uvs = []
out_normals = []
out_tangents = []
out_bitangents = []
newindex = 0
def getSimilarVertexIndex(in_vertex, in_uv, in_normal, vertex_list,
uv_list, normal_list):
def is_near(v1, v2):
return fabs(v1 - v2) < 0.01
for idx in range(0, len(vertex_list) / 3):
vertex_in_list = vertex_list[idx * 3:idx * 3 + 3]
uv_in_list = uv_list[idx * 2:idx * 2 + 2]
normal_in_list = normal_list[idx * 3:idx * 3 + 3]
if (is_near(in_vertex[0], vertex_in_list[0])
& is_near(in_vertex[1], vertex_in_list[1])
& is_near(in_vertex[2], vertex_in_list[2])
& is_near(in_uv[0], uv_in_list[0])
& is_near(in_uv[1], uv_in_list[1])
& is_near(in_normal[0], normal_in_list[0])
& is_near(in_normal[1], normal_in_list[1])
& is_near(in_normal[2], normal_in_list[2])):
return True, idx
return False, 0
for idx in range(0, len(vertex) / 3):
current_v = vertex[idx * 3:idx * 3 + 3]
current_uv = uv[idx * 2:idx * 2 + 2]
current_normal = normal[idx * 3:idx * 3 + 3]
found, idx_found = getSimilarVertexIndex(current_v, current_uv,
current_normal,
out_vertexs, out_uvs,
out_normals)
if found:
indices.append(idx_found)
else:
indices.append(newindex)
out_vertexs = out_vertexs + current_v
out_uvs = out_uvs + current_uv
out_normals = normal + current_normal
out_tangents = out_tangents + tangents[idx * 3:idx * 3 + 3]
out_bitangents = out_bitangents + bitangents[idx * 3:idx * 3 +
3]
newindex += 1
outobj = Container()
outobj.indices = indices
outobj.vertexs = out_vertexs
outobj.texcoords = out_uvs
outobj.normals = out_normals
outobj.tangents = out_tangents
outobj.bitangents = out_bitangents
return outobj
def computeTangentBasis(self, vertex, uv, normal):
tangents = []
bitangents = []
for idx in range(0, len(vertex) / 9):
offset = idx * 9
v0 = vertex[offset:offset + 3]
v1 = vertex[offset + 3:offset + 6]
v2 = vertex[offset + 6:offset + 9]
offset = idx * 6
uv0 = uv[offset:offset + 2]
uv1 = uv[offset + 2:offset + 4]
uv2 = uv[offset + 4:offset + 6]
#print v0,v1,v2
deltaPos1 = glm.vec3([v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]])
deltaPos2 = glm.vec3([v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]])
deltaUV1 = glm.vec2([uv1[0] - uv0[0], uv1[1] - uv0[1]])
deltaUV2 = glm.vec2([uv2[0] - uv0[0], uv2[1] - uv0[1]])
r = 1.0 / (deltaUV1.x * deltaUV2.y - deltaUV1.y * deltaUV2.x)
tangent = (deltaPos1 * deltaUV2.y - deltaPos2 * deltaUV1.y) * r
bitangent = (deltaPos2 * deltaUV1.x - deltaPos1 * deltaUV2.x) * r
tangents.extend([tangent.x, tangent.y, tangent.z])
tangents.extend([tangent.x, tangent.y, tangent.z])
tangents.extend([tangent.x, tangent.y, tangent.z])
bitangents.extend([bitangent.x, bitangent.y, bitangent.z])
bitangents.extend([bitangent.x, bitangent.y, bitangent.z])
bitangents.extend([bitangent.x, bitangent.y, bitangent.z])
return tangents, bitangents
def loadShader(self):
self.shader = Shader()
self.shader.initShaderFromGLSL(
["glsl/tu10/NormalMapping.vertexshader.glsl"],
["glsl/tu10/NormalMapping.fragmentshader.glsl"])
self.MatrixID = glGetUniformLocation(self.shader.program, "MVP")
self.ViewMatrixID = glGetUniformLocation(self.shader.program, "V")
self.ModelMatrixID = glGetUniformLocation(self.shader.program, "M")
self.ModelView3x3MatrixID = glGetUniformLocation(
self.shader.program, "MV3x3")
self.DiffuseTextureID = glGetUniformLocation(self.shader.program,
"DiffuseTextureSampler")
self.NormalTextureID = glGetUniformLocation(self.shader.program,
"NormalTextureSampler")
self.SpecularTextureID = glGetUniformLocation(
self.shader.program, "SpecularTextureSampler")
self.LightID = glGetUniformLocation(self.shader.program,
"LightPosition_worldspace")
def loadObject(self):
from utils.objLoader import objLoader
model = objLoader(self.meshName).to_array_style()
tangents, bitangents = self.computeTangentBasis(
model.vertexs, model.texcoords, model.normals)
self.model = model = self.indexVBO_TBN(model.vertexs, model.texcoords,
model.normals, tangents,
bitangents)
self.vertexbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.vertexbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.vertexs) * 4,
(GLfloat * len(model.vertexs))(*model.vertexs),
GL_STATIC_DRAW)
self.normalbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.normalbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.normals) * 4,
(GLfloat * len(model.normals))(*model.normals),
GL_STATIC_DRAW)
self.tangentbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.tangentbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.tangents) * 4,
(GLfloat * len(model.tangents))(*model.tangents),
GL_STATIC_DRAW)
self.bitangentbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.bitangentbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.bitangents) * 4,
(GLfloat * len(model.bitangents))(*model.bitangents),
GL_STATIC_DRAW)
self.indicesbufferSize = len(model.indices)
self.indicesbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.indicesbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.indices) * 2,
(GLushort * len(model.indices))(*model.indices),
GL_STATIC_DRAW)
def loadTexture(self):
from utils.textureLoader import textureLoader
DiffuseTexture = textureLoader(self.textureName[0])
NormalTexture = textureLoader(self.textureName[1])
SpecularTexture = textureLoader(self.textureName[2])
model = self.model
# if(DiffuseTexture.inversedVCoords):
for index in range(0, len(model.texcoords)):
if (index % 2):
model.texcoords[index] = 1.0 - model.texcoords[index]
self.DiffuseTexture = DiffuseTexture.textureGLID
self.NormalTexture = NormalTexture.textureGLID
self.SpecularTexture = SpecularTexture.textureGLID
self.uvbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.uvbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(model.texcoords) * 4,
(GLfloat * len(model.texcoords))(*model.texcoords),
GL_STATIC_DRAW)
def rendering(self, MVP, View, Projection):
self.shader.begin()
ModelMatrix = glm.mat4(1.0)
#print View
ModelViewMatrix = glm.mat4(View) * ModelMatrix
ModelView3x3Matrix = glm.mat3(ModelViewMatrix)
glUniformMatrix4fv(self.MatrixID, 1, GL_FALSE, glm.value_ptr(MVP))
glUniformMatrix4fv(self.ModelMatrixID, 1, GL_FALSE,
glm.value_ptr(ModelMatrix))
glUniformMatrix4fv(self.ViewMatrixID, 1, GL_FALSE, glm.value_ptr(View))
glUniformMatrix3fv(self.ModelView3x3MatrixID, 1, GL_FALSE,
glm.value_ptr(ModelView3x3Matrix))
lightPos = glm.vec3(0.0, 0.0, 4.0)
glUniform3f(self.LightID, lightPos.x, lightPos.y, lightPos.z)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self.DiffuseTexture)
glUniform1i(self.DiffuseTextureID, 0)
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_2D, self.NormalTexture)
glUniform1i(self.NormalTextureID, 1)
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_2D, self.SpecularTexture)
glUniform1i(self.SpecularTextureID, 2)
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, self.vertexbuffer)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(1)
glBindBuffer(GL_ARRAY_BUFFER, self.uvbuffer)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(2)
glBindBuffer(GL_ARRAY_BUFFER, self.normalbuffer)
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(3)
glBindBuffer(GL_ARRAY_BUFFER, self.tangentbuffer)
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(4)
glBindBuffer(GL_ARRAY_BUFFER, self.bitangentbuffer)
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 0, None)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.indicesbuffer)
glDrawElements(
GL_TRIANGLES, # mode
self.indicesbufferSize, #// count
GL_UNSIGNED_SHORT, # // type
None #// element array buffer offset
)
glDisableVertexAttribArray(0)
glDisableVertexAttribArray(1)
glDisableVertexAttribArray(2)
glDisableVertexAttribArray(3)
glDisableVertexAttribArray(4)
class Draw2DText(meshWithRender):
def __init__(self, text_str, x, y, Xsize, Ysize):
(self.text_str, self.x, self.y, self.Xsize,
self.Ysize) = (text_str, x, y, Xsize, Ysize)
def loadShader(self):
self.shader = Shader()
self.shader.initShaderFromGLSL(
["glsl/tu09/TextVertexShader.vertexshader.glsl"],
["glsl/tu09/TextVertexShader.fragmentshader.glsl"])
self.HALFSCREENSIZE_ID = glGetUniformLocation(self.shader.program,
"HALFSCREENSIZE")
self.Texture_ID = glGetUniformLocation(self.shader.program,
"myTextureSampler")
def loadObject(self):
vertex_array = []
uv_array = []
lineCount = 0
for line in self.text_str:
for idx in range(0, len(line)):
xoffset = idx * self.Xsize
yoffset = lineCount * self.Ysize
vertex_up_left = [
self.x + xoffset, self.y + yoffset + self.Ysize
]
vertex_up_right = [
self.x + xoffset + self.Xsize,
self.y + yoffset + self.Ysize
]
vertex_down_right = [
self.x + xoffset + self.Xsize, self.y + yoffset
]
vertex_down_left = [self.x + xoffset, self.y + yoffset]
vertex_array = vertex_array + vertex_up_left + vertex_down_left + vertex_up_right
vertex_array = vertex_array + vertex_down_right + vertex_up_right + vertex_down_left
character = ord(line[idx])
uv_x = (character % 16) / 16.0
uv_y = (character / 16) / 16.0
uv_up_left = [uv_x, uv_y]
uv_up_right = [uv_x + 1.0 / 16.0, uv_y]
uv_down_right = [uv_x + 1.0 / 16.0, uv_y + 1.0 / 16.0]
uv_down_left = [uv_x, uv_y + 1.0 / 16.0]
uv_array = uv_array + uv_up_left + uv_down_left + uv_up_right
uv_array = uv_array + uv_down_right + uv_up_right + uv_down_left
lineCount += 1
self.vertexbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.vertexbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(vertex_array) * 4,
(GLfloat * len(vertex_array))(*vertex_array),
GL_STATIC_DRAW)
self.uvbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.uvbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
len(uv_array) * 4, (GLfloat * len(uv_array))(*uv_array),
GL_STATIC_DRAW)
self.vertex_array = vertex_array
def loadTexture(self):
from utils.textureLoader import textureLoader
texture = textureLoader("resources/tu09/Holstein.DDS")
self.texturebuffer = texture.textureGLID
def rendering(self, MVP, View, Projection):
self.shader.begin()
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self.texturebuffer)
glUniform1i(self.Texture_ID, 0)
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, self.vertexbuffer)
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(1)
glBindBuffer(GL_ARRAY_BUFFER, self.uvbuffer)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, None)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glDrawArrays(GL_TRIANGLES, 0, len(self.vertex_array))
glDisable(GL_BLEND)
glDisableVertexAttribArray(0)
glDisableVertexAttribArray(1)
self.shader.end()
class basicShading(meshWithRender):
def __init__(self,meshName,textureName,location=[0.0,0.0,0.0]):
self.meshName = meshName
self.textureName = textureName
self.location = location
def loadShader(self):
self.shader = Shader()
self.shader.initShaderFromGLSL(
["glsl/tu07/StandardShading.vertexshader.glsl"], ["glsl/tu07/StandardShading.fragmentshader.glsl"])
self.MVP_ID = glGetUniformLocation(self.shader.program, "MVP")
self.ModelMatrix_ID = glGetUniformLocation(self.shader.program, "M")
self.ViewMatrix_ID = glGetUniformLocation(self.shader.program, "V")
self.Texture_ID = glGetUniformLocation(self.shader.program, "myTextureSampler")
self.Light_ID = glGetUniformLocation(self.shader.program, "LightPosition_worldspace")
self.OFFSET_ID = glGetUniformLocation(self.shader.program, "LOCATION_OFFSET")
def loadObject(self):
from utils.objLoader import objLoader
model = objLoader(self.meshName).to_single_index_style()
self.model = model
self.vertexbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,self.vertexbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,len(model.vertexs)*4,(GLfloat * len(model.vertexs))(*model.vertexs),GL_STATIC_DRAW)
# used normal
self.normalbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,self.normalbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,len(model.normals)*4,(GLfloat * len(model.normals))(*model.normals),GL_STATIC_DRAW)
self.indicesbufferSize = len(model.indices)
self.indicesbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,self.indicesbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,len(model.indices)*2,(GLushort * len(model.indices))(*model.indices),GL_STATIC_DRAW)
def loadTexture(self):
from utils.textureLoader import textureLoader
texture = textureLoader(self.textureName)
model = self.model
if(texture.inversedVCoords):
for index in range(0,len(model.texcoords)):
if(index % 2):
model.texcoords[index] = 1.0 - model.texcoords[index]
self.texturebuffer = texture.textureGLID
self.uvbuffer = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,self.uvbuffer)
glBufferData(GL_ELEMENT_ARRAY_BUFFER,len(model.texcoords)*4,(GLfloat * len(model.texcoords))(*model.texcoords),GL_STATIC_DRAW)
def rendering(self, MVP,View,Projection):
self.shader.begin()
glUniformMatrix4fv(self.MVP_ID,1,GL_FALSE, glm.value_ptr(MVP))
glUniformMatrix4fv(self.ModelMatrix_ID,1,GL_FALSE,glm.value_ptr(glm.mat4(1.0)))
glUniformMatrix4fv(self.ViewMatrix_ID,1,GL_FALSE,glm.value_ptr(View))
glUniform3f(self.OFFSET_ID,self.location[0],self.location[1],self.location[2])
lightPos = glm.vec3(0.0,0.0,4.0)
glUniform3f(self.Light_ID, lightPos.x, lightPos.y, lightPos.z)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self.texturebuffer)
glUniform1i(self.Texture_ID, 0) #// Set "myTextureSampler" sampler to use Texture Unit 0
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, self.vertexbuffer)
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,None)
glEnableVertexAttribArray(1)
glBindBuffer(GL_ARRAY_BUFFER, self.uvbuffer)
glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,0,None)
glEnableVertexAttribArray(2)
glBindBuffer(GL_ARRAY_BUFFER, self.normalbuffer)
glVertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,0,None)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.indicesbuffer)
glDrawElements(
GL_TRIANGLES, # mode
self.indicesbufferSize, #// count
GL_UNSIGNED_SHORT, # // type
None #// element array buffer offset
)
glDisableVertexAttribArray(0)
glDisableVertexAttribArray(1)
glDisableVertexAttribArray(1)
def loadShader(self):
self.shader = Shader()
self.shader.initShaderFromGLSL(["glsl/tu01/vertex.glsl"],
["glsl/tu01/fragment.glsl"])
self.MVP_ID = glGetUniformLocation(self.shader.program, "MVP")
