Beispiel #1
0
exports.update_scene_nla = function(scene, is_cyclic) {
    var nla = {
        frame_start: scene["frame_start"],
        frame_end: scene["frame_end"],
        last_frame: -1,
        cyclic: is_cyclic,
        objects: []
    }

    var sobjs = m_scenes.get_scene_objs(scene, "ALL");

    for (var i = 0; i < sobjs.length; i++) {
        var sobj = sobjs[i];

        var adata = sobj["animation_data"];
        if (adata && adata["nla_tracks"].length) {
            var nla_tracks = adata["nla_tracks"];

            if (m_util.is_armature(sobj) || m_cam.is_camera(sobj) || m_util.is_mesh(sobj)) {
                var nla_events = get_nla_events(nla_tracks);
                sobj._nla_events = nla_events;
                nla.objects.push(sobj);
            }

            if (m_sfx.is_speaker(sobj)) {
                var nla_events = get_nla_events(nla_tracks);
                sobj._nla_events = nla_events;
                nla.objects.push(sobj);
            }
        }
    }

    for (var i = 0; i < sobjs.length; i++) {
        var sobj = sobjs[i];

        for (var j = 0; j < nla.objects.length; j++)
            if (m_anim.get_first_armature_object(sobj) == nla.objects[j]) {
                sobj._nla_events = m_util.clone_object_json(nla.objects[j]._nla_events);
                nla.objects.push(sobj);
            }

        if (m_particles.has_particles(sobj) && 
                m_particles.has_anim_particles(sobj)) {

            var ev = {
                frame_start: nla.frame_start,
                frame_end: nla.frame_end+1,
                frame_offset: 0,
                scheduled: false,
                action: null
            }
            sobj._nla_events = [ev];
            nla.objects.push(sobj);
        }
    }

    enforce_nla_consistency(nla);

    _nla_arr.push(nla);
}
Beispiel #2
0
exports.is_ortho_camera = function(camobj) {
    if (!camera.is_camera(camobj)) {
        m_print.error("is_ortho_camera(): wrong object");
        return;
    }
    
    return camobj._render.cameras[0].type == camera.TYPE_ORTHO;
}
Beispiel #3
0
exports.get_ortho_scale = function(camobj) {
    if (!camera.is_camera(camobj) || !exports.is_ortho_camera(camobj)) {
        m_print.error("get_ortho_scale(): wrong object");
        return;
    }

    return camobj._render.cameras[0].top * 2;
}
Beispiel #4
0
exports.get_move_style = function(camobj) {
    if (!camera.is_camera(camobj)) {
        m_print.error("get_move_style(): Wrong object");
        return null;
    }

    return camera.get_move_style(camobj);
}
Beispiel #5
0
exports["get_trans_speed"] = function(camobj) {
    if (!camera.is_camera(camobj)) {
        m_print.error("Wrong object");
        return 0;
    }

    return camobj._render.trans_speed[0];
}
Beispiel #6
0
function process_event(obj, ev, frame, elapsed) {

    if ((m_particles.has_particles(obj) && m_particles.has_anim_particles(obj)) ||
            m_util.is_armature(obj) || m_util.is_mesh(obj) ||
            m_cam.is_camera(obj)) {
        var init_anim_frame = frame - ev.frame_start + ev.action_frame_start;
        m_anim.set_current_frame_float(obj, init_anim_frame, m_anim.SLOT_0);
        m_anim.update_object_animation(obj, 0, m_anim.SLOT_0);
    }
}
Beispiel #7
0
exports.get_eye = function(camobj, dest) {
    if (!camera.is_camera(camobj)) {
        m_print.error("get_eye(): Wrong object");
        return;
    }
    
    if (!dest)
        var dest = new Float32Array(3);

    m_vec3.copy(camobj._render.trans, dest);
    return dest;
}
Beispiel #8
0
function process_event_start(obj, ev, frame, elapsed) {

    if (m_particles.has_particles(obj) && m_particles.has_anim_particles(obj)) {
        m_anim.apply_def(obj);
        m_anim.set_behavior(obj, m_anim.AB_FINISH_STOP, m_anim.SLOT_0);
    } else if (m_util.is_armature(obj) || m_util.is_mesh(obj) || m_cam.is_camera(obj)) {
        m_anim.apply(obj, ev.action, m_anim.SLOT_0);
        // NOTE: should not be required
        m_anim.set_behavior(obj, m_anim.AB_FINISH_STOP, m_anim.SLOT_0);
    } else if (m_sfx.is_speaker(obj)) {
        // TODO: speakers are special
        var when = (ev.frame_start - frame) / cfg_ani.framerate;
        var duration = (ev.frame_end - ev.frame_start) / cfg_ani.framerate;
        m_sfx.play(obj, when, duration);
    }
}
Beispiel #9
0
function process_event_start(obj, ev, frame, elapsed) {

    // subtract elapsed because play() occures before animation calcuations
    var init_anim_frame = ev.frame_offset - elapsed * cfg_ani.framerate;

    if (m_particles.has_particles(obj) && m_particles.has_anim_particles(obj)) {
        m_anim.apply_def(obj);
        m_anim.set_current_frame_float(obj, init_anim_frame);
        m_anim.play(obj);
    } else if (m_util.is_armature(obj) || m_util.is_mesh(obj) || m_cam.is_camera(obj)) {
        m_anim.apply(obj, ev.action);
        m_anim.set_current_frame_float(obj, init_anim_frame);
        m_anim.play(obj);
    } else if (m_sfx.is_speaker(obj)) {
        // TODO: speakers are special
        var when = 0;
        var duration = (ev.frame_end - frame) / cfg_ani.framerate;
        m_sfx.play(obj, when, duration);
    }
}
Beispiel #10
0
exports.set_ortho_scale = function(camobj, ortho_scale) {
    if (!camera.is_camera(camobj) || !exports.is_ortho_camera(camobj)) {
        m_print.error("set_ortho_scale(): wrong object");
        return;
    }

    var render = camobj._render;

    if (camera.is_target_camera(camobj)) {
        var dir_dist = m_vec3.dist(render.trans, render.pivot);
        render.init_top = ortho_scale / 2 * render.init_dist / dir_dist;
    } else if (camera.is_hover_camera(camobj) 
            && exports.has_distance_limits(camobj)) {
        var dir_dist = m_vec3.distance(render.trans, render.hover_pivot);
        render.init_top = ortho_scale / 2 * render.init_dist / dir_dist;
    } else
        // hover camera without distance limits, eye or static camera
        camobj._render.cameras[0].top = ortho_scale / 2;

    camera.update_ortho_scale(camobj);
}
Beispiel #11
0
exports["is_camera"] = function(obj) {
    return camera.is_camera(obj);
}
Beispiel #12
0
exports.update_scene_nla = function(scene, is_cyclic) {
    var nla = {
        frame_start: scene["frame_start"],
        frame_end: scene["frame_end"],
        frame_offset: 0,
        last_frame: -1,
        cyclic: is_cyclic,
        objects: [],
        script: [],
        curr_script_slot: 0
    }
    
    prepare_nla_script(scene, nla);

    var sobjs = m_scs.get_scene_objs(scene, "ALL", m_scs.DATA_ID_ALL);

    for (var i = 0; i < sobjs.length; i++) {
        var sobj = sobjs[i];

        var adata = sobj["animation_data"];
        if (adata && adata["nla_tracks"].length) {
            var nla_tracks = adata["nla_tracks"];

            if (m_util.is_armature(sobj) || m_cam.is_camera(sobj) || m_util.is_mesh(sobj)) {
                var nla_events = get_nla_events(nla_tracks);
                sobj._nla_events = nla_events;
            }

            if (m_sfx.is_speaker(sobj)) {
                var nla_events = get_nla_events(nla_tracks);
                sobj._nla_events = nla_events;
            }
        }

        if (m_anim.has_animated_nodemats(sobj)) {
            var materials = sobj["data"]["materials"];

            for (var j = 0; j < materials.length; j++) {
                var mat = materials[j];
                var node_tree = mat["node_tree"];
                var adata = node_tree["animation_data"];
                if (node_tree && adata) {
                    var nla_tracks = adata["nla_tracks"];
                    var nla_events = get_nla_events(nla_tracks);
                    if (sobj._nla_events)
                        sobj._nla_events = sobj._nla_events.concat(nla_events);
                    else
                        sobj._nla_events = nla_events;
                }
            }
        }

        if (sobj._nla_events)
            nla.objects.push(sobj);
    }

    for (var i = 0; i < sobjs.length; i++) {
        var sobj = sobjs[i];

        if (m_particles.has_particles(sobj) &&
                m_particles.has_anim_particles(sobj)) {

            var ev = {
                frame_start: nla.frame_start,
                frame_end: nla.frame_end+1,
                scheduled: false,
                paused: false,
                action: null,
                action_frame_start: 0,
                action_frame_end: 0,
                ext_frame_start: 0,
                ext_frame_end: 0
            }
            sobj._nla_events = [ev];
            nla.objects.push(sobj);
        }
    }

    enforce_nla_consistency(nla);
    calc_nla_extents(nla);

    _nla_arr.push(nla);
}
Beispiel #13
0
function process_event_stop(obj, ev, frame) {
    if (m_particles.has_particles(obj) && m_particles.has_anim_particles(obj))
        m_anim.stop(obj);
    else if (m_util.is_armature(obj) || m_util.is_mesh(obj) || m_cam.is_camera(obj))
        m_anim.stop(obj);
}
Beispiel #14
0
exports.update_scene_nla = function(scene, is_cyclic) {
    var nla = {
        frame_start: scene["frame_start"],
        frame_end: scene["frame_end"],
        frame_offset: 0,
        last_frame: -1,
        cyclic: is_cyclic,
        objects: [],
        textures: [],
        script: [],
        curr_script_slot: 0,
        registers: {
            "R1" : 0,
            "R2" : 0,
            "R3" : 0,
            "R4" : 0,
            "R5" : 0,
            "R6" : 0,
            "R7" : 0,
            "R8" : 0
        }
    }
    
    prepare_nla_script(scene, nla);

    var sobjs = m_scs.get_scene_objs(scene, "ALL", m_scs.DATA_ID_ALL);

    for (var i = 0; i < sobjs.length; i++) {
        var sobj = sobjs[i];
        var slot_num = 0;
        var obj_nla_events = [];

        var adata = sobj["animation_data"];
        if (adata && adata["nla_tracks"].length) {
            var nla_tracks = adata["nla_tracks"];

            if (m_util.is_armature(sobj) ||
                    m_cam.is_camera(sobj) ||
                    m_util.is_mesh(sobj) ||
                    m_util.is_empty(sobj) ||
                    // no need for separate slot in case of sound
                    m_sfx.is_speaker(sobj)) {

                var nla_events = get_nla_events(nla_tracks, slot_num);
                if (nla_events.length) {
                    obj_nla_events = obj_nla_events.concat(nla_events);
                    slot_num++;
                }
            }
        }

        if (has_spk_param_nla(sobj)) {
            var nla_tracks = sobj["data"]["animation_data"]["nla_tracks"];
            var nla_events = get_nla_events(nla_tracks, slot_num);

            if (nla_events.length) {
                obj_nla_events = obj_nla_events.concat(nla_events);
                slot_num++;
            }
        }

        if (m_anim.has_animated_nodemats(sobj)) {
            var materials = sobj["data"]["materials"];

            for (var j = 0; j < materials.length; j++) {
                var mat = materials[j];
                var node_tree = mat["node_tree"];
                var adata = node_tree["animation_data"];
                if (node_tree && adata) {
                    var nla_tracks = adata["nla_tracks"];
                    var nla_events = get_nla_events(nla_tracks, -1);

                    var mat_anim_names = [];

                    for (var k = 0; k < nla_events.length; k++) {
                        var ev = nla_events[k];

                        if (mat_anim_names.indexOf(ev.anim_name) == -1)
                            mat_anim_names.push(ev.anim_name);

                        ev.anim_slot = slot_num + 
                                mat_anim_names.indexOf(ev.anim_name);

                        obj_nla_events.push(ev);
                    }

                    slot_num += mat_anim_names.length;
                }
            }
        }

        for (var j = 0; j < sobj["particle_systems"].length; j++) {
            var psys = sobj["particle_systems"][j];
            var pset = psys["settings"];

            if (pset["type"] == "EMITTER" && pset["b4w_allow_nla"]) {
                var ev = init_event();

                ev.type = "CLIP";
                ev.frame_start = nla.frame_start;
                ev.frame_end = nla.frame_end+1;
                ev.anim_name = psys["name"];
                ev.anim_slot = slot_num;

                obj_nla_events.push(ev);
                slot_num++;
            }
        }

        var slot_num_va = slot_num+1;

        // NOTE: the data is missing in the meta objects
        if (m_util.is_mesh(sobj) && sobj["data"]) {
            for (var j = 0; j < sobj["data"]["b4w_vertex_anim"].length; j++) {
                var va = sobj["data"]["b4w_vertex_anim"][j];

                if (va["allow_nla"]) {
                    slot_num = slot_num_va;

                    var ev = init_event();

                    ev.type = "CLIP";
                    ev.frame_start = nla.frame_start;
                    ev.frame_end = nla.frame_end+1;
                    ev.anim_name = va["name"];
                    ev.anim_slot = slot_num;
                    obj_nla_events.push(ev);
                }
            }
        }

        if (obj_nla_events.length) {
            sobj._nla_events = obj_nla_events;
            nla.objects.push(sobj);
        }

    }

    var textures = scene._render.video_textures;
    for (var j = 0; j < textures.length; j++) {
        var ev = init_event();
        var texture = textures[j]._render;

        ev.type = "VIDEO";
        ev.frame_start = Math.min(texture.frame_start, nla.frame_end);

        if (texture.use_cyclic)
            ev.frame_end = nla.frame_end;
        else 
            ev.frame_end =  Math.min(texture.frame_duration + texture.frame_start 
                    + texture.frame_offset, nla.frame_end);

        ev.anim_name = textures[j].name;

        texture._nla_tex_event = ev;
        nla.textures.push(texture);
    }

    enforce_nla_consistency(nla);
    calc_nla_extents(nla);

    _nla_arr.push(nla);
}