]> git.sesse.net Git - nageru/blob - nageru/theme.lua
011dc4f84c79c1636ffd6a46de2816eadaa1f50b
[nageru] / nageru / theme.lua
1 -- The theme is what decides what's actually shown on screen, what kind of
2 -- transitions are available (if any), and what kind of inputs there are,
3 -- if any. In general, it drives the entire display logic by creating Movit
4 -- chains (called “scenes”), setting their parameters and then deciding which
5 -- to show when.
6 --
7 -- Themes are written in Lua, which reflects a simplified form of the Movit API
8 -- where all the low-level details (such as texture formats) and alternatives
9 -- (e.g. turning scaling on or off) are handled by the C++ side and you
10 -- generally just build scenes.
11
12 local state = {
13         transition_start = -2.0,
14         transition_end = -1.0,
15         transition_type = 0,
16         transition_src_signal = 0,
17         transition_dst_signal = 0,
18
19         neutral_colors = {
20                 {0.5, 0.5, 0.5},  -- Input 0.
21                 {0.5, 0.5, 0.5}   -- Input 1.
22         },
23
24         live_signal_num = 0,
25         preview_signal_num = 1
26 }
27
28 -- Valid values for live_signal_num and preview_signal_num.
29 local INPUT0_SIGNAL_NUM = 0
30 local INPUT1_SIGNAL_NUM = 1
31 local SBS_SIGNAL_NUM = 2
32 local STATIC_SIGNAL_NUM = 3
33
34 -- Valid values for transition_type. (Cuts are done directly, so they need no entry.)
35 local NO_TRANSITION = 0
36 local ZOOM_TRANSITION = 1  -- Also for slides.
37 local FADE_TRANSITION = 2
38
39 function make_sbs_input(scene)
40         return {
41                 input = scene:add_input(),
42                 resample_effect = scene:add_effect({ResampleEffect.new(), ResizeEffect.new()}),
43                 wb_effect = scene:add_effect(WhiteBalanceEffect.new()),
44                 padding_effect = scene:add_effect(IntegralPaddingEffect.new())
45         }
46 end
47
48 -- The main live scene.
49 function make_sbs_scene()
50         local scene = Scene.new(16, 9)
51
52         local input0 = make_sbs_input(scene)
53         input0.input:display(0)
54         input0.padding_effect:set_vec4("border_color", 0.0, 0.0, 0.0, 1.0)
55
56         local input1 = make_sbs_input(scene)
57         input1.input:display(1)
58         input1.padding_effect:set_vec4("border_color", 0.0, 0.0, 0.0, 0.0)
59
60         scene:add_effect(OverlayEffect.new(), input0.padding_effect, input1.padding_effect)
61         scene:finalize()
62
63         return {
64                 scene = scene,
65                 input0 = input0,
66                 input1 = input1
67         }
68 end
69 local sbs_scene = make_sbs_scene()
70
71 function make_fade_input(scene)
72         return {
73                 input = scene:add_input(),
74                 resample_effect = scene:add_optional_effect(ResampleEffect.new()),  -- Activated if scaling.
75                 wb_effect = scene:add_optional_effect(WhiteBalanceEffect.new())  -- Activated for video inputs.
76         }
77 end
78
79 -- A scene to fade between two inputs, of which either can be a picture
80 -- or a live input. Only used live.
81 function make_fade_scene()
82         local scene = Scene.new(16, 9)
83         local input0 = make_fade_input(scene)
84         local input1 = make_fade_input(scene)
85         local mix_effect = scene:add_effect(MixEffect.new(), input0.wb_effect, input1.wb_effect)
86         scene:finalize(true)  -- Only used live.
87
88         return {
89                 scene = scene,
90                 input0 = input0,
91                 input1 = input1,
92                 mix_effect = mix_effect
93         }
94 end
95 local fade_scene = make_fade_scene()
96
97 -- A scene to show a single input on screen.
98 local scene = Scene.new(16, 9)
99 local simple_scene = {
100         scene = scene,
101         input = scene:add_input(),
102         resample_effect = scene:add_effect({ResampleEffect.new(), ResizeEffect.new(), IdentityEffect.new()}),
103         wb_effect = scene:add_effect(WhiteBalanceEffect.new())
104 }
105 scene:finalize()
106
107 -- A scene to show a single static picture on screen.
108 local static_image = ImageInput.new("bg.jpeg")  -- Also used as input to other scenes.
109 local static_scene = Scene.new(16, 9)
110 static_scene:add_input(static_image)  -- Note: Locks this input to images only.
111 static_scene:finalize()
112
113 -- Set some global state.
114 Nageru.set_num_channels(4)  -- Can only be called at the start of the program.
115
116 -- Set some global state. Unless marked otherwise, these can only be set once,
117 -- at the start of the program.
118 Nageru.set_num_channels(4)
119
120 -- Sets, for each channel, which signal it corresponds to (starting from 0).
121 -- The information is used for whether right-click on the channel should bring up
122 -- an input selector or not. Only call this for channels that actually correspond
123 -- directly to a signal (ie., live inputs, not live (0) or preview (1)).
124 Nageru.set_channel_signal(2, 0)
125 Nageru.set_channel_signal(3, 1)
126
127 -- Set whether a given channel supports setting white balance. (Default is false.)
128 Nageru.set_supports_wb(2, true)
129 Nageru.set_supports_wb(3, true)
130
131 -- These can be set at any time.
132 Nageru.set_channel_name(SBS_SIGNAL_NUM + 2, "Side-by-side")
133 Nageru.set_channel_name(STATIC_SIGNAL_NUM + 2, "Static picture")
134
135 -- API ENTRY POINT
136 -- Called every frame. Returns the color (if any) to paint around the given
137 -- channel. Returns a CSS color (typically to mark live and preview signals);
138 -- "transparent" is allowed.
139 -- Will never be called for live (0) or preview (1).
140 function channel_color(channel)
141         if state.transition_type ~= NO_TRANSITION then
142                 if channel_involved_in(channel, state.transition_src_signal) or
143                    channel_involved_in(channel, state.transition_dst_signal) then
144                         return "#f00"
145                 end
146         else
147                 if channel_involved_in(channel, state.live_signal_num) then
148                         return "#f00"
149                 end
150         end
151         if channel_involved_in(channel, state.preview_signal_num) then
152                 return "#0f0"
153         end
154         return "transparent"
155 end
156
157 function is_plain_signal(num)
158         return num == INPUT0_SIGNAL_NUM or num == INPUT1_SIGNAL_NUM
159 end
160
161 function channel_involved_in(channel, signal_num)
162         if is_plain_signal(signal_num) then
163                 return channel == (signal_num + 2)
164         end
165         if signal_num == SBS_SIGNAL_NUM then
166                 return (channel == 2 or channel == 3)
167         end
168         if signal_num == STATIC_SIGNAL_NUM then
169                 return (channel == 5)
170         end
171         return false
172 end
173
174 -- API ENTRY POINT
175 -- Gets called with a new gray point when the white balance is changing.
176 -- The color is in linear light (not sRGB gamma).
177 function set_wb(channel, red, green, blue)
178         if is_plain_signal(channel - 2) then
179                 state.neutral_colors[channel - 2 + 1] = { red, green, blue }
180         end
181 end
182
183 function finish_transitions(t)
184         if state.transition_type ~= NO_TRANSITION and t >= state.transition_end then
185                 state.live_signal_num = state.transition_dst_signal
186                 state.transition_type = NO_TRANSITION
187         end
188 end
189
190 function in_transition(t)
191        return t >= state.transition_start and t <= state.transition_end
192 end
193
194 -- API ENTRY POINT
195 -- Called every frame.
196 function get_transitions(t)
197         if in_transition(t) then
198                 -- Transition already in progress, the only thing we can do is really
199                 -- cut to the preview. (TODO: Make an “abort” and/or “finish”, too?)
200                 return {"Cut"}
201         end
202
203         finish_transitions(t)
204
205         if state.live_signal_num == state.preview_signal_num then
206                 -- No transitions possible.
207                 return {}
208         end
209
210         if (is_plain_signal(state.live_signal_num) or state.live_signal_num == STATIC_SIGNAL_NUM) and
211            (is_plain_signal(state.preview_signal_num) or state.preview_signal_num == STATIC_SIGNAL_NUM) then
212                 return {"Cut", "", "Fade"}
213         end
214
215         -- Various zooms.
216         if state.live_signal_num == SBS_SIGNAL_NUM and is_plain_signal(state.preview_signal_num) then
217                 return {"Cut", "Zoom in"}
218         elseif is_plain_signal(state.live_signal_num) and state.preview_signal_num == SBS_SIGNAL_NUM then
219                 return {"Cut", "Zoom out"}
220         end
221
222         return {"Cut"}
223 end
224
225 function swap_preview_live()
226         local temp = state.live_signal_num
227         state.live_signal_num = state.preview_signal_num
228         state.preview_signal_num = temp
229 end
230
231 function start_transition(type_, t, duration)
232         state.transition_start = t
233         state.transition_end = t + duration
234         state.transition_type = type_
235         state.transition_src_signal = state.live_signal_num
236         state.transition_dst_signal = state.preview_signal_num
237         swap_preview_live()
238 end
239
240 -- API ENTRY POINT
241 -- Called when the user clicks a transition button.
242 function transition_clicked(num, t)
243         if num == 0 then
244                 -- Cut.
245                 if in_transition(t) then
246                         -- Ongoing transition; finish it immediately before the cut.
247                         finish_transitions(state.transition_end)
248                 end
249
250                 swap_preview_live()
251         elseif num == 1 then
252                 -- Zoom.
253                 finish_transitions(t)
254
255                 if state.live_signal_num == state.preview_signal_num then
256                         -- Nothing to do.
257                         return
258                 end
259
260                 if is_plain_signal(state.live_signal_num) and is_plain_signal(state.preview_signal_num) then
261                         -- We can't zoom between these. Just make a cut.
262                         io.write("Cutting from " .. state.live_signal_num .. " to " .. state.live_signal_num .. "\n")
263                         swap_preview_live()
264                         return
265                 end
266
267                 if (state.live_signal_num == SBS_SIGNAL_NUM and is_plain_signal(state.preview_signal_num)) or
268                    (state.preview_signal_num == SBS_SIGNAL_NUM and is_plain_signal(state.live_signal_num)) then
269                         start_transition(ZOOM_TRANSITION, t, 1.0)
270                 end
271         elseif num == 2 then
272                 finish_transitions(t)
273
274                 -- Fade.
275                 if (state.live_signal_num ~= state.preview_signal_num) and
276                    (is_plain_signal(state.live_signal_num) or
277                     state.live_signal_num == STATIC_SIGNAL_NUM) and
278                    (is_plain_signal(state.preview_signal_num) or
279                     state.preview_signal_num == STATIC_SIGNAL_NUM) then
280                         start_transition(FADE_TRANSITION, t, 1.0)
281                 else
282                         -- Fades involving SBS are ignored (we have no scene for it).
283                 end
284         end
285 end
286
287 -- API ENTRY POINT
288 function channel_clicked(num)
289         state.preview_signal_num = num
290 end
291
292 function setup_fade_input(state, input, signals, signal_num, width, height)
293         if signal_num == STATIC_SIGNAL_NUM then
294                 input.input:display(static_image)
295                 input.wb_effect:disable()
296
297                 -- We assume this is already correctly scaled at load time.
298                 input.resample_effect:disable()
299         else
300                 input.input:display(signal_num)
301                 input.wb_effect:enable()
302                 set_neutral_color(input.wb_effect, state.neutral_colors[signal_num - INPUT0_SIGNAL_NUM + 1])
303
304                 if (signals:get_width(signal_num) ~= width or signals:get_height(signal_num) ~= height) then
305                         input.resample_effect:enable()
306                         input.resample_effect:set_int("width", width)
307                         input.resample_effect:set_int("height", height)
308                 else
309                         input.resample_effect:disable()
310                 end
311         end
312 end
313
314 function needs_scale(signals, signal_num, width, height)
315         if signal_num == STATIC_SIGNAL_NUM then
316                 -- We assume this is already correctly scaled at load time.
317                 return false
318         end
319         assert(is_plain_signal(signal_num))
320         return (signals:get_width(signal_num) ~= width or signals:get_height(signal_num) ~= height)
321 end
322
323 function setup_simple_input(state, signals, signal_num, width, height, hq)
324         simple_scene.input:display(signal_num)
325         if needs_scale(signals, signal_num, width, height) then
326                 if hq then
327                         simple_scene.resample_effect:choose(ResampleEffect)  -- High-quality resampling.
328                 else
329                         simple_scene.resample_effect:choose(ResizeEffect)  -- Low-quality resampling.
330                 end
331                 simple_scene.resample_effect:set_int("width", width)
332                 simple_scene.resample_effect:set_int("height", height)
333         else
334                 simple_scene.resample_effect:disable()  -- No scaling.
335         end
336         set_neutral_color_from_signal(state, simple_scene.wb_effect, signal_num)
337 end
338
339 -- API ENTRY POINT
340 -- Called every frame. Get the scene for displaying at input <num>,
341 -- where 0 is live, 1 is preview, 2 is the first channel to display
342 -- in the bottom bar, and so on up to num_channels()+1. t is the
343 -- current time in seconds. width and height are the dimensions of
344 -- the output, although you can ignore them if you don't need them
345 -- (they're useful if you want to e.g. know what to resample by).
346 --
347 -- <signals> is basically an exposed InputState, which you can use to
348 -- query for information about the signals at the point of the current
349 -- frame. In particular, you can call get_width() and get_height()
350 -- for any signal number, and use that to e.g. assist in scene selection.
351 --
352 -- You should return scene to use, after having set any parameters you
353 -- want to set (through set_int() etc.). The parameters will be snapshot
354 -- at return time and used during rendering.
355 function get_scene(num, t, width, height, signals)
356         local input_resolution = {}
357         for signal_num=0,1 do
358                 local res = {
359                         width = signals:get_width(signal_num),
360                         height = signals:get_height(signal_num),
361                 }
362                 if signals:get_interlaced(signal_num) then
363                         -- Convert height from frame height to field height.
364                         -- (Needed for e.g. place_rectangle.)
365                         res.height = res.height * 2
366                 end
367                 input_resolution[signal_num] = res
368
369                 local text_res = signals:get_human_readable_resolution(signal_num)
370                 Nageru.set_channel_name(signal_num + 2, "Input " .. (signal_num + 1) .. " (" .. text_res .. ")")
371         end
372
373         if num == 0 then  -- Live.
374                 finish_transitions(t)
375                 if state.transition_type == ZOOM_TRANSITION then
376                         -- Transition in or out of SBS.
377                         prepare_sbs_scene(state, calc_zoom_progress(state, t), state.transition_type, state.transition_src_signal, state.transition_dst_signal, width, height, input_resolution, true)
378                         return sbs_scene.scene
379                 elseif state.transition_type == NO_TRANSITION and state.live_signal_num == SBS_SIGNAL_NUM then
380                         -- Static SBS view.
381                         prepare_sbs_scene(state, 0.0, NO_TRANSITION, 0, SBS_SIGNAL_NUM, width, height, input_resolution, true)
382                         return sbs_scene.scene
383                 elseif state.transition_type == FADE_TRANSITION then
384                         setup_fade_input(state, fade_scene.input0, signals, state.transition_src_signal, width, height)
385                         setup_fade_input(state, fade_scene.input1, signals, state.transition_dst_signal, width, height)
386
387                         local tt = calc_fade_progress(t, state.transition_start, state.transition_end)
388                         fade_scene.mix_effect:set_float("strength_first", 1.0 - tt)
389                         fade_scene.mix_effect:set_float("strength_second", tt)
390
391                         return fade_scene.scene
392                 elseif is_plain_signal(state.live_signal_num) then
393                         setup_simple_input(state, signals, state.live_signal_num, width, height, true)
394                         return simple_scene.scene
395                 elseif state.live_signal_num == STATIC_SIGNAL_NUM then  -- Static picture.
396                         return static_scene
397                 else
398                         assert(false)
399                 end
400         end
401         if num == 1 then  -- Preview.
402                 num = state.preview_signal_num + 2
403         end
404
405         -- Individual preview inputs.
406         if is_plain_signal(num - 2) then
407                 setup_simple_input(state, signals, num - 2, width, height, false)
408                 return simple_scene.scene
409         end
410         if num == SBS_SIGNAL_NUM + 2 then
411                 prepare_sbs_scene(state, 0.0, NO_TRANSITION, 0, SBS_SIGNAL_NUM, width, height, input_resolution, false)
412                 return sbs_scene.scene
413         end
414         if num == STATIC_SIGNAL_NUM + 2 then
415                 return static_scene
416         end
417 end
418
419 function place_rectangle(input, x0, y0, x1, y1, screen_width, screen_height, input_width, input_height, hq)
420         input.padding_effect:set_int("width", screen_width)
421         input.padding_effect:set_int("height", screen_height)
422
423         -- Cull.
424         if x0 > screen_width or x1 < 0.0 or y0 > screen_height or y1 < 0.0 then
425                 input.resample_effect:choose(ResizeEffect)  -- Low-quality resizing.
426                 input.resample_effect:set_int("width", 1)
427                 input.resample_effect:set_int("height", 1)
428                 input.padding_effect:set_int("left", screen_width + 100)
429                 input.padding_effect:set_int("top", screen_height + 100)
430                 return
431         end
432
433         local srcx0 = 0.0
434         local srcx1 = 1.0
435         local srcy0 = 0.0
436         local srcy1 = 1.0
437
438         -- Clip.
439         if x0 < 0 then
440                 srcx0 = -x0 / (x1 - x0)
441                 x0 = 0
442         end
443         if y0 < 0 then
444                 srcy0 = -y0 / (y1 - y0)
445                 y0 = 0
446         end
447         if x1 > screen_width then
448                 srcx1 = (screen_width - x0) / (x1 - x0)
449                 x1 = screen_width
450         end
451         if y1 > screen_height then
452                 srcy1 = (screen_height - y0) / (y1 - y0)
453                 y1 = screen_height
454         end
455
456         if hq then
457                 -- High-quality resampling. Go for the actual effect (returned by choose())
458                 -- since we want to set zoom_*, which will give an error if set on ResizeEffect.
459                 local resample_effect = input.resample_effect:choose(ResampleEffect)
460
461                 local x_subpixel_offset = x0 - math.floor(x0)
462                 local y_subpixel_offset = y0 - math.floor(y0)
463
464                 -- Resampling must be to an integral number of pixels. Round up,
465                 -- and then add an extra pixel so we have some leeway for the border.
466                 local width = math.ceil(x1 - x0) + 1
467                 local height = math.ceil(y1 - y0) + 1
468                 resample_effect:set_int("width", width)
469                 resample_effect:set_int("height", height)
470
471                 -- Correct the discrepancy with zoom. (This will leave a small
472                 -- excess edge of pixels and subpixels, which we'll correct for soon.)
473                 local zoom_x = (x1 - x0) / (width * (srcx1 - srcx0))
474                 local zoom_y = (y1 - y0) / (height * (srcy1 - srcy0))
475                 resample_effect:set_float("zoom_x", zoom_x)
476                 resample_effect:set_float("zoom_y", zoom_y)
477                 resample_effect:set_float("zoom_center_x", 0.0)
478                 resample_effect:set_float("zoom_center_y", 0.0)
479
480                 -- Padding must also be to a whole-pixel offset.
481                 input.padding_effect:set_int("left", math.floor(x0))
482                 input.padding_effect:set_int("top", math.floor(y0))
483
484                 -- Correct _that_ discrepancy by subpixel offset in the resampling.
485                 resample_effect:set_float("left", srcx0 * input_width - x_subpixel_offset / zoom_x)
486                 resample_effect:set_float("top", srcy0 * input_height - y_subpixel_offset / zoom_y)
487
488                 -- Finally, adjust the border so it is exactly where we want it.
489                 input.padding_effect:set_float("border_offset_left", x_subpixel_offset)
490                 input.padding_effect:set_float("border_offset_right", x1 - (math.floor(x0) + width))
491                 input.padding_effect:set_float("border_offset_top", y_subpixel_offset)
492                 input.padding_effect:set_float("border_offset_bottom", y1 - (math.floor(y0) + height))
493         else
494                 -- Lower-quality simple resizing.
495                 input.resample_effect:choose(ResizeEffect)
496
497                 local width = round(x1 - x0)
498                 local height = round(y1 - y0)
499                 input.resample_effect:set_int("width", width)
500                 input.resample_effect:set_int("height", height)
501
502                 -- Padding must also be to a whole-pixel offset.
503                 input.padding_effect:set_int("left", math.floor(x0))
504                 input.padding_effect:set_int("top", math.floor(y0))
505
506                 -- No subpixel stuff.
507                 input.padding_effect:set_float("border_offset_left", 0.0)
508                 input.padding_effect:set_float("border_offset_right", 0.0)
509                 input.padding_effect:set_float("border_offset_top", 0.0)
510                 input.padding_effect:set_float("border_offset_bottom", 0.0)
511         end
512 end
513
514 -- This is broken, of course (even for positive numbers), but Lua doesn't give us access to real rounding.
515 function round(x)
516         return math.floor(x + 0.5)
517 end
518
519 function lerp(a, b, t)
520         return a + (b - a) * t
521 end
522
523 function lerp_pos(a, b, t)
524         return {
525                 x0 = lerp(a.x0, b.x0, t),
526                 y0 = lerp(a.y0, b.y0, t),
527                 x1 = lerp(a.x1, b.x1, t),
528                 y1 = lerp(a.y1, b.y1, t)
529         }
530 end
531
532 function pos_from_top_left(x, y, width, height, screen_width, screen_height)
533         local xs = screen_width / 1280.0
534         local ys = screen_height / 720.0
535         return {
536                 x0 = round(xs * x),
537                 y0 = round(ys * y),
538                 x1 = round(xs * (x + width)),
539                 y1 = round(ys * (y + height))
540         }
541 end
542
543 function prepare_sbs_scene(state, t, transition_type, src_signal, dst_signal, screen_width, screen_height, input_resolution, hq)
544         set_neutral_color(sbs_scene.input0.wb_effect, state.neutral_colors[1])
545         set_neutral_color(sbs_scene.input1.wb_effect, state.neutral_colors[2])
546
547         -- First input is positioned (16,48) from top-left.
548         -- Second input is positioned (16,48) from the bottom-right.
549         local pos0 = pos_from_top_left(16, 48, 848, 477, screen_width, screen_height)
550         local pos1 = pos_from_top_left(1280 - 384 - 16, 720 - 216 - 48, 384, 216, screen_width, screen_height)
551
552         local pos_fs = { x0 = 0, y0 = 0, x1 = screen_width, y1 = screen_height }
553         local affine_param
554         if transition_type == NO_TRANSITION then
555                 -- Static SBS view.
556                 affine_param = { sx = 1.0, sy = 1.0, tx = 0.0, ty = 0.0 }   -- Identity.
557         else
558                 -- Zooming to/from SBS view into or out of a single view.
559                 assert(transition_type == ZOOM_TRANSITION)
560                 local signal, real_t
561                 if src_signal == SBS_SIGNAL_NUM then
562                         signal = dst_signal
563                         real_t = t
564                 else
565                         assert(dst_signal == SBS_SIGNAL_NUM)
566                         signal = src_signal
567                         real_t = 1.0 - t
568                 end
569
570                 if signal == INPUT0_SIGNAL_NUM then
571                         affine_param = find_affine_param(pos0, lerp_pos(pos0, pos_fs, real_t))
572                 elseif signal == INPUT1_SIGNAL_NUM then
573                         affine_param = find_affine_param(pos1, lerp_pos(pos1, pos_fs, real_t))
574                 end
575         end
576
577         -- NOTE: input_resolution is not 1-indexed, unlike usual Lua arrays.
578         place_rectangle_with_affine(sbs_scene.input0, pos0, affine_param, screen_width, screen_height, input_resolution[0].width, input_resolution[0].height, hq)
579         place_rectangle_with_affine(sbs_scene.input1, pos1, affine_param, screen_width, screen_height, input_resolution[1].width, input_resolution[1].height, hq)
580 end
581
582 -- Find the transformation that changes the first rectangle to the second one.
583 function find_affine_param(a, b)
584         local sx = (b.x1 - b.x0) / (a.x1 - a.x0)
585         local sy = (b.y1 - b.y0) / (a.y1 - a.y0)
586         return {
587                 sx = sx,
588                 sy = sy,
589                 tx = b.x0 - a.x0 * sx,
590                 ty = b.y0 - a.y0 * sy
591         }
592 end
593
594 function place_rectangle_with_affine(input, pos, aff, screen_width, screen_height, input_width, input_height, hq)
595         local x0 = pos.x0 * aff.sx + aff.tx
596         local x1 = pos.x1 * aff.sx + aff.tx
597         local y0 = pos.y0 * aff.sy + aff.ty
598         local y1 = pos.y1 * aff.sy + aff.ty
599
600         place_rectangle(input, x0, y0, x1, y1, screen_width, screen_height, input_width, input_height, hq)
601 end
602
603 function set_neutral_color(effect, color)
604         effect:set_vec3("neutral_color", color[1], color[2], color[3])
605 end
606
607 function set_neutral_color_from_signal(state, effect, signal)
608         if is_plain_signal(signal) then
609                 set_neutral_color(effect, state.neutral_colors[signal - INPUT0_SIGNAL_NUM + 1])
610         end
611 end
612
613 function calc_zoom_progress(state, t)
614         if t < state.transition_start then
615                 return 0.0
616         elseif t > state.transition_end then
617                 return 1.0
618         else
619                 local tt = (t - state.transition_start) / (state.transition_end - state.transition_start)
620                 -- Smooth it a bit.
621                 return math.sin(tt * 3.14159265358 * 0.5)
622         end
623 end
624
625 function calc_fade_progress(t, transition_start, transition_end)
626         local tt = (t - transition_start) / (transition_end - transition_start)
627         if tt < 0.0 then
628                 return 0.0
629         elseif tt > 1.0 then
630                 return 1.0
631         end
632
633         -- Make the fade look maybe a tad more natural, by pumping it
634         -- through a sigmoid function.
635         tt = 10.0 * tt - 5.0
636         tt = 1.0 / (1.0 + math.exp(-tt))
637
638         return tt
639 end