Source: extern/debug.js

  1. import b4w from "../util/b4w.js";
  2. import register from "../util/register.js";
  4. import m_assert_fact from "../util/assert.js";
  5. import m_batch_fact from "../intern/batch.js";
  6. import m_cfg_fact from "../intern/config.js";
  7. import m_context_fact from "../intern/context.js";
  8. import m_compat_fact from "../intern/compat.js";
  9. import m_ctl_fact from "../intern/controls.js";
  10. import m_cont_fact from "../intern/container.js";
  11. import m_data_fact from "../intern/data.js";
  12. import m_debug_fact from "../intern/debug.js";
  13. import m_debug_batch_fact from "../intern/debug/batch.js";
  14. import m_debug_check_fact from "../intern/debug/check.js";
  15. import m_debug_subscene_fact from "../intern/debug/subscene.js";
  16. import m_debug_telemetry_fact from "../intern/debug/telemetry.js";
  18. import m_debug_render_time_fact from "../intern/debug/render_time.js";
  19. import m_ext_fact from "../intern/extensions.js";
  20. import m_geom_fact from "../intern/geometry.js";
  21. import m_load_fact from "../intern/loader.js";
  22. import m_obj_fact from "../intern/objects.js";
  23. import m_obj_util_fact from "../intern/obj_util.js";
  24. import m_phy_fact from "../intern/physics.js";
  25. import m_print_fact from "../intern/print.js";
  26. import m_render_fact from "../intern/renderer.js";
  27. import m_scenes_fact from "../intern/scenes.js";
  28. import m_scgraph_fact from "../intern/scenegraph.js";
  29. import m_sfx_fact from "../intern/sfx.js";
  30. import m_shaders_fact from "../intern/shaders.js";
  31. import m_subs_fact from "../intern/subscene.js";
  32. import m_textures_fact from "../intern/textures.js";
  33. import m_time_fact from "../intern/time.js";
  34. import m_trans_fact from "../intern/transform.js";
  35. import * as m_tsr from "../intern/tsr.js";
  36. import * as m_util from "../intern/util.js";
  37. import * as m_vec3 from "../libs/gl_matrix/vec3.js";
  39. /**
  40.  * Engine debugging API.
  41.  * @module debug
  42.  * @local DebugViewMode
  43.  * @local StageloadCallback
  44.  * @local LoadedCallback
  45.  * @local CodeTestCallback
  46.  * @local EqualsFunction
  47.  * @local OKFunction
  48.  */
  49. function Debug(ns, exports) {
  51. var m_assert   = m_assert_fact(ns);
  52. var m_batch    = m_batch_fact(ns);
  53. var m_cfg      = m_cfg_fact(ns);
  54. var m_compat   = m_compat_fact(ns);
  55. var m_ctl      = m_ctl_fact(ns);
  56. var m_cont     = m_cont_fact(ns);
  57. var m_context  = m_context_fact(ns);
  58. var m_data     = m_data_fact(ns);
  59. var m_debug    = m_debug_fact(ns);
  60. var m_debug_batch = m_debug_batch_fact(ns);
  61. var m_debug_check = m_debug_check_fact(ns);
  62. var m_debug_subscene = m_debug_subscene_fact(ns);
  63. var m_debug_telemetry = m_debug_telemetry_fact(ns);
  64. var m_debug_render_time = m_debug_render_time_fact(ns);
  65. var m_ext      = m_ext_fact(ns);
  66. var m_geom     = m_geom_fact(ns);
  67. var m_load     = m_load_fact(ns);
  68. var m_obj      = m_obj_fact(ns);
  69. var m_obj_util = m_obj_util_fact(ns);
  70. var m_phy      = m_phy_fact(ns);
  71. var m_print    = m_print_fact(ns);
  72. var m_render   = m_render_fact(ns);
  73. var m_scenes   = m_scenes_fact(ns);
  74. var m_scgraph  = m_scgraph_fact(ns);
  75. var m_sfx      = m_sfx_fact(ns);
  76. var m_shaders  = m_shaders_fact(ns);
  77. var m_subs     = m_subs_fact(ns);
  78. var m_time     = m_time_fact(ns);
  79. var m_textures = m_textures_fact(ns);
  80. var m_trans    = m_trans_fact(ns);
  82. var _tsr_tmp = m_tsr.create();
  83. var _vec2_tmp = new Float32Array(2);
  84. var _vec3_tmp = m_vec3.create();
  85. var _vec3_tmp2 = m_vec3.create();
  87. var _normal_line = null;
  89. var cfg_def = m_cfg.defaults;
  91. var FAKE_LOAD_INTERVAL         = 5000;
  92. var FAKE_LOAD_START_PERCENTAGE = 0;
  93. var FAKE_LOAD_END_PERCENTAGE   = 100;
  95. var PERF_NUM_CALLS = 5;
  96. var EPS = 0.000001;
  98. var _called_funcs = [];
  99. var _last_warn_message = "";
  100. var _last_err_message = "";
  101. var _warn_got = false;
  102. var _err_got = false;
  103. var _test_result = true;
  105. var _pixel = new Uint8Array(4);
  107. /**
  108.  * Debug view mode.
  109.  * @typedef {number} DebugViewMode
  110.  */
  112.  /**
  113.  * Data loaded callback.
  114.  * @callback LoadedCallback
  115.  */
  117. /**
  118.  * Loading stage callback.
  119.  * @callback StageloadCallback
  120.  * @param {number} percentage Loading progress (0-100).
  121.  */
  123. /**
  124.  * Code test callback.
  125.  * @callback CodeTestCallback
  126.  * @param {EqualsFunction} equals Comparison function.
  127.  * @param {OKFunction} ok Code test function.
  128.  */
  130. /**
  131.  * Return the comparison result of the given parameters.
  132.  * @callback EqualsFunction
  133.  * @param {*} result Real function result.
  134.  * @param {*} exp_result Expected result.
  135.  */
  137.  /**
  138.  * Check code crash.
  139.  * @callback OKFunction
  140.  * @param {*} result Real function result.
  141.  */
  144. /**
  145.  * Debug view mode: turn off debug view.
  146.  * @const {DebugViewMode} module:debug.DV_NONE
  147.  */
  148. exports.DV_NONE = m_debug_subscene.DV_NONE;
  150. /**
  151.  * Debug view mode: turn on the black-and-white wireframe view.
  152.  * @const {DebugViewMode} module:debug.DV_OPAQUE_WIREFRAME
  153.  */
  154. exports.DV_OPAQUE_WIREFRAME = m_debug_subscene.DV_OPAQUE_WIREFRAME;
  156. /**
  157.  * Debug view mode: turn on the transparent (superimposed on the source color) wireframe view.
  158.  * @const {DebugViewMode} module:debug.DV_TRANSPARENT_WIREFRAME
  159.  */
  160. exports.DV_TRANSPARENT_WIREFRAME = m_debug_subscene.DV_TRANSPARENT_WIREFRAME;
  162. /**
  163.  * Debug view mode: turn on the wireframe view with the front/back faces coloration.
  164.  * @const {DebugViewMode} module:debug.DV_FRONT_BACK_VIEW
  165.  */
  166. exports.DV_FRONT_BACK_VIEW = m_debug_subscene.DV_FRONT_BACK_VIEW;
  168. /**
  169.  * Debug view mode: turn on the debug spheres view.
  170.  * @const {DebugViewMode} module:debug.DV_BOUNDINGS
  171.  */
  172. exports.DV_BOUNDINGS = m_debug_subscene.DV_BOUNDINGS;
  174. /**
  175.  * Debug view mode: turn on the clusters view.
  176.  * @const {DebugViewMode} module:debug.DV_CLUSTERS_VIEW
  177.  */
  178. exports.DV_CLUSTERS_VIEW = m_debug_subscene.DV_CLUSTERS_VIEW;
  180. /**
  181.  * Debug view mode: turn on the batches view.
  182.  * @const {DebugViewMode} module:debug.DV_BATCHES_VIEW
  183.  */
  184. exports.DV_BATCHES_VIEW = m_debug_subscene.DV_BATCHES_VIEW;
  186. /**
  187.  * Debug view mode: turn on the render time view.
  188.  * @const {DebugViewMode} module:debug.DV_RENDER_TIME
  189.  */
  190. exports.DV_RENDER_TIME = m_debug_subscene.DV_RENDER_TIME;
  192. /**
  193.  * Print info about the physics worker.
  194.  * @method module:debug.physics_stats
  195.  */
  196. exports.physics_stats = function() {
  197.     m_phy.debug_workers();
  198. }
  200. /**
  201.  * Print object info by physics ID.
  202.  * @method module:debug.physics_id
  203.  * @param {number} id Physics ID
  204.  */
  205. exports.physics_id = function(id) {
  206.     m_print.log("O", m_phy.find_obj_by_body_id(id))
  208.     var act_phy_scene = m_phy.get_active_scene();
  210.     if (!act_phy_scene) {
  211.         m_print.error("No active physics scene.");
  212.         return;
  213.     }
  215.     var bundles = act_phy_scene._physics.bundles;
  217.     for (var i = 0; i < bundles.length; i++) {
  218.         var bundle = bundles[i];
  219.         var phy = bundle.physics;
  221.         if (phy.body_id == id)
  222.             m_print.log("B", bundle);
  223.     }
  224. }
  226. /**
  227.  * Print names and info for objects inside the view frustum.
  228.  * @method module:debug.visible_objects
  229.  */
  230. exports.visible_objects = function() {
  231.     var scene = m_scenes.get_active();
  233.     var objs = m_obj.get_scene_objs(scene, "MESH", m_obj.DATA_ID_ALL);
  235.     var main_subscenes = m_scenes.subs_array(scene, [m_subs.MAIN_OPAQUE,
  236.                                                      m_subs.MAIN_BLEND,
  237.                                                      m_subs.MAIN_GLOW]);
  239.     for (var i = 0; i < main_subscenes.length; i++) {
  240.         var subs_main = main_subscenes[i];
  241.         var draw_data = subs_main.draw_data;
  243.         if (!draw_data.length)
  244.             continue;
  246.         print_objs(subs_main, draw_data, objs, "DYNAMIC");
  247.         print_objs(subs_main, draw_data, objs, "STATIC");
  248.     }
  249. }
  251. function print_objs(subs, draw_data, objs, type) {
  253.     m_print.group(m_subs.subs_label(subs), type);
  255.     for (var j = 0; j < objs.length; j++) {
  256.         var obj = objs[j];
  257.         var render = obj.render;
  259.         if (render.type != type)
  260.             continue;
  262.         var is_visible = false;
  264.         for (var k = 0; k < draw_data.length; k++) {
  265.             var bundles = draw_data[k].bundles;
  266.             for (var m = 0; m < bundles.length; m++) {
  267.                 var bundle = bundles[m];
  268.                 if (bundle.do_render && bundle.obj_render == render) {
  269.                     if (type == "STATIC")
  270.                         m_print.log_raw(obj.origin_name, obj);
  271.                     else
  272.                         m_print.log_raw(obj.name, obj);
  273.                     is_visible = true;
  274.                     break;
  275.                 }
  276.             }
  277.             if (is_visible)
  278.                 break;
  279.         }
  280.     }
  282.     m_print.groupEnd();
  283. }
  285. /**
  286.  * Print debug info for the object with the given name
  287.  * @method module:debug.object_info
  288.  * @param {string} name Object name
  289.  */
  290. exports.object_info = function(name) {
  291.     var scene = m_scenes.get_active();
  293.     var objs = m_obj.get_scene_objs(scene, "MESH", m_obj.DATA_ID_ALL);
  295.     for (var i = 0; i < objs.length; i++) {
  296.         var obj = objs[i];
  298.         if (obj.name != name)
  299.             continue;
  301.         m_print.log("Object", obj);
  303.         var subscenes = m_scenes.get_all_subscenes(scene);
  305.         for (var j = 0; j < subscenes.length; j++) {
  306.             var subs = subscenes[j];
  307.             var print_bundles = [];
  309.             var draw_data = subs.draw_data;
  311.             for (var k = 0; k < draw_data.length; k++) {
  312.                 var bundles = draw_data[k].bundles;
  313.                 for (var m = 0; m < bundles.length; m++) {
  314.                     if (bundles[m].obj_render == obj.render)
  315.                         print_bundles.push(bundles[m]);
  316.                 }
  317.             }
  319.             m_print.log("Subscene " + subs.type, print_bundles);
  320.         }
  321.     }
  322. }
  324. /**
  325.  * Print debug info for the object with the given name
  326.  * @method module:debug.objects_stat
  327.  */
  328. exports.objects_stat = function() {
  329.     var scene = m_scenes.get_active();
  331.     m_print.log("Armatures: " + m_obj.get_scene_objs(scene, "ARMATURE",
  332.             m_obj.DATA_ID_ALL).length);
  333.     m_print.log("Cameras: " + m_obj.get_scene_objs(scene, "CAMERA",
  334.             m_obj.DATA_ID_ALL).length);
  335.     m_print.log("Curves: " + m_obj.get_scene_objs(scene, "CURVE",
  336.             m_obj.DATA_ID_ALL).length);
  337.     m_print.log("Empties: " + m_obj.get_scene_objs(scene, "EMPTY",
  338.             m_obj.DATA_ID_ALL).length);
  339.     m_print.log("Lamps: " + m_obj.get_scene_objs(scene, "LAMP",
  340.             m_obj.DATA_ID_ALL).length);
  341.     m_print.log("Meshes: " + m_obj.get_scene_objs(scene, "MESH",
  342.             m_obj.DATA_ID_ALL).length);
  343.     m_print.log("Speakers: " + m_obj.get_scene_objs(scene, "SPEAKER",
  344.             m_obj.DATA_ID_ALL).length);
  345. }
  347. /**
  348.  * Return the number of vertices in the active scene.
  349.  * @method module:debug.num_vertices
  350.  * @returns {number} The number of vertices.
  351.  */
  352. exports.num_vertices = function() {
  354.     var num = 0;
  356.     var scene = m_scenes.get_active();
  358.     var main_subscenes = m_scenes.subs_array(scene, [m_subs.MAIN_OPAQUE,
  359.                                                      m_subs.MAIN_BLEND,
  360.                                                      m_subs.MAIN_GLOW]);
  362.     for (var i = 0; i < main_subscenes.length; i++) {
  364.         var subs = main_subscenes[i];
  366.         var draw_data = subs.draw_data;
  368.         for (var j = 0; j < draw_data.length; j++) {
  369.             var bundles = draw_data[j].bundles;
  370.             for (var k = 0; k < bundles.length; k++) {
  372.                 var batch = bundles[k].batch;
  373.                 // NOTE: some objects (particles) do not have any submesh
  374.                 if (batch)
  375.                     num += batch.num_vertices;
  376.             }
  377.         }
  378.     }
  380.     return num;
  381. }
  383. /**
  384.  * Return the number of all triangles in the active scene.
  385.  * @method module:debug.num_triangles
  386.  * @returns {number} The number of all triangles.
  387.  */
  388. exports.num_triangles = function() {
  390.     var num = 0;
  392.     var scene = m_scenes.get_active();
  394.     var main_subscenes = m_scenes.subs_array(scene, [m_subs.MAIN_OPAQUE,
  395.                                                      m_subs.MAIN_BLEND,
  396.                                                      m_subs.MAIN_GLOW]);
  398.     for (var i = 0; i < main_subscenes.length; i++) {
  400.         var subs = main_subscenes[i];
  402.         var draw_data = subs.draw_data;
  404.         for (var j = 0; j < draw_data.length; j++) {
  405.             var bundles = draw_data[j].bundles;
  406.             for (var k = 0; k < bundles.length; k++) {
  408.                 var batch = bundles[k].batch;
  409.                 // NOTE: some objects (particles) do not have any submesh
  410.                 if (batch)
  411.                     num += batch.num_triangles;
  412.             }
  413.         }
  414.     }
  416.     return num;
  417. }
  419. /**
  420.  * Return the number of batches in the main scenes.
  421.  * @method module:debug.num_draw_calls
  422.  * @returns {number} The number of batches.
  423.  */
  424. exports.num_draw_calls = function() {
  426.     var scene = m_scenes.get_active();
  428.     var main_subscenes = m_scenes.subs_array(scene, [m_subs.MAIN_OPAQUE,
  429.                                                      m_subs.MAIN_BLEND,
  430.                                                      m_subs.MAIN_GLOW,
  431.                                                      m_subs.MAIN_PLANE_REFLECT,
  432.                                                      m_subs.MAIN_PLANE_REFLECT_BLEND]);
  434.     var number = 0;
  435.     for (var i = 0; i < main_subscenes.length; i++) {
  436.         var subs = main_subscenes[i];
  437.         var draw_data = subs.draw_data;
  438.         for (var j = 0; j < draw_data.length; j++)
  439.             number += draw_data[j].bundles.length;
  440.     }
  442.     var cube_reflect_subs = m_scenes.subs_array(scene,
  443.                             [m_subs.MAIN_CUBE_REFLECT, m_subs.MAIN_CUBE_REFLECT_BLEND]);
  444.     for (var i = 0; i < cube_reflect_subs.length; i++) {
  445.         var subs = cube_reflect_subs[i];
  446.         var draw_data = subs.draw_data;
  447.         for (var j = 0; j < draw_data.length; j++)
  448.             number += 6 * draw_data[j].bundles.length;
  449.     }
  451.     return number;
  452. }
  454. /**
  455.  * Return the number of compiled shaders.
  456.  * @method module:debug.num_shaders
  457.  * @returns {number} The number of compiled shaders.
  458.  */
  459. exports.num_shaders = function() {
  460.     var compiled_shaders = m_shaders.get_compiled_shaders();
  461.     return m_util.get_dict_length(compiled_shaders);
  462. }
  464. /**
  465.  * Return geometry info in the main scenes.
  466.  * @method module:debug.geometry_stats
  467.  * @returns {Object} Geometry info.
  468.  */
  469. exports.geometry_stats = function() {
  471.     var scene = m_scenes.get_active();
  472.     var subscenes = m_scenes.get_all_subscenes(scene);
  473.     var unique_batches = {};
  475.     for (var i = 0; i < subscenes.length; i++) {
  477.         var subs = subscenes[i];
  479.         if (subs.type == m_subs.SINK || subs.type == m_subs.DEBUG_VIEW)
  480.             continue;
  482.         var draw_data = subs.draw_data;
  483.         for (var j = 0; j < draw_data.length; j++) {
  484.             var bundles = draw_data[j].bundles;
  485.             for (var k = 0; k < bundles.length; k++) {
  486.                 var batch = bundles[k].batch;
  487.                 var render = bundles[k].obj_render;
  488.                 // NOTE: some objects (particles) do not have any submesh
  489.                 if (batch)
  490.                     if (subs.type != m_subs.COLOR_PICKING && subs.type != m_subs.OUTLINE_MASK
  491.                             || render.origin_selectable || render.origin_outlining)
  492.                         unique_batches[batch.id] = batch;
  493.             }
  494.         }
  495.     }
  497.     var vbo_memory = 0;
  498.     var ibo_memory = 0;
  500.     for (var id in unique_batches) {
  501.         var bufs_data = unique_batches[id].bufs_data;
  503.         if (bufs_data.debug_ibo_bytes)
  504.             ibo_memory += bufs_data.debug_ibo_bytes / (1024 * 1024);
  506.         vbo_memory += bufs_data.debug_vbo_bytes / (1024 * 1024);
  507.     }
  509.     return {"vbo_memory": vbo_memory, "ibo_memory": ibo_memory};
  510. }
  512. /**
  513.  * Return the number of unique textures in the main scenes.
  514.  * @method module:debug.num_textures
  515.  * @returns {Object} Textures info.
  516.  */
  517. exports.num_textures = function() {
  519.     var tex_list = [];
  521.     var memory = 0;
  523.     var scene = m_scenes.get_active();
  525.     var main_subscenes = m_scenes.subs_array(scene, [m_subs.MAIN_OPAQUE,
  526.                                                      m_subs.MAIN_BLEND,
  527.                                                      m_subs.MAIN_GLOW]);
  529.     for (var i = 0; i < main_subscenes.length; i++) {
  531.         var subs = main_subscenes[i];
  533.         var draw_data = subs.draw_data;
  534.         for (var j = 0; j < draw_data.length; j++) {
  535.             var bundles = draw_data[j].bundles;
  536.             for (var k = 0; k < bundles.length; k++) {
  538.                 var batch = bundles[k].batch;
  539.                 // NOTE: some objects (particles) do not have any submesh
  540.                 if (batch) {
  541.                     var batch_texs = batch.textures;
  543.                     for (var m = 0; m < batch_texs.length; m++) {
  545.                         var batch_tex = batch_texs[m];
  547.                         if (batch_tex.source === "IMAGE" ||
  548.                                 batch_tex.source === "ENVIRONMENT_MAP") {
  550.                             var tex = batch_tex.w_texture;
  552.                             if (tex_list.indexOf(tex) === -1) {
  553.                                 tex_list.push(tex);
  554.                                 var mem = batch_tex.width * batch_tex.height *
  555.                                     4 / (1024 * 1024) / batch_tex.compress_ratio;
  557.                                 // mipmaps
  558.                                 mem *=  1.3333;
  560.                                 memory += mem;
  561.                             }
  562.                         }
  563.                     }
  564.                 }
  565.             }
  566.         }
  567.     }
  569.     return {"number": tex_list.length, "memory": memory};
  570. }
  572. /**
  573.  * Return the number and the total size of unique output framebuffers.
  574.  * @method module:debug.num_render_targets
  575.  * @returns {Object} Render targets info.
  576.  */
  577. exports.num_render_targets = function() {
  579.     var list = [];
  581.     var memory = 0;
  583.     var scene = m_scenes.get_active();
  585.     var subscenes = m_scenes.get_all_subscenes(scene);
  587.     for (var i = 0; i < subscenes.length; i++) {
  589.         var subs = subscenes[i];
  591.         if (subs.type == m_subs.SINK)
  592.             continue;
  594.         var cam = subs.camera;
  595.         var subs_textures = [cam.color_attachment, cam.depth_attachment];
  596.         subs_textures.push.apply(subs_textures, subs.textures_internal);
  598.         for (var j = 0; j < subs_textures.length; j++) {
  599.             var tex = subs_textures[j];
  600.             if (m_textures.is_texture(tex) && list.indexOf(tex) == -1) {
  601.                 list.push(tex);
  602.                 memory += cam.width * cam.height * m_textures.get_texture_texel_size(tex);
  603.             }
  604.         }
  605.     }
  607.     return {"number": list.length, "memory": (memory / 1024 / 1024)};
  608. }
  610. /**
  611.  * Draw a frustum for the active camera.
  612.  * @method module:debug.make_camera_frustum_shot
  613.  */
  614. exports.make_camera_frustum_shot = function() {
  616.     var active_scene = m_scenes.get_active();
  617.     var subs_main = m_scenes.get_subs(active_scene, m_subs.MAIN_OPAQUE);
  618.     if (!subs_main)
  619.         return;
  621.     m_scenes.make_frustum_shot(subs_main.camera, subs_main, [1,1,0]);
  622. }
  624. /**
  625.  * Draw a light frustum, used for rendering the shadow maps.
  626.  * @method module:debug.make_light_frustum_shot
  627.  */
  628. exports.make_light_frustum_shot = function() {
  630.     var active_scene = m_scenes.get_active();
  631.     var subs_main = m_scenes.get_subs(active_scene, m_subs.MAIN_OPAQUE);
  632.     var subscenes_shadow = m_scenes.subs_array(active_scene, [m_subs.SHADOW_CAST]);
  633.     if (!subs_main)
  634.         return;
  636.     for (var i = 0; i < subscenes_shadow.length; i++) {
  637.         var subs_shadow = subscenes_shadow[i];
  639.         var color;
  640.         switch (i) {
  641.         case 0:
  642.             color = [1, 0, 0];
  643.             break;
  644.         case 1:
  645.             color = [0, 1, 0];
  646.             break;
  647.         case 2:
  648.             color = [0, 0, 1];
  649.             break;
  650.         default:
  651.             color = [1, 0, 1];
  652.         }
  654.         m_scenes.make_frustum_shot(subs_shadow.camera, subs_main, color);
  655.     }
  656. }
  659. /**
  660.  * Print info about the active scene graph in DOT format.
  661.  * @method module:debug.scenegraph_to_dot
  662.  */
  663. exports.scenegraph_to_dot = function() {
  664.     var scenes = m_scenes.get_all_scenes();
  666.     for (var i = 0; i < scenes.length; i++) {
  667.         var scene = scenes[i];
  668.         var graph = m_scenes.get_graph(scene);
  669.         m_print.log("\n" + m_scgraph.debug_convert_to_dot(graph));
  670.     }
  671. }
  673. exports.loading_graph_to_dot = function(data_id) {
  674.     data_id = data_id | 0;
  675.     m_print.log("\n" + m_load.graph_to_dot(data_id));
  676. }
  678. /**
  679.  * Print info about the controls module.
  680.  * @method module:debug.controls_info
  681.  */
  682. exports.controls_info = m_ctl.debug;
  684. /**
  685.  * Get the distance between two objects.
  686.  * @method module:debug.object_distance
  687.  * @param {Object3D} obj The first object.
  688.  * @param {Object3D} obj2 The second object.
  689.  * @returns {number} Distance.
  690.  * @deprecated use {@link module:transform.distance|transform.distance} instead.
  691.  */
  692. exports.object_distance = function(obj, obj2) {
  693.     var trans = m_tsr.get_trans_view(obj.render.world_tsr);
  694.     var trans2 = m_tsr.get_trans_view(obj2.render.world_tsr);
  695.     var dist = m_vec3.dist(trans, trans2);
  696.     return dist;
  697. }
  699. /**
  700.  * Store a simple telemetry message.
  701.  * @method module:debug.msg
  702.  */
  703. exports.msg = function() {
  704.     m_debug_telemetry.msg.apply(m_debug_telemetry, arguments);
  705. }
  707. /**
  708.  * Store a flashback telemetry message.
  709.  * @method module:debug.fbmsg
  710.  */
  711. exports.fbmsg = function() {
  712.     m_debug_telemetry.fbmsg.apply(m_debug_telemetry, arguments);
  713. }
  715. /**
  716.  * Print the list of flashback messages.
  717.  * @method module:debug.print_telemetry
  718.  */
  719. exports.print_telemetry = function() {
  720.     m_debug_telemetry.print_telemetry.apply(m_debug_telemetry, arguments);
  721. }
  723. /**
  724.  * Plot the list of flashback messages as a gnuplot datafile.
  725.  * @method module:debug.plot_telemetry
  726.  */
  727. exports.plot_telemetry = function() {
  728.     m_debug_telemetry.plot_telemetry.apply(m_debug_telemetry, arguments);
  729. }
  731. /**
  732.  * Store the callback function result as a flashback message.
  733.  * @method module:debug.fbres
  734.  * @param {Function} fun fun
  735.  * @param {number} timeout timeout
  736.  */
  737. exports.fbres = function(fun, timeout) {
  738.     if (!timeout)
  739.         timeout = 16;
  741.     var cb = function() {
  742.         m_debug_telemetry.fbmsg("FBRES", fun());
  743.         setTimeout(cb, timeout);
  744.     }
  746.     cb();
  747. }
  749. /**
  750.  * Check the engine constants, abort if not constant.
  751.  * @method module:debug.assert_constants
  752.  */
  753. exports.assert_constants = function() {
  754.     var VEC3_IDENT = new Float32Array(3);
  755.     var QUAT4_IDENT = new Float32Array([0,0,0,1]);
  757.     var AXIS_X = new Float32Array([1, 0, 0]);
  758.     var AXIS_Y = new Float32Array([0, 1, 0]);
  759.     var AXIS_Z = new Float32Array([0, 0, 1]);
  760.     var AXIS_MX = new Float32Array([-1, 0, 0]);
  761.     var AXIS_MY = new Float32Array([ 0,-1, 0]);
  762.     var AXIS_MZ = new Float32Array([ 0, 0,-1]);
  764.     if (!m_util.cmp_arr(VEC3_IDENT, m_util.VEC3_IDENT))
  765.         throw "Wrong VEC3_IDENT";
  766.     if (!m_util.cmp_arr(QUAT4_IDENT, m_util.QUAT4_IDENT))
  767.         throw "Wrong QUAT4_IDENT";
  769.     if (!m_util.cmp_arr(AXIS_X, m_util.AXIS_X))
  770.         throw "Wrong AXIS_X";
  771.     if (!m_util.cmp_arr(AXIS_Y, m_util.AXIS_Y))
  772.         throw "Wrong AXIS_Y";
  773.     if (!m_util.cmp_arr(AXIS_Z, m_util.AXIS_Z))
  774.         throw "Wrong AXIS_Z";
  775.     if (!m_util.cmp_arr(AXIS_MX, m_util.AXIS_MX))
  776.         throw "Wrong AXIS_MX";
  777.     if (!m_util.cmp_arr(AXIS_MY, m_util.AXIS_MY))
  778.         throw "Wrong AXIS_MY";
  779.     if (!m_util.cmp_arr(AXIS_MZ, m_util.AXIS_MZ))
  780.         throw "Wrong AXIS_MZ";
  781. }
  783. /**
  784.  * Mute the BACKGROUND_MUSIC speakers.
  785.  * @method module:debug.mute_music
  786.  */
  787. exports.mute_music = function() {
  788.     var spks = m_sfx.get_speaker_objects();
  790.     for (var i = 0; i < spks.length; i++) {
  791.         var spk = spks[i];
  793.         if (m_sfx.get_spk_behavior(spk) == "BACKGROUND_MUSIC")
  794.             m_sfx.mute(spk, true);
  795.     }
  796. }
  798. /**
  799.  * Check the object for a finite value.
  800.  * @method module:debug.check_finite
  801.  * @param {*} o Value
  802.  */
  803. exports.check_finite = function(o) {
  804.     return m_debug_check.finite(o);
  805. }
  807. /**
  808.  * Set debugging parameters.
  809.  * @method module:debug.set_debug_params
  810.  * @param {DebugParams} params Debug parameters
  811.  * @cc_externs debug_view_mode wireframe_edge_color debug_colors_seed
  812.  */
  813. exports.set_debug_params = function(params) {
  814.     var active_scene = m_scenes.get_active();
  815.     var subs_debug_views = m_scenes.subs_array(active_scene, [m_subs.DEBUG_VIEW]);
  817.     if (!subs_debug_views.length) {
  818.         m_print.error("Debugging is not available on the scene.");
  819.         return;
  820.     }
  822.     for (var i = 0; i < subs_debug_views.length; i++) {
  823.         var subs_debug_view = subs_debug_views[i];
  824.         if (typeof params.debug_view_mode == "number") {
  825.             switch (params.debug_view_mode) {
  826.             case m_debug_subscene.DV_NONE:
  827.             case m_debug_subscene.DV_OPAQUE_WIREFRAME:
  828.             case m_debug_subscene.DV_TRANSPARENT_WIREFRAME:
  829.             case m_debug_subscene.DV_FRONT_BACK_VIEW:
  830.             case m_debug_subscene.DV_BOUNDINGS:
  831.             case m_debug_subscene.DV_CLUSTERS_VIEW:
  832.             case m_debug_subscene.DV_BATCHES_VIEW:
  833.             case m_debug_subscene.DV_RENDER_TIME:
  834.                 m_scenes.set_debug_view_mode(subs_debug_view, params.debug_view_mode);
  835.                 break;
  836.             default:
  837.                 m_print.error("set_debug_params(): Wrong debug view mode");
  838.                 break;
  839.             }
  840.         }
  841.         if (typeof params.debug_colors_seed == "number")
  842.             m_scenes.set_debug_colors_seed(subs_debug_view, params.debug_colors_seed);
  843.         if (typeof params.render_time_threshold == "number")
  844.             m_scenes.set_render_time_threshold(subs_debug_view, params.render_time_threshold);
  845.         if (typeof params.wireframe_edge_color == "object")
  846.             m_scenes.set_wireframe_edge_color(subs_debug_view,
  847.                     m_util.f32(params.wireframe_edge_color));
  848.     }
  849. }
  851. exports.get_error_quantity = function() {
  852.     return m_print.get_error_count();
  853. }
  855. exports.get_warning_quantity = function() {
  856.     return m_print.get_warning_count();
  857. }
  859. exports.clear_errors_warnings = function() {
  860.     return m_print.clear_errors_warnings();
  861. }
  863. /**
  864.  * Print shaders' statistics.
  865.  * @method module:debug.analyze_shaders
  866.  * @param {string} [opt_shader_id_part=""] Shader ID (filename) part.
  867.  */
  868. exports.analyze_shaders = function(opt_shader_id_part) {
  870.     var compiled_shaders = m_shaders.get_compiled_shaders();
  872.     var count = 0;
  873.     for (var shader_id in compiled_shaders) {
  874.         if (opt_shader_id_part && shader_id.indexOf(opt_shader_id_part) === -1)
  875.             continue;
  876.         count++;
  877.     }
  878.     var msg = "of " + count + " analyzing...";
  880.     var rslts = {};
  882.     for (var shader_id in compiled_shaders) {
  884.         if (opt_shader_id_part && shader_id.indexOf(opt_shader_id_part) === -1)
  885.             continue;
  887.         var cshader = compiled_shaders[shader_id];
  888.         var stat = get_shaders_stat(cshader.vshader, cshader.fshader);
  889.         if (!stat)
  890.             continue;
  892.         var shaders_info = cshader.shaders_info;
  893.         var title = shaders_info.vert + " + " + shaders_info.frag;
  895.         // NOTE: cshader.shaders_info
  896.         stat.cshader = cshader;
  897.         stat.shaders_info = shaders_info;
  899.         var stats = rslts[title] = rslts[title] || [];
  901.         stats.push(stat);
  902.         m_print.log_raw(msg);
  903.     }
  905.     for (var title in rslts) {
  907.         m_print.group("%c" + title, "color: #800");
  908.         var stats = rslts[title];
  909.         print_shader_stats(stats);
  910.         m_print.groupEnd();
  911.     }
  912. }
  914. /**
  915.  * Return stage callback without loading data.
  916.  * @method module:debug.fake_load
  917.  * @param {StageloadCallback} stageload_cb Callback to report about the loading progress
  918.  * @param {number} [interval=5000] Loading interval
  919.  * @param {number} [start=0] Start percentage
  920.  * @param {number} [end=5000] End percentage
  921.  * @param {LoadedCallback} [loaded_cb=null] Callback to be executed right after load
  922.  */
  923. exports.fake_load = function(stageload_cb, interval, start, end, loaded_cb) {
  924.     stageload_cb = stageload_cb || null;
  926.     if (!stageload_cb)
  927.         m_assert.panic("Stage load callback is undefined");
  929.     interval = interval || FAKE_LOAD_INTERVAL;
  930.     start    = start || FAKE_LOAD_START_PERCENTAGE;
  931.     end      = end || FAKE_LOAD_END_PERCENTAGE;
  933.     if (end > 100)
  934.         m_assert.panic("Max percentage must be less than 100");
  936.     if (start < 0)
  937.         m_assert.panic("Min percentage must be greater than 0");
  939.     if (start > end)
  940.         m_assert.panic("Max percentage must be greater than min percentage");
  942.     var animator = m_time.animate(start, end, interval, function(e) {
  943.         var rounded_percentage = e.toFixed();
  945.         stageload_cb(rounded_percentage);
  947.         if (rounded_percentage == 100) {
  948.             m_time.clear_animation(animator);
  950.             if (loaded_cb)
  951.                 loaded_cb();
  953.             return;
  954.         }
  955.     })
  956. }
  958. function get_shaders_stat(vshader, fshader) {
  960.     var ext_ds = m_ext.get_debug_shaders();
  961.     if (!ext_ds) {
  962.         m_print.warn("WEBGL_debug_shaders extension not found");
  963.         return;
  964.     }
  966.     var vsrc_trans = ext_ds.getTranslatedShaderSource(vshader);
  967.     var fsrc_trans = ext_ds.getTranslatedShaderSource(fshader);
  969.     if (m_compat.detect_mobile()) {
  970.         vsrc_trans = vsrc_trans.replace("#version", "#version 300 //")
  971.         fsrc_trans = fsrc_trans.replace("#version", "#version 300 //")
  972.         var vout = post_sync("/analyze_shader/vert_gles", vsrc_trans);
  973.         var fout = post_sync("/analyze_shader/frag_gles", fsrc_trans);
  974.     } else {
  975.         // HACK: lower GLSL version for cgc tool
  976.         vsrc_trans = vsrc_trans.replace("#version", "#version 400 //")
  977.         fsrc_trans = fsrc_trans.replace("#version", "#version 400 //")
  978.         var vout = post_sync("/analyze_shader/vert", vsrc_trans);
  979.         var fout = post_sync("/analyze_shader/frag", fsrc_trans);
  980.     }
  982.     var vstats = parse_shader_assembly(vout);
  983.     var fstats = parse_shader_assembly(fout);
  985.     return {
  986.         vsrc: m_context.get_gl().getShaderSource(vshader),
  987.         vsrc_trans: vsrc_trans,
  988.         vout: vout,
  989.         vstats: vstats,
  990.         fsrc: m_context.get_gl().getShaderSource(fshader),
  991.         fsrc_trans: fsrc_trans,
  992.         fout: fout,
  993.         fstats: fstats
  994.     };
  995. }
  997. function parse_shader_assembly(data) {
  998.     var stats = {};
  1000.     if (!data)
  1001.         return stats;
  1003.     var lines = data.split("\n");
  1005.     for (var i = 0; i < lines.length; i++) {
  1006.         var line = lines[i];
  1008.         if (line.search(new RegExp(/^[A-Z.]+ ?/)) == -1) {
  1009.             continue;
  1010.         }
  1012.         var op = line.split(" ")[0];
  1014.         if (!(op in stats))
  1015.             stats[op] = 0;
  1017.         stats[op]++;
  1018.     }
  1020.     var all_ops = 0;
  1021.     var tex_ops = 0;
  1022.     var attribs = 0;
  1024.     for (var op in stats) {
  1025.         switch (op) {
  1026.         case "KIL":
  1027.         case "TEX":
  1028.         case "TXB":
  1029.         case "TXP":
  1030.         case "KIL.F":
  1031.         case "TEX.F":
  1032.         case "TXB.F":
  1033.         case "TXD.F":
  1034.         case "TXL.F":
  1035.         case "TXQ.F":
  1036.         case "TXP.F":
  1037.             tex_ops += stats[op];
  1038.             all_ops += stats[op];
  1039.             break;
  1040.         // data type qualifiers
  1041.         case "ATTRIB":
  1042.             attribs += stats[op];
  1043.             break;
  1044.         case "ADDRESS":
  1045.         case "PARAM":
  1046.         case "TEMP":
  1047.         case "ALIAS":
  1048.         case "OUTPUT":
  1049.             break;
  1050.         // end program line
  1051.         case "END":
  1052.             break;
  1053.         default:
  1054.             all_ops += stats[op];
  1055.             break;
  1056.         }
  1057.     }
  1059.     stats["ALL_OPS"] = all_ops;
  1060.     stats["TEX_OPS"] = tex_ops;
  1061.     stats["ATTRIBS"] = attribs;
  1063.     return stats;
  1064. }
  1066. function post_sync(path, data) {
  1067.     var req = new XMLHttpRequest();
  1068.     req.open("POST", path, false);
  1069.     req.send(data);
  1071.     if (req.status == 200)
  1072.         return req.responseText;
  1073.     else {
  1074.         m_print.error(req.responseText);
  1075.         throw("Error POST XHR: " + req.status);
  1076.     }
  1077. }
  1079. function print_shader_stats(stats) {
  1080.     // sort in descending order by fragment shader operations
  1081.     stats.sort(function(a, b) {
  1082.         return b.fstats["ALL_OPS"] - a.fstats["ALL_OPS"];
  1083.     })
  1085.     for (var j = 0; j < stats.length; j++) {
  1086.         var stat = stats[j];
  1088.         var fstats = stat.fstats;
  1089.         var vstats = stat.vstats;
  1091.         var mat_names = find_material_names_by_comp_shader(stat.cshader);
  1092.         mat_names = mat_names.length ? "\t\t(" + mat_names.join(", ") + ")" : "\t\t(NA)";
  1094.         // NOTE some not changing params are commented out
  1095.         m_print.groupCollapsed(
  1096.             "VERT ->",
  1097.             "OPS", vstats["ALL_OPS"],
  1098.             "ATT", vstats["ATTRIBS"],
  1099.             "TEX", vstats["TEX_OPS"],
  1101.             "\t\tFRAG ->",
  1102.             "OPS", fstats["ALL_OPS"],
  1103.             "TEX", fstats["TEX_OPS"],
  1104.             mat_names
  1105.         );
  1107.         m_print.groupCollapsed("directives");
  1108.         // NOTE: perhaps they should be stored in sorted order
  1109.         var dirs = stat.shaders_info.directives.slice().sort();
  1110.         for (var i = 0; i < dirs.length; i++) {
  1111.             var dir = dirs[i];
  1112.             m_print.log_raw(dir[0], dir[1]);
  1113.         }
  1114.         m_print.groupEnd();
  1116.         m_print.groupCollapsed("node elements");
  1117.         var nelem = stat.shaders_info.node_elements;
  1118.         for (var i = 0; i < nelem.length; i++)
  1119.             m_print.log_raw(nelem[i]);
  1120.         m_print.groupEnd();
  1122.         m_print.groupCollapsed("vert source");
  1123.         m_print.log_raw(stat.vsrc);
  1124.         m_print.groupEnd();
  1126.         m_print.groupCollapsed("vert translated source");
  1127.         m_print.log_raw(stat.vsrc_trans);
  1128.         m_print.groupEnd();
  1130.         // ignore them as they used for collective stats
  1131.         var ignored_stats = ["ALL_OPS", "TEX_OPS", "ATTRIBS"];
  1133.         m_print.groupCollapsed("vert ops stats");
  1134.         for (var op in vstats)
  1135.             if (ignored_stats.indexOf(op) == -1)
  1136.                 m_print.log_raw(op, vstats[op]);
  1137.         m_print.groupEnd();
  1139.         m_print.groupCollapsed("vert assembly");
  1140.         m_print.log_raw(stat.vout);
  1141.         m_print.groupEnd();
  1143.         m_print.groupCollapsed("frag source");
  1144.         m_print.log_raw(stat.fsrc);
  1145.         m_print.groupEnd();
  1147.         m_print.groupCollapsed("frag translated source");
  1148.         m_print.log_raw(stat.fsrc_trans);
  1149.         m_print.groupEnd();
  1151.         m_print.groupCollapsed("frag ops stats");
  1152.         for (var op in fstats)
  1153.             if (ignored_stats.indexOf(op) == -1)
  1154.                 m_print.log_raw(op, fstats[op]);
  1155.         m_print.groupEnd();
  1157.         m_print.groupCollapsed("frag assembly");
  1158.         m_print.log_raw(stat.fout);
  1159.         m_print.groupEnd();
  1161.         m_print.groupEnd();
  1162.     }
  1163. }
  1165. function find_material_names_by_comp_shader(cshader) {
  1167.     var names = [];
  1169.     var scenes = m_scenes.get_all_scenes();
  1171.     for (var i = 0; i < scenes.length; i++) {
  1172.         var scene = scenes[i];
  1173.         var objects = m_obj.get_scene_objs(scene, "MESH", m_obj.DATA_ID_ALL);
  1175.         for (var j = 0; j < objects.length; j++) {
  1176.             var obj = objects[j];
  1177.             var scene_data = m_obj_util.get_scene_data(obj, scene);
  1179.             if (!scene_data || !scene_data.batches.length)
  1180.                 continue;
  1182.             var batches = scene_data.batches;
  1184.             for (var k = 0; k < batches.length; k++) {
  1185.                 var batch = batches[k];
  1187.                 if (batch.shader == cshader)
  1188.                     for (var l = 0; l < batch.material_names.length; l++) {
  1189.                         var name = batch.material_names[l];
  1190.                         if (names.indexOf(name) == -1)
  1191.                             names.push(name);
  1192.                     }
  1193.             }
  1194.         }
  1195.     }
  1197.     return names;
  1198. }
  1200. /**
  1201.  * Perform simple performance test.
  1202.  * @method module:debug.test_performance
  1203.  * @param {TestPerformanceCallback} callback Callback
  1204.  */
  1205. exports.test_performance = function(callback) {
  1206.     // waiting for shaders
  1207.     if (!m_shaders.check_shaders_loaded()) {
  1208.         window.setTimeout(function() {
  1209.             exports.test_performance(callback);
  1210.         }, 100);
  1211.         return;
  1212.     }
  1214.     var ext = m_ext.get_disjoint_timer_query();
  1215.     if (!ext) {
  1216.         callback(0, 0);
  1217.         return;
  1218.     }
  1220.     var gl_debug_save = cfg_def.gl_debug;
  1221.     // enable it to force timer queries update for
  1222.     // paused engine / unloaded scenes
  1223.     cfg_def.gl_debug = true;
  1225.     var graph = m_scgraph.create_performance_graph();
  1226.     m_scenes.generate_auxiliary_batches(null, graph);
  1228.     var subs = m_scgraph.find_subs(graph, m_subs.PERFORMANCE);
  1229.     var cam = subs.camera;
  1231.     for (var i = 0; i < PERF_NUM_CALLS; i++)
  1232.         m_render.draw(subs);
  1234.     cfg_def.gl_debug = gl_debug_save;
  1236.     window.setTimeout(function() {
  1237.         m_debug_render_time.process_timer_queries(subs);
  1238.         // in ms
  1239.         var time = subs.debug_render_time;
  1240.         // in GB/s (100 texture lookups)
  1241.         var bandwidth = (cam.width * cam.height * 4 * 10) /
  1242.                 (time / 1000) / Math.pow(10, 9);
  1243.         callback(time, bandwidth);
  1244.     }, 100);
  1245. }
  1247. exports.calc_vbo_garbage_byte_size = m_debug.calc_vbo_garbage_byte_size;
  1249. exports.show_vbo_garbage_info = m_debug.show_vbo_garbage_info;
  1251. exports.print_batches_stat = function() {
  1252.     m_debug_batch.print_batches_stat();
  1253. }
  1255. function call(func, name) {
  1256.     var decor_func = function() {
  1257.         _called_funcs.push(decor_func);
  1258.         return func.apply(func, arguments);
  1260.     }
  1261.     return decor_func;
  1262. }
  1264. exports.start_debug = function(module) {
  1265.     _called_funcs = [];
  1266.     _test_result = true;
  1268.     if (typeof module === "string")
  1269.         module = b4w.require(module);
  1271.     for (var name in module)
  1272.         if (typeof module[name] === "function")
  1273.             module[name] = call(module[name], name);
  1274. }
  1276. exports.check_debug_result = function() {
  1277.     return _test_result;
  1278. }
  1280. /**
  1281.  * Test code.
  1282.  * @method module:debug.test
  1283.  * @param {string} test_name Test name
  1284.  * @param {CodeTestCallback} callback Callback
  1285.  */
  1286. exports.test = function(test_name, callback) {
  1288.     var print_err_func = m_print.error;
  1289.     var print_err_once_func = m_print.error_once;
  1290.     var print_warn_func = m_print.warn;
  1292.     m_print.error = m_print.error_once = function error() {
  1293.         var args = m_print.compose_args_prefix(arguments, "B4W ERROR");
  1294.         _last_err_message = args.join(" ");
  1295.         _err_got = true;
  1296.     }
  1298.     m_print.warn = function warn() {
  1299.         var args = m_print.compose_args_prefix(arguments, "B4W WARN");
  1300.         _last_warn_message = args.join(" ");
  1301.         _warn_got = true;
  1302.     }
  1304.     _warn_got = false;
  1305.     _err_got = false;
  1307.     try {
  1308.         callback();
  1309.         var success = true;
  1310.     } catch(e) {
  1311.         _test_result = false;
  1312.         console.error("Test \"" + test_name + "\" failed with exception: \"" + e + "\"");
  1313.         var success = false;
  1314.         _warn_got = false;
  1315.         _err_got = false;
  1316.     }
  1318.     m_print.error = print_err_func;
  1319.     m_print.error_once = print_err_once_func;
  1320.     m_print.warn = print_warn_func;
  1322.     return success;
  1323. }
  1325. /**
  1326.  * Compare color picked at the center of the screen with reference RGBA vector.
  1327.  * @param {RGBA} ref_color Reference RGBA vector to compare with.
  1328.  */
  1329. exports.pix = function(ref_color) {
  1330.     var canvas_w = m_cont.get_viewport_width();
  1331.     var canvas_h = m_cont.get_viewport_height();
  1333.     var canvas_x = canvas_w / 2;
  1334.     var canvas_y = canvas_h / 2;
  1336.     m_cont.resize(canvas_w, canvas_h, false);
  1338.     var scene = m_scenes.get_active();
  1339.     var graph = scene._render.graph;
  1340.     var subs = m_scgraph.find_on_screen(graph);
  1341.     if (!subs)
  1342.         m_assert.panic("Couldn't find onscreen subscene");
  1344.     var cam = subs.camera;
  1345.     var viewport_xy = m_cont.canvas_to_viewport_coords(canvas_x, canvas_y,
  1346.             _vec2_tmp, subs.camera);
  1348.     viewport_xy[1] = cam.height - viewport_xy[1];
  1349.     var color = m_render.read_pixels(cam.framebuffer, viewport_xy[0],
  1350.             viewport_xy[1], 1, 1, _pixel);
  1352.     eqv(ref_color, color, 1);
  1353. }
  1355. exports.eqs = function(result, exp_result, expected_err, expected_warn) {
  1356.     if (JSON.stringify(result) != JSON.stringify(exp_result))
  1357.         throw "debug.eqs: wrong result";
  1359.     check_err_warn_messages(expected_err, expected_warn, "eqs");
  1360. }
  1362. exports.eqv = eqv;
  1363. function eqv(result, exp_result, eps, expected_err, expected_warn) {
  1364.     if (typeof exp_result != typeof result)
  1365.         throw "debug.eqv: wrong expected data type";
  1366.     if (result.length != exp_result.length)
  1367.         throw "debug.eqv: wrong expected vector length";
  1368.     eps = eps ? eps : EPS;
  1369.     for (var i = 0; i < result.length; i++) {
  1370.         // NaN values are not allowed
  1371.         if (typeof exp_result[i] != "number" || isNaN(exp_result[i]))
  1372.             throw "debug.eqv: wrong expected data type";
  1373.         if (typeof result[i] != "number" || isNaN(result[i]))
  1374.             throw "debug.eqv: wrong result data type";
  1375.         if (exp_result[i] > result[i] + eps || exp_result[i] < result[i] - eps)
  1376.             throw "debug.eqv: wrong result";
  1377.     }
  1379.     check_err_warn_messages(expected_err, expected_warn, "eqv");
  1380. }
  1382. exports.eqf = function(result, exp_result, eps, expected_err, expected_warn) {
  1383.     // NaN values are not allowed
  1384.     if (typeof exp_result != "number" || isNaN(exp_result))
  1385.         throw "debug.eqf: wrong expected data type";
  1386.     if (typeof result != "number" || isNaN(result))
  1387.         throw "debug.eqf: wrong result data type";
  1388.     eps = eps ? eps : EPS;
  1389.     if (exp_result > result + eps || exp_result < result - eps)
  1390.         throw "debug.eqf: wrong result";
  1392.     check_err_warn_messages(expected_err, expected_warn, "eqf");
  1393. }
  1395. exports.eq = function(result, exp_result, expected_err, expected_warn) {
  1396.     if (result !== exp_result)
  1397.         throw "debug.eq: wrong result";
  1399.     check_err_warn_messages(expected_err, expected_warn, "eq");
  1400. }
  1402. exports.ok = function(exp, expected_err, expected_warn) {
  1404.     if (!Boolean(exp))
  1405.         throw "debug.ok: wrong result";
  1407.     check_err_warn_messages(expected_err, expected_warn, "ok");
  1408. }
  1410. function check_err_warn_messages(expected_err, expected_warn, func_name) {
  1411.     expected_err = expected_err || "";
  1412.     expected_warn = expected_warn || "";
  1414.     if (_err_got) {
  1415.         if (expected_err == "")
  1416.             throw "debug." + func_name + ": no error is expected, but got \"" 
  1417.                     + _last_err_message + "\"";
  1418.         else if (_last_err_message != expected_err)
  1419.             throw "debug." + func_name + ": error \"" + expected_err 
  1420.                     + "\" is expected, but got \"" + _last_err_message + "\"";
  1421.     } else {
  1422.         if (expected_err != "")
  1423.             throw "debug." + func_name + ": error \"" + expected_err 
  1424.                 + "\" is expected, but got nothing";
  1425.     }
  1426.     if (_warn_got) {
  1427.         if (expected_warn == "")
  1428.             throw "debug." + func_name + ": no warning is expected, but got \"" 
  1429.                     + _last_warn_message + "\"";
  1430.         else if (_last_warn_message != expected_warn)
  1431.             throw "debug." + func_name + ": warning \"" + expected_warn 
  1432.                     + "\" is expected, but got \"" + _last_warn_message + "\"";
  1433.     } else {
  1434.         if (expected_warn != "")
  1435.             throw "debug." + func_name + ": warning \"" + expected_warn 
  1436.                 + "\" is expected, but got nothing";
  1437.     }
  1439.     _warn_got = false;
  1440.     _err_got = false;
  1441. }
  1443. exports.stat = function(module) {
  1444.     var missing_functions = [];
  1446.     if (typeof module === "string")
  1447.         module = b4w.require(module);
  1449.     for (var name in module)
  1450.         if (_called_funcs.indexOf(module[name]) == -1 &&
  1451.                 typeof module[name] === "function")
  1452.             missing_functions.push(name);
  1454.     if (missing_functions.length) {
  1455.         m_print.groupCollapsed(missing_functions.length + " function(s) not tested.");
  1456.         for (var i = 0; i < missing_functions.length; i++)
  1457.             m_print.log_raw(missing_functions[i]);
  1458.         m_print.groupEnd();
  1459.     } else
  1460.         m_print.group("All functions were tested.");
  1461. }
  1463. /**
  1464.  * Show normals of the dynamic object.
  1465.  * @method module:debug.show_normals
  1466.  * @param {Object3D} obj Object 3D
  1467.  * @param {string} mat_name Material name
  1468.  * @param {number} length Length of normals
  1469.  * @param {number} width Width of normals
  1470.  */
  1471. exports.show_normals = function(obj, mat_name, length, width) {
  1472.     hide_normals();
  1474.     var batch = m_batch.find_batch_material(obj, mat_name, "MAIN");
  1475.     if (!m_geom.has_dyn_geom(obj) || !batch) {
  1476.         m_print.error("Normals are not avaliable for the dynamic object:", obj.name);
  1477.         return false;
  1478.     }
  1480.     var bufs_data = batch.bufs_data;
  1481.     if (!(bufs_data && bufs_data.pointers &&
  1482.             bufs_data.pointers["a_position"] &&
  1483.             bufs_data.pointers["a_tbn"])) {
  1484.         m_print.error("Normals are not avaliable for the object:", obj.name);
  1485.         return false;
  1486.     }
  1488.     var positions = m_geom.extract_array_float(bufs_data, "a_position");
  1489.     var norms = m_geom.extract_array_float(bufs_data, "a_normal");
  1491.     var obj_tsr = m_trans.get_tsr(obj, _tsr_tmp);
  1493.     _normal_line = m_obj.create_line("normal_line");
  1495.     var normals = new Float32Array(2 * positions.length);
  1496.     for (var i = 0; i < positions.length; i += 3) {
  1497.         var ver_pos = _vec3_tmp;
  1498.         ver_pos[0] = positions[i + 0];
  1499.         ver_pos[1] = positions[i + 1];
  1500.         ver_pos[2] = positions[i + 2];
  1501.         var begin_norm = m_tsr.transform_vec3(ver_pos, obj_tsr, _vec3_tmp2);
  1502.         normals[2 * i + 0] = begin_norm[0];
  1503.         normals[2 * i + 1] = begin_norm[1];
  1504.         normals[2 * i + 2] = begin_norm[2];
  1506.         var dir = m_vec3.scale(norms.subarray(i, i + 3), length, _vec3_tmp2);
  1507.         var end_norm_l = m_vec3.add(ver_pos, dir, _vec3_tmp2);
  1508.         var end_norm = m_tsr.transform_vec3(end_norm_l, obj_tsr, _vec3_tmp2);
  1509.         normals[2 * i + 3] = end_norm[0];
  1510.         normals[2 * i + 4] = end_norm[1];
  1511.         normals[2 * i + 5] = end_norm[2];
  1512.     }
  1514.     var normal_line_batch = m_batch.get_first_batch(_normal_line);
  1516.     m_geom.draw_line(normal_line_batch, normals, true);
  1517.     m_render.assign_attribute_setters(normal_line_batch);
  1518.     normal_line_batch.diffuse_color.set([1.0, 1.0, 1.0, 1.0]);
  1519.     normal_line_batch.line_width = width;
  1520. }
  1522. /**
  1523.  * Hide normals of a dynamic object.
  1524.  * @method module:debug.hide_normals
  1525.  */
  1526. exports.hide_normals = hide_normals;
  1527. function hide_normals() {
  1528.     if (!_normal_line)
  1529.         return;
  1531.     // NOTE: it is a copy/paste m_scenes.remove_object
  1532.     m_obj.obj_switch_cleanup_flags(_normal_line, false, false, false);
  1533.     m_data.prepare_object_unloading(_normal_line);
  1534.     m_obj.obj_switch_cleanup_flags(_normal_line, true, true, true);
  1535.     m_obj.remove_object(_normal_line);
  1537.     _normal_line = null;
  1538. }
  1540. }
  1542. var debug_factory = register("debug", Debug);
  1544. export default debug_factory;