/*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(width=800, height=2000, 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);
		gunmesh.position.set(width/2, height/2, depth/2);
		gunObject.add(gunmesh);
		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(width=800, height=2000, depth=600) {return rack(width, height, depth);}

	export function rv(param) {
		const width=800, height=2500, depth=800;
		const rv = new THREE.Object3D();
		const rv_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;
			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(850, 90, 800);
			rv.add(group2);			
		
			
		}
		function refreshText() {
			group.remove( textMesh );
			if ( ! text ) return;
			createText();
		}
		insertText(50, [850, 2330, 600], [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});
		
		// rack
		const rrgeometry = new THREE.BoxGeometry(width, height, depth);
		const rrmesh = new THREE.Mesh(rrgeometry, softbluematerial);
		rrmesh.position.set( 0, 0 , -5);
		rv_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 , -5);
		rv_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 , -5);
		rv_rackObject.add(Rtargetmesh);		
		
		//edge le	
		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 re		
		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 ue		
		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 de		
		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);				

	
		//base and add texture
		const drawer1geometry = new THREE.BoxGeometry(10, 2450, 550);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/rvscreenfoto.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 , -10);
		rv_rackObject.add(gridgeometrymesh);			

		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, [810,1730,550], [0, Math.PI / 2, 0]);
	
		const silvermaterial = new THREE.MeshLambertMaterial({color: 0xc5c2bd});
		const target = new THREE.MeshLambertMaterial({color: 0xfbe928});

		//rack
		const geometry = new THREE.BoxGeometry(width, height, depth);
		const rackmesh = new THREE.Mesh(geometry, silvermaterial);
		rackmesh.position.set( 0, 0 , 0);
		id_rackObject.add(rackmesh);	
		
		//front yellow tag
		const Ftarget = new THREE.BoxGeometry(2, 90, 550);
		const Ftargetmesh = new THREE.Mesh(Ftarget, target);
		Ftargetmesh.position.set( -401, 900 , -15);
		id_rackObject.add(Ftargetmesh);		
		//Rear yellow tag
		const Rtarget = new THREE.BoxGeometry(2, 90, 550);
		const Rtargetmesh = new THREE.Mesh(Rtarget, target);
		Rtargetmesh.position.set( 401, 900 , -15);
		id_rackObject.add(Rtargetmesh);		
		
		//base and build texture
		const drawer1geometry = new THREE.BoxGeometry(2, height, width-200);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/idscreenfoto.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 , 0);
		id_rackObject.add(gridgeometrymesh);

		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=1500, 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 rrgeometry = new THREE.BoxGeometry(width, height, depth);
		const rrmesh = new THREE.Mesh(rrgeometry, materialGreyDark);
		
		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, 600);
			rllrf.add(group2);			
			
		}
		function refreshText() {
			group.remove( textMesh );
			if ( ! text ) return;
			createText();
		}
		insertText(50, [1000,1270,550], [0, Math.PI / 2, 0]);		
		
		//rrmesh.position.set( 0, 0 , -depth+290);
		llrf_rackObject.add(rrmesh);
		
		//front yellow tag
		const Ftarget = new THREE.BoxGeometry(2, 90, 550);
		const Ftargetmesh = new THREE.Mesh(Ftarget, target);
		Ftargetmesh.position.set( -405, 640 , 10);
		llrf_rackObject.add(Ftargetmesh);		
		//Rear yellow tag
		const Rtarget = new THREE.BoxGeometry(2, 90, 550);
		const Rtargetmesh = new THREE.Mesh(Rtarget, target);
		Rtargetmesh.position.set( 405, 640 , 10);
		llrf_rackObject.add(Rtargetmesh);			


		//base and add texture
		const drawer1geometry = new THREE.BoxGeometry(10, 1500, 600);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/rllrfscreenfoto.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 , 10);
		llrf_rackObject.add(gridgeometrymesh);	

		llrf_rackObject.rotateY(Math.PI);
		llrf_rackObject.position.set(600, 750, 300);
		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, 1925, -180], [0, Math.PI / 2, 0]);				

		const greenmaterial = new THREE.MeshLambertMaterial({color: 0x00ac76});
		const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
		//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);
		
		//front yellow tag
		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 tag
		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);		
	
		//base and build texture
		const drawer1geometry = new THREE.BoxGeometry(2, height, width);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/rpsbscreenfoto.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( -503, 0 , 0);
		rpsb_rackObject.add(gridgeometrymesh);			
		
		rpsb_rackObject.rotateY(Math.PI);
		rpsb_rackObject.position.set(400, 1050, -400);
		rpsb.add(rpsb_rackObject);	
		return rpsb;
	}

	// PS rack
	export function rps(param) {
		const width=800, height=2500, depth=600;
		const rps = new THREE.Object3D();
		const rps_rackObject = 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, 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});
		
		// rack
		const rrgeometry = new THREE.BoxGeometry(width, height, depth);
		const rrmesh = new THREE.Mesh(rrgeometry, softbluematerial);
		rrmesh.position.set( 0, 0 , -10);
		rps_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 , -15);
		rps_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 , -15);
		rps_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);
		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);				

	
		//base and build texture
		const drawer1geometry = new THREE.BoxGeometry(10, 2450, 550);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/rpsscreenfoto.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 , -10);
		rps_rackObject.add(gridgeometrymesh);			
		
		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, 450], [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});
		
		// 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 tag
		const Ftarget = new THREE.BoxGeometry(2, 90, 550);
		const Ftargetmesh = new THREE.Mesh(Ftarget, target);
		Ftargetmesh.position.set( -451, 1200 , 0);
		rc_rackObject.add(Ftargetmesh);		
		//Rear yellow tag
		const Rtarget = new THREE.BoxGeometry(2, 90, 550);
		const Rtargetmesh = new THREE.Mesh(Rtarget, target);
		Rtargetmesh.position.set( 401, 1200 , 0);
		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);				

	
		//base and build texture
		const drawer1geometry = new THREE.BoxGeometry(10, 2450, 550);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/rcscreenfoto.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 , -10);
		rc_rackObject.add(gridgeometrymesh);			
		
		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});
		
		// 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 tag
		const Ftarget = new THREE.BoxGeometry(2, 90, 550);
		const Ftargetmesh = new THREE.Mesh(Ftarget, target);
		Ftargetmesh.position.set( -451, 1200 , -15);
		rd_rackObject.add(Ftargetmesh);		
		//Rear yellow tag
		const Rtarget = new THREE.BoxGeometry(2, 90, 550);
		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);				

	
		//base and build texture
		const drawer1geometry = new THREE.BoxGeometry(10, 2450, 550);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/rdscreenfoto.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 , -10);
		rd_rackObject.add(gridgeometrymesh);	

		rd_rackObject.rotateY(Math.PI);
		rd_rackObject.position.set(400, 1250, 300);
		rd.add(rd_rackObject);	
		return rd;
	}		

	// PRP rack
	export function rrp(param) {
		const width=800, height=2500, depth=600;
		const rrp = new THREE.Object3D();
		const rrp_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;
			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, 1050);
			rrp.add(group2);			
			
		}
		function refreshText() {
			group.remove( textMesh );
			if ( ! text ) return;
			createText();
		}
		insertText(50, [850, 2330, 800], [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});
		//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 tag
		const Ftarget = new THREE.BoxGeometry(2, 90, 700);
		const Ftargetmesh = new THREE.Mesh(Ftarget, target);
		Ftargetmesh.position.set( -451, 1200 , -15);
		rrp_rackObject.add(Ftargetmesh);		
		//Rear yellow tag
		const Rtarget = new THREE.BoxGeometry(2, 90, 700);
		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);				

	
		//base and build texture
		const drawer1geometry = new THREE.BoxGeometry(10, 2450, 550);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/rrpscreenfoto.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 , -10);
		rrp_rackObject.add(gridgeometrymesh);			
		
		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, num=1) {
		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, 630], [0, Math.PI / 2, 0]);
	
		const materialGreyDark= new THREE.MeshLambertMaterial({color: 0x9d9d9d});
		const silvermaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
		const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
		
		//front yellow tag
		const Ftarget = new THREE.BoxGeometry(2, 90, 600);
		const Ftargetmesh = new THREE.Mesh(Ftarget, target);
		Ftargetmesh.position.set( -451, 1200 , -15);
		kly_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 , -15);
		kly_rackObject.add(Rtargetmesh);			
		
		// 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);
		
		//edge le		
		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 re		
		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 ue		
		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 de		
		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);
		
		//base and texture
   		const drawer1geometry = new THREE.BoxGeometry(10, 2450, 750);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/rar'+num+'texture.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 , 0);
		kly_rackObject.add(gridgeometrymesh);				

		kly_rackObject.rotateY(Math.PI);
		kly_rackObject.position.set(400, 1250, 400);
		rar.add(kly_rackObject);	
		return rar;
	}

	// 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 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]);		
	
		const bluematerial = new THREE.MeshLambertMaterial({color: 0x0053d9});
		const softbluematerial = new THREE.MeshLambertMaterial({color: 0x2b7cff});
		const target = new THREE.MeshLambertMaterial({color: 0xfbe928});
		//front yellow tag
		const Ftarget = new THREE.BoxGeometry(2, 90, 600);
		const Ftargetmesh = new THREE.Mesh(Ftarget, target);
		Ftargetmesh.position.set( -451, 1200 , -15);
		rtf_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 , -15);
		rtf_rackObject.add(Rtargetmesh);				
		
		//left 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);		
		
		//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 and build texture
		const drawer1geometry = new THREE.BoxGeometry(10, 2450, 550);
		const textureLoader = new THREE.TextureLoader();
		const texture = textureLoader.load('./components/rtfscreenfoto.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 , -10);
		rtf_rackObject.add(gridgeometrymesh);			
		
		rtf_rackObject.rotateY(Math.PI);
		rtf_rackObject.position.set(400, 1250, 400);
		rtf.add(rtf_rackObject);	
		return rtf;
	}


	// RAR2
	export function rar2(param) {
		return rar1(param, 2);
	}

	// RAR3
	export function rar3(param) {
		return rar1(param, 3);
	}

	// 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=1500;
		const cavitylinacMaster = new THREE.Object3D();
		const dmaterial = new THREE.MeshLambertMaterial({color: 0xf0f0f0});
		const d1geometry = new THREE.CylinderGeometry(400, 400, length, 25);
		const d1mesh = new THREE.Mesh(d1geometry, dmaterial);
		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;
	}

	// fug PS
	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=200, sphereFactor=0.8;
		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(200, 0, 0);
		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;
	}

	// 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;
	}

	// Beam Loss Monitor
	export function blm(param) {
		const length=100, dcolor='white', width=100;
		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;
	}
	// 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});
			}
		}
	}
	// 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});
			}
		}
	}