Home Reference Source

cables_dev/cables_ui/src/ui/commands/cmd_debug.js

  1. import { Logger, TalkerAPI } from "cables-shared-client";
  2. import GlDebugTab from "../components/tabs/tab_debugglui.js";
  3. import MetaHistory from "../components/tabs/tab_history.js";
  4. import LoggingTab from "../components/tabs/tab_logfilter.js";
  5. import OpDocsJson from "../components/tabs/tab_opdocsjson.js";
  6. import OpSerialized from "../components/tabs/tab_opserialized.js";
  7. import OpWatchUiAttribs from "../components/tabs/tab_uiattribs.js";
  8. import GlGuiTab from "../components/tabs/tab_glpatch.js";
  10. import CMD from "./commands.js";
  11. import { portType } from "../core_constants.js";
  12. import { platform } from "../platform.js";
  13. import tab_PreferencesDebug from "../components/tabs/tab_preferencesdebug.js";
  14. import { CmdPatch } from "./cmd_patch.js";
  15. import UserSettings, { userSettings } from "../components/usersettings.js";
  17. import Gui, { gui } from "../gui.js";
  18. import GlTimelineDebugTab from "../components/tabs/tab_debugtimeline.js";
  19. import TabThreeDebug from "../components/tabs/tab_threedebug.js";
  21. const log = new Logger("CMD DEBUG");
  22. export { CmdDebug };
  24. class CmdDebug
  25. {
  27.     /** @type {import("./commands.js").CommandObject[]} */
  28.     static get commands()
  29.     {
  31.         return [
  32.             {
  33.                 "cmd": "Glui debug",
  34.                 "category": "debug",
  35.                 "func": CmdDebug.debugGlUi,
  36.                 "icon": "command"
  37.             },
  38.             {
  39.                 "cmd": "timeline debug",
  40.                 "category": "debug",
  41.                 "func": CmdDebug.debugTimeline,
  42.                 "icon": "command"
  43.             },
  44.             {
  45.                 "cmd": "Glui debug colors",
  46.                 "category": "debug",
  47.                 "userSetting": UserSettings.SETTING_GLUI_DEBUG_COLORS,
  48.                 "func": CmdDebug.debugGlUiColors,
  49.                 "icon": "command"
  50.             },
  51.             {
  52.                 "cmd": "Test all ops",
  53.                 "category": "debug",
  54.                 "func": CmdDebug.testAllOps,
  55.                 "icon": "command"
  56.             },
  57.             {
  58.                 "cmd": "Dump global vars",
  59.                 "category": "debug",
  60.                 "func": CmdDebug.globalVarDump,
  61.                 "icon": "command"
  62.             },
  63.             {
  64.                 "cmd": "Logging",
  65.                 "category": "debug",
  66.                 "func": CmdDebug.logging,
  67.                 "icon": "command"
  68.             },
  69.             {
  70.                 "cmd": "Log console",
  71.                 "category": "debug",
  72.                 "func": CmdDebug.logConsole,
  73.                 "icon": "list"
  74.             },
  75.             {
  76.                 "cmd": "Log socketcluster traffic",
  77.                 "category": "debug",
  78.                 "func": CmdDebug.logSocketCluster,
  79.                 "icon": "command"
  80.             },
  81.             {
  82.                 "cmd": "Glgui tab",
  83.                 "category": "debug",
  84.                 "func": CmdDebug.newGlguiTab,
  85.                 "icon": "command"
  86.             },
  87.             {
  88.                 "cmd": "Toggle multiplayer",
  89.                 "category": "debug",
  90.                 "func": CmdDebug.toggleMultiplayer,
  91.                 "icon": "command"
  92.             },
  93.             {
  94.                 "cmd": "Restriction remoteviewer",
  95.                 "category": "debug",
  96.                 "func": CmdDebug.restrictRemoteView,
  97.                 "icon": "command"
  98.             },
  99.             {
  100.                 "cmd": "Restriction follow",
  101.                 "category": "debug",
  102.                 "func": CmdDebug.restrictFollow,
  103.                 "icon": "command"
  104.             },
  105.             {
  106.                 "cmd": "Restriction explorer",
  107.                 "category": "debug",
  108.                 "func": CmdDebug.restrictExplorer,
  109.                 "icon": "command"
  110.             },
  111.             {
  112.                 "cmd": "Restriction full",
  113.                 "category": "debug",
  114.                 "func": CmdDebug.restrictFull,
  115.                 "icon": "command"
  116.             },
  117.             {
  118.                 "cmd": "Test op",
  119.                 "category": "debug",
  120.                 "func": CmdDebug.testOp,
  121.                 "icon": "op"
  122.             },
  123.             {
  124.                 "cmd": "Show op docs json",
  125.                 "func": CmdDebug.watchOpDocsJson,
  126.                 "category": "debug",
  127.                 "icon": "op"
  128.             },
  129.             {
  130.                 "cmd": "Show op serialized",
  131.                 "func": CmdDebug.watchOpSerialized,
  132.                 "category": "debug",
  133.                 "icon": "op"
  134.             },
  135.             {
  136.                 "cmd": "Show op uiattribs",
  137.                 "func": CmdDebug.watchOpUiAttribs,
  138.                 "category": "debug",
  139.                 "icon": "op"
  140.             },
  141.             {
  142.                 "cmd": "Save without objnames",
  143.                 "func": CmdDebug.saveWithOutObjnames,
  144.                 "category": "debug",
  145.                 "icon": "op"
  146.             },
  147.             {
  148.                 "cmd": "Glui focusOpAnim",
  149.                 "func": CmdDebug.focusOpAnim,
  150.                 "category": "debug",
  151.             },
  152.             {
  153.                 "cmd": "Undo history",
  154.                 "func": CmdDebug.undoHistory,
  155.                 "category": "debug",
  156.             },
  157.             {
  158.                 "cmd": "Test all commands",
  159.                 "func": CmdDebug.testCommands,
  160.                 "category": "debug",
  161.             },
  162.             {
  163.                 "cmd": "Show User Preferences Data",
  164.                 "func": CmdDebug.showUserPrefs,
  165.                 "category": "debug",
  166.             },
  168.             {
  169.                 "cmd": "Three Debug",
  170.                 "func": CmdDebug.showThreeDebug,
  171.                 "category": "debug",
  172.             },
  174.         ];
  175.     }
  177.     static showUserPrefs()
  178.     {
  179.         new tab_PreferencesDebug(gui.mainTabs);
  180.         gui.maintabPanel.show();
  181.     }
  183.     static showThreeDebug()
  184.     {
  185.         new TabThreeDebug(gui.mainTabs);
  186.         gui.maintabPanel.show();
  187.     }
  189.     static testCommands()
  190.     {
  191.         for (let i = 0; i < CMD.commands.length; i++)
  192.         {
  193.             if (CMD.commands[i].cmd.indexOf("Test all") == -1 &&
  194.             CMD.commands[i].cmd != "Upload file" &&
  195.             CMD.commands[i].cmd != "Clear" &&
  196.             CMD.commands[i].cmd != "Reload patch" &&
  197.             CMD.commands[i].cmd != "Open patch website" &&
  198.             CMD.commands[i].cmd != "Toggle window fullscreen")
  199.             {
  200.                 log.log("CMD: " + CMD.commands[i].cmd);
  201.                 if (!CMD.commands[i].func)log.error("cmd has no function");
  202.                 else CMD.commands[i].func();
  203.             }
  204.         }
  205.     }
  207.     static testBlueprint2()
  208.     {
  209.         const p = gui.corePatch();
  210.         const sub = gui.patchView.getCurrentSubPatch();
  212.         let ops = p.getSubPatchOps(sub, true);
  214.         const serOps = [];
  216.         for (let i = 0; i < ops.length; i++)
  217.         {
  218.             serOps.push(ops[i].getSerialized());
  219.         }
  221.         log.log(JSON.stringify(serOps));
  222.     }
  224.     static globalVarDump()
  225.     {
  226.         CABLESUILOADER.GlobalVarTester.after(window);
  227.     }
  229.     static newGlguiTab()
  230.     {
  231.         new GlGuiTab(gui.mainTabs);
  232.     }
  234.     static toggleMultiplayer()
  235.     {
  236.         platform.talkerAPI.send(
  237.             TalkerAPI.CMD_TOGGLE_MULTIPLAYER_SESSION,
  238.             { "projectId": this._patchId },
  239.             (err, res) =>
  240.             {
  241.             // window reloaded from outside
  242.             },
  243.         );
  245.     /*
  246.      *if (!gui.getSavedState())
  247.      *{
  248.      *    log.log("SHOW MODAL");
  249.      *}
  250.      *else
  251.      *{
  252.      *    platform.talkerAPI.send(
  253.      *        "toggleMultiplayerSession",
  254.      *        { "projectId": this._patchId },
  255.      *        (err, res) =>
  256.      *        {
  257.      *            // window reloaded from outside
  258.      *        },
  259.      *    );
  260.      *}
  261.      */
  262.     }
  264.     static debugGlUiColors()
  265.     {
  266.         userSettings.set(UserSettings.SETTING_GLUI_DEBUG_COLORS, !userSettings.get(UserSettings.SETTING_GLUI_DEBUG_COLORS));
  268.     }
  270.     static debugGlUi()
  271.     {
  272.         new GlDebugTab(gui.mainTabs);
  273.         gui.maintabPanel.show(true);
  274.     }
  276.     static debugTimeline()
  277.     {
  278.         new GlTimelineDebugTab(gui.mainTabs);
  279.         gui.maintabPanel.show(true);
  280.     }
  282.     static logConsole()
  283.     {
  284.         if (gui) gui.showBottomTabs();
  285.         else log.warn("couldnot open bottomtabs");
  286.     }
  288.     static logging()
  289.     {
  290.         new LoggingTab(gui.mainTabs);
  291.         gui.maintabPanel.show(true);
  292.     }
  294.     static logSocketCluster()
  295.     {
  296.         if (gui.socket) gui.socket.enableVerboseLogging();
  297.     }
  299.     static restrictRemoteView = () =>
  300.     {
  301.         gui.setRestriction(Gui.RESTRICT_MODE_REMOTEVIEW);
  302.     };
  304.     static restrictFollow = () =>
  305.     {
  306.         gui.setRestriction(Gui.RESTRICT_MODE_FOLLOWER);
  307.     };
  309.     static restrictExplorer = () =>
  310.     {
  311.         gui.setRestriction(Gui.RESTRICT_MODE_EXPLORER);
  312.     };
  314.     static restrictFull = () =>
  315.     {
  316.         gui.setRestriction(Gui.RESTRICT_MODE_FULL);
  317.     };
  319.     static testAllOps()
  320.     {
  321.         function load(opname)
  322.         {
  323.             gui.serverOps.loadOpDependencies(opname, function ()
  324.             {
  325.                 gui.corePatch().addOp(opname);
  326.             });
  327.         }
  329.         const ops = gui.opDocs.getAll();
  331.         log.log(ops);
  333.         for (const i in ops)
  334.         {
  335.             log.log(ops[i].name);
  336.             const opname = ops[i].name;
  338.             load(opname);
  339.         }
  340.     }
  342.     static focusOpAnim()
  343.     {
  344.         const ops = gui.patchView.getSelectedOps();
  345.         if (ops.length > 0) gui.patchView.patchRenderer.focusOpAnim(ops[0].id);
  346.     }
  348.     static testOp()
  349.     {
  350.         const ops = gui.patchView.getSelectedOps();
  352.         for (let i = 0; i < ops.length; i++)
  353.         {
  354.             for (let j = 0; j < 100; j++)
  355.             {
  356.                 for (let ip = 0; ip < ops[i].portsIn.length; ip++)
  357.                 {
  358.                     const p = ops[i].portsIn[ip];
  360.                     if (p.type == portType.array)
  361.                     {
  362.                         const tests = [
  363.                             () => { p.set([]); },
  364.                             () => { p.set(null); },
  365.                             () => { p.set(undefined); },
  366.                             () => { p.set([0]); },
  367.                             () => { p.set([0, 1]); },
  368.                             () => { p.set([0, 1, 2]); },
  369.                             () => { p.set([-0, -1, -2]); },
  370.                             () => { p.set([0, 1, 2, 3]); },
  371.                             () => { p.set([0, 1, 2, 3, 4]); },
  372.                             () => { p.set([0, 1, null, 3, 4]); },
  373.                             () => { p.set([0, "hallo", 2, 3, 4]); },
  374.                         ];
  375.                         tests[Math.floor(tests.length * Math.random())]();
  376.                     }
  377.                     if (p.type == portType.number)
  378.                     {
  379.                         const tests = [
  380.                             () => { p.set(0); },
  381.                             () => { p.set(1); },
  382.                             () => { p.set(1.2); },
  383.                             () => { p.set(100); },
  384.                             () => { p.set(-100); },
  385.                         ];
  386.                         tests[Math.floor(tests.length * Math.random())]();
  387.                     }
  388.                     if (p.type == portType.string)
  389.                     {
  390.                         const tests = [
  391.                             () => { p.set("hello"); },
  392.                             () => { p.set(""); },
  393.                             () => { p.set(null); },
  394.                             () => { p.set(undefined); }
  395.                         ];
  396.                         tests[Math.floor(tests.length * Math.random())]();
  397.                     }
  398.                     if (p.type == portType.object)
  399.                     {
  400.                         const tests = [
  401.                             () => { p.set(null); },
  402.                             () => { p.set(undefined); },
  403.                             () => { p.set({ "a": () => { log.log(1); } }); },
  404.                             () => { p.set({ "a": 1234 }); },
  405.                             () => { p.set({ "b": null }); }
  406.                         ];
  407.                         tests[Math.floor(tests.length * Math.random())]();
  408.                     }
  409.                     if (p.type == portType.trigger)
  410.                     {
  411.                         const tests = [
  412.                             () => { p.trigger(); },
  413.                             () => { },
  414.                         ];
  415.                         tests[Math.floor(tests.length * Math.random())]();
  416.                     }
  417.                 }
  418.             }
  419.         }
  421.         log.log("op test finished!");
  422.     }
  424.     static watchOpSerialized()
  425.     {
  426.         new OpSerialized(gui.mainTabs);
  427.         gui.maintabPanel.show(true);
  428.     }
  430.     static watchOpDocsJson()
  431.     {
  432.         new OpDocsJson(gui.mainTabs);
  433.         gui.maintabPanel.show(true);
  434.     }
  436.     static watchOpUiAttribs()
  437.     {
  438.         new OpWatchUiAttribs(gui.mainTabs);
  439.         gui.maintabPanel.show(true);
  440.     }
  442.     static saveWithOutObjnames()
  443.     {
  444.         gui.corePatch().storeObjNames = false;
  445.         CmdPatch.save();
  446.     }
  448.     static undoHistory()
  449.     {
  450.         new MetaHistory(gui.mainTabs); gui.maintabPanel.show(true);
  451.     }
  452. }