add loading switch and dummy load for testing

engine/camera.go

@@ -40,6 +40,8 @@ func init() {
 type Camera struct {
 	ID
 	Child interface{}
+	Disables
+	Hides
 
 	// Camera controls
 	// These directly manipulate the camera. If you want to restrict the camera

engine/dummy.go

@@ -0,0 +1,18 @@
+package engine
+
+import (
+	"io/fs"
+	"time"
+)
+
+// DummyLoad is a loader that just takes up time and doesn't actually load
+// anything.
+type DummyLoad struct {
+	time.Duration
+}
+
+// Load sleeps for d.Duration, then returns nil.
+func (d DummyLoad) Load(fs.FS) error {
+	time.Sleep(d.Duration)
+	return nil
+}

engine/loading.go

@@ -17,12 +17,56 @@ limitations under the License.
 package engine
 
 import (
-	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/ebitenutil"
+	"io/fs"
+	"log"
+	"time"
 )
 
-type LoadingScreen struct{}
+type LoadingSwitch struct {
+	During Hider
+	After  Hider
 
-func (LoadingScreen) Draw(screen *ebiten.Image, _ *ebiten.DrawImageOptions) {
-	ebitenutil.DebugPrint(screen, "Loading...")
+	assets fs.FS
+}
+
+// Scan only scans s.During, thus, only s.During is loaded by Game directly.
+func (s *LoadingSwitch) Scan(visit VisitFunc) error {
+	return visit(s.During)
+}
+
+// Load stores a copy of assets to use later.
+func (s *LoadingSwitch) Load(assets fs.FS) error {
+	s.assets = assets
+	return nil
+}
+
+// Prepare loads, registers, and prepares.After in a separate goroutine. Once
+// ready, LoadingSwitch hides s.During and shows s.After.
+func (s *LoadingSwitch) Prepare(game *Game) error {
+	go func() {
+		startLoad := time.Now()
+		if err := game.Load(s.After, s.assets); err != nil {
+			log.Printf("Couldn't load: %v", err)
+			return
+		}
+		log.Printf("LoadingSwitch: finished loading in %v", time.Since(startLoad))
+
+		startBuild := time.Now()
+		if err := game.Register(s.After, s); err != nil {
+			log.Printf("Couldn't register: %v", err)
+			return
+		}
+		log.Printf("LoadingSwitch: finished registering in %v", time.Since(startBuild))
+		startPrep := time.Now()
+		if err := game.Prepare(s.After); err != nil {
+			log.Printf("Couldn't prepare: %v", err)
+			return
+		}
+		log.Printf("LoadingSwitch: finished preparing in %v", time.Since(startPrep))
+
+		// TODO: better scene transitions
+		s.During.Hide()
+		s.After.Show()
+	}()
+	return nil
 }

example.go

@@ -91,10 +91,16 @@ func main() {
 					ID:    "bg_fill",
 					Color: color.Gray{100},
 				},
-				&engine.Camera{
+				&engine.LoadingSwitch{
+					During: &engine.Billboard{
+						ID:  "loading_screen",
+						Src: engine.ImageRef{Path: "assets/loading.png"},
+					},
+					After: &engine.Camera{
 						ID:    "game_camera",
 						Child: lev1,
 					},
+				},
 				&engine.DebugToast{ID: "toast", Pos: image.Pt(0, 15)},
 				engine.PerfDisplay{},
 			),

example/level1.go

@@ -18,6 +18,7 @@ package example
 
 import (
 	"image"
+	"time"
 
 	"github.com/DrJosh9000/ichigo/engine"
 	"github.com/DrJosh9000/ichigo/geom"
@@ -29,6 +30,9 @@ func Level1() *engine.Scene {
 		ID:     "level_1",
 		Bounds: engine.Bounds(image.Rect(-32, -32, 320+32, 240+32)),
 		Child: engine.MakeContainer(
+			engine.DummyLoad{
+				Duration: 2 * time.Second,
+			},
 			&engine.Parallax{
 				CameraID: "game_camera",
 				Child: &engine.Billboard{