feat(engine): fix TransformEngineService->changeChildOrder

now consider sourceTransform's parent
Wonder-Technology · Jan 15, 2019 · 6ca57a2 · 6ca57a2
1 parent 5e5cc0a
commit 6ca57a2
Show file tree

Hide file tree

Showing 4 changed files with 188 additions and 70 deletions.
diff --git a/src/core/utils/engine/GameObjectUtils.re b/src/core/utils/engine/GameObjectUtils.re
@@ -22,7 +22,6 @@ let getParent = (child, engineState) =>
 
 let getParentGameObject = (child, engineState) =>
   getParent(child, engineState)
-  |> Js.Undefined.toOption
   |> Js.Option.map((. parentTransform) =>
        TransformEngineService.getGameObjectByTransform(
          parentTransform,

diff --git a/src/service/state/engine/TransformEngineService.re b/src/service/state/engine/TransformEngineService.re
@@ -23,7 +23,8 @@ let setTransformLocalEulerAngles = (localEulerAngles, transform, engineState) =>
   );
 
 let getParent = (child: Wonderjs.TransformType.transform, state) =>
-  Wonderjs.TransformAPI.unsafeGetTransformParent(child, state);
+  Wonderjs.TransformAPI.unsafeGetTransformParent(child, state)
+  |> Js.Undefined.toOption;
 
 let setParent =
     (
@@ -91,21 +92,25 @@ let changeChildOrder =
       state,
     )
     : Wonderjs.StateDataMainType.state => {
-  ...state,
-  transformRecord:
-    Some(
-      _changeChildOrder(
-        sourceTransfrom,
-        targetTransform,
-        getChildren(parentTransform, state),
-        action,
-      )
-      /* TODO move to engine */
-      |> Wonderjs.HierachyTransformService._setChildren(
-           Wonderjs.RecordTransformMainService.getRecord(state),
-           parentTransform,
-         ),
-    ),
+  let state = setParentKeepOrder(parentTransform, sourceTransfrom, state);
+
+  {
+    ...state,
+    transformRecord:
+      Some(
+        _changeChildOrder(
+          sourceTransfrom,
+          targetTransform,
+          getChildren(parentTransform, state),
+          action,
+        )
+        /* TODO move to engine */
+        |> Wonderjs.HierachyTransformService._setChildren(
+             Wonderjs.RecordTransformMainService.getRecord(state),
+             parentTransform,
+           ),
+      ),
+  };
 };
 
 let getGameObjectByTransform = Wonderjs.TransformAPI.unsafeGetTransformGameObject;

diff --git a/src/service/stateTuple/logic/sceneTree/CheckSceneTreeLogicService.re b/src/service/stateTuple/logic/sceneTree/CheckSceneTreeLogicService.re
@@ -1,8 +1,5 @@
 let rec _judgeAllParents = (targetTransform, draggedTransform, engineState) =>
-  switch (
-    TransformEngineService.getParent(targetTransform, engineState)
-    |> Js.Undefined.to_opt
-  ) {
+  switch (TransformEngineService.getParent(targetTransform, engineState)) {
   | None => false
   | Some(transformParent) =>
     transformParent === draggedTransform ?
@@ -34,7 +31,6 @@ let _checkTargetGameObjectBeDragedGameObjectParent =
               draggedGameObject,
             ),
        )
-    |> Js.Undefined.to_opt
   ) {
   | None => Success()
   | Some(transformParent) =>

diff --git a/test/unit/service/TransformEngineService_test.re b/test/unit/service/TransformEngineService_test.re
@@ -26,59 +26,177 @@ let _ =
 
     describe("changeChildOrder", () =>
       describe("change child order", () => {
-        let _prepare = state => {
-          let (state, parent) = Wonderjs.TransformAPI.createTransform(state);
-          let (state, child1) = Wonderjs.TransformAPI.createTransform(state);
-          let (state, child2) = Wonderjs.TransformAPI.createTransform(state);
-          let (state, child3) = Wonderjs.TransformAPI.createTransform(state);
-
-          let state =
-            state
-            |> Wonderjs.TransformAPI.setTransformParent(
-                 Js.Nullable.return(parent),
-                 child1,
-               )
-            |> Wonderjs.TransformAPI.setTransformParent(
-                 Js.Nullable.return(parent),
-                 child2,
-               )
-            |> Wonderjs.TransformAPI.setTransformParent(
-                 Js.Nullable.return(parent),
-                 child3,
-               );
+        describe("test source and target has the same parent", () => {
+          let _prepare = state => {
+            let (state, parent) =
+              Wonderjs.TransformAPI.createTransform(state);
+            let (state, child1) =
+              Wonderjs.TransformAPI.createTransform(state);
+            let (state, child2) =
+              Wonderjs.TransformAPI.createTransform(state);
+            let (state, child3) =
+              Wonderjs.TransformAPI.createTransform(state);
+
+            let state =
+              state
+              |> Wonderjs.TransformAPI.setTransformParent(
+                   Js.Nullable.return(parent),
+                   child1,
+                 )
+              |> Wonderjs.TransformAPI.setTransformParent(
+                   Js.Nullable.return(parent),
+                   child2,
+                 )
+              |> Wonderjs.TransformAPI.setTransformParent(
+                   Js.Nullable.return(parent),
+                   child3,
+                 );
+
+            (state, parent, (child1, child2, child3));
+          };
+
+          test("test before", () => {
+            let (state, parent, (child1, child2, child3)) =
+              _prepare(state^);
+
+            let state =
+              TransformEngineService.changeChildOrder(
+                child3,
+                child1,
+                parent,
+                TransformType.Before,
+                state,
+              );
+
+            TransformEngineService.getChildren(parent, state)
+            |> expect == [|child3, child1, child2|];
+          });
+          test("test after", () => {
+            let (state, parent, (child1, child2, child3)) =
+              _prepare(state^);
+
+            let state =
+              TransformEngineService.changeChildOrder(
+                child3,
+                child1,
+                parent,
+                TransformType.After,
+                state,
+              );
+
+            TransformEngineService.getChildren(parent, state)
+            |> expect == [|child1, child3, child2|];
+          });
+        });
 
-          (state, parent, (child1, child2, child3));
-        };
+        describe("test source and target has different parents", () => {
+          let _prepare = state => {
+            let (state, parent1) =
+              Wonderjs.TransformAPI.createTransform(state);
+            let (state, parent2) =
+              Wonderjs.TransformAPI.createTransform(state);
+            let (state, child1) =
+              Wonderjs.TransformAPI.createTransform(state);
+            let (state, child2) =
+              Wonderjs.TransformAPI.createTransform(state);
+            let (state, child3) =
+              Wonderjs.TransformAPI.createTransform(state);
 
-        test("test before", () => {
-          let (state, parent, (child1, child2, child3)) = _prepare(state^);
+            let state =
+              state
+              |> Wonderjs.TransformAPI.setTransformParent(
+                   Js.Nullable.return(parent1),
+                   child1,
+                 )
+              |> Wonderjs.TransformAPI.setTransformParent(
+                   Js.Nullable.return(parent1),
+                   child2,
+                 )
+              |> Wonderjs.TransformAPI.setTransformParent(
+                   Js.Nullable.return(parent2),
+                   child3,
+                 );
 
-          let state =
-            TransformEngineService.changeChildOrder(
-              child3,
-              child1,
-              parent,
-              TransformType.Before,
-              state,
-            );
+            (state, (parent1, parent2), (child1, child2, child3));
+          };
 
-          TransformEngineService.getChildren(parent, state)
-          |> expect == [|child3, child1, child2|];
+          test("test before", () => {
+            let (state, (parent1, parent2), (child1, child2, child3)) =
+              _prepare(state^);
+
+            let state =
+              TransformEngineService.changeChildOrder(
+                child3,
+                child1,
+                parent1,
+                TransformType.Before,
+                state,
+              );
+
+            (
+              TransformEngineService.getChildren(parent1, state),
+              TransformEngineService.getChildren(parent2, state),
+            )
+            |> expect == ([|child3, child1, child2|], [||]);
+          });
         });
-        test("test after", () => {
-          let (state, parent, (child1, child2, child3)) = _prepare(state^);
-
-          let state =
-            TransformEngineService.changeChildOrder(
-              child3,
-              child1,
-              parent,
-              TransformType.After,
-              state,
-            );
-
-          TransformEngineService.getChildren(parent, state)
-          |> expect == [|child1, child3, child2|];
+
+        describe("test source not has a parent", () => {
+          let _prepare = state => {
+            let (state, parent1) =
+              Wonderjs.TransformAPI.createTransform(state);
+            /* let (state, parent2) =
+               Wonderjs.TransformAPI.createTransform(state); */
+            let (state, child1) =
+              Wonderjs.TransformAPI.createTransform(state);
+            let (state, child2) =
+              Wonderjs.TransformAPI.createTransform(state);
+            let (state, child3) =
+              Wonderjs.TransformAPI.createTransform(state);
+
+            let state =
+              state
+              |> Wonderjs.TransformAPI.setTransformParent(
+                   Js.Nullable.return(parent1),
+                   child1,
+                 )
+              |> Wonderjs.TransformAPI.setTransformParent(
+                   Js.Nullable.return(parent1),
+                   child2,
+                 );
+            /* |> Wonderjs.TransformAPI.setTransformParent(
+                 Js.Nullable.return(parent2),
+                 child3,
+               ); */
+
+            (state, parent1, (child1, child2, child3));
+          };
+
+          test("test before", () => {
+            let (state, parent1, (child1, child2, child3)) =
+              _prepare(state^);
+
+            let state =
+              TransformEngineService.changeChildOrder(
+                child3,
+                child1,
+                parent1,
+                TransformType.Before,
+                state,
+              );
+
+            (
+              TransformEngineService.getChildren(parent1, state),
+              TransformEngineService.getParent(child1, state),
+              TransformEngineService.getParent(child3, state),
+            )
+            |>
+            expect == (
+                        [|child3, child1, child2|],
+                        Some(parent1),
+                        Some(parent1),
+                      );
+          });
         });
       })
     );