171 lines
4.7 KiB
Plaintext
171 lines
4.7 KiB
Plaintext
|
|
transform CGCamera(zoom, endzoom, pos, endpos, rotate, endrotate, t):
|
|
subpixel True
|
|
|
|
offset pos
|
|
zoom zoom
|
|
rotate rotate
|
|
parallel:
|
|
ease_quad t zoom endzoom
|
|
parallel:
|
|
ease_quad t xoffset endpos[0] yoffset endpos[1]
|
|
parallel:
|
|
linear t rotate endrotate
|
|
|
|
init python:
|
|
|
|
class CGController(object):
|
|
default_timer = 1.0
|
|
|
|
def __init__(self, min_zoom=0.1, max_zoom=5.0):
|
|
self.imagepath = None
|
|
self.scale = 1.0
|
|
|
|
self.last_type = 0
|
|
self.type = 0 # 0 - image, 1 - Movie
|
|
|
|
self.last_image = None
|
|
self.image = None
|
|
self.overlay = None
|
|
|
|
self.max_zoom = max_zoom
|
|
self.min_zoom = min_zoom
|
|
|
|
self.last_zoom = min_zoom
|
|
self.zoom = min_zoom
|
|
|
|
self.last_pos = (0, 0)
|
|
self.pos = (0, 0)
|
|
|
|
self.last_rotate = 0
|
|
self.rotate = 0
|
|
|
|
self.child = None
|
|
|
|
def set_imagepath(self, path):
|
|
self.imagepath = f"images/CG/{path}/".replace("//", "/")
|
|
|
|
def set_image(self, img, trans=d1):
|
|
p = max(0, self.get_pause())
|
|
|
|
self.last_image = self.image
|
|
|
|
if isinstance( (vid := renpy.get_registered_image(img)), Movie ):
|
|
self.image = vid
|
|
elif isinstance(img, str) and self.imagepath:
|
|
self.image = f"{self.imagepath}{img}.webp"
|
|
else:
|
|
self.image = img
|
|
|
|
# Reset last variables to new variables to not redraw the transform.
|
|
self.last_zoom = self.zoom
|
|
self.last_pos = self.pos
|
|
self.last_rotate = self.rotate
|
|
|
|
if self.last_type == 0:
|
|
renpy.pause(p - 0.1)
|
|
self.redraw(0)
|
|
renpy.with_statement(trans)
|
|
else:
|
|
renpy.pause(p - 0.1)
|
|
self.redraw(0)
|
|
renpy.with_statement(trans)
|
|
|
|
def set_overlay(self, overlay):
|
|
if (img := renpy.get_registered_image(overlay)):
|
|
self.overlay = img
|
|
elif self.imagepath and isinstance(img, str):
|
|
self.overlay = f"{self.imagepath}{overlay}.webp"
|
|
else:
|
|
self.overlay = img
|
|
|
|
self.redraw(0)
|
|
|
|
def set_zoom(self, n):
|
|
self.last_zoom = self.zoom
|
|
self.zoom = float(clamp(n, self.min_zoom, self.max_zoom))
|
|
|
|
def set_rotation(self, n):
|
|
self.last_rotate = self.rotate
|
|
self.rotate = n
|
|
|
|
def set_pos(self, pos):
|
|
self.last_pos = tuple(self.pos)
|
|
self.pos = pos
|
|
|
|
def set(self, zoom=None, rotate=None, pos=None, t=None, initialize=False, pause=False, image=None, overlay=False, trans=d1):
|
|
if zoom is None:
|
|
zoom=self.last_zoom
|
|
if rotate is None:
|
|
rotate=self.last_rotate
|
|
if pos is None:
|
|
pos=self.last_pos
|
|
if t is None:
|
|
t = self.default_timer
|
|
|
|
self.set_zoom(zoom)
|
|
self.set_rotation(rotate)
|
|
self.set_pos(pos)
|
|
|
|
if initialize:
|
|
self.last_zoom = zoom
|
|
self.last_rotate = rotate
|
|
self.last_pos = pos
|
|
|
|
if image:
|
|
self.set_image(image, trans)
|
|
|
|
if overlay is not False:
|
|
self.set_overlay(overlay)
|
|
|
|
self.redraw(t)
|
|
|
|
if pause:
|
|
renpy.pause(t)
|
|
|
|
def redraw(self, t):
|
|
if (d := self.image) is None:
|
|
return
|
|
|
|
if isinstance(d, Movie):
|
|
self.scale = 2.0
|
|
self.last_type = self.type
|
|
self.type = 1
|
|
else:
|
|
self.scale = 1.0
|
|
self.last_type = self.type
|
|
self.type = 0
|
|
|
|
if self.overlay:
|
|
overlay = Transform(self.overlay, zoom=1.0/self.scale)
|
|
d = Fixed(d, overlay, fit_first=True)
|
|
|
|
last_zoom = self.last_zoom * self.scale
|
|
zoom = self.zoom * self.scale
|
|
|
|
self.child = At(d, CGCamera(last_zoom, zoom, self.last_pos, self.pos, self.last_rotate, self.rotate, t))
|
|
|
|
def get_image(self):
|
|
return self.child
|
|
|
|
def get_pause(self):
|
|
d = self.image
|
|
|
|
if d is None:
|
|
return 0
|
|
|
|
if isinstance(d, Movie) and renpy.music.is_playing(d.channel):
|
|
p = renpy.music.get_pos(d.channel) or 0.0
|
|
t = renpy.music.get_duration(d.channel)
|
|
return t - p
|
|
else:
|
|
return 0
|
|
|
|
default camera = CGController()
|
|
|
|
screen animatedCG():
|
|
tag cg
|
|
zorder 16
|
|
|
|
add camera.get_image() align (0.5, 0.5)
|