722 lines
22 KiB
JavaScript
722 lines
22 KiB
JavaScript
/* SPDX-License-Identifier: GPL-3.0-or-later */
|
|
/*
|
|
This js file is meant to be used in Cycling'74 Max with the [v8] object.
|
|
It provides a way to control cameras in a typical first-person fashion,
|
|
and move and turn objects in view-space.
|
|
|
|
Copyright (C) 2025 Théophile Clet <contact@tflcl.xyz> - https://tflcl.xyz
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details:
|
|
<https://www.gnu.org/licenses/gpl-3.0.txt>.
|
|
*/
|
|
|
|
autowatch = 1;
|
|
outlets = 2;
|
|
|
|
const g = new Global("tc.fpcontrol");
|
|
const instance = (() => {
|
|
if (g.instance_count) {
|
|
g.instance_count += 1
|
|
} else {
|
|
g.instance_count = 1;
|
|
}
|
|
return g.instance_count
|
|
})();
|
|
|
|
let world_bangs = false; // is the world banging?
|
|
const ctx_finder = require("implicit.context.js");
|
|
ctx_finder.register_drawto(this, dosetdrawto, set_root);
|
|
|
|
include("FF_Vector.js");
|
|
|
|
var ease = 0.1;
|
|
declareattribute({
|
|
name: "ease",
|
|
setter: "set_ease",
|
|
label: "Ease",
|
|
type: "float",
|
|
min: 0.0,
|
|
default: 0.1,
|
|
});
|
|
|
|
var camera = "";
|
|
declareattribute({
|
|
name: "camera",
|
|
setter: "set_camera",
|
|
label: "Camera anim node",
|
|
type: "string",
|
|
});
|
|
|
|
var flymode = 0;
|
|
declareattribute({
|
|
name: "flymode",
|
|
setter: "set_flymode",
|
|
style: "onoff",
|
|
default: 0,
|
|
});
|
|
|
|
var controlmode = 0;
|
|
declareattribute({
|
|
name: "controlmode",
|
|
setter: "set_controlmode",
|
|
style: "enumindex",
|
|
enumvals: ["View space", "Object space"],
|
|
label: "Control Mode",
|
|
})
|
|
|
|
var show_bounds = 1;
|
|
declareattribute({
|
|
name: "show_bounds",
|
|
setter: "set_show_bounds",
|
|
style: "onoff",
|
|
default: 1,
|
|
});
|
|
|
|
const ANIMABLE_GL_OBJECTS = [
|
|
"jit_gl_node",
|
|
"jit_gl_mesh",
|
|
"jit_gl_gridshape",
|
|
"jit_gl_model",
|
|
"jit_gl_plato",
|
|
"jit_gl_nurbs",
|
|
"jit_gl_text",
|
|
"jit_gl_videoplane",
|
|
"jit_gl_graph",
|
|
"jit_gl_sketch",
|
|
"jit_gl_path",
|
|
"jit_gl_lua",
|
|
"jit_gl_isosurf",
|
|
"jit_gl_cornerpin",
|
|
"jit_gl_skybox",
|
|
"jit_gl_volume",
|
|
"jit_gl_multiple",
|
|
"jit_gl_light",
|
|
"jit_gl_camera",
|
|
];
|
|
|
|
let controllable_objects = []; // Used for listing all controllable objects in a patch
|
|
|
|
let top_level_patcher;
|
|
let ctlr;
|
|
|
|
class Controller {
|
|
constructor(drawto) {
|
|
this.ease = 0.1; // anim.drive easing
|
|
this.flymode = false;
|
|
this.flymode_applyed = false; // Flag
|
|
this.control_obj_type; // 'cam' if the camera is the target, 'obj' otherwise
|
|
|
|
this.root_anim_node = null; // The implicit drawto context anim node
|
|
|
|
this.world_up = new FF_Vector(0, 1, 0);
|
|
this.camera_target = {
|
|
name: '',
|
|
class: '',
|
|
anim: '',
|
|
}
|
|
this.camera_node_implicit = new JitterObject("jit.anim.node"); // Used if camera isn't attached to an anim.node (using the pre-made anim node of a jit.gl.camera doesn't work for some reason, so we use our own "implicit" one)
|
|
this.camera_node_implicit.name = "camera_node_implicit_" + instance;
|
|
this.camera_node = new JitterObject("jit.proxy"); // Either proxy of a jit.anim.node defined by user, or of this.camera_node_implicit
|
|
this.cam_direction, this.cam_up, this.cam_right;
|
|
|
|
this.camera_base_matrix;
|
|
this.get_cam_base_matrix();
|
|
|
|
// main_node always has its Y axis aligned with world_up direction
|
|
// It is used with main_drive for up/down movements, Y rotation (yaw) and X-Y movements (accross an horizontal plan)
|
|
this.main_node = new JitterObject("jit.anim.node");
|
|
this.main_node.turnmode = "local";
|
|
this.main_node.movemode = "local";
|
|
this.main_node.tripod = 1; // for flymode
|
|
|
|
this.main_drive = new JitterObject("jit.anim.drive");
|
|
this.main_drive.drawto = drawto;
|
|
this.main_drive.ease = this.ease;
|
|
this.main_drive.targetname = this.main_node.name;
|
|
|
|
// pitch_node used with pitch_drive for pitch rotation (over the objects local x axis)
|
|
this.pitch_node = new JitterObject("jit.anim.node");
|
|
this.pitch_node.name = "fp_pitch_node_" + instance;
|
|
this.pitch_node.anim = this.main_node.name;
|
|
this.pitch_node.turnmode = "parent";
|
|
this.pitch_node.movemode = "parent";
|
|
|
|
this.pitch_drive = new JitterObject("jit.anim.drive");
|
|
this.pitch_drive.drawto = drawto;
|
|
this.pitch_drive.ease = this.ease;
|
|
this.pitch_drive.targetname = this.pitch_node.name;
|
|
|
|
this.target = new JitterObject("jit.proxy"); // Stores the object to control (always an anim.node)
|
|
this.last_target_anim_node = null; // Stores which parent anim.node was bound to our target, so we can restore it later
|
|
this.target_type; // Class of the target object
|
|
|
|
// For displaying bounds, we rely on our own jit.gl.mesh cube. It's simpler than keeping track of each objects draw_bounds attribute, and we can customize its appearance.
|
|
this.show_bounds = show_bounds;
|
|
this.cube_matrix = new JitterMatrix(3, "float32", 8);
|
|
const cube_points = new Float32Array([-1., -1., 1., 1., -1., 1., 1., 1., 1., -1., 1., 1., -1., -1., -1., 1., -1., -1., 1., 1., -1., -1., 1., -1.]);
|
|
this.cube_matrix.copyarraytomatrix(cube_points);
|
|
this.cube_indexes = new JitterMatrix(1, "char", 24);
|
|
const cube_point_indexes = new Uint8Array([0, 1, 1, 2, 2, 3, 3, 0, 0, 4, 1, 5, 2, 6, 3, 7, 4, 5, 5, 6, 6, 7, 7, 4]);
|
|
this.cube_indexes.copyarraytomatrix(cube_point_indexes);
|
|
this.bounds = new JitterObject("jit.gl.mesh");
|
|
this.bounds.drawto = drawto;
|
|
this.bounds.draw_mode = "lines";
|
|
this.bounds.vertex_matrix(this.cube_matrix.name);
|
|
this.bounds.index_matrix(this.cube_indexes.name);
|
|
this.bounds.anim = this.pitch_node.name;
|
|
this.bounds.enable = 0;
|
|
|
|
this.dummy_node = new JitterObject("jit.anim.node"); // Only used for quat to euler conversion
|
|
}
|
|
|
|
// Taking control over a new target
|
|
control(obj_name, obj_type) {
|
|
if (obj_name && !this.camera_target.name) {
|
|
error("No camera defined. Cannot control object.\n");
|
|
return false;
|
|
}
|
|
|
|
// Make sure the requested object is a jit.anim.node or a controllable object (a jit.gl object with an anim attribute)
|
|
let new_target;
|
|
if (obj_name != undefined) {
|
|
const p = new JitterObject("jit.proxy");
|
|
p.name = obj_name;
|
|
if (p.class === "jit_anim_node") {
|
|
new_target = obj_name;
|
|
} else if (p.class && is_controllable(p.class)) {
|
|
new_target = p.send("getanim");
|
|
};
|
|
this.target_type = p.class;
|
|
p.freepeer();
|
|
}
|
|
|
|
if (
|
|
new_target != undefined &&
|
|
(this.target.name != "" || this.target.name != new_target)
|
|
) {
|
|
// New object to target
|
|
this.control_obj_type = obj_type;
|
|
if (this.target.name != "") {
|
|
// If there is already a targeted object, we unbind it and make it preserve its transform
|
|
const world_pos = this.target.send("getworldpos");
|
|
const world_quat = this.target.send("getworldquat");
|
|
const world_scale = this.target.send("getworldscale");
|
|
|
|
if (this.last_target_anim_node) {
|
|
this.target.send("anim", this.last_target_anim_node);
|
|
} else {
|
|
this.target.send("anim");
|
|
}
|
|
this.target.send("anim_reset");
|
|
|
|
const local = this.world_to_local(this.last_target_anim_node, world_pos, world_quat);
|
|
this.target.send("position", local.pos);
|
|
this.target.send("quat", local.quat);
|
|
this.target.send("scale", world_scale);
|
|
}
|
|
|
|
this.target.name = new_target; // Bind to new target
|
|
this.reset(); // Reset controller anim nodes
|
|
|
|
// Get target transform
|
|
const world_pos = this.target.send("getworldpos");
|
|
const world_quat = this.target.send("getworldquat");
|
|
const world_scale = this.target.send("getworldscale");
|
|
|
|
this.dummy_node.quat = world_quat;
|
|
const world_rotatexyz = this.dummy_node.rotatexyz;
|
|
|
|
// Apply it to our control nodes
|
|
this.main_node.position = world_pos;
|
|
this.main_node.rotatexyz = [0, world_rotatexyz[1], 0];
|
|
this.pitch_node.rotatexyz = [world_rotatexyz[0], 0, world_rotatexyz[2]];
|
|
this.pitch_node.scale = world_scale;
|
|
|
|
// And select the new target
|
|
this.last_target_anim_node = this.target.send("getanim");
|
|
this.target.send("anim_reset");
|
|
this.target.send("anim", this.pitch_node.name);
|
|
this.target.send("update_node"); //Sometimes targetting an anim.node parent with anim.node children doesn't work (children don't get their transform updated). This solves it for some reason.
|
|
|
|
// Apply specific rules depending on if controlling the camera or an object
|
|
if (this.control_obj_type == "cam") {
|
|
this.main_node.movemode = "local";
|
|
this.main_node.turnmode = "local";
|
|
this.pitch_node.turnmode = "parent";
|
|
this.set_flymode(this.flymode);
|
|
} else {
|
|
this.flymode_applyed = false;
|
|
if (controlmode == 0) {
|
|
// When controlling an object, we convert the translation vector
|
|
// from screen space to world space in this.move
|
|
// So we need the cam base matrix
|
|
this.main_node.movemode = "world";
|
|
this.main_node.turnmode = "world";
|
|
this.pitch_node.turnmode = "world";
|
|
this.get_cam_base_matrix();
|
|
} else {
|
|
this.main_node.movemode = "local";
|
|
this.main_node.turnmode = "local";
|
|
this.pitch_node.turnmode = "parent";
|
|
}
|
|
}
|
|
|
|
} else if (obj_name == undefined && this.target.name != "") {
|
|
// No target, unbinding previous target
|
|
const world_pos = this.target.send("getworldpos");
|
|
const world_quat = this.target.send("getworldquat");
|
|
const world_scale = this.target.send("getworldscale");
|
|
|
|
if (this.last_target_anim_node) {
|
|
this.target.send("anim", this.last_target_anim_node);
|
|
} else {
|
|
this.target.send("anim");
|
|
}
|
|
this.target.send("anim_reset");
|
|
|
|
const local = this.world_to_local(this.last_target_anim_node, world_pos, world_quat);
|
|
this.target.send("position", local.pos);
|
|
this.target.send("quat", local.quat);
|
|
this.target.send("scale", world_scale);
|
|
|
|
this.last_target_anim_node = null;
|
|
this.target.name = "";
|
|
}
|
|
this.set_bounds();
|
|
outlet(0, "control", obj_name, this.target.name);
|
|
return true;
|
|
}
|
|
|
|
camera(obj_name) {
|
|
if (obj_name === this.camera_target.name) return;
|
|
// Is it a camera or a node?
|
|
const proxy = new JitterObject("jit.proxy");
|
|
proxy.name = obj_name;
|
|
const proxy_class = proxy.class;
|
|
let target = null;
|
|
if (proxy_class == "jit_anim_node") {
|
|
// If user passed an anim.node as camera, we use it directly.
|
|
target = obj_name;
|
|
} else if (proxy_class == "jit_gl_camera") {
|
|
// If it's a jit_gl_camera, we get its world transform from its parent node (whether it is implicit or user-defined),
|
|
const cam_anim = new JitterObject("jit.proxy");
|
|
cam_anim.name = proxy.send("getanim");
|
|
const transform = cam_anim.send("getworldtransform");
|
|
cam_anim.freepeer();
|
|
// Then we attach our camera_node_implicit to the camera and restore its world transform
|
|
proxy.send("anim_reset");
|
|
proxy.send("anim", this.camera_node_implicit.name);
|
|
this.camera_node_implicit.transform = transform;
|
|
target = this.camera_node_implicit.name;
|
|
}
|
|
if (target) {
|
|
this.camera_node.name = target;
|
|
this.camera_node.send("animmode", "world");
|
|
// this.get_cam_base_matrix();
|
|
this.camera_target.name = proxy.name;
|
|
this.camera_target.class = proxy.class;
|
|
this.camera_target.anim = proxy.anim;
|
|
camera = target;
|
|
} else {
|
|
this.unbind_camera();
|
|
}
|
|
proxy.freepeer();
|
|
}
|
|
|
|
unbind_camera() {
|
|
if (this.camera_target.name) {
|
|
if (this.camera_target.class === "jit_anim_node") {
|
|
// If user passed an anim node as camera target, we just unbind our proxy from it
|
|
this.camera_node.name = "";
|
|
} else if (this.camera_target.class === "jit_gl_camera") {
|
|
// If it was a camera, we set it back as it was, but with the current transform
|
|
const transform = this.camera_node.send("getworldtransform");
|
|
const cam = new JitterObject("jit.proxy");
|
|
cam.name = this.camera_target.name;
|
|
cam.send("anim");
|
|
cam.send("anim_reset");
|
|
const cam_anim = new JitterObject("jit.proxy");
|
|
cam_anim.name = cam.send("getanim");
|
|
cam_anim.send("transform", transform);
|
|
cam.freepeer();
|
|
cam_anim.freepeer();
|
|
}
|
|
this.control();
|
|
this.camera_target.name = "";
|
|
this.camera_target.class = "";
|
|
this.camera_target.anim = "";
|
|
camera = "";
|
|
}
|
|
}
|
|
|
|
get_cam_base_matrix() {
|
|
if (this.camera_node.name != "") {
|
|
this.cam_direction = new FF_Vector(this.camera_node.send("getdirection"));
|
|
this.cam_direction.y = 0;
|
|
this.cam_direction.normalize();
|
|
this.cam_right = this.cam_direction.crossNew(this.world_up);
|
|
this.cam_right.normalize();
|
|
// this.cam_right = normalize(cross(this.cam_direction, this.world_up));
|
|
this.cam_up = this.cam_right.crossNew(this.cam_direction);
|
|
this.cam_up.normalize();
|
|
// this.cam_up = normalize(cross(this.cam_right, this.cam_direction));
|
|
this.camera_base_matrix = [
|
|
this.cam_right,
|
|
this.cam_up,
|
|
this.cam_direction,
|
|
];
|
|
}
|
|
}
|
|
|
|
move(x, y, z) {
|
|
let translat_vec = [x, y, z];
|
|
if (this.control_obj_type == "obj" && controlmode == 0) {
|
|
this.get_cam_base_matrix();
|
|
let cam_x_rot = this.camera_node.send("getrotatexyz")[0];
|
|
// Inverse translation direction if cam is upside down
|
|
if (cam_x_rot < -90 || cam_x_rot > 90) {
|
|
x *= -1;
|
|
z *= -1;
|
|
}
|
|
translat_vec = multiplyMatrixVector(this.camera_base_matrix, new FF_Vector(x, 0, -z));
|
|
}
|
|
this.main_drive.move(translat_vec[0], y, translat_vec[2]);
|
|
}
|
|
|
|
turn(x, y, z) {
|
|
let rot_vec = [x, y, z];
|
|
if (this.control_obj_type == "obj") {
|
|
this.get_cam_base_matrix();
|
|
rot_vec = multiplyMatrixVector(this.camera_base_matrix, new FF_Vector(-x, 0, 0));
|
|
rot_vec[1] = -y;
|
|
}
|
|
if (this.flymode && this.control_obj_type == "cam") {
|
|
// When flymode is enabled, we apply all rotations to the main_node
|
|
// so that the cam can move toward the direction it is pointing to
|
|
this.main_drive.turn(rot_vec[0], rot_vec[1], 0);
|
|
this.pitch_drive.turn(0, 0, 0);
|
|
} else {
|
|
this.main_drive.turn(0, rot_vec[1], 0);
|
|
this.pitch_drive.turn(rot_vec[0], 0, rot_vec[2]);
|
|
}
|
|
}
|
|
|
|
elev(y) {
|
|
this.main_drive.move([0, y, 0]);
|
|
}
|
|
|
|
set_flymode(v) {
|
|
// When enabled, the camera can move toward any direction it faces.
|
|
// When disabled, it should not move on the world y axis ("walk mode") unless explicitely sending move messages with non-null Y component.
|
|
if (v == 1) {
|
|
this.flymode = true;
|
|
} else {
|
|
this.flymode = false;
|
|
}
|
|
this.apply_flymode();
|
|
}
|
|
|
|
apply_flymode() {
|
|
if (this.control_obj_type == "cam") {
|
|
if (this.flymode) {
|
|
// When enabling flymode, we move all rotations to main_node
|
|
this.main_node.rotatexyz = [
|
|
this.pitch_node.rotatexyz[0],
|
|
this.main_node.rotatexyz[1],
|
|
0,
|
|
];
|
|
this.pitch_node.anim_reset();
|
|
this.flymode_applyed = true;
|
|
} else if (this.flymode_applyed) {
|
|
// And we revert when disabling
|
|
let rotatexyz = this.main_node.rotatexyz;
|
|
this.pitch_node.anim_reset();
|
|
this.pitch_node.rotatexyz = [rotatexyz[0], 0, 0];
|
|
this.main_node.rotatexyz = [0, rotatexyz[1], rotatexyz[2]];
|
|
this.flymode_applyed = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
set_drawto(v) {
|
|
this.main_drive.drawto = v;
|
|
this.pitch_drive.drawto = v;
|
|
this.bounds.drawto = v;
|
|
}
|
|
|
|
set_ease(v) {
|
|
this.ease = v;
|
|
this.main_drive.ease = this.ease;
|
|
this.pitch_drive.ease = this.ease;
|
|
}
|
|
|
|
reset() {
|
|
this.main_node.anim_reset();
|
|
this.pitch_node.anim_reset();
|
|
}
|
|
|
|
resync() {
|
|
if (this.target.name != "") {
|
|
this.control(this.target.name, this.control_obj_type);
|
|
}
|
|
}
|
|
|
|
set_show_bounds(v) {
|
|
this.show_bounds = v ? 1 : 0;
|
|
this.set_bounds();
|
|
}
|
|
|
|
set_bounds() {
|
|
if (this.show_bounds && this.control_obj_type === "obj") {
|
|
switch (this.target_type) {
|
|
case "jit_anim_node":
|
|
this.bounds.color = [1, 0, 1, 1];
|
|
break;
|
|
default:
|
|
this.bounds.color = [1, 1, 1, 1];
|
|
break;
|
|
}
|
|
this.bounds.enable = 1;
|
|
} else {
|
|
this.bounds.enable = 0;
|
|
}
|
|
}
|
|
|
|
world_to_local(anim_node_name, world_pos, world_quat) {
|
|
if (!anim_node_name) {
|
|
return { pos: world_pos, quat: world_quat };
|
|
}
|
|
const parent = new JitterObject("jit.proxy");
|
|
parent.name = anim_node_name;
|
|
const pos = parent.send("worldtolocal", world_pos);
|
|
const quat = parent.send("worldtolocal_quat", world_quat);
|
|
parent.freepeer();
|
|
return { pos, quat };
|
|
}
|
|
|
|
destroy() {
|
|
if (this.target.name != "") {
|
|
this.target.send("anim");
|
|
this.target.send("transform", this.pitch_node.worldtransform);
|
|
}
|
|
this.camera_node_implicit.freepeer();
|
|
this.main_node.freepeer();
|
|
this.main_drive.freepeer();
|
|
this.pitch_node.freepeer();
|
|
this.pitch_drive.freepeer();
|
|
this.target.freepeer();
|
|
this.cube_indexes.freepeer();
|
|
this.cube_matrix.freepeer();
|
|
this.bounds.freepeer();
|
|
this.dummy_node.freepeer();
|
|
}
|
|
}
|
|
|
|
loadbang();
|
|
|
|
// Select the object to use as basis for view-space transforms
|
|
function set_camera(name) {
|
|
camera = name;
|
|
if (world_bangs) {
|
|
ctlr.camera(name);
|
|
}
|
|
}
|
|
|
|
// Select which object to control in view-space
|
|
function control(obj_name) {
|
|
ctlr.control(obj_name, "obj");
|
|
}
|
|
|
|
// Select which camera to control
|
|
function control_camera(obj_name) {
|
|
if (obj_name !== undefined) {
|
|
const answer = ctlr.control(obj_name, "cam");
|
|
// if (answer) do_show_bounds(0);
|
|
}
|
|
}
|
|
|
|
// Output from the second outlet a list of all controllable jit.gl and jit.anim.node objects in the entire patcher hierarchy
|
|
function controllable() {
|
|
controllable_objects = [];
|
|
top_level_patcher.applydeepif(
|
|
add_to_controllable_list,
|
|
is_controllable_applydeepif
|
|
);
|
|
outlet(1, "controllable");
|
|
for (let obj of controllable_objects) {
|
|
outlet(1, obj.maxclass, obj.getattr("name"));
|
|
}
|
|
outlet(1, "done");
|
|
}
|
|
|
|
function add_to_controllable_list(obj) {
|
|
controllable_objects.push(obj);
|
|
}
|
|
add_to_controllable_list.local = 1;
|
|
|
|
function is_controllable_applydeepif(obj) {
|
|
return (
|
|
obj.maxclass == "jit.anim.node" ||
|
|
is_controllable(obj.maxclass.replaceAll(".", "_"))
|
|
);
|
|
}
|
|
is_controllable_applydeepif.local = 1;
|
|
|
|
function resync() {
|
|
ctlr.resync();
|
|
}
|
|
|
|
function reset() {
|
|
ctlr.reset();
|
|
}
|
|
|
|
function move(x, y, z) {
|
|
ctlr.move(x, y, z);
|
|
}
|
|
|
|
function turn(x, y, z) {
|
|
ctlr.turn(x, y, z);
|
|
}
|
|
|
|
function elev(v) {
|
|
ctlr.elev(v);
|
|
}
|
|
|
|
function anim_move(x, y, z, t) {
|
|
ctlr.move(x, y, z);
|
|
}
|
|
function anim_turn(x, y, z, t) {
|
|
ctlr.turn(x, y, z);
|
|
}
|
|
|
|
function set_ease(v) {
|
|
ctlr.set_ease(v);
|
|
ease = v;
|
|
}
|
|
set_ease.local = 1;
|
|
|
|
function set_flymode(v) {
|
|
flymode = v == undefined ? !flymode : v == 1; // If flymode with no argument is provided, act as a toggle
|
|
ctlr.set_flymode(flymode);
|
|
}
|
|
set_flymode.local = 1;
|
|
|
|
function set_show_bounds(v) {
|
|
show_bounds = v == true;
|
|
ctlr.set_show_bounds(show_bounds);
|
|
}
|
|
set_show_bounds.local = 1;
|
|
|
|
function set_controlmode(v) {
|
|
const new_val = v > 0 ? 1 : 0;
|
|
if (controlmode === new_val) return;
|
|
controlmode = new_val;
|
|
ctlr.control(ctlr.target.name, ctlr.control_obj_type);
|
|
}
|
|
|
|
function bang() {
|
|
outlet(0, ctlr.pitch_node.worldtransform);
|
|
}
|
|
|
|
function loadbang() {
|
|
if (!top_level_patcher) {
|
|
top_level_patcher = get_top_level_patcher();
|
|
ctlr = new Controller(drawto);
|
|
}
|
|
}
|
|
|
|
function notifydeleted() {
|
|
control();
|
|
set_camera();
|
|
ctlr.destroy();
|
|
ctx_finder.dispose();
|
|
if (ctx_lstnr) ctx_lstnr.freepeer();
|
|
// implicit_tracker.freepeer();
|
|
}
|
|
|
|
/////////////////////////////////////////////
|
|
// HELPER METHODS
|
|
/////////////////////////////////////////////
|
|
|
|
function is_controllable(obj_class) {
|
|
// Using jit.proxy syntax (ie 'jit_gl_mesh' and not 'jit.gl.mesh')
|
|
return ANIMABLE_GL_OBJECTS.includes(obj_class);
|
|
}
|
|
is_controllable.local = 1;
|
|
|
|
function get_top_level_patcher() {
|
|
let prev = 0;
|
|
let owner = this.patcher.box;
|
|
while (owner) {
|
|
prev = owner;
|
|
owner = owner.patcher.box;
|
|
}
|
|
return prev ? prev.patcher : this.patcher;
|
|
}
|
|
get_top_level_patcher.local = 1;
|
|
|
|
/////////////////////////////////////////////
|
|
// MATHS
|
|
/////////////////////////////////////////////
|
|
|
|
function multiplyMatrixVector(matrix, vector) {
|
|
return [
|
|
matrix[0].dot(vector),
|
|
matrix[1].dot(vector),
|
|
matrix[2].dot(vector),
|
|
];
|
|
}
|
|
multiplyMatrixVector.local = 1;
|
|
|
|
/////////////////////////////////////////////
|
|
// GL Context
|
|
/////////////////////////////////////////////
|
|
let ctx_root;
|
|
let ctx_lstnr;
|
|
function set_root(new_root) {
|
|
ctx_root = new_root;
|
|
if (ctx_lstnr) {
|
|
ctx_lstnr.freepeer();
|
|
ctw_lstnr = null;
|
|
}
|
|
ctx_lstnr = new JitterListener(new_root, ctx_callback);
|
|
}
|
|
set_root.local = 1;
|
|
|
|
function ctx_callback(event) {
|
|
switch (event.eventname) {
|
|
case "swap": case "draw":
|
|
if (!world_bangs) {
|
|
// First world bang: world initialized, we can set the camera
|
|
world_bangs = true;
|
|
set_camera(camera);
|
|
}
|
|
break;
|
|
default:
|
|
// post(event.args); post();
|
|
break;
|
|
}
|
|
}
|
|
ctx_callback.local = 1;
|
|
|
|
function dosetdrawto(arg) {
|
|
if (arg === drawto || !arg) {
|
|
// bounce
|
|
return;
|
|
}
|
|
|
|
drawto = arg;
|
|
ctlr.set_drawto(drawto);
|
|
ctx_proxy.name = drawto;
|
|
|
|
}
|
|
dosetdrawto.local = 1;
|