include renpy

1 files changed, 296 insertions, 0 deletions

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 <pytom@bishoujo.us>
+#
+# 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 * <double> state.xzoom
+    yzoom = zoom * <double> 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
+