From 718936110b9511631fa1f4396be992752bf8b719 Mon Sep 17 00:00:00 2001 From: Alex Xu Date: Thu, 22 Aug 2013 22:45:26 -0400 Subject: include renpy --- unrpyc/renpy/display/accelerator.pyx | 296 +++++++++++++++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100644 unrpyc/renpy/display/accelerator.pyx (limited to 'unrpyc/renpy/display/accelerator.pyx') diff --git a/unrpyc/renpy/display/accelerator.pyx b/unrpyc/renpy/display/accelerator.pyx new file mode 100644 index 0000000..8c4172c --- /dev/null +++ b/unrpyc/renpy/display/accelerator.pyx @@ -0,0 +1,296 @@ +#cython: profile=False +# Copyright 2004-2013 Tom Rothamel +# +# Permission is hereby granted, free of charge, to any person +# obtaining a copy of this software and associated documentation files +# (the "Software"), to deal in the Software without restriction, +# including without limitation the rights to use, copy, modify, merge, +# publish, distribute, sublicense, and/or sell copies of the Software, +# and to permit persons to whom the Software is furnished to do so, +# subject to the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +import renpy +import math +from renpy.display.render cimport Render, Matrix2D, render + + +################################################################################ +# Surface copying +################################################################################ + +from pygame cimport * + +def nogil_copy(src, dest): + """ + Does a gil-less blit of src to dest, with minimal locking. + """ + + cdef SDL_Surface *src_surf + cdef SDL_Surface *dst_surf + + src_surf = PySurface_AsSurface(src) + dest_surf = PySurface_AsSurface(dest) + + old_alpha = src_surf.flags & SDL_SRCALPHA + + if old_alpha: + SDL_SetAlpha(src_surf, 0, 255) + + with nogil: + SDL_BlitSurface(src_surf, NULL, dest_surf, NULL) + + if old_alpha: + SDL_SetAlpha(src_surf, SDL_SRCALPHA, 255) + + + +################################################################################ +# Transform render function +################################################################################ + +cdef Matrix2D IDENTITY +IDENTITY = renpy.display.render.IDENTITY + +# This file contains implementations of methods of classes that +# are found in other files, for performance reasons. + +def transform_render(self, widtho, heighto, st, at): + + cdef double rxdx, rxdy, rydx, rydy + cdef double cosa, sina + cdef double xo, x1, x2, x3, px + cdef double yo, y1, y2, y3, py + cdef float zoom, xzoom, yzoom + cdef double cw, ch, nw, nh + cdef Render rv, cr + cdef double angle + cdef double alpha + cdef double width = widtho + cdef double height = heighto + + # Should we perform clipping? + clipping = False + + # Prevent time from ticking backwards, as can happen if we replace a + # transform but keep its state. + if st + self.st_offset <= self.st: + self.st_offset = self.st - st + if at + self.at_offset <= self.at: + self.at_offset = self.at - at + + self.st = st = st + self.st_offset + self.at = at = at + self.at_offset + + # Update the state. + self.update_state() + + # Render the child. + child = self.child + + if child is None: + raise Exception("Transform does not have a child.") + + state = self.state + + if state.size: + widtho, heighto = state.size + + cr = render(child, widtho, heighto, st - self.child_st_base, at) + + width = cr.width + height = cr.height + + self.child_size = width, height + + # The reverse matrix. + rxdx = 1 + rxdy = 0 + rydx = 0 + rydy = 1 + + xo = 0 + yo = 0 + + # Cropping. + crop = state.crop + if (state.corner1 is not None) and (crop is None) and (state.corner2 is not None): + x1, y1 = state.corner1 + x2, y2 = state.corner2 + + if x1 > x2: + x3 = x1 + x1 = x2 + x2 = x3 + if y1 > y2: + y3 = y1 + y1 = y2 + y2 = y3 + + crop = (x1, y1, x2-x1, y2-y1) + + if crop is not None: + + negative_xo, negative_yo, width, height = crop + + if state.rotate: + clipcr = Render(width, height) + clipcr.subpixel_blit(cr, (-negative_xo, -negative_yo)) + clipcr.clipping = True + cr = clipcr + else: + xo = -negative_xo + yo = -negative_yo + clipping = True + + # Size. + size = state.size + if (size is not None) and (size != (width, height)): + nw, nh = size + xzoom = 1.0 * nw / width + yzoom = 1.0 * nh / height + + rxdx = xzoom + rydy = yzoom + + xo *= xzoom + yo *= yzoom + + width, height = size + + # zoom + zoom = state.zoom + xzoom = zoom * state.xzoom + yzoom = zoom * state.yzoom + + if xzoom != 1: + + rxdx *= xzoom + + if xzoom < 0: + width *= -xzoom + else: + width *= xzoom + + xo *= xzoom + # origin corrections for flipping + if xzoom < 0: + xo += width + + if yzoom != 1: + + rydy *= yzoom + + if yzoom < 0: + height *= -yzoom + else: + height *= yzoom + + yo *= yzoom + # origin corrections for flipping + if yzoom < 0: + yo += height + + # Rotation. + rotate = state.rotate + if rotate is not None: + + cw = width + ch = height + + angle = rotate * 3.1415926535897931 / 180 + + cosa = math.cos(angle) + sina = math.sin(angle) + + # reverse = Matrix2D(xdx, xdy, ydx, ydy) * reverse + + # We know that at this point, rxdy and rydx are both 0, so + # we can simplify these formulae a bit. + rxdy = rydy * -sina + rydx = rxdx * sina + rxdx *= cosa + rydy *= cosa + + # first corner point (changes with flipping) + px = cw / 2.0 + if xzoom < 0: + px = -px + py = ch / 2.0 + if yzoom < 0: + py = -py + + if state.rotate_pad: + width = height = math.hypot(cw, ch) + + xo = -px * cosa + py * sina + yo = -px * sina - py * cosa + + else: + xo = -px * cosa + py * sina + yo = -px * sina - py * cosa + + x2 = -px * cosa - py * sina + y2 = -px * sina + py * cosa + + x3 = px * cosa - py * sina + y3 = px * sina + py * cosa + + x4 = px * cosa + py * sina + y4 = px * sina - py * cosa + + width = max(xo, x2, x3, x4) - min(xo, x2, x3, x4) + height = max(yo, y2, y3, y4) - min(yo, y2, y3, y4) + + xo += width / 2.0 + yo += height / 2.0 + + alpha = state.alpha + + rv = Render(width, height) + + # Default case - no transformation matrix. + if rxdx == 1 and rxdy == 0 and rydx == 0 and rydy == 1: + self.forward = IDENTITY + self.reverse = IDENTITY + + else: + + self.reverse = rv.reverse = Matrix2D(rxdx, rxdy, rydx, rydy) + + inv_det = rxdx * rydy - rxdy * rydx + + if not inv_det: + self.forward = rv.forward = Matrix2D(0, 0, 0, 0) + else: + self.forward = rv.forward = Matrix2D( + rydy / inv_det, + -rxdy / inv_det, + -rydx / inv_det, + rxdx / inv_det) + + rv.alpha = alpha + rv.clipping = clipping + + pos = (xo, yo) + + if state.subpixel: + rv.subpixel_blit(cr, pos) + else: + rv.blit(cr, pos) + + self.offsets = [ pos ] + self.render_size = (width, height) + + return rv + -- cgit v1.2.3-54-g00ecf