def render(self, width, height, st, at): width = max(self.style.xminimum, width) height = max(self.style.yminimum, height) color = self.color or self.style.color rv = Render(width, height) if color is None or width <= 0 or height <= 0: return rv SIZE = 10 if width < SIZE or height < SIZE: tex = renpy.display.draw.solid_texture(width, height, color) else: tex = renpy.display.draw.solid_texture(SIZE, SIZE, color) rv.forward = Matrix2D(1.0 * SIZE / width, 0, 0, 1.0 * SIZE / height) rv.reverse = Matrix2D(1.0 * width / SIZE, 0, 0, 1.0 * height / SIZE) rv.blit(tex, (0, 0)) return rv
def draw(x0, x1, y0, y1): # Compute the coordinates of the left, right, top, and # bottom sides of the region, for both the source and # destination surfaces. # left side. if x0 >= 0: dx0 = x0 sx0 = x0 else: dx0 = dw + x0 sx0 = sw + x0 # right side. if x1 > 0: dx1 = x1 sx1 = x1 else: dx1 = dw + x1 sx1 = sw + x1 # top side. if y0 >= 0: dy0 = y0 sy0 = y0 else: dy0 = dh + y0 sy0 = sh + y0 # bottom side if y1 > 0: dy1 = y1 sy1 = y1 else: dy1 = dh + y1 sy1 = sh + y1 # Quick exit. if sx0 == sx1 or sy0 == sy1: return # Compute sizes. csw = sx1 - sx0 csh = sy1 - sy0 cdw = dx1 - dx0 cdh = dy1 - dy0 if csw <= 0 or csh <= 0 or cdh <= 0 or cdw <= 0: return # Get a subsurface. cr = crend.subsurface((sx0, sy0, csw, csh)) # Scale or tile if we have to. if csw != cdw or csh != cdh: if self.tile: ctw, cth = cdw, cdh xtiles = max(1, cdw // csw + (1 if cdw % csw else 0)) ytiles = max(1, cdh // csh + (1 if cdh % csh else 0)) if cdw % csw or cdh % csh: # Area is not an exact integer number of tiles if self.tile == "integer": if cdw % csw / float(csw) < self.tile_ratio: xtiles = max(1, xtiles - 1) if cdh % csh / float(csh) < self.tile_ratio: ytiles = max(1, ytiles - 1) # Set size of the used tiles (ready to scale) ctw, cth = csw * xtiles, csh * ytiles newcr = Render(ctw, cth) newcr.xclipping = True newcr.yclipping = True for x in range(0, xtiles): for y in range(0, ytiles): newcr.blit(cr, (x * csw, y * csh)) csw, csh = ctw, cth cr = newcr if csw != cdw or csh != cdh: # Subsurface needs scaling newcr = Render(cdw, cdh) newcr.forward = Matrix2D(1.0 * csw / cdw, 0, 0, 1.0 * csh / cdh) newcr.reverse = Matrix2D(1.0 * cdw / csw, 0, 0, 1.0 * cdh / csh) newcr.blit(cr, (0, 0)) cr = newcr # Blit. rv.blit(cr, (dx0, dy0)) return
def draw(x0, x1, y0, y1): # Compute the coordinates of the left, right, top, and # bottom sides of the region, for both the source and # destination surfaces. # left side. if x0 >= 0: dx0 = x0 sx0 = x0 else: dx0 = dw + x0 sx0 = sw + x0 # right side. if x1 > 0: dx1 = x1 sx1 = x1 else: dx1 = dw + x1 sx1 = sw + x1 # top side. if y0 >= 0: dy0 = y0 sy0 = y0 else: dy0 = dh + y0 sy0 = sh + y0 # bottom side if y1 > 0: dy1 = y1 sy1 = y1 else: dy1 = dh + y1 sy1 = sh + y1 # Quick exit. if sx0 == sx1 or sy0 == sy1: return # Compute sizes. csw = sx1 - sx0 csh = sy1 - sy0 cdw = dx1 - dx0 cdh = dy1 - dy0 if csw <= 0 or csh <= 0 or cdh <= 0 or cdw <= 0: return # Get a subsurface. cr = crend.subsurface((sx0, sy0, csw, csh)) # Scale or tile if we have to. if csw != cdw or csh != cdh: if self.tile: newcr = Render(cdw, cdh) newcr.xclipping = True newcr.yclipping = True for x in xrange(0, cdw, csw): for y in xrange(0, cdh, csh): newcr.blit(cr, (x, y)) cr = newcr else: newcr = Render(cdw, cdh) newcr.forward = Matrix2D(1.0 * csw / cdw, 0, 0, 1.0 * csh / cdh) newcr.reverse = Matrix2D(1.0 * cdw / csw, 0, 0, 1.0 * cdh / csh) newcr.blit(cr, (0, 0)) cr = newcr # Blit. rv.blit(cr, (dx0, dy0)) return
def render(self, width, height, st, at): # Should we perform clipping? clipping = False # Preserve the illusion of linear time. if st == 0: self.st_offset = self.st if at == 0: self.at_offset = self.at self.st = st = st + self.st_offset self.at = at = at + self.at_offset # If we have to, call the function that updates this transform. if self.function is not None: fr = self.function(self, st, at) if fr is not None: renpy.display.render.redraw(self, fr) self.active = True if self.state.size: width, height = self.state.size if self.child is None: raise Exception("Transform does not have a child.") cr = render(self.child, width, height, st - self.child_st_base, at) width, height = cr.get_size() forward = IDENTITY reverse = IDENTITY xo = yo = 0 # Cropping. crop = self.state.crop if crop is None and self.state.corner1 and self.state.corner2: x1, y1 = self.state.corner1 x2, y2 = self.state.corner2 minx = min(x1, x2) maxx = max(x1, x2) miny = min(y1, y2) maxy = max(y1, y2) crop = (minx, miny, maxx - minx, maxy - miny) if crop: negative_xo, negative_yo, width, height = crop xo = -negative_xo yo = -negative_yo clipping = True if self.state.rotate: clipcr = renpy.display.render.Render(width, height) clipcr.subpixel_blit(cr, (xo, yo)) clipcr.clipping = clipping xo = yo = 0 cr = clipcr clipping = False # Size. if self.state.size and self.state.size != (width, height): nw, nh = self.state.size xzoom = 1.0 * nw / width yzoom = 1.0 * nh / height forward = forward * Matrix2D(1.0 / xzoom, 0, 0, 1.0 / yzoom) reverse = Matrix2D(xzoom, 0, 0, yzoom) * reverse xo = xo * xzoom yo = yo * yzoom width, height = self.state.size # Rotation. if self.state.rotate is not None: cw = width ch = height width = height = math.hypot(cw, ch) angle = -self.state.rotate * math.pi / 180 xdx = math.cos(angle) xdy = -math.sin(angle) ydx = -xdy ydy = xdx forward = forward * Matrix2D(xdx, xdy, ydx, ydy) xdx = math.cos(-angle) xdy = -math.sin(-angle) ydx = -xdy ydy = xdx reverse = Matrix2D(xdx, xdy, ydx, ydy) * reverse xo, yo = reverse.transform(-cw / 2.0, -ch / 2.0) xo += width / 2.0 yo += height / 2.0 xzoom = self.state.zoom * self.state.xzoom yzoom = self.state.zoom * self.state.yzoom if xzoom != 1 or yzoom != 1: forward = forward * Matrix2D(1.0 / xzoom, 0, 0, 1.0 / yzoom) reverse = Matrix2D(xzoom, 0, 0, yzoom) * reverse width *= xzoom height *= yzoom xo *= xzoom yo *= yzoom rv = renpy.display.render.Render(width, height) if forward is not IDENTITY: rv.forward = forward rv.reverse = reverse self.forward = forward rv.alpha = self.state.alpha rv.clipping = clipping if self.state.subpixel: rv.subpixel_blit(cr, (xo, yo), main=True) else: rv.blit(cr, (xo, yo), main=True) self.offsets = [(xo, yo)] return rv