0d14e5a379
Needs a lot of cleanup. Data has been de-duplicated, and where identical copies existed, one of them has been replaced with a symlink. Some files have been excluded, such as binaries, installers and debug dumps. Some of that may still be present.
297 lines
No EOL
9.3 KiB
JavaScript
297 lines
No EOL
9.3 KiB
JavaScript
//
|
|
// interface.js
|
|
//
|
|
// version 0.1
|
|
//
|
|
// Created by Victor Kislichenko, April 2015
|
|
//
|
|
// Presents the Builder for the stage script
|
|
//
|
|
// Icons downloaded from http://icons8.com/
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
|
|
StageBuilder = (function() {
|
|
|
|
//private: Calculators
|
|
var getCirclePoints = function(data)
|
|
{
|
|
if(data.limit <= 0 || data.limit > 360) data.limit = 360;
|
|
|
|
var result = [];
|
|
var rotateRad = data.rotate * (Math.PI/180);
|
|
var circleLimitRad = data.limit * (Math.PI/180);
|
|
|
|
|
|
for(var i = 0; i < data.pointsAmount+1; i++) {
|
|
var angleRad = circleLimitRad * i / data.pointsAmount;
|
|
//var angleDeg = angleRad * (180/Math.PI);
|
|
result.push({
|
|
x : data.center.x + data.radius * Math.cos(angleRad + rotateRad),
|
|
y : data.center.x + data.radius * Math.sin(angleRad + rotateRad),
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
var lineDistance = function(pointA, pointB)
|
|
{
|
|
var dist = {
|
|
x : Math.abs(pointA.x - pointB.x),
|
|
y : Math.abs(pointA.y - pointB.y),
|
|
}
|
|
return Math.sqrt(dist.x * dist.x + dist.y * dist.y);
|
|
}
|
|
|
|
var getBlocsFromPoints = function(points, options)
|
|
{
|
|
var result = [];
|
|
var gapFix = options.block_gapfix;
|
|
for(var i = 0; i < points.length-1; i++) {
|
|
var block = {
|
|
pointA : points[i],
|
|
pointB : points[i+1],
|
|
};
|
|
block.proportions = {
|
|
length : lineDistance(block.pointA, block.pointB) + gapFix,
|
|
};
|
|
block.pointCenter = {
|
|
x : (block.pointA.x + block.pointB.x) / 2,
|
|
y : (block.pointA.y + block.pointB.y) / 2,
|
|
}
|
|
block.rotation = Math.atan2(block.pointB.y - block.pointA.y,block.pointB.x - block.pointA.x);
|
|
block.rotationDeg = block.rotation * (180/Math.PI);
|
|
result.push(block);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function colorLuminance(hex, lum) {
|
|
// validate hex string
|
|
hex = String(hex).replace(/[^0-9a-f]/gi, '');
|
|
if (hex.length < 6) {
|
|
hex = hex[0]+hex[0]+hex[1]+hex[1]+hex[2]+hex[2];
|
|
}
|
|
lum = lum || 0;
|
|
|
|
// convert to decimal and change luminosity
|
|
var rgb = "#", c, i;
|
|
for (i = 0; i < 3; i++) {
|
|
c = parseInt(hex.substr(i*2,2), 16);
|
|
c = Math.round(Math.min(Math.max(0, c + (c * lum)), 255)).toString(16);
|
|
rgb += ("00"+c).substr(c.length);
|
|
}
|
|
|
|
return rgb;
|
|
}
|
|
function hexToRgb(hex) {
|
|
var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
|
|
return result ? {
|
|
r: parseInt(result[1], 16),
|
|
g: parseInt(result[2], 16),
|
|
b: parseInt(result[3], 16)
|
|
} : null;
|
|
}
|
|
|
|
var getRandomInt = function(min, max) {
|
|
return Math.floor(Math.random() * (max - min)) + min;
|
|
}
|
|
|
|
function normalizeDegrees(degrees) {
|
|
while (degrees > 180) degrees -= 360;
|
|
while (degrees < -180) degrees += 360;
|
|
return degrees;
|
|
}
|
|
|
|
//public
|
|
var that = {
|
|
options: {
|
|
levels : 5,
|
|
blocks : 20,
|
|
circle_radius: 5,
|
|
circle_limit: 180,
|
|
circle_rotate: 0,
|
|
block_height: 0.5,
|
|
block_depth: 2,
|
|
block_gapfix: 0.1,
|
|
block_script: '',
|
|
block_color_random: false,
|
|
block_color_base: "#E6E6E6",
|
|
},
|
|
};
|
|
|
|
that.calc = function() {
|
|
var result = [];
|
|
|
|
//get points
|
|
var circleConfig = {
|
|
pointsAmount : that.options.blocks,
|
|
radius : that.options.circle_radius,
|
|
limit: that.options.circle_limit,
|
|
rotate : that.options.circle_rotate,
|
|
center : {
|
|
x : 0,
|
|
y : 0,
|
|
},
|
|
};
|
|
//build all levels
|
|
for(var i = 0; i < that.options.levels; i++) {
|
|
var levelResult = {
|
|
level : i,
|
|
};
|
|
//get points
|
|
levelResult.points = getCirclePoints(circleConfig);
|
|
//get blocks
|
|
levelResult.blocs = getBlocsFromPoints(levelResult.points, that.options);
|
|
|
|
result.push(levelResult);
|
|
|
|
circleConfig.radius += that.options.block_depth-that.options.block_gapfix;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
that.build = function()
|
|
{
|
|
if(!StageManager.managerEntity) return;
|
|
|
|
//delete existing blocks
|
|
that.clear();
|
|
|
|
|
|
//second: resize stage floor
|
|
var managerEntityDimensions = StageManager.managerEntity.entityProperties.dimensions;
|
|
managerEntityDimensions.x = that.options.circle_radius * 2;
|
|
managerEntityDimensions.z = that.options.circle_radius * 2;
|
|
StageManager.managerEntity.edit({dimensions: managerEntityDimensions});
|
|
|
|
|
|
|
|
//create blocks
|
|
var blueprint = that.calc();
|
|
|
|
//center
|
|
var center = {
|
|
x : StageManager.managerEntity.entityProperties.position.x,
|
|
y : StageManager.managerEntity.entityProperties.position.y,
|
|
z : StageManager.managerEntity.entityProperties.position.z,
|
|
};
|
|
|
|
//define identity checker
|
|
var entityIdentifier = new StageEntityIdentifier();
|
|
|
|
var blockColor = that.options.block_color_base;
|
|
var blockColorLum = -0.05 / that.options.levels;
|
|
for(var i in blueprint)
|
|
{
|
|
var level = blueprint[i];
|
|
var blockColorRGB = hexToRgb(blockColor);
|
|
if(that.options.block_color_random) {
|
|
var blockColorRGB = { r: getRandomInt(0,255), g: getRandomInt(0,255), b: getRandomInt(0,255) };
|
|
}
|
|
|
|
//draw blocks
|
|
for(var j in level.blocs)
|
|
{
|
|
var block = level.blocs[j];
|
|
var blockEntityProperties = {
|
|
type: "Box",
|
|
position : {
|
|
x: block.pointCenter.x + center.x,
|
|
z: block.pointCenter.y + center.z,
|
|
y: center.y + that.options.block_height * level.level,
|
|
},
|
|
registrationPoint: {x:0.5, y:0, z:0.5},
|
|
rotation : Quat.fromPitchYawRollRadians(0, -1*block.rotation, 0),
|
|
|
|
dimensions : {
|
|
x: block.proportions.length+that.options.block_gapfix,
|
|
y: that.options.block_height,
|
|
z: that.options.block_depth,
|
|
},
|
|
|
|
velocity: { x: 0, y: 0, z: 0 },
|
|
gravity: { x: 0, y: 0, z: 0 },
|
|
damping: 0,
|
|
color: { red: blockColorRGB.r, green: blockColorRGB.g, blue: blockColorRGB.b },
|
|
|
|
script : that.options.block_script,
|
|
|
|
userData : {
|
|
isStageBlock: true,
|
|
stageEntity : StageManager.managerEntity.entity,
|
|
},
|
|
};
|
|
|
|
var blockEntity = new StageEntity({
|
|
properties : blockEntityProperties,
|
|
// callback : {
|
|
// add : function() { print('add '+JSON.stringify(this)); },
|
|
// identify: function() {print('identify '+JSON.stringify(this));},
|
|
// },
|
|
});
|
|
entityIdentifier.entities.push(blockEntity);
|
|
}
|
|
if(blockColorLum !== 0) blockColor = colorLuminance(blockColor, blockColorLum);
|
|
}
|
|
|
|
//wait for identities and save blocks
|
|
entityIdentifier.process({
|
|
progress : function(identified, total){
|
|
StageInterface.webWindows.manage.emitScriptEvent({
|
|
type: 'action',
|
|
action: 'applyProgress',
|
|
identified : identified,
|
|
total: total,
|
|
});
|
|
},
|
|
done : function(){
|
|
var blocks = [];
|
|
|
|
for(var i in this.entities) {
|
|
blocks.push(this.entities[i].entity);
|
|
}
|
|
|
|
var userData = StageManager.getUserData();
|
|
userData.blocks = blocks;
|
|
StageManager.setUserData(userData);
|
|
StageInterface.webWindows.manage.emitScriptEvent({
|
|
type: 'action',
|
|
action: 'applied',
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
that.clear = function() {
|
|
if(!StageManager.managerEntity) return;
|
|
//delete from hf
|
|
var userData = StageManager.getUserData();
|
|
if(userData.blocks) {
|
|
for(var i in userData.blocks) {
|
|
//load and delete
|
|
new StageEntity({
|
|
entity : userData.blocks[i],
|
|
callback : {
|
|
load : function() {
|
|
this.remove();
|
|
},
|
|
},
|
|
});
|
|
}
|
|
}
|
|
/*
|
|
//delete from userData
|
|
userData.blocks = [];
|
|
StageManager.setUserData(userData);
|
|
*/
|
|
}
|
|
|
|
return that;
|
|
})() |