/*jshint esversion: 6 */
import * as THREE from 'three';
// import { RoundedBoxGeometry } from 'three/addons/geometries/RoundedBoxGeometry.js';
import {FontLoader} from 'three/addons/loaders/FontLoader.js';
import {TextGeometry} from 'three/addons/geometries/TextGeometry.js';
// rack
export function rack(param) {
const width=800, height=2000, depth = param.depth? param.depth: 800, color=0xf0f0f0;
const gunObject = new THREE.Object3D();
const gunmaterial = new THREE.MeshLambertMaterial({color: color});
const gungeometry = new THREE.BoxGeometry(width, height, depth);
const gunmesh = new THREE.Mesh(gungeometry, gunmaterial);
const rackObject = new THREE.Object3D();
rackObject.add(gunmesh);
rackObject.position.set(width/2, height/2, depth/2);
gunObject.add(rackObject);
return gunObject;
}
// transparent wall
export function wall(param) {
const length=3000;
const material = new THREE.MeshBasicMaterial({color: 0xff8080, transparent: true, opacity: 0.2, side: THREE.DoubleSide,});
const geometry = new THREE.CylinderGeometry(10 /*radiusTop*/, 10 /*radiusBottom*/, length /*height*/, 4 /*radialSegments*/, 2 /*heightSegments*/, false /*openEnded*/,0 /*thetaStart*/, Math.PI * 2 /*thetaLength*/);
const chamberMesh = new THREE.Mesh(geometry, material);
chamberMesh.rotateX(Math.PI * 0.5);
chamberMesh.scale.setZ(100);
chamberMesh.rotatedX = true;
return chamberMesh;
}
// label
export function label(param) {
const text=param.name, height=-50;
const length = param && param.labelReverse && param.labelReverse[1]? param.labelReverse[1]: -3000;
const depth = param && param.labelReverse && param.labelReverse[2]? param.labelReverse[2]: -3000;
let size=800;
const materialBase = new THREE.MeshLambertMaterial({color: 0xff0000});
const objLabel = new THREE.Object3D();
let group, textMesh, textGeo, materials;
let textheight = 50;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
objLabel.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = - 0.5 * ( textGeo.boundingBox.max.x - textGeo.boundingBox.min.x );
textMesh = new THREE.Mesh( textGeo, materialBase );
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(size, [length, height, depth], [Math.PI*0.5, Math.PI, 0]);
return objLabel;
}
export function rack2(param) {param.depth=600; return rack(param);}
export function rv(param) {
const width=800, height=2500, depth=800;
const rv = new THREE.Object3D();
const rv_rackObject = new THREE.Object3D();
const pspump_rackObject = new THREE.Object3D();
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialGreyMedium= new THREE.MeshLambertMaterial({color: 0x636363});
const materialVeryGreyDark= new THREE.MeshLambertMaterial({color: 0x242424});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xcfcfcf});
const greenmaterial = new THREE.MeshLambertMaterial({color: 0x17fc03});
const Darkwhitematerial = new THREE.MeshLambertMaterial({color: 0xbababa});
const bluematerial = new THREE.MeshLambertMaterial({color: 0x0053d9});
const softbluematerial = new THREE.MeshLambertMaterial({color: 0x2b7cff});
const screenmaterial = new THREE.MeshLambertMaterial({color: 0xdeebff});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000d0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rv.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(800, 90, 800);
rv.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850, 2330, 550], [0, Math.PI / 2, 0]);
// rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, softbluematerial);
//rrmesh.position.set( 0, 0 , -810);
rv_rackObject.add(rrmesh);
//front yellow tag
const Ftarget = new THREE.BoxGeometry(2, 90, 600);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 1200 , -5);
rv_rackObject.add(Ftargetmesh);
//Rear yellow tag
const Rtarget = new THREE.BoxGeometry(2, 90, 600);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 1200 , -5);
rv_rackObject.add(Rtargetmesh);
//edge lle
const llegeometry = new THREE.BoxGeometry(width-750, height, depth-750);
const llemesh = new THREE.Mesh(llegeometry, bluematerial);
llemesh.position.set( -425, 0 , -365);
rv_rackObject.add(llemesh);
//edge lre
const lregeometry = new THREE.BoxGeometry(width-750, height, depth-750);
const lremesh = new THREE.Mesh(lregeometry, bluematerial);
lremesh.position.set( -425, 0 , 380);
rv_rackObject.add(lremesh);
//edge lue
const luegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const luemesh = new THREE.Mesh(luegeometry, bluematerial);
luemesh.position.set( -425, 1225 , 3);
rv_rackObject.add(luemesh);
//edge lde
const ldegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const ldemesh = new THREE.Mesh(ldegeometry, bluematerial);
ldemesh.position.set( -425, -1230 , 3);
rv_rackObject.add(ldemesh);
//silverbase
const drawer1geometry = new THREE.BoxGeometry(10, 2450, 750);
const drawer1geometrymesh = new THREE.Mesh(drawer1geometry, silvermaterial);
drawer1geometrymesh.position.set( -400, 0 , -10);
rv_rackObject.add(drawer1geometrymesh);
//base PS ionic Pump
const baseionicpump = new THREE.BoxGeometry(10, 250, 300);
const baseionicpumpmesh = new THREE.Mesh(baseionicpump, Darkwhitematerial);
baseionicpumpmesh.position.set( -401, 900 , -150);
pspump_rackObject.add(baseionicpumpmesh);
//sceen PS ionic Pump
const screenionicpump = new THREE.BoxGeometry(10, 60, 180);
const screenionicpumpmesh = new THREE.Mesh(screenionicpump, screenmaterial);
screenionicpumpmesh.position.set( -402, 950 , -150);
pspump_rackObject.add(screenionicpumpmesh);
//button ON OFF PS ionic Pump
const buttonionicpump = new THREE.BoxGeometry(10, 50, 30);
const buttonionicpumpmesh = new THREE.Mesh(buttonionicpump, materialVeryGreyDark);
buttonionicpumpmesh.position.set( -402, 830 , -250);
pspump_rackObject.add(buttonionicpumpmesh);
//button ON Details
const I = new THREE.BoxGeometry(3, 12, 3);
const IMesh = new THREE.Mesh(I, Darkwhitematerial);
IMesh.position.set( -407, 844 , -250);
pspump_rackObject.add(IMesh);
//button OFF Details
const OI1 = new THREE.CylinderGeometry(8, 8, 2, 15);
const OI1Mesh = new THREE.Mesh(OI1, Darkwhitematerial);
OI1Mesh.rotateX(Math.PI * 0.5);
OI1Mesh.rotateY(Math.PI * 1);
OI1Mesh.rotateZ(Math.PI * 0.5);
OI1Mesh.position.set( -407, 817 , -250);
pspump_rackObject.add(OI1Mesh);
//button OFF Details 2
const OI2 = new THREE.CylinderGeometry(6, 6, 2, 15);
const OI2Mesh = new THREE.Mesh(OI2, materialVeryGreyDark);
OI2Mesh.rotateX(Math.PI * 0.5);
OI2Mesh.rotateY(Math.PI * 1);
OI2Mesh.rotateZ(Math.PI * 0.5);
OI2Mesh.position.set( -408, 817 , -250);
pspump_rackObject.add(OI2Mesh);
//border up
const borderup = new THREE.BoxGeometry(10, 2, 260);
const borderupmesh = new THREE.Mesh(borderup, bluematerial);
borderupmesh.position.set( -402, 1000 , -150);
pspump_rackObject.add(borderupmesh);
//border mid
const bordermid = new THREE.BoxGeometry(10, 2, 260);
const bordermidmesh = new THREE.Mesh(bordermid, bluematerial);
bordermidmesh.position.set( -402, 900 , -150);
pspump_rackObject.add(bordermidmesh);
//border left
const borderleft = new THREE.BoxGeometry(10, 100, 2);
const borderleftmesh = new THREE.Mesh(borderleft, bluematerial);
borderleftmesh.position.set( -402, 950 , -280);
pspump_rackObject.add(borderleftmesh);
//border right
const borderright = new THREE.BoxGeometry(10, 100, 2);
const borderrightmesh = new THREE.Mesh(borderright, bluematerial);
borderrightmesh.position.set( -402, 950 , -20);
pspump_rackObject.add(borderrightmesh);
//button1 PS ionic Pump
const button1ionicpump = new THREE.BoxGeometry(10, 30, 30);
const button1ionicpumpmesh = new THREE.Mesh(button1ionicpump, materialGreyDark);
button1ionicpumpmesh.position.set( -402, 830 , -200);
pspump_rackObject.add(button1ionicpumpmesh);
//button2 up PS ionic Pump
const button2ionicpump = new THREE.BoxGeometry(10, 30, 30);
const button2ionicpumpmesh = new THREE.Mesh(button2ionicpump, materialGreyDark);
button2ionicpumpmesh.position.set( -402, 860 , -160);
pspump_rackObject.add(button2ionicpumpmesh);
//button3 up PS ionic Pump
const button3ionicpump = new THREE.BoxGeometry(10, 30, 30);
const button3ionicpumpmesh = new THREE.Mesh(button3ionicpump, materialGreyDark);
button3ionicpumpmesh.position.set( -402, 860 , -120);
pspump_rackObject.add(button3ionicpumpmesh);
//button4 up PS ionic Pump
const button4ionicpump = new THREE.BoxGeometry(10, 30, 30);
const button4ionicpumpmesh = new THREE.Mesh(button4ionicpump, materialGreyDark);
button4ionicpumpmesh.position.set( -402, 860 , -80);
pspump_rackObject.add(button4ionicpumpmesh);
//button5 up PS ionic Pump
const button5ionicpump = new THREE.BoxGeometry(10, 30, 30);
const button5ionicpumpmesh = new THREE.Mesh(button5ionicpump, materialGreyDark);
button5ionicpumpmesh.position.set( -402, 860 , -40);
pspump_rackObject.add(button5ionicpumpmesh);
rv_rackObject.add(pspump_rackObject);
//CLONE PS PUMP
const pump2 = pspump_rackObject.clone();
pump2.position.set( 0, 0 , 310);
rv_rackObject.add(pump2);
const pump3 = pspump_rackObject.clone();
pump3.position.set( 0, -260 , 0);
rv_rackObject.add(pump3);
const pump4 = pspump_rackObject.clone();
pump4.position.set( 0, -260 , 310);
rv_rackObject.add(pump4);
const pump5 = pspump_rackObject.clone();
pump5.position.set( 0, -520 , 0);
rv_rackObject.add(pump5);
const pump6 = pspump_rackObject.clone();
pump6.position.set( 0, -520 , 310);
rv_rackObject.add(pump6);
rv_rackObject.rotateY(Math.PI);
rv_rackObject.position.set(400, 1250, 400);
rv.add(rv_rackObject);
return rv;
}
// ID rack
export function rid(param) {
const width=800, height=1900, depth=600;
const rid = new THREE.Object3D();
const id_rackObject = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000c0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rid.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(800, 90, 650);
rid.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850,1730,550], [0, Math.PI / 2, 0]);
const materialGreyMedium= new THREE.MeshLambertMaterial({color: 0x636363});
const materialVeryGreyDark= new THREE.MeshLambertMaterial({color: 0x242424});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xcfcfcf});
const greenmaterial = new THREE.MeshLambertMaterial({color: 0x17fc03});
const redmaterial = new THREE.MeshLambertMaterial({color: 0xff0000});
const yellowmaterial = new THREE.MeshLambertMaterial({color: 0xcc9d02});
const whitematerial = new THREE.MeshLambertMaterial({color: 0xffffff});
const materialDarkblue = new THREE.MeshLambertMaterial({color: 0x021061});
const materialThightblue = new THREE.MeshLambertMaterial({color: 0x96a5fa});
const materialviolet = new THREE.MeshLambertMaterial({color: 0xa425b8});
const blackmaterial = new THREE.MeshLambertMaterial({color: 0x000000});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
//rack
const rgeometry = new THREE.BoxGeometry(width, height, depth);
const rmesh = new THREE.Mesh(rgeometry, silvermaterial);
rmesh.position.set(0 , 0 , 0);
id_rackObject.add(rmesh);
//screen border
const screenbordergeometry = new THREE.BoxGeometry(10, 250, 350);
const screenbordergeometrymesh = new THREE.Mesh(screenbordergeometry, whitematerial);
screenbordergeometrymesh.position.set( -400, 500 , 0);
id_rackObject.add(screenbordergeometrymesh);
//screen
const screengeometry = new THREE.BoxGeometry(10, 200, 300);
const screengeometrymesh = new THREE.Mesh(screengeometry, materialDarkblue);
screengeometrymesh.position.set( -401, 500 , 0);
id_rackObject.add(screengeometrymesh);
//wiendow screen
const screenwindowgeometry = new THREE.BoxGeometry(10, 150, 150);
const screenwindowgeometrymesh = new THREE.Mesh(screenwindowgeometry, materialThightblue);
screenwindowgeometrymesh.position.set( -402, 500 , -40);
id_rackObject.add(screenwindowgeometrymesh);
//window screen green button
const screenwindowgreenbuttongeometry = new THREE.BoxGeometry(10, 25, 35);
const screenwindowgreenbuttongeometryymesh = new THREE.Mesh(screenwindowgreenbuttongeometry, greenmaterial);
screenwindowgreenbuttongeometryymesh.position.set( -403, 540 , -80);
id_rackObject.add(screenwindowgreenbuttongeometryymesh);
//window screen violet button
const screenwindowvioletbuttongeometry = new THREE.BoxGeometry(10, 25, 35);
const screenwindowvioletbuttongeometryymesh = new THREE.Mesh(screenwindowvioletbuttongeometry, materialviolet);
screenwindowvioletbuttongeometryymesh.position.set( -403, 510 , -80);
id_rackObject.add(screenwindowvioletbuttongeometryymesh);
//window screen blu button
const screenwindowblubuttongeometry = new THREE.BoxGeometry(10, 25, 35);
const screenwindowblubuttongeometryymesh = new THREE.Mesh(screenwindowblubuttongeometry, materialDarkblue);
screenwindowblubuttongeometryymesh.position.set( -403, 480 , -80);
id_rackObject.add(screenwindowblubuttongeometryymesh);
//key
const keygeometry = new THREE.BoxGeometry(50, 200, 50);
const keygeometrymesh = new THREE.Mesh(keygeometry, whitematerial);
keygeometrymesh.position.set( -400, -400 , -250);
id_rackObject.add(keygeometrymesh);
//key2
const key2geometry = new THREE.CylinderGeometry(15, 15, 15, 15);
const key2geometrymesh = new THREE.Mesh(key2geometry, materialGreyMedium);
key2geometrymesh.rotateX(Math.PI * 0.5);
key2geometrymesh.rotateY(Math.PI * 1);
key2geometrymesh.rotateZ(Math.PI * 0.5);
key2geometrymesh.position.set(-421, -400 , -250);
id_rackObject.add(key2geometrymesh);
//whitebutton1
const whitebutton = new THREE.CylinderGeometry(30, 30, 30, 15);
const whitebuttonmesh = new THREE.Mesh(whitebutton, whitematerial);
whitebuttonmesh.rotateX(Math.PI * 0.5);
whitebuttonmesh.rotateY(Math.PI * 1);
whitebuttonmesh.rotateZ(Math.PI * 0.5);
whitebuttonmesh.position.set(-405, 200 , -200);
id_rackObject.add(whitebuttonmesh);
//blackbutton1
const blackbutton1 = new THREE.CylinderGeometry(30, 30, 30, 15);
const blackbutton1mesh = new THREE.Mesh(blackbutton1, materialVeryGreyDark);
blackbutton1mesh.rotateX(Math.PI * 0.5);
blackbutton1mesh.rotateY(Math.PI * 1);
blackbutton1mesh.rotateZ(Math.PI * 0.5);
blackbutton1mesh.position.set(-405, 200 , -100);
id_rackObject.add(blackbutton1mesh);
//blackbutton2
const blackbutton2 = new THREE.CylinderGeometry(30, 30, 30, 15);
const blackbutton2mesh = new THREE.Mesh(blackbutton2, materialVeryGreyDark);
blackbutton2mesh.rotateX(Math.PI * 0.5);
blackbutton2mesh.rotateY(Math.PI * 1);
blackbutton2mesh.rotateZ(Math.PI * 0.5);
blackbutton2mesh.position.set(-405, 200 , 0);
id_rackObject.add(blackbutton2mesh);
//blackbutton3
const blackbutton3 = new THREE.CylinderGeometry(30, 30, 30, 15);
const blackbutton3mesh = new THREE.Mesh(blackbutton3, materialVeryGreyDark);
blackbutton3mesh.rotateX(Math.PI * 0.5);
blackbutton3mesh.rotateY(Math.PI * 1);
blackbutton3mesh.rotateZ(Math.PI * 0.5);
blackbutton3mesh.position.set(-405, 200 , 100);
id_rackObject.add(blackbutton3mesh);
//yellowbutton
const yellowbutton = new THREE.CylinderGeometry(30, 30, 30, 15);
const yellowbuttonmesh = new THREE.Mesh(yellowbutton, yellowmaterial);
yellowbuttonmesh.rotateX(Math.PI * 0.5);
yellowbuttonmesh.rotateY(Math.PI * 1);
yellowbuttonmesh.rotateZ(Math.PI * 0.5);
yellowbuttonmesh.position.set(-405, 200 , 200);
id_rackObject.add(yellowbuttonmesh);
//emergencybutton yellow
const emergencybuttonyellow = new THREE.CylinderGeometry(70, 70, 5, 15);
const emergencybuttonyellowmesh = new THREE.Mesh(emergencybuttonyellow, yellowmaterial);
emergencybuttonyellowmesh.rotateX(Math.PI * 0.5);
emergencybuttonyellowmesh.rotateY(Math.PI * 1);
emergencybuttonyellowmesh.rotateZ(Math.PI * 0.5);
emergencybuttonyellowmesh.position.set(-403, 50 , 150);
id_rackObject.add(emergencybuttonyellowmesh);
//emergencybutton red
const emergencybutton = new THREE.CylinderGeometry(50, 50, 30, 15);
const emergencybuttonmesh = new THREE.Mesh(emergencybutton, redmaterial);
emergencybuttonmesh.rotateX(Math.PI * 0.5);
emergencybuttonmesh.rotateY(Math.PI * 1);
emergencybuttonmesh.rotateZ(Math.PI * 0.5);
emergencybuttonmesh.position.set(-405, 50 , 150);
id_rackObject.add(emergencybuttonmesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 500);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 900 , -15);
id_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 500);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 900 , -15);
id_rackObject.add(Rtargetmesh);
id_rackObject.rotateY(Math.PI);
id_rackObject.position.set(400, 950, 300);
rid.add(id_rackObject);
return rid;
}
// Low Level RF Rack
export function rllrf(param) {
const width=800, height=1900, depth=600;
const rllrf = new THREE.Object3D();
const llrf_rackObject = new THREE.Object3D();
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0xa6a6a6});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
const materialDark= new THREE.MeshLambertMaterial({color: 0x000000});
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000c0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rllrf.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(1200, 90, 400);
rllrf.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [1000,1270,440], [0, Math.PI / 2, 0]);
// rack llrf
const rrgeometry = new THREE.BoxGeometry(800, 1500, 600);
const rrmesh = new THREE.Mesh(rrgeometry, materialGreyDark);
rrmesh.position.set( 0, 0 , -depth+290);
llrf_rackObject.add(rrmesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 550);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -405, 640 , -300);
llrf_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 550);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 405, 640 , -300);
llrf_rackObject.add(Rtargetmesh);
//handle
const handlegeometry = new THREE.BoxGeometry(30, 300, 70);
const handlegeometrymesh = new THREE.Mesh(handlegeometry, materialDark);
handlegeometrymesh.position.set( -401, 0 , -550);
llrf_rackObject.add(handlegeometrymesh);
llrf_rackObject.rotateY(Math.PI);
llrf_rackObject.position.set(600, 750, -depth+500);
rllrf.add(llrf_rackObject);
return rllrf;
}
// Bending rack
export function rpsb(param) {
const width=1000, height=2100, depth=1000;
const rpsb = new THREE.Object3D();
const rpsb_rackObject = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000d0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rpsb.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(790, 90, -850);
rpsb.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [900, 1930, -850], [0, Math.PI / 2, 0]);
const greenmaterial = new THREE.MeshLambertMaterial({color: 0x00ac76});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
const redmaterial = new THREE.MeshLambertMaterial({color: 0xff0000});
const yellowmaterial = new THREE.MeshLambertMaterial({color: 0xcc9d02});
const whitematerial = new THREE.MeshLambertMaterial({color: 0xffffff});
const materialThightblue = new THREE.MeshLambertMaterial({color: 0x96a5fa});
const materialDarkblue = new THREE.MeshLambertMaterial({color: 0x021061});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
//rack
const geometry = new THREE.BoxGeometry(width, height, depth);
const rackmesh = new THREE.Mesh(geometry, greenmaterial);
rackmesh.position.set( 0, 0 ,0);
rpsb_rackObject.add(rackmesh);
//emergencybutton yellow
const emergencybuttonyellow = new THREE.CylinderGeometry(70, 70, 5, 15);
const emergencybuttonyellowmesh = new THREE.Mesh(emergencybuttonyellow, yellowmaterial);
emergencybuttonyellowmesh.rotateX(Math.PI * 0.5);
emergencybuttonyellowmesh.rotateY(Math.PI * 1);
emergencybuttonyellowmesh.rotateZ(Math.PI * 0.5);
emergencybuttonyellowmesh.position.set(-503, 320 , 0);
rpsb_rackObject.add(emergencybuttonyellowmesh);
//emergencybutton red
const emergencybutton = new THREE.CylinderGeometry(50, 50, 30, 15);
const emergencybuttonmesh = new THREE.Mesh(emergencybutton, redmaterial);
emergencybuttonmesh.rotateX(Math.PI * 0.5);
emergencybuttonmesh.rotateY(Math.PI * 1);
emergencybuttonmesh.rotateZ(Math.PI * 0.5);
emergencybuttonmesh.position.set(-505, 320 , 0);
rpsb_rackObject.add(emergencybuttonmesh);
//base border
const screenbordergeometry = new THREE.BoxGeometry(10, 350, 450);
const screenbordergeometrymesh = new THREE.Mesh(screenbordergeometry, whitematerial);
screenbordergeometrymesh.position.set( -500, 600 , 0);
rpsb_rackObject.add(screenbordergeometrymesh);
//screen border
const basebordergeometry = new THREE.BoxGeometry(10, 100, 100);
const basebordergeometrymesh = new THREE.Mesh(basebordergeometry, silvermaterial);
basebordergeometrymesh.position.set( -501, 700 , 0);
rpsb_rackObject.add(basebordergeometrymesh);
//screen
const screengeometry = new THREE.BoxGeometry(10, 80, 80);
const screengeometrymesh = new THREE.Mesh(screengeometry, materialDarkblue);
screengeometrymesh.position.set( -502, 700 , 0);
rpsb_rackObject.add(screengeometrymesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 600);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -504, 999 , 0);
rpsb_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 600);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 504, 999 , 0);
rpsb_rackObject.add(Rtargetmesh);
rpsb_rackObject.rotateY(Math.PI);
//rpsb_rackObject.position.set(400, 1050, -400);
rpsb_rackObject.position.set(width/2, height/2, depth/2);
rpsb.add(rpsb_rackObject);
return rpsb;
}
// PS rack
export function rps(param) {
const width=800, height=2500, depth=600;
const psObject = new THREE.Object3D();
const rps_rackObject = new THREE.Object3D();
const rps = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000b0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rps.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(850, 90, 550);
rps.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850, 2330, 550], [0, Math.PI / 2, 0]);
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialGreyMedium= new THREE.MeshLambertMaterial({color: 0x636363});
const materialVeryGreyDark= new THREE.MeshLambertMaterial({color: 0x242424});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const greenmaterial = new THREE.MeshLambertMaterial({color: 0x17fc03});
const whitematerial = new THREE.MeshLambertMaterial({color: 0xffffff});
const redmaterial = new THREE.MeshLambertMaterial({color: 0xff0000});
const bluematerial = new THREE.MeshLambertMaterial({color: 0x0053d9});
const softbluematerial = new THREE.MeshLambertMaterial({color: 0x2b7cff});
const screenmaterial = new THREE.MeshLambertMaterial({color: 0xdeebff});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
// rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, softbluematerial);
rrmesh.position.set( 0, 0 , 0);
rps_rackObject.add(rrmesh);
//edge le
const llegeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const llemesh = new THREE.Mesh(llegeometry, bluematerial);
llemesh.position.set( -425, 0 , -285);
rps_rackObject.add(llemesh);
//edge re
const lregeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const lremesh = new THREE.Mesh(lregeometry, bluematerial);
lremesh.position.set( -425, 0 , 265);
rps_rackObject.add(lremesh);
//edge ue
const luegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const luemesh = new THREE.Mesh(luegeometry, bluematerial);
luemesh.position.set( -425, 1225 , -7);
rps_rackObject.add(luemesh);
//edge de
const ldegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const ldemesh = new THREE.Mesh(ldegeometry, bluematerial);
ldemesh.position.set( -425, -1230 , -7);
rps_rackObject.add(ldemesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 600);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 1200 , -15);
rps_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 600);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 1200 , -15);
rps_rackObject.add(Rtargetmesh);
// START PS base RED
const basered = new THREE.BoxGeometry(10, 30, 110);
const baseredmesh = new THREE.Mesh(basered, redmaterial);
baseredmesh.position.set( -401, 1100 , -170);
psObject.add(baseredmesh);
// PS base BLUE
const baseblue = new THREE.BoxGeometry(10, 180, 110);
const basebluemesh = new THREE.Mesh(baseblue, bluematerial);
basebluemesh.position.set( -401, 995 , -170);
psObject.add(basebluemesh);
// PS base SILVER
const basesilver = new THREE.BoxGeometry(10, 150, 500);
const basesilvermesh = new THREE.Mesh(basesilver, silvermaterial);
basesilvermesh.position.set( -401, -300 , 0);
rps_rackObject.add(basesilvermesh);
rps_rackObject.add(psObject);
//CLONE PS
const psA2 = psObject.clone();
psA2.position.set( 0, 0 , 120);
rps_rackObject.add(psA2);
const psA3 = psObject.clone();
psA3.position.set( 0, 0 , 240);
rps_rackObject.add(psA3);
const psB1 = psObject.clone();
psB1.position.set( 0, -220 , 0);
rps_rackObject.add(psB1);
const psB2 = psObject.clone();
psB2.position.set( 0, -220 , 120);
rps_rackObject.add(psB2);
const psB3 = psObject.clone();
psB3.position.set( 0, -220 , 240);
rps_rackObject.add(psB3);
const psC1 = psObject.clone();
psC1.position.set( 0, -440 , 0);
rps_rackObject.add(psC1);
const psC2 = psObject.clone();
psC2.position.set( 0, -440 , 120);
rps_rackObject.add(psC2);
const psC3 = psObject.clone();
psC3.position.set( 0, -440 , 240);
rps_rackObject.add(psC3);
const psD1 = psObject.clone();
psD1.position.set( 0, -660 , 0);
rps_rackObject.add(psD1);
const psD2 = psObject.clone();
psD2.position.set( 0, -660 , 120);
rps_rackObject.add(psD2);
const psD3 = psObject.clone();
psD3.position.set( 0, -660 , 240);
rps_rackObject.add(psD3);
const psE1 = psObject.clone();
psE1.position.set( 0, -880 , 0);
rps_rackObject.add(psE1);
const psE2 = psObject.clone();
psE2.position.set( 0, -880 , 120);
rps_rackObject.add(psE2);
const psE3 = psObject.clone();
psE3.position.set( 0, -880 , 240);
rps_rackObject.add(psE3);
rps_rackObject.rotateY(Math.PI);
rps_rackObject.position.set(400, 1250, 300);
rps.add(rps_rackObject);
return rps;
}
// Control rack
export function rc(param) {
const width=800, height=2500, depth=600;
const rc = new THREE.Object3D();
const rc_rackObject = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000d0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rc.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(850, 90, 550);
rc.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850, 2330, 550], [0, Math.PI / 2, 0]);
const bluematerial = new THREE.MeshLambertMaterial({color: 0x0053d9});
const softbluematerial = new THREE.MeshLambertMaterial({color: 0x2b7cff});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialGreyMedium= new THREE.MeshLambertMaterial({color: 0x636363});
//rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, softbluematerial);
rrmesh.position.set( 0, 0 , -10);
rc_rackObject.add(rrmesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 500);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 1200 , -15);
rc_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 500);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 1200 , -15);
rc_rackObject.add(Rtargetmesh);
//edge le
const llegeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const llemesh = new THREE.Mesh(llegeometry, bluematerial);
llemesh.position.set( -425, 0 , -285);
rc_rackObject.add(llemesh);
//edge re
const lregeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const lremesh = new THREE.Mesh(lregeometry, bluematerial);
lremesh.position.set( -425, 0 , 265);
rc_rackObject.add(lremesh);
//edge ue
const luegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const luemesh = new THREE.Mesh(luegeometry, bluematerial);
luemesh.position.set( -425, 1225 , -7);
rc_rackObject.add(luemesh);
//edge de
const ldegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const ldemesh = new THREE.Mesh(ldegeometry, bluematerial);
ldemesh.position.set( -425, -1230 , -7);
rc_rackObject.add(ldemesh);
//borderEC down
const borderECgeometry = new THREE.BoxGeometry(10, 400, 600);
const borderECgeometrymesh = new THREE.Mesh(borderECgeometry, materialGreyDark);
borderECgeometrymesh.position.set( -400, -250 , -10);
rc_rackObject.add(borderECgeometrymesh);
//EC1 down
const EC1geometry = new THREE.BoxGeometry(10, 350, 40);
const EC1geometrymesh = new THREE.Mesh(EC1geometry, materialGreyMedium);
EC1geometrymesh.position.set( -402, -250 , -200);
rc_rackObject.add(EC1geometrymesh);
//EC2 down
const EC2geometry = new THREE.BoxGeometry(10, 350, 40);
const EC2geometrymesh = new THREE.Mesh(EC2geometry, materialGreyMedium);
EC2geometrymesh.position.set( -402, -250 , -150);
rc_rackObject.add(EC2geometrymesh);
//EC2 down
const EC3geometry = new THREE.BoxGeometry(10, 350, 40);
const EC3geometrymesh = new THREE.Mesh(EC3geometry, materialGreyMedium);
EC3geometrymesh.position.set( -402, -250 , -100);
rc_rackObject.add(EC3geometrymesh);
//borderEC up
const borderupECgeometry = new THREE.BoxGeometry(10, 400, 600);
const borderupECgeometrymesh = new THREE.Mesh(borderupECgeometry, materialGreyDark);
borderupECgeometrymesh.position.set( -400, 250 , -10);
rc_rackObject.add(borderupECgeometrymesh);
//EC1 up
const EC1geometryup = new THREE.BoxGeometry(10, 350, 40);
const EC1geometryupmesh = new THREE.Mesh(EC1geometryup, materialGreyMedium);
EC1geometryupmesh.position.set( -402, 250 , -200);
rc_rackObject.add(EC1geometryupmesh);
//EC2 up
const EC2geometryup = new THREE.BoxGeometry(10, 350, 40);
const EC2geometryupmesh = new THREE.Mesh(EC2geometryup, materialGreyMedium);
EC2geometryupmesh.position.set( -402, 250 , -150);
rc_rackObject.add(EC2geometryupmesh);
//EC2 up
const EC3geometryup = new THREE.BoxGeometry(10, 350, 40);
const EC3geometryupmesh = new THREE.Mesh(EC3geometryup, materialGreyMedium);
EC3geometryupmesh.position.set( -402, 250 , -100);
rc_rackObject.add(EC3geometryupmesh);
rc_rackObject.rotateY(Math.PI);
rc_rackObject.position.set(400, 1250, 300);
rc.add(rc_rackObject);
return rc;
}
// diagnostic rack
export function rd(param) {
const width=800, height=2500, depth=600;
const rd = new THREE.Object3D();
const rd_rackObject = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000d0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rd.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(850, 90, 550);
rd.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850, 2330, 500], [0, Math.PI / 2, 0]);
const bluematerial = new THREE.MeshLambertMaterial({color: 0x0053d9});
const softbluematerial = new THREE.MeshLambertMaterial({color: 0x2b7cff});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialGreyMedium= new THREE.MeshLambertMaterial({color: 0x636363});
//rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, softbluematerial);
rrmesh.position.set( 0, 0 , -10);
rd_rackObject.add(rrmesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 500);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 1200 , -15);
rd_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 500);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 1200 , -15);
rd_rackObject.add(Rtargetmesh);
//edge le
const llegeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const llemesh = new THREE.Mesh(llegeometry, bluematerial);
llemesh.position.set( -425, 0 , -285);
rd_rackObject.add(llemesh);
//edge re
const lregeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const lremesh = new THREE.Mesh(lregeometry, bluematerial);
lremesh.position.set( -425, 0 , 265);
rd_rackObject.add(lremesh);
//edge ue
const luegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const luemesh = new THREE.Mesh(luegeometry, bluematerial);
luemesh.position.set( -425, 1225 , -7);
rd_rackObject.add(luemesh);
//edge de
const ldegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const ldemesh = new THREE.Mesh(ldegeometry, bluematerial);
ldemesh.position.set( -425, -1230 , -7);
rd_rackObject.add(ldemesh);
//borderEC
const borderECgeometry = new THREE.BoxGeometry(10, 400, 600);
const borderECgeometrymesh = new THREE.Mesh(borderECgeometry, materialGreyDark);
borderECgeometrymesh.position.set( -400, 0 , -10);
rd_rackObject.add(borderECgeometrymesh);
//EC1
const EC1geometry = new THREE.BoxGeometry(10, 350, 40);
const EC1geometrymesh = new THREE.Mesh(EC1geometry, materialGreyMedium);
EC1geometrymesh.position.set( -402, 0 , -200);
rd_rackObject.add(EC1geometrymesh);
//EC2
const EC2geometry = new THREE.BoxGeometry(10, 350, 40);
const EC2geometrymesh = new THREE.Mesh(EC2geometry, materialGreyMedium);
EC2geometrymesh.position.set( -402, 0 , -150);
rd_rackObject.add(EC2geometrymesh);
//EC2
const EC3geometry = new THREE.BoxGeometry(10, 350, 40);
const EC3geometrymesh = new THREE.Mesh(EC3geometry, materialGreyMedium);
EC3geometrymesh.position.set( -402, 0 , -100);
rd_rackObject.add(EC3geometrymesh);
//libera 1
const libera1geometry = new THREE.BoxGeometry(10, 100, 600);
const libera1geometrymesh = new THREE.Mesh(libera1geometry, materialGreyMedium);
libera1geometrymesh.position.set( -400, 900 , -10);
rd_rackObject.add(libera1geometrymesh);
//libera 2
const libera2geometrymesh = new THREE.Mesh(libera1geometry, materialGreyMedium);
libera2geometrymesh.position.set( -400, 750 , -10);
rd_rackObject.add(libera2geometrymesh);
//libera 3
const libera3geometrymesh = new THREE.Mesh(libera1geometry, materialGreyMedium);
libera3geometrymesh.position.set( -400, 600 , -10);
rd_rackObject.add(libera3geometrymesh);
//libera 4
const libera4geometrymesh = new THREE.Mesh(libera1geometry, materialGreyMedium);
libera4geometrymesh.position.set( -400, -600 , -10);
rd_rackObject.add(libera4geometrymesh);
//libera 5
const libera5geometrymesh = new THREE.Mesh(libera1geometry, materialGreyMedium);
libera5geometrymesh.position.set( -400, -750 , -10);
rd_rackObject.add(libera5geometrymesh);
//libera 6
const libera6geometrymesh = new THREE.Mesh(libera1geometry, materialGreyMedium);
libera6geometrymesh.position.set( -400, -900 , -10);
rd_rackObject.add(libera6geometrymesh);
rd_rackObject.rotateY(Math.PI);
rd_rackObject.position.set(400, 1250, 300);
rd.add(rd_rackObject);
return rd;
}
// RRP rack
export function rrp(param) {
const width=800, height=2500, depth=600;
const rrp = new THREE.Object3D();
const rrp_rackObject = new THREE.Object3D();
const blackbaseObject = new THREE.Object3D();
const bluematerial = new THREE.MeshLambertMaterial({color: 0x0053d9});
const softbluematerial = new THREE.MeshLambertMaterial({color: 0x2b7cff});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const blackmaterial = new THREE.MeshLambertMaterial({color: 0x000000});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000d0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rrp.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(850, 90, 1200);
rrp.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850, 2330, 800], [0, Math.PI / 2, 0]);
// rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, softbluematerial);
rrmesh.position.set( 0, 0 , -10);
rrp_rackObject.add(rrmesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 500);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 1200 , -15);
rrp_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 500);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 1200 , -15);
rrp_rackObject.add(Rtargetmesh);
//edge le
const llegeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const llemesh = new THREE.Mesh(llegeometry, bluematerial);
llemesh.position.set( -425, 0 , -285);
rrp_rackObject.add(llemesh);
//edge re
const lregeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const lremesh = new THREE.Mesh(lregeometry, bluematerial);
lremesh.position.set( -425, 0 , 265);
rrp_rackObject.add(lremesh);
//edge ue
const luegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const luemesh = new THREE.Mesh(luegeometry, bluematerial);
luemesh.position.set( -425, 1225 , -7);
rrp_rackObject.add(luemesh);
//edge de
const ldegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const ldemesh = new THREE.Mesh(ldegeometry, bluematerial);
ldemesh.position.set( -425, -1230 , -7);
rrp_rackObject.add(ldemesh);
// blackbase 1
const black1geometry = new THREE.BoxGeometry(3, 200, 550);
const black1geometrymesh = new THREE.Mesh(black1geometry, blackmaterial);
black1geometrymesh.position.set( -402, 1000 , 0);
rrp_rackObject.add(black1geometrymesh);
// blackbase 2
const black2geometry = new THREE.BoxGeometry(3, 200, 550);
const black2geometrymesh = new THREE.Mesh(black2geometry, blackmaterial);
black2geometrymesh.position.set( -402, 780 , 0);
rrp_rackObject.add(black2geometrymesh);
// blackbase 3
const black3geometry = new THREE.BoxGeometry(3, 200, 550);
const black3geometrymesh = new THREE.Mesh(black3geometry, blackmaterial);
black3geometrymesh.position.set( -402, 560 , 0);
rrp_rackObject.add(black3geometrymesh);
// blackbase 4
const black4geometry = new THREE.BoxGeometry(3, 200, 550);
const black4geometrymesh = new THREE.Mesh(black4geometry, blackmaterial);
black4geometrymesh.position.set( -402, 340 , 0);
blackbaseObject.add(black4geometrymesh);
const square1geometry = new THREE.BoxGeometry(3, 70, 70);
const square1geometrymesh = new THREE.Mesh(square1geometry, silvermaterial);
square1geometrymesh.position.set( -403, 340 , -100);
blackbaseObject.add(square1geometrymesh);
const square2geometry = new THREE.BoxGeometry(3, 70, 70);
const square2geometrymesh = new THREE.Mesh(square2geometry, silvermaterial);
square2geometrymesh.position.set( -403, 340 , 100);
blackbaseObject.add(square2geometrymesh);
//CLONE PS
const psA2 = blackbaseObject.clone();
psA2.position.set( 0, -220 , 0);
rrp_rackObject.add(psA2);
const psA3 = blackbaseObject.clone();
psA3.position.set( 0, -440 , 0);
rrp_rackObject.add(psA3);
rrp_rackObject.add(blackbaseObject);
// silverbase
const silvergeometry = new THREE.BoxGeometry(3, 200, 550);
const silvergeometrymesh = new THREE.Mesh(silvergeometry, silvermaterial);
silvergeometrymesh.position.set( -402, -320 , 0);
rrp_rackObject.add(silvergeometrymesh);
//lastblack
const black5geometry = new THREE.BoxGeometry(3, 780, 550);
const black5geometrymesh = new THREE.Mesh(black5geometry, blackmaterial);
black5geometrymesh.position.set( -402, -830 , 0);
rrp_rackObject.add(black5geometrymesh);
rrp_rackObject.rotateY(Math.PI);
rrp_rackObject.position.set(400, 1250, depth);
rrp.add(rrp_rackObject);
return rrp;
}
// RAR 1 - 2 - 3
export function rar1(param) {
const width=800, height=2500, depth=800;
const rar = new THREE.Object3D();
const kly_rackObject = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000d0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rar.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(850, 80, 750);
rar.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850, 2330, 600], [0, Math.PI / 2, 0]);
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialGreyMedium= new THREE.MeshLambertMaterial({color: 0x636363});
const materialVeryGreyDark= new THREE.MeshLambertMaterial({color: 0x242424});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const greenmaterial = new THREE.MeshLambertMaterial({color: 0x17fc03});
const redmaterial = new THREE.MeshLambertMaterial({color: 0xff0000});
const yellowmaterial = new THREE.MeshLambertMaterial({color: 0xcc9d02});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
//right rack
const lrgeometry = new THREE.BoxGeometry(width, height, depth);
const lrmesh = new THREE.Mesh(lrgeometry, silvermaterial);
lrmesh.position.set(0 , 0 , 0);
kly_rackObject.add(lrmesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 700);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 1200 , -15);
kly_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 700);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 1200 , -15);
kly_rackObject.add(Rtargetmesh);
//edge rle
const rlegeometry = new THREE.BoxGeometry(width-750, height, depth-750);
const rlemesh = new THREE.Mesh(rlegeometry, materialGreyDark);
rlemesh.position.set( -425, 0 , -370);
kly_rackObject.add(rlemesh);
//edge rre
const rregeometry = new THREE.BoxGeometry(width-750, height, depth-750);
const rremesh = new THREE.Mesh(rregeometry, materialGreyDark);
rremesh.position.set( -425, 0 , 375);
kly_rackObject.add(rremesh);
//edge rue
const ruegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const ruemesh = new THREE.Mesh(ruegeometry, materialGreyDark);
ruemesh.position.set( -425, 1225 , 0);
kly_rackObject.add(ruemesh);
//edge rde
const rdegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const rdemesh = new THREE.Mesh(rdegeometry, materialGreyDark);
rdemesh.position.set( -425, -1230 , 0);
kly_rackObject.add(rdemesh);
//drawer1 rack right
const drawer1rrgeometry = new THREE.BoxGeometry(10, 250, 630);
const drawer1rrgeometrymesh = new THREE.Mesh(drawer1rrgeometry, materialGreyDark);
drawer1rrgeometrymesh.position.set( -400, 1000 , 0);
kly_rackObject.add(drawer1rrgeometrymesh);
//display right rack
const display1rrgeometry = new THREE.BoxGeometry(50, 50, 150);
const display1rrgeometrymesh = new THREE.Mesh(display1rrgeometry, materialVeryGreyDark);
display1rrgeometrymesh.position.set( -400, 1000 , 0);
kly_rackObject.add(display1rrgeometrymesh);
//GreenLed1 right rack
const greenled1rr = new THREE.SphereGeometry(13, 10, 10);
const greenled1rrmesh = new THREE.Mesh(greenled1rr, greenmaterial);
greenled1rrmesh.position.set(-400, 1050 , 200);
kly_rackObject.add(greenled1rrmesh);
//GreenLed2 right rack
const greenled2rr = new THREE.SphereGeometry(13, 10, 10);
const greenled2rrmesh = new THREE.Mesh(greenled2rr, greenmaterial);
greenled2rrmesh.position.set(-400, 1000 , 200);
kly_rackObject.add(greenled2rrmesh);
//GreenLed3 right rack
const greenled3rr = new THREE.SphereGeometry(13, 10, 10);
const greenled3rrmesh = new THREE.Mesh(greenled3rr, greenmaterial);
greenled3rrmesh.position.set(-400, 950 , 200);
kly_rackObject.add(greenled3rrmesh);
//drawer2 rack right
const drawer2rrgeometry = new THREE.BoxGeometry(10, 250, 630);
const drawer2rrgeometrymesh = new THREE.Mesh(drawer2rrgeometry, materialGreyDark);
drawer2rrgeometrymesh.position.set( -400, 700 , 0);
kly_rackObject.add(drawer2rrgeometrymesh);
//blackbutton1 right rack
const blackled1rr = new THREE.SphereGeometry(30, 10, 10);
const blackled1rrmesh = new THREE.Mesh(blackled1rr, materialVeryGreyDark);
blackled1rrmesh.position.set(-400, 750 , -200);
kly_rackObject.add(blackled1rrmesh);
//blackbutton2 right rack
const blackled2rr = new THREE.SphereGeometry(30, 10, 10);
const blackled2rrmesh = new THREE.Mesh(blackled2rr, materialVeryGreyDark);
blackled2rrmesh.position.set(-400, 670 , -200);
kly_rackObject.add(blackled2rrmesh);
//GreenLED1 right rack
const greenled1rrdrawer2 = new THREE.SphereGeometry(25, 10, 10);
const greenled1rrdrawer2rmesh = new THREE.Mesh(greenled1rrdrawer2, greenmaterial);
greenled1rrdrawer2rmesh.position.set(-400, 750 , -50);
kly_rackObject.add(greenled1rrdrawer2rmesh);
//yellowLED1 right rack
const yellowled1rrdrawer2 = new THREE.SphereGeometry(25, 10, 10);
const yellowled1rrdrawer2rmesh = new THREE.Mesh(yellowled1rrdrawer2, yellowmaterial);
yellowled1rrdrawer2rmesh.position.set(-400, 750 , 30);
kly_rackObject.add(yellowled1rrdrawer2rmesh);
//emergencyLED1 right rack
const emergencybutton = new THREE.CylinderGeometry(70, 10, 10);
const emergencybuttonmesh = new THREE.Mesh(emergencybutton, redmaterial);
emergencybuttonmesh.rotateX(Math.PI * 0.5);
emergencybuttonmesh.rotateY(Math.PI * 1);
emergencybuttonmesh.rotateZ(Math.PI * 0.5);
emergencybuttonmesh.position.set(-405, 700 , 150);
kly_rackObject.add(emergencybuttonmesh);
//drawer3 rack right
const drawer3rrgeometry = new THREE.BoxGeometry(10, 250, 630);
const drawer3rrgeometrymesh = new THREE.Mesh(drawer3rrgeometry, materialGreyMedium);
drawer3rrgeometrymesh.position.set( -400, 400 , 0);
kly_rackObject.add(drawer3rrgeometrymesh);
//darkscreen rack right
const darkscreenrrgeometry = new THREE.BoxGeometry(10, 150, 270);
const darkscreenrrgeometrymesh = new THREE.Mesh(darkscreenrrgeometry, materialVeryGreyDark);
darkscreenrrgeometrymesh.position.set( -402, 400 , -120);
kly_rackObject.add(darkscreenrrgeometrymesh);
//drawer4 rack right
const drawer4rrgeometry = new THREE.BoxGeometry(10, 250, 630);
const drawer4rrgeometrymesh = new THREE.Mesh(drawer4rrgeometry, materialGreyDark);
drawer4rrgeometrymesh.position.set( -400, 100 , 0);
kly_rackObject.add(drawer4rrgeometrymesh);
//drawer4 dark rack right
const drawer4darkrrgeometry = new THREE.BoxGeometry(10, 220, 500);
const drawer4darkrrgeometrymesh = new THREE.Mesh(drawer4darkrrgeometry, materialVeryGreyDark);
drawer4darkrrgeometrymesh.position.set( -402, 100 , 50);
kly_rackObject.add(drawer4darkrrgeometrymesh);
//GreenLed1 drawer4 right rack
const greenled1drawer4rr = new THREE.SphereGeometry(13, 10, 10);
const greenled1drawer4rrmesh = new THREE.Mesh(greenled1drawer4rr, greenmaterial);
greenled1drawer4rrmesh.position.set(-400, 150 , -250);
kly_rackObject.add(greenled1drawer4rrmesh);
//GreenLed2 drawer4 right rack
const greenled2drawer4rr = new THREE.SphereGeometry(13, 10, 10);
const greenled2drawer4rrmesh = new THREE.Mesh(greenled2drawer4rr, greenmaterial);
greenled2drawer4rrmesh.position.set(-400, 100 , -250);
kly_rackObject.add(greenled2drawer4rrmesh);
//GreenLed3 drawer4 right rack
const greenled3drawer4rr = new THREE.SphereGeometry(13, 10, 10);
const greenled3drawer4rrmesh = new THREE.Mesh(greenled3drawer4rr, greenmaterial);
greenled3drawer4rrmesh.position.set(-400, 50 , -250);
kly_rackObject.add(greenled3drawer4rrmesh);
//RdLed1 drawer4 right rack
const greenred1drawer4rr = new THREE.SphereGeometry(13, 10, 10);
const greenred1drawer4rrmesh = new THREE.Mesh(greenred1drawer4rr, redmaterial);
greenred1drawer4rrmesh.position.set(-400, 150 , 180);
kly_rackObject.add(greenred1drawer4rrmesh);
//RdLed1 drawer4 right rack
const greenred2drawer4rr = new THREE.SphereGeometry(13, 10, 10);
const greenred2drawer4rrmesh = new THREE.Mesh(greenred2drawer4rr, redmaterial);
greenred2drawer4rrmesh.position.set(-400, 100 , 180);
kly_rackObject.add(greenred2drawer4rrmesh);
//drawer5 rack right
const drawer5rrgeometry = new THREE.BoxGeometry(10, 350, 630);
const drawer5rrgeometrymesh = new THREE.Mesh(drawer5rrgeometry, materialGreyDark);
drawer5rrgeometrymesh.position.set( -400, -250 , 0);
kly_rackObject.add(drawer5rrgeometrymesh);
//display1 drawer5 rack right
const display1drawer5rrgeometry = new THREE.BoxGeometry(30, 70, 150);
const display1drawer5rrgeometrymesh = new THREE.Mesh(display1drawer5rrgeometry, materialVeryGreyDark);
display1drawer5rrgeometrymesh.position.set( -402, -120 , 0);
kly_rackObject.add(display1drawer5rrgeometrymesh);
//display2 drawer5 rack right
const display2drawer5rrgeometry = new THREE.BoxGeometry(30, 70, 150);
const display2drawer5rrgeometrymesh = new THREE.Mesh(display2drawer5rrgeometry, materialVeryGreyDark);
display2drawer5rrgeometrymesh.position.set( -402, -200 , 0);
kly_rackObject.add(display2drawer5rrgeometrymesh);
//display3 drawer5 rack right
const display3drawer5rrgeometry = new THREE.BoxGeometry(30, 70, 150);
const display3drawer5rrgeometrymesh = new THREE.Mesh(display3drawer5rrgeometry, materialVeryGreyDark);
display3drawer5rrgeometrymesh.position.set( -402, -280 , 0);
kly_rackObject.add(display3drawer5rrgeometrymesh);
//display4 drawer5 rack right
const display4drawer5rrgeometry = new THREE.BoxGeometry(30, 70, 150);
const display4drawer5rrgeometrymesh = new THREE.Mesh(display4drawer5rrgeometry, materialVeryGreyDark);
display4drawer5rrgeometrymesh.position.set( -402, -360 , 0);
kly_rackObject.add(display4drawer5rrgeometrymesh);
//drawer6 rack right
const drawer6rrgeometry = new THREE.BoxGeometry(10, 350, 630);
const drawer6rrgeometrymesh = new THREE.Mesh(drawer5rrgeometry, materialGreyDark);
drawer6rrgeometrymesh.position.set( -400, -650 , 0);
kly_rackObject.add(drawer6rrgeometrymesh);
//display1 drawer6 rack right
const display1drawer6rrgeometry = new THREE.BoxGeometry(30, 70, 150);
const display1drawer6rrgeometrymesh = new THREE.Mesh(display1drawer6rrgeometry, materialVeryGreyDark);
display1drawer6rrgeometrymesh.position.set( -402, -570 , 0);
kly_rackObject.add(display1drawer6rrgeometrymesh);
//display2 drawer6 rack right
const display2drawer6rrgeometry = new THREE.BoxGeometry(30, 70, 150);
const display2drawer6rrgeometrymesh = new THREE.Mesh(display2drawer6rrgeometry, materialVeryGreyDark);
display2drawer6rrgeometrymesh.position.set( -402, -650 , 0);
kly_rackObject.add(display2drawer6rrgeometrymesh);
kly_rackObject.rotateY(Math.PI);
kly_rackObject.position.set(400, 1250, 400);
rar.add(kly_rackObject);
return rar;
}
// RAR2
export function rar2(param) {
const width=800, height=2500, depth=800;
const rar2 = new THREE.Object3D();
const kly_rackObject = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000d0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rar2.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(850, 80, 750);
rar2.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850, 2330, 600], [0, Math.PI / 2, 0]);
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialGreyMedium= new THREE.MeshLambertMaterial({color: 0x636363});
const materialVeryGreyDark= new THREE.MeshLambertMaterial({color: 0x242424});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const greenmaterial = new THREE.MeshLambertMaterial({color: 0x17fc03});
const redmaterial = new THREE.MeshLambertMaterial({color: 0xff0000});
const yellowmaterial = new THREE.MeshLambertMaterial({color: 0xcc9d02});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
//rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, silvermaterial);
rrmesh.position.set( 0, 0 , -810);
kly_rackObject.add(rrmesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 700);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 1200 , -815);
kly_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 700);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 1200 , -815);
kly_rackObject.add(Rtargetmesh);
//edge
const llegeometry = new THREE.BoxGeometry(width-750, height, depth-750);
const llemesh = new THREE.Mesh(llegeometry, materialGreyDark);
llemesh.position.set( -425, 0 , -1185);
kly_rackObject.add(llemesh);
//edge lre
const lregeometry = new THREE.BoxGeometry(width-750, height, depth-750);
const lremesh = new THREE.Mesh(lregeometry, materialGreyDark);
lremesh.position.set( -425, 0 , -430);
kly_rackObject.add(lremesh);
//edge lue
const luegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const luemesh = new THREE.Mesh(luegeometry, materialGreyDark);
luemesh.position.set( -425, 1225 , -807);
kly_rackObject.add(luemesh);
//edge lde
const ldegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const ldemesh = new THREE.Mesh(ldegeometry, materialGreyDark);
ldemesh.position.set( -425, -1230 , -807);
kly_rackObject.add(ldemesh);
//drawer1
const drawer1geometry = new THREE.BoxGeometry(10, 250, 630);
const drawer1geometrymesh = new THREE.Mesh(drawer1geometry, materialGreyDark);
drawer1geometrymesh.position.set( -400, 1000 , -810);
kly_rackObject.add(drawer1geometrymesh);
//display1 left
const display1leftgeometry = new THREE.BoxGeometry(50, 50, 150);
const display1leftgeometrygeometrymesh = new THREE.Mesh(display1leftgeometry, materialVeryGreyDark);
display1leftgeometrygeometrymesh.position.set( -400, 1050 , -1000);
kly_rackObject.add(display1leftgeometrygeometrymesh);
//display1 right
const displayupgeometry2 = new THREE.BoxGeometry(50, 50, 150);
const displayupgeometrymesh2 = new THREE.Mesh(displayupgeometry2, materialVeryGreyDark);
displayupgeometrymesh2.position.set( -400, 1050 , -820);
kly_rackObject.add(displayupgeometrymesh2);
//selector1
const selector1geometry = new THREE.BoxGeometry(20, 70, 20);
const selector1geometrymesh = new THREE.Mesh(selector1geometry, materialVeryGreyDark);
selector1geometrymesh.position.set( -400, 940 , -1030);
selector1geometrymesh.rotateX(Math.PI * 1.75);
selector1geometrymesh.rotateY(Math.PI * 1.50);
selector1geometrymesh.rotateZ(Math.PI * 1.50);
kly_rackObject.add(selector1geometrymesh);
//sfere selector1
const sphereselector1drawer1 = new THREE.SphereGeometry(20, 10, 10);
const sphereselector1drawer1mesh = new THREE.Mesh(sphereselector1drawer1, materialVeryGreyDark);
sphereselector1drawer1mesh.position.set(-400, 940 , -1030);
kly_rackObject.add(sphereselector1drawer1mesh);
//sfere drawer1 button1
const spherebutton1drawer1 = new THREE.SphereGeometry(20, 10, 10);
const spherebutton1drawer1mesh = new THREE.Mesh(spherebutton1drawer1, materialVeryGreyDark);
spherebutton1drawer1mesh.position.set(-400, 990 , -630);
kly_rackObject.add(spherebutton1drawer1mesh);
//sfere drawer1 button2
const spherebutton2drawer1 = new THREE.SphereGeometry(20, 10, 10);
const spherebutton2drawer1mesh = new THREE.Mesh(spherebutton2drawer1, materialVeryGreyDark);
spherebutton2drawer1mesh.position.set(-400, 990 , -550);
kly_rackObject.add(spherebutton2drawer1mesh);
//drawer2
const drawer2geometry = new THREE.BoxGeometry(10, 250, 630);
const drawer2geometrymesh = new THREE.Mesh(drawer2geometry, materialGreyDark);
drawer2geometrymesh.position.set( -400, 700 , -810);
kly_rackObject.add(drawer2geometrymesh);
//display2 left
const display1leftgeometrydrawer2 = new THREE.BoxGeometry(50, 50, 150);
const display1leftgeometrygeometrydrawer2mesh = new THREE.Mesh(display1leftgeometrydrawer2, materialVeryGreyDark);
display1leftgeometrygeometrydrawer2mesh.position.set( -400, 750 , -1000);
kly_rackObject.add(display1leftgeometrygeometrydrawer2mesh);
//display2 right
const display2leftgeometrydrawer2 = new THREE.BoxGeometry(50, 50, 150);
const display2leftgeometrygeometrydrawer2mesh = new THREE.Mesh(display2leftgeometrydrawer2, materialVeryGreyDark);
display2leftgeometrygeometrydrawer2mesh.position.set( -400, 750 , -820);
kly_rackObject.add(display2leftgeometrygeometrydrawer2mesh);
//selector2
const selector1geometrydrawer2 = new THREE.BoxGeometry(20, 70, 20);
const selector1geometrydrawer2mesh = new THREE.Mesh(selector1geometrydrawer2, materialVeryGreyDark);
selector1geometrydrawer2mesh.position.set( -400, 640 , -1030);
selector1geometrydrawer2mesh.rotateX(Math.PI * 1.75);
selector1geometrydrawer2mesh.rotateY(Math.PI * 1.50);
selector1geometrydrawer2mesh.rotateZ(Math.PI * 1.50);
kly_rackObject.add(selector1geometrydrawer2mesh);
//sfere selector2
const sphereselector1drawer2 = new THREE.SphereGeometry(20, 10, 10);
const sphereselector1drawer2mesh = new THREE.Mesh(sphereselector1drawer2, materialVeryGreyDark);
sphereselector1drawer2mesh.position.set(-400, 640 , -1030);
kly_rackObject.add(sphereselector1drawer2mesh);
//sfere drawer2 button1
const spherebutton1drawer2 = new THREE.SphereGeometry(20, 10, 10);
const spherebutton1drawer2mesh = new THREE.Mesh(spherebutton1drawer2, materialVeryGreyDark);
spherebutton1drawer2mesh.position.set(-400, 690 , -630);
kly_rackObject.add(spherebutton1drawer2mesh);
//sfere drawer2 button2
const spherebutton2drawer2 = new THREE.SphereGeometry(20, 10, 10);
const spherebutton2drawer2mesh = new THREE.Mesh(spherebutton2drawer2, materialVeryGreyDark);
spherebutton2drawer2mesh.position.set(-400, 690 , -550);
kly_rackObject.add(spherebutton2drawer2mesh);
//drawer3
const drawer3geometry = new THREE.BoxGeometry(10, 250, 630);
const drawer3geometrymesh = new THREE.Mesh(drawer3geometry, materialGreyDark);
drawer3geometrymesh.position.set( -400, 400 , -810);
kly_rackObject.add(drawer3geometrymesh);
//display2 left
const display1leftgeometrydrawer3 = new THREE.BoxGeometry(50, 50, 150);
const display1leftgeometrygeometrydrawer3mesh = new THREE.Mesh(display1leftgeometrydrawer3, materialVeryGreyDark);
display1leftgeometrygeometrydrawer3mesh.position.set( -400, 450 , -1000);
kly_rackObject.add(display1leftgeometrygeometrydrawer3mesh);
//display2 right
const display2leftgeometrydrawer3 = new THREE.BoxGeometry(50, 50, 150);
const display2leftgeometrygeometrydrawer3mesh = new THREE.Mesh(display2leftgeometrydrawer3, materialVeryGreyDark);
display2leftgeometrygeometrydrawer3mesh.position.set( -400, 450 , -820);
kly_rackObject.add(display2leftgeometrygeometrydrawer3mesh);
//selector2
const selector1geometrydrawer3 = new THREE.BoxGeometry(20, 70, 20);
const selector1geometrydrawer3mesh = new THREE.Mesh(selector1geometrydrawer3, materialVeryGreyDark);
selector1geometrydrawer3mesh.position.set( -400, 340 , -1030);
selector1geometrydrawer3mesh.rotateX(Math.PI * 1.75);
selector1geometrydrawer3mesh.rotateY(Math.PI * 1.50);
selector1geometrydrawer3mesh.rotateZ(Math.PI * 1.50);
kly_rackObject.add(selector1geometrydrawer3mesh);
//sfere selector2
const sphereselector1drawer3 = new THREE.SphereGeometry(20, 10, 10);
const sphereselector1drawer3mesh = new THREE.Mesh(sphereselector1drawer3, materialVeryGreyDark);
sphereselector1drawer3mesh.position.set(-400, 340 , -1030);
kly_rackObject.add(sphereselector1drawer3mesh);
//sfere drawer2 button1
const spherebutton1drawer3 = new THREE.SphereGeometry(20, 10, 10);
const spherebutton1drawer3mesh = new THREE.Mesh(spherebutton1drawer3, materialVeryGreyDark);
spherebutton1drawer3mesh.position.set(-400, 390 , -630);
kly_rackObject.add(spherebutton1drawer3mesh);
//sfere drawer2 button2
const spherebutton2drawer3 = new THREE.SphereGeometry(20, 10, 10);
const spherebutton2drawer3mesh = new THREE.Mesh(spherebutton2drawer3, materialVeryGreyDark);
spherebutton2drawer3mesh.position.set(-400, 390 , -550);
kly_rackObject.add(spherebutton2drawer3mesh);
//borderscreen
const borderscreengeometry = new THREE.BoxGeometry(10, 400, 500);
const borderscreengeometrymesh = new THREE.Mesh(borderscreengeometry, materialGreyDark);
borderscreengeometrymesh.position.set( -400, 0 , -810);
kly_rackObject.add(borderscreengeometrymesh);
//screen
const screengeometry = new THREE.BoxGeometry(10, 300, 400);
const screengeometrymesh = new THREE.Mesh(screengeometry, materialVeryGreyDark);
screengeometrymesh.position.set( -402, 0 , -810);
kly_rackObject.add(screengeometrymesh);
//GreenLed1
const greenled1 = new THREE.SphereGeometry(13, 10, 10);
const greenled1mesh = new THREE.Mesh(greenled1, greenmaterial);
greenled1mesh.position.set(-400, 175 , -750);
kly_rackObject.add(greenled1mesh);
//GreenLed2
const greenled2 = new THREE.SphereGeometry(13, 10, 10);
const greenled2mesh = new THREE.Mesh(greenled2, greenmaterial);
greenled2mesh.position.set(-400, 175 , -700);
kly_rackObject.add(greenled2mesh);
//borderEC
const borderECgeometry = new THREE.BoxGeometry(10, 400, 600);
const borderECgeometrymesh = new THREE.Mesh(borderECgeometry, materialGreyDark);
borderECgeometrymesh.position.set( -400, -650 , -810);
kly_rackObject.add(borderECgeometrymesh);
//EC1
const EC1geometry = new THREE.BoxGeometry(10, 350, 40);
const EC1geometrymesh = new THREE.Mesh(EC1geometry, materialGreyMedium);
EC1geometrymesh.position.set( -402, -650 , -1000);
kly_rackObject.add(EC1geometrymesh);
//EC2
const EC2geometry = new THREE.BoxGeometry(10, 350, 40);
const EC2geometrymesh = new THREE.Mesh(EC2geometry, materialGreyMedium);
EC2geometrymesh.position.set( -402, -650 , -950);
kly_rackObject.add(EC2geometrymesh);
//EC2
const EC3geometry = new THREE.BoxGeometry(10, 350, 40);
const EC3geometrymesh = new THREE.Mesh(EC3geometry, materialGreyMedium);
EC3geometrymesh.position.set( -402, -650 , -900);
kly_rackObject.add(EC3geometrymesh);
kly_rackObject.rotateY(Math.PI);
kly_rackObject.position.set(400, 1250, -400);
rar2.add(kly_rackObject);
return rar2;
}
// RAR3
export function rar3(param) {
const width=800, height=2500, depth=800;
const rar3 = new THREE.Object3D();
const rar3_rackObject = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000d0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rar3.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(850, 80, 750);
rar3.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850, 2330, 600], [0, Math.PI / 2, 0]);
const softbluematerial = new THREE.MeshLambertMaterial({color: 0x2b7cff});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialGreyMedium= new THREE.MeshLambertMaterial({color: 0x636363});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const materialVeryGreyDark= new THREE.MeshLambertMaterial({color: 0x242424});
//rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, silvermaterial);
rrmesh.position.set( 0, 0 , -10);
rar3_rackObject.add(rrmesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 700);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 1200 , -15);
rar3_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 700);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 1200 , -15);
rar3_rackObject.add(Rtargetmesh);
//edge le
const llegeometry = new THREE.BoxGeometry(width-750, height, depth-750);
const llemesh = new THREE.Mesh(llegeometry, materialGreyDark);
llemesh.position.set( -425, 0 , -370);
rar3_rackObject.add(llemesh);
//edge re
const lregeometry = new THREE.BoxGeometry(width-750, height, depth-750);
const lremesh = new THREE.Mesh(lregeometry, materialGreyDark);
lremesh.position.set( -425, 0 , 375);
rar3_rackObject.add(lremesh);
//edge ue
const luegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const luemesh = new THREE.Mesh(luegeometry, materialGreyDark);
luemesh.position.set( -425, 1225 , 0);
rar3_rackObject.add(luemesh);
//edge de
const ldegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const ldemesh = new THREE.Mesh(ldegeometry, materialGreyDark);
ldemesh.position.set( -425, -1230 , 0);
rar3_rackObject.add(ldemesh);
//drawer 1
const d1geometry = new THREE.BoxGeometry(10, 200, 600);
const d1geometrymesh = new THREE.Mesh(d1geometry, materialGreyMedium);
d1geometrymesh.position.set( -400, 900 , -10);
rar3_rackObject.add(d1geometrymesh);
//drawer 2
const d2geometrymesh = new THREE.Mesh(d1geometry, materialGreyMedium);
d2geometrymesh.position.set( -400, 600 , -10);
rar3_rackObject.add(d2geometrymesh);
//drawer 3
const d3geometrymesh = new THREE.Mesh(d1geometry, materialGreyMedium);
d3geometrymesh.position.set( -400, 300 , -10);
rar3_rackObject.add(d3geometrymesh);
//drawer 4
const d4geometrymesh = new THREE.Mesh(d1geometry, materialGreyMedium);
d4geometrymesh.position.set( -400, 0 , -10);
rar3_rackObject.add(d4geometrymesh);
//drawer 5
const d5geometrymesh = new THREE.Mesh(d1geometry, materialGreyMedium);
d5geometrymesh.position.set( -400, -300 , -10);
rar3_rackObject.add(d5geometrymesh);
//drawer 6
const d6geometrymesh = new THREE.Mesh(d1geometry, materialGreyMedium);
d6geometrymesh.position.set( -400, -600 , -10);
rar3_rackObject.add(d6geometrymesh);
rar3_rackObject.rotateY(Math.PI);
rar3_rackObject.position.set(400, 1250, 400);
rar3.add(rar3_rackObject);
return rar3;
}
// rack Terafermi
export function rtf(param) {
const width=800, height=2500, depth=600;
const rtf = new THREE.Object3D();
const rtf_rackObject = new THREE.Object3D();
const bluematerial = new THREE.MeshLambertMaterial({color: 0x0053d9});
const softbluematerial = new THREE.MeshLambertMaterial({color: 0x2b7cff});
const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
const materialDarkblue = new THREE.MeshLambertMaterial({color: 0x021061});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const whitematerial = new THREE.MeshLambertMaterial({color: 0xffffff});
const materialBase = new THREE.MeshLambertMaterial({color: 0x0000d0});
const text = param.name;
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
rtf.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
function createText() {
textGeo = new TextGeometry(text, {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = -0.5 * (textGeo.boundingBox.max.x - textGeo.boundingBox.min.x);
textMesh = new THREE.Mesh(textGeo, materialBase);
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
const group2 = group.clone();
group2.rotateY(Math.PI);
group2.position.set(850, 90, 850);
rtf.add(group2);
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(50, [850, 2330, 600], [0, Math.PI / 2, 0]);
// rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, softbluematerial);
rrmesh.position.set( 0, 0 , -10);
rtf_rackObject.add(rrmesh);
//front yellow target
const Ftarget = new THREE.BoxGeometry(2, 90, 500);
const Ftargetmesh = new THREE.Mesh(Ftarget, target);
Ftargetmesh.position.set( -451, 1200 , -15);
rtf_rackObject.add(Ftargetmesh);
//Rear yellow target
const Rtarget = new THREE.BoxGeometry(2, 90, 500);
const Rtargetmesh = new THREE.Mesh(Rtarget, target);
Rtargetmesh.position.set( 401, 1200 , -15);
rtf_rackObject.add(Rtargetmesh);
//edge le
const llegeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const llemesh = new THREE.Mesh(llegeometry, bluematerial);
llemesh.position.set( -425, 0 , -285);
rtf_rackObject.add(llemesh);
//edge re
const lregeometry = new THREE.BoxGeometry(width-750, height, depth-550);
const lremesh = new THREE.Mesh(lregeometry, bluematerial);
lremesh.position.set( -425, 0 , 265);
rtf_rackObject.add(lremesh);
//edge ue
const luegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const luemesh = new THREE.Mesh(luegeometry, bluematerial);
luemesh.position.set( -425, 1225 , -7);
rtf_rackObject.add(luemesh);
//edge de
const ldegeometry = new THREE.BoxGeometry(width-750, height-2450, depth-50);
const ldemesh = new THREE.Mesh(ldegeometry, bluematerial);
ldemesh.position.set( -425, -1230 , -7);
rtf_rackObject.add(ldemesh);
//base border
const screenbordergeometry = new THREE.BoxGeometry(10, 350, 550);
const screenbordergeometrymesh = new THREE.Mesh(screenbordergeometry, whitematerial);
screenbordergeometrymesh.position.set( -400, 400 , 0);
rtf_rackObject.add(screenbordergeometrymesh);
//screen border
const basebordergeometry = new THREE.BoxGeometry(10, 150, 200);
const basebordergeometrymesh = new THREE.Mesh(basebordergeometry, silvermaterial);
basebordergeometrymesh.position.set( -401, 450 , 0);
rtf_rackObject.add(basebordergeometrymesh);
//screen
const screengeometry = new THREE.BoxGeometry(10, 140, 180);
const screengeometrymesh = new THREE.Mesh(screengeometry, materialDarkblue);
screengeometrymesh.position.set( -402, 450 , 0);
rtf_rackObject.add(screengeometrymesh);
//base border2
const baseborder2geometry = new THREE.BoxGeometry(10, 450, 550);
const baseborder2geometrymesh = new THREE.Mesh(baseborder2geometry, whitematerial);
baseborder2geometrymesh.position.set( -400, -800 , 0);
rtf_rackObject.add(baseborder2geometrymesh);
rtf_rackObject.rotateY(Math.PI);
rtf_rackObject.position.set(400, 1250, 400);
rtf.add(rtf_rackObject);
return rtf;
}
// camod rack
export function camod(param) {
const width=800, height=2500, depth=800;
const camod = new THREE.Object3D();
const camod_rackObject = new THREE.Object3D();
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialGreyMedium= new THREE.MeshLambertMaterial({color: 0x636363});
const materialVeryGreyDark= new THREE.MeshLambertMaterial({color: 0x242424});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const greenmaterial = new THREE.MeshLambertMaterial({color: 0x17fc03});
const redmaterial = new THREE.MeshLambertMaterial({color: 0xff0000});
const yellowmaterial = new THREE.MeshLambertMaterial({color: 0xFBE928});
const blackmaterial = new THREE.MeshLambertMaterial({color: 0x000000});
//right rack
const lrgeometry = new THREE.BoxGeometry(width, height, depth);
const lrmesh = new THREE.Mesh(lrgeometry, materialGreyDark);
lrmesh.position.set(0 , 0 , 0);
camod_rackObject.add(lrmesh);
//left rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, materialGreyDark);
rrmesh.position.set( 0, 0 , -810);
camod_rackObject.add(rrmesh);
//edge lle
const llegeometry = new THREE.BoxGeometry(width-750, height-100, depth-790);
const llemesh = new THREE.Mesh(llegeometry, blackmaterial);
llemesh.position.set( -377, 0 , -1155);
camod_rackObject.add(llemesh);
//edge lre
const lregeometry = new THREE.BoxGeometry(width-750, height-100, depth-790);
const lremesh = new THREE.Mesh(lregeometry, blackmaterial);
lremesh.position.set( -377, 0 , -470);
camod_rackObject.add(lremesh);
//edge rle
const rlegeometry = new THREE.BoxGeometry(width-750, height-100, depth-790);
const rlemesh = new THREE.Mesh(rlegeometry, blackmaterial);
rlemesh.position.set( -377, 0 , -340);
camod_rackObject.add(rlemesh);
//edge rre
const rregeometry = new THREE.BoxGeometry(width-750, height-100, depth-790);
const rremesh = new THREE.Mesh(rregeometry, blackmaterial);
rremesh.position.set( -377, 0 , 345);
camod_rackObject.add(rremesh);
//edge lue
const luegeometry = new THREE.BoxGeometry(width-750, height-2490, depth-105);
const luemesh = new THREE.Mesh(luegeometry, blackmaterial);
luemesh.position.set( -377, 1200 , -813);
camod_rackObject.add(luemesh);
//edge lde
const ldegeometry = new THREE.BoxGeometry(width-750, height-2490, depth-105);
const ldemesh = new THREE.Mesh(ldegeometry, blackmaterial);
ldemesh.position.set( -377, -1200 , -807);
camod_rackObject.add(ldemesh);
//edge rue
const ruegeometry = new THREE.BoxGeometry(width-750, height-2490, depth-105);
const ruemesh = new THREE.Mesh(ruegeometry, blackmaterial);
ruemesh.position.set( -377, 1200 , 0);
camod_rackObject.add(ruemesh);
//edge rde
const rdegeometry = new THREE.BoxGeometry(width-750, height-2490, depth-105);
const rdemesh = new THREE.Mesh(rdegeometry, blackmaterial);
rdemesh.position.set( -377, -1200 , 0);
camod_rackObject.add(rdemesh);
//triangle warning1
const trianglewarning = new THREE.CylinderGeometry(200, 200, 1, 3);
const trianglewarningmesh = new THREE.Mesh(trianglewarning, yellowmaterial);
trianglewarningmesh.rotateX(Math.PI * 0.5);
trianglewarningmesh.rotateY(Math.PI * 1);
trianglewarningmesh.rotateZ(Math.PI * 0.5);
trianglewarningmesh.position.set(-401, 700 , 0);
camod_rackObject.add(trianglewarningmesh);
//triangle warning black
const trianglewarning2 = new THREE.CylinderGeometry(180, 180, 1, 3);
const trianglewarning2mesh = new THREE.Mesh(trianglewarning2, blackmaterial);
trianglewarning2mesh.rotateX(Math.PI * 0.5);
trianglewarning2mesh.rotateY(Math.PI * 1);
trianglewarning2mesh.rotateZ(Math.PI * 0.5);
trianglewarning2mesh.position.set(-402, 700 , 0);
camod_rackObject.add(trianglewarning2mesh);
//triangle warning yellow2
const trianglewarning3 = new THREE.CylinderGeometry(150, 150, 1, 3);
const trianglewarning3mesh = new THREE.Mesh(trianglewarning3, yellowmaterial);
trianglewarning3mesh.rotateX(Math.PI * 0.5);
trianglewarning3mesh.rotateY(Math.PI * 1);
trianglewarning3mesh.rotateZ(Math.PI * 0.5);
trianglewarning3mesh.position.set(-403, 700 , 0);
camod_rackObject.add(trianglewarning3mesh);
//ZOT1
const zot1geometry = new THREE.BoxGeometry(10, 110, 10);
const zot1geometrymesh = new THREE.Mesh(zot1geometry, blackmaterial);
zot1geometrymesh.position.set( -404, 750 , -20);
zot1geometrymesh.rotateX(Math.PI * 1.65);
zot1geometrymesh.rotateY(Math.PI * 1.50);
zot1geometrymesh.rotateZ(Math.PI * 1.50);
camod_rackObject.add(zot1geometrymesh);
//ZOT2
const zot2geometry = new THREE.BoxGeometry(10, 70, 10);
const zot2geometrymesh = new THREE.Mesh(zot2geometry, blackmaterial);
zot2geometrymesh.position.set( -404, 715 , -16);
zot2geometrymesh.rotateX(Math.PI * 1.85);
zot2geometrymesh.rotateY(Math.PI * 1.50);
zot2geometrymesh.rotateZ(Math.PI * 1.50);
camod_rackObject.add(zot2geometrymesh);
//ZOT3
const zot3geometry = new THREE.BoxGeometry(10, 80, 10);
const zot3geometrymesh = new THREE.Mesh(zot3geometry, blackmaterial);
zot3geometrymesh.position.set( -404, 697 , -1);
zot3geometrymesh.rotateX(Math.PI * 1.65);
zot3geometrymesh.rotateY(Math.PI * 1.50);
zot3geometrymesh.rotateZ(Math.PI * 1.50);
camod_rackObject.add(zot3geometrymesh);
//ZOT TRIANGLE
const zottrianglegeometry = new THREE.CylinderGeometry(22, 22, 1, 3);
const zottrianglegeometrymesh = new THREE.Mesh(zottrianglegeometry, blackmaterial);
zottrianglegeometrymesh.rotateX(Math.PI * 0.95);
zottrianglegeometrymesh.rotateY(Math.PI * 1);
zottrianglegeometrymesh.rotateZ(Math.PI * 0.5);
zottrianglegeometrymesh.position.set(-405, 660 , -19);
camod_rackObject.add(zottrianglegeometrymesh);
//handle1
const handle1geometry = new THREE.BoxGeometry(10, 250, 80);
const handle1geometrymesh = new THREE.Mesh(handle1geometry, materialVeryGreyDark);
handle1geometrymesh.position.set( -401, 100 , -550);
camod_rackObject.add(handle1geometrymesh);
//handle2
const handle2geometry = new THREE.BoxGeometry(10, 250, 80);
const handle2geometrymesh = new THREE.Mesh(handle2geometry, materialVeryGreyDark);
handle2geometrymesh.position.set( -401, 100 , -260);
camod_rackObject.add(handle2geometrymesh);
camod_rackObject.rotateY(Math.PI);
camod_rackObject.position.set(400, 1250, 340);
camod_rackObject.scale.set(1, 1, 0.94);
camod.add(camod_rackObject);
return camod;
}
// base mod
export function klystron(param) {
const text = param.name;
const myscale=0.625;
console.log('klystron(), text:',text.replace('TKLY_KG','K').replace('.01','').replace('KSP','KS').replace('K0','K'));
const width=1500, height=1500, depth=1500;
const ModK = new THREE.Object3D();
const ModContainer = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0xff0000});
const klystron = new THREE.Object3D();
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
klystron.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
materials = [
new THREE.MeshPhongMaterial( { color: 0x333333, flatShading: true } ), // front
new THREE.MeshPhongMaterial( { color: 0x333333 } ) // side
];
function createText() {
textGeo = new TextGeometry(text.replace('TKLY_KG','K').replace('.01','').replace('KSP','KS').replace('K0','K'), {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = - 0.5 * ( textGeo.boundingBox.max.x - textGeo.boundingBox.min.x );
textMesh = new THREE.Mesh( textGeo, materials );
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(75, [940,730,560], [0, Math.PI / 2, 0]);
const basegeometry = new THREE.BoxGeometry(width, height, depth);
const d1mesh = new THREE.Mesh(basegeometry, materialBase);
ModContainer.add(d1mesh);
// cover
const d2geometry = new THREE.BoxGeometry(width+100, 100, depth+100);
const dmaterial2= new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const d2mesh = new THREE.Mesh(d2geometry, dmaterial2);
d2mesh.position.set(0, 800, 0);
ModContainer.add(d2mesh);
// base
const d3geometry = new THREE.BoxGeometry(width+100, 100, depth+100);
const d3mesh = new THREE.Mesh(d3geometry, materialBase);
d3mesh.position.set(0, -800, 0);
ModContainer.add(d3mesh);
// big cylinder
const d4geometry = new THREE.CylinderGeometry(400, 400, 1200, 50);
const textureLoader = new THREE.TextureLoader();
const texture = textureLoader.load('./components/mod_texture.png');
texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
texture.repeat.set(5, 5);
const material = new THREE.MeshBasicMaterial({ map: texture });
const d4mesh = new THREE.Mesh(d4geometry, material);
d4mesh.rotateX(Math.PI * 1);
d4mesh.rotateY(Math.PI * 1);
d4mesh.rotateZ(Math.PI * 1);
d4mesh.position.set(0, 970 , 300);
ModContainer.add(d4mesh);
// small cylinder
const d5geometry = new THREE.CylinderGeometry(200, 200, 1200, 50);
const textureLoader2 = new THREE.TextureLoader();
const texture2 = textureLoader.load('./components/mod_texture.png');
texture2.wrapS = texture2.wrapT = THREE.RepeatWrapping;
texture2.repeat.set(3, 3);
const material2 = new THREE.MeshBasicMaterial({ map: texture2 });
const d5mesh = new THREE.Mesh(d5geometry, material2);
d5mesh.rotateX(Math.PI * 1);
d5mesh.rotateY(Math.PI * 1);
d5mesh.rotateZ(Math.PI * 1);
d5mesh.position.set(0, 1670 , 300);
ModContainer.add(d5mesh);
// high cover
const d6geometry = new THREE.CylinderGeometry(220, 220, 90, 50);
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const d6mesh = new THREE.Mesh(d6geometry, materialGreyDark);
d6mesh.rotateX(Math.PI * 1);
d6mesh.rotateY(Math.PI * 1);
d6mesh.rotateZ(Math.PI * 1);
d6mesh.position.set(0, 2300 , 300);
ModContainer.add(d6mesh);
// right arm
const Bracciodx = new THREE.BoxGeometry( 600, 100, 200 );
const d7mesh = new THREE.Mesh(Bracciodx, materialBase);
d7mesh.rotateX(Math.PI * 1);
d7mesh.rotateY(Math.PI * 1.25);
d7mesh.rotateZ(Math.PI * 1);
d7mesh.position.set(300, 1300 , 600);
ModContainer.add(d7mesh);
// left arm
const Bracciosx = new THREE.BoxGeometry( 600, 100, 200 );
const d8mesh = new THREE.Mesh(Bracciosx, materialBase);
d8mesh.rotateX(Math.PI * 1);
d8mesh.rotateY(Math.PI * 1.75);
d8mesh.rotateZ(Math.PI * 1);
d8mesh.position.set(300, 1300 , 0);
ModContainer.add(d8mesh);
// right arm continue
const PBracciodx = new THREE.BoxGeometry( 600, 100, 190 );
const d9mesh = new THREE.Mesh(PBracciodx, materialBase);
d9mesh.rotateX(Math.PI * 1);
d9mesh.rotateY(Math.PI * 1);
d9mesh.rotateZ(Math.PI * 1);
d9mesh.position.set(743, 1300 , 790);
ModContainer.add(d9mesh);
//prolung braccia sx
const PBracciosx = new THREE.BoxGeometry( 600, 100, 190 );
const d10mesh = new THREE.Mesh(PBracciosx, materialBase);
d10mesh.rotateX(Math.PI * 1);
d10mesh.rotateY(Math.PI * 1);
d10mesh.rotateZ(Math.PI * 1);
d10mesh.position.set(743, 1300 , -190);
ModContainer.add(d10mesh);
//trave 1 base
const trave1 = new THREE.BoxGeometry( 80, 1500, 190 );
const materialtrave= new THREE.MeshLambertMaterial({color: 0xd80000});
const d12mesh = new THREE.Mesh(trave1, materialtrave);
d12mesh.rotateX(Math.PI * 1);
d12mesh.rotateY(Math.PI * 1);
d12mesh.rotateZ(Math.PI * 1);
d12mesh.position.set(-760, 0 , -300);
ModContainer.add(d12mesh);
//trave 2 base
const trave2 = new THREE.BoxGeometry( 80, 1500, 190 );
const d13mesh = new THREE.Mesh(trave1, materialtrave);
d13mesh.rotateX(Math.PI * 1);
d13mesh.rotateY(Math.PI * 1);
d13mesh.rotateZ(Math.PI * 1);
d13mesh.position.set(-760, 0 , 300);
ModContainer.add(d13mesh);
//targhetta
const targhetta = new THREE.BoxGeometry( 10, 300, 300 );
const d14mesh = new THREE.Mesh(targhetta, dmaterial2);
d14mesh.position.set(-750, 550 , 0);
ModContainer.add(d14mesh);
//Torus basso sx
const torus_bs = new THREE.TorusGeometry( 60, 15, 20, 20, 7);
const d15mesh = new THREE.Mesh( torus_bs, materialGreyDark );
d15mesh.rotateX(Math.PI * 1);
d15mesh.rotateY(Math.PI * 1.5);
d15mesh.rotateZ(Math.PI * 1);
d15mesh.position.set(-700, 900 , -600);
ModContainer.add(d15mesh);
//Torus basso dx
const torus_bd = new THREE.TorusGeometry( 60, 15, 20, 20, 7);
const d16mesh = new THREE.Mesh( torus_bd, materialGreyDark );
d16mesh.rotateX(Math.PI * 1);
d16mesh.rotateY(Math.PI * 1.5);
d16mesh.rotateZ(Math.PI * 1);
d16mesh.position.set(-700, 900 , 600);
ModContainer.add(d16mesh);
//Torus alto sx
const torus_as = new THREE.TorusGeometry( 60, 15, 20, 20, 7);
const d17mesh = new THREE.Mesh( torus_as, materialGreyDark );
d17mesh.rotateX(Math.PI * 1);
d17mesh.rotateY(Math.PI * 1.5);
d17mesh.rotateZ(Math.PI * 1);
d17mesh.position.set(700, 900 , -600);
ModContainer.add(d17mesh);
//Torus alto dx
const torus_ad = new THREE.TorusGeometry( 60, 15, 20, 20, 7);
const d18mesh = new THREE.Mesh( torus_ad, materialGreyDark );
d18mesh.rotateX(Math.PI * 1);
d18mesh.rotateY(Math.PI * 1.5);
d18mesh.rotateZ(Math.PI * 1);
d18mesh.position.set(700, 900 , 600);
ModContainer.add(d18mesh);
ModContainer.rotateY(Math.PI);
ModContainer.scale.set(myscale, myscale, myscale);
ModContainer.position.set(width*myscale/2, height*myscale/2+50, depth*myscale/2);
klystron.add(ModContainer);
return klystron;
}
// base KXS
export function klystronx(param) {
const text = param.name;
const myscale=0.625;
const width=1200, height=1200, depth=1200;
const ModK = new THREE.Object3D();
const ModContainer = new THREE.Object3D();
const materialBase = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const klystron = new THREE.Object3D();
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
klystron.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
materials = [
new THREE.MeshPhongMaterial( { color: 0x333333, flatShading: true } ), // front
new THREE.MeshPhongMaterial( { color: 0x333333 } ) // side
];
function createText() {
textGeo = new TextGeometry(text.replace('TKLY_KG','K').replace('.01',''), {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = - 0.5 * ( textGeo.boundingBox.max.x - textGeo.boundingBox.min.x );
textMesh = new THREE.Mesh( textGeo, materials );
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(75, [760,600,840], [0, Math.PI / 2, 0]);
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const basegeometry = new THREE.BoxGeometry(width, height+200, depth);
const d1mesh = new THREE.Mesh(basegeometry, materialBase);
d1mesh.position.set(0, 100, -900);
ModContainer.add(d1mesh);
// redcube
const d2geometry = new THREE.BoxGeometry(width-400, height, depth);
const dmaterial2= new THREE.MeshLambertMaterial({color: 0xe02900});
const d2mesh = new THREE.Mesh(d2geometry, dmaterial2);
d2mesh.position.set(200, 1400, -900);
ModContainer.add(d2mesh);
// base
const d3geometry = new THREE.BoxGeometry(width, height, depth);
const d3mesh = new THREE.Mesh(d3geometry, materialBase);
d3mesh.position.set(0, 0, 300);
ModContainer.add(d3mesh);
// big red cylinder
const d4geometry = new THREE.CylinderGeometry(450, 450, 1200, 50);
const material = new THREE.MeshLambertMaterial({color: 0xfc0303});
const d4mesh = new THREE.Mesh(d4geometry, material);
d4mesh.rotateX(Math.PI * 1);
d4mesh.rotateY(Math.PI * 1);
d4mesh.rotateZ(Math.PI * 1);
d4mesh.position.set(0, 800 , 300);
ModContainer.add(d4mesh);
// yellow 1 cylinder
const d5geometry = new THREE.CylinderGeometry(300, 370, 200, 50);
const material2 = new THREE.MeshLambertMaterial({color: 0xecfc03});
const d5mesh = new THREE.Mesh(d5geometry, material2);
d5mesh.rotateX(Math.PI * 1);
d5mesh.rotateY(Math.PI * 1);
d5mesh.rotateZ(Math.PI * 1);
d5mesh.position.set(0, 1450 , 300);
ModContainer.add(d5mesh);
// yellow 2 cylinder
const d6geometry = new THREE.CylinderGeometry(150, 150, 250, 50);
const material3= new THREE.MeshLambertMaterial({color: 0xecfc03});
const d6mesh = new THREE.Mesh(d6geometry, material3);
d6mesh.rotateX(Math.PI * 1);
d6mesh.rotateY(Math.PI * 1);
d6mesh.rotateZ(Math.PI * 1);
d6mesh.position.set(0, 1680 , 300);
ModContainer.add(d6mesh);
// yellow 3 cylinder
const d7geometry = new THREE.CylinderGeometry(200, 200, 100, 50);
const d7mesh = new THREE.Mesh(d7geometry, material3);
d7mesh.rotateX(Math.PI * 1);
d7mesh.rotateY(Math.PI * 1);
d7mesh.rotateZ(Math.PI * 1);
d7mesh.position.set(0, 1780 , 300);
ModContainer.add(d7mesh);
// tag
const targhetta = new THREE.BoxGeometry( 10, 200, 300 );
const materialwhite= new THREE.MeshLambertMaterial({color: 0xeffffff});
const d14mesh = new THREE.Mesh(targhetta, materialwhite);
d14mesh.position.set(-610, 600 , -600);
ModContainer.add(d14mesh);
// torus red1
const torus_bs = new THREE.TorusGeometry( 60, 15, 20, 20, 7);
const d15mesh = new THREE.Mesh( torus_bs, materialGreyDark );
d15mesh.rotateX(Math.PI * 1);
d15mesh.rotateY(Math.PI * 1.5);
d15mesh.rotateZ(Math.PI * 1);
d15mesh.position.set(550, 2050 , -1400);
ModContainer.add(d15mesh);
// torus red2
const torus_bd = new THREE.TorusGeometry( 60, 15, 20, 20, 7);
const d16mesh = new THREE.Mesh( torus_bd, materialGreyDark );
d16mesh.rotateX(Math.PI * 1);
d16mesh.rotateY(Math.PI * 1.5);
d16mesh.rotateZ(Math.PI * 1);
d16mesh.position.set(-150, 2050 , -400);
ModContainer.add(d16mesh);
// torus 1 white
const torus_as = new THREE.TorusGeometry( 60, 15, 20, 20, 7);
const d17mesh = new THREE.Mesh( torus_as, materialGreyDark );
d17mesh.rotateX(Math.PI * 1);
d17mesh.rotateY(Math.PI * 1.5);
d17mesh.rotateZ(Math.PI * 1);
d17mesh.position.set(-400, 850 , -500);
ModContainer.add(d17mesh);
// torus 2 white
const torus_ad = new THREE.TorusGeometry( 60, 15, 20, 20, 7);
const d18mesh = new THREE.Mesh( torus_ad, materialGreyDark );
d18mesh.rotateX(Math.PI * 1);
d18mesh.rotateY(Math.PI * 1.5);
d18mesh.rotateZ(Math.PI * 1);
d18mesh.position.set(-400, 850 , -1300);
ModContainer.add(d18mesh);
// line1
const line1 = new THREE.BoxGeometry(10, 10, 1150);
const d19mesh = new THREE.Mesh(line1, dmaterial2);
d19mesh.position.set(-610, 750, -900);
ModContainer.add(d19mesh);
// line2
const line2 = new THREE.BoxGeometry(10, 10, 1150);
const d20mesh = new THREE.Mesh(line2, dmaterial2);
d20mesh.position.set(-610, 550, 300);
ModContainer.add(d20mesh);
ModContainer.rotateY(Math.PI);
ModContainer.scale.set(myscale, myscale, myscale);
ModContainer.position.set(width*myscale/2, height*myscale/2, depth*myscale/2);
klystron.add(ModContainer);
return klystron;
}
// cavity for linac
export function cavitylinac(param) {
const length = param.length? param.length: 1100;
const cavitylinacMaster = new THREE.Object3D();
const dmaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const d1geometry = new THREE.CylinderGeometry(75, 75, length, 25);
const d1mesh = new THREE.Mesh(d1geometry, dmaterial);
d1mesh.position.set(0, length/2+350, 0);
cavitylinacMaster.add(d1mesh);
cavitylinacMaster.rotateX(Math.PI * 0.5);
cavitylinacMaster.rotatedX = true;
return cavitylinacMaster;
}
// Current Monitor
export function cm(param) {
const cmContiner = new THREE.Object3D();
const cmObject = new THREE.Object3D();
//cylinder mid
const cylgeometry = new THREE.CylinderGeometry(115, 115, 30, 20);
const cylmaterial = new THREE.MeshLambertMaterial({color: 0x00d0ff});
const cylmesh = new THREE.Mesh(cylgeometry, cylmaterial);
cylmesh.rotateX(Math.PI * 1);
cylmesh.rotateY(Math.PI * 1.0);
cylmesh.rotateZ(Math.PI * 1.5);
cylmesh.position.set(0, 0 , 0);
cmObject.add(cylmesh);
//cylinder center
const cyl2geometry = new THREE.CylinderGeometry(75, 75, 31, 20);
const cyl2material = new THREE.MeshLambertMaterial({color: 0x2d2b70});
const cyl2mesh = new THREE.Mesh(cyl2geometry, cyl2material);
cyl2mesh.rotateX(Math.PI * 1);
cyl2mesh.rotateY(Math.PI * 1.0);
cyl2mesh.rotateZ(Math.PI * 1.5);
cyl2mesh.position.set(0, 0 , 0);
cmObject.add(cyl2mesh);
cmObject.scale.setX(1);
cmObject.scale.setY(1);
cmObject.scale.setZ(1);
cmObject.position.set(0, 0, 0);
cmContiner.add(cmObject);
cmContiner.rotateY(Math.PI * -0.5);
return cmContiner;
}
// flsc
export function flsc(param) {
const length=700;
const flscSR = new THREE.Object3D();
const flscContiner = new THREE.Object3D();
const materialGrey = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const materialDarkGrey = new THREE.MeshLambertMaterial({color: 0x8c8c8c});
const materialOrange= new THREE.MeshLambertMaterial({color: 0xfc9403});
const materialBlack= new THREE.MeshLambertMaterial({color: 0x000000});
//cil center
const d1geometry = new THREE.CylinderGeometry(25, 25, 400, 25);
const d1mesh = new THREE.Mesh(d1geometry, materialGrey);
d1mesh.position.set(0, 200 , 0);
flscContiner.add(d1mesh);
flscContiner.rotateX(Math.PI * 1);
// esagono
const d2geometry = new THREE.CylinderGeometry(70, 70, 70, 6);
const d2mesh = new THREE.Mesh(d2geometry, materialGrey);
d2mesh.position.set(0, 290, 0);
d2mesh.rotateX(Math.PI * 1);
d2mesh.rotateY(Math.PI * 1);
d2mesh.rotateZ(Math.PI * 1.5);
flscContiner.add(d2mesh);
// box orange down
const orangegeometry = new THREE.CylinderGeometry(90, 90, 250, 15);
const orangegeometrymesh = new THREE.Mesh(orangegeometry, materialOrange);
orangegeometrymesh.position.set(0, 550, 0);
flscContiner.add(orangegeometrymesh);
// box black down
const blackgeometry = new THREE.CylinderGeometry(90, 90, 25, 15);
const blackgeometrymesh = new THREE.Mesh(blackgeometry, materialBlack);
blackgeometrymesh.position.set(0, 412, 0);
flscContiner.add(blackgeometrymesh);
// base zigrinatura
const d3geometry = new THREE.CylinderGeometry(90, 90, 50, 15);
const d3mesh = new THREE.Mesh(d3geometry, materialGrey);
d3mesh.rotateX(Math.PI * 1);
d3mesh.rotateY(Math.PI * 1);
d3mesh.rotateZ(Math.PI * 1);
d3mesh.position.set(0, 170 , 0);
flscContiner.add(d3mesh);
// zigrinatura
const d4geometry = new THREE.CylinderGeometry(60, 60, 170, 15);
const textureLoader = new THREE.TextureLoader();
const texture = textureLoader.load('./components/flsc_texture.png');
texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
texture.repeat.set(5, 40);
const material = new THREE.MeshBasicMaterial({ map: texture });
const d4mesh = new THREE.Mesh(d4geometry, material);
d4mesh.rotateX(Math.PI * 1);
d4mesh.rotateY(Math.PI * 1);
d4mesh.rotateZ(Math.PI * 1);
d4mesh.position.set(0, 60 , 0);
flscContiner.add(d4mesh);
// tetto zigrinatura
const d5geometry = new THREE.CylinderGeometry(90, 90, 50, 15);
const d5mesh = new THREE.Mesh(d5geometry, materialGrey);
d5mesh.rotateX(Math.PI * 1);
d5mesh.rotateY(Math.PI * 1);
d5mesh.rotateZ(Math.PI * 1);
d5mesh.position.set(0, -50 , 0);
flscContiner.add(d5mesh);
//half sphere down1
const down1geometry = new THREE.CylinderGeometry(30, 30, 15, 25);
const down1geometrymesh = new THREE.Mesh(down1geometry, materialGrey);
down1geometrymesh.position.set(-75, 170, -75);
flscContiner.add(down1geometrymesh);
//half sphere up1
const up1geometry = new THREE.CylinderGeometry(30, 30, 15, 25);
const up1geometrymesh = new THREE.Mesh(up1geometry, materialGrey);
up1geometrymesh.position.set(-75, -50, -75);
flscContiner.add(up1geometrymesh);
//half sphere down2
const down2geometry = new THREE.CylinderGeometry(30, 30, 15, 25);
const down2geometrymesh = new THREE.Mesh(down2geometry, materialGrey);
down2geometrymesh.position.set(75, 170, -75);
flscContiner.add(down2geometrymesh);
//half sphere up2
const up2geometry = new THREE.CylinderGeometry(30, 30, 15, 25);
const up2geometrymesh = new THREE.Mesh(up2geometry, materialGrey);
up2geometrymesh.position.set(75, -50, -75);
flscContiner.add(up2geometrymesh);
//half sphere down3
const down3geometry = new THREE.CylinderGeometry(30, 30, 15, 25);
const down3geometrymesh = new THREE.Mesh(down2geometry, materialGrey);
down3geometrymesh.position.set(0, 170, 100);
flscContiner.add(down3geometrymesh);
//half sphere up3
const up3geometry = new THREE.CylinderGeometry(30, 30, 15, 25);
const up3geometrymesh = new THREE.Mesh(up3geometry, materialGrey);
up3geometrymesh.position.set(0, -50, 100);
flscContiner.add(up3geometrymesh);
//cil support1
const d11geometry = new THREE.CylinderGeometry(10, 10, 300, 25);
const d11mesh = new THREE.Mesh(d11geometry, materialGrey);
d11mesh.position.set(-75, 20, -75);
flscContiner.add(d11mesh);
//cil support2
const d12geometry = new THREE.CylinderGeometry(10, 10, 300, 25);
const d12mesh = new THREE.Mesh(d12geometry, materialGrey);
d12mesh.position.set(75, 20, -75);
flscContiner.add(d12mesh);
//cil support3
const d13geometry = new THREE.CylinderGeometry(10, 10, 300, 25);
const d13mesh = new THREE.Mesh(d13geometry, materialGrey);
d13mesh.position.set(0, 20, 100);
flscContiner.add(d13mesh);
// blocco supporto
const d15geometry = new THREE.CylinderGeometry(120, 120, 20, 25);
const d15mesh = new THREE.Mesh(d15geometry, materialGrey);
d15mesh.position.set(0, -130, 0);
d15mesh.rotateX(Math.PI * 1);
flscContiner.add(d15mesh);
//internal block
const d16geometry = new THREE.CylinderGeometry(20, 20, 60, 15);
const d16mesh = new THREE.Mesh(d16geometry, materialGrey);
d16mesh.position.set(0, -100, 0);
d16mesh.rotateX(Math.PI * 1);
flscContiner.add(d16mesh);
// high box1
const d7geometry = new THREE.BoxGeometry(40, 90, 100);
const d7mesh = new THREE.Mesh(d7geometry, materialDarkGrey);
d7mesh.position.set(-20, -180, 0);
flscContiner.add(d7mesh);
// high box2
const d8geometry = new THREE.BoxGeometry(40, 60, 100);
const d8mesh = new THREE.Mesh(d8geometry, materialDarkGrey);
d8mesh.position.set(20, -170, 0);
flscContiner.add(d8mesh);
flscContiner.position.set(0, 235, 0);
flscContiner.scale.setX(0.8);
flscContiner.scale.setY(0.8);
flscContiner.scale.setZ(0.8);
flscSR.add(flscContiner);
flscSR.rotateY(Math.PI * -0.5);
return flscSR;
}
//SIP
export function sip(param) {
const sipContiner = new THREE.Object3D();
const sipObject = new THREE.Object3D();
//cylinder
const cylgeometry = new THREE.CylinderGeometry(35, 35, 50, 15);
const cylmaterial = new THREE.MeshLambertMaterial({color: 0xc7c7c7});
const cylmesh = new THREE.Mesh(cylgeometry, cylmaterial);
cylmesh.rotateX(Math.PI * 1);
cylmesh.rotateY(Math.PI * 1.0);
cylmesh.rotateZ(Math.PI * 1.5);
cylmesh.position.set(0, 0 , 0);
sipObject.add(cylmesh);
// connect
const vlvgeometry = new THREE.BoxGeometry(30, 90, 30 );
const vlv1mesh = new THREE.Mesh(vlvgeometry, cylmaterial);
vlv1mesh.position.set(0, -50, 0);
sipObject.add(vlv1mesh);
// box
const boxmaterial = new THREE.MeshLambertMaterial({color: 0xb6b6b6});
const boxgeometry = new THREE.BoxGeometry(60, 80, 120 );
const boxmesh = new THREE.Mesh(boxgeometry, boxmaterial);
boxmesh.position.set(0, -120, 0);
sipObject.add(boxmesh);
// blackbox1
const bb1material = new THREE.MeshLambertMaterial({color: 0x000000});
const bb1geometry = new THREE.BoxGeometry(60, 80, 10 );
const bb1mesh = new THREE.Mesh(bb1geometry, bb1material);
bb1mesh.position.set(0, -120, -65);
sipObject.add(bb1mesh);
// blackbox2
const bb2geometry = new THREE.BoxGeometry(60, 80, 10 );
const bb2mesh = new THREE.Mesh(bb2geometry, bb1material);
bb2mesh.position.set(0, -120, 65);
sipObject.add(bb2mesh);
// border
const bordergeometry = new THREE.BoxGeometry(61, 81, 1 );
const bordermesh = new THREE.Mesh(bordergeometry, bb1material);
bordermesh.position.set(0, -120, 0);
sipObject.add(bordermesh);
sipObject.scale.setX(1);
sipObject.scale.setY(1);
sipObject.scale.setZ(1);
sipObject.position.set(0, 0, 0);
sipContiner.add(sipObject);
sipContiner.rotateY(Math.PI * 0.5);
return sipContiner;
}
// FuG PS
export function fug(width=800, height=1700, depth=600) {
const text = 'Fug';
const fugObject = new THREE.Object3D();
let group, textMesh, textGeo, materials;
let size = 60;
let textheight = 10;
let pos = [];
let rot = [];
const hover = 30;
const curveSegments = 8;
let font;
function insertText(isize, ipos, irot) {
group = new THREE.Group();
group.position.y = 100;
fugObject.add( group );
size = isize;
pos = ipos;
rot = irot;
loadFont();
}
function loadFont() {
const loader = new FontLoader();
// https://threejs.org/examples/fonts/droid_sans_bold.typeface.json
loader.load( './fonts/droid_sans_bold.typeface.json', function ( response ) {
font = response;
refreshText();
} );
}
materials = [
new THREE.MeshPhongMaterial( { color: 0x272c7d , flatShading: true } ), // front
new THREE.MeshPhongMaterial( { color: 0x272c7d } ) // side
];
function createText() {
textGeo = new TextGeometry(text.replace('TKLY_KG','K').replace('.01',''), {font: font, size: size, height: textheight, curveSegments: curveSegments});
textGeo.computeBoundingBox();
const centerOffset = - 0.5 * ( textGeo.boundingBox.max.x - textGeo.boundingBox.min.x );
textMesh = new THREE.Mesh( textGeo, materials );
textMesh.position.x = pos[0];
textMesh.position.y = pos[1];
textMesh.position.z = pos[2];
textMesh.rotation.x = rot[0];
textMesh.rotation.y = rot[1];
textMesh.rotation.z = rot[2];
group.add( textMesh );
}
function refreshText() {
group.remove( textMesh );
if ( ! text ) return;
createText();
}
insertText(270, [-650,-1500,-720], [0, -Math.PI / 2, 0]);
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialVeryGreyDark= new THREE.MeshLambertMaterial({color: 0x242424});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const testmaterial = new THREE.MeshLambertMaterial({color: 0x00ff00});
const greenmaterial = new THREE.MeshLambertMaterial({color: 0x095c23});
const greenmaterial2 = new THREE.MeshLambertMaterial({color: 0x0f993b});
const redmaterial = new THREE.MeshLambertMaterial({color: 0xab0000});
const yellowmaterial = new THREE.MeshLambertMaterial({color: 0xcc9d02});
const emergencymaterial = new THREE.MeshLambertMaterial({color: 0xff0000});
const blumaterial = new THREE.MeshLambertMaterial({color: 0x272c7d});
const whiteaterial = new THREE.MeshLambertMaterial({color: 0xdfdfe8});
//fix FUG logo
const fugfixgeometry = new THREE.BoxGeometry(10, 50, 460);
const fugfixgeometrymesh = new THREE.Mesh(fugfixgeometry, blumaterial);
fugfixgeometrymesh.position.set(-655,-1157,-310);
fugObject.add(fugfixgeometrymesh);
//left rack
const lrgeometry = new THREE.BoxGeometry(800, 1700, 600);
const lrmesh = new THREE.Mesh(lrgeometry, silvermaterial);
lrmesh.position.set(0 , 0 , -100);
fugObject.add(lrmesh);
//right rack
const rrgeometry = new THREE.BoxGeometry(800, 1700, 600);
const rrmesh = new THREE.Mesh(rrgeometry, silvermaterial);
rrmesh.position.set( 0, 0 , -710);
fugObject.add(rrmesh);
//basefug
const basegeometry = new THREE.BoxGeometry(1050, 900, 1200);
const basemesh = new THREE.Mesh(basegeometry, silvermaterial);
basemesh.position.set( -130, -1320 , -400);
fugObject.add(basemesh);
//edge lle
const llegeometry = new THREE.BoxGeometry(50, 1700, 50);
const llemesh = new THREE.Mesh(llegeometry, materialGreyDark);
llemesh.position.set( -425, 0 , -985);
fugObject.add(llemesh);
//edge lre
const lregeometry = new THREE.BoxGeometry(50, 1700, 50);
const lremesh = new THREE.Mesh(lregeometry, materialGreyDark);
lremesh.position.set( -425, 0 , -430);
fugObject.add(lremesh);
//edge rle
const rlegeometry = new THREE.BoxGeometry(50, 1700, 50);
const rlemesh = new THREE.Mesh(rlegeometry, materialGreyDark);
rlemesh.position.set( -425, 0 , -370);
fugObject.add(rlemesh);
//edge rre
const rregeometry = new THREE.BoxGeometry(50, 1700, 50);
const rremesh = new THREE.Mesh(rregeometry, materialGreyDark);
rremesh.position.set( -425, 0 , 175);
fugObject.add(rremesh);
//edge lue
const luegeometry = new THREE.BoxGeometry(50, 50, 505);
const luemesh = new THREE.Mesh(luegeometry, materialGreyDark);
luemesh.position.set( -425, 825 , -707);
fugObject.add(luemesh);
//edge lde
const ldegeometry = new THREE.BoxGeometry(50, 50, 505);
const ldemesh = new THREE.Mesh(ldegeometry, materialGreyDark);
ldemesh.position.set( -425, -830 , -707);
fugObject.add(ldemesh);
//edge rue
const ruegeometry = new THREE.BoxGeometry(50, 50, 505);
const ruemesh = new THREE.Mesh(ruegeometry, materialGreyDark);
ruemesh.position.set( -425, 825 , -100);
fugObject.add(ruemesh);
//edge rde
const rdegeometry = new THREE.BoxGeometry(50, 50, 505);
const rdemesh = new THREE.Mesh(rdegeometry, materialGreyDark);
rdemesh.position.set( -425, -825 , -100);
fugObject.add(rdemesh);
//GreenButton
const greenbutton = new THREE.CylinderGeometry(55, 55, 40, 15);
const greenbuttonmesh = new THREE.Mesh(greenbutton, greenmaterial);
greenbuttonmesh.rotateX(Math.PI * 0.5);
greenbuttonmesh.rotateY(Math.PI * 1);
greenbuttonmesh.rotateZ(Math.PI * 0.5);
greenbuttonmesh.position.set(-400, 600 , -670);
fugObject.add(greenbuttonmesh);
//GreenLed
const greenled = new THREE.CylinderGeometry(40, 40, 40, 15);
const greenledmesh = new THREE.Mesh(greenled, greenmaterial2);
greenledmesh.rotateX(Math.PI * 0.5);
greenledmesh.rotateY(Math.PI * 1);
greenledmesh.rotateZ(Math.PI * 0.5);
greenledmesh.position.set(-400, 600 , -550);
fugObject.add(greenledmesh);
//RedButton
const redbutton = new THREE.CylinderGeometry(55, 55, 40, 15);
const redbuttonmesh = new THREE.Mesh(redbutton, redmaterial);
redbuttonmesh.rotateX(Math.PI * 0.5);
redbuttonmesh.rotateY(Math.PI * 1);
redbuttonmesh.rotateZ(Math.PI * 0.5);
redbuttonmesh.position.set(-400, 450 , -670);
fugObject.add(redbuttonmesh);
//YelloyLed
const yellowled = new THREE.CylinderGeometry(40, 40, 40, 15);
const yellowledmesh = new THREE.Mesh(yellowled, yellowmaterial);
yellowledmesh.rotateX(Math.PI * 0.5);
yellowledmesh.rotateY(Math.PI * 1);
yellowledmesh.rotateZ(Math.PI * 0.5);
yellowledmesh.position.set(-400, 450 , -550);
fugObject.add(yellowledmesh);
//EmergenctButton
const emergencybutton = new THREE.CylinderGeometry(80, 80, 40, 15);
const emergencybuttonmesh = new THREE.Mesh(emergencybutton, emergencymaterial);
emergencybuttonmesh.rotateX(Math.PI * 0.5);
emergencybuttonmesh.rotateY(Math.PI * 1);
emergencybuttonmesh.rotateZ(Math.PI * 0.5);
emergencybuttonmesh.position.set(-400, 270 , -620);
fugObject.add(emergencybuttonmesh);
//display up
const displayupgeometry = new THREE.BoxGeometry(50, 50, 150);
const displayupgeometrymesh = new THREE.Mesh(displayupgeometry, materialVeryGreyDark);
displayupgeometrymesh.position.set( -400, 600 , -850);
fugObject.add(displayupgeometrymesh);
//display2 down
const displayupgeometry2 = new THREE.BoxGeometry(50, 50, 150);
const displayupgeometrymesh2 = new THREE.Mesh(displayupgeometry2, materialVeryGreyDark);
displayupgeometrymesh2.position.set( -400, 500 , -850);
fugObject.add(displayupgeometrymesh2);
//switch
const switchgeometry = new THREE.BoxGeometry(10, 350, 200);
const switchgeometrymesh = new THREE.Mesh(switchgeometry, materialVeryGreyDark);
switchgeometrymesh.position.set( -400, -50 , -850);
fugObject.add(switchgeometrymesh);
//Lgrid2 down
const grid2geometry = new THREE.BoxGeometry(10, 200, 520);
const textureLoader2 = new THREE.TextureLoader();
const texture2 = textureLoader2.load('./components/grid_texture.png');
texture2.wrapS = texture2.wrapT = THREE.RepeatWrapping;
texture2.repeat.set(50, 1);
const material2 = new THREE.MeshBasicMaterial({ map: texture2 });
const grid2geometrymesh = new THREE.Mesh(grid2geometry, material2);
grid2geometrymesh.rotateX(Math.PI * 1);
grid2geometrymesh.rotateY(Math.PI * 1);
grid2geometrymesh.rotateZ(Math.PI * 1);
grid2geometrymesh.position.set( -400, -650 , -710);
fugObject.add(grid2geometrymesh);
//Rgrid2 down
const grid4geometry = new THREE.BoxGeometry(10, 200, 520);
const textureLoader4 = new THREE.TextureLoader();
const texture4 = textureLoader4.load('./components/grid_texture.png');
texture4.wrapS = texture4.wrapT = THREE.RepeatWrapping;
texture4.repeat.set(50, 1);
const material4 = new THREE.MeshBasicMaterial({ map: texture2 });
const grid4geometrymesh = new THREE.Mesh(grid4geometry, material2);
grid4geometrymesh.rotateX(Math.PI * 1);
grid4geometrymesh.rotateY(Math.PI * 1);
grid4geometrymesh.rotateZ(Math.PI * 1);
grid4geometrymesh.position.set( -400, -650 , -130);
fugObject.add(grid4geometrymesh);
//drawer1
const drawer1geometry = new THREE.BoxGeometry(10, 220, 500);
const drawer1geometrytrymesh = new THREE.Mesh(drawer1geometry, whiteaterial);
drawer1geometrytrymesh.position.set( -400, 650 , -100);
fugObject.add(drawer1geometrytrymesh);
//drawer2
const drawer2geometry = new THREE.BoxGeometry(10, 220, 500);
const drawer2geometrytrymesh = new THREE.Mesh(drawer2geometry, whiteaterial);
drawer2geometrytrymesh.position.set( -400, 400 , -100);
fugObject.add(drawer2geometrytrymesh);
fugObject.rotateY(Math.PI);
fugObject.position.set(400, 1750, 300);
const fug = new THREE.Object3D();
fug.add(fugObject);
return fug;
}
/*
export function fug(param) {
const width=800, height=1700, depth=600;
const fug = new THREE.Object3D();
const fugObject = new THREE.Object3D();
const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
const materialVeryGreyDark= new THREE.MeshLambertMaterial({color: 0x242424});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
const basematerial = new THREE.MeshLambertMaterial({color: 0xc4b2a8});
//right rack
const lrgeometry = new THREE.BoxGeometry(width, height, depth);
const lrmesh = new THREE.Mesh(lrgeometry, silvermaterial);
lrmesh.position.set(0 , 0 , -100);
fugObject.add(lrmesh);
//left rack
const rrgeometry = new THREE.BoxGeometry(width, height, depth);
const rrmesh = new THREE.Mesh(rrgeometry, silvermaterial);
rrmesh.position.set( 0, 0 , -710);
fugObject.add(rrmesh);
//basefug
const basegeometry = new THREE.BoxGeometry(width+250, height-800, depth+600);
const basemesh = new THREE.Mesh(basegeometry, silvermaterial);
basemesh.position.set( -130, -1320 , -400);
fugObject.add(basemesh);
//edge lle
const llegeometry = new THREE.BoxGeometry(50, 1700, 50);
const llemesh = new THREE.Mesh(llegeometry, materialGreyDark);
llemesh.position.set( -425, 0 , -985);
fugObject.add(llemesh);
//edge lre
const lregeometry = new THREE.BoxGeometry(50, 1700, 50);
const lremesh = new THREE.Mesh(lregeometry, materialGreyDark);
lremesh.position.set( -425, 0 , -430);
fugObject.add(lremesh);
//edge rle
const rlegeometry = new THREE.BoxGeometry(50, 1700, 50);
const rlemesh = new THREE.Mesh(rlegeometry, materialGreyDark);
rlemesh.position.set( -425, 0 , -370);
fugObject.add(rlemesh);
//edge rre
const rregeometry = new THREE.BoxGeometry(50, 1700, 50);
const rremesh = new THREE.Mesh(rregeometry, materialGreyDark);
rremesh.position.set( -425, 0 , 175);
fugObject.add(rremesh);
//edge lue
const luegeometry = new THREE.BoxGeometry(50, 50, 505);
const luemesh = new THREE.Mesh(luegeometry, materialGreyDark);
luemesh.position.set( -425, 825 , -707);
fugObject.add(luemesh);
//edge lde
const ldegeometry = new THREE.BoxGeometry(50, 50, 505);
const ldemesh = new THREE.Mesh(ldegeometry, materialGreyDark);
ldemesh.position.set( -425, -830 , -707);
fugObject.add(ldemesh);
//edge rue
const ruegeometry = new THREE.BoxGeometry(50, 50, 505);
const ruemesh = new THREE.Mesh(ruegeometry, materialGreyDark);
ruemesh.position.set( -425, 825 , -100);
fugObject.add(ruemesh);
//edge rde
const rdegeometry = new THREE.BoxGeometry(50, 50, 505);
const rdemesh = new THREE.Mesh(rdegeometry, materialGreyDark);
rdemesh.position.set( -425, -825 , -100);
fugObject.add(rdemesh);
//base1 left and texture
const drawer1geometry = new THREE.BoxGeometry(10, 1600, 500);
const textureLoader = new THREE.TextureLoader();
const texture = textureLoader.load('./components/fug1screenfoto.jpg');
texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
texture.repeat.set(1, 1);
const material = new THREE.MeshBasicMaterial({ map: texture });
const gridgeometrymesh = new THREE.Mesh(drawer1geometry, material);
gridgeometrymesh.rotateX(Math.PI * 1);
gridgeometrymesh.rotateY(Math.PI * 1);
gridgeometrymesh.rotateZ(Math.PI * 1);
gridgeometrymesh.position.set( -400, 0 , -707);
fugObject.add(gridgeometrymesh);
//base2 right and texture
const drawer2geometry = new THREE.BoxGeometry(10, 1600, 500);
const textureLoader2 = new THREE.TextureLoader();
const texture2 = textureLoader2.load('./components/fug2screenfoto.jpg');
texture2.wrapS = texture2.wrapT = THREE.RepeatWrapping;
texture2.repeat.set(1, 1);
const material2 = new THREE.MeshBasicMaterial({ map: texture2 });
const gridgeometry2mesh = new THREE.Mesh(drawer2geometry, material2);
gridgeometry2mesh.rotateX(Math.PI * 1);
gridgeometry2mesh.rotateY(Math.PI * 1);
gridgeometry2mesh.rotateZ(Math.PI * 1);
gridgeometry2mesh.position.set( -400, 0 , -100);
fugObject.add(gridgeometry2mesh);
//base3 FUG write and texture
const drawer0geometry = new THREE.BoxGeometry(1, 900, 1200);
const textureLoader0 = new THREE.TextureLoader();
const texture0 = textureLoader0.load('./components/fug0screenfoto.jpg');
texture0.wrapS = texture0.wrapT = THREE.RepeatWrapping;
texture0.repeat.set(1, 1);
const material0 = new THREE.MeshBasicMaterial({ map: texture0 });
const gridgeometry0mesh = new THREE.Mesh(drawer0geometry, material0);
gridgeometry0mesh.rotateX(Math.PI * 1);
gridgeometry0mesh.rotateY(Math.PI * 1);
gridgeometry0mesh.rotateZ(Math.PI * 1);
gridgeometry0mesh.position.set( -655, -1320 , -400);
fugObject.add(gridgeometry0mesh);
fugObject.rotateY(Math.PI);
fugObject.position.set(400, 1750, 300);
fug.add(fugObject);
return fug;
}
*/
export function gun(param) {
const sphereRadius=400, sphereFactor=0.3;
const cavityObject = new THREE.Object3D();
const cavitymaterial = new THREE.MeshLambertMaterial({color: 0xb0b0b0});
const cavitygeometry = new THREE.SphereGeometry(sphereRadius, 32, 32);
const cavitymesh = new THREE.Mesh(cavitygeometry, cavitymaterial);
cavitymesh.scale.setZ(sphereFactor);
cavityObject.add(cavitymesh);
/*const rfGeometry = new THREE.CylinderGeometry(cylinderRadius, cylinderRadius, cylinderHeight, 20, 2, false, 0, Math.PI * 2);
const rfMesh = new THREE.Mesh(rfGeometry, cavitymaterial);
// rfMesh.rotateX(Math.PI * 0.5);
rfMesh.position.set(0, sphereRadius, 0);
cavityObject.add(rfMesh);*/
return cavityObject;
}
// corrector fermi
export function correctorfermi() {
const length=400;
const CorrectorContiner = new THREE.Object3D();
const CorrectorMaster = new THREE.Object3D();
// coil settings
const loader = new THREE.TextureLoader();
const texture = loader.load('./components/coil_texture_fermi.png');
const textureTop = texture.clone();
const textureSide = texture.clone();
texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
texture.repeat.set(2, 20);
textureTop.center.set(0.5, 0.5);
textureTop.rotation = THREE.MathUtils.degToRad(90);
textureSide.offset.set(0, 0.8);
const dmaterial = new THREE.MeshLambertMaterial({map: texture});
const face = new THREE.MeshBasicMaterial({map: texture});
const faceTop = new THREE.MeshBasicMaterial({map: textureTop});
const faceSide = new THREE.MeshBasicMaterial({map: textureSide});
const materials = [face,face,faceTop,faceSide,faceSide,faceSide];
const d1geometry = new THREE.CylinderGeometry(500, 500, length, 4 /*radialSegments*/, 2 /*heightSegments*/, true /*openEnded*/,0 /*thetaStart*/, Math.PI * 2 /*thetaLength*/);
const d1mesh = new THREE.Mesh(d1geometry, materials);
d1mesh.position.set(0, 0, 0);
d1mesh.rotateX(Math.PI * 1.25);
d1mesh.rotateY(Math.PI * 1);
d1mesh.rotateZ(Math.PI * 1.5);
CorrectorMaster.add(d1mesh);
//spessore esterno plastica bianca
const redmaterialp = new THREE.MeshLambertMaterial({color: 0xeD2D2D2, side:THREE.DoubleSide});
const geometry_1p = new THREE.CylinderGeometry(501 /*radiusTop*/, 501 /*radiusBottom*/, 90 /*height*/, 4 /*radialSegments*/, 2 /*heightSegments*/, true /*openEnded*/,0 /*thetaStart*/, Math.PI * 2 /*thetaLength*/);
const dmesh_1p = new THREE.Mesh(geometry_1p, redmaterialp);
dmesh_1p.position.set(0, 0, 0);
dmesh_1p.rotateX(Math.PI * 1.25);
dmesh_1p.rotateY(Math.PI * 1);
dmesh_1p.rotateZ(Math.PI * 1.5);
CorrectorMaster.add(dmesh_1p);
//spessore alto centro
const redmaterial_5 = new THREE.MeshLambertMaterial({color: 0xeD2D2D2});
const geometry_1_5 = new THREE.BoxGeometry(length, 150, 700);
const dmesh_1_5 = new THREE.Mesh(geometry_1_5, redmaterial_5);
dmesh_1_5.position.set(0, 277, 0);
CorrectorMaster.add(dmesh_1_5);
//spessore basso
const dmesh_2 = new THREE.Mesh(geometry_1_5, redmaterial_5);
dmesh_2.position.set(0, -277, 0);
CorrectorMaster.add(dmesh_2);
//spessore destro
const geometry_3 = new THREE.BoxGeometry(length, 600, 150);
const dmesh_3 = new THREE.Mesh(geometry_3, redmaterial_5);
dmesh_3.position.set(0, 0, -275);
CorrectorMaster.add(dmesh_3);
//spessore sinistro
const dmesh_4 = new THREE.Mesh(geometry_3, redmaterial_5);
dmesh_4.position.set(0, 0, 275);
CorrectorMaster.add(dmesh_4);
//cubo al centro
const loader_2 = new THREE.TextureLoader();
const texture_2 = loader.load('./components/coil_texture_fermi.png');
texture_2.wrapS = texture_2.wrapT = THREE.RepeatWrapping;
texture_2.repeat.set(20, 20);
const textureTop_2 = texture.clone();
const textureSide_2 = texture.clone();
const dmaterial_2 = new THREE.MeshLambertMaterial({map: texture_2});
const geometry_2 = new THREE.BoxGeometry(390, 390, 390);
const dmesh_5 = new THREE.Mesh(geometry_2, dmaterial_2);
dmesh_5.position.set(0, 0, 0);
CorrectorMaster.add(dmesh_5);
//spessore interno plastica bianca
const redmaterial_6 = new THREE.MeshLambertMaterial({color: 0xeD2D2D2, side:THREE.DoubleSide});
const geometry_6 = new THREE.CylinderGeometry(280 /*radiusTop*/, 280 /*radiusBottom*/, 90 /*height*/, 4 /*radialSegments*/, 2 /*heightSegments*/, true /*openEnded*/,0 /*thetaStart*/, Math.PI * 2 /*thetaLength*/);
const dmesh_6 = new THREE.Mesh(geometry_6, redmaterial_6);
dmesh_6.position.set(0, 0, 0);
dmesh_6.rotateX(Math.PI * 1);
dmesh_6.rotateY(Math.PI * 1.25);
dmesh_6.rotateZ(Math.PI * 1);
CorrectorMaster.add(dmesh_6);
CorrectorMaster.position.set(0, 0, 0);
CorrectorContiner.add(CorrectorMaster);
CorrectorContiner.rotateY(Math.PI * 1);
CorrectorContiner.scale.setX(0.25);
CorrectorContiner.scale.setY(0.125);
CorrectorContiner.scale.setZ(0.25);
return CorrectorContiner;
}
// BPM (beam position monitor)
export function bpm(param) {
const width=300, height=300, depth=50, transverse=100;
const bpmObject = new THREE.Object3D();
const bpmmaterial = new THREE.MeshLambertMaterial({color: 0x8000ff});
const bpmgeometryh = new THREE.BoxGeometry(width, transverse, depth);
const bpmmeshh = new THREE.Mesh(bpmgeometryh, bpmmaterial);
bpmObject.add(bpmmeshh);
const bpmgeometryv = new THREE.BoxGeometry(transverse, height, depth);
const bpmmeshv = new THREE.Mesh(bpmgeometryv, bpmmaterial);
bpmObject.add(bpmmeshv);
return bpmObject;
}
// quadrupole fermi
export function quadrupolefermi(param) {
const length=200;
const QuadrupolContiner = new THREE.Object3D();
const QuadrupoleMaster = new THREE.Object3D();
const dmaterial = new THREE.MeshLambertMaterial({color: 0xe05040, side: THREE.DoubleSide});
const d1geometry = new THREE.CylinderGeometry(500, 500, length, 4 /*radialSegments*/, 2 /*heightSegments*/, true /*openEnded*/,0 /*thetaStart*/, Math.PI * 2 /*thetaLength*/);
const d1mesh = new THREE.Mesh(d1geometry, dmaterial);
d1mesh.position.set(0, 0, 0);
d1mesh.rotateX(Math.PI * 1.25);
d1mesh.rotateY(Math.PI * 1);
d1mesh.rotateZ(Math.PI * 1.5);
QuadrupoleMaster.add(d1mesh);
// coil settings
const coilmaterial = new THREE.MeshLambertMaterial({color: 0xcd7f32, side: THREE.DoubleSide});
const textureLoader = new THREE.TextureLoader();
const texture = textureLoader.load('./components/coil_texture.png');
texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
texture.repeat.set(5, 5);
const coiltexture = new THREE.MeshBasicMaterial({ map: texture });
const coilmaterials = [coiltexture, coilmaterial, coilmaterial];
const coilgeometry = new THREE.CylinderGeometry(110 /*radiusTop*/, 110 /*radiusBottom*/, 120 /*height*/, 25 /*radialSegments*/, 4 /*heightSegments*/, false /*openEnded*/,Math.PI * 1.5 /*thetaStart*/, Math.PI * 2 /*thetaLength*/);
//spessore alto
const redmaterial = new THREE.MeshLambertMaterial({color: 0xe05040});
const geometry_1 = new THREE.BoxGeometry(200, 100, 705);
const dmesh_1 = new THREE.Mesh(geometry_1, redmaterial);
dmesh_1.position.set(0, 300, 0);
QuadrupoleMaster.add(dmesh_1);
//spessore basso
const dmesh_2 = new THREE.Mesh(geometry_1, redmaterial);
dmesh_2.position.set(0, -300, 0);
QuadrupoleMaster.add(dmesh_2);
//spessore destro
const geometry_3 = new THREE.BoxGeometry(200, 500, 100);
const dmesh_3 = new THREE.Mesh(geometry_3, redmaterial);
dmesh_3.position.set(0, 0, -300);
QuadrupoleMaster.add(dmesh_3);
//spessore sinistro
const dmesh_4 = new THREE.Mesh(geometry_3, redmaterial);
dmesh_4.position.set(0, 0, 300);
QuadrupoleMaster.add(dmesh_4);
const geometry_5 = new THREE.BoxGeometry(200, 115, 280);
const dmesh_5 = new THREE.Mesh(geometry_5, redmaterial);
dmesh_5.rotateX(Math.PI * 0.25);
dmesh_5.position.set(0, 210, 210);
QuadrupoleMaster.add(dmesh_5);
const dmesh_6 = new THREE.Mesh(geometry_5, redmaterial);
dmesh_6.rotateX(Math.PI * 0.75);
dmesh_6.position.set(0, 210, -210);
QuadrupoleMaster.add(dmesh_6);
const dmesh_7 = new THREE.Mesh(geometry_5, redmaterial);
dmesh_7.rotateX(Math.PI * 0.75);
dmesh_7.position.set(0, -210, 210);
QuadrupoleMaster.add(dmesh_7);
const dmesh_8 = new THREE.Mesh(geometry_5, redmaterial);
dmesh_8.rotateX(Math.PI * 0.25);
dmesh_8.position.set(0, -210, -210);
QuadrupoleMaster.add(dmesh_8);
// coil basso destra
const d2mesh = new THREE.Mesh(coilgeometry, coilmaterials);
d2mesh.position.set(0, -130, 120);
d2mesh.rotateX(Math.PI * 1.25);
d2mesh.rotateY(Math.PI * 1.50);
d2mesh.rotateZ(Math.PI * 1.50);
QuadrupoleMaster.add(d2mesh);
// coil basso sinistra
const d3mesh = new THREE.Mesh(coilgeometry, coilmaterials);
d3mesh.position.set(0, -130, -120);
d3mesh.rotateX(Math.PI * 1.75);
d3mesh.rotateY(Math.PI * 1.50);
d3mesh.rotateZ(Math.PI * 1.50);
QuadrupoleMaster.add(d3mesh);
// coil alto destra
const d4mesh = new THREE.Mesh(coilgeometry, coilmaterials);
d4mesh.position.set(0, 130, 120);
d4mesh.rotateX(Math.PI * 0.75);
d4mesh.rotateY(Math.PI * 1.50);
d4mesh.rotateZ(Math.PI * 1.50);
QuadrupoleMaster.add(d4mesh);
// coil alto destra
const d5mesh = new THREE.Mesh(coilgeometry, coilmaterials);
d5mesh.position.set(0, 130, -120);
d5mesh.rotateX(Math.PI * 1.25);
d5mesh.rotateY(Math.PI * 1.50);
d5mesh.rotateZ(Math.PI * 1.50);
QuadrupoleMaster.add(d5mesh);
QuadrupoleMaster.position.set(0, 0, 0);
QuadrupolContiner.add(QuadrupoleMaster);
QuadrupolContiner.rotateY(Math.PI * -0.5);
QuadrupolContiner.scale.setX(0.5);
QuadrupolContiner.scale.setY(0.5);
QuadrupolContiner.scale.setZ(0.5);
return QuadrupolContiner;
}
// Bending Dipole
export function dipolefermi(length = 500) {
const dipoleContainer = new THREE.Object3D();
const dipoleMaster = new THREE.Object3D();
//texture
const loader = new THREE.TextureLoader();
const texture = loader.load('./components/dipole.png');
const textureTop = texture.clone();
const textureSide = texture.clone();
textureTop.center.set(0.5, 0.5);
textureTop.rotation = THREE.MathUtils.degToRad(90);
textureSide.offset.set(0, 0.8);
const dmaterial = new THREE.MeshLambertMaterial({map: texture});
const face = new THREE.MeshBasicMaterial({map: texture});
const faceTop = new THREE.MeshBasicMaterial({map: textureTop});
const faceSide = new THREE.MeshBasicMaterial({map: textureSide});
const materials = [face,face,faceTop,faceSide,faceSide,faceSide];
const d1geometry = new THREE.BoxGeometry(550, 400, length);
const d1mesh = new THREE.Mesh(d1geometry, materials);
d1mesh.position.set(-100, 100, 0);
dipoleMaster.add(d1mesh);
//Coil
const dipoleCoil = new THREE.Object3D();
const coilmaterial = new THREE.MeshLambertMaterial({color: 0xc08000});
const d4geometry = new THREE.BoxGeometry(100, 100, length);
const d4mesh = new THREE.Mesh(d4geometry, coilmaterial);
d4mesh.position.set(-200, 0, 0);
dipoleCoil.add(d4mesh);
const d2geometry = new THREE.CylinderGeometry(150 /*radiusTop*/, 150 /*radiusBottom*/, 100 /*height*/, 20 /*radialSegments*/, 2 /*heightSegments*/, false /*openEnded*/,Math.PI * 1.5 /*thetaStart*/, Math.PI * 1 /*thetaLength*/);
const d2mesh = new THREE.Mesh(d2geometry, coilmaterial);
d2mesh.position.set(-100, 0, length/2);
dipoleCoil.add(d2mesh);
const d3geometry = new THREE.CylinderGeometry(150 /*radiusTop*/, 150 /*radiusBottom*/, 100 /*height*/, 20 /*radialSegments*/, 2 /*heightSegments*/, false /*openEnded*/,Math.PI * 0.5 /*thetaStart*/, Math.PI * 1 /*thetaLength*/);
const d3mesh = new THREE.Mesh(d3geometry, coilmaterial);
d3mesh.position.set(-100, 0, -length/2);
dipoleCoil.add(d3mesh);
dipoleCoil.position.set(0, 0, 0);
dipoleMaster.add(dipoleCoil);
const dipoleCoil2 = dipoleCoil.clone();
dipoleCoil2.position.set(0, 200, 0);
dipoleMaster.add(dipoleCoil2);
dipoleMaster.position.set(100, 0, 0);
dipoleMaster.scale.setX(0.7);
dipoleMaster.scale.setY(0.7);
dipoleMaster.scale.setZ(0.7);
dipoleContainer.add(dipoleMaster);
return dipoleContainer;
}
// undulator
export function undulator(param) {
const length=1000;
const undulatorMaster = new THREE.Object3D();
const chamberMaterial = new THREE.MeshLambertMaterial({color: 0xc0c0c0});
const loader = new THREE.TextureLoader();
const texture = loader.load('./components/undulator.png');
const textureTop = texture.clone();
const textureSide = texture.clone();
textureTop.wrapS = textureTop.wrapT = THREE.RepeatWrapping;
textureTop.repeat.set(30, 1);
textureSide.offset.set(0.95, 0.95);
const face = new THREE.MeshBasicMaterial({map: texture});
const faceTop = new THREE.MeshBasicMaterial({map: textureTop});
const faceSide = new THREE.MeshBasicMaterial({map: textureSide});
const materials = [faceTop,faceTop,chamberMaterial,chamberMaterial,chamberMaterial,chamberMaterial];
const ugeometry = new THREE.BoxGeometry(400, 400, length);
const umesh = new THREE.Mesh(ugeometry, materials);
undulatorMaster.add(umesh);
const qedges = new THREE.EdgesGeometry(ugeometry);
const lineMaterial = new THREE.LineBasicMaterial({color: 0x000000});
lineMaterial.linewidth = 4;
const qline = new THREE.LineSegments(qedges, lineMaterial);
undulatorMaster.add(qline);
return undulatorMaster;
}
// valve
export function vlv(param) {
const vlvContiner = new THREE.Object3D();
const vlvObject = new THREE.Object3D();
//cylinder
const cylgeometry = new THREE.CylinderGeometry(25, 25, 50, 15);
const cylmaterial = new THREE.MeshLambertMaterial({color: 0xc7c7c7});
const cylmesh = new THREE.Mesh(cylgeometry, cylmaterial);
cylmesh.rotateX(Math.PI * 1);
cylmesh.rotateY(Math.PI * 1.0);
cylmesh.rotateZ(Math.PI * 1.5);
cylmesh.position.set(0, 0 , 0);
vlvObject.add(cylmesh);
// base1
const vlvgeometry = new THREE.BoxGeometry(30, 160, 60 );
const vlvmaterial = new THREE.MeshLambertMaterial({color: 0xc7c7c7});
const vlv1mesh = new THREE.Mesh(vlvgeometry, vlvmaterial);
vlv1mesh.position.set(0, 50, 0);
vlv1mesh.colorable = true;
vlvObject.add(vlv1mesh);
// hat1
const hatmaterial = new THREE.MeshLambertMaterial({color: 0xc7c7c7});
const hatgeometry = new THREE.BoxGeometry(50, 20, 100 );
const hatmesh = new THREE.Mesh(hatgeometry, hatmaterial);
hatmesh.colorable = true;
hatmesh.position.set(0, 120, 0);
vlvObject.add(hatmesh);
// blackbox
const blackboxmaterial = new THREE.MeshLambertMaterial({color: 0x636363});
const blackboxgeometry = new THREE.BoxGeometry(40, 70, 70 );
const blackboxmesh = new THREE.Mesh(blackboxgeometry, blackboxmaterial);
blackboxmesh.position.set(0, 165, 15);
vlvObject.add(blackboxmesh);
// blackbox2
const blackbox2material = new THREE.MeshLambertMaterial({color: 0x000000});
const blackbox2geometry = new THREE.BoxGeometry(40, 40, 20 );
const blackbo2xmesh = new THREE.Mesh(blackbox2geometry, blackbox2material);
blackbo2xmesh.position.set(0, 165, -30);
vlvObject.add(blackbo2xmesh);
vlvObject.scale.setX(1.5);
vlvObject.scale.setY(1.5);
vlvObject.scale.setZ(1.5);
//TRIANGLE1
const trianglegeometry = new THREE.CylinderGeometry(18, 18, 32, 3);
const trianglegeometrymesh = new THREE.Mesh(trianglegeometry, blackbox2material);
trianglegeometrymesh.rotateX(Math.PI * 0);
trianglegeometrymesh.rotateY(Math.PI * 0);
trianglegeometrymesh.rotateZ(Math.PI * 0.5);
trianglegeometrymesh.position.set(0, 60 , -17);
vlvObject.add(trianglegeometrymesh);
//TRIANGLE2
const trianglegeometry2 = new THREE.CylinderGeometry(18, 18, 32, 3);
const triangle2geometrymesh = new THREE.Mesh(trianglegeometry2, blackbox2material);
triangle2geometrymesh.rotateX(Math.PI * 0);
triangle2geometrymesh.rotateY(Math.PI * 1);
triangle2geometrymesh.rotateZ(Math.PI * 0.5);
triangle2geometrymesh.position.set(0, 60 ,17);
vlvObject.add(triangle2geometrymesh);
vlvObject.position.set(0, 0, 0);
vlvObject.rotateY(Math.PI * -0.5);
vlvContiner.add(vlvObject);
return vlvContiner;
}
export function vlvUpdate(c, color) {
const vlv = c.children[0].children;
for (let i=0; i<vlv.length; i++) {
if (vlv[i].colorable) {
vlv[i].material.dispose();
vlv[i].material = new THREE.MeshLambertMaterial({color: color});
}
}
}
// Beam Loss Monitor
export function blm(param) {
const length=10, dcolor='white', width=50;
const cMaster = new THREE.Object3D();
const d1geometry = new THREE.BoxGeometry(length, width, width);
const material = new THREE.MeshLambertMaterial({color: dcolor});
const d1mesh = new THREE.Mesh(d1geometry, material);
d1mesh.position.set(-length/2, 0, 0);
cMaster.add(d1mesh);
return cMaster;
}
function blmColor(val) {
if (document.location.search.indexOf('demo')>-1) {
if (val < 0) return 'white';
else if (val < 1) return 'yellow';
else if (val < 2) return 'orange';
else if (val < 3) return 'red';
else return 'violet';
}
if (val < 20) return 'white';
else if (val < 50) return 'yellow';
else if (val < 100) return 'orange';
else if (val < 200) return 'red';
else return 'violet';
}
export function blmUpdate(c, val, direction, width=100, histogramFactor=50) {
if (typeof val !== 'number') val = 0; else val = Math.abs(val);
const blm = c.children[0];
blm.material.dispose();
blm.material = new THREE.MeshLambertMaterial({color: blmColor(val)});
blm.geometry.dispose();
blm.geometry = new THREE.BoxGeometry(width+val*histogramFactor, width, width);
blm.position.set(direction*(width+val*histogramFactor)/2, 0, 0);
blm.geometry.computeVertexNormals();
blm.geometry.normalsNeedUpdate = true;
blm.geometry.verticesNeedUpdate = true;
blm.geometry.dynamic = true;
}
// PLC
export function plc(param) {
const plcObject = new THREE.Object3D();
const cardsObject = new THREE.Object3D();
const greenmaterial = new THREE.MeshLambertMaterial({color: 0x00ff11});
const greenDarkmaterial = new THREE.MeshLambertMaterial({color: 0x0b5e11});
const graymaterial = new THREE.MeshLambertMaterial({color: 0x575757});
const graymaterial2 = new THREE.MeshLambertMaterial({color: 0x7d7d7d});
const silvermaterial = new THREE.MeshLambertMaterial({color: 0xa6a6a6});
const blackmaterial = new THREE.MeshLambertMaterial({color: 0x000000});
// base
const basegeometry = new THREE.BoxGeometry(500, 300, 600);
const basegeometrymesh = new THREE.Mesh(basegeometry, silvermaterial);
basegeometrymesh.position.set( 0, 0 ,0);
plcObject.add(basegeometrymesh);
// card
const cardgeometry = new THREE.BoxGeometry(502, 270, 50);
const cardgeometrymesh = new THREE.Mesh(cardgeometry, blackmaterial);
cardgeometrymesh.position.set( 0, 0 , -200);
cardsObject.add(cardgeometrymesh);
//led1
const led1green = new THREE.BoxGeometry(504, 20, 20);
const led1greenmesh = new THREE.Mesh(led1green, greenmaterial);
led1greenmesh.position.set( 0, 120 , -200);
cardsObject.add(led1greenmesh);
//led2
const led2green = new THREE.BoxGeometry(504, 20, 20);
const led2greenmesh = new THREE.Mesh(led2green, greenmaterial);
led2greenmesh.position.set( 0, 90 , -200);
cardsObject.add(led2greenmesh);
//led3
const led3green = new THREE.BoxGeometry(504, 20, 20);
const led3greenmesh = new THREE.Mesh(led3green, greenmaterial);
led3greenmesh.position.set( 0, 60 , -200);
cardsObject.add(led3greenmesh);
//led4
const led4green = new THREE.BoxGeometry(504, 20, 20);
const led4greenmesh = new THREE.Mesh(led4green, greenmaterial);
led4greenmesh.position.set( 0, 30 , -200);
cardsObject.add(led4greenmesh);
//led5
const led5green = new THREE.BoxGeometry(504, 20, 20);
const led5greenmesh = new THREE.Mesh(led5green, greenDarkmaterial);
led5greenmesh.position.set( 0, 0 , -200);
cardsObject.add(led5greenmesh);
//led6
const led6green = new THREE.BoxGeometry(504, 20, 20);
const led6greenmesh = new THREE.Mesh(led6green, greenDarkmaterial);
led6greenmesh.position.set( 0, -30 , -200);
cardsObject.add(led6greenmesh);
//led7
const led7green = new THREE.BoxGeometry(504, 20, 20);
const led7greenmesh = new THREE.Mesh(led7green, greenDarkmaterial);
led7greenmesh.position.set( 0, -60 , -200);
cardsObject.add(led7greenmesh);
//led8
const led8green = new THREE.BoxGeometry(504, 20, 20);
const led8greenmesh = new THREE.Mesh(led8green, greenDarkmaterial);
led8greenmesh.position.set( 0, -90 , -200);
cardsObject.add(led8greenmesh);
//led9
const led9green = new THREE.BoxGeometry(504, 20, 20);
const led9greenmesh = new THREE.Mesh(led9green, greenDarkmaterial);
led9greenmesh.position.set( 0, -120 , -200);
cardsObject.add(led9greenmesh);
//CLONE Cards
const card2 = cardsObject.clone();
card2.position.set( 0, 0 , 50);
plcObject.add(card2);
const card3 = cardsObject.clone();
card3.position.set( 0, 0 , 100);
plcObject.add(card3);
const card4 = cardsObject.clone();
card4.position.set( 0, 0 , 150);
plcObject.add(card4);
const card5 = cardsObject.clone();
card5.position.set( 0, 0 , 200);
plcObject.add(card5);
// baseScreen
const baseScreengeometry = new THREE.BoxGeometry(502, 270, 200);
const baseScreengeometrymesh = new THREE.Mesh(baseScreengeometry, blackmaterial);
baseScreengeometrymesh.position.set( 0, 0 , 120);
plcObject.add(baseScreengeometrymesh);
// 1livel
const livel1geometry = new THREE.BoxGeometry(550, 150, 150);
const livel1geometrymesh = new THREE.Mesh(livel1geometry, graymaterial);
livel1geometrymesh.position.set( 0, 0 , 120);
plcObject.add(livel1geometrymesh);
// 2livel
const livel2geometry = new THREE.BoxGeometry(590, 100, 149);
const livel2geometrymesh = new THREE.Mesh(livel2geometry, graymaterial2);
livel2geometrymesh.position.set( 0, 0 , 120);
plcObject.add(livel2geometrymesh);
plcObject.add(cardsObject);
plcObject.scale.setX(0.7);
plcObject.scale.setY(0.7);
plcObject.scale.setZ(0.7);
return plcObject;
}
// bst
export function bst(param) {
const bstObject = new THREE.Object3D();
const bstContiner = new THREE.Object3D();
const materialGrey = new THREE.MeshLambertMaterial({color: 0xc0c0c0});
const d1geometry = new THREE.CylinderGeometry(25, 25, 200, 25);
const d1mesh = new THREE.Mesh(d1geometry, materialGrey);
d1mesh.position.set(0, 190, 0);
bstObject.add(d1mesh);
bstObject.rotateX(Math.PI * 1);
// circ base
const d2geometry = new THREE.CylinderGeometry(50, 50, 80, 15);
const d2mesh = new THREE.Mesh(d2geometry, materialGrey);
d2mesh.position.set(0, 290, 0);
d2mesh.rotateX(Math.PI * 1);
d2mesh.rotateY(Math.PI * 1);
d2mesh.rotateZ(Math.PI * 1.5);
bstObject.add(d2mesh);
// zigrinatura
const d4geometry = new THREE.CylinderGeometry(40, 40, 120, 15);
const textureLoader = new THREE.TextureLoader();
const texture = textureLoader.load('./components/flsc_texture.png');
texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
texture.repeat.set(5, 40);
const material = new THREE.MeshBasicMaterial({ map: texture });
const d4mesh = new THREE.Mesh(d4geometry, material);
d4mesh.rotateX(Math.PI * 1);
d4mesh.rotateY(Math.PI * 1);
d4mesh.rotateZ(Math.PI * 1);
d4mesh.position.set(0, 120 , 0);
bstObject.add(d4mesh);
// cil Major
const d5geometry = new THREE.CylinderGeometry(90, 90, 20, 15);
const d5mesh = new THREE.Mesh(d5geometry, materialGrey);
d5mesh.rotateX(Math.PI * 1);
d5mesh.rotateY(Math.PI * 1);
d5mesh.rotateZ(Math.PI * 1);
d5mesh.position.set(0, 50 , 0);
d5mesh.colorable = true;
bstObject.add(d5mesh);
// cil Med
const d6geometry = new THREE.CylinderGeometry(70, 70, 80, 15);
const d6mesh = new THREE.Mesh(d6geometry, materialGrey);
d6mesh.rotateX(Math.PI * 1);
d6mesh.rotateY(Math.PI * 1);
d6mesh.rotateZ(Math.PI * 1);
d6mesh.position.set(0, 0 , 0);
d6mesh.colorable = true;
bstObject.add(d6mesh);
// cil low
const d7geometry = new THREE.CylinderGeometry(50, 50, 120, 15);
const d7mesh = new THREE.Mesh(d7geometry, materialGrey);
d7mesh.rotateX(Math.PI * 1);
d7mesh.rotateY(Math.PI * 1);
d7mesh.rotateZ(Math.PI * 1);
d7mesh.position.set(0, -100 , 0);
d7mesh.colorable = true;
bstObject.add(d7mesh);
const d8geometry = new THREE.CylinderGeometry(60, 60, 20, 15);
const d8mesh = new THREE.Mesh(d8geometry, materialGrey);
d8mesh.rotateX(Math.PI * 1);
d8mesh.rotateY(Math.PI * 1);
d8mesh.rotateZ(Math.PI * 1);
d8mesh.position.set(0, -170 , 0);
bstObject.add(d8mesh);
bstObject.position.set(0, 290, 0);
bstContiner.add(bstObject);
bstContiner.rotateY(Math.PI * -0.5);
return bstContiner;
}
export function bstUpdate(c, color) {
const vlv = c.children[0].children;
for (let i=0; i<vlv.length; i++) {
if (vlv[i].colorable) {
vlv[i].material.dispose();
vlv[i].material = new THREE.MeshLambertMaterial({color: color});
}
}
}