ml
616 lines
19 KiB
Go
616 lines
19 KiB
Go
package movies
|
|
|
|
import (
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"image/gif"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"github.com/asticode/go-astisub"
|
|
"github.com/inkyblackness/imgui-go/v3"
|
|
|
|
"github.com/inkyblackness/hacked/editor/external"
|
|
"github.com/inkyblackness/hacked/editor/graphics"
|
|
"github.com/inkyblackness/hacked/editor/render"
|
|
"github.com/inkyblackness/hacked/ss1/content/audio"
|
|
"github.com/inkyblackness/hacked/ss1/content/bitmap"
|
|
"github.com/inkyblackness/hacked/ss1/content/movie"
|
|
"github.com/inkyblackness/hacked/ss1/edit/undoable"
|
|
"github.com/inkyblackness/hacked/ss1/edit/undoable/cmd"
|
|
"github.com/inkyblackness/hacked/ss1/resource"
|
|
"github.com/inkyblackness/hacked/ss1/world"
|
|
"github.com/inkyblackness/hacked/ss1/world/ids"
|
|
"github.com/inkyblackness/hacked/ui/gui"
|
|
)
|
|
|
|
type movieInfo struct {
|
|
title string
|
|
multilang bool
|
|
}
|
|
|
|
var knownMovies = map[resource.ID]movieInfo{
|
|
ids.MovieIntro: {title: "Intro", multilang: true},
|
|
ids.MovieDeath: {title: "Death", multilang: false},
|
|
ids.MovieEnd: {title: "End", multilang: false},
|
|
}
|
|
|
|
var knownMoviesOrder = []resource.ID{ids.MovieIntro, ids.MovieDeath, ids.MovieEnd}
|
|
|
|
// View provides edit controls for animations.
|
|
type View struct {
|
|
mod *world.Mod
|
|
|
|
frameCache *graphics.FrameCache
|
|
frameCacheKey graphics.FrameCacheKey
|
|
|
|
movieService undoable.MovieService
|
|
|
|
modalStateMachine gui.ModalStateMachine
|
|
guiScale float32
|
|
commander cmd.Commander
|
|
|
|
model viewModel
|
|
}
|
|
|
|
// NewMoviesView returns a new instance.
|
|
func NewMoviesView(mod *world.Mod, frameCache *graphics.FrameCache,
|
|
movieService undoable.MovieService,
|
|
modalStateMachine gui.ModalStateMachine, guiScale float32, commander cmd.Commander) *View {
|
|
view := &View{
|
|
mod: mod,
|
|
|
|
frameCache: frameCache,
|
|
frameCacheKey: frameCache.AllocateKey(),
|
|
|
|
movieService: movieService,
|
|
|
|
modalStateMachine: modalStateMachine,
|
|
guiScale: guiScale,
|
|
commander: commander,
|
|
|
|
model: freshViewModel(),
|
|
}
|
|
return view
|
|
}
|
|
|
|
// WindowOpen returns the flag address, to be used with the main menu.
|
|
func (view *View) WindowOpen() *bool {
|
|
return &view.model.windowOpen
|
|
}
|
|
|
|
// Render renders the view.
|
|
func (view *View) Render() {
|
|
if view.model.restoreFocus {
|
|
imgui.SetNextWindowFocus()
|
|
view.model.restoreFocus = false
|
|
view.model.windowOpen = true
|
|
}
|
|
if view.model.windowOpen {
|
|
imgui.SetNextWindowSizeV(imgui.Vec2{X: 800 * view.guiScale, Y: 300 * view.guiScale}, imgui.ConditionFirstUseEver)
|
|
if imgui.BeginV("Movies", view.WindowOpen(), imgui.WindowFlagsNoCollapse|imgui.WindowFlagsHorizontalScrollbar) {
|
|
view.renderContent()
|
|
}
|
|
imgui.End()
|
|
}
|
|
}
|
|
|
|
func (view *View) renderContent() {
|
|
if imgui.BeginChildV("Properties", imgui.Vec2{X: 350 * view.guiScale, Y: 0}, false, 0) {
|
|
imgui.PushItemWidth(-150 * view.guiScale)
|
|
if imgui.BeginCombo("Movie", knownMovies[view.model.currentKey.ID].title) {
|
|
for _, id := range knownMoviesOrder {
|
|
if imgui.SelectableV(knownMovies[id].title, id == view.model.currentKey.ID, 0, imgui.Vec2{}) {
|
|
view.model.currentKey.ID = id
|
|
view.model.currentKey.Index = 0
|
|
view.model.currentScene = 0
|
|
view.model.currentFrame = 0
|
|
view.model.frameTimeFraction = -1
|
|
}
|
|
}
|
|
imgui.EndCombo()
|
|
}
|
|
|
|
if knownMovies[view.model.currentKey.ID].multilang {
|
|
if imgui.BeginCombo("Language", view.model.currentKey.Lang.String()) {
|
|
languages := resource.Languages()
|
|
for _, lang := range languages {
|
|
if imgui.SelectableV(lang.String(), lang == view.model.currentKey.Lang, 0, imgui.Vec2{}) {
|
|
view.model.currentKey.Lang = lang
|
|
}
|
|
}
|
|
imgui.EndCombo()
|
|
}
|
|
} else {
|
|
imgui.LabelText("Language", "(not localized)")
|
|
}
|
|
|
|
imgui.Separator()
|
|
|
|
view.renderProperties()
|
|
|
|
imgui.PopItemWidth()
|
|
}
|
|
imgui.EndChild()
|
|
|
|
scenes := view.movieService.Video(view.model.currentKey)
|
|
imgui.SameLine()
|
|
imgui.BeginGroup()
|
|
imgui.BeginChildV("Scenes", imgui.Vec2{X: 200 * view.guiScale, Y: -60 * view.guiScale}, true,
|
|
imgui.WindowFlagsHorizontalScrollbar|imgui.WindowFlagsAlwaysVerticalScrollbar)
|
|
for index, scene := range scenes {
|
|
sceneInfo := fmt.Sprintf("Scene %02d (%d frames)", index, len(scene.Frames))
|
|
if imgui.SelectableV(sceneInfo, view.model.currentScene == index, 0, imgui.Vec2{}) {
|
|
view.model.currentScene = index
|
|
view.model.currentFrame = 0
|
|
view.model.frameTimeFraction = -1
|
|
}
|
|
}
|
|
imgui.EndChild()
|
|
if imgui.Button("Up") {
|
|
view.requestMoveSceneEarlier()
|
|
}
|
|
imgui.SameLine()
|
|
if imgui.Button("Down") {
|
|
view.requestMoveSceneLater()
|
|
}
|
|
imgui.SameLine()
|
|
if imgui.Button("Remove") {
|
|
view.requestRemoveScene()
|
|
}
|
|
if imgui.Button("Import") {
|
|
view.requestImportScene("")
|
|
}
|
|
imgui.SameLine()
|
|
if imgui.Button("Export") {
|
|
view.requestExportScene()
|
|
}
|
|
imgui.EndGroup()
|
|
imgui.SameLine()
|
|
if imgui.BeginChildV("Frames", imgui.Vec2{X: -1, Y: 0}, false, 0) {
|
|
var scene *movie.Scene
|
|
if (view.model.currentScene >= 0) && (view.model.currentScene < len(scenes)) {
|
|
scene = &scenes[view.model.currentScene]
|
|
}
|
|
if scene != nil {
|
|
var frame *movie.Frame
|
|
if (view.model.currentFrame >= 0) && (view.model.currentFrame < len(scene.Frames)) {
|
|
frame = &scene.Frames[view.model.currentFrame]
|
|
}
|
|
if frame != nil {
|
|
// This code updates the texture every render cycle. In case of performance loss, this is a point to optimize.
|
|
view.frameCache.SetTexture(view.frameCacheKey, 600, 300, frame.Pixels, &scene.Palette)
|
|
|
|
render.FrameImage("Frame", view.frameCache, view.frameCacheKey,
|
|
imgui.Vec2{
|
|
X: float32(movie.HighResDefaultWidth) * view.guiScale,
|
|
Y: float32(movie.HighResDefaultHeight) * view.guiScale,
|
|
})
|
|
}
|
|
|
|
imgui.PushItemWidth(-150 * view.guiScale)
|
|
gui.StepSliderInt("Frame Index", &view.model.currentFrame, 0, len(scene.Frames)-1)
|
|
imgui.PopItemWidth()
|
|
if (frame != nil) && (frame.DisplayTime < (time.Second / 4)) {
|
|
imgui.Separator()
|
|
if view.model.frameTimeFraction < 0 {
|
|
view.model.frameTimeFraction = int((frame.DisplayTime * 0x10000) / time.Second)
|
|
}
|
|
imgui.PushItemWidth(-150 * view.guiScale)
|
|
gui.StepSliderInt("Frame time fraction", &view.model.frameTimeFraction, 0, 0x3FFF)
|
|
imgui.PopItemWidth()
|
|
if imgui.Button("Set for scene") {
|
|
displayTime := (time.Duration(view.model.frameTimeFraction) * time.Second) / 0x10000
|
|
view.requestSetFramesDisplayTime(displayTime)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
imgui.EndChild()
|
|
}
|
|
|
|
func (view *View) renderProperties() {
|
|
view.renderAudioProperties()
|
|
view.renderSubtitlesProperties()
|
|
|
|
if view.movieService.SizeWarning(view.model.currentKey) {
|
|
view.renderSizeWarning()
|
|
}
|
|
}
|
|
|
|
func (view *View) renderAudioProperties() {
|
|
imgui.PushID("audio")
|
|
imgui.Separator()
|
|
sound := view.currentSound()
|
|
imgui.LabelText("Audio", fmt.Sprintf("%.2f sec", sound.Duration()))
|
|
if imgui.Button("Import") {
|
|
view.requestImportAudio()
|
|
}
|
|
if !sound.Empty() {
|
|
imgui.SameLine()
|
|
if imgui.Button("Export") {
|
|
view.requestExportAudio(sound)
|
|
}
|
|
imgui.SameLine()
|
|
if imgui.Button("Clear") {
|
|
view.requestClearAudio()
|
|
}
|
|
}
|
|
imgui.PopID()
|
|
}
|
|
|
|
func (view *View) renderSubtitlesProperties() {
|
|
imgui.PushID("subtitles")
|
|
imgui.Separator()
|
|
if imgui.BeginCombo("Sub Language", view.model.currentSubtitleLang.String()) {
|
|
languages := resource.Languages()
|
|
for _, lang := range languages {
|
|
if imgui.SelectableV(lang.String(), lang == view.model.currentSubtitleLang, 0, imgui.Vec2{}) {
|
|
view.model.currentSubtitleLang = lang
|
|
}
|
|
}
|
|
imgui.EndCombo()
|
|
}
|
|
sub := view.currentSubtitles()
|
|
imgui.Text(fmt.Sprintf("%d lines", len(sub.Entries)))
|
|
if imgui.Button("Import") {
|
|
view.requestImportSubtitles()
|
|
}
|
|
if len(sub.Entries) > 0 {
|
|
imgui.SameLine()
|
|
if imgui.Button("Export") {
|
|
view.requestExportSubtitles()
|
|
}
|
|
imgui.SameLine()
|
|
if imgui.Button("Clear") {
|
|
view.requestClearSubtitles()
|
|
}
|
|
}
|
|
imgui.PopID()
|
|
}
|
|
|
|
func (view *View) renderSizeWarning() {
|
|
imgui.Separator()
|
|
imgui.PushStyleColor(imgui.StyleColorText, imgui.Vec4{X: 1, Y: 0, Z: 0, W: 1})
|
|
imgui.Text("Size warning - reduce content!")
|
|
imgui.PopStyleColor()
|
|
if imgui.IsItemHovered() {
|
|
imgui.BeginTooltip()
|
|
imgui.SetTooltip("The movie has reached a size larger than officially supported.\n" +
|
|
"While the game might still show the movie, a future update may stop supporting it.")
|
|
imgui.EndTooltip()
|
|
}
|
|
}
|
|
|
|
func (view *View) restoreFunc() func() {
|
|
return view.restoreFuncWithScene(view.model.currentScene)
|
|
}
|
|
|
|
func (view *View) restoreFuncWithScene(oldScene int) func() {
|
|
oldKey := view.model.currentKey
|
|
oldSubtitlesLang := view.model.currentSubtitleLang
|
|
oldFrame := view.model.currentFrame
|
|
|
|
return func() {
|
|
view.model.restoreFocus = true
|
|
view.model.currentKey = oldKey
|
|
view.model.currentSubtitleLang = oldSubtitlesLang
|
|
view.model.currentScene = oldScene
|
|
view.model.currentFrame = oldFrame
|
|
view.model.frameTimeFraction = -1
|
|
}
|
|
}
|
|
|
|
func (view *View) currentSound() audio.L8 {
|
|
return view.movieService.Audio(view.model.currentKey)
|
|
}
|
|
|
|
func (view *View) requestExportAudio(sound audio.L8) {
|
|
filename := fmt.Sprintf("%s_%s.wav", knownMovies[view.model.currentKey.ID].title, view.model.currentKey.Lang.String())
|
|
|
|
external.ExportAudio(view.modalStateMachine, filename, sound)
|
|
}
|
|
|
|
func (view *View) requestImportAudio() {
|
|
external.ImportAudio(view.modalStateMachine, func(sound audio.L8) {
|
|
view.movieService.RequestSetAudio(view.model.currentKey, sound, view.restoreFunc())
|
|
})
|
|
}
|
|
|
|
func (view *View) requestClearAudio() {
|
|
view.movieService.RequestSetAudio(view.model.currentKey, audio.L8{}, view.restoreFunc())
|
|
}
|
|
|
|
func (view *View) currentSubtitles() movie.SubtitleList {
|
|
return view.movieService.Subtitles(view.model.currentKey, view.model.currentSubtitleLang)
|
|
}
|
|
|
|
func (view View) requestExportSubtitles() {
|
|
filename := fmt.Sprintf("%s_%s.srt", knownMovies[view.model.currentKey.ID].title, view.model.currentSubtitleLang.String())
|
|
info := "File to be written: " + filename
|
|
var exportTo func(string)
|
|
currentSubtitles := view.currentSubtitles()
|
|
|
|
exportTo = func(dirname string) {
|
|
writer, err := os.Create(filepath.Join(dirname, filename))
|
|
if err != nil {
|
|
external.Export(view.modalStateMachine, "Could not create file.\n"+info, exportTo, true)
|
|
return
|
|
}
|
|
defer func() { _ = writer.Close() }()
|
|
|
|
sub := astisub.NewSubtitles()
|
|
|
|
var lastItem *astisub.Item
|
|
for _, entry := range currentSubtitles.Entries {
|
|
var item astisub.Item
|
|
var line astisub.Line
|
|
line.Items = append(line.Items, astisub.LineItem{Text: entry.Text})
|
|
item.Lines = []astisub.Line{line}
|
|
item.StartAt = entry.Timestamp
|
|
item.EndAt = item.StartAt
|
|
if lastItem != nil {
|
|
lastItem.EndAt = item.StartAt
|
|
}
|
|
lastItem = &item
|
|
sub.Items = append(sub.Items, lastItem)
|
|
}
|
|
|
|
err = sub.WriteToSRT(writer)
|
|
if err != nil {
|
|
external.Export(view.modalStateMachine, "Could not export subtitles.\n"+info, exportTo, true)
|
|
return
|
|
}
|
|
}
|
|
|
|
external.Export(view.modalStateMachine, info, exportTo, false)
|
|
}
|
|
|
|
func (view *View) requestImportSubtitles() {
|
|
info := "File must be an .SRT file."
|
|
types := []external.TypeInfo{{Title: "Subtitle files (*.srt)", Extensions: []string{"srt"}}}
|
|
var fileHandler func(string)
|
|
|
|
fileHandler = func(filename string) {
|
|
reader, err := os.Open(filename)
|
|
if err != nil {
|
|
external.Import(view.modalStateMachine, "Could not open file.\n"+info, types, fileHandler, true)
|
|
return
|
|
}
|
|
defer func() { _ = reader.Close() }()
|
|
|
|
subtitles, err := astisub.ReadFromSRT(reader)
|
|
if err != nil {
|
|
external.Import(view.modalStateMachine, "File not recognized as SRT.\n"+info, types, fileHandler, true)
|
|
return
|
|
}
|
|
var newSubtitles movie.SubtitleList
|
|
for _, item := range subtitles.Items {
|
|
var newEntry movie.Subtitle
|
|
newEntry.Timestamp = item.StartAt
|
|
for _, line := range item.Lines {
|
|
for _, lineItem := range line.Items {
|
|
if len(newEntry.Text) > 0 {
|
|
newEntry.Text += "\n"
|
|
}
|
|
newEntry.Text += lineItem.Text
|
|
}
|
|
}
|
|
newSubtitles.Entries = append(newSubtitles.Entries, newEntry)
|
|
}
|
|
|
|
view.movieService.RequestSetSubtitles(view.model.currentKey, view.model.currentSubtitleLang,
|
|
newSubtitles, view.restoreFunc())
|
|
}
|
|
|
|
external.Import(view.modalStateMachine, info, types, fileHandler, false)
|
|
}
|
|
|
|
func (view *View) requestClearSubtitles() {
|
|
view.movieService.RequestSetSubtitles(view.model.currentKey, view.model.currentSubtitleLang,
|
|
movie.SubtitleList{}, view.restoreFunc())
|
|
}
|
|
|
|
func (view *View) requestImportScene(returningInfo string) {
|
|
info := fmt.Sprintf("File must be an animated GIF file in size %dx%d.",
|
|
movie.HighResDefaultWidth, movie.HighResDefaultHeight)
|
|
types := []external.TypeInfo{{Title: "Animation files (*.gif)", Extensions: []string{"gif"}}}
|
|
var fileHandler func(string)
|
|
|
|
fileHandler = func(filename string) {
|
|
reader, err := os.Open(filename)
|
|
if err != nil {
|
|
external.Import(view.modalStateMachine, "Could not open file.\n"+info, types, fileHandler, true)
|
|
return
|
|
}
|
|
defer func() { _ = reader.Close() }()
|
|
data, err := gif.DecodeAll(reader)
|
|
if err != nil {
|
|
external.Import(view.modalStateMachine, "File not recognized as GIF.\n"+info, types, fileHandler, true)
|
|
return
|
|
}
|
|
|
|
if (data.Config.Width != movie.HighResDefaultWidth) || (data.Config.Height != movie.HighResDefaultHeight) {
|
|
external.Import(view.modalStateMachine, info, types, fileHandler, true)
|
|
return
|
|
}
|
|
|
|
var scene movie.Scene
|
|
scene.Frames = make([]movie.Frame, len(data.Image))
|
|
var palette bitmap.Palette
|
|
if gifPalette, isPal := data.Config.ColorModel.(color.Palette); isPal {
|
|
for index, clr := range gifPalette {
|
|
r, g, b, _ := clr.RGBA()
|
|
palette[index].Red = byte(r >> 8)
|
|
palette[index].Green = byte(g >> 8)
|
|
palette[index].Blue = byte(b >> 8)
|
|
}
|
|
}
|
|
framebuffer := make([]byte, data.Config.Width*data.Config.Height)
|
|
framebufferSnapshot := func() []byte {
|
|
buf := make([]byte, len(framebuffer))
|
|
copy(buf, framebuffer)
|
|
return buf
|
|
}
|
|
|
|
var usedColors [256]bool
|
|
for _, img := range data.Image {
|
|
for y := img.Bounds().Min.Y; y < img.Bounds().Max.Y; y++ {
|
|
for x := img.Bounds().Min.X; x < img.Bounds().Max.X; x++ {
|
|
colorIndex := img.ColorIndexAt(x, y)
|
|
usedColors[colorIndex] = true
|
|
}
|
|
}
|
|
}
|
|
var indexMap [256]byte
|
|
for i := 0; i < 256; i++ {
|
|
indexMap[byte(i)] = byte(i)
|
|
}
|
|
// Ensure color index 0 is not used.
|
|
if usedColors[0] && (data.BackgroundIndex != 0) {
|
|
if data.BackgroundIndex == 255 {
|
|
indexMap[0] = palette.IndexClosestTo(palette[0], []byte{0, 255})
|
|
} else {
|
|
palette[0], palette[data.BackgroundIndex] = palette[data.BackgroundIndex], palette[0]
|
|
indexMap[0] = data.BackgroundIndex
|
|
indexMap[data.BackgroundIndex] = 0
|
|
}
|
|
}
|
|
palette[0] = bitmap.RGB{Red: 0x00, Green: 0x00, Blue: 0x00} // default color for background
|
|
// In case the last index is in use by the animation, use a similar color as this entry is reserved for subtitles.
|
|
if usedColors[255] && (data.BackgroundIndex != 255) {
|
|
indexMap[255] = palette.IndexClosestTo(palette[255], []byte{0, 255})
|
|
}
|
|
palette[255] = bitmap.RGB{Red: 0x9A, Green: 0x35, Blue: 0x35} // default color in intro
|
|
|
|
scene.Palette = palette
|
|
for index, img := range data.Image {
|
|
for y := img.Bounds().Min.Y; y < img.Bounds().Max.Y; y++ {
|
|
for x := img.Bounds().Min.X; x < img.Bounds().Max.X; x++ {
|
|
colorIndex := img.ColorIndexAt(x, y)
|
|
if colorIndex != data.BackgroundIndex {
|
|
framebuffer[y*data.Config.Width+x] = indexMap[colorIndex]
|
|
}
|
|
}
|
|
}
|
|
|
|
scene.Frames[index].DisplayTime = time.Duration(data.Delay[index]) * 10 * time.Millisecond // nolint: durationcheck
|
|
scene.Frames[index].Pixels = framebufferSnapshot()
|
|
}
|
|
|
|
view.compressAndAddScene(scene, data.Config.Width, data.Config.Height)
|
|
}
|
|
|
|
external.Import(view.modalStateMachine, returningInfo+info, types, fileHandler, false)
|
|
}
|
|
|
|
func (view *View) compressAndAddScene(scene movie.Scene, width, height int) {
|
|
view.modalStateMachine.SetState(&compressingStartState{
|
|
machine: view.modalStateMachine,
|
|
view: view,
|
|
width: width,
|
|
height: height,
|
|
input: scene,
|
|
listener: view.onCompressionResult,
|
|
})
|
|
}
|
|
|
|
func (view *View) onCompressionResult(result compressionResult) {
|
|
switch typedResult := result.(type) {
|
|
case compressionAborted:
|
|
case compressionFinished:
|
|
view.requestAddScene(typedResult.scene)
|
|
case compressionFailed:
|
|
view.requestImportScene("Could not compress. Follow recommendations and retry.\n" +
|
|
"Technical details:\n" + typedResult.err.Error() + "\n\n")
|
|
}
|
|
}
|
|
|
|
func (view *View) requestAddScene(scene movie.HighResScene) {
|
|
view.movieService.RequestAddScene(view.model.currentKey, scene, view.restoreFunc())
|
|
}
|
|
|
|
func (view *View) requestExportScene() {
|
|
filename := fmt.Sprintf("%s_Scene%02d_%s.gif",
|
|
knownMovies[view.model.currentKey.ID].title,
|
|
view.model.currentScene,
|
|
view.model.currentKey.Lang.String())
|
|
info := "File to be written: " + filename
|
|
var exportTo func(string)
|
|
|
|
scenes := view.movieService.Video(view.model.currentKey)
|
|
var scene *movie.Scene
|
|
if view.model.currentScene >= 0 && view.model.currentScene < len(scenes) {
|
|
scene = &scenes[view.model.currentScene]
|
|
}
|
|
|
|
if (scene == nil) || len(scene.Frames) == 0 {
|
|
return
|
|
}
|
|
|
|
exportTo = func(dirname string) {
|
|
writer, err := os.Create(filepath.Join(dirname, filename))
|
|
if err != nil {
|
|
external.Export(view.modalStateMachine, "Could not create file.\n"+info, exportTo, true)
|
|
return
|
|
}
|
|
defer func() { _ = writer.Close() }()
|
|
|
|
colorPalette := scene.Palette.ColorPalette(false)
|
|
data := gif.GIF{
|
|
Config: image.Config{
|
|
Width: 600,
|
|
Height: 300,
|
|
ColorModel: colorPalette,
|
|
},
|
|
LoopCount: -1,
|
|
}
|
|
|
|
imageRect := image.Rect(0, 0, data.Config.Width, data.Config.Height)
|
|
for _, frame := range scene.Frames {
|
|
frameImg := image.NewPaletted(imageRect, colorPalette)
|
|
frameImg.Pix = frame.Pixels
|
|
frameImg.Stride = data.Config.Width
|
|
data.Image = append(data.Image, frameImg)
|
|
data.Delay = append(data.Delay, int(((frame.DisplayTime/time.Millisecond)+5)/10))
|
|
}
|
|
|
|
err = gif.EncodeAll(writer, &data)
|
|
if err != nil {
|
|
external.Export(view.modalStateMachine, info, exportTo, true)
|
|
return
|
|
}
|
|
}
|
|
|
|
external.Export(view.modalStateMachine, info, exportTo, false)
|
|
}
|
|
|
|
func (view *View) requestMoveSceneEarlier() {
|
|
scenes := view.movieService.Video(view.model.currentKey)
|
|
if (view.model.currentScene > 0) && (view.model.currentScene < len(scenes)) {
|
|
view.movieService.RequestMoveSceneEarlier(view.model.currentKey, view.model.currentScene,
|
|
view.restoreFuncWithScene(view.model.currentScene-1))
|
|
}
|
|
}
|
|
|
|
func (view *View) requestMoveSceneLater() {
|
|
scenes := view.movieService.Video(view.model.currentKey)
|
|
if (view.model.currentScene >= 0) && (view.model.currentScene < (len(scenes) - 1)) {
|
|
view.movieService.RequestMoveSceneLater(view.model.currentKey, view.model.currentScene,
|
|
view.restoreFuncWithScene(view.model.currentScene+1))
|
|
}
|
|
}
|
|
|
|
func (view *View) requestRemoveScene() {
|
|
scenes := view.movieService.Video(view.model.currentKey)
|
|
if (view.model.currentScene >= 0) && (view.model.currentScene < len(scenes)) {
|
|
view.movieService.RequestRemoveScene(view.model.currentKey, view.model.currentScene, view.restoreFunc())
|
|
}
|
|
}
|
|
|
|
func (view *View) requestSetFramesDisplayTime(displayTime time.Duration) {
|
|
view.movieService.RequestSetSceneFramesDisplayTime(view.model.currentKey, view.model.currentScene, displayTime, view.restoreFunc())
|
|
}
|