def __init__(self, OBJname, MATname): #loads .obj and .mat files
self.meshData = []
self.materialData = []
self.count = 0
self.VBOs = []
self.VAOs = []
self.shader = Shader("./shaders/diffuseSpec") #loads the master shader
self.textures = []
self.loadMesh(OBJname)
self.loadMaterial(MATname)
self.loadDataInGPU()
def setup_prim(self):
self.va = VertexArray()
self.vbo = VertexBuffer(self.vertices)
self.layout = VertexBufferLayout()
self.layout.push_float(3)
self.layout.push_float(2)
self.layout.push_float(3)
self.va.add_buffer(self.vbo, self.layout)
self.ib = IndexBuffer(self.indices)
self.shader = Shader('resources/shaders/BasicTextureMVP.glsl')
self.material.textures.basecolor.setup_texture()
class SFTaxiShader(sf.Drawable):
def __init__(self, P):
sf.Drawable.__init__(self)
self.quad= Quad()
self.shader= Shader(P)
self.states= sf.RenderStates(shader=self.shader)
def draw(self, target,states):
self.shader.set_parameter("iResolution", target.size )
self.quad.align(target)
target.draw(self.quad,self.states)
def corners(self): return self.quad.corners()
class SFTaxiShader(sf.Drawable):
def __init__(self, P):
sf.Drawable.__init__(self)
self.quad = Quad()
self.shader = Shader(P)
self.states = sf.RenderStates(shader=self.shader)
def draw(self, target, states):
self.shader.set_parameter("iResolution", target.size)
self.quad.align(target)
target.draw(self.quad, self.states)
def corners(self):
return self.quad.corners()
def __init__(self , fname):
self.shader = Shader(fname)
self.mat = MaterialData()
self.identityMat = pyrr.matrix44.create_identity()
vertices = [-1 , 1 , -1 , -1 , 1 , 1 , 1 , -1]
vertices = np.array(vertices, dtype='float32')
self.vao = glGenVertexArrays(1)
glBindVertexArray(self.vao)
self.vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.vbo);
glBufferData(GL_ARRAY_BUFFER,8*4 , vertices, GL_STATIC_DRAW)
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, None);
glBindVertexArray(0);
def __init__(self, attributes, bone_nodes, bone_offsets, index=None):
self.vertex_array = VertexArrayObject(attributes, index)
self.skinning_shader = Shader(SKINNING_VERT, COLOR_FRAG)
self.bone_nodes = bone_nodes
self.bone_offsets = bone_offsets
def __init__(self, WINDOW, FONTLOADER, MaxLineLenght):
self._maxLineLenght = MaxLineLenght
## Initialize Current Window
# Pointers
self._Window = WINDOW
self._FontLoader = FONTLOADER
self.StringLenght = np.zeros([2])
self._fixedWindowSize = False
self._INITIATION = True
self._fullUpdate = True
self._stringLenght = 0
self._fontColor = np.ones([3])
self._screenWidth, self._screenHeight = 0, 0
self._stringList = ""
self._maxStringHeight = 0
self._maxStringWidth = 0
self._maxHeightOffset = 0
self._maxLetterLength = int(1000)
self._bufferItemSize = int(4 * (2 * 4))
self._UPDATETEXTPOS = True
self._lastPositionX = 0
self._lastPositionY = 0
self._shaderFont = Shader.shader("../shaders/font.vs",
"../shaders/font.fs")
self._shaderFont.use()
# self._shaderFont.Int("bitMap", 1)
self._initiateQuad()
def shader(self):
if self._shaderProgram is None:
self._shaderProgram = Shader.MakeProgramFromSource( vs, ps )
self._shaderProgram.uniform1i( "stage1", 0 )
self._shaderProgram.uniform1i( "stage2", 1 )
self._shaderProgram.uniform1i( "stage3", 2 )
return self._shaderProgram
def __init__(self, step, cell_size):
self.step = step
self.cell_size = cell_size
self.grid = []
self.grid_sdr = Shader('resources/shaders/Grid.glsl')
self.grid_sdr.bind()
self.layout = VertexBufferLayout()
self.layout.push_float(2)
self.VA = VertexArray()
self.VA.unbind()
self.grid_sdr.unbind()
distance = cell_size * step
grid_array = []
if step == 0:
xline = [cell_size, 0.0, -cell_size, 0.0]
yline = [0.0, cell_size, 0.0, -cell_size]
else:
xline = [distance, 0.0, -distance, 0.0]
yline = [0.0, distance, 0.0, -distance]
grid_array.extend(xline)
grid_array.extend(yline)
if step > 0:
for i in range(step):
i = i + 1
grid_array.extend(
[distance, i * cell_size, -distance, i * cell_size])
grid_array.extend(
[distance, -i * cell_size, -distance, -i * cell_size])
grid_array.extend(
[i * cell_size, distance, i * cell_size, -distance])
grid_array.extend(
[-i * cell_size, distance, -i * cell_size, -distance])
else:
print("Grid step count can't be negative.")
self.grid = numpy.array(grid_array, 'f')
self.VB = VertexBuffer(self.get_grid_array())
self.VA.add_buffer(self.VB, self.layout)
def __init__(self,
WINDOW,
FONTRENDERER,
PRIMETIVES,
DataType=False,
Length=0.02,
Color=(1, 1, 1)):
self._Window = WINDOW
self._FontRenderer = FONTRENDERER
self._Primetive = PRIMETIVES
self._startNumbNormal = 48
self._startNumbKeypad = 320
self._startLetter = 65
self._alphabetStringLC = "abcdefghijklmnopqrstuvwxyz"
self._alphabetStringUC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
self._capsLockKey = False
self._enterKey = False
self._ctrlKey = False
self._tabKey = False
self._backSpaceKey = False
self._dataType = DataType
self._Calculator = stringCalculator.StringCalculator(DataType)
self._keySilenceTime = 0
self._keySilenceTimeHold = 0
self._keySilenceTimeLimit = 0.2
self._currentIndex = 0
self._time = 0
self._mouseClickHold = False
self._firstClick = True
self._mouseClickTime = 0
self._mouseClickTimeHold = 0
self._mouseClickTimeLimit = 0.3
self._copy = False
self._paste = False
self._markString = True
self._lineSeperatorTime = 0
self._lineSeperatorTimeHold = 0
self._lineSeperatorRefreshTime = 0.5
self._lineSeperatorState = True
self._lineSeperatorUpdate = False
self._shaderLINE = Shader.shader("../shaders/Line.vs",
"../shaders/Line.fs")
self._shaderLINE.use()
self._shaderLINE.float("length", Length)
self._shaderLINE.vec3("color", Color)
# Public
self.KeyEvent = False
self.MainString = ""
self.MousePickStartPos = 1
self.MousePickEndPos = 1
self.MousePickHeightCenter = 1
if DataType is not False:
self.MainString = "0.0"
def __init__(self,
Scaler,
WindowPointer,
PrimetiveShapePointer,
FontLoaderPointer,
PosX,
PosY,
SizeX,
SizeY,
TexturePath=None):
# Pointers
self._Window = WindowPointer
self._Primetive = PrimetiveShapePointer
self._fontLoader = FontLoaderPointer
self._PathSplitter = pathSplitter.PathSplitter()
# Static values
self._windowScaler = Scaler
self._textSize = 0.25 * self._windowScaler
self._baseAlpha = 0.88
self._edge = 1.3
self.TextBoxKeyEvent = False
self._leftClickGuard = False
self.ButtonState = False
self._buttonHold = False
self.SlidebarPercent = 0.5
self._initiationFlag = True
# DropDown Menu
self._lastDropSize = False
self._endPos = 0
self._rangeText = 0
self.DropDownIndex = 0
self._spaceScale = self._textSize * 110
self._dropDownName = ""
self.dropDownHold = False
self._sizeX = SizeX * self._windowScaler
self._sizeY = SizeY * self._windowScaler
self._positionX = PosX * self._windowScaler
self._positionY = PosY * self._windowScaler
self._RENDERTEXTURE = False
if TexturePath is not None:
self._loadImageData(TexturePath)
self._RENDERTEXTURE = True
self._lastWindowSizeX = self._Window.width
self._lastWindowSizeY = self._Window.height
self._shaderGUI = Shader.shader("../shaders/GUI.vs",
"../shaders/GUI.fs")
self._primaryFont = fontRenderer.FONTRENDERER(self._Window,
self._fontLoader, 800)
self._initiateGUI()
def drawScreen(self):
"""Draw the screen"""
GraphicsCard.resetPolygonCount()
GraphicsCard.enable('texture_2d', 'blend', 'cull_face')
GraphicsCard.setBlendFunction('src_alpha', 'one_minus_src_alpha')
GraphicsCard.setFrontFace('ccw')
GraphicsCard.loadIdentity()
GraphicsCard.multMatrix(self.world.camera.getViewMatrix().toList())
glLightfv(GL_LIGHT0, GL_POSITION, [0, 1, 0, 0])
GraphicsCard.clearDepth(1.0)
GraphicsCard.clear()
#Draw the world
self.world.draw()
TextureManager.DisableStage(1)
TextureManager.DisableStage(2)
if Settings.UseShaders: Shader.DisableShaders()
#self.font.draw( 0, 0, "FPS: " + str( self.fps ) )
DebugDisplay.update("FPS", self.fps, delay=0.3333)
DebugDisplay.update("yaw", radianToDegree(self.world.camera.yaw))
DebugDisplay.update("pitch", radianToDegree(self.world.camera.pitch))
DebugDisplay.update("polygons_drawn", GraphicsCard.polygonsDrawn())
if self.world.playerEnt:
DebugDisplay.update("onGround", self.world.playerEnt.onGround)
DebugDisplay.update("groundNormal",
self.world.playerEnt.groundNormal)
GraphicsCard.loadIdentity()
if self.consoleVisible:
self.console.draw()
gl2D.start2D()
if Settings.DrawDebugInfo:
GraphicsCard.setColorRGBA(1, 1, 1, 1)
self.font.draw(0, 0, str(DebugDisplay.globalState))
self.world.scene.drawDebugInfo(self.font)
else:
GraphicsCard.setColorRGBA(1, 1, 1, 1)
pygame.display.set_caption("FPS: " + str(DebugDisplay.get("FPS")))
#self.bigfont.draw(0, 0, "Ninjas Killed: %s" % (self.world.ninjasKilled) )
#self.bigfont.draw(0, 30, "Pirates Killed: %s" % (self.world.piratesKilled) )
#self.bigfont.draw(0, 60, "Treasures Stolen: %s" % (self.world.treasuresTaken) )
#DebugDisplay.globalState.draw( self.font )
gl2D.end2D()
#put stuff on the screen
pygame.display.flip()
err = graphext.GetGLError()
while err != GL_NO_ERROR:
print err
print graphext.GLErrorString(err)
def onInit(self):
self.program = Shader.MakeProgramFromSource(vs, ps)
self.program.printInfoLog()
#setup lighting
n = vec3(0, 0, 1)
n = n.normalize()
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
[0.8, 0.8, 0.8, 1.0])
glLightfv(GL_LIGHT0, GL_AMBIENT, [0.0, 0.0, 0.0, 1.0])
glLightfv(GL_LIGHT0, GL_DIFFUSE, [1.0, 1.0, 1.0, 1.0])
glLightfv(GL_LIGHT0, GL_POSITION, [n.x, n.y, n.z, 1.0])
glEnable(GL_LIGHT0)
def __init__(self, points, sizes, mass):
'''
Constructor
'''
self._window = 0
self._first = True
self._sizes = np.array(sizes)
self._points = points
self._pointmasses = mass
self._pointsGL = None
self._cornerX = None
self._cornerY = None
self._shader = Shader.Shader("Billboard")
self._texture = 0
def main(argc,argv):
# inicializar subsistemas
# son las cosas minimas necesarias para crear la ventana
c = Controller()
v = View((WIDTH,HEIGHT),(90.0, 0.1, 100.0))
# m = Model(Triangle((5,5,-15),(-5,-5,-15),(5,-5,-15)))
m = Model(Cube((-5,-5,-5),(5,5,5)))
# configurar la ventana
v.init_GL((0.0, 0.5, 0.5, 1.0))
# Creamos el Shader
shader_program = Shader("basic_shader")
shader_program.compile()
# Configuramos las ubicaciones de los uniformes
shader_program.uniform_location = {
"lightPos": glGetUniformLocation(shader_program.program, "lightPos"),
"lightCol": glGetUniformLocation(shader_program.program, "lightCol")
}
# Configuramos las ubicaciones de los atributos
shader_program.bindAttributeLocation({
"position": 0,
"color": 1,
"normal": 2
})
# Le entregamos los shaders a la vista para que los use
v.useShader(shader_program)
# Le entregamos el modelo a la vista
v.model = m
run = True
while run:
# actualizar subsistemas
dt = c.update()
m.update(dt)
v.update(dt)
run = c.check_close()
shader_program.delete()
# cerrar subsistemas
c.close()
m.close()
v.close()
class FullScreenQuad:
def __init__(self , fname):
self.shader = Shader(fname)
self.mat = MaterialData()
self.identityMat = pyrr.matrix44.create_identity()
vertices = [-1 , 1 , -1 , -1 , 1 , 1 , 1 , -1]
vertices = np.array(vertices, dtype='float32')
self.vao = glGenVertexArrays(1)
glBindVertexArray(self.vao)
self.vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.vbo);
glBufferData(GL_ARRAY_BUFFER,8*4 , vertices, GL_STATIC_DRAW)
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, None);
glBindVertexArray(0);
def renderFullScreenQuad(self):
self.shader.bind()
self.shader.updateUniforms(self.identityMat , self.identityMat ,self.identityMat , self.mat)
glBindVertexArray(self.vao)
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
class Primitive:
def __init__(self):
self.vertex_count = 0
self.vertices = []
self.indices = []
self.material = None
self.va = None
self.ib = None
self.vbo = None
self.layout = None
self.shader = None
def setup_prim(self):
self.va = VertexArray()
self.vbo = VertexBuffer(self.vertices)
self.layout = VertexBufferLayout()
self.layout.push_float(3)
self.layout.push_float(2)
self.layout.push_float(3)
self.va.add_buffer(self.vbo, self.layout)
self.ib = IndexBuffer(self.indices)
self.shader = Shader('resources/shaders/BasicTextureMVP.glsl')
self.material.textures.basecolor.setup_texture()
def draw_prim(self, modeltransform):
self.shader.bind()
mvp = Global.ProjMat * Global.ViewMat * modeltransform
self.shader.set_uniformMat4f('u_MVP', mvp)
self.material.textures.basecolor.bind()
self.shader.set_uniform1i('u_Texture', 0)
self.va.bind()
self.ib.bind()
glDrawElements(GL_TRIANGLES, self.ib.get_count(), GL_UNSIGNED_INT,
None)
class Grid:
def __init__(self, step, cell_size):
self.step = step
self.cell_size = cell_size
self.grid = []
self.grid_sdr = Shader('resources/shaders/Grid.glsl')
self.grid_sdr.bind()
self.layout = VertexBufferLayout()
self.layout.push_float(2)
self.VA = VertexArray()
self.VA.unbind()
self.grid_sdr.unbind()
distance = cell_size * step
grid_array = []
if step == 0:
xline = [cell_size, 0.0, -cell_size, 0.0]
yline = [0.0, cell_size, 0.0, -cell_size]
else:
xline = [distance, 0.0, -distance, 0.0]
yline = [0.0, distance, 0.0, -distance]
grid_array.extend(xline)
grid_array.extend(yline)
if step > 0:
for i in range(step):
i = i + 1
grid_array.extend(
[distance, i * cell_size, -distance, i * cell_size])
grid_array.extend(
[distance, -i * cell_size, -distance, -i * cell_size])
grid_array.extend(
[i * cell_size, distance, i * cell_size, -distance])
grid_array.extend(
[-i * cell_size, distance, -i * cell_size, -distance])
else:
print("Grid step count can't be negative.")
self.grid = numpy.array(grid_array, 'f')
self.VB = VertexBuffer(self.get_grid_array())
self.VA.add_buffer(self.VB, self.layout)
def get_grid_array(self):
return self.grid
def get_point_count(self):
# if self.step == 0:
# return 4
return 4 + (self.step * 8)
def unbind_shader(self):
self.grid_sdr.bind()
def bind_shader(self):
self.grid_sdr.unbind()
def draw_grid(self, proj, view):
if Settings.GridEnabled:
glEnable(GL_LINE_SMOOTH)
self.grid_sdr.bind()
self.VA.bind()
self.grid_sdr.set_uniformMat4f(
'u_MVP',
proj * view *
rotate(mat4(1.0), radians(90), vec3(1.0, 0.0, 0.0)))
glDrawArrays(GL_LINES, 0, self.get_point_count())
self.grid_sdr.unbind()
self.VA.unbind()
def draw_element(self, va: VertexArray, ib: IndexBuffer, shader: Shader):
shader.bind()
va.bind()
ib.bind()
glDrawElements(GL_TRIANGLES, ib.get_count(), GL_UNSIGNED_INT, None)
def __init__(self, attributes, index=None):
self.vertex_array = VertexArrayObject(attributes, index)
self.shader = Shader(COLOR_VERT, COLOR_FRAG)
def draw_array(self, va: VertexArray, shader: Shader, vertex_count):
shader.bind()
va.bind()
glDrawArrays(GL_TRIANGLES, 0, vertex_count)
"--uniforms",
action="store",
type="string",
dest="uniforms",
default="")
parser.add_option("-t",
"--textures",
action="store",
type="string",
dest="textures",
default="")
(options, args) = parser.parse_args()
if options.compile is not None:
print(Shader.getShader(options.compile, set(options.compile)))
exit()
app = QtGui.QApplication(['ShaderTest'])
glutInit(sys.argv)
vertex = options.vertex
fragment = options.fragment
if options.shader is not None:
vertex = options.shader + ".vert"
fragment = options.shader + ".frag"
window = ShaderTest(vertex, fragment, options.uniforms, options.textures)
window.show()
sys.exit(app.exec_())
self.grpCyclorama.hide()
self.setDomeSettings()
self.grpDome.show()
elif self.btnCyclorama.isChecked():
self.grpCyclorama.show()
self.grpDome.hide()
self.setCycloramaSettings()
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-s","--shader", action="store", type="string", dest="shader")
parser.add_option("-n","--no-gui", action="store_true", dest="no_gui",
help="Be moderately verbose")
(options, args) = parser.parse_args()
if options.shader is not None:
print(Shader.getShader(options.shader,set(options.shader)))
exit()
if not options.no_gui:
app = QtGui.QApplication(['Dome'])
glutInit(sys.argv)
window = DomeGUI()
window.show()
sys.exit(app.exec_())
def __init__(self, P):
sf.Drawable.__init__(self)
self.quad = Quad()
self.shader = Shader(P)
self.states = sf.RenderStates(shader=self.shader)
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-s","--shader",action="store",type="string",dest="shader")
parser.add_option("-f","--fragment", action="store", type="string", dest="fragment")
parser.add_option("-v","--vertex", action="store", type="string",dest="vertex")
parser.add_option("-c","--compile", action="store", type="string",dest="compile")
parser.add_option("-u","--uniforms", action="store",
type="string",dest="uniforms",default="")
parser.add_option("-t","--textures", action="store",
type="string",dest="textures",default="")
(options, args) = parser.parse_args()
if options.compile is not None:
print(Shader.getShader(options.compile,set(options.compile)))
exit()
app = QtGui.QApplication(['ShaderTest'])
glutInit(sys.argv)
vertex = options.vertex
fragment = options.fragment
if options.shader is not None:
vertex = options.shader+".vert"
fragment = options.shader+".frag"
window = ShaderTest(vertex,fragment,options.uniforms,options.textures)
window.show()
def __init__(self, caption="Game"):
self.screen = None
self.caption = caption
self.fullscreen = False
self.flags = True
self.shaders = Shader.shaderList()
def __init__(self, P): sf.Drawable.__init__(self) self.quad= Quad() self.shader= Shader(P) self.states= sf.RenderStates(shader=self.shader)
self.grpDome.hide()
self.setCycloramaSettings()
if __name__ == '__main__':
parser = OptionParser()
parser.add_option("-s",
"--shader",
action="store",
type="string",
dest="shader")
parser.add_option("-n",
"--no-gui",
action="store_true",
dest="no_gui",
help="Be moderately verbose")
(options, args) = parser.parse_args()
if options.shader is not None:
print(Shader.getShader(options.shader, set(options.shader)))
exit()
if not options.no_gui:
app = QtGui.QApplication(['Dome'])
glutInit(sys.argv)
window = DomeGUI()
window.show()
sys.exit(app.exec_())
class Mesh:
def __init__(self, OBJname, MATname): #loads .obj and .mat files
self.meshData = []
self.materialData = []
self.count = 0
self.VBOs = []
self.VAOs = []
self.shader = Shader("./shaders/diffuseSpec") #loads the master shader
self.textures = []
self.loadMesh(OBJname)
self.loadMaterial(MATname)
self.loadDataInGPU()
def loadMaterial(self, fname):
for line in open(fname, 'r'):
if line.startswith('#'): continue
values = line.split()
if not values: continue
if values[0] == 'o':
data = []
data = MaterialData.MaterialData()
self.materialData.append(data)
if values[0] == 'diffuse':
data.diffuse = values[2]
self.textures.append(Texture.Texture("./res/" + data.diffuse))
if values[0] == 'specularIntensity':
data.specularIntensity = np.float32(float(values[2]))
if values[0] == 'specularPower':
data.specularPower = np.float32(float(values[2]))
if values[0] == 'reflectAmt':
data.reflectAmt = np.float32(float(values[2]))
if values[0] == 'reflectColor':
data.reflectColor[0] = np.float32(float(values[1]))
data.reflectColor[1] = np.float32(float(values[2]))
data.reflectColor[2] = np.float32(float(values[3]))
if values[0] == 'refractAmt':
data.refractAmt = np.float32(float(values[2]))
if values[0] == 'refractColor':
data.refractColor[0] = np.float32(float(values[1]))
data.refractColor[1] = np.float32(float(values[2]))
data.refractColor[2] = np.float32(float(values[3]))
def loadMesh(self, fname):
data = []
for line in open(fname, 'r'):
if line.startswith('#'): continue
values = line.split()
if not values: continue
if values[0] == 'o':
data = []
data = MeshData.MeshData()
self.meshData.append(data)
self.count = self.count + 1
for c in values[1:]:
data.name += c
if values[0] == 'v':
data.vert_coords.append(values[1:4])
if values[0] == 'vt':
data.text_coords.append(values[1:3])
if values[0] == 'vn':
data.norm_coords.append(values[1:4])
if values[0] == 'f':
face_i = []
text_i = []
norm_i = []
for v in values[1:4]:
w = v.split('/')
vOffset = 0
tOffset = 0
nOffset = 0
if (self.count >= 2):
for g in range(self.count - 1):
vOffset += len(self.meshData[g].vert_coords)
tOffset += len(self.meshData[g].text_coords)
nOffset += len(self.meshData[g].norm_coords)
face_i.append(int(w[0]) - 1 - vOffset)
text_i.append(int(w[1]) - 1 - tOffset)
norm_i.append(int(w[2]) - 1 - nOffset)
data.vertex_index.append(face_i)
data.texture_index.append(text_i)
data.normal_index.append(norm_i)
for k in range(self.count):
self.meshData[k].vertex_index = [
y for x in self.meshData[k].vertex_index for y in x
]
self.meshData[k].texture_index = [
y for x in self.meshData[k].texture_index for y in x
]
self.meshData[k].normal_index = [
y for x in self.meshData[k].normal_index for y in x
]
for i in self.meshData[k].vertex_index:
self.meshData[k].model.extend(self.meshData[k].vert_coords[i])
for i in self.meshData[k].texture_index:
self.meshData[k].model.extend(self.meshData[k].text_coords[i])
for i in self.meshData[k].normal_index:
self.meshData[k].model.extend(self.meshData[k].norm_coords[i])
self.meshData[k].model = np.array(self.meshData[k].model,
dtype='float32')
def loadDataInGPU(self):
for i in range(self.count):
texture_offset = len(self.meshData[i].vertex_index) * 12
normal_offset = (texture_offset +
len(self.meshData[i].texture_index) * 8)
self.VAOs.append(glGenVertexArrays(1))
glBindVertexArray(self.VAOs[i])
self.VBOs.append(glGenBuffers(1))
glBindBuffer(GL_ARRAY_BUFFER, self.VBOs[i])
glBufferData(
GL_ARRAY_BUFFER,
self.meshData[i].model.itemsize * len(self.meshData[i].model),
self.meshData[i].model, GL_STATIC_DRAW)
# position
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
self.meshData[i].model.itemsize * 3,
ctypes.c_void_p(0))
glEnableVertexAttribArray(0)
# texture
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
self.meshData[i].model.itemsize * 2,
ctypes.c_void_p(texture_offset))
glEnableVertexAttribArray(1)
#normal
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE,
self.meshData[i].model.itemsize * 3,
ctypes.c_void_p(normal_offset))
glEnableVertexAttribArray(2)
glBindVertexArray(0)
def renderALL(self, view, projection, model):
self.shader.bind()
for i in range(self.count):
self.textures[i].bind(GL_TEXTURE0)
self.shader.updateUniforms(view, projection, model,
self.materialData[i])
glBindVertexArray(self.VAOs[i])
glDrawArrays(GL_TRIANGLES, 0, len(self.meshData[i].vertex_index))
glBindVertexArray(0)
y=1010)
# Map
m, inter_map, inter_map_obj, shadow_map = loadmap("map\\draconis")
#m.check_unsigned_data(tile_dictionary, obj_dictionary)
# Lightning
Lightning.propagate_all(inter_map, inter_map_obj, shadow_map)
DLconf = DaylightConfigurator()
# Areas
shader_area_1 = ShaderArea([[30, 30], [30, 40], [40, 30], [40, 40]],
(0, 0, 100, 255), 50)
# Shader
shader_layer = Shader()
# Start LAN
LAN_SERVER = Popen("python src\\LAN.py")
# Entities
p = Player(DISC_POS, OFFSET, "src\\Char\\Lianna.png")
entity_dict = {}
# Socket Connection
context = zmq.Context()
socket = context.socket(zmq.DEALER)
HOST = "127.0.0.1"
PORT = 33000
receive_string = "tcp://" + HOST + ":" + str(PORT)
timer_string = "tcp://" + HOST + ":" + str(PORT + 1)
def draw_line(self, va: VertexArray, shader: Shader, point_count):
shader.bind()
va.bind()
glDrawArrays(GL_LINES, 0, point_count)
def __init__(self, caption="Game"):
self.screen = None
self.caption = caption
self.fullscreen = False
self.flags = True
self.shaders = Shader.shaderList()
