mirror of
https://github.com/JannisX11/blockbench.git
synced 2024-11-27 04:21:46 +08:00
1555 lines
44 KiB
JavaScript
1555 lines
44 KiB
JavaScript
//Actions
|
|
function origin2geometry() {
|
|
|
|
if (Format.bone_rig && Group.selected) {
|
|
Undo.initEdit({group: Group.selected})
|
|
|
|
if (!Group.selected || Group.selected.children.length === 0) return;
|
|
var position = [0, 0, 0]
|
|
Group.selected.children.forEach(function(obj) {
|
|
if (obj.type === 'cube') {
|
|
position[0] += obj.from[0] + obj.size(0)/2
|
|
position[1] += obj.from[1] + obj.size(1)/2
|
|
position[2] += obj.from[2] + obj.size(2)/2
|
|
}
|
|
})
|
|
position.forEach(function(p, pi) {
|
|
position[pi] = p / Group.selected.children.length
|
|
})
|
|
Group.selected.origin.V3_set(position)
|
|
|
|
} else if (Cube.selected) {
|
|
Undo.initEdit({elements: Cube.selected})
|
|
|
|
var center = getSelectionCenter();
|
|
var original_center = center.slice();
|
|
|
|
Cube.selected.forEach(cube => {
|
|
if (Format.bone_rig && cube.parent instanceof Group) {
|
|
var v = new THREE.Vector3().fromArray(original_center);
|
|
cube.parent.mesh.worldToLocal(v);
|
|
v.x += cube.parent.origin[0];
|
|
v.y += cube.parent.origin[1];
|
|
v.z += cube.parent.origin[2];
|
|
center = v.toArray();
|
|
cube.transferOrigin(center)
|
|
} else {
|
|
cube.transferOrigin(original_center)
|
|
}
|
|
})
|
|
}
|
|
Canvas.updatePositions()
|
|
Undo.finishEdit('origin to geometry')
|
|
}
|
|
function getSelectionCenter(all = false) {
|
|
if (Group.selected && selected.length == 0 && !all) {
|
|
let vec = THREE.fastWorldPosition(Group.selected.mesh, new THREE.Vector3());
|
|
return vec.toArray();
|
|
}
|
|
var center = [0, 0, 0]
|
|
var i = 0;
|
|
let items = (selected.length == 0 || all) ? elements : selected;
|
|
items.forEach(obj => {
|
|
if (obj.getWorldCenter) {
|
|
var pos = obj.getWorldCenter();
|
|
center[0] += pos.x
|
|
center[1] += pos.y
|
|
center[2] += pos.z
|
|
}
|
|
})
|
|
if (items.length) {
|
|
for (var i = 0; i < 3; i++) {
|
|
center[i] = center[i] / items.length
|
|
}
|
|
}
|
|
if (!Format.centered_grid) {
|
|
center.V3_add(8, 8, 8)
|
|
}
|
|
return center;
|
|
}
|
|
//Canvas Restriction
|
|
function isInBox(val) {
|
|
return !(Format.canvas_limit && !settings.deactivate_size_limit.value) || (val < 32 && val > -16)
|
|
}
|
|
function limitToBox(val, inflate) {
|
|
if (typeof inflate != 'number') inflate = 0;
|
|
if (!(Format.canvas_limit && !settings.deactivate_size_limit.value)) {
|
|
return val;
|
|
} else if (val + inflate > 32) {
|
|
return 32 - inflate;
|
|
} else if (val - inflate < -16) {
|
|
return -16 + inflate;
|
|
} else {
|
|
return val;
|
|
}
|
|
}
|
|
//Movement
|
|
function moveCubesRelative(difference, index, event) { //Multiple
|
|
if (!quad_previews.current || !Cube.selected.length) {
|
|
return;
|
|
}
|
|
var _has_groups = Format.bone_rig && Group.selected && Group.selected.matchesSelection() && Toolbox.selected.transformerMode == 'translate';
|
|
|
|
Undo.initEdit({elements: Cube.selected, outliner: _has_groups})
|
|
var axes = []
|
|
// < >
|
|
// PageUpDown
|
|
// ^ v
|
|
var facing = quad_previews.current.getFacingDirection()
|
|
var height = quad_previews.current.getFacingHeight()
|
|
switch (facing) {
|
|
case 'north': axes = [0, 2, 1]; break;
|
|
case 'south': axes = [0, 2, 1]; break;
|
|
case 'west': axes = [2, 0, 1]; break;
|
|
case 'east': axes = [2, 0, 1]; break;
|
|
}
|
|
|
|
if (height !== 'middle') {
|
|
if (index === 1) {
|
|
index = 2
|
|
} else if (index === 2) {
|
|
index = 1
|
|
}
|
|
}
|
|
if (facing === 'south' && (index === 0 || index === 1)) difference *= -1
|
|
if (facing === 'west' && index === 0) difference *= -1
|
|
if (facing === 'east' && index === 1) difference *= -1
|
|
if (index === 2 && height !== 'down') difference *= -1
|
|
if (index === 1 && height === 'up') difference *= -1
|
|
|
|
if (event) {
|
|
difference *= canvasGridSize(event.shiftKey, event.ctrlOrCmd);
|
|
}
|
|
|
|
moveElementsInSpace(difference, axes[index]);
|
|
updateSelection();
|
|
|
|
Undo.finishEdit('move')
|
|
}
|
|
//Rotate
|
|
function rotateSelected(axis, steps) {
|
|
if (!Cube.selected.length) return;
|
|
Undo.initEdit({elements: Cube.selected});
|
|
if (!steps) steps = 1
|
|
var origin = [8, 8, 8]
|
|
if (Group.selected && Format.bone_rig) {
|
|
origin = Group.selected.origin.slice()
|
|
} else if (Format.centered_grid) {
|
|
origin = [0, 0, 0]
|
|
} else {
|
|
origin = Cube.selected[0].origin.slice()
|
|
}
|
|
Cube.selected.forEach(function(obj) {
|
|
obj.roll(axis, steps, origin)
|
|
})
|
|
updateSelection()
|
|
Undo.finishEdit('rotate')
|
|
}
|
|
//Mirror
|
|
function mirrorSelected(axis) {
|
|
if (Modes.animate && Timeline.selected.length) {
|
|
|
|
Undo.initEdit({keyframes: Timeline.selected})
|
|
for (var kf of Timeline.selected) {
|
|
kf.flip(axis)
|
|
}
|
|
Undo.finishEdit('flipped keyframes');
|
|
updateKeyframeSelection();
|
|
Animator.preview();
|
|
|
|
} else if (Modes.edit && selected.length) {
|
|
Undo.initEdit({elements: selected, outliner: Format.bone_rig})
|
|
var center = Format.centered_grid ? 0 : 8;
|
|
if (Format.bone_rig) {
|
|
if (Group.selected && Group.selected.matchesSelection()) {
|
|
function flipGroup(group) {
|
|
if (group.type === 'group') {
|
|
for (var i = 0; i < 3; i++) {
|
|
if (i === axis) {
|
|
group.origin[i] *= -1
|
|
} else {
|
|
group.rotation[i] *= -1
|
|
}
|
|
}
|
|
if (axis == 0 && group.name.includes('right')) {
|
|
group.name = group.name.replace(/right/g, 'left').replace(/2/, '');
|
|
} else if (axis == 0 && group.name.includes('left')) {
|
|
group.name = group.name.replace(/left/g, 'right').replace(/2/, '');
|
|
}
|
|
}
|
|
Canvas.updateAllBones([group]);
|
|
}
|
|
flipGroup(Group.selected)
|
|
Group.selected.forEachChild(flipGroup)
|
|
}
|
|
}
|
|
selected.forEach(function(obj) {
|
|
obj.flip(axis, center, false)
|
|
if (Project.box_uv && obj instanceof Cube && axis === 0) {
|
|
obj.shade = !obj.shade
|
|
Canvas.updateUV(obj)
|
|
}
|
|
})
|
|
updateSelection()
|
|
Undo.finishEdit('mirror')
|
|
}
|
|
}
|
|
|
|
const Vertexsnap = {
|
|
step1: true,
|
|
vertexes: new THREE.Object3D(),
|
|
vertexed_cubes: [],
|
|
hovering: false,
|
|
createVertexGizmo(cube, vec, id) {
|
|
//Each vertex needs it's own material for hovering
|
|
let outline_color = '0x'+CustomTheme.data.colors.accent.replace('#', '')
|
|
let material = new THREE.MeshBasicMaterial({color: parseInt(outline_color)})
|
|
let mesh = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), material)
|
|
|
|
let pos = mesh.position.copy(vec)
|
|
pos.applyMatrix4(cube.mesh.matrixWorld)
|
|
if (!Format.centered_grid) {
|
|
pos.addScalar(8)
|
|
}
|
|
mesh.rotation.copy(cube.mesh.rotation)
|
|
if (id == 100) {
|
|
mesh.rotation.y += Math.PI/4;
|
|
}
|
|
mesh.cube = cube
|
|
mesh.isVertex = true
|
|
mesh.vertex_id = id
|
|
mesh.material.transparent = true;
|
|
mesh.renderOrder = 999;
|
|
Vertexsnap.vertexes.add(mesh)
|
|
},
|
|
addVertices: function(cube) {
|
|
if (Vertexsnap.vertexed_cubes.includes(cube)) return;
|
|
if (cube.visibility === false) return;
|
|
|
|
$('#preview').get(0).removeEventListener("mousemove", Vertexsnap.hoverCanvas)
|
|
$('#preview').get(0).addEventListener("mousemove", Vertexsnap.hoverCanvas)
|
|
|
|
var o_vertices = cube.mesh.geometry.vertices
|
|
cube.mesh.updateMatrixWorld()
|
|
o_vertices.forEach(function(v, id) {
|
|
Vertexsnap.createVertexGizmo(cube, v, id)
|
|
})
|
|
Vertexsnap.createVertexGizmo(cube, new THREE.Vector3(), 100)
|
|
Vertexsnap.vertexed_cubes.push(cube)
|
|
Vertexsnap.updateVertexSize()
|
|
},
|
|
removeVertexes: function() {
|
|
var i = Vertexsnap.vertexes.children.length
|
|
while (i >= 0) {
|
|
Vertexsnap.vertexes.remove(Vertexsnap.vertexes.children[i])
|
|
i--;
|
|
}
|
|
Vertexsnap.vertexed_cubes = []
|
|
$('#preview').get(0).removeEventListener("mousemove", Vertexsnap.hoverCanvas)
|
|
},
|
|
hoverCanvas: function(event) {
|
|
if (Vertexsnap.hovering) {
|
|
Vertexsnap.vertexes.children.forEach(function(v) {
|
|
if (v.type === 'Line') {
|
|
Vertexsnap.vertexes.remove(v)
|
|
} else {
|
|
v.material.color.set(parseInt('0x'+CustomTheme.data.colors.accent.replace('#', '')))
|
|
v.material.depthTest = true;
|
|
}
|
|
})
|
|
}
|
|
let data = Canvas.raycast(event)
|
|
if (!data || !data.vertex) {
|
|
Blockbench.setStatusBarText()
|
|
return;
|
|
}
|
|
var vertex = data.vertex
|
|
vertex.material.color.g = 1
|
|
Vertexsnap.hovering = true
|
|
|
|
vertex.material.depthTest = false;
|
|
|
|
if (Vertexsnap.step1 === false) {
|
|
//Line
|
|
var geometry = new THREE.Geometry();
|
|
geometry.vertices.push(Vertexsnap.vertex_pos);
|
|
geometry.vertices.push(vertex.position);
|
|
var line = new THREE.Line(geometry, Vertexsnap.lineMaterial);
|
|
line.renderOrder = 900
|
|
Vertexsnap.vertexes.add(line)
|
|
//Measure
|
|
var diff = new THREE.Vector3().copy(Vertexsnap.vertex_pos)
|
|
diff.sub(vertex.position)
|
|
Blockbench.setStatusBarText(tl('status_bar.vertex_distance', [trimFloatNumber(diff.length())] ))
|
|
}
|
|
},
|
|
select: function() {
|
|
Vertexsnap.removeVertexes()
|
|
Cube.selected.forEach(function(obj) {
|
|
Vertexsnap.addVertices(obj)
|
|
})
|
|
if (Cube.selected.length) {
|
|
$('#preview').css('cursor', (Vertexsnap.step1 ? 'copy' : 'alias'))
|
|
}
|
|
Vertexsnap.lineMaterial = Canvas.outlineMaterial.clone()
|
|
Vertexsnap.lineMaterial.depthTest = false
|
|
},
|
|
canvasClick: function(data) {
|
|
if (!data || !data.vertex) return;
|
|
|
|
if (Vertexsnap.step1) {
|
|
Vertexsnap.step1 = false
|
|
Vertexsnap.vertex_pos = data.vertex.position
|
|
Vertexsnap.vertex_id = data.vertex.vertex_id
|
|
Vertexsnap.cubes = Cube.selected.slice()
|
|
Vertexsnap.removeVertexes()
|
|
$('#preview').css('cursor', (Vertexsnap.step1 ? 'copy' : 'alias'))
|
|
|
|
} else {
|
|
Vertexsnap.snap(data)
|
|
$('#preview').css('cursor', (Vertexsnap.step1 ? 'copy' : 'alias'))
|
|
}
|
|
Blockbench.setStatusBarText()
|
|
},
|
|
snap: function(data) {
|
|
Undo.initEdit({elements: Vertexsnap.cubes})
|
|
|
|
let mode = BarItems.vertex_snap_mode.get()
|
|
|
|
if (Vertexsnap.vertex_id === 100) {
|
|
|
|
Vertexsnap.cubes.forEach(function(cube) {
|
|
let vec = new THREE.Vector3().copy(data.vertex.position)
|
|
|
|
if (Format.bone_rig && cube.parent instanceof Group && cube.mesh.parent) {
|
|
cube.mesh.parent.worldToLocal(vec);
|
|
}
|
|
let vec_array = vec.toArray()
|
|
vec_array.V3_add(cube.parent.origin);
|
|
cube.transferOrigin(vec_array)
|
|
})
|
|
} else {
|
|
|
|
var global_delta = data.vertex.position
|
|
global_delta.sub(Vertexsnap.vertex_pos)
|
|
|
|
if (mode === 'scale') {
|
|
//Scale
|
|
|
|
var m;
|
|
switch (Vertexsnap.vertex_id) {
|
|
case 0: m=[ 1,1,1 ]; break;
|
|
case 1: m=[ 1,1,0 ]; break;
|
|
case 2: m=[ 1,0,1 ]; break;
|
|
case 3: m=[ 1,0,0 ]; break;
|
|
case 4: m=[ 0,1,0 ]; break;
|
|
case 5: m=[ 0,1,1 ]; break;
|
|
case 6: m=[ 0,0,0 ]; break;
|
|
case 7: m=[ 0,0,1 ]; break;
|
|
}
|
|
|
|
Vertexsnap.cubes.forEach(function(obj) {
|
|
var q = obj.mesh.getWorldQuaternion(new THREE.Quaternion()).inverse()
|
|
var cube_pos = new THREE.Vector3().copy(global_delta).applyQuaternion(q)
|
|
|
|
for (i=0; i<3; i++) {
|
|
if (m[i] === 1) {
|
|
obj.to[i] = limitToBox(obj.to[i] + cube_pos.getComponent(i), obj.inflate)
|
|
} else {
|
|
obj.from[i] = limitToBox(obj.from[i] + cube_pos.getComponent(i), -obj.inflate)
|
|
}
|
|
}
|
|
if (Project.box_uv && obj.visibility) {
|
|
Canvas.updateUV(obj)
|
|
}
|
|
})
|
|
} else if (mode === 'move') {
|
|
Vertexsnap.cubes.forEach(function(obj) {
|
|
var cube_pos = new THREE.Vector3().copy(global_delta)
|
|
|
|
if (Format.bone_rig && obj.parent instanceof Group && obj.mesh.parent) {
|
|
var q = obj.mesh.parent.getWorldQuaternion(new THREE.Quaternion()).inverse();
|
|
cube_pos.applyQuaternion(q);
|
|
}
|
|
if (Format.rotate_cubes) {
|
|
obj.origin.V3_add(cube_pos);
|
|
}
|
|
var in_box = obj.moveVector(cube_pos.toArray());
|
|
if (!in_box && Format.canvas_limit && !settings.deactivate_size_limit.value) {
|
|
Blockbench.showMessageBox({translateKey: 'canvas_limit_error'})
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
Vertexsnap.removeVertexes()
|
|
Canvas.updateAllPositions()
|
|
Undo.finishEdit('vertex snap')
|
|
Vertexsnap.step1 = true
|
|
},
|
|
updateVertexSize: function() {
|
|
if (!Preview.selected) return;
|
|
Vertexsnap.vertexes.children.forEach(function(v,i) {
|
|
let scale = Preview.selected.calculateControlScale(v.position) * 0.6;
|
|
v.scale.set(scale, scale, scale);
|
|
})
|
|
}
|
|
}
|
|
Blockbench.on('update_camera_position resize_window', e => {
|
|
if (Toolbox && Toolbox.selected.id == 'vertex_snap_tool') {
|
|
Vertexsnap.updateVertexSize();
|
|
}
|
|
})
|
|
//Scale
|
|
function scaleAll(save, size) {
|
|
if (save === true) {
|
|
hideDialog()
|
|
}
|
|
if (size === undefined) {
|
|
size = $('#model_scale_label').val()
|
|
}
|
|
var origin = [
|
|
parseFloat($('#scaling_origin_x').val())||0,
|
|
parseFloat($('#scaling_origin_y').val())||0,
|
|
parseFloat($('#scaling_origin_z').val())||0,
|
|
]
|
|
var overflow = [];
|
|
selected.forEach(function(obj) {
|
|
obj.autouv = 0;
|
|
origin.forEach(function(ogn, i) {
|
|
if ($('#model_scale_'+getAxisLetter(i)+'_axis').is(':checked')) {
|
|
|
|
if (obj.from) {
|
|
obj.from[i] = (obj.before.from[i] - obj.inflate - ogn) * size;
|
|
if (obj.from[i] + ogn > 32 || obj.from[i] + ogn < -16) overflow.push(obj);
|
|
obj.from[i] = limitToBox(obj.from[i] + obj.inflate + ogn, -obj.inflate);
|
|
}
|
|
|
|
if (obj.to) {
|
|
obj.to[i] = (obj.before.to[i] + obj.inflate - ogn) * size;
|
|
if (obj.to[i] + ogn > 32 || obj.to[i] + ogn < -16) overflow.push(obj);
|
|
obj.to[i] = limitToBox(obj.to[i] - obj.inflate + ogn, obj.inflate);
|
|
if (Format.integer_size) {
|
|
obj.to[i] = obj.from[i] + Math.round(obj.to[i] - obj.from[i])
|
|
}
|
|
}
|
|
|
|
if (obj.origin) {
|
|
obj.origin[i] = (obj.before.origin[i] - ogn) * size;
|
|
obj.origin[i] = obj.origin[i] + ogn;
|
|
}
|
|
} else {
|
|
|
|
if (obj.from) obj.from[i] = obj.before.from[i];
|
|
if (obj.to) obj.to[i] = obj.before.to[i];
|
|
|
|
if (obj.origin) obj.origin[i] = obj.before.origin[i];
|
|
|
|
}
|
|
})
|
|
if (save === true) {
|
|
delete obj.before
|
|
}
|
|
if (Project.box_uv) {
|
|
Canvas.updateUV(obj)
|
|
}
|
|
})
|
|
if (Format.bone_rig && Group.selected) {
|
|
Group.selected.forEachChild((g) => {
|
|
g.origin[0] = g.old_origin[0] * size
|
|
g.origin[1] = g.old_origin[1] * size
|
|
g.origin[2] = g.old_origin[2] * size
|
|
if (save === true) {
|
|
delete g.old_origin
|
|
}
|
|
}, Group)
|
|
}
|
|
if (overflow.length && Format.canvas_limit && !settings.deactivate_size_limit.value) {
|
|
scaleAll.overflow = overflow;
|
|
$('#scaling_clipping_warning').text('Model clipping: Your model is too large for the canvas')
|
|
$('#scale_overflow_btn').css('display', 'inline-block')
|
|
} else {
|
|
$('#scaling_clipping_warning').text('')
|
|
$('#scale_overflow_btn').hide()
|
|
}
|
|
Canvas.updatePositions()
|
|
if (save === true) {
|
|
Undo.finishEdit('scale')
|
|
}
|
|
}
|
|
function modelScaleSync(label) {
|
|
if (label) {
|
|
var size = $('#model_scale_label').val()
|
|
$('#model_scale_range').val(size)
|
|
} else {
|
|
var size = $('#model_scale_range').val()
|
|
$('#model_scale_label').val(size)
|
|
}
|
|
scaleAll(false, size)
|
|
}
|
|
function cancelScaleAll() {
|
|
selected.forEach(function(obj) {
|
|
if (obj === undefined) return;
|
|
if (obj.from) obj.from.V3_set(obj.before.from);
|
|
if (obj.to) obj.to.V3_set(obj.before.to);
|
|
if (obj.origin) obj.origin.V3_set(obj.before.origin);
|
|
delete obj.before
|
|
if (Project.box_uv) {
|
|
Canvas.updateUV(obj)
|
|
}
|
|
})
|
|
if (Format.bone_rig && Group.selected) {
|
|
Group.selected.forEachChild((g) => {
|
|
g.origin[0] = g.old_origin[0]
|
|
g.origin[1] = g.old_origin[1]
|
|
g.origin[2] = g.old_origin[2]
|
|
delete g.old_origin
|
|
}, Group)
|
|
}
|
|
Canvas.updatePositions()
|
|
hideDialog()
|
|
}
|
|
function setScaleAllPivot(mode) {
|
|
if (mode === 'selection') {
|
|
var center = getSelectionCenter()
|
|
} else {
|
|
var center = Cube.selected[0] && Cube.selected[0].origin;
|
|
}
|
|
if (center) {
|
|
$('input#scaling_origin_x').val(center[0]);
|
|
$('input#scaling_origin_y').val(center[1]);
|
|
$('input#scaling_origin_z').val(center[2]);
|
|
}
|
|
}
|
|
function scaleAllSelectOverflow() {
|
|
cancelScaleAll()
|
|
selected.empty();
|
|
scaleAll.overflow.forEach(obj => {
|
|
obj.selectLow()
|
|
})
|
|
updateSelection();
|
|
}
|
|
//Center
|
|
function centerCubesAll(axis) {
|
|
centerCubes(0, false)
|
|
centerCubes(1, false)
|
|
centerCubes(2, false)
|
|
Canvas.updatePositions()
|
|
}
|
|
function centerCubes(axis, update) {
|
|
if (!selected.length) return;
|
|
var average = 0;
|
|
selected.forEach(function(obj) {
|
|
if (obj.movable) average += obj.from[axis]
|
|
if (obj.resizable) average += obj.to[axis]
|
|
})
|
|
average = average / (selected.length * 2)
|
|
var difference = (Format.centered_grid ? 0 : 8) - average
|
|
|
|
selected.forEach(function(obj) {
|
|
if (obj.movable) obj.from[axis] = limitToBox(obj.from[axis] + difference, obj.inflate);
|
|
if (obj.resizable) obj.to[axis] = limitToBox(obj.to[axis] + difference, obj.inflate);
|
|
if (obj.origin) obj.origin[axis] += difference;
|
|
})
|
|
|
|
if (update !== false) {
|
|
Canvas.updatePositions()
|
|
}
|
|
}
|
|
|
|
//Move
|
|
function moveElementsInSpace(difference, axis) {
|
|
let space = Transformer.getTransformSpace()
|
|
let group = Format.bone_rig && Group.selected && Group.selected.matchesSelection() && Group.selected;
|
|
var group_m;
|
|
|
|
if (group) {
|
|
if (space === 0) {
|
|
group_m = new THREE.Vector3();
|
|
group_m[getAxisLetter(axis)] = difference;
|
|
|
|
var rotation = new THREE.Quaternion();
|
|
group.mesh.parent.getWorldQuaternion(rotation);
|
|
group_m.applyQuaternion(rotation.inverse());
|
|
|
|
group.forEachChild(g => {
|
|
g.origin.V3_add(group_m.x, group_m.y, group_m.z);
|
|
}, Group, true)
|
|
|
|
} else if (space === 2) {
|
|
group_m = new THREE.Vector3();
|
|
group_m[getAxisLetter(axis)] = difference;
|
|
|
|
group_m.applyQuaternion(group.mesh.quaternion);
|
|
|
|
group.forEachChild(g => {
|
|
g.origin.V3_add(group_m.x, group_m.y, group_m.z);
|
|
}, Group, true)
|
|
|
|
} else {
|
|
group.forEachChild(g => {
|
|
g.origin[axis] += difference
|
|
}, Group, true)
|
|
}
|
|
Canvas.updateAllBones([Group.selected]);
|
|
}
|
|
|
|
selected.forEach(el => {
|
|
|
|
if (space == 2 && !group_m) {
|
|
if (el.movable) el.from[axis] += difference;
|
|
if (el.resizable) el.to[axis] += difference;
|
|
|
|
} else if (space instanceof Group) {
|
|
if (el.movable) el.from[axis] += difference;
|
|
if (el.resizable) el.to[axis] += difference;
|
|
if (el.rotatable) el.origin[axis] += difference;
|
|
} else {
|
|
let move_origin = !!group;
|
|
if (group_m) {
|
|
var m = group_m
|
|
} else {
|
|
var m = new THREE.Vector3();
|
|
m[getAxisLetter(axis)] = difference;
|
|
|
|
let parent = el.parent;
|
|
while (parent instanceof Group) {
|
|
if (!parent.rotation.allEqual(0)) break;
|
|
parent = parent.parent;
|
|
}
|
|
|
|
if (parent == 'root') {
|
|
// If none of the parent groups are rotated, move origin.
|
|
move_origin = true;
|
|
} else {
|
|
var rotation = new THREE.Quaternion();
|
|
if (el.mesh) {
|
|
el.mesh.getWorldQuaternion(rotation);
|
|
} else if (el.parent instanceof Group) {
|
|
el.parent.mesh.getWorldQuaternion(rotation);
|
|
}
|
|
m.applyQuaternion(rotation.inverse());
|
|
}
|
|
}
|
|
|
|
if (el.movable) el.from.V3_add(m.x, m.y, m.z);
|
|
if (el.resizable) el.to.V3_add(m.x, m.y, m.z);
|
|
if (move_origin) {
|
|
if (el.rotatable) el.origin.V3_add(m.x, m.y, m.z);
|
|
}
|
|
}
|
|
if (el instanceof Cube) {
|
|
el.mapAutoUV()
|
|
Canvas.adaptObjectPosition(el);
|
|
}
|
|
})
|
|
}
|
|
|
|
//Rotate
|
|
function getRotationInterval(event) {
|
|
if (Format.rotation_limit) {
|
|
return 22.5;
|
|
} else if (event.shiftKey && event.ctrlOrCmd) {
|
|
return 0.25;
|
|
} else if (event.shiftKey) {
|
|
return 22.5;
|
|
} else if (event.ctrlOrCmd) {
|
|
return 1;
|
|
} else {
|
|
return 2.5;
|
|
}
|
|
}
|
|
function getRotationObject() {
|
|
if (Format.bone_rig && Group.selected) return Group.selected;
|
|
if (Format.rotate_cubes && Cube.selected.length) return Cube.selected;
|
|
}
|
|
function rotateOnAxis(modify, axis, slider) {
|
|
var things;
|
|
if (Format.bone_rig && Group.selected) {
|
|
things = [Group.selected]
|
|
} else if (Format.rotate_cubes && Cube.selected.length) {
|
|
things = Cube.selected;
|
|
}
|
|
if (!things) return;
|
|
/*
|
|
if (Format.bone_rig && Group.selected) {
|
|
if (!Group.selected) return;
|
|
let obj = Group.selected.mesh
|
|
|
|
if (typeof space == 'object') {
|
|
let normal = axis == 0 ? THREE.NormalX : (axis == 1 ? THREE.NormalY : THREE.NormalZ)
|
|
let rotWorldMatrix = new THREE.Matrix4();
|
|
rotWorldMatrix.makeRotationAxis(normal, Math.degToRad(modify(0)))
|
|
rotWorldMatrix.multiply(obj.matrix)
|
|
obj.matrix.copy(rotWorldMatrix)
|
|
obj.setRotationFromMatrix(rotWorldMatrix)
|
|
let e = obj.rotation;
|
|
Group.selected.rotation[0] = Math.radToDeg(e.x);
|
|
Group.selected.rotation[1] = Math.radToDeg(e.y);
|
|
Group.selected.rotation[2] = Math.radToDeg(e.z);
|
|
Canvas.updateAllBones()
|
|
|
|
} else if (space == 0) {
|
|
let normal = axis == 0 ? THREE.NormalX : (axis == 1 ? THREE.NormalY : THREE.NormalZ)
|
|
let rotWorldMatrix = new THREE.Matrix4();
|
|
rotWorldMatrix.makeRotationAxis(normal, Math.degToRad(modify(0)))
|
|
rotWorldMatrix.multiply(obj.matrixWorld)
|
|
|
|
let inverse = new THREE.Matrix4().getInverse(obj.parent.matrixWorld)
|
|
rotWorldMatrix.premultiply(inverse)
|
|
|
|
obj.matrix.copy(rotWorldMatrix)
|
|
obj.setRotationFromMatrix(rotWorldMatrix)
|
|
let e = obj.rotation;
|
|
Group.selected.rotation[0] = Math.radToDeg(e.x);
|
|
Group.selected.rotation[1] = Math.radToDeg(e.y);
|
|
Group.selected.rotation[2] = Math.radToDeg(e.z);
|
|
Canvas.updateAllBones()
|
|
|
|
} else {
|
|
var value = modify(Group.selected.rotation[axis]);
|
|
Group.selected.rotation[axis] = Math.trimDeg(value)
|
|
Canvas.updateAllBones()
|
|
}
|
|
return;
|
|
}
|
|
*/
|
|
//Warning
|
|
if (Format.rotation_limit && settings.dialog_rotation_limit.value) {
|
|
var i = 0;
|
|
while (i < Cube.selected.length) {
|
|
if (Cube.selected[i].rotation[(axis+1)%3] ||
|
|
Cube.selected[i].rotation[(axis+2)%3]
|
|
) {
|
|
i = Infinity
|
|
|
|
Blockbench.showMessageBox({
|
|
title: tl('message.rotation_limit.title'),
|
|
icon: 'rotate_right',
|
|
message: tl('message.rotation_limit.message'),
|
|
buttons: [tl('dialog.ok'), tl('dialog.dontshowagain')]
|
|
}, function(r) {
|
|
if (r === 1) {
|
|
settings.dialog_rotation_limit.value = false
|
|
Settings.save()
|
|
}
|
|
})
|
|
return;
|
|
//Gotta stop the numslider here
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
var axis_letter = getAxisLetter(axis)
|
|
var origin =things[0].origin
|
|
things.forEach(function(obj, i) {
|
|
if (!obj.rotation.allEqual(0)) {
|
|
origin = obj.origin
|
|
}
|
|
})
|
|
|
|
let space = Transformer.getTransformSpace()
|
|
things.forEach(obj => {
|
|
let mesh = obj.mesh;
|
|
if (obj instanceof Cube && !Format.bone_rig) {
|
|
if (obj.origin.allEqual(0)) {
|
|
obj.origin.V3_set(origin)
|
|
}
|
|
}
|
|
|
|
if (slider || space == 2) {
|
|
var obj_val = modify(obj.rotation[axis]);
|
|
obj_val = Math.trimDeg(obj_val)
|
|
if (Format.rotation_limit) {
|
|
//Limit To 1 Axis
|
|
obj.rotation[(axis+1)%3] = 0
|
|
obj.rotation[(axis+2)%3] = 0
|
|
//Limit Angle
|
|
obj_val = Math.round(obj_val/22.5)*22.5
|
|
if (obj_val > 45 || obj_val < -45) {
|
|
|
|
let f = obj_val > 45
|
|
obj.roll(axis, f!=(axis==1) ? 1 : 3)
|
|
obj_val = f ? -22.5 : 22.5;
|
|
}
|
|
}
|
|
obj.rotation[axis] = obj_val
|
|
if (obj instanceof Cube) {
|
|
obj.rotation_axis = axis_letter
|
|
}
|
|
|
|
} else if (space instanceof Group) {
|
|
let normal = axis == 0 ? THREE.NormalX : (axis == 1 ? THREE.NormalY : THREE.NormalZ)
|
|
let rotWorldMatrix = new THREE.Matrix4();
|
|
rotWorldMatrix.makeRotationAxis(normal, Math.degToRad(modify(0)))
|
|
rotWorldMatrix.multiply(mesh.matrix)
|
|
mesh.matrix.copy(rotWorldMatrix)
|
|
mesh.setRotationFromMatrix(rotWorldMatrix)
|
|
let e = mesh.rotation;
|
|
obj.rotation[0] = Math.radToDeg(e.x);
|
|
obj.rotation[1] = Math.radToDeg(e.y);
|
|
obj.rotation[2] = Math.radToDeg(e.z);
|
|
|
|
} else if (space == 0) {
|
|
let normal = axis == 0 ? THREE.NormalX : (axis == 1 ? THREE.NormalY : THREE.NormalZ)
|
|
let rotWorldMatrix = new THREE.Matrix4();
|
|
rotWorldMatrix.makeRotationAxis(normal, Math.degToRad(modify(0)))
|
|
rotWorldMatrix.multiply(mesh.matrixWorld)
|
|
|
|
let inverse = new THREE.Matrix4().getInverse(mesh.parent.matrixWorld)
|
|
rotWorldMatrix.premultiply(inverse)
|
|
|
|
mesh.matrix.copy(rotWorldMatrix)
|
|
mesh.setRotationFromMatrix(rotWorldMatrix)
|
|
let e = mesh.rotation;
|
|
obj.rotation[0] = Math.radToDeg(e.x);
|
|
obj.rotation[1] = Math.radToDeg(e.y);
|
|
obj.rotation[2] = Math.radToDeg(e.z);
|
|
|
|
}
|
|
if (obj instanceof Group) {
|
|
Canvas.updateAllBones()
|
|
}
|
|
})
|
|
}
|
|
|
|
BARS.defineActions(function() {
|
|
|
|
|
|
new BarSelect('transform_space', {
|
|
condition: {modes: ['edit'], tools: ['move_tool', 'pivot_tool']},
|
|
category: 'transform',
|
|
value: 'local',
|
|
options: {
|
|
global: true,
|
|
bone: {condition: () => Format.bone_rig, name: true},
|
|
local: true
|
|
},
|
|
onChange() {
|
|
updateSelection();
|
|
}
|
|
})
|
|
new BarSelect('rotation_space', {
|
|
condition: {modes: ['edit'], tools: ['rotate_tool']},
|
|
category: 'transform',
|
|
value: 'local',
|
|
options: {
|
|
global: 'action.transform_space.global',
|
|
bone: {condition: () => Format.bone_rig, name: true, name: 'action.transform_space.bone'},
|
|
local: 'action.transform_space.local'
|
|
},
|
|
onChange() {
|
|
updateSelection();
|
|
}
|
|
})
|
|
let grid_locked_interval = function(event) {
|
|
event = event||0;
|
|
return canvasGridSize(event.shiftKey, event.ctrlOrCmd);
|
|
}
|
|
|
|
function moveOnAxis(modify, axis) {
|
|
selected.forEach(function(obj, i) {
|
|
if (obj.movable) {
|
|
var val = modify(obj.from[axis])
|
|
|
|
if (Format.canvas_limit && !settings.deactivate_size_limit.value) {
|
|
var size = obj.resizable ? obj.size(axis) : 0;
|
|
val = limitToBox(limitToBox(val, -obj.inflate) + size, obj.inflate) - size
|
|
}
|
|
|
|
//val -= obj.from[axis];
|
|
var before = obj.from[axis];
|
|
obj.from[axis] = val;
|
|
if (obj.resizable) {
|
|
obj.to[axis] += (val - before);
|
|
}
|
|
if (obj instanceof Cube) {
|
|
obj.mapAutoUV()
|
|
Canvas.adaptObjectPosition(obj);
|
|
}
|
|
}
|
|
})
|
|
TickUpdates.selection = true;
|
|
}
|
|
new NumSlider('slider_pos_x', {
|
|
name: tl('action.slider_pos', ['X']),
|
|
description: tl('action.slider_pos.desc', ['X']),
|
|
color: 'x',
|
|
category: 'transform',
|
|
condition: () => (selected.length && Modes.edit),
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
return selected[0].from[0]
|
|
},
|
|
change: function(modify) {
|
|
moveOnAxis(modify, 0)
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('move')
|
|
}
|
|
})
|
|
new NumSlider('slider_pos_y', {
|
|
name: tl('action.slider_pos', ['Y']),
|
|
description: tl('action.slider_pos.desc', ['Y']),
|
|
color: 'y',
|
|
category: 'transform',
|
|
condition: () => (selected.length && Modes.edit),
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
return selected[0].from[1]
|
|
},
|
|
change: function(modify) {
|
|
moveOnAxis(modify, 1)
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('move')
|
|
}
|
|
})
|
|
new NumSlider('slider_pos_z', {
|
|
name: tl('action.slider_pos', ['Z']),
|
|
description: tl('action.slider_pos.desc', ['Z']),
|
|
color: 'z',
|
|
category: 'transform',
|
|
condition: () => (selected.length && Modes.edit),
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
return selected[0].from[2]
|
|
},
|
|
change: function(modify) {
|
|
moveOnAxis(modify, 2)
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('move')
|
|
}
|
|
})
|
|
|
|
|
|
function resizeOnAxis(modify, axis) {
|
|
selected.forEach(function(obj, i) {
|
|
if (obj.resizable) {
|
|
obj.resize(modify, axis, false, true)
|
|
}
|
|
})
|
|
}
|
|
new NumSlider('slider_size_x', {
|
|
name: tl('action.slider_size', ['X']),
|
|
description: tl('action.slider_size.desc', ['X']),
|
|
color: 'x',
|
|
category: 'transform',
|
|
condition: () => (Cube.selected.length && Modes.edit),
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
return Cube.selected[0].to[0] - Cube.selected[0].from[0]
|
|
},
|
|
change: function(modify) {
|
|
resizeOnAxis(modify, 0)
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: Cube.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('resize')
|
|
}
|
|
})
|
|
new NumSlider('slider_size_y', {
|
|
name: tl('action.slider_size', ['Y']),
|
|
description: tl('action.slider_size.desc', ['Y']),
|
|
color: 'y',
|
|
category: 'transform',
|
|
condition: () => (Cube.selected.length && Modes.edit),
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
return Cube.selected[0].to[1] - Cube.selected[0].from[1]
|
|
},
|
|
change: function(modify) {
|
|
resizeOnAxis(modify, 1)
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: Cube.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('resize')
|
|
}
|
|
})
|
|
new NumSlider('slider_size_z', {
|
|
name: tl('action.slider_size', ['Z']),
|
|
description: tl('action.slider_size.desc', ['Z']),
|
|
color: 'z',
|
|
category: 'transform',
|
|
condition: () => (Cube.selected.length && Modes.edit),
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
return Cube.selected[0].to[2] - Cube.selected[0].from[2]
|
|
},
|
|
change: function(modify) {
|
|
resizeOnAxis(modify, 2)
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: Cube.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('resize')
|
|
}
|
|
})
|
|
//Inflate
|
|
new NumSlider('slider_inflate', {
|
|
category: 'transform',
|
|
condition: function() {return Cube.selected.length && Modes.edit},
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
return Cube.selected[0].inflate
|
|
},
|
|
change: function(modify) {
|
|
Cube.selected.forEach(function(obj, i) {
|
|
var v = modify(obj.inflate)
|
|
if (Format.canvas_limit && !settings.deactivate_size_limit.value) {
|
|
v = obj.from[0] - Math.clamp(obj.from[0]-v, -16, 32);
|
|
v = obj.from[1] - Math.clamp(obj.from[1]-v, -16, 32);
|
|
v = obj.from[2] - Math.clamp(obj.from[2]-v, -16, 32);
|
|
v = Math.clamp(obj.to[0]+v, -16, 32) - obj.to[0];
|
|
v = Math.clamp(obj.to[1]+v, -16, 32) - obj.to[1];
|
|
v = Math.clamp(obj.to[2]+v, -16, 32) - obj.to[2];
|
|
}
|
|
obj.inflate = v
|
|
})
|
|
Canvas.updatePositions()
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: Cube.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('inflate')
|
|
}
|
|
})
|
|
|
|
//Rotation
|
|
new NumSlider('slider_rotation_x', {
|
|
name: tl('action.slider_rotation', ['X']),
|
|
description: tl('action.slider_rotation.desc', ['X']),
|
|
color: 'x',
|
|
category: 'transform',
|
|
condition: () => (Modes.edit && getRotationObject()),
|
|
get: function() {
|
|
if (Format.bone_rig && Group.selected) {
|
|
return Group.selected.rotation[0];
|
|
}
|
|
if (Format.rotate_cubes && Cube.selected[0]) {
|
|
return Cube.selected[0].rotation[0];
|
|
}
|
|
},
|
|
change: function(modify) {
|
|
rotateOnAxis(modify, 0, true)
|
|
Canvas.updatePositions()
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: Cube.selected, group: Group.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('rotate')
|
|
},
|
|
getInterval: getRotationInterval
|
|
})
|
|
new NumSlider('slider_rotation_y', {
|
|
name: tl('action.slider_rotation', ['Y']),
|
|
description: tl('action.slider_rotation.desc', ['Y']),
|
|
color: 'y',
|
|
category: 'transform',
|
|
condition: () => (Modes.edit && getRotationObject()),
|
|
get: function() {
|
|
if (Format.bone_rig && Group.selected) {
|
|
return Group.selected.rotation[1];
|
|
}
|
|
if (Format.rotate_cubes && Cube.selected[0]) {
|
|
return Cube.selected[0].rotation[1];
|
|
}
|
|
},
|
|
change: function(modify) {
|
|
rotateOnAxis(modify, 1, true)
|
|
Canvas.updatePositions()
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: selected, group: Group.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('rotate')
|
|
},
|
|
getInterval: getRotationInterval
|
|
})
|
|
new NumSlider('slider_rotation_z', {
|
|
name: tl('action.slider_rotation', ['Z']),
|
|
description: tl('action.slider_rotation.desc', ['Z']),
|
|
color: 'z',
|
|
category: 'transform',
|
|
condition: () => (Modes.edit && getRotationObject()),
|
|
get: function() {
|
|
if (Format.bone_rig && Group.selected) {
|
|
return Group.selected.rotation[2];
|
|
}
|
|
if (Format.rotate_cubes && Cube.selected[0]) {
|
|
return Cube.selected[0].rotation[2];
|
|
}
|
|
},
|
|
change: function(modify) {
|
|
rotateOnAxis(modify, 2, true)
|
|
Canvas.updatePositions()
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: selected, group: Group.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('rotate')
|
|
},
|
|
getInterval: getRotationInterval
|
|
})
|
|
function rotateCondition() {
|
|
return (Modes.edit && (
|
|
(Format.bone_rig && Group.selected) ||
|
|
(Format.rotate_cubes && Cube.selected.length)
|
|
))
|
|
}
|
|
|
|
//Origin
|
|
function moveOriginOnAxis(modify, axis) {
|
|
var rotation_object = getRotationObject()
|
|
|
|
if (rotation_object instanceof Group) {
|
|
var val = modify(rotation_object.origin[axis]);
|
|
rotation_object.origin[axis] = val;
|
|
Canvas.updatePositions()
|
|
if (Format.bone_rig) {
|
|
Canvas.updateAllBones()
|
|
}
|
|
} else {
|
|
rotation_object.forEach(function(obj, i) {
|
|
var val = modify(obj.origin[axis]);
|
|
obj.origin[axis] = val;
|
|
})
|
|
Canvas.updatePositions()
|
|
}
|
|
if (Modes.animate) {
|
|
Animator.preview();
|
|
}
|
|
}
|
|
new NumSlider('slider_origin_x', {
|
|
name: tl('action.slider_origin', ['X']),
|
|
description: tl('action.slider_origin.desc', ['X']),
|
|
color: 'x',
|
|
category: 'transform',
|
|
condition: () => (Modes.edit || Modes.animate) && getRotationObject(),
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
if (Format.bone_rig && Group.selected) {
|
|
return Group.selected.origin[0];
|
|
}
|
|
if (Format.rotate_cubes && Cube.selected[0]) {
|
|
return Cube.selected[0].origin[0];
|
|
}
|
|
},
|
|
change: function(modify) {
|
|
moveOriginOnAxis(modify, 0)
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: selected, group: Group.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('origin')
|
|
}
|
|
})
|
|
new NumSlider('slider_origin_y', {
|
|
name: tl('action.slider_origin', ['Y']),
|
|
description: tl('action.slider_origin.desc', ['Y']),
|
|
color: 'y',
|
|
category: 'transform',
|
|
condition: () => (Modes.edit || Modes.animate) && getRotationObject(),
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
if (Format.bone_rig && Group.selected) {
|
|
return Group.selected.origin[1];
|
|
}
|
|
if (Format.rotate_cubes && Cube.selected[0]) {
|
|
return Cube.selected[0].origin[1];
|
|
}
|
|
},
|
|
change: function(modify) {
|
|
moveOriginOnAxis(modify, 1)
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: selected, group: Group.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('origin')
|
|
}
|
|
})
|
|
new NumSlider('slider_origin_z', {
|
|
name: tl('action.slider_origin', ['Z']),
|
|
description: tl('action.slider_origin.desc', ['Z']),
|
|
color: 'z',
|
|
category: 'transform',
|
|
condition: () => (Modes.edit || Modes.animate) && getRotationObject(),
|
|
getInterval: grid_locked_interval,
|
|
get: function() {
|
|
if (Format.bone_rig && Group.selected) {
|
|
return Group.selected.origin[2];
|
|
}
|
|
if (Format.rotate_cubes && Cube.selected[0]) {
|
|
return Cube.selected[0].origin[2];
|
|
}
|
|
},
|
|
change: function(modify) {
|
|
moveOriginOnAxis(modify, 2)
|
|
},
|
|
onBefore: function() {
|
|
Undo.initEdit({elements: selected, group: Group.selected})
|
|
},
|
|
onAfter: function() {
|
|
Undo.finishEdit('origin')
|
|
}
|
|
})
|
|
|
|
new Action('scale', {
|
|
icon: 'settings_overscan',
|
|
category: 'transform',
|
|
condition: () => (Modes.edit && selected.length),
|
|
click: function () {
|
|
$('#model_scale_range, #model_scale_label').val(1)
|
|
$('#scaling_clipping_warning').text('')
|
|
|
|
Undo.initEdit({elements: selected, outliner: Format.bone_rig})
|
|
|
|
selected.forEach(function(obj) {
|
|
obj.before = {
|
|
from: obj.from ? obj.from.slice() : undefined,
|
|
to: obj.to ? obj.to.slice() : undefined,
|
|
origin: obj.origin ? obj.origin.slice() : undefined
|
|
}
|
|
})
|
|
if (Format.bone_rig && Group.selected) {
|
|
Group.selected.forEachChild((g) => {
|
|
g.old_origin = g.origin.slice();
|
|
}, Group, true)
|
|
}
|
|
showDialog('scaling')
|
|
var v = Format.centered_grid ? 0 : 8;
|
|
var origin = Group.selected ? Group.selected.origin : [v, 0, v];
|
|
$('#scaling_origin_x').val(origin[0])
|
|
$('#scaling_origin_y').val(origin[1])
|
|
$('#scaling_origin_z').val(origin[2])
|
|
scaleAll(false, 1)
|
|
}
|
|
})
|
|
new Action('rotate_x_cw', {
|
|
name: tl('action.rotate_cw', 'X'),
|
|
icon: 'rotate_right',
|
|
color: 'x',
|
|
category: 'transform',
|
|
click: function () {
|
|
rotateSelected(0, 1);
|
|
}
|
|
})
|
|
new Action('rotate_x_ccw', {
|
|
name: tl('action.rotate_ccw', 'X'),
|
|
icon: 'rotate_left',
|
|
color: 'x',
|
|
category: 'transform',
|
|
click: function () {
|
|
rotateSelected(0, 3);
|
|
}
|
|
})
|
|
new Action('rotate_y_cw', {
|
|
name: tl('action.rotate_cw', 'Y'),
|
|
icon: 'rotate_right',
|
|
color: 'y',
|
|
category: 'transform',
|
|
click: function () {
|
|
rotateSelected(1, 1);
|
|
}
|
|
})
|
|
new Action('rotate_y_ccw', {
|
|
name: tl('action.rotate_ccw', 'Y'),
|
|
icon: 'rotate_left',
|
|
color: 'y',
|
|
category: 'transform',
|
|
click: function () {
|
|
rotateSelected(1, 3);
|
|
}
|
|
})
|
|
new Action('rotate_z_cw', {
|
|
name: tl('action.rotate_cw', 'Z'),
|
|
icon: 'rotate_right',
|
|
color: 'z',
|
|
category: 'transform',
|
|
click: function () {
|
|
rotateSelected(2, 1);
|
|
}
|
|
})
|
|
new Action('rotate_z_ccw', {
|
|
name: tl('action.rotate_ccw', 'Z'),
|
|
icon: 'rotate_left',
|
|
color: 'z',
|
|
category: 'transform',
|
|
click: function () {
|
|
rotateSelected(2, 3);
|
|
}
|
|
})
|
|
|
|
new Action('flip_x', {
|
|
name: tl('action.flip', 'X'),
|
|
icon: 'icon-mirror_x',
|
|
color: 'x',
|
|
category: 'transform',
|
|
click: function () {
|
|
mirrorSelected(0);
|
|
}
|
|
})
|
|
new Action('flip_y', {
|
|
name: tl('action.flip', 'Y'),
|
|
icon: 'icon-mirror_y',
|
|
color: 'y',
|
|
category: 'transform',
|
|
click: function () {
|
|
mirrorSelected(1);
|
|
}
|
|
})
|
|
new Action('flip_z', {
|
|
name: tl('action.flip', 'Z'),
|
|
icon: 'icon-mirror_z',
|
|
color: 'z',
|
|
category: 'transform',
|
|
click: function () {
|
|
mirrorSelected(2);
|
|
}
|
|
})
|
|
|
|
new Action('center_x', {
|
|
name: tl('action.center', 'X'),
|
|
icon: 'vertical_align_center',
|
|
color: 'x',
|
|
category: 'transform',
|
|
click: function () {
|
|
Undo.initEdit({elements: selected});
|
|
centerCubes(0);
|
|
Undo.finishEdit('center')
|
|
}
|
|
})
|
|
new Action('center_y', {
|
|
name: tl('action.center', 'Y'),
|
|
icon: 'vertical_align_center',
|
|
color: 'y',
|
|
category: 'transform',
|
|
click: function () {
|
|
Undo.initEdit({elements: selected});
|
|
centerCubes(1);
|
|
Undo.finishEdit('center')
|
|
}
|
|
})
|
|
new Action('center_z', {
|
|
name: tl('action.center', 'Z'),
|
|
icon: 'vertical_align_center',
|
|
color: 'z',
|
|
category: 'transform',
|
|
click: function () {
|
|
Undo.initEdit({elements: selected});
|
|
centerCubes(2);
|
|
Undo.finishEdit('center')
|
|
}
|
|
})
|
|
new Action('center_all', {
|
|
icon: 'filter_center_focus',
|
|
category: 'transform',
|
|
click: function () {
|
|
Undo.initEdit({elements: selected});
|
|
centerCubesAll();
|
|
Undo.finishEdit('center')
|
|
}
|
|
})
|
|
|
|
//Move Cube Keys
|
|
new Action('move_up', {
|
|
icon: 'arrow_upward',
|
|
category: 'transform',
|
|
condition: {modes: ['edit'], method: () => (!open_menu && selected.length)},
|
|
keybind: new Keybind({key: 38, ctrl: null, shift: null}),
|
|
click: function (e) {moveCubesRelative(-1, 2, e)}
|
|
})
|
|
new Action('move_down', {
|
|
icon: 'arrow_downward',
|
|
category: 'transform',
|
|
condition: {modes: ['edit'], method: () => (!open_menu && selected.length)},
|
|
keybind: new Keybind({key: 40, ctrl: null, shift: null}),
|
|
click: function (e) {moveCubesRelative(1, 2, e)}
|
|
})
|
|
new Action('move_left', {
|
|
icon: 'arrow_back',
|
|
category: 'transform',
|
|
condition: {modes: ['edit'], method: () => (!open_menu && selected.length)},
|
|
keybind: new Keybind({key: 37, ctrl: null, shift: null}),
|
|
click: function (e) {moveCubesRelative(-1, 0, e)}
|
|
})
|
|
new Action('move_right', {
|
|
icon: 'arrow_forward',
|
|
category: 'transform',
|
|
condition: {modes: ['edit'], method: () => (!open_menu && selected.length)},
|
|
keybind: new Keybind({key: 39, ctrl: null, shift: null}),
|
|
click: function (e) {moveCubesRelative(1, 0, e)}
|
|
})
|
|
new Action('move_forth', {
|
|
icon: 'keyboard_arrow_up',
|
|
category: 'transform',
|
|
condition: {modes: ['edit'], method: () => (!open_menu && selected.length)},
|
|
keybind: new Keybind({key: 33, ctrl: null, shift: null}),
|
|
click: function (e) {moveCubesRelative(-1, 1, e)}
|
|
})
|
|
new Action('move_back', {
|
|
icon: 'keyboard_arrow_down',
|
|
category: 'transform',
|
|
condition: {modes: ['edit'], method: () => (!open_menu && selected.length)},
|
|
keybind: new Keybind({key: 34, ctrl: null, shift: null}),
|
|
click: function (e) {moveCubesRelative(1, 1, e)}
|
|
})
|
|
|
|
new Action('toggle_visibility', {
|
|
icon: 'visibility',
|
|
category: 'transform',
|
|
click: function () {toggleCubeProperty('visibility')}
|
|
})
|
|
new Action('toggle_locked', {
|
|
icon: 'fas.fa-lock',
|
|
category: 'transform',
|
|
click: function () {toggleCubeProperty('locked')}
|
|
})
|
|
new Action('toggle_export', {
|
|
icon: 'save',
|
|
category: 'transform',
|
|
click: function () {toggleCubeProperty('export')}
|
|
})
|
|
new Action('toggle_autouv', {
|
|
icon: 'fullscreen_exit',
|
|
category: 'transform',
|
|
condition: {modes: ['edit']},
|
|
click: function () {toggleCubeProperty('autouv')}
|
|
})
|
|
new Action('toggle_shade', {
|
|
icon: 'wb_sunny',
|
|
category: 'transform',
|
|
condition: () => !Project.box_uv && Modes.edit,
|
|
click: function () {toggleCubeProperty('shade')}
|
|
})
|
|
new Action('toggle_mirror_uv', {
|
|
icon: 'icon-mirror_x',
|
|
category: 'transform',
|
|
condition: () => Project.box_uv && (Modes.edit || Modes.paint),
|
|
click: function () {toggleCubeProperty('shade')}
|
|
})
|
|
new Action('update_autouv', {
|
|
icon: 'brightness_auto',
|
|
category: 'transform',
|
|
condition: () => !Project.box_uv && Modes.edit,
|
|
click: function () {
|
|
if (Cube.selected.length) {
|
|
Undo.initEdit({elements: Cube.selected[0].forSelected(), selection: true})
|
|
Cube.selected[0].forSelected(function(cube) {
|
|
cube.mapAutoUV()
|
|
})
|
|
Undo.finishEdit('update_autouv')
|
|
}
|
|
}
|
|
})
|
|
new Action('origin_to_geometry', {
|
|
icon: 'filter_center_focus',
|
|
category: 'transform',
|
|
condition: {modes: ['edit', 'animate']},
|
|
click: function () {origin2geometry()}
|
|
})
|
|
new Action('rescale_toggle', {
|
|
icon: 'check_box_outline_blank',
|
|
category: 'transform',
|
|
condition: function() {return Format.rotation_limit && Cube.selected.length;},
|
|
click: function () {
|
|
Undo.initEdit({elements: Cube.selected})
|
|
var value = !Cube.selected[0].rescale
|
|
Cube.selected.forEach(function(cube) {
|
|
cube.rescale = value
|
|
})
|
|
Canvas.updatePositions()
|
|
updateNslideValues()
|
|
Undo.finishEdit('rescale')
|
|
}
|
|
})
|
|
new Action('bone_reset_toggle', {
|
|
icon: 'check_box_outline_blank',
|
|
category: 'transform',
|
|
condition: function() {return Format.bone_rig && Group.selected;},
|
|
click: function () {
|
|
Undo.initEdit({group: Group.selected})
|
|
Group.selected.reset = !Group.selected.reset
|
|
updateNslideValues()
|
|
Undo.finishEdit('bone_reset')
|
|
}
|
|
})
|
|
|
|
new Action('remove_blank_faces', {
|
|
icon: 'cancel_presentation',
|
|
category: 'filter',
|
|
condition: () => !Format.box_uv,
|
|
click: function () {
|
|
Undo.initEdit({elements: Cube.selected})
|
|
var arr = Cube.selected.slice()
|
|
var empty_cubes = [];
|
|
var cleared_total = 0;
|
|
unselectAll()
|
|
arr.forEach(cube => {
|
|
var clear_count = 0;
|
|
for (var face in cube.faces) {
|
|
var face_tag = cube.faces[face];
|
|
if (face_tag.texture == false) {
|
|
face_tag.texture = null
|
|
clear_count++;
|
|
cleared_total++;
|
|
}
|
|
}
|
|
if (clear_count == 6) {
|
|
empty_cubes.push(cube);
|
|
}
|
|
})
|
|
updateSelection();
|
|
Blockbench.showQuickMessage(tl('message.removed_faces', [cleared_total]))
|
|
if (empty_cubes.length) {
|
|
Blockbench.showMessageBox({
|
|
title: tl('message.cleared_blank_faces.title'),
|
|
icon: 'rotate_right',
|
|
message: tl('message.cleared_blank_faces.message', [empty_cubes.length]),
|
|
buttons: ['generic.remove', 'dialog.cancel'],
|
|
confirm: 0,
|
|
cancel: 1,
|
|
}, function(r) {
|
|
empty_cubes.forEach(cube => {
|
|
if (r == 0) {
|
|
cube.remove();
|
|
} else {
|
|
for (var face in cube.faces) {
|
|
cube.faces[face].texture = false;
|
|
}
|
|
}
|
|
})
|
|
updateSelection();
|
|
Canvas.updateAllFaces();
|
|
Undo.finishEdit('remove blank faces');
|
|
})
|
|
} else {
|
|
Canvas.updateAllFaces();
|
|
Undo.finishEdit('remove blank faces');
|
|
}
|
|
}
|
|
})
|
|
})
|