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)