def _CreteAsteroid(self, **kwargs): go = gameObject.GameObject(kwargs["callable"]) go.Type = "Asteroid" go.asteroidType = kwargs["asteroidType"] go.transform = transform.Transform() go.transform.x = kwargs["transform"].x go.transform.y = kwargs["transform"].y go.transform.speed = kwargs["transform"].speed go.transform.rotation = kwargs["transform"].rotation go.transform.rotationSpeed = kwargs["transform"].rotationSpeed if go.asteroidType is AsteroidType.large: go.sound = self.bigAsteroidExplosionSound go.radius = 40 image, path = self.itemFactory.getAsteroid(AsteroidType.large) go.Render = renderer.Renderer(80, 80, path, go.transform, image, None, go.Type) elif go.asteroidType is AsteroidType.medium: go.sound = self.mediumAsteroidExplosionSound go.radius = 25 go.transform.speed += 0.2 image, path = self.itemFactory.getAsteroid(AsteroidType.medium) go.Render = renderer.Renderer(50, 50, path, go.transform, image, None, go.Type) else: go.sound = self.smallAsteroidExplosionSound go.transform.speed += 0.4 go.radius = 15 image, path = self.itemFactory.getAsteroid(AsteroidType.small) go.Render = renderer.Renderer(30, 30, path, go.transform, image, None, go.Type) go.Render.setCacheMode(QGraphicsItem.DeviceCoordinateCache) self.SceneManager.scene.addItem(go.Render) return go
def paste_below_item(parent, scene): ''' Paste items under a selected symbol ''' LOG.debug('Pasting below item ' + repr(parent)[slice(0, 20)]) symbols = [] for item_list, _ in COPY_PASTE: states = [i for i in item_list if isinstance(i, ogAST.State)] for i in [ c for c in item_list if not isinstance(c, (ogAST.State, ogAST.TextArea, ogAST.Start)) ]: LOG.debug('PASTE ' + str(i)) # Create the new item from the AST description new_item = Renderer.render(i, scene=CLIPBOARD, parent=None, states=states) # Check that item is compatible with parent if (type(new_item).__name__ in parent.allowed_followers): # Move the item from the clipboard to the scene Renderer.add_to_scene(new_item, scene) new_item.pos_x = new_item.pos_y = 0.0 symbols.append(new_item) else: raise TypeError( 'Cannot paste here ({t1} cannot follow {t2})'.format( t1=type(new_item), t2=type(parent))) return symbols
def _CreateProjectile(self, **kwargs): width = 4 height = -12 go = gameObject.GameObject(kwargs["callable"]) go.Type = "Projectile" go.name = kwargs["name"] go.transform.x = kwargs["transform"].x go.transform.y = kwargs["transform"].y go.transform.rotation = kwargs["transform"].rotation go.transform.speed = kwargs["transform"].speed go.transform.rotationSpeed = kwargs["transform"].rotationSpeed if kwargs["playerType"] is PlayerType.player1: go.Render = renderer.Renderer(width, height, None, go.transform, None, Qt.gray, go.Type) if kwargs["playerType"] is PlayerType.player2: go.Render = renderer.Renderer(width, height, None, go.transform, None, Qt.red, go.Type) if kwargs["playerType"] is PlayerType.player3: go.Render = renderer.Renderer(width, height, None, go.transform, None, Qt.green, go.Type) if kwargs["playerType"] is PlayerType.player4: go.Render = renderer.Renderer(width, height, None, go.transform, None, Qt.yellow, go.Type) self.SceneManager.scene.addItem(go.Render) go.Render.moveItem() go.Render.rotateItem() return go
def __init__(self): application = self #global initialization pyxel.init(255, 255, caption="Nearym Quest", scale=3) self.debugOverlay = False self.camera = Camera() self.streamingArea = Box() self.streamingArea.size = Vector2f(512, 512) self.streamingArea.center = Vector2f(0, 0) self.renderer = Renderer() self.physics = Physics() random.seed(0) # Event Manager self.inputManager = InputManager() self.inputManager.addInput( Input(InputType.BUTTON, InputNotify.PRESSED, [pyxel.KEY_F1], 'debug')) # world and player self.LoadMap() self.draw_count = 0 # has to be completely at the end of init pyxel.run(self.update, self.draw)
class Engine: def __init__(self): self.running = True self.screen = pg.display.set_mode( (SCREENWIDTH, SCREENHEIGHT), pg.DOUBLEBUF | pg.RESIZABLE | pg.HWSURFACE) self.env = Environment3() self.camera = Camera(SCREENWIDTH, SCREENHEIGHT, THETA_W, THETA_H, NEAR, FAR, self.env.sectors[0], self.env, False) self.renderer = Renderer() def run(self): pg.init() pg.display.set_caption('2.5D Engine') clock = pg.time.Clock() while self.running: self.processInputs() self.camera.processEvents(pg.event.get()) self.camera.update(self.env, False) self.renderer.renderFrame(self.screen, self.camera, self.env) pg.display.update() clock.tick() def processInputs(self): events = pg.event.get() for event in events: if event.type == pg.QUIT: self.running = False self.camera.processEvents(events)
def __init__(self): self.running = True self.screen = pg.display.set_mode( (SCREENWIDTH, SCREENHEIGHT), pg.DOUBLEBUF | pg.RESIZABLE | pg.HWSURFACE) self.env = Environment3() self.camera = Camera(SCREENWIDTH, SCREENHEIGHT, THETA_W, THETA_H, NEAR, FAR, self.env.sectors[0], self.env, False) self.renderer = Renderer()
def init(self, stateManager): self.player = Player(0, 0, -1.0, 0.0, 0.0, 0.66) self.map = Map("level1.png", self.player) self.oldMapPos = (int(self.player.posX), int(self.player.posY)) self.renderer = Renderer(stateManager.display, self.player, self.map) # Mouse for FPS pygame.event.set_grab(True) pygame.mouse.set_visible(False) # Play music if Settings.MUSIC: pygame.mixer.music.load("Resources/Sounds/Music/turmoil.ogg") pygame.mixer.music.play(-1)
class PreviewCanvas(object): def __init__(self, parent, sf, notations, sd=SongDecorator(), embedded=False): object.__init__(self) show_link = not embedded and platform.system() != 'Linux' self.link = None if show_link: self.main_panel = wx.Window(parent) bSizer = wx.BoxSizer(wx.VERTICAL) self.link = wx.adv.HyperlinkCtrl( self.main_panel, 0, _("Copy formatted song to clipboard"), '') tt = wx.ToolTip( _("Copy formatted song to clipboard, so that it can be pasted in any program and printed" )) self.link.SetToolTip(tt) bSizer.Add(self.link, 0, wx.EXPAND) parent = self.main_panel self.panel = wx.ScrolledWindow(parent, style=wx.BORDER_DOUBLE) self.panel.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) self.pixedScrolled = 10 self.panel.SetScrollbars(self.pixedScrolled, self.pixedScrolled, 0, 0) self.panel.Bind(wx.EVT_PAINT, self.OnPaint, self.panel) self.panel.SetBackgroundColour(wx.WHITE) self.text = "" if show_link: bSizer.Add(self.panel, 1, wx.EXPAND) else: self.main_panel = self.panel #SongFormat self.renderer = Renderer(sf, sd, notations) if show_link: self.main_panel.SetSizer(bSizer) self.main_panel.Layout() def OnPaint(self, e): #print("OnPaint") dc = wx.AutoBufferedPaintDC(self.panel) self.panel.PrepareDC(dc) dc.SetBackground(wx.WHITE_BRUSH) dc.Clear() w, h = self.renderer.Render(self.text, dc) self.panel.SetVirtualSize(wx.Size(w, h)) def Refresh(self, text): self.text = text self.panel.Refresh() def SetDecorator(self, sd): self.renderer.SetDecorator(sd)
def DrawOnDC(self, dc): decorator = self.pref.decorator if self.pref.labelVerses else SongDecorator( ) r = Renderer(self.pref.format, decorator, self.pref.notations) start, end = self.text.GetSelection() if start == end: w, h = r.Render(self.text.GetText(), dc) else: w, h = r.Render(self.text.GetText(), dc, self.text.LineFromPosition(start), self.text.LineFromPosition(end)) return w, h
def initUI(self): self.resize(1280, 720) self.center() # Put a real title here when I think of something to name this self.setWindowTitle('Yoshi\'s new Island Editor') # Set up initial ui layout vLayout = QtWidgets.QVBoxLayout(self) self.setLayout(vLayout) # Placeholder for where Obj editor widget will go label = QtWidgets.QLabel("Placeholder") # Place View and Editor widgets into horizontal layout hLayout = QtWidgets.QHBoxLayout() hLayout.addWidget(label) hLayout.addWidget(self.view) # Setup Zoom widget # noinspection PyUnresolvedReferences self.zoom.valueChanged.connect(self.ZoomAdjust) zoomLayout = QtWidgets.QHBoxLayout() zoomLayout.addWidget(self.zoom) zoomLayout.addWidget(self.zoomLabel) # Place everything into the vertical layout vLayout.addLayout(hLayout) vLayout.addLayout(zoomLayout) # Load level data filename = input("input a level name: ") levelData = Reader.LoadLevelData(filename) # Render Stuff # Render Collision for col in range(0, len(levelData.Data[0])): Renderer.RenderCollision(levelData.Data[0][col], self.view) # Render Objects for obj in range(0, len(levelData.Data[1])): Objects.InitObject(levelData.Data[1][obj], self.view) # Render Areas for area in range(0, len(levelData.Data[2])): Renderer.RenderAreas(levelData.Data[2][area], self.view) # Render Paths for path in range(0, len(levelData.Data[3])): Renderer.RenderPaths(levelData.Data[3][path], self.view) self.setWindowTitle('Yoshi\'s new Island Editor | ' + filename)
def OnExportAsHtml(self, evt): n = self.AskExportFileName(_("HTML file"), "html") if n is not None: h = HtmlExporter(self.pref.format) r = Renderer(self.pref.format, h, self.pref.notations) start, end = self.text.GetSelection() if start == end: r.Render(self.text.GetText(), None) else: r.Render(self.text.GetText(), None, self.text.LineFromPosition(start), self.text.LineFromPosition(end)) with open(n, "w", encoding='utf-8') as f: f.write(h.getHtml()) f.close()
def __init__(self): self.player_class = 0 self.player_id = None self.player_x = 300 self.player_y = 300 self.player_lead_x_change = 0 self.player_lead_y_change = 0 self.previous_x = 0 self.previous_y = 0 #Server response flag self.is_registered = False #self.ammo = ammo self.time_lasted = 0 self.average_performance = 0 #Feature variables self.health = 100 self.score = 0 #measures endurance against remaining health self.class_packs = 0 #measures agility self.out_of_bounds_OR_game_over = 0 #apply game rules, violation of which will cost something #resourcefulness #ammo and shields self.renderer = Renderer.Renderer()
def main(pattern_file, img_file): pattern = cv2.imread('pattern.png', 0) # trainImage matcher = cm.CorrespondenceMatcher(pattern) estimator = pe.ProjectionEstimator() renderer = rr.Renderer() print("loading image " + img_file) query = cv2.imread(img_file, 0) # queryImage q_h, q_w = query.shape[:2] p_h, p_w = pattern.shape[:2] print("finding homography for " + img_file) h = matcher.find_homography(query) print("homography matrix " + str(h)) print("finding extrinsic camera parameter for " + img_file) rx, ry, rz, px, py, pz, residual = estimator.compute_extrinsic( h, p_w, q_w, FOCAL_LENGTH, PATTERN_SIZE) print("rotation: " + str([rx, ry, rz])) print("position: " + str([px, py, pz])) print("parameter residual " + str(residual)) print("rendering result generated from pattern " + pattern_file + " and image " + img_file) renderer.render(img_file, rx, ry, rz, px, py, pz)
def resetBoard(): nonlocal board1, renderer, controller, count, srcTile, desTile, ID, currentTile \ ,displayHover, currentSide, wep_sniper, wep_assault, wep_shotgun, soldiers f = open("map.txt") tiles = {} for line in f.readlines(): cols = line.split() passable = (cols[2] == "True") tiles[(int(cols[0]), int(cols[1]))] = board.Tile( (int(cols[0]), int(cols[1])), passable, int(cols[3]), int(cols[4]), int(cols[5]), int(cols[6])) #print(tiles) board1 = board.Board(15, 20, tiles) for i in range(0, board1.width): for j in range(0, board1.height): exec( compile( open("soldier.txt", "rb").read(), "soldier.txt", 'exec')) # exec(compile(open("map.txt", "rb").read(), "map.txt", 'exec')) print("HI!") renderer = Renderer.Renderer(board1, screen) controller = Controller.Controller() count = 0 srcTile = None desTile = None ID = None currentTile = None displayHover = 0 currentSide = 0
def __init__(self): super(VehicleDetector, self).__init__() # Sliding windows self.yStart = 400 self.yStop = 650 self.x_overlap = 0.65 self.y_overlap = 0.75 # Filter self.filterThreshold = 2 self.filter = F.Filter(self.filterThreshold) # Print summary to check correct parameters self.Summary() # Sub-components self.renderer = R.Renderer() self.database = D.Database() cars, notcars = self.database.GetListOfImages() self.classifier = C.Classifier(cars, notcars, loadFromFile=True, database=self.database) # Output video parameters self.outputToImages = 0 self.outputVideoName = self.database.GetOutputVideoPath() # Train classifier ? self.trainClassifier = 1 # TODO: implement the loading # Bounding boxes self.bboxes = self.LoadSlidingWindows()
def __init__(self): super(Test, self).__init__() self.database = D.Database() cars, notcars = self.database.GetListOfImages() self.classifier = C.Classifier(cars, notcars, loadFromFile=True, database=self.database) self.renderer = R.Renderer() self.vehicleDetector = V.VehicleDetector()
def __init__(self, direction, speed, socket_data_list): self.socket_data_list = socket_data_list self.color = red self.direction = direction self.speed = speed self.damage_point = gameObject.damage_point self.top_attack_startx = 0 self.bottom_attack_startx = 0 self.left_attack_starty = 0 self.right_attack_starty = 0 self.x = 0 self.y = 0 self.end_x = 0 self.end_y = 0 self.isActive = True self.renderer = Renderer.Renderer() self.aum = AUM.AttackUnitMover() self.aum.initialize(self) self.top_side_attack_config = [] #configuration for top attack self.left_side_attack_config = [] #configuration for left attack self.bottom_side_attack_config = [] #configuration for bottom attack self.right_side_attack_config = [] #configuration for right attack self.create_attack_start_list() #initializes attack data from server self.create_attack_config() #populates attack config lists
def resize(self, event): size = (event.width, event.height) self.image = Image.new('RGBA', size) self._computeBands(size) self.display() self.renderer = Renderer.Renderer(self.master, self.image, self.colorspace.hasAlpha) self.config(image=self.renderer)
def __init__(self): # We create a MainWindow object and initialise with the UI from PMainWindowUi self.app = QtGui.QApplication(sys.argv) self.MainWindow = QtGui.QMainWindow() self.ui_m = MainWindowUi.Ui_MainWindow() self.ui_m.setupUi(self.MainWindow) # We connect all the buttons to their respective callback functions, called when the 'clicked' event is generated self.ui_m.pushButton.clicked.connect(self.openLoadStackDialog) self.ui_m.pushButton_2.clicked.connect(self.cutObj) self.ui_m.pushButton_3.clicked.connect(self.setSliceResolution) self.ui_m.pushButton_4.clicked.connect(self.changeColorMap) self.ui_m.pushButton_5.clicked.connect(self.takeSnapshot) #self.ui_m.pushButton_6.clicked.connect(self.saveAsVTKObj) self.ui_m.pushButton_7.clicked.connect(self.record) self.ui_m.pushButton_8.clicked.connect(self.removePoint) self.ui_m.pushButton_9.clicked.connect(self.addPoint) self.ui_m.pushButton_10.clicked.connect(self.renderV) #self.ui_m.pushButton_11.clicked.connect(self.openVTKObj) self.ui_m.pushButton_12.clicked.connect(self.changeBGColor) self.ui_m.pushButton_13.clicked.connect(self.resetCamera) self.ui_m.pushButton_11.clicked.connect(self.alignPlaneToX) self.ui_m.pushButton_14.clicked.connect(self.alignPlaneToZ) self.ui_m.pushButton_15.clicked.connect(self.alignPlaneToY) # Below are the toggle buttons self.ui_m.radioButton.toggled.connect(self.toggleOutline) self.ui_m.radioButton_2.toggled.connect(self.togglePlane) self.ui_m.radioButton_3.toggled.connect(self.toggleClippingBox) self.ui_m.radioButton_4.toggled.connect(self.toggleVolume) self.ui_m.radioButton_5.toggled.connect(self.toggleSlice) self.ui_m.radioButton_6.toggled.connect(self.toggleAlignedPlane) self.ui_m.horizontalSlider.valueChanged.connect(self.valueChangeSlider) # These are the 'Clip' and 'Set' (set slice reolution) buttons which are initially disabled, enabled only when the Plane Widget is active self.ui_m.pushButton_2.setEnabled(False) self.ui_m.pushButton_3.setEnabled(False) self.ui_m.pushButton_10.setEnabled(False) self.ui_m.pushButton_11.setEnabled(False) self.ui_m.pushButton_14.setEnabled(False) self.ui_m.pushButton_15.setEnabled(False) self.ui_m.horizontalSlider.setEnabled(False) self.Dialog = QtGui.QDialog() self.ui_l = Ui_Dialog() self.ui_l.setupUi(self.Dialog) self.pRenderer = Renderer.Renderer() self.pRenderer.renderBlank(self.ui_m.qvtkWidget) self.MainWindow.show() self.pCutObj = CutObj.CutObj() self.histWidg = HistogramWidget.HistogramWidget() self.loadStack = LoadStack.LoadStack(self) sys.exit(self.app.exec_())
def checkParams(self, fractal): for current in filenames: args = Arguer.Argue([ fractal, current, '--dim', filenames[current], '--zoom', '2', '--pan', '[-1.0,1.0]', '--iters', '50', '--com', '[-0.75,0.11]' ]) r = Renderer.Render(args).draw() args = Arguer.Argue([ fractal, current, '--dim', filenames[current], '--zoom', '5', '--pan', '[2.5,-0.5]', '--iters', '13' ]) r = Renderer.Render(args).draw() self.assertTrue(os.path.isfile(current)) self.assertTrue( self.checkDims( filenames[current][:filenames[current].index('x')], filenames[current][filenames[current].index('x') + 1:], current))
def moveallsearchers(searchers, count, window): reachedend = False for i in range(count): if searchers[i].x == Renderer.grid_width - 1 and searchers[ i].y == Renderer.grid_height - 1: reachedend = True Renderer.drawpath(searchers[i], window) break if searchers[i].randmoves == 1 or (searchers[i].mutate and searchers[i].count > (4 * lifespan) / 6): movesearcher(searchers[i], random.randint(0, 3)) else: movesearcher(searchers[i], searchers[i].dna[searchers[i].count]) searchers[i].count += 1 return reachedend
def paste_floating_objects(scene): ''' Paste items with no parents (states, text areas) ''' symbols = [] LOG.debug('PASTING FLOATING OBJECTS') for item_list, terminators in COPY_PASTE: # states is a list passed as parameter - not a generator: start = [i for i in item_list if isinstance(i, ogAST.Start)] states = [i for i in item_list if isinstance(i, ogAST.State)] text_areas = (i for i in item_list if isinstance(i, ogAST.TextArea)) labels = (i for i in item_list if isinstance(i, ogAST.Floating_label)) procedures = (i for i in item_list if isinstance(i, ogAST.Procedure)) processes = (i for i in item_list if isinstance(i, ogAST.Process)) for state in states: # First check if state has already been pasted try: new_item = Renderer.render(state, scene=CLIPBOARD, terminators=terminators, states=states) except TypeError as err: LOG.debug('No paste "' + state.inputString + '" -' + str(err)) # Discard terminators (explanation given in Renderer._state) pass else: LOG.debug('PASTE STATE "' + state.inputString + '"') symbols.append(new_item) # Insert the new state at click coordinates Renderer.add_to_scene(new_item, scene) for each in chain(text_areas, labels, procedures, processes): LOG.debug('PASTE TA/LAB/PROC') new_item = Renderer.render(each, scene, states=states) symbols.append(new_item) if start: start, = start LOG.debug('PASTE START') for item in scene.visible_symb: if isinstance(item, sdlSymbols.Start): raise TypeError('Only one START symbol is possible') new_item = Renderer.render(start, scene, states=states) symbols.append(new_item) return symbols
def __init__(self, game: GameMain, city: City) -> None: super().__init__(game) self.city = city game.city = self.city game.city_size = self.city.size self.eye_pos = ( [int(i / self.game.renderer.tile_size) for i in self.game.center]) game.renderer = Renderer(game, self.city, self.eye_pos) self.iso_eye_pos = ( [int(i) for i in game.renderer.cart2iso(self.eye_pos)])
def paste_below_item(parent, scene): ''' Paste items under a selected symbol ''' LOG.debug('Pasting below item ' + repr(parent)[slice(0, 20)]) symbols = [] for item_list, _ in COPY_PASTE: states = [i for i in item_list if isinstance(i, ogAST.State)] for i in [c for c in item_list if not isinstance (c, (ogAST.State, ogAST.TextArea, ogAST.Start))]: LOG.debug('PASTE ' + str(i)) # Create the new item from the AST description new_item = Renderer.render(i, scene=CLIPBOARD, parent=None, states=states) # Check that item is compatible with parent if (type(new_item).__name__ in parent.allowed_followers): # Move the item from the clipboard to the scene Renderer.add_to_scene(new_item, scene) new_item.setPos(0, 0) symbols.append(new_item) else: raise TypeError('Cannot paste here ({t1} cannot follow {t2}' .format(t1=type(new_item), t2=type(parent))) return symbols
def paste_floating_objects(scene): ''' Paste items with no parents (states, text areas) ''' symbols = [] LOG.debug('PASTING FLOATING OBJECTS') for item_list, terminators in COPY_PASTE: # states is a list passed as parameter - not a generator: start = [i for i in item_list if isinstance(i, ogAST.Start)] states = [i for i in item_list if isinstance(i, ogAST.State)] text_areas = (i for i in item_list if isinstance(i, ogAST.TextArea)) labels = (i for i in item_list if isinstance(i, ogAST.Floating_label)) procedures = (i for i in item_list if isinstance(i, ogAST.Procedure)) processes = (i for i in item_list if isinstance(i, ogAST.Process)) for state in states: # nesting is not copied, because the nested content is a scene # that is just referenced.. content must be actually copied # to a new scene only if a state is renamed (this will preserve # the nesting content of the original state) # First check if state has already been pasted try: new_item = Renderer.render(state, scene=CLIPBOARD, terminators=terminators, states=states) except TypeError as err: LOG.debug('No paste "' + state.inputString + '" -' + str(err)) # Discard terminators (explanation given in Renderer._state) pass else: LOG.debug('PASTE STATE "' + state.inputString + '"') symbols.append(new_item) # Insert the new state at click coordinates Renderer.add_to_scene(new_item, scene) for each in chain(text_areas, labels): LOG.debug('PASTE Text Area/Label') new_item = Renderer.render(each, scene, states=states) symbols.append(new_item) for each in chain(procedures, processes): LOG.debug('PASTE Process/Procedure') new_item = Renderer.render(each, scene, states=states) symbols.append(new_item) new_item.nested_scene = scene.create_subscene( new_item.context_name) # Render recursively, creating any required scene try: new_item.nested_scene.render_everything(each.content) except TypeError as err: LOG.debug(str(err)) if start: start, = start LOG.debug('PASTE START') for item in scene.visible_symb: if isinstance(item, sdlSymbols.Start): raise TypeError('Only one START symbol is possible') new_item = Renderer.render(start, scene, states=states) symbols.append(new_item) return symbols
def render_scene(self, dimensions, image_name): to_canvas = TransformationFactory.to_canvas(dimensions) randy = Renderer(dimensions) # initialize renderer print("Rendering...") # TO VIEW SPACE scene_edges = [] scene_faces = [] for model in self.scene.models: for face in model.faces: scene_faces.append( Face(face.v1, face.v2, face.v3, random_color())) print("faces in scene: {}".format(len(scene_faces))) scene_faces = transform_faces(scene_faces, self.to_view_space) print("basis swap to camera complete") # RENDER BEFORE CULLING self.render_face_edges(scene_faces, dimensions, image_name + "_beforeCulling", [self.to_screen_space, to_canvas]) # CULLING before_filter = len(scene_faces) culled_faces = [] for face in scene_faces: if not face.should_cull(): culled_faces.append(face) difference = before_filter - len(culled_faces) print(str(difference) + " FACES CULLED") # TO SCREEN SPACE scene_faces = transform_faces(culled_faces, self.to_screen_space) # RENDER AFTER CULLING self.render_face_edges(scene_faces, dimensions, image_name + "_afterCulling", [to_canvas]) # TODO: Clipping scene_faces = clip(scene_faces) self.render_face_edges(scene_faces, dimensions, image_name + "_afterClipping", [to_canvas]) # TODO: RENDER HERE scene_faces = transform_faces(scene_faces, to_canvas) for face in scene_faces: randy.rasterize(face) randy.save(image_name + "_afterRasterizing") # TODO: Rasterize # TODO: Z-Buffer print("image saved!")
def start(): win_offset_y = 25 os.environ['SDL_VIDEO_WINDOW_POS'] = str(0) + "," + str(win_offset_y) pygame.init() info_obj = pygame.display.Info() #print(info_obj) screen_dim = Vec2d(int(info_obj.current_w), int(info_obj.current_h - win_offset_y)) em = EventManager.EventManager() game_engine = GameEngine.GameEngine(em, screen_dim) renderer = Renderer.Renderer(em, game_engine, screen_dim) controller = Controller.Controller(em, game_engine) game_engine.run()
def __init__(self, parent, sf, notations, sd=SongDecorator(), embedded=False): object.__init__(self) show_link = not embedded and platform.system() != 'Linux' self.link = None if show_link: self.main_panel = wx.Window(parent) bSizer = wx.BoxSizer(wx.VERTICAL) self.link = wx.adv.HyperlinkCtrl( self.main_panel, 0, _("Copy formatted song to clipboard"), '') tt = wx.ToolTip( _("Copy formatted song to clipboard, so that it can be pasted in any program and printed" )) self.link.SetToolTip(tt) bSizer.Add(self.link, 0, wx.EXPAND) parent = self.main_panel self.panel = wx.ScrolledWindow(parent, style=wx.BORDER_DOUBLE) self.panel.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) self.pixedScrolled = 10 self.panel.SetScrollbars(self.pixedScrolled, self.pixedScrolled, 0, 0) self.panel.Bind(wx.EVT_PAINT, self.OnPaint, self.panel) self.panel.SetBackgroundColour(wx.WHITE) self.text = "" if show_link: bSizer.Add(self.panel, 1, wx.EXPAND) else: self.main_panel = self.panel #SongFormat self.renderer = Renderer(sf, sd, notations) if show_link: self.main_panel.SetSizer(bSizer) self.main_panel.Layout()
def game_start(args): engine = g.GameEngine(int(args.size)) re = None num_games = int(args.number) num_humans = int(args.humans) board_size = int(args.size) gui = int(args.graphical) if gui: re = r.Renderer(engine) re.window_setup(500, 500) for i in range(num_games): winner, num_moves = play_game(engine, num_humans, re, FIRST_AI, SECOND_AI, board_size) print('Player', i, 'won in', num_moves, 'moves.')
def __init__(self, direction, speed): self.color = red self.direction = direction self.speed = speed self.x = 0 self.y = 0 self.end_x = 0 self.end_y = True self.isActive = True self.renderer = Renderer.Renderer() self.aum = AUM.AttackUnitMover() self.top_side_attack_config = [] self.left_side_attack_config = [] self.bottom_side_attack_config = [] self.right_side_attack_config = [] self.create_attack_config()
def __init__(self): self.player_id = None self.player_x = 300 self.player_y = 300 self.player_lead_x_change = 0 self.player_lead_y_change = 0 self.player_class = 0.14026667 #self.ammo = ammo self.time_lasted = 0 self.average_performance = 0 #Possible Feature variables self.health = 100 self.score = 0 #measures endurance self.class_packs = 0 #measures agility #apply game rules, violation of which will cost something #resourcefulness #ammo and shields self.renderer = Renderer.Renderer()
''' Created on Nov 8, 2012 @author: Wighton ''' from Planner import * from Renderer import * planner = Planner(500,500) planner.loadObstacles(open("/Users/Wighton/Documents/Aptana_Workspace/MotionPlanner/obstacles", "r")); planner.loadRobot(open("/Users/Wighton/Documents/Aptana_Workspace/MotionPlanner/robot", "r")); planner.getRoadmap() renderer = Renderer(700, 700) renderer.addSceneObject(planner) renderer.start()
del im del t t = self.image self.image = self.tomorrow self.tomorrow = t self.ticks += 1 if __name__ == "__main__": logging.getLogger().setLevel(logging.INFO) logging.basicConfig() args = Renderer.cmd_line_args() LN2015 = Renderer.Player('gameoflife', MADRIX_X, MADRIX_Y, fps=24, args=args) LN2015.load_sprite("gameoflife", 50, GOL()) alive = True while alive: alive = LN2015.run() if 'windows' in platform.platform().lower(): ffmpeg_exe = 'C:\\Users\\admin\\Desktop\\ffmpeg-20150921-git-74e4948-win64-static\\bin\\ffmpeg.exe' else: ffmpeg_exe = 'ffmpeg' LN2015.export_video(ffmpeg_exe)
def startGame(self): if self._debugMode: print("Initializing game...") self._running = True self._mainWindow = tk.Tk() self._mainWindow.protocol("WM_DELETE_WINDOW", self.stopGame) self._mainWindow.title(self._title) self._mainWindow.resizable(0, 0) self._renderer = Renderer(self) self._gameInput = Input(self) try: self._mainCanvas = tk.Canvas( self._mainWindow, width=self._size[0], height=self._size[1], borderwidth=0 ) self._mainCanvas.pack() self._mainCanvas.update() except: self._mainWindow = None if self._debugMode: print("!!! Unexpected error occurred on startGame.") raise if self._debugMode: print("Game running...") lastTimer = self.getTimeMicros() lastTime = lastTimer renderDelta = 0 updateDelta = 0 frames = 0 updates = 0 microPerRender = 1000000 / self._targetFPS microPerUpdate = 1000000 / self._targetUPS while self._running: timeNow = self.getTimeMicros() timeDelta = (timeNow-lastTime) renderDelta += timeDelta updateDelta += timeDelta lastTime = timeNow if updateDelta > microPerUpdate: updateDelta -= microPerUpdate updates += 1 if self._currentScene is not None: self._gameScenes[self._currentScene].onUpdate( self._gameInput, timeDelta/1000000.0 ) self._gameInput._update() if not self._vSync or renderDelta > microPerRender: renderDelta -= microPerRender frames += 1 if self._currentScene is not None: self._renderer.clearAll(self._gameBG) self._gameScenes[self._currentScene].onRender( self._renderer, renderDelta ) if self._showFPS: self._renderer.setColor(Color(255, 255, 255)) self._renderer.drawString( (10, 5), self._infoText, tk.NW, tk.LEFT ) self.sleep(self._idleTime) if self.getTimeMicros() - lastTimer >= 1000000: self._PSInfo = [frames, updates, timeDelta/1000.0] self._infoText = "%d FPS, %d UPS [%0.2fms]" % ( frames, updates, timeDelta/1000.0 ) if self._debugMode: print(self._infoText) frames = 0 updates = 0 lastTimer = self.getTimeMicros() if self._currentScene is not None: self._gameScenes[self._currentScene].onExit() tk.sys.exit(0)
class Game: _debugMode = False _PSInfo = [-1, -1, -1] _infoText = "-1 FPS -1 UPS [0.00ms]" _mainWindow = None _mainCanvas = None _renderer = None _gameInput = None _currentScene = None _title = "ParticlePlay Game" _gameBG = Color(0, 0, 0) _size = (640, 480) _targetFPS = 30 _targetUPS = 30 _vSync = False _showFPS = True _running = False _idleTime = 0.002 _gameScenes = {} def setDebugMode(self, debug): self._debugMode = debug def setTitle(self, title): self._title = title if self._mainWindow is not None: self._mainWindow.title(title) def setSize(self, size): self._size = size def getSize(self): return self._size def getWidth(self): return self._size[0] def getHeight(self): return self._size[1] def setGameBG(self, color): self._gameBG = color def setTargetFPS(self, targetFPS): self._targetFPS = targetFPS def setTargetUPS(self, targetUPS): self._targetUPS = targetUPS def setIdleTime(self, idleTime): self._idleTime = idleTime def setShowFPS(self, showFPS): self._showFPS = showFPS def setVSync(self, vSync): self._vSync = vSync def getFPS(self): return self._PSInfo[0] def getUPS(self): return self._PSInfo[1] def addScene(self, sceneName, gameScene): gameScene.game = self gameScene.name = sceneName self._gameScenes[sceneName] = gameScene def getScene(self, sceneName): return self._gameScenes[sceneName] def removeScene(self, sceneName): del self._gameScenes[sceneName] def enterScene(self, scene, sceneName="UntitledScene"): if isinstance(scene, str): scene = self.getScene(scene) elif isinstance(scene, Scene): self.addScene(sceneName, scene) if scene is not None: if self._debugMode: if sceneName == "UntitledScene": print("Enter a new scene") else: print("Current Scene: " + scene.name) startGame = self._currentScene is None self._currentScene = scene.name scene.onInit() if startGame: self.startGame() def startGame(self): if self._debugMode: print("Initializing game...") self._running = True self._mainWindow = tk.Tk() self._mainWindow.protocol("WM_DELETE_WINDOW", self.stopGame) self._mainWindow.title(self._title) self._mainWindow.resizable(0, 0) self._renderer = Renderer(self) self._gameInput = Input(self) try: self._mainCanvas = tk.Canvas( self._mainWindow, width=self._size[0], height=self._size[1], borderwidth=0 ) self._mainCanvas.pack() self._mainCanvas.update() except: self._mainWindow = None if self._debugMode: print("!!! Unexpected error occurred on startGame.") raise if self._debugMode: print("Game running...") lastTimer = self.getTimeMicros() lastTime = lastTimer renderDelta = 0 updateDelta = 0 frames = 0 updates = 0 microPerRender = 1000000 / self._targetFPS microPerUpdate = 1000000 / self._targetUPS while self._running: timeNow = self.getTimeMicros() timeDelta = (timeNow-lastTime) renderDelta += timeDelta updateDelta += timeDelta lastTime = timeNow if updateDelta > microPerUpdate: updateDelta -= microPerUpdate updates += 1 if self._currentScene is not None: self._gameScenes[self._currentScene].onUpdate( self._gameInput, timeDelta/1000000.0 ) self._gameInput._update() if not self._vSync or renderDelta > microPerRender: renderDelta -= microPerRender frames += 1 if self._currentScene is not None: self._renderer.clearAll(self._gameBG) self._gameScenes[self._currentScene].onRender( self._renderer, renderDelta ) if self._showFPS: self._renderer.setColor(Color(255, 255, 255)) self._renderer.drawString( (10, 5), self._infoText, tk.NW, tk.LEFT ) self.sleep(self._idleTime) if self.getTimeMicros() - lastTimer >= 1000000: self._PSInfo = [frames, updates, timeDelta/1000.0] self._infoText = "%d FPS, %d UPS [%0.2fms]" % ( frames, updates, timeDelta/1000.0 ) if self._debugMode: print(self._infoText) frames = 0 updates = 0 lastTimer = self.getTimeMicros() if self._currentScene is not None: self._gameScenes[self._currentScene].onExit() tk.sys.exit(0) def stopGame(self): print("Attempting to close game...") if (self._currentScene is not None and not self._gameScenes[self._currentScene].willExit()): return if self._debugMode: print("Closing game...") self._running = False def getTimeMicros(self): return int(round(time.time() * 1000000)) def sleep(self, secs): if self._mainWindow is None: time.sleep(secs) else: self._mainWindow.update_idletasks() self._mainWindow.after(int(1000 * secs), self._mainWindow.quit) self._mainWindow.mainloop()