theater/qrun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge Timeline and timelineBuilder into single struct, remove cells()/setCells()

Browse Source
This commit is contained in:
Ian Gulliver
2026-02-20 16:27:23 -07:00
parent 4607e77ee7
commit 47ed09a848
1 changed files with 97 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

215
cmd/qrunproxy/timeline.go
View File

@@ -48,6 +48,11 @@ type TimelineTrack struct {
type Timeline struct {
Tracks []TimelineTrack `json:"tracks"`
Blocks map[string]Block `json:"blocks"`
show Show `json:"-"`
trackIdx map[string]int `json:"-"`
constraints []constraint `json:"-"`
exclusives []exclusiveGroup `json:"-"`
}
type TimelineCell struct {
@@ -76,47 +81,7 @@ type exclusiveGroup struct {
members []cellID
}
type timelineBuilder struct {
show Show
blocks map[string]Block
tracks []Track
trackIdx map[string]int
trackCells [][]TimelineCell
constraints []constraint
exclusives []exclusiveGroup
}
func newTimelineBuilder(show Show) *timelineBuilder {
b := &timelineBuilder{
show: show,
blocks: map[string]Block{},
trackIdx: map[string]int{},
}
b.tracks = append(b.tracks, Track{ID: cueTrackID, Name: "Cue"})
b.trackIdx[cueTrackID] = 0
for i, track := range show.Tracks {
b.tracks = append(b.tracks, track)
b.trackIdx[track.ID] = i + 1
}
for _, block := range show.Blocks {
if block.Type == "cue" {
block.Track = cueTrackID
}
b.blocks[block.ID] = block
}
b.trackCells = make([][]TimelineCell, len(b.tracks))
return b
}
func validateShow(show Show) error {
blockSet := map[string]bool{}
for _, block := range show.Blocks {
blockSet[block.ID] = true
}
startTargeted := map[string]bool{}
for _, trigger := range show.Triggers {
for _, target := range trigger.Targets {
@@ -143,25 +108,34 @@ func BuildTimeline(show Show) (Timeline, error) {
return Timeline{}, err
}
b := newTimelineBuilder(show)
b.buildCells()
b.buildConstraints()
b.assignRows()
tracks := make([]TimelineTrack, len(b.tracks))
for i, t := range b.tracks {
tracks[i] = TimelineTrack{Track: t, Cells: b.trackCells[i]}
tl := Timeline{
show: show,
Blocks: map[string]Block{},
trackIdx: map[string]int{},
}
return Timeline{
Tracks: tracks,
Blocks: b.blocks,
}, nil
tl.Tracks = append(tl.Tracks, TimelineTrack{Track: Track{ID: cueTrackID, Name: "Cue"}})
tl.trackIdx[cueTrackID] = 0
for i, track := range show.Tracks {
tl.Tracks = append(tl.Tracks, TimelineTrack{Track: track})
tl.trackIdx[track.ID] = i + 1
}
for _, block := range show.Blocks {
if block.Type == "cue" {
block.Track = cueTrackID
}
tl.Blocks[block.ID] = block
}
tl.buildCells()
tl.buildConstraints()
tl.assignRows()
return tl, nil
}
func (b *timelineBuilder) addConstraint(kind string, a, b2 cellID) {
b.constraints = append(b.constraints, constraint{kind: kind, a: a, b: b2})
func (tl *Timeline) addConstraint(kind string, a, b cellID) {
tl.constraints = append(tl.constraints, constraint{kind: kind, a: a, b: b})
}
func getCueCells(block Block) []TimelineCell {
@@ -182,9 +156,9 @@ func getBlockCells(block Block) []TimelineCell {
}
}
func (b *timelineBuilder) findCell(blockID, event string) cellID {
track := b.trackIdx[b.blocks[blockID].Track]
for i, c := range b.trackCells[track] {
func (tl *Timeline) findCell(blockID, event string) cellID {
track := tl.trackIdx[tl.Blocks[blockID].Track]
for i, c := range tl.Tracks[track].Cells {
if !c.IsGap && c.BlockID == blockID && c.Event == event {
return cellID{track: track, index: i}
}
@@ -192,14 +166,14 @@ func (b *timelineBuilder) findCell(blockID, event string) cellID {
panic("cell not found: " + blockID + " " + event)
}
func (b *timelineBuilder) endChainsSameTrack(blockID string) bool {
trackID := b.blocks[blockID].Track
for _, trigger := range b.show.Triggers {
func (tl *Timeline) endChainsSameTrack(blockID string) bool {
trackID := tl.Blocks[blockID].Track
for _, trigger := range tl.show.Triggers {
if trigger.Source.Block != blockID || trigger.Source.Signal != "END" {
continue
}
for _, target := range trigger.Targets {
if target.Hook == "START" && b.blocks[target.Block].Track == trackID {
if target.Hook == "START" && tl.Blocks[target.Block].Track == trackID {
return true
}
}
@@ -207,10 +181,10 @@ func (b *timelineBuilder) endChainsSameTrack(blockID string) bool {
return false
}
func (b *timelineBuilder) buildCells() {
for _, sb := range b.show.Blocks {
block := b.blocks[sb.ID]
idx := b.trackIdx[block.Track]
func (tl *Timeline) buildCells() {
for _, sb := range tl.show.Blocks {
block := tl.Blocks[sb.ID]
idx := tl.trackIdx[block.Track]
var cells []TimelineCell
switch block.Type {
case "cue":
@@ -218,58 +192,57 @@ func (b *timelineBuilder) buildCells() {
default:
cells = getBlockCells(block)
}
b.trackCells[idx] = append(b.trackCells[idx], cells...)
if block.Type != "cue" && !b.endChainsSameTrack(block.ID) {
b.trackCells[idx] = append(b.trackCells[idx], TimelineCell{IsGap: true, IsBreak: true})
tl.Tracks[idx].Cells = append(tl.Tracks[idx].Cells, cells...)
if block.Type != "cue" && !tl.endChainsSameTrack(block.ID) {
tl.Tracks[idx].Cells = append(tl.Tracks[idx].Cells, TimelineCell{IsGap: true, IsBreak: true})
}
}
}
func (b *timelineBuilder) buildConstraints() {
for _, trigger := range b.show.Triggers {
sourceID := b.findCell(trigger.Source.Block, trigger.Source.Signal)
func (tl *Timeline) buildConstraints() {
for _, trigger := range tl.show.Triggers {
sourceID := tl.findCell(trigger.Source.Block, trigger.Source.Signal)
group := exclusiveGroup{members: []cellID{sourceID}}
hasCrossTrack := false
for _, target := range trigger.Targets {
targetID := b.findCell(target.Block, target.Hook)
targetID := tl.findCell(target.Block, target.Hook)
if sourceID.track == targetID.track {
b.addConstraint("next_row", sourceID, targetID)
tl.addConstraint("next_row", sourceID, targetID)
} else {
b.addConstraint("same_row", sourceID, targetID)
tl.addConstraint("same_row", sourceID, targetID)
hasCrossTrack = true
}
group.members = append(group.members, targetID)
}
if hasCrossTrack {
b.trackCells[sourceID.track][sourceID.index].IsSignal = true
tl.Tracks[sourceID.track].Cells[sourceID.index].IsSignal = true
}
b.exclusives = append(b.exclusives, group)
tl.exclusives = append(tl.exclusives, group)
}
}
func (b *timelineBuilder) assignRows() {
func (tl *Timeline) assignRows() {
for {
found := false
for _, c := range b.constraints {
aRow := b.rowOf(c.a)
bRow := b.rowOf(c.b)
for _, c := range tl.constraints {
aRow := tl.rowOf(c.a)
bRow := tl.rowOf(c.b)
switch c.kind {
case "same_row":
if aRow < bRow {
b.insertGap(c.a.track, c.a.index)
tl.insertGap(c.a.track, c.a.index)
found = true
} else if bRow < aRow {
b.insertGap(c.b.track, c.b.index)
tl.insertGap(c.b.track, c.b.index)
found = true
}
case "next_row":
if bRow <= aRow {
b.insertGap(c.b.track, c.b.index)
tl.insertGap(c.b.track, c.b.index)
found = true
}
}
@@ -278,7 +251,7 @@ func (b *timelineBuilder) assignRows() {
}
}
if !found {
found = b.enforceExclusives()
found = tl.enforceExclusives()
}
if !found {
break
@@ -286,50 +259,51 @@ func (b *timelineBuilder) assignRows() {
}
}
func (b *timelineBuilder) enforceExclusives() bool {
for _, g := range b.exclusives {
func (tl *Timeline) enforceExclusives() bool {
for _, g := range tl.exclusives {
if len(g.members) == 0 {
continue
}
row := b.rowOf(g.members[0])
row := tl.rowOf(g.members[0])
allAligned := true
memberTracks := map[int]bool{}
for _, m := range g.members {
memberTracks[m.track] = true
if b.rowOf(m) != row {
if tl.rowOf(m) != row {
allAligned = false
}
}
if !allAligned {
continue
}
for trackIdx := range b.trackCells {
for trackIdx := range tl.Tracks {
if memberTracks[trackIdx] {
continue
}
if row >= len(b.trackCells[trackIdx]) {
if row >= len(tl.Tracks[trackIdx].Cells) {
continue
}
c := b.trackCells[trackIdx][row]
c := tl.Tracks[trackIdx].Cells[row]
if c.IsGap || c.BlockID == "" {
continue
}
b.insertGap(trackIdx, row)
tl.insertGap(trackIdx, row)
return true
}
}
return false
}
func (b *timelineBuilder) rowOf(id cellID) int {
func (tl *Timeline) rowOf(id cellID) int {
return id.index
}
func (b *timelineBuilder) isAllGapRow(row, exceptTrack int) bool {
for trackIdx, cells := range b.trackCells {
func (tl *Timeline) isAllGapRow(row, exceptTrack int) bool {
for trackIdx := range tl.Tracks {
if trackIdx == exceptTrack {
continue
}
cells := tl.Tracks[trackIdx].Cells
if row >= len(cells) {
continue
}
@@ -340,11 +314,12 @@ func (b *timelineBuilder) isAllGapRow(row, exceptTrack int) bool {
return true
}
func (b *timelineBuilder) removeGapAt(track, index int) {
b.trackCells[track] = append(b.trackCells[track][:index], b.trackCells[track][index+1:]...)
func (tl *Timeline) removeGapAt(track, index int) {
cells := tl.Tracks[track].Cells
tl.Tracks[track].Cells = append(cells[:index], cells[index+1:]...)
for i := range b.constraints {
c := &b.constraints[i]
for i := range tl.constraints {
c := &tl.constraints[i]
if c.a.track == track && c.a.index > index {
c.a.index--
}
@@ -352,9 +327,9 @@ func (b *timelineBuilder) removeGapAt(track, index int) {
c.b.index--
}
}
for i := range b.exclusives {
for j := range b.exclusives[i].members {
m := &b.exclusives[i].members[j]
for i := range tl.exclusives {
for j := range tl.exclusives[i].members {
m := &tl.exclusives[i].members[j]
if m.track == track && m.index > index {
m.index--
}
@@ -362,10 +337,10 @@ func (b *timelineBuilder) removeGapAt(track, index int) {
}
}
func (b *timelineBuilder) insertGap(track, beforeIndex int) {
func (tl *Timeline) insertGap(track, beforeIndex int) {
for {
blocked := false
for _, c := range b.constraints {
for _, c := range tl.constraints {
if c.kind == "next_row" && c.a.track == track && c.b.track == track && c.a.index == beforeIndex-1 && c.b.index == beforeIndex {
beforeIndex = c.a.index
blocked = true
@@ -377,16 +352,16 @@ func (b *timelineBuilder) insertGap(track, beforeIndex int) {
}
}
if b.isAllGapRow(beforeIndex, track) {
for trackIdx := range b.trackCells {
if tl.isAllGapRow(beforeIndex, track) {
for trackIdx := range tl.Tracks {
if trackIdx == track {
continue
}
if beforeIndex >= len(b.trackCells[trackIdx]) {
if beforeIndex >= len(tl.Tracks[trackIdx].Cells) {
continue
}
if b.trackCells[trackIdx][beforeIndex].IsGap {
b.removeGapAt(trackIdx, beforeIndex)
if tl.Tracks[trackIdx].Cells[beforeIndex].IsGap {
tl.removeGapAt(trackIdx, beforeIndex)
}
}
return
@@ -394,7 +369,7 @@ func (b *timelineBuilder) insertGap(track, beforeIndex int) {
gap := TimelineCell{IsGap: true}
for i := beforeIndex - 1; i >= 0; i-- {
c := b.trackCells[track][i]
c := tl.Tracks[track].Cells[i]
if c.IsGap {
continue
}
@@ -404,15 +379,15 @@ func (b *timelineBuilder) insertGap(track, beforeIndex int) {
break
}
cells := b.trackCells[track]
cells := tl.Tracks[track].Cells
newCells := make([]TimelineCell, 0, len(cells)+1)
newCells = append(newCells, cells[:beforeIndex]...)
newCells = append(newCells, gap)
newCells = append(newCells, cells[beforeIndex:]...)
b.trackCells[track] = newCells
tl.Tracks[track].Cells = newCells
for i := range b.constraints {
c := &b.constraints[i]
for i := range tl.constraints {
c := &tl.constraints[i]
if c.a.track == track && c.a.index >= beforeIndex {
c.a.index++
}
@@ -420,14 +395,12 @@ func (b *timelineBuilder) insertGap(track, beforeIndex int) {
c.b.index++
}
}
for i := range b.exclusives {
for j := range b.exclusives[i].members {
m := &b.exclusives[i].members[j]
for i := range tl.exclusives {
for j := range tl.exclusives[i].members {
m := &tl.exclusives[i].members[j]
if m.track == track && m.index >= beforeIndex {
m.index++
}
}
}
}