feat(asset-bundle): script api add initAllSABGameObjects,addSABSceneGameObjectChildrenToScene

add ImportABSystem_test test;
use.html use the new api;

Author: yyc-git

examples/asset_bundle/use.html

@@ -173,21 +173,22 @@
                                         var state = api.unsafeGetState();
 
 
-                                        var allGameObjects = api.getAllGameObjects(sceneGameObject, state);
 
-                                        var state =
-                                            allGameObjects.reduce((state, gameObject) => {
-                                                return api.initGameObject(
-                                                    gameObject, state
-                                                );
-                                            }, state);
+                                        var state = api.initAllSABGameObjects(
+                                            sceneGameObject, state
+                                        );
 
 
-                                        var state =
-                                            api.disposeSceneAllChildren(state);
+                                        // var state =
+                                        //     api.disposeSceneAllChildren(state);
+
+                                        // var state =
+                                        //     api.setSABSceneGameObjectToBeScene(sceneGameObject, state);
+
 
                                         var state =
-                                            api.setSABSceneGameObjectToBeScene(sceneGameObject, state);
+                                            api.addSABSceneGameObjectChildrenToScene(sceneGameObject, state);
+
 
                                         api.setState(state);
                                     },

src/asset_bundle/import/ImportABSystem.re

@@ -183,15 +183,28 @@ module RAB = {
   };
 };
 
-let setSABSceneGameObjectToBeScene = (sceneGameObject, state) =>
-  GameObjectSceneMainService.setSceneGameObject(sceneGameObject, state);
+let setSABSceneGameObjectToBeScene = (sabSceneGameObject, state) =>
+  GameObjectSceneMainService.setSceneGameObject(sabSceneGameObject, state);
+
+let initAllSABGameObjects = (sabSceneGameObject, state) =>
+  state
+  |> AllGameObjectMainService.getAllGameObjects(sabSceneGameObject)
+  |> WonderCommonlib.ArrayService.reduceOneParam(
+       (. state, gameObject) =>
+         InitGameObjectMainService.initGameObject(gameObject, state),
+       state,
+     );
+
+let addSABSceneGameObjectChildrenToScene = (sabSceneGameObject, state) =>
+  state
+  |> AllGameObjectMainService.getAllChildren(sabSceneGameObject)
+  |> GameObjectSceneMainService.addChildren(_, state);
 
 let disposeSceneAllChildren = state => {
   let scene = state |> GameObjectSceneMainService.getSceneGameObject;
 
   state
-  |> AllGameObjectMainService.getAllGameObjects(scene)
-  |> Js.Array.sliceFrom(1)
+  |> AllGameObjectMainService.getAllChildren(scene)
   |> WonderCommonlib.ArrayService.reduceOneParam(
        (. state, gameObject) =>
          state |> DisposeGameObjectMainService.deferDispose(gameObject),

src/service/state/main/api/script/RecordScriptAPIMainService.re

@@ -141,6 +141,18 @@ let create = () => {
   "disposeSceneAllChildren":
     (. state) => ImportABSystem.disposeSceneAllChildren(state),
   "setSABSceneGameObjectToBeScene":
-    (. sceneGameObject, state) =>
-      ImportABSystem.setSABSceneGameObjectToBeScene(sceneGameObject, state),
+    (. sabSceneGameObject, state) =>
+      ImportABSystem.setSABSceneGameObjectToBeScene(
+        sabSceneGameObject,
+        state,
+      ),
+  "initAllSABGameObjects":
+    (. sabSceneGameObject, state) =>
+      ImportABSystem.initAllSABGameObjects(sabSceneGameObject, state),
+  "addSABSceneGameObjectChildrenToScene":
+    (. sabSceneGameObject, state) =>
+      ImportABSystem.addSABSceneGameObjectChildrenToScene(
+        sabSceneGameObject,
+        state,
+      ),
 };

src/service/state/main/gameObject/AllGameObjectMainService.re

@@ -52,6 +52,9 @@ let getAllGameObjects = (gameObject, state) => {
   );
 };
 
+let getAllChildren = (gameObject, state) =>
+  state |> getAllGameObjects(gameObject) |> Js.Array.sliceFrom(1);
+
 let _getAllComponentsOfGameObject =
     (gameObject, getComponentFunc, {gameObjectRecord} as state) => {
   let (_, components) =

test/integration/no_worker/asset_bundle/tool/GenerateSABTool.re

@@ -364,4 +364,7 @@ let findGameObjectsByName = (targetGameObject, name, state) =>
 
 let unsafeFindGameObjectByName = (targetGameObject, name, state) =>
   findGameObjectsByName(targetGameObject, name, state)
-  |> ArrayService.unsafeGetFirst;
+  |> ArrayService.unsafeGetFirst;
+
+let isDeferDisposed = (gameObject, state) =>
+  state.gameObjectRecord.disposedUidArray |> Js.Array.includes(gameObject);

test/tool/service/gameObject/GameObjectTool.re

@@ -0,0 +1,104 @@
+open Wonder_jest;
+
+let _ =
+  describe("ImportABSystem", () => {
+    open Expect;
+    open Expect.Operators;
+    open Sinon;
+
+    let sandbox = getSandboxDefaultVal();
+    let state = ref(CreateStateMainService.createState());
+
+    beforeEach(() => {
+      sandbox := createSandbox();
+      state := TestTool.init(~sandbox, ());
+    });
+    afterEach(() => restoreSandbox(refJsObjToSandbox(sandbox^)));
+
+    describe("setSABSceneGameObjectToBeScene", () =>
+      test("set sab->scene gameObject to be scene", () => {
+        let (state, gameObject) = GameObjectAPI.createGameObject(state^);
+
+        let state =
+          ImportABSystem.setSABSceneGameObjectToBeScene(gameObject, state);
+
+        SceneAPI.getSceneGameObject(state) |> expect == gameObject;
+      })
+    );
+
+    describe("initAllSABGameObjects", () => {
+      beforeEach(() =>
+        state :=
+          TestTool.initWithJobConfigWithoutBuildFakeDom(
+            ~sandbox,
+            ~noWorkerJobRecord=NoWorkerJobConfigTool.buildNoWorkerJobConfig(),
+            (),
+          )
+      );
+
+      test("init all sab->gameObjects", () => {
+        let (state, gameObject1, _, _) =
+          InitLightMaterialJobTool.prepareGameObject(sandbox, state^);
+        let (state, gameObject2, _, _) =
+          InitLightMaterialJobTool.prepareGameObject(sandbox, state);
+        let state =
+          state |> GameObjectTool.addChild(gameObject1, gameObject2);
+        let attachShader = createEmptyStubWithJsObjSandbox(sandbox);
+        let state =
+          state
+          |> FakeGlTool.setFakeGl(
+               FakeGlTool.buildFakeGl(~sandbox, ~attachShader, ()),
+             );
+        let state = AllMaterialTool.prepareForInit(state);
+
+        let state = ImportABSystem.initAllSABGameObjects(gameObject1, state);
+
+        attachShader |> getCallCount |> expect == 2;
+      });
+    });
+
+    describe("addSABSceneGameObjectChildrenToScene", () =>
+      test("add sab->scene gameObject->children to scene", () => {
+        let (state, gameObject1) = GameObjectAPI.createGameObject(state^);
+        let (state, gameObject2) = GameObjectAPI.createGameObject(state);
+        let state =
+          state |> GameObjectTool.addChild(gameObject1, gameObject2);
+
+        let (state, gameObject3) = GameObjectAPI.createGameObject(state);
+
+        let state = state |> SceneAPI.addSceneChild(gameObject3);
+
+        let state =
+          ImportABSystem.addSABSceneGameObjectChildrenToScene(
+            gameObject1,
+            state,
+          );
+
+        GameObjectTool.getChildren(SceneAPI.getSceneGameObject(state), state)
+        |> expect == [|gameObject3, gameObject2|];
+      })
+    );
+
+    describe("disposeSceneAllChildren", () =>
+      test("dispose all scene->children", () => {
+        let (state, gameObject1) = GameObjectAPI.createGameObject(state^);
+        let (state, gameObject2) = GameObjectAPI.createGameObject(state);
+        let state =
+          state |> GameObjectTool.addChild(gameObject1, gameObject2);
+
+        let (state, gameObject3) = GameObjectAPI.createGameObject(state);
+
+        let state =
+          state |> SceneAPI.addSceneChildren([|gameObject3, gameObject1|]);
+
+        let state = ImportABSystem.disposeSceneAllChildren(state);
+
+        (
+          GameObjectTool.isDeferDisposed(gameObject1, state),
+          GameObjectTool.isDeferDisposed(gameObject2, state),
+          GameObjectTool.isDeferDisposed(gameObject3, state),
+        )
+        |> expect == (true, true, true);
+      })
+    );
+  });