Source: extern/geometry.js

  1. import register from "../util/register.js";
  3. import m_batch_fact from "../intern/batch.js";
  4. import m_geom_fact from "../intern/geometry.js";
  5. import m_print_fact from "../intern/print.js";
  6. import m_render_fact from "../intern/renderer.js";
  7. import * as m_tbn from "../intern/tbn.js";
  9. /**
  10.  * Low-level geometry API.
  11.  * Enable the "Dynamic geometry" checkbox for the objects to allow geometry modification.
  12.  * @module geometry
  13.  */
  14. function Geometry(ns, exports) {
  16. var m_batch  = m_batch_fact(ns);
  17. var m_geom   = m_geom_fact(ns);
  18. var m_print  = m_print_fact(ns);
  19. var m_render = m_render_fact(ns);
  21. /**
  22.  * Extract the vertex array from the object.
  23.  * @method module:geometry.extract_vertex_array
  24.  * @param {Object3D} obj Object 3D
  25.  * @param {string} mat_name Material name
  26.  * @param {string} attrib_name Attribute name (a_position, a_tbn, a_normal)
  27.  * @returns {Float32Array} Vertex array
  28.  */
  29. exports.extract_vertex_array = function(obj, mat_name, attrib_name) {
  31.     if (!m_geom.has_dyn_geom(obj)) {
  32.         m_print.error("Wrong object:", obj.name);
  33.         return null;
  34.     }
  36.     var batch = m_batch.find_batch_material(obj, mat_name, "MAIN");
  37.     if (batch) {
  38.         var bufs_data = batch.bufs_data;
  39.         if (bufs_data && bufs_data.pointers &&
  40.                 (attrib_name == "a_normal" && bufs_data.pointers["a_tbn"] ||
  41.                 bufs_data.pointers[attrib_name])) {
  42.             return m_geom.extract_array_float(bufs_data, attrib_name);
  43.         } else {
  44.             m_print.error("Attribute not found:" + attrib_name);
  45.             return null;
  46.         }
  47.     } else {
  48.         m_print.error("Wrong material:", mat_name);
  49.         return null;
  50.     }
  51. }
  53. /**
  54.  * Extract the array of triangulated face indices from the given object.
  55.  * @method module:geometry.extract_index_array
  56.  * @param {Object3D} obj Object 3D
  57.  * @param {string} mat_name Material name
  58.  * @returns {Uint16Array|Uint32Array} Array of triangle indices
  59.  */
  60. exports.extract_index_array = function(obj, mat_name) {
  62.     if (!m_geom.has_dyn_geom(obj)) {
  63.         m_print.error("Wrong object:", obj.name);
  64.         return null;
  65.     }
  67.     var batch = m_batch.find_batch_material(obj, mat_name, "MAIN");
  69.     if (batch) {
  70.         var bufs_data = batch.bufs_data;
  71.         if (bufs_data && bufs_data.pointers) {
  72.             return bufs_data.ibo_array;
  73.         } else {
  74.             m_print.error("Buffer data not found");
  75.             return null;
  76.         }
  77.     } else {
  78.         m_print.error("Wrong material:", mat_name);
  79.         return null;
  80.     }
  81. }
  83. /**
  84.  * Update the vertex array for the given object.
  85.  * @method module:geometry.update_vertex_array
  86.  * @param {Object3D} obj Object 3D
  87.  * @param {string} mat_name Material name
  88.  * @param {string} attrib_name Attribute name (a_position, a_tbn, a_normal)
  89.  * @param {Float32Array} array The new array
  90.  */
  91. exports.update_vertex_array = function(obj, mat_name, attrib_name, array) {
  92.     if (!m_geom.has_dyn_geom(obj)) {
  93.         m_print.error("Wrong object:", obj.name);
  94.         return;
  95.     }
  97.     var types = ["MAIN", "SHADOW", "COLOR_ID"];
  98.     for (var i = 0; i < types.length; i++) {
  99.         var type = types[i];
  101.         var batch = m_batch.find_batch_material(obj, mat_name, type);
  103.         if (batch) {
  104.             var bufs_data = batch.bufs_data;
  106.             if (bufs_data && bufs_data.pointers &&
  107.                     (attrib_name == "a_normal" && bufs_data.pointers["a_tbn"] ||
  108.                     bufs_data.pointers[attrib_name]))
  109.                 m_geom.update_bufs_data_array(bufs_data, attrib_name, 0, array);
  110.         }
  111.     }
  112. }
  114. /**
  115.  * Override geometry for the given object.
  116.  * @method module:geometry.override_geometry
  117.  * @param {Object3D} obj Object 3D
  118.  * @param {string} mat_name Material name
  119.  * @param {Uint16Array|Uint32Array} ibo_array Array of triangle indices
  120.  * @param {Float32Array} positions_array New vertex positions array
  121.  * @param {boolean} smooth_normals Enable normals smoothing
  122.  */
  123. exports.override_geometry = function(obj, mat_name, ibo_array,
  124.                                         positions_array, smooth_normals) {
  125.     if (!m_geom.has_dyn_geom(obj)) {
  126.         m_print.error("Wrong object:", obj.name);
  127.         return;
  128.     }
  130.     if (!(ibo_array instanceof Uint16Array) &&
  131.         !(ibo_array instanceof Uint32Array)) {
  132.             m_print.error("Wrong ibo_array type");
  133.             return;
  134.     }
  136.     if (!(positions_array instanceof Float32Array)) {
  137.         m_print.error("Wrong positions_array type");
  138.         return;
  139.     }
  141.     var types = ["MAIN", "SHADOW", "COLOR_ID"];
  142.     for (var i = 0; i < types.length; i++) {
  143.         var batch_type = types[i];
  144.         var batch = m_batch.find_batch_material(obj, mat_name, batch_type);
  146.         if (batch) {
  147.             var bufs_data = batch.bufs_data;
  149.             if (bufs_data) {
  150.                 m_geom.update_bufs_data_index_array(bufs_data, batch.draw_mode,
  151.                         ibo_array);
  153.                 var lengths = {};
  154.                 for (var attr in bufs_data.pointers) {
  155.                     var pointer = bufs_data.pointers[attr];
  157.                     var len = positions_array.length / 3 * pointer.num_comp;
  158.                     var type = m_geom.get_vbo_type_by_attr_name(attr);
  160.                     if (!lengths[type])
  161.                         lengths[type] = 0;
  162.                     lengths[type] += len;
  163.                 }
  165.                 var vbo_source_data = m_geom.init_vbo_source_data(lengths);
  166.                 bufs_data.vbo_source_data = vbo_source_data;
  168.                 var offsets = {}
  169.                 for (var attr in bufs_data.pointers) {
  170.                     var pointer = bufs_data.pointers[attr];
  171.                     var type = m_geom.get_vbo_type_by_attr_name(attr);
  173.                     if (!offsets[type])
  174.                         offsets[type] = 0;
  176.                     switch (attr) {
  177.                     case "a_position":
  178.                         m_geom.vbo_source_data_set_attr(bufs_data.vbo_source_data, 
  179.                                 "a_position", positions_array, offsets[type]);
  180.                         pointer.offset = offsets[type];
  181.                         pointer.length = positions_array.length;
  182.                         offsets[type] += pointer.length;
  183.                         break;
  184.                     case "a_tbn":
  185.                         var shared_indices;
  187.                         if (smooth_normals)
  188.                             shared_indices = m_geom.calc_shared_indices(
  189.                                 ibo_array, positions_array, positions_array);
  191.                         var normals = m_geom.calc_normals(ibo_array,
  192.                                       positions_array, shared_indices);
  194.                         pointer.length = positions_array.length / 3 * pointer.num_comp;
  195.                         var tangents = new Float32Array(pointer.length);
  197.                         for (var j = 0; j < tangents.length; j +=4) {
  198.                             tangents[j] = 1;
  199.                             tangents[j + 3] = 1;
  200.                         }
  202.                         var a_tbn = m_tbn.from_norm_tan(normals, tangents);
  203.                         m_geom.vbo_source_data_set_attr(bufs_data.vbo_source_data, 
  204.                                 "a_tbn", a_tbn, offsets[type]);
  205.                         pointer.offset = offsets[type];
  206.                         offsets[type] += pointer.length;
  207.                         break;
  208.                     default:
  209.                         pointer.offset = offsets[type];
  210.                         pointer.length = positions_array.length / 3 * pointer.num_comp;
  212.                         var constructor = m_geom.get_constructor_by_type(type);
  213.                         var new_array = new constructor(pointer.length);
  214.                         m_geom.vbo_source_data_set_attr(bufs_data.vbo_source_data, 
  215.                                 attr, new_array, offsets[type]);
  216.                         offsets[type] += pointer.length;
  217.                         break;
  218.                     }
  219.                 }
  221.                 m_geom.update_gl_buffers(bufs_data);
  222.                 m_render.assign_attribute_setters(batch);
  224.                 // NOTE: process child batches if bufs_data was copied not by link
  225.                 var child_batch = m_batch.find_batch_material_forked(obj, batch);
  226.                 if (child_batch && child_batch.bufs_data)
  227.                     child_batch.bufs_data = bufs_data;
  229.             }
  230.         }
  231.     }
  232. }
  233. /**
  234.  * Apply shape key to the object. If the object is supposed to be available for 
  235.  * selecting (for example, via the {@link module:scenes.pick_object|pick_object} 
  236.  * method) call the {@link module:objects.update_boundings|update_boundings} method 
  237.  * after applying a shape key or override object bounding volumes in Blender 
  238.  * beforehand so that the boundings can contain the object in its largest shape.
  239.  * @method module:geometry.set_shape_key_value
  240.  * @param {Object3D} obj Object 3D
  241.  * @param {string} key_name Shape key name
  242.  * @param {number} value Shape key value
  243.  * @example var m_geom = require("geometry");
  244.  * var m_scenes = require("scenes");
  245.  *
  246.  * var cube = m_scenes.get_object_by_name("Cube");
  247.  * m_geom.set_shape_key_value(cube, "Key 1", 0.5);
  248.  */
  249. exports.set_shape_key_value = function(obj, key_name, value) {
  250.     if (!m_geom.check_shape_keys(obj)) {
  251.         m_print.error("Wrong object:", obj.name);
  252.         return;
  253.     }
  255.     if (!m_geom.has_shape_key(obj, key_name)) {
  256.         m_print.error("Wrong key name:", key_name);
  257.         return;
  258.     }
  260.     var float_value = parseFloat(value);
  262.     m_geom.apply_shape_key(obj, key_name, float_value);
  263. }
  264. /**
  265.  * Check if object has got shape keys.
  266.  * @method module:geometry.check_shape_keys
  267.  * @param {Object3D} obj Object 3D
  268.  * @returns {boolean} Checking result.
  269.  */
  270. exports.check_shape_keys = function(obj) {
  271.     return m_geom.check_shape_keys(obj);
  272. }
  273. /**
  274.  * Return all available shape keys names.
  275.  * @method module:geometry.get_shape_keys_names
  276.  * @param {Object3D} obj Object 3D
  277.  * @returns {string[]} Array of animation names
  278.  */
  279. exports.get_shape_keys_names = function(obj) {
  281.     if (!m_geom.check_shape_keys(obj)) {
  282.         m_print.error("Wrong object:", obj.name);
  283.         return [];
  284.     }
  286.     return m_geom.get_shape_keys_names(obj);
  287. }
  288. /**
  289.  * Return shape key current value.
  290.  * @method module:geometry.get_shape_key_value
  291.  * @param {Object3D} obj Object 3D
  292.  * @param {string} key_name Shape key name
  293.  * @returns {number} value Shape key value
  294.  */
  295. exports.get_shape_key_value = function(obj, key_name) {
  297.     if (!m_geom.check_shape_keys(obj)) {
  298.         m_print.error("Wrong object:", obj.name);
  299.         return 0;
  300.     }
  302.     if (!m_geom.has_shape_key(obj, key_name)) {
  303.         m_print.error("Wrong key name:", key_name);
  304.         return 0;
  305.     }
  307.     return m_geom.get_shape_key_value(obj, key_name);
  308. }
  310. /**
  311.  * Draw a line.
  312.  * @method module:geometry.draw_line
  313.  * @param {Object3D} obj Line object
  314.  * @param {Float32Array} positions Line points [X0,Y0,Z0,X1,Y1,Z1...] in the 
  315.  * local space of the given line object.
  316.  * @param {boolean} [is_split=false] True - draw a split line
  317.  * (points specified in pairs), false - draw continuous line
  318.  * @example 
  319.  * var m_geom = require("geometry");
  320.  * var m_scenes = require("scenes");
  321.  * 
  322.  * var empty = m_scenes.get_object_by_name("Empty");
  323.  * var points = new Float32Array([0, 0, 0, 5, 0, 0, 0, 0, 5, 0, 0, 0]); // draw a triangle
  324.  * m_geom.draw_line(empty, points);
  325.  */
  326. exports.draw_line = function(obj, positions, is_split) {
  327.     is_split = is_split || false;
  329.     if (!(positions instanceof Float32Array)) {
  330.         m_print.error("Wrong positions type");
  331.         return;
  332.     }
  334.     var batch = m_batch.get_first_batch(obj);
  336.     if (batch) {
  337.         m_geom.draw_line(batch, positions, is_split);
  338.         m_render.assign_attribute_setters(batch);
  339.     }
  340. }
  342. }
  344. var geometry_factory = register("geometry", Geometry);
  346. export default geometry_factory;