def render_world(self, camera): view = Matrix.lookat( camera.x + 19, camera.y, 15, camera.x + 19, camera.y, 0, 0,1,0) with self.fbo as frame: frame.clear(0,0.03,0.15,1) Shader.upload_projection_view(self.projection, view) Shader.upload_game(None) Shader.upload_light(self.ambient_light, self.cull_lights()) # parallax background pm = Matrix.transform( 0.75 * camera.x, camera.y * 0.5 - 12, 0, (19*4) * self.parallax_rep, 19, 0 ) self.shader_hud.bind() self.parallax.texture_bind() Shader.upload_model(pm) self.repquad.draw() Shader.upload_projection_view(self.projection, view) self.shader.bind() self.map.draw() # entities for obj in self.map.obj: obj.draw() if not self.is_over: self.projectile.draw()
def matrix(self): """Get the camera matrix to convert object from world coordinate to camera coordinate """ if self.__matrix is not None: return self.__matrix # calculate matrices translation = [ [1, 0, 0, -self.position.x], [0, 1, 0, -self.position.y], [0, 0, 1, -self.position.z], [0, 0, 0, 1] ] trans_mat = Matrix.new(translation) camera_zaxis = self.facing_dir.unit_vector camera_yaxis = self.up_dir.unit_vector camera_xaxis = camera_yaxis.cross(camera_zaxis).unit_vector alignment = [ [*camera_xaxis.to_list(), 0], [*camera_yaxis.to_list(), 0], [*camera_zaxis.to_list(), 0], [0, 0, 0, 1] ] alignment_mat = Matrix.new(alignment) # now, we have our world coordinate aligned with camera coordinate # calculate projection matrix proj_mat = self.projection.matrix self.__matrix = proj_mat * alignment_mat * trans_mat return self.__matrix
def __init__(self, angleOfView=60, aspectRatio=1, near=0.1, far=1000): super().__init__() self.projectionMatrix = Matrix.perspective(angleOfView=angleOfView, aspectRatio=aspectRatio, near=near, far=far) self.viewMatrix = Matrix.identity()
def model_matrix(self): phase = (pygame.time.get_ticks() - self.phase) / 1000.0 if self.flip: phase *= -1 offset = Matrix.translate(-0.5, -0.5) translate = Matrix.translate(self.pos.x + 0.5, self.pos.y + 0.5) scale = Matrix.scale(2.2, 2.2) rotate = Matrix.rotatez(phase * 1.0) return np.dot(offset, np.dot(rotate, np.dot(scale, translate)))
def draw(self, *args, **kwargs): Shader.upload_model(Matrix.identity()) glActiveTexture(GL_TEXTURE1) self.normal[0].texture_bind() glActiveTexture(GL_TEXTURE0) self.texture[0].texture_bind() self.vbo.draw(*args, **kwargs)
def main() -> None: print("Podaj pierwszy ciąg:") string1 = input() print("Podaj drugi ciąg:") string2 = input() matrix = Matrix(string1, string2) print(f"Najdłuższy wspólny podciąg: {matrix.right_bottom}") print(f"LCS: {matrix.lcs}")
def transform_point(self, point3d): pointarr = [*point3d.to_list(), 1.] pointmatrix = Matrix.new([[x] for x in pointarr]) result = self.camera.matrix * pointmatrix z = result.array[-1][0] x = result.array[0][0] y = result.array[1][0] try: return [x/z, y/z] except Exception as e: # DivisionByZero in fact return None
def _gen_random_matrix(self, n_rows, n_colums): """Generate a n_rows * n_columns matrix with random numbers. Arguments: n_rows {int} -- The number of rows. n_colums {int} -- The number of columns. Returns: Matrix """ data = [[random() for _ in range(n_colums)] for _ in range(n_rows)] return Matrix(data)
def matrix(self): if self.__matrix is not None: return self.__matrix d = self.plane_distance projection = [ [d, 0, 0, 0], [0, d, 0, 0], [0, 0, d, 0], # we want w coordinate of projected point to be the z coordinate [0, 0, 1, 0], ] self.__matrix = Matrix.new(projection) return self.__matrix
def __init__(self, height, properties, **kwargs): Item.__init__(self, height=height, properties=properties, **kwargs) flip = 1 offset = 0 if 'Flip' in properties: flip = -1 offset = 5 self.mat = Matrix.transform(self.pos.x + offset, self.pos.y - height * (1.0/8) + 1, 0, 5 * flip, 5, 1) self.loaded = self.sprite self.unloaded = image.Sprite(diffuse=Catapult.other) self.broken = image.Sprite(diffuse=Catapult.broken)
def response_from_server(self, method: int): """ Ask the server to solve a sudoku with a specific algorithm Parameters ---------- method : int The algorithm to execute to solve the sudoku """ self.flag = False self.response = "" if self.socket != None: message = "SOLVE " + str(method) + " " + self.sudoku_matrix try: self.socket.send(message.encode("utf-8")) response = self.socket.recv(1024).decode("utf-8") if response != "": response_split = response.split(" ") if response_split[1] != "-1": server = response_split[0] position = int(response_split[1]) number = response_split[2] print("Before built matrix") Matrix.print_matrix(Matrix.build_matrix(self.sudoku_matrix)) matriz_list_temp = Matrix.to_list(self.sudoku_matrix) matriz_list_temp[position] = number self.sudoku_matrix = Matrix.to_str(matriz_list_temp) print(response) self.response = response print("After built matrix") Matrix.print_matrix(Matrix.build_matrix(self.sudoku_matrix)) else: self.response = response except socket.timeout as ex: print("Error: Connection timeout. A response cannot be found for method: " + str(method) + " =>", ex) else: print("Error: A valid connection doesn't created, a response can't be waited") self.flag = True self.thread = None
def render(self): glClearColor(1,0,1,1) glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) camera = self.camera.copy() if self.projectile: camera.x = min(max(self.projectile.pos.x - 19, 0), self.camera_max) self.follow_cam = camera elif self.follow_cam: camera = self.follow_cam self.render_hud(camera) self.render_world(camera) mat = Matrix.scale(self.size.x, self.size.y) Shader.upload_projection_view(self.ortho, Matrix.identity()) Shader.upload_model(mat) self.fbo.bind_texture() self.post.bind() self.quad.draw() y = self.size.x * (160./800) # hud background pm = Matrix.transform( 0, y, 0, self.size.x, -y, 1 ) self.shader_hud.bind() self.hudbg.texture_bind() Shader.upload_model(pm) self.quad.draw() # ui pm = Matrix.transform( 0, self.hud_ui.height, 0, self.hud_ui.width, -self.hud_ui.height, 1 ) self.hud_ui.draw() self.shader_hud.bind() Shader.upload_model(pm) self.quad.draw() # messagebox mat = Matrix.translate(self.size.x / 2 - self.hud_msgbox.width / 2, self.size.y - self.hud_msgbox.height) Shader.upload_model(mat) self.hud_msgbox.draw() # scrollbar mat = Matrix.translate(0, y-22) Shader.upload_model(mat) self.scrollbar.draw() pygame.display.flip()
def _items_mul_ratings(self, items, ratings): """Multiply a dense matrix(item matrix) with sparse matrix (rating matrix). The result(users) is a k * m matrix, m stands for number of user_ids. Arguments: items {Matrix} -- k * n matrix, n stands for number of item_ids. ratings {dict} -- The items ratings by users. {user_id: {item_id: rating}} Returns: Matrix -- User matrix. """ def f(items_row, user_id): item_ids = iter(ratings[user_id].keys()) scores = iter(ratings[user_id].values()) col_nos = map(lambda x: self.item_ids_dict[x], item_ids) _items_row = map(lambda x: items_row[x], col_nos) return sum(a * b for a, b in zip(_items_row, scores)) ret = [[f(items_row, user_id) for user_id in self.user_ids] for items_row in items.data] return Matrix(ret)
def init(self, size, fullscreen=False): flags = OPENGL|DOUBLEBUF if fullscreen: flags |= FULLSCREEN pygame.display.set_mode(size.xy, flags) pygame.display.set_caption('Ancient Earth') i = pygame.display.Info() self.size = Vector2i(i.current_w, i.current_h) glMatrixMode(GL_MODELVIEW) glEnable(GL_TEXTURE_2D) glDisable(GL_CULL_FACE) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA) image.setup() self.stage = 1 self.projection = Matrix.perspective(75, self.size, 0.1, 100) self.ortho = Matrix.ortho(self.size) v = np.array([ 0,0,0, 0,0, 1,0,0, 1,0, 1,1,0, 1,1, 0,1,0, 0,1, ], np.float32) i = np.array([0,1,2,3], np.uint32) self.quad = VBO(GL_QUADS, v, i) # parallax self.parallax_rep = 10 v = np.array([ 0,0,0, 0,1, 1,0,0, self.parallax_rep, 1, 1,1,0, self.parallax_rep, 0, 0,1,0, 0,0, ], np.float32) i = np.array([0,1,2,3], np.uint32) self.repquad = VBO(GL_QUADS, v, i) self.parallax = Image('texture/sky.png', wrap=GL_REPEAT) self.hudbg = Image('texture/hud_bottom.png') self.fbo = FBO(self.size, format=GL_RGB8, depth=True) self.shader = Shader.load('default') self.shader_hud = Shader.load('hud') self.post = Shader.load('post') self.windmax = 1.0 self.random_wind() self.ambient_light = (1.0, 1.0, 1.0) fontsize = 16 + int(self.res_hack() * 14) self.map = Map('map.json') self.clock = pygame.time.Clock() self.hud_msgbox = HUD(Vector2i(500,100), 'msgbox') self.hud_ui = HUD(Vector2i(self.size.x, self.size.x * (160./800)), 'ui') self.scrollbar = HUD(Vector2i(self.size.x,28), 'scrollbar') self.font = self.hud_msgbox.create_font(size=fontsize) self.font_ui = self.hud_ui.create_font(size=fontsize, font='Comic Sans MS') self.camera_max = self.map.width - 38 self.catapults = [self.map.get_named_item('Catapult 1'), self.map.get_named_item('Catapult 2')] self.reset() with self.hud_msgbox: self.hud_msgbox.clear((0,1,1,1))
def model_matrix(self): return Matrix.translate(self.pos.x, self.pos.y)
def rotate(self, x, y, z, localCoord=False): matrix = Matrix.rotateX(x) @ Matrix.rotateY(y) @ Matrix.rotateZ(z) self.applyMatrix(matrix, localCoord)
def scale(self, x, y, z, localCoord=False): matrix = Matrix.scale(x, y, z) self.applyMatrix(matrix, localCoord)
def translate(self, x, y, z, localCoord=False): matrix = Matrix.translate(x, y, z) self.applyMatrix(matrix, localCoord)
def handle(self, *args, **options): m = Matrix() m.pantsMatrixToCsv() self.stdout.write(self.style.SUCCESS(f"All tops are added in matrix!"))
def __init__(self): self.transform = Matrix.identity() self.parent = None self.children = []