exports.set_light_params = function(light_name, light_params) {
var scene = scenes.get_active();
if (!scene) {
m_print.error("No active scene");
return false;
}
var lamps = scenes.get_scene_objs(scene, "LAMP", scenes.DATA_ID_ALL);
for (var i = 0; i < lamps.length; i++) {
var lamp = lamps[i];
if (lamp["name"] === light_name) {
var light = lamp._light;
break;
}
}
if (!light) {
m_print.error("B4W Warning: light \"" + light_name +
"\" not found");
return false;
}
if (typeof light_params.light_energy == "number") {
lights.set_light_energy(light, light_params.light_energy);
scenes.update_lamp_scene(lamp, scene);
}
if (typeof light_params.light_color == "object") {
lights.set_light_color(light, light_params.light_color);
scenes.update_lamp_scene(lamp, scene);
}
}
exports["set_light_params"] = function(light_name, light_params) {
var scene = scenes.get_active();
if (!scene) {
m_print.error("No active scene");
return false;
}
var lamps = scenes.get_scene_objs(scene, "LAMP")
for (var i = 0; i < lamps.length; i++) {
var lamp = lamps[i];
if (lamp["name"] === light_name) {
var light = lamp._light;
break;
}
}
if (!light) {
m_print.error("B4W Warning: light \"" + light_name +
"\" not found");
return false;
}
if ("light_energy" in light_params) {
lights.set_light_energy(light, light_params["light_energy"]);
scenes.update_lamp_scene(lamp, scene);
}
if ("light_color" in light_params) {
lights.set_light_color(light, light_params["light_color"]);
scenes.update_lamp_scene(lamp, scene);
}
}
/**
* Set object render world_matrix.
* NOTE: do not try to update batched objects (buggy _dg_parent influence)
* @methodOf transform
* @param {Object} obj Object ID
*/
function update_transform(obj) {
var render = obj._render;
m_cons.update_constraint(obj, _elapsed);
m_cam.update_camera(obj);
if (obj["type"] == "CAMERA")
m_cam.clamp_limits(obj);
// should not change after constraint update
var trans = render.trans;
var scale = render.scale;
var quat = render.quat;
m_tsr.set_sep(trans, scale, quat, render.tsr);
var wm = render.world_matrix;
m_mat4.identity(wm);
m_mat4.fromQuat(quat, wm);
// TODO: remove world matrix and move to tsr system
if (obj["type"] != "CAMERA")
m_util.scale_mat4(wm, scale, wm);
wm[12] = trans[0];
wm[13] = trans[1];
wm[14] = trans[2];
m_mat4.invert(wm, render.inv_world_matrix);
if (obj._anim_slots && m_particles.has_anim_particles(obj))
m_particles.update_emitter_transform(obj);
// NOTE: available only after batch creation (really needed now?)
if (render.bb_local && render.bb_world) {
m_bounds.bounding_box_transform(render.bb_local, wm, render.bb_world);
m_bounds.bounding_sphere_transform(render.bs_local, wm, render.bs_world);
m_bounds.bounding_ellipsoid_transform(render.be_local, render.tsr,
render.be_world)
if (render.shadow_cast)
m_scs.schedule_shadow_update(m_scs.get_active());
}
switch (obj["type"]) {
case "SPEAKER":
m_sfx.speaker_update_transform(obj, _elapsed);
break;
case "CAMERA":
m_cam.update_camera_transform(obj);
if (m_scs.check_active())
m_sfx.listener_update_transform(m_scs.get_active(), trans, quat, _elapsed);
break;
case "LAMP":
m_lights.update_light_transform(obj);
if (m_scs.check_active())
m_scs.update_lamp_scene(obj, m_scs.get_active());
break;
case "EMPTY":
if (obj["field"])
m_scs.update_force(obj);
break;
}
if (obj["type"] == "LAMP" || obj["type"] == "CAMERA") {
if (m_scs.check_active()) {
var active_scene = m_scs.get_active();
m_scs.schedule_shadow_update(active_scene);
m_scs.schedule_grass_map_update(active_scene);
}
}
var descends = obj._descends;
for (var i = 0; i < descends.length; i++)
update_transform(descends[i]);
}
/**
* Set the sun parameters.
* @method module:lights.set_sun_params
* @param {Object} sun_params sun parameters
*/
function set_sun_params (sun_params) {
var scene = scenes.get_active();
var lamps = scenes.get_scene_objs(scene, "LAMP", scenes.DATA_ID_ALL);
// Index of lamp(sun) on the scene
for (var i = 0; i < lamps.length; i++) {
var lamp = lamps[i];
var light = lamp._light;
if (light.type == "SUN") {
var sun = lamp;
break;
}
}
if (!sun) {
m_print.error("There is no sun on the scene");
return null;
}
if (typeof sun_params.hor_position == "number" &&
typeof sun_params.vert_position == "number") {
// convert to radians
var angle_hor = ((180 - sun_params.hor_position)) / 180 * Math.PI;
var angle_vert = ((90 - sun_params.vert_position)) / 180 * Math.PI;
var sun_render = sun._render;
// rotate sun
transform.set_rotation_euler(sun, [angle_vert, angle_hor, 0]);
var dir = new Float32Array(3);
util.quat_to_dir(sun_render.quat, util.AXIS_Y, dir);
var dist_to_center = m_vec3.length(sun_render.trans);
m_vec3.copy(dir, _sun_pos);
m_vec3.scale(_sun_pos, dist_to_center, _sun_pos);
// translate sun
transform.set_translation(sun, _sun_pos);
transform.update_transform(sun);
var sun_light = sun._light;
if (sun_light.dynamic_intensity) {
// set amplitude lighting params
var def_sun_energy = sun["data"]["energy"];
var def_env_color = scene["world"]["light_settings"]["environment_energy"];
// change sun intensity dependent to its position
var energy = Math.cos(Math.abs(angle_vert));
var sun_energy = Math.max( Math.min(3.0 * energy, 1.0), 0.0) * def_sun_energy;
var env_energy = Math.max(energy, 0.1) * def_env_color;
lights.set_light_energy(sun_light, sun_energy);
scenes.set_environment_colors(scene, env_energy, null, null);
}
scenes.update_lamp_scene(sun, scene);
}
}
/**
* Set object render world_matrix.
* NOTE: do not try to update batched objects (buggy _dg_parent influence)
* @methodOf transform
* @param {Object} obj Object ID
*/
function update_transform(obj) {
var render = obj._render;
// NOTE: need to update before constraints, because they rely on to this flag
if (obj["type"] == "CAMERA")
m_cam.update_camera_upside_down(obj);
m_cons.update_constraint(obj, _elapsed);
if (obj["type"] == "CAMERA")
m_cam.update_camera(obj);
// should not change after constraint update
var trans = render.trans;
var scale = render.scale;
var quat = render.quat;
m_tsr.set_sep(trans, scale, quat, render.tsr);
var wm = render.world_matrix;
m_mat4.identity(wm);
m_mat4.fromQuat(quat, wm);
// TODO: remove world matrix and move to tsr system
if (obj["type"] != "CAMERA")
m_util.scale_mat4(wm, scale, wm);
wm[12] = trans[0];
wm[13] = trans[1];
wm[14] = trans[2];
m_mat4.invert(wm, render.inv_world_matrix);
if (obj._anim_slots.length && m_particles.has_anim_particles(obj))
m_particles.update_emitter_transform(obj);
// NOTE: available only after batch creation (really needed now?)
if (render.bb_local && render.bb_world) {
m_bounds.bounding_box_transform(render.bb_local, wm, render.bb_world);
m_bounds.bounding_sphere_transform(render.bs_local, wm, render.bs_world);
m_bounds.bounding_ellipsoid_transform(render.be_local, render.tsr,
render.be_world)
if (render.shadow_cast)
m_scs.schedule_shadow_update(m_scs.get_active());
}
switch (obj["type"]) {
case "SPEAKER":
m_sfx.speaker_update_transform(obj, _elapsed);
break;
case "CAMERA":
m_cam.update_camera_transform(obj);
// listener only for active scene camera
if (m_scs.check_active() && m_scs.get_camera(m_scs.get_active()) == obj)
m_sfx.listener_update_transform(m_scs.get_active(), trans, quat, _elapsed);
break;
case "LAMP":
m_lights.update_light_transform(obj);
if (m_scs.check_active())
m_scs.update_lamp_scene(obj, m_scs.get_active());
break;
case "EMPTY":
if (obj["field"])
m_scs.update_force(obj);
break;
}
if (obj["type"] == "LAMP" || obj["type"] == "CAMERA") {
if (m_scs.check_active()) {
var active_scene = m_scs.get_active();
m_scs.schedule_shadow_update(active_scene);
m_scs.schedule_grass_map_update(active_scene);
}
}
if (obj["type"] == "MESH") {
var modifiers = obj["modifiers"];
var armobj = null;
for (var i = 0; i < modifiers.length; i++) {
var modifier = modifiers[i];
if (modifier["type"] == "ARMATURE")
armobj = modifier["object"];
}
if (armobj) {
var armobj_tsr = armobj._render.tsr;
m_tsr.invert(armobj_tsr, _tsr_tmp);
m_tsr.multiply(_tsr_tmp, render.tsr, _tsr_tmp);
m_vec4.set(_tsr_tmp[0], _tsr_tmp[1], _tsr_tmp[2], _tsr_tmp[3],
render.arm_rel_trans);
m_quat.set(_tsr_tmp[4], _tsr_tmp[5], _tsr_tmp[6], _tsr_tmp[7],
render.arm_rel_quat);
}
}
var descends = obj._descends;
for (var i = 0; i < descends.length; i++)
update_transform(descends[i]);
render.force_zsort = true;
}
/**
* Set object render world_tsr.
* NOTE: do not try to update batched objects (buggy _dg_parent influence)
* @methodOf transform
* @param {Object3D} obj Object 3D
*/
function update_transform(obj) {
var render = obj.render;
var scenes_data = obj.scenes_data;
var obj_type = obj.type;
// NOTE: need to update before constraints, because they rely on to this flag
if (obj_type == "CAMERA")
m_cam.update_camera_upside_down(obj);
m_cons.update_constraint(obj, _elapsed);
if (obj_type == "CAMERA")
m_cam.update_camera(obj);
// should not change after constraint update
var trans = m_tsr.get_trans_value(render.world_tsr, _vec3_tmp);
var quat = m_tsr.get_quat_value(render.world_tsr, _quat4_tmp);
// NOTE: available only after batch creation (really needed now?)
if (render.bb_local && render.bb_world) {
m_bounds.bounding_box_transform(render.bb_local, render.world_tsr, render.bb_world);
m_bounds.bounding_sphere_transform(render.bs_local, render.world_tsr, render.bs_world);
m_bounds.bounding_ellipsoid_transform(render.be_local, render.world_tsr,
render.be_world)
}
switch (obj_type) {
case "SPEAKER":
m_sfx.speaker_update_transform(obj, _elapsed);
break;
case "MESH":
var armobj = obj.armobj;
if (armobj) {
var armobj_tsr = armobj.render.world_tsr;
m_tsr.invert(armobj_tsr, _tsr_tmp);
m_tsr.multiply(_tsr_tmp, render.world_tsr, _tsr_tmp);
m_vec4.set(_tsr_tmp[0], _tsr_tmp[1], _tsr_tmp[2], _tsr_tmp[3],
render.arm_rel_trans);
m_quat.set(_tsr_tmp[4], _tsr_tmp[5], _tsr_tmp[6], _tsr_tmp[7],
render.arm_rel_quat);
}
break;
case "CAMERA":
m_cam.update_camera_transform(obj);
// listener only for active scene camera
if (m_scs.check_active()) {
var active_scene = m_scs.get_active();
if (m_scs.get_camera(active_scene) == obj)
m_sfx.listener_update_transform(active_scene, trans, quat,
_elapsed);
}
break;
case "LAMP":
m_lights.update_light_transform(obj);
break;
}
for (var i = 0; i < scenes_data.length; i++) {
var sc_data = scenes_data[i];
if (sc_data.is_active) {
var scene = sc_data.scene;
var sc_render = scene._render;
var batches = sc_data.batches;
switch (obj_type) {
case "LAMP":
m_scs.update_lamp_scene(obj, scene);
break;
case "CAMERA":
m_scs.schedule_grass_map_update(scene);
if (sc_render.shadow_params) {
// camera movement only influence csm shadows
if (sc_render.shadow_params.enable_csm)
m_scs.schedule_shadow_update(scene);
m_scs.update_shadow_billboard_view(obj, sc_render.graph);
}
break;
case "MESH":
if (render.bb_local && render.bb_world) {
if (render.shadow_cast)
m_scs.schedule_shadow_update(scene);
var cube_refl_subs = sc_data.cube_refl_subs;
if (render.cube_reflection_id != null && cube_refl_subs) {
m_scs.update_cube_reflect_subs(cube_refl_subs, trans);
}
}
break;
case "EMPTY":
m_obj.update_force(obj);
break;
}
var plane_refl_subs = sc_data.plane_refl_subs;
var refl_objs = obj.reflective_objs;
if (refl_objs.length) {
for (var j = 0; j < plane_refl_subs.length; j++) {
var cam = plane_refl_subs[j].camera;
m_scs.update_plane_reflect_subs(plane_refl_subs[j], trans, quat);
m_obj_util.update_refl_objects(refl_objs, cam.reflection_plane);
m_cam.set_view(cam, m_scs.get_camera(scene));
m_util.extract_frustum_planes(cam.view_proj_matrix, cam.frustum_planes);
}
}
}
}
var cons_descends = obj.cons_descends;
for (var i = 0; i < cons_descends.length; i++)
update_transform(cons_descends[i]);
var cons_armat_bone_descends = obj.cons_armat_bone_descends;
for (var i = 0; i < cons_armat_bone_descends.length; i++) {
var cons_armat_desc = cons_armat_bone_descends[i];
var armobj = cons_armat_desc[0];
var bone_name = cons_armat_desc[1];
m_cons.update_bone_constraint(armobj, bone_name);
}
render.force_zsort = true;
}