diff --git a/src/modules/controller.js b/src/modules/controller.js
index d5bf0f5..c501368 100644
--- a/src/modules/controller.js
+++ b/src/modules/controller.js
@@ -15,7 +15,7 @@ let controller = this;
let prescrizione;
let def_config;
let lang = navigator.language.split('-')[0] != 'it' ? 'en' : 'it';
-
+const hidden_fields = {};
let API = 'http://localhost/api/';
let CRM_URL = 'http://localhost/prescrizioni/';
let CFG_URL = 'http://localhost/config-predefinite/';
@@ -182,6 +182,21 @@ export const init = async (_scene, _cameraControls) => {
}else{
generaModalProdotti(); //riattivare
+ /** eliminare prima di andare in produzione */
+
+ $("#salvaDati").on('click', () => {
+ $("#clinicoPazienteModal").modal('hide');
+ let clinico = $("#nomeClinico").val();
+ let paziente = $("#nomePaziente").val();
+ let html = clinico ? '
'+_t('clinico')+': '+clinico+'
' : '';
+ html += '
'+_t('paziente')+': '+paziente+'
';
+ $(".dettagli-prescrizione").html(html);
+ });
+
+ $("#clinicoPazienteModal").modal('show');
+
+ /* ***** */
+
$(".btn-salva").addClass('d-none');
$(".btn-torna-prescrizione").addClass('d-none');
}
@@ -281,15 +296,12 @@ const attivaEvento = (field) => {
if(field.field_type == 'select'){
label = $("#"+field.id+" option:selected").text();
- //console.log("LABEL",label)
}
if(field.data_type == 'model'){
updateConfig(field, val, label);
- //console.log("model",field);
-
}else{
config[field.id] = {field: field, value: val, label: label};
Object.keys(config).forEach((k) => {
@@ -302,15 +314,80 @@ const attivaEvento = (field) => {
ui.generaListaConfig(config,menu_data)
}
- if(field.check_depends){
+
+ if(field.check_depends && field?.depends_on?.hide == null){
+
document.querySelectorAll(`[data-dep-id="${field.id}"]`).forEach((el) => {
-
+
if (el.getAttribute('data-dep-value') !== val) {
el.style.display = 'none';
} else {
el.style.display = '';
}
+
});
+
+ let firstVisibleOption = document.querySelector(`[data-dep-id="${field.id}"]:not([style*="display: none"])`);
+
+ if (firstVisibleOption) {
+ let emptyOption = firstVisibleOption.parentNode.querySelector('option[value=""]');
+
+ if (emptyOption) {
+ emptyOption.selected = true;
+ } else {
+ firstVisibleOption.selected = true;
+ }
+
+ firstVisibleOption.parentElement.dispatchEvent(new Event('change'));
+ }
+ }else if(field.check_depends && field.depends_on.hide){
+
+ document.querySelectorAll(`[data-dep-id]`).forEach((el) => {
+ if(el.type === 'checkbox') {
+
+ if(el.getAttribute('data-dep-id') === field.id) {
+ if(!el.checked && val.length > 0) {
+ el.parentElement.style.display = 'none';
+ } else {
+ el.parentElement.style.display = '';
+ }
+ }
+ }
+
+ });
+
+ //document.querySelector(`#${field.depends_on.id}`).parentElement.style.display = 'none';
+
+ }
+ if(field.reset_field){
+ //console.log("resetto", field.reset_field)
+ $("#"+field.reset_field).val('');
+ $("#"+field.reset_field).trigger('change');
+ }
+
+ if(field.hide_elements != null){
+ field.hide_elements.forEach((el_id) => {
+ if(hidden_fields[el_id] == null)
+ hidden_fields[el_id] = 0;
+
+ if(val.length > 0)
+
+ hidden_fields[el_id]++;
+ else{
+ hidden_fields[el_id]--;
+ if(hidden_fields[el_id] < 0)
+ hidden_fields[el_id] = 0;
+ }
+
+ })
+ }
+
+ for(let k in hidden_fields){
+ if(hidden_fields[k] > 0){
+ $("#"+k).parent().parent().hide();
+ }else{
+ $("#"+k).parent().parent().show();
+ }
}
})
}
diff --git a/src/modules/interfaccia.js b/src/modules/interfaccia.js
index a8029a5..c36f7d1 100644
--- a/src/modules/interfaccia.js
+++ b/src/modules/interfaccia.js
@@ -93,14 +93,14 @@ export const generaMenu = (data) => {
field_list.forEach((field) => {
if (field.depends_on) {
- let dependentField = field_list.find(f => f.id === field.depends_on);
+ let dependentField = field_list.find(f => f.id === field.depends_on || f.id === field.depends_on.id);
+
if (dependentField) {
dependentField.check_depends = true;
}
}
});
- console.log("field_list", field_list);
return field_list;
}
@@ -215,15 +215,21 @@ export const generaCheckbox = (field) => {
field.id = 'input-'+gen_id;
gen_id++;
}
+
+ let depends_str = '';
+ if(field.depends_on != null){
+ depends_str = ` data-dep-id="${field.depends_on.id}" data-dep-value="${field.depends_on.value}"`
+ }
+
let inline = field.inline ? 'd-inline-block' : '';
- let html = '
';
+ let html = `
`;
field_list.push(field);
return html;
diff --git a/src/modules/scena-controller copy.js b/src/modules/scena-controller copy.js
new file mode 100644
index 0000000..d5c8f80
--- /dev/null
+++ b/src/modules/scena-controller copy.js
@@ -0,0 +1,707 @@
+import * as THREE from 'three'
+import { TrackballControls } from 'three/examples/jsm/controls/TrackballControls';
+import * as interfaccia from './interfaccia';
+import { STLLoader } from 'three/examples/jsm/loaders/STLLoader';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { FontLoader } from 'three/addons/loaders/FontLoader.js';
+import { TextGeometry } from 'three/addons/geometries/TextGeometry.js';
+import { DecalGeometry } from 'three/examples/jsm/geometries/DecalGeometry.js';
+
+
+import WebGPU from 'three/examples/jsm/capabilities/WebGPU';
+import WebGL from 'three/examples/jsm/capabilities/WebGL';
+
+
+import * as JSZip from 'jszip';
+import * as JSZipUtils from 'jszip-utils';
+import 'jszip-utils';
+import { degToRad } from 'three/src/math/MathUtils';
+
+
+/**
+ * Sizes
+ */
+const sizes = {}
+
+
+// Scene
+let scene = new THREE.Scene()
+let mainGroup = new THREE.Group();
+
+let camera;
+let cameraControls;
+const clock = new THREE.Clock();
+
+let actions = [];
+let mixers = [];
+let end = false;
+let doRender = false;
+let renderer = null;
+
+let frustumSize = 1600; // Aumentato per vedere meglio i modelli (era 1100)
+
+$(".loading").css('visibility','visible');
+
+window.addEventListener('resize', () =>
+{
+ // Save sizes
+ updateWindowSize();
+
+ if(camera != null){
+ // Update camera
+ // Aggiorna le dimensioni del frustum della camera
+ var aspect = sizes.width / sizes.height;
+ // Imposta questo al valore che preferisci
+
+ camera.left = -frustumSize * aspect / 2;
+ camera.right = frustumSize * aspect / 2;
+ camera.top = frustumSize / 2;
+ camera.bottom = -frustumSize / 2;
+
+ // Aggiorna la matrice di proiezione della camera
+ camera.updateProjectionMatrix();
+
+ }
+ // Update renderer
+ renderer.setPixelRatio(window.devicePixelRatio)
+ renderer.setSize(sizes.width, sizes.height)// renderer.setSize(sizes.width, sizes.height, true)
+ doRender = true;
+})
+
+window.addEventListener('load', ()=>{ init(); });
+
+
+const updateWindowSize = () => {
+ let canvas = document.querySelector('.canvas-container');
+ sizes.width = canvas.clientWidth
+ sizes.height = canvas.clientHeight
+
+ //console.log("canvas size", sizes)
+}
+
+export const matValues = (nome) => {
+
+ let roughness = parseFloat($("#roughness-"+nome).val());
+ let metalness = parseFloat($("#metalness-"+nome).val());
+
+ if(isNaN(roughness)) roughness = 0;
+ if(isNaN(metalness)) metalness = 0;
+ let obj = scene.getObjectByName(nome);
+
+ if(obj.isMesh){
+
+ obj.material.roughness = roughness;
+ obj.material.metalness = metalness;
+ obj.material.needsUpdate = true;
+ doRender = true;
+
+ }
+
+};
+
+const loadJsonModel = (name, path, callback = null) => {
+
+ const loader = new THREE.ObjectLoader();
+ let loadBar = $(".load-bar");
+
+ JSZipUtils.getBinaryContent('./assets/'+name+'.zip', {
+
+ progress: (update) => {
+ //console.log(e.percent + "% loaded");
+ $(loadBar).text(parseInt(update.percent) + '%');
+ },
+ callback: (err, data) => {
+ if(err) {
+ throw err; // or handle err
+ }
+
+ $(".loading").text("Inizializzazione scena...");
+ // loadStatus.nativeElement.innerHTML = 'Caricamento...';
+ //clearInterval(timer);
+ JSZip.loadAsync(data).then((zip) => {
+ let sceneFile = zip.file(name+'.json');
+ sceneFile.async('string', (update) => {
+ //console.log(update);
+ $(loadBar).text(parseInt(update.percent) + '%');
+ }).then((objectJson) => {
+
+ loader.parse(JSON.parse(objectJson), (parsedObj)=>{
+
+ if(callback != null){
+ callback(parsedObj);
+ }
+
+ });
+ });
+
+ });
+ }});
+
+}
+
+export const loadSTLModel = async (name, path, color, material, callback = null) => {
+
+ return new Promise(async (resolve, reject) => {
+ const loader = new STLLoader();
+
+ interfaccia.showLoader();
+
+ let geometry;
+ loader.loadAsync(path+name+".stl", (progress) => {
+ interfaccia.aggiornaLoader(progress);
+ }).then((obj) => {
+
+ let mesh = addModelToScene(obj, name, color, material);
+ interfaccia.resetLoader();
+ resolve(mesh);
+
+ }).catch((err) => {
+
+ interfaccia.resetLoader();
+ resolve(null)
+ console.log(err);
+
+ });
+ });
+
+}
+
+export const loadGLBModel = async (name, path, color, material, callback = null) => {
+
+ return new Promise(async (resolve, reject) => {
+ const loader = new GLTFLoader();
+
+ interfaccia.showLoader();
+
+ let geometry;
+ loader.loadAsync(path+name+".glb", (progress) => {
+ interfaccia.aggiornaLoader(progress);
+ }).then((obj) => {
+
+ let mesh = addModelToScene(obj.scene.children[0], name, color, material);
+ interfaccia.resetLoader();
+ resolve(mesh);
+
+ }).catch((err) => {
+
+ interfaccia.resetLoader();
+ resolve(null)
+ console.log(err);
+
+ });
+
+
+ //if(callback != null) callback();
+ });
+
+}
+
+export const addModelToScene = (obj, name, color, material_type) => {
+
+ let mesh = null;
+
+
+ let roughness = 1;
+ let metalness = 0;
+
+ if(material_type == 'metal'){
+ metalness = 0.3;
+ roughness = 0.20;
+ }
+
+ const material = new THREE.MeshStandardMaterial({color: color, roughness: roughness, metalness: metalness}); //'#a0a0a0'
+
+ if(obj.isMesh){
+ mesh = obj;
+ mesh.material.color = new THREE.Color(color);
+ mesh.material.roughness = roughness;
+ mesh.material.metalness = metalness;
+ mesh.material.needsUpdate = true;
+ }else{
+ mesh = new THREE.Mesh(obj, material);
+ }
+
+ mesh.scale.multiplyScalar(15);
+ mesh.name = name;
+ mesh.castShadow = false;
+ mesh.receiveShadow = false;
+ mainGroup.add(mesh)
+ //console.log(mesh)
+ //scene.add(mesh);
+ //console.log(scene)
+ doRender = true;
+ return mesh;
+}
+
+export const mostraArcata = async (model) => {
+
+ const url = new URL(location.href);
+ const params = url.searchParams;
+
+ let debug = params.get('debug');
+
+ let el = scene.getObjectByName("modello-"+model);
+ $(".color-"+model).addClass('d-none');
+
+ if(el){
+ if(el.visible){
+ el.visible = false;
+
+
+ }else{
+ el.visible = true;
+ if(debug == 'true'){
+ $(".color-"+model).removeClass('d-none');
+ }
+ }
+
+ doRender = true;
+ }
+ else{
+ let obj = await loadGLBModel("modello-"+model, './assets/glb/', '#ffffff');
+ obj.userData = {"type":"arcata"};
+ obj.material.roughness = 0.26;
+ obj.material.metalness = 0;
+
+ if(debug == 'true'){
+ $(".color-"+model).removeClass('d-none');
+ }
+
+ }
+
+}
+
+const randomColor = () => {
+ var color = '#';
+ var caratteri = '0123456789ABCDEF';
+
+ for (var i = 0; i < 6; i++) {
+ color += caratteri[Math.floor(Math.random() * 16)];
+ }
+
+ return color;
+}
+
+export const loadModels = async (config) => {
+ let activeObjs = [];
+ console.log("Config:", config);
+ return new Promise(async (resolve, reject)=>{
+ for(let key in config){
+
+ let el = config[key];
+
+ if(el.field.data_type == 'model' && el.value != ""){
+ let obj = scene.getObjectByName(el.value);
+ el.colore = el.colore == null ? el.field.color: el.colore
+ console.log("Loading model:", el.value, el.colore, el.field.material);
+ if(obj != null)
+ activeObjs.push(obj);
+ else{
+
+ obj = await loadGLBModel(el.value, './assets/glb/', el.colore, el.field.material);
+ if(obj != null)
+ activeObjs.push(obj);
+ else{
+ el.model_not_found = true;
+ }
+
+ }
+
+ if(el.field.accessory != null && el.field.accessory != ""){
+ let acc = scene.getObjectByName(el.field.accessory);
+ if(acc != null)
+ activeObjs.push(acc);
+ else{
+ acc = await loadGLBModel(el.field.accessory, './assets/glb/', el.colore, el.field.material);
+ if(acc != null)
+ activeObjs.push(acc);
+ else{
+ el.accessory_not_found = true;
+ }
+ }
+ }
+ }
+
+
+ }
+
+ console.log("Active objs:", activeObjs);
+
+ mainGroup.traverse((el) => {
+ if(el.isMesh && el.userData.type != 'arcata') el.visible = false;
+ });
+
+ activeObjs.forEach((obj) => {
+ obj.visible = true;
+ });
+
+ doRender = true;
+ resolve();
+ })
+
+
+}
+
+export const init = async () => {
+
+ //let scena = await (await fetch("./assets/scene.json")).json();
+ const loader = new THREE.ObjectLoader();
+ scene = await loader.loadAsync("./assets/scene.json");
+
+ let pointLight, ambientLight;
+ updateWindowSize();
+ renderer = new THREE.WebGLRenderer({
+ canvas: document.querySelector('.webgl'),
+ antialias: true,
+ alpha: true,
+ useLegacyLights: false
+ })
+
+ mainGroup.rotateX(degToRad(-90));
+ scene.add(mainGroup);
+
+ /*
+ scene.traverse((obj) => {
+
+ if(obj.isLight && Math.abs(obj.position.x) == 50){
+ obj.shadow.mapSize.width = 1024; // default
+ obj.shadow.mapSize.height = 1024; // default
+ obj.shadow.camera.near = 330; // default
+ obj.shadow.camera.far = 1000; // default
+ obj.shadow.camera.right = 500;
+ obj.shadow.camera.left = -500;
+ obj.shadow.camera.top = 500;
+ obj.shadow.camera.bottom = -500;
+ obj.shadow.radius = 2000;
+ obj.shadow.blurSamples = 2500;
+ obj.position.y = 0;
+ obj.castShadow = true;
+
+ //const helper = new THREE.CameraHelper( obj.shadow.camera );
+ //scene.add( helper );
+
+ }
+ })
+
+ renderer.shadowMap.autoUpdate = false;
+ renderer.shadowMap.needsUpdate = true; //chiamare ogni volta che viene aggiunto un elemento
+*/
+
+ let view = {
+ left: 0,
+ bottom: 0,
+ width: 1,
+ height: 1,
+ background: new THREE.Color( 0.5, 0.5, 0.7 ),
+ eye: [0,0,2800],// [ 0, 300, 1800 ],
+ up: [ 0, 1, 0 ],
+ fov: 50,
+ frustum: 120,
+ container: '.view1',
+ active: true,
+ main: true,
+ updateCamera: function ( camera, scene, mouseX ) {
+
+ }
+ }
+
+ let aspect = sizes.width / sizes.height;
+
+ //camera = new THREE.PerspectiveCamera(50, sizes.width / sizes.height, 0.1, 10000);
+ camera = new THREE.OrthographicCamera( frustumSize * aspect / - 2, frustumSize * aspect / 2, frustumSize / 2, frustumSize / - 2, 0.1, 10000 );
+
+ camera.position.fromArray( view.eye );
+ camera.up.fromArray( view.up );
+
+ scene.add(camera);
+
+ var pointLight2 = new THREE.PointLight( 0xffffff, 0.8 ); // 0xff6666
+ camera.add( pointLight2 );
+/*
+
+ ambientLight = new THREE.AmbientLight( 0xffffff, 0.3 );
+ scene.add( ambientLight );
+
+ pointLight = new THREE.PointLight( 0x7c7b7b, 0.5 ); // 0xff0000
+ pointLight.position.z = 2500;
+ scene.add( pointLight );
+
+
+ var pointLight3 = new THREE.PointLight( 0x7c7b7b, 0.5 ); // 0x0000ff
+ pointLight3.position.x = - 1000;
+ pointLight3.position.z = 1000;
+ scene.add( pointLight3 );
+
+ let pointLight4 = new THREE.DirectionalLight( 0x7c7b7b, 0.8 ); // 0xff0000
+ pointLight4.position.y = 0;
+
+ scene.add( pointLight4 );
+*/
+ window.scene = scene;
+
+ renderer.setPixelRatio(window.devicePixelRatio)
+ renderer.setSize(sizes.width, sizes.height)
+ renderer.toneMapping = THREE.CineonToneMapping;
+ renderer.toneMappingExposure = 0.5;
+ renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+ renderer.shadowMap.enabled = true;
+ renderer.physicallyCorrectLights = false;
+
+
+
+ cameraControls = new TrackballControls( camera, renderer.domElement );
+
+ cameraControls.minDistance = 1;
+ cameraControls.maxDistance = Infinity;
+
+ // TrackballControls permette rotazione infinita in tutte le direzioni
+ cameraControls.rotateSpeed = 2.5; // Aumentata sensibilità rotazione
+ cameraControls.zoomSpeed = 1.2;
+ cameraControls.panSpeed = 0.8;
+
+ // No damping per TrackballControls (usa staticMoving)
+ cameraControls.staticMoving = false;
+ cameraControls.dynamicDampingFactor = 0.2;
+
+ // Salva il metodo update originale per modificarlo
+ const originalUpdate = cameraControls.update.bind(cameraControls);
+
+ // Override del metodo update per bloccare la rotazione Z
+ cameraControls.update = function() {
+ // Chiama l'update originale
+ originalUpdate();
+
+ // Resetta la rotazione Z della camera mantenendola sempre a zero
+ const up = new THREE.Vector3(0, 1, 0);
+ const right = new THREE.Vector3();
+
+ // Calcola il vettore right come perpendicolare a forward e up
+ const forward = new THREE.Vector3();
+ forward.subVectors(this.target, camera.position).normalize();
+ right.crossVectors(forward, up).normalize();
+
+ // Ricalcola up come perpendicolare a forward e right per mantenere l'orientamento
+ up.crossVectors(right, forward).normalize();
+
+ // Imposta l'up della camera
+ camera.up.copy(up);
+ };
+
+ window.camera = camera;
+ window.cc = cameraControls;
+ // Update camera
+ camera.aspect = sizes.width / sizes.height
+ camera.updateProjectionMatrix()
+
+
+ // Update renderer
+ //renderer.setPixelRatio(sizes.width / sizes.height);
+ renderer.setSize(sizes.width, sizes.height, true)
+ doRender = true;
+
+ loop();
+}
+
+const textToMesh = async (text) => {
+ const loader = new FontLoader();
+ const font = await loader.loadAsync('assets/fonts/Agency_FB_Bold.json');
+
+ let geometry = new TextGeometry( text, {
+ font: font,
+ size: 80,
+ height: 5,
+ /*
+ curveSegments: 12,
+ bevelEnabled: true,
+ bevelThickness: 10,
+ bevelSize: 8,
+ bevelOffset: 0,
+ bevelSegments: 5*/
+ } );
+
+ geometry.center();
+ let material = new THREE.MeshBasicMaterial( { color: 0xFF0000 } );
+ let mesh = new THREE.Mesh( geometry, material );
+ mesh.position.z = 0;
+ mesh.position.y = 0;
+ mesh.position.x = 0;
+ //scene.add(mesh);
+ return mesh;
+
+
+}
+
+async function applyTextToMesh(mesh, text, font, size, color) {
+ // Crea un nuovo elemento canvas
+ const canvas = document.createElement('canvas');
+ const context = canvas.getContext('2d');
+
+ // Imposta il font e il colore del testo
+ context.font = `${size}px ${font}`;
+ context.fillStyle = color;
+
+ // Disegna il testo sul canvas
+ context.fillText(text, 0, size);
+
+ const loader = new THREE.TextureLoader();
+
+ // Carica la texture dall'immagine base64
+ const texture = await loader.loadAsync(canvas.toDataURL("image/jpeg"));
+
+
+ console.log(canvas.toDataURL("image/jpeg"))
+ // Crea una nuova texture dal canvas
+
+ console.log("asd",texture);
+ mesh.material.map = texture;
+ mesh.material.needsUpdate = true;
+ // Crea un nuovo materiale utilizzando la texture
+ //const material = new THREE.MeshBasicMaterial({ map: texture });
+
+ // Applica il materiale alla mesh
+ //mesh.material = material;
+ mesh.geometry.computeVertexNormals();
+
+}
+
+
+
+
+/**
+ * Loop
+ */
+const loop = () =>
+{
+ // TrackballControls.update() deve essere chiamato ad ogni frame
+ cameraControls.update();
+
+ // Render sempre per vedere gli aggiornamenti dei controlli
+ renderer.render( scene, camera );
+
+ if(doRender){
+ // Render aggiuntivo se richiesto da altre parti del codice
+ }
+
+ doRender = false;
+ window.requestAnimationFrame(loop)
+
+}
+
+export const cambiaColore = (objName, color) => {
+
+ let obj = scene.getObjectByName(objName);
+
+ if(obj == null) return;
+ obj.material.color = new THREE.Color(color);
+ obj.material.needsUpdate = true;
+ doRender = true;
+}
+
+export const toggleModel = (objName) => {
+ let obj = scene.getObjectByName(objName);
+ console.log(obj.material)
+ obj.material.transparent = !obj.material.transparent;
+ if(obj.material.transparent)obj.material.opacity = 0.1;
+
+ obj.material.needsUpdate = true;
+
+ doRender = true;
+}
+
+window.esporta = () => {
+ var output = scene.toJSON();
+ output = JSON.stringify( output, 1, '\t' );
+ output = output.replace( /[\n\t]+([\d\.e\-\[\]]+)/g, '$1' );
+ saveString(output, "scena.json");
+}
+
+
+function save( blob, filename ) {
+
+ var link = document.createElement( 'a' );
+ link.style.display = 'none';
+ document.body.appendChild( link );
+
+ link.href = URL.createObjectURL( blob );
+ link.download = filename;
+ link.click();
+
+ // URL.revokeObjectURL( url ); breaks Firefox...
+
+}
+
+function saveString( text, filename ) {
+
+ save( new Blob( [ text ], { type: 'text/plain' } ), filename );
+
+}
+
+
+
+const toggleMobileMenu = () => {
+ $(".navbar-collapse").removeClass('show');
+}
+
+window.rotateTo = (side) => {
+
+ toggleMobileMenu();
+
+ $('.pos-btn').removeClass('active');
+
+ // Calcola la posizione della camera in base alla vista richiesta
+ const distance = camera.position.distanceTo(cameraControls.target);
+ let newPosition = new THREE.Vector3();
+
+ switch ( side ) {
+
+ case 'front':
+ // Vista frontale: camera davanti all'oggetto
+ newPosition.set(0, 0, distance);
+ break;
+
+ case 'back':
+ // Vista posteriore: camera dietro all'oggetto
+ newPosition.set(0, 0, -distance);
+ break;
+
+ case 'up':
+ // Vista dall'alto: camera sopra l'oggetto
+ newPosition.set(0, distance, 0);
+ break;
+
+ case 'down':
+ // Vista dal basso: camera sotto l'oggetto
+ newPosition.set(0, -distance, 0);
+ break;
+
+ case 'right':
+ // Vista destra: camera a destra dell'oggetto
+ newPosition.set(distance, 0, 0);
+ break;
+
+ case 'left':
+ // Vista sinistra: camera a sinistra dell'oggetto
+ newPosition.set(-distance, 0, 0);
+ break;
+
+ }
+
+ // Anima la transizione con GSAP
+ if(window.gsap) {
+ gsap.to(camera.position, {
+ duration: 0.8,
+ x: newPosition.x,
+ y: newPosition.y,
+ z: newPosition.z,
+ onUpdate: () => {
+ camera.lookAt(cameraControls.target);
+ }
+ });
+ } else {
+ camera.position.copy(newPosition);
+ camera.lookAt(cameraControls.target);
+ }
+
+ $('.move-'+side).addClass('active');
+
+}
diff --git a/src/modules/scena-controller.js b/src/modules/scena-controller.js
index 0130de5..19219a7 100644
--- a/src/modules/scena-controller.js
+++ b/src/modules/scena-controller.js
@@ -206,8 +206,8 @@ export const addModelToScene = (obj, name, color, material_type) => {
let metalness = 0;
if(material_type == 'metal'){
- metalness = 0.9;
- roughness = 0.28;
+ metalness = 0.86 ;
+ roughness = 0.3;
}
const material = new THREE.MeshStandardMaterial({color: color, roughness: roughness, metalness: metalness}); //'#a0a0a0'
@@ -259,9 +259,9 @@ export const mostraArcata = async (model) => {
doRender = true;
}
else{
- let obj = await loadGLBModel("modello-"+model, './assets/glb/', '#ffffff');
+ let obj = await loadGLBModel("modello-"+model, './assets/glb/', '#efc971');
obj.userData = {"type":"arcata"};
- obj.material.roughness = 0.26;
+ obj.material.roughness = 0.40;
obj.material.metalness = 0;
if(debug == 'true'){
@@ -285,7 +285,7 @@ const randomColor = () => {
export const loadModels = async (config) => {
let activeObjs = [];
- console.log("Config:", config);
+ //console.log("Config:", config);
return new Promise(async (resolve, reject)=>{
for(let key in config){
@@ -294,7 +294,7 @@ export const loadModels = async (config) => {
if(el.field.data_type == 'model' && el.value != ""){
let obj = scene.getObjectByName(el.value);
el.colore = el.colore == null ? el.field.color: el.colore
- console.log("Loading model:", el.value, el.colore, el.field.material);
+ //console.log("Loading model:", el.value, el.colore, el.field.material);
if(obj != null)
activeObjs.push(obj);
else{
@@ -308,19 +308,22 @@ export const loadModels = async (config) => {
}
- if(el.field.accessory != null && el.field.accessory != ""){
- let acc = scene.getObjectByName(el.field.accessory);
- if(acc != null)
- activeObjs.push(acc);
- else{
- acc = await loadGLBModel(el.field.accessory, './assets/glb/', el.colore, el.field.material);
- if(acc != null)
+ if(el.field.other_models != null){
+ for(let om of el.field.other_models){
+ let acc = scene.getObjectByName(om.model);
+ if(acc != null)
activeObjs.push(acc);
- else{
- el.accessory_not_found = true;
- }
+ else{
+ acc = await loadGLBModel(om.model, './assets/glb/', om.color, om.material);
+ if(acc != null)
+ activeObjs.push(acc);
+ else{
+ el.accessory_not_found = true;
+ }
+ }
}
}
+
}
diff --git a/utils/converter.py b/utils/converter.py
index 08a51a6..402a49c 100644
--- a/utils/converter.py
+++ b/utils/converter.py
@@ -250,14 +250,14 @@ def stl_to_gltf(path_to_stl, out_path, is_binary):
print("Done! Exported to %s" %out_path)
def batch_conversion(binary_stl_path, out_path, is_binary):
- #print(os.listdir(binary_stl_path))
+
for f in os.listdir(binary_stl_path):
new_file_name = f.replace('.stl','.glb')
destination = out_path+'/'+new_file_name
source = binary_stl_path+'/'+f
- if source.endswith('.stl') and not source.startswith('.'):
+ if source.endswith('.stl') and not f.startswith('.'):
stl_to_gltf(source, destination, is_binary)
print('Convert: '+f+ ' ---> '+new_file_name)
@@ -267,8 +267,8 @@ if __name__ == '__main__':
import sys
if len(sys.argv) < 3:
- print("use it like python3 stl_to_gltf.py /path/to/stl /path/to/gltf/folder -b -batch")
- print("or python3 stl_to_gltf.py /path/to/stl /path/to/glb/file -b")
+ print("use it like python3 converter.py /path/to/stl /path/to/gltf/folder -b -batch")
+ print("or python3 converter.py /path/to/stl /path/to/glb/file -b")
sys.exit(1)
path_to_stl = sys.argv[1]