Try different semantic material

TODO: Use Map object to optimize node lookup

.gitignore

@@ -8,3 +8,5 @@
 
 vendor/
 .vscode
+
+docs/

config.js

@@ -16,8 +16,12 @@ const theater2Popup = `
 
 export const config = {
     scene : {
-        initialExposure: 0.7,
+        initialExposure: 0.95,
-        autoLP: true,
+        autoLP: false,
+        shadows: false,
+        initLightDir: [0.2,-0.3,-0.7],
+        initRotation: [0, 1.5, 0],
+        ambientOcclusion: false,
     },
     menu : {
         //audioBtn1
@@ -29,14 +33,12 @@ export const config = {
             uri : `${BASE_URI}/scenes/salvador/`,
             popup: theater1Popup,
             coords: [45.4363, 12.3352],
-            nodes: [
+            nodes: {
-                {
                     label: 'Teatro',
                     model: "teatro_san_salvador_20250926.gltf",
                     isMain: true,
                 },
-            ],
+            pano: `pano/gradient.jpg`,
-            pano: `pano/defsky-grass.jpg`,
         },
         {
             id : "ssgp",
@@ -44,89 +46,133 @@ export const config = {
             uri : `${BASE_URI}/scenes/ssgp/`,
             popup: theater2Popup,
             coords: [45.4401, 12.3408],
-            nodes: [
+            nodes: {
-                /*
+                label: 'Teatro',
-                {
+                children: [
-                    label: 'Struttura principale',
+                    /*
-                    model: 'models/ssgp/Teatro_SSGP_Full_ConSottrazioni.glb',
+                    {
-                    isMain: true,
+                        label: 'Struttura complessiva',
-                },
+                        model: 'models/ssgp/Teatro_SSGP_Full_ConSottrazioni.glb',
-                */
+                    },
-                {
+                    */
-                    label: 'Struttura parete di fondo',
+                    {
-                    model: 'models/ssgp/Teatro_SSGP_Layer_Struttura_parete_di_fondo.glb',
+                        label: 'Involucro',
-                    isMain: true,
+                        model: 'models/ssgp/Teatro_SSGP_Layer_Struttura_parete_di_fondo.glb',
-                },
+                        isMain: true,
-                {
+                        opacity: 0.2,
-                    label: 'Ballatoio',
+                    },
-                    model: 'models/ssgp/Teatro_SSGP_Ballatoio.glb',
+                    {
-                },
+                        label: 'Sala / Auditorium',
-                {
+                        color: 'rgb(212, 96, 75)',
-                    label: 'Boccascena',
+                        children: [
-                    model: 'models/ssgp/Teatro_SSGP_Boccascena.glb',
+                            {
-                },
+                                label: 'Peplano / Platea',
-                {
+                                model: 'models/ssgp/Teatro_SSGP_Platea_peplano.glb',
-                    label: 'Fossa orchestra',
+                            },
-                    model: 'models/ssgp/Teatro_SSGP_Fossa_orchestra.glb',
+                            {
-                },
+                                label: 'Ordini di palchi',
-                {
+                                children: [
-                    label: 'Graticcia',
+                                    {
-                    model: 'models/ssgp/Teatro_SSGP_Graticcia.glb',
+                                        label: 'Ordine 1',
-                },
+                                        model: 'models/ssgp/Teatro_SSGP_Ordine1.glb',
-                {
+                                    },
-                    label: 'Ordine 1',
+                                    {
-                    model: 'models/ssgp/Teatro_SSGP_Ordine1.glb',
+                                        label: 'Ordine 2',
-                },
+                                        model: 'models/ssgp/Teatro_SSGP_Ordine2.glb',
-                {
+                                    },
-                    label: 'Ordine 2',
+                                    {
-                    model: 'models/ssgp/Teatro_SSGP_Ordine2.glb',
+                                        label: 'Ordine 3',
-                },
+                                        model: 'models/ssgp/Teatro_SSGP_Ordine3.glb',
-                {
+                                    },
-                    label: 'Ordine 3',
+                                    {
-                    model: 'models/ssgp/Teatro_SSGP_Ordine3.glb',
+                                        label: 'Ordine 4',
-                },
+                                        model: 'models/ssgp/Teatro_SSGP_Ordine4.glb',
-                {
+                                    },
-                    label: 'Ordine 4',
+                                    {
-                    model: 'models/ssgp/Teatro_SSGP_Ordine4.glb',
+                                        label: 'Ordine 5',
-                },
+                                        model: 'models/ssgp/Teatro_SSGP_Ordine5.glb',
-                {
+                                    },
-                    label: 'Ordine 5',
+                                ]
-                    model: 'models/ssgp/Teatro_SSGP_Ordine5.glb',
+                            },
-                },
+                            {
-                {
+                                label: 'Parapetto',
-                    label: 'Palcoscenico',
+                                model: 'models/ssgp/Teatro_SSGP_parapetto_scala_piani.glb',
-                    model: 'models/ssgp/Teatro_SSGP_Palcoscenico.glb',
+                            },
-                },
+                            {
-                {
+                                label: 'Percorsi pubblico',
-                    label: 'Parapetto scala piani',
+                                model: 'models/ssgp/Teatro_SSGP_Percorsi_scale_corridoi.glb',
-                    model: 'models/ssgp/Teatro_SSGP_parapetto_scala_piani.glb',
+                            },
-                },
+                        ]
-                {
+                    },
-                    label: 'Percorsi scale corridoi',
+                    {
-                    model: 'models/ssgp/Teatro_SSGP_Percorsi_scale_corridoi.glb',
+                        label: 'Scena',
-                },
+                        color: 'rgb(75, 100, 212)',
-                {
+                        children: [
-                    label: 'Platea peplano',
+                            {
-                    model: 'models/ssgp/Teatro_SSGP_Platea_peplano.glb',
+                                label: 'Palcoscenico',
-                },
+                                model: 'models/ssgp/Teatro_SSGP_Palcoscenico.glb',
-                {
+                                isSemantic: true,
-                    label: 'Quinte architettoniche fisse',
+                                // TEMP
-                    model: 'models/ssgp/Teatro_SSGP_Layer_quinte_architettoniche_fisse.glb',
+                                content: {
-                },
+                                    type: 'img',
-                {
+                                    imgSrc: '/a/scaenae/assets/img/rilievo_ssgp_bezzi.webp',
-                    label: 'Quinte architettoniche mobili',
+                                    title: 'Disegno della pianta del teatro SS. Giovanni e Paolo',
-                    model: 'models/ssgp/Teatro_SSGP_Layer_quinte_architettoniche_mobili.glb',
+                                    description: `
-                },
+                                    Tommaso Bezzi: Disegno della pianta del teatro di SS. Giovanni e Paolo di Venezia, 1691-1693, Sir John Soane's Museum, Londra.
-                {
+                                    `
-                    label: 'Spazio tecnico superiore',
+                                }
-                    model: 'models/ssgp/Teatro_SSGP_Layer_Spazio_tecnico_sup_soffitta.glb',
+                            },
-                },
+                            {
-                {
+                                label: 'Boccascena / Proscenio',
-                    label: 'Spazio tecnico inferiore',
+                                model: 'models/ssgp/Teatro_SSGP_Boccascena.glb',
-                    model: 'models/ssgp/Teatro_SSGP_Spazio_tecnico_inf.glb',
+                            },
-                },
+                            {
-            ],
+                                label: 'Quinte architettoniche fisse',
-            pano: `pano/defsky-grass.jpg`,
+                                model: 'models/ssgp/Teatro_SSGP_Layer_quinte_architettoniche_fisse.glb',
+                            },
+                            {
+                                label: 'Quinte architettoniche mobili',
+                                model: 'models/ssgp/Teatro_SSGP_Layer_quinte_architettoniche_mobili.glb',
+                            },
+                        ]
+                    },
+                    {
+                        label: 'Spazi tecnici',
+                        color: 'rgb(42, 139, 75)',
+                        children: [
+                            {
+                                label: 'Spazio tecnico superiore',
+                                model: 'models/ssgp/Teatro_SSGP_Layer_Spazio_tecnico_sup_soffitta.glb',
+                                children: [
+                                    {
+                                        label: 'Graticcia',
+                                        model: 'models/ssgp/Teatro_SSGP_Graticcia.glb',
+                                    },
+                                    {
+                                        label: 'Ballatoio',
+                                        model: 'models/ssgp/Teatro_SSGP_Ballatoio.glb',
+                                    },
+                                ],
+                            },
+                            {
+                                label: 'Spazio tecnico inferiore',
+                                model: 'models/ssgp/Teatro_SSGP_Spazio_tecnico_inf.glb',
+                            },
+                        ]
+                    },
+                    {
+                        label: 'Orchestra',
+                        color: 'rgb(195, 153, 235)',
+                        children: [
+                            {
+                                label: 'Fossa orchestra',
+                                model: 'models/ssgp/Teatro_SSGP_Fossa_orchestra.glb',
+                            },
+                        ]
+                    }
+                ]
+            },
+            pano: `pano/gradient.jpg`,
         }
     ],
     map : {

css/app.css

@@ -1,26 +1,188 @@
+:root {
+    --toggle-background-color-on: #6da0ff;
+    --toggle-background-color-off: darkgray;
+    --toggle-width: 32px;
+    --toggle-height: 15px;
+    --toggle-gutter: 2px;
+    --toggle-radius: 50%;
+    --toggle-control-size: 40px;
+    --toggle-control-color: white;
+    --toggle-control-speed: .15s;
+    --toggle-control-ease: ease-in;
+
+    /** Don't change calculated values! **/
+    --toggle-radius: calc(var(--toggle-height) / 2);
+    --toggle-control-size: calc(var(--toggle-height) - (var(--toggle-gutter) * 2));
+}
+
 body {
     height: 100vh;
 }
-.c-hand {
+
-    cursor: pointer;
-}
 input[type="checkbox"] {
     cursor: pointer;
 }
+
+.c-hand {
+    cursor: pointer;
+}
+
+.w-max-content {
+    width: max-content;
+}
+
 #clipper-bar .btn {
     background-repeat: no-repeat;
     background-position: center;
     background-size: 80%;
 }
+
 #map {
     height: 100%;
 }
+
 #clipX {
     background-image: url('/a/scaenae/assets/icons/section_x.png');
 }
+
 #clipY {
     background-image: url('/a/scaenae/assets/icons/section_y.png');
 }
+
 #clipZ {
     background-image: url('/a/scaenae/assets/icons/section_z.png');
+}
+
+.tab-pane details > summary {
+    padding-left: 0;
+    list-style-position: outside;
+}
+/* Tooltips from https://codepen.io/pure-css/pen/bddggP */
+span:after {
+   text-align: left;
+   white-space: normal;
+}
+
+span:focus {
+   outline: none;
+}
+
+.app-tooltip {
+    cursor: help;
+    position: relative;
+}
+
+/*== common styles for both parts of app-tooltip tip ==*/
+.app-tooltip::before,
+.app-tooltip::after {
+    left: 50%;
+    opacity: 0;
+    position: absolute;
+    z-index: -100;
+}
+
+.app-tooltip:hover::before,
+.app-tooltip:focus::before,
+.app-tooltip:hover::after,
+.app-tooltip:focus::after {
+    opacity: 1;
+    transform: scale(1) translateY(0);
+    z-index: 100; 
+}
+
+/*== pointer tip ==*/
+.app-tooltip::before {
+    border-style: solid;
+    border-width: 1em 0.75em 0 0.75em;
+    border-color: #3E474F transparent transparent transparent;
+    bottom: 100%;
+    content: "";
+    margin-left: -0.5em;
+    transition: all .65s cubic-bezier(.84,-0.18,.31,1.26), opacity .65s .5s;
+    transform:  scale(.6) translateY(-90%);
+} 
+
+.app-tooltip:hover::before,
+.app-tooltip:focus::before {
+    transition: all .65s cubic-bezier(.84,-0.18,.31,1.26) .2s;
+}
+
+/*== speech bubble ==*/
+.app-tooltip::after {
+    background: #3E474F;
+    border-radius: .25em;
+    bottom: 180%;
+    color: #EDEFF0;
+    content: attr(data-tip);
+    margin-left: -4.75em;
+    padding: 1em;
+    transition: all .65s cubic-bezier(.84,-0.18,.31,1.26) .2s;
+    transform:  scale(.6) translateY(50%);  
+    width: 17.5em;
+}
+
+.app-tooltip:hover::after,
+.app-tooltip:focus::after  {
+    transition: all .65s cubic-bezier(.84,-0.18,.31,1.26);
+}
+
+@media (max-width: 760px) {
+  .app-tooltip::after { 
+        font-size: .75em;
+        margin-left: -5em;
+        width: 10em; 
+  }
+}
+/**
+* Toggle switch styles
+* From: https://codepen.io/AriTheElk/pen/YmxYZr
+*/
+.toggle-control {
+  display: block;
+  position: relative;
+  padding-left: var(--toggle-width);
+  margin-bottom: 12px;
+  cursor: pointer;
+  font-size: 18px;
+  user-select: none;
+  color: #fff;
+
+  input {
+    position: absolute;
+    opacity: 0;
+    cursor: pointer;
+    height: 0;
+    width: 0;
+  }
+
+  input:checked ~ .control {
+    background-color: var(--toggle-background-color-on);
+    
+    &:after {
+      left: calc(var(--toggle-width) - var(--toggle-control-size) - var(--toggle-gutter));
+    }
+  }
+
+  .control {
+    position: absolute;
+    top: 25%;
+    left: 0;
+    height: var(--toggle-height);
+    width: var(--toggle-width);
+    border-radius: var(--toggle-radius);
+    background-color: var(--toggle-background-color-off);
+    transition: background-color var(--toggle-control-speed) var(--toggle-control-ease);
+
+    &:after {
+      content: "";
+      position: absolute;
+      left: var(--toggle-gutter);
+      top: var(--toggle-gutter);
+      width: var(--toggle-control-size);
+      height: var(--toggle-control-size);
+      border-radius: var(--toggle-radius);
+      background: var(--toggle-control-color);
+      transition: left var(--toggle-control-speed) var(--toggle-control-ease);
+    }
+  }
 }

js/controllers/clipper_controller.js

@@ -0,0 +1,74 @@
+// Global ATON
+import { Controller } from "@hotwired/stimulus"
+import AppState from "../state.js";
+import { addClippingPlane, resetClipping } from "../utils/clipping.js";
+import { toggleAmbientOcclusion } from "../utils/environment.js";
+
+/**
+ * Handle events for the clipper toolbar,
+ * related to the clipping module
+ */
+export default class extends Controller {
+    static targets = ['trigger', 'clipper', 'axis'];
+    static values = { enabled: Boolean };
+
+    connect() {
+        console.log('#clipper controller connected');
+    }
+
+    clip(event) {
+        /**
+         * @type {string}
+         */
+        const label = event.params.axis;
+        /**
+         * @type {HTMLButtonElement}
+         */
+        const target = event.target;
+        /**
+         * @type {NodeListOf<HTMLButtonElement>}
+         */
+        const axes = this.axisTargets;
+        const classes = ['border', 'border-2', 'border-warning'];
+
+        addClippingPlane(label, -1);
+        target.classList.add(...classes);
+
+        for (const btn of axes) {
+            if (btn.id !== target.id) {
+                btn.classList.remove(...classes);
+            }
+        }
+    }
+    /**
+     * Toggle clipper toolbar
+     */
+    toggleClipper() {
+        /**
+         * @type {HTMLElement}
+         */
+        const trigger = this.triggerTarget;
+        this.clipperTarget.classList.toggle('d-none');
+        // If the toolbar is shown, clipping is enabled and vice versa
+        this.enabledValue = !this.clipperTarget.classList.contains('d-none');
+
+        this.axisTargets.forEach(btn => {
+            btn.classList.remove('border', 'border-2', 'border-warning');
+        });
+
+        if (this.enabledValue) {
+            // AO should be turned off if clipping is enabled
+            toggleAmbientOcclusion(false);
+            trigger.className += ' border border-2 border-white';
+        }
+
+        if (!this.enabledValue) {
+            resetClipping();
+            trigger.className = trigger.className.replace(/ border.*$/g, '');
+            toggleAmbientOcclusion(AppState.ambientOcclusion);
+        }
+
+        AppState.clipping.enabled = this.enabledValue;
+    }
+}
+

js/controllers/menu_controller.js

@@ -0,0 +1,252 @@
+// Global ATON
+import { Controller } from "@hotwired/stimulus";
+import AppState from "../state.js";
+import { traverseOntology } from "../ontology.js";
+
+const html = String.raw;
+const domParser = new DOMParser;
+// TODO: hard-coded, but follows a convention...
+const ontologyJsonPath = location.pathname + 'ontology.json';
+
+export default class extends Controller {
+    static targets = ['trigger', 'layers', 'ontology'];
+
+    connect() {
+        console.log('#menu controller connected');
+    }
+    /**
+     * Open settings panel
+     */
+    async toggleMenu() {
+        ATON.UI.setSidePanelRight();
+        ATON.UI.showSidePanel({header: 'Menu'});
+        this.#buildMenuPanel(ATON.UI.elSidePanel);
+        this.#buildLayersMenu(AppState.treeNodes, this.layersTarget);
+        this.#buildOntologyMenu(await traverseOntology(ontologyJsonPath), this.ontologyTarget);
+    }
+    /**
+     * @param {Event} event 
+     */
+    toggleNode(event) {
+
+        console.debug(AppState.treeNodes);
+
+        /**
+         * The node's id
+         * @type {string}
+         */
+        const id = event?.params.node;
+        const status = event?.target?.checked;
+        const node = AppState.normalizedNodes.find(n => n.id === id);
+        /**
+         * @type {HTMLElement|null}
+         */
+        const eye = event.target.parentElement.querySelector('i');
+
+        if (eye) {
+            eye.classList.toggle('bi-eye');
+            eye.classList.toggle('bi-eye-slash');
+        }
+
+        if (node.children.length > 0) {
+            this.#toggleGroup(node, status);
+            this.#syncGroupCheckboxes(node, status, this.layersTarget);
+        } else {
+            ATON.getSceneNode(id).toggle(status);
+            node.active = status;
+        }
+    }
+    /**
+     * Recursively toggle children in a nodes group
+     * @param {Object} groupNode
+     * @param {Boolean} status
+     */
+    #toggleGroup(groupNode, status) {
+        for (const child of groupNode.children) {
+            child.active = status;
+            if (child.model) {
+                ATON.getSceneNode(child.id).toggle(status);
+            }
+            if (child.children.length > 0) {
+                this.#toggleGroup(child, status);
+            }
+        }
+    }
+    /**
+     * Toggles checkboxes in a group based on status
+     * @param {Object} groupNode
+     * @param {Boolean} status
+     * @param {HTMLElement} container
+     */
+    #syncGroupCheckboxes(groupNode, status, container) {
+        for (const child of groupNode.children) {
+            const checkbox = container.querySelector(
+                `[data-menu-node-param="${child.id}"]`
+            );
+
+            if (checkbox) checkbox.checked = status;
+            
+            if (child.children.length > 0) {
+                this.#syncGroupCheckboxes(child, status, container);
+            }
+        }
+    }
+    /**
+     * Clone a <template> by id
+     * @param {String} id
+     * @returns {DocumentFragment}
+     */
+    #cloneTemplate(id) {
+        return document.getElementById(id)?.content?.cloneNode(true);
+    }
+    /**
+     * Create the left-side settings panel
+     * content
+     * @param {Element} panel 
+     */
+    #buildMenuPanel(panel) {
+        const fragment = this.#cloneTemplate('tmpl-menu-tabs');
+
+        panel.appendChild(fragment);
+    }
+    /**
+     * @todo Don't rebuild it every time, use caching, return a container with checkboxes
+     * @param {Array<import("../state.js").NormalizedSceneNode>} tree The normalized scene nodes tree
+     * @param {HTMLElement} tab Tab content element
+     */
+    #buildLayersMenu(tree, tab) {
+        const heading = document.createElement('h1');
+        heading.classList.add('fs-5', 'fw-bold', 'ms-0');
+        heading.textContent = 'Teatro'; // Hard-coded!!
+
+        tab.appendChild(heading);
+
+        for (const node of tree) {
+            tab.appendChild(
+                node.children.length > 0
+                    ? this.#createLayerGroup(node)
+                    : this.#createLayerToggle(node)
+            );
+        }
+    }
+    /**
+     * @param {import("../state.js").NormalizedSceneNode} node 
+     * @param {boolean} isGroup
+     * @returns {HTMLDivElement}
+     */
+    #createLayerToggle(node, isGroup = false) {
+        // This should be calculated somehow!
+        const labelIndent = node.depth < 3 ? '1.5rem' : '1rem';
+        const labelText = isGroup ? '<i class="bi bi-eye"></i>' : node.id;
+        const toggle = html`
+            <label class="toggle-control ms-${node.depth} ps-${node.depth} mt-1 mb-1">
+                <input id="${node.id}" type="checkbox" ${node.active ? 'checked' : ''} role="switch"
+                    data-menu-node-param="${node.id}"
+                    data-action="change->menu#toggleNode">
+                <span class="control"></span>
+                <span class="ps-2 fs-6" title="Mostra / nascondi ${isGroup ? 'gruppo' : 'layer'}" style="margin-left: ${labelIndent}">
+                    ${labelText}
+                </span>
+            </label>
+        `;
+
+        return domParser.parseFromString(toggle, 'text/html').querySelector('label');
+    }
+    /**
+     * @param {import("../state.js").NormalizedSceneNode} node 
+     * @returns {HTMLDetailsElement}
+     */
+    #createLayerGroup(node) {
+        const { trigger, collapseDiv } = this.#createNodeCollapse(node);
+        const wrapper = document.createElement('div');
+        wrapper.classList.add('w-max-content', 'ps-1', 'mb-1');
+            
+        collapseDiv.appendChild(this.#createLayerToggle(node, true));
+
+        for (const child of node.children) {
+            collapseDiv.appendChild(
+                child.children.length > 0
+                    ? this.#createLayerGroup(child)
+                    : this.#createLayerToggle(child)
+            );
+        }
+
+        wrapper.appendChild(trigger);
+        wrapper.appendChild(collapseDiv);
+        wrapper.classList.add('border-start', 'border-bottom', 'rounded', `ms-${node.depth}`);
+
+        return wrapper;
+    }
+    /**
+     * 
+     * @param {import("../state.js").NormalizedSceneNode} node 
+     * @returns {{trigger: HTMLButtonElement, collapseDiv: HTMLDivElement}}
+     */
+    #createNodeCollapse(node) {
+        const cleanId = node.id.replace(/[\s\/\-]+/g, '');
+        const trigger = document.createElement('button');
+        trigger.className = 'btn btn-link p-0 fs-6 fw-bold text-decoration-none text-reset';
+        trigger.setAttribute('data-bs-toggle', 'collapse');
+        trigger.setAttribute('data-bs-target', `#group-${cleanId}`);
+        trigger.setAttribute('data-action', 'menu#toggleChevron');
+        trigger.innerHTML = html`
+            <i class="bi bi-chevron-down me-1"></i>${node.id}
+        `;
+        // Add color "swatch" only for first level groups
+        /*
+        if (node.depth === 2) {
+            trigger.innerHTML += html`
+                <div class="d-inline-block border rounded ms-2"
+                    style="background-color: ${node.color}; height: 15px; width:15px">
+                </div>
+            `;
+        }
+        */
+
+        const collapseDiv = document.createElement('div');
+        collapseDiv.className = 'collapse';
+        collapseDiv.id = `group-${cleanId}`;
+
+        return {trigger, collapseDiv};
+    }
+    /**
+     * 
+     * @param {Event} event 
+     */
+    toggleChevron(event) {
+        /**
+         * @type {HTMLButtonElement} collapse
+         */
+        const collapse = event.target;
+        const icon = collapse.querySelector('i');
+        icon.classList.toggle('bi-chevron-down');
+        icon.classList.toggle('bi-chevron-up');
+    }
+    /**
+     * Temporary implementation to show domains only
+     * @todo Don't rebuild it every time, use caching, return a container
+     * @param {Object} ontology The traversed ontology object (temp)
+     * @param {HTMLElement} tab Tab content element
+     */
+    #buildOntologyMenu(ontology, tab) {
+        console.debug(ontology);
+
+        const mainNode = tab.querySelector('#ontology-list');
+        mainNode.textContent = ontology.ontology;
+
+        let domainList = html`
+            <ul class="list-group mt-2" id="domains-list"></ul>
+        `;
+
+        // Very fragile and ugly!!
+        mainNode.innerHTML += domainList;
+        domainList = tab.querySelector('#domains-list');
+        
+        for(let domain of ontology.domains) {
+            const domainItem = html`
+                <li class="list-group-item">${domain.label}</li>
+            `;
+            domainList.innerHTML += domainItem;
+        }
+    }
+}

js/controllers/modal_controller.js

@@ -0,0 +1,39 @@
+
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+    static targets = ['modal'];
+
+    connect() {
+        console.log('#modal controller connected');
+    }
+    /**
+     * 
+     * @param {Event} event 
+     */
+    showSemanticModal(event) {
+        const modal = this.modalTarget;
+        const title = modal.querySelector('.modal-title');
+        // Clear any existing content first
+        title.innerHTML = '';
+        title.innerHTML = event.content?.title;
+        const body = modal.querySelector('.modal-body');
+        body.innerHTML = '';
+        const contentType = event.content?.type;
+
+        const content = document.createElement(contentType);
+        if (contentType === 'img') {
+            content.src = event.content?.imgSrc;
+            content.classList.add('img-fluid');
+        }
+
+        const description = document.createElement('p');
+        description.textContent = event.content?.description;
+        description.classList.add('py-3', 'my-2', 'fst-italic');
+
+        body.appendChild(content);
+        body.appendChild(description);
+
+        bootstrap.Modal.getOrCreateInstance(modal).show();
+    }
+}

js/controllers/settings_controller.js

@@ -0,0 +1,28 @@
+import { Controller } from "@hotwired/stimulus"
+import AppState from "../state.js";
+
+export default class extends Controller {
+    static targets = ['ao', 'shadows'];
+
+    connect() {
+        console.log('#settings controller connected');
+        this.aoTarget.checked = AppState.ambientOcclusion;
+        this.shadowsTarget.checked = AppState.shadows;
+    }
+    /**
+     * Toggle Ambient Occlusion
+     * @param {Event} event 
+     */
+    toggleAO(event) {
+        ATON.FX.togglePass(ATON.FX.PASS_AO, event.target.checked);
+        AppState.ambientOcclusion = event.target.checked;
+    }
+    /**
+     * Toggle shadows
+     * @param {Event} event 
+     */
+    toggleShadows(event) {
+        ATON.toggleShadows(event.target.checked);
+        AppState.shadows = event.target.checked;
+    }
+}

js/controllers/tabs_controller.js

@@ -0,0 +1,42 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+    static targets = ['active', 'tab', 'content'];
+
+    connect() {
+        console.log('#tabs controller connected');
+    }
+    /**
+     * 
+     * @param {Event} event 
+     */
+    activate(event) {
+        event.preventDefault();
+        this.deactivate();
+        const activeId = event.currentTarget.dataset.id;
+
+        event.currentTarget.parentElement.classList.add('active');
+        this.contentTargets.find(c => c.dataset.id === activeId)
+            .classList.remove('d-hide');
+    }
+
+    reset() {
+        this.deactivate();
+        const activeId = this.activeTarget.dataset.id;
+
+        this.activeTarget.classList.add('active');
+        this.contentTargets.find(c => c.dataset.id === activeId)
+            .classList.remove('d-hide');
+    }
+
+    deactivate() {
+        this.tabTargets.forEach(tab => {
+            tab.classList.remove('active');
+        });
+
+        this.contentTargets.forEach(content => {
+            content.classList.add('d-hide');
+        });
+    }
+}
+

js/controllers/toolbar_controller.js

@@ -0,0 +1,53 @@
+// Global ATON
+import { Controller } from "@hotwired/stimulus"
+import AppState from "../state.js";
+import { createExposureSlider, createLightSlider } from "../utils/environment.js";
+
+const html = String.raw;
+const panelHeader = html`
+    <i class="bi bi-gear-fill me-1"></i> Impostazioni
+`;
+
+export default class extends Controller {
+    static targets = ['settings'];
+
+    connect() {
+        console.log('#toolbar controller connected');
+    }
+    /**
+     * Open settings panel
+     * @param {Event} event 
+     */
+    toggleSettings(event) {
+        ATON.UI.setSidePanelLeft();
+        ATON.UI.showSidePanel({header: panelHeader});
+        this.#buildSettingsPanel(ATON.UI.elSidePanel);
+    }
+    /**
+     * Clone a <template> by id
+     * @param {String} id
+     * @returns {DocumentFragment}
+     */
+    #cloneTemplate(id) {
+        return document.getElementById(id).content.cloneNode(true);
+    }
+    /**
+     * Create the left-side settings panel
+     * content
+     * @param {Element} panel 
+     */
+    #buildSettingsPanel(panel) {
+        const fragment = this.#cloneTemplate('tmpl-settings');
+        let sliderContainer = fragment.querySelector('[data-sliders-container]');
+        let exposureContainer = fragment.querySelector('[data-slider-exposure-container]'); 
+
+        ['x', 'y', 'z'].forEach((axis, i) => {
+            const label = ['Asse X', 'Asse Y', 'Asse Z'][i];
+            sliderContainer.appendChild(createLightSlider(axis, label, [-2, 2], 0.1));
+        })
+
+        exposureContainer.appendChild(createExposureSlider('Valore', [0, 5]));
+
+        panel.appendChild(fragment);
+    }
+}

js/ontology.js

@@ -0,0 +1,43 @@
+/**
+ * @module Ontology
+ */
+
+/**
+ * @todo Temporarily returns domains and ontology labels only
+ * Traverse an ontology from its JSON description
+ * @param {String} jsonPath The path (URI) of the ontology JSON file
+ * @returns {Object}
+ */
+export async function traverseOntology(jsonPath) {
+    const ontology = await loadOntology(jsonPath);
+    const domains = [];
+
+    for (const k of Object.keys(ontology)) {
+        if (k === 'domains') {
+            for (const domainKey of Object.keys(ontology[k])) {
+                domains.push({
+                    label: domainKey,
+                    child: ontology[k][domainKey][0].label,
+                });
+            }
+        }
+    }
+
+    return {
+        ontology: ontology.ontology,
+        domains
+    };
+}
+
+/**
+ * Load an ontology from its JSON description
+ * @param {String} jsonPath The path (URI) of the ontology JSON file
+ * @returns {Object}
+ */
+export async function loadOntology(jsonPath) {
+    const ontology = await fetch(jsonPath)
+        .then(res => res.json())
+        .catch(err => console.error(err));
+
+    return ontology;
+}

js/scene.js

@@ -2,17 +2,17 @@
 
 import AppState from "./state.js";
 import { config } from "../config.js";
-import UI from "./ui.js";
+import { toggleAmbientOcclusion } from "./utils/environment.js";
 
-const Scene = {};
+/**
-
+ * @module Scene
-Scene.UI = UI;
+ */
 
 /**
  * @todo Experimental...
  * @param {THREE.Object3D} object - A THREE Object3D instance
  */
-Scene.showEdges = function(object) {
+function showEdges (object) {
     const edgeMaterial = new THREE.LineBasicMaterial( { color: 0x000000 } );
 
     object.traverse(function(child) {
@@ -27,240 +27,78 @@ Scene.showEdges = function(object) {
     });
 }
 
-/**
+function init () {
- * Calculate bounding box for the scene root object
- * and return it along with its center and size (bad?).
- * It only uses meshes to prevent "empty" nodes in the scene
- * from being included in the calculation.
- * @todo Use ATON.Node.getBound()? [bounding sphere]
- */
-Scene.getRootBoundingBox = function() {
-    const meshes = [];
-    AppState.root.traverse(obj => {
-        if (obj.isMesh) meshes.push(obj);
-    });
-
-    if (meshes.length === 0) return null;
-
-    const bbox = new THREE.Box3().setFromObject(meshes[0]);
-    for (let i = 1; i < meshes.length; i++) {
-        bbox.union(new THREE.Box3().setFromObject(meshes[i]));
-    }
-
-    const center = bbox.getCenter(new THREE.Vector3());
-    const size = bbox.getSize(new THREE.Vector3());
-
-    return { bbox, center, size };
-}
-
-/**
- * 
- * @param {THREE.Sphere} boundingSphere - The bounding sphere for the main node
- * @returns {THREE.Mesh}
- */
-Scene.createClippingPlaneMesh = function (boundingSphere) {
-    const planeSize = boundingSphere.radius * 1.5;
-    const mesh = new THREE.Mesh(
-        new THREE.PlaneGeometry(planeSize, planeSize),
-        new THREE.MeshBasicMaterial({ color: 0xffff00, opacity: 0.1, side: THREE.DoubleSide, transparent: true })
-    );
-
-    return mesh;
-}
-
-/**
- * 
- * @param {THREE.Mesh} planeMesh 
- * @param {THREE.ArrowHelper} arrowHelper 
- * @param {String} axis 
- */
-Scene.dragClipper = function(planeMesh, axis) {
-    const controls = new THREE.DragControls(
-        [planeMesh],
-        ATON.Nav._camera,
-        ATON._renderer.domElement,
-    ); 
-
-    const startPosition = new THREE.Vector3();
-    // Only move along the selected axis (exlude the others)
-    const excludedAxes = ['x', 'y', 'z'].filter(a => a != axis);
-
-    if (AppState.clipping.enabled && AppState.clipping.vector) {
-        controls.addEventListener('dragstart', function (event) {
-            startPosition.copy(event.object.position);
-            ATON.Nav.setUserControl(false);
-        });
-
-        controls.addEventListener('drag', function(event) {
-            const point = event.object.position;
-            Scene.updateClipper(AppState.clipping.vector, point);
-            for (const a of excludedAxes) {
-                event.object.position[a] = startPosition[a];
-            }
-        });
-
-        controls.addEventListener('dragend', function (event) {
-            ATON.Nav.setUserControl(true);
-        });
-
-        AppState.clipping.controls = controls;
-    }
-}
-
-/**
- * @param {String} axis - The axis along which the plane's normal should be directed,
- *                        one of 'x', 'y', 'z'
- * @param {Number} orientation - Positive (1) or negative (-1) orientation on the axis
- */
-Scene.addClippingPlane = function(axis, orientation = -1) {
-    axis = axis.toLowerCase();
-    const bound = AppState.clipping.boundingSphere;
-
-    if (!bound) return;
-
-    const vector = [
-        axis === 'x' ? orientation : 0,
-        axis === 'y' ? orientation : 0,
-        axis === 'z' ? orientation : 0,
-    ];
-
-    AppState.clipping.vector = vector;
-
-    // First, add a default clipping plane
-    // at a default point (calculated...)
-    const defaultPoint = bound.center.clone();
-    Scene.activateClipper(vector, axis, defaultPoint);
-}
-
-/**
- * @todo WIP!
- * Activate clipping plane
- * @param {Number[]} vector - The vector array to direct the plane
- * @param {String} axis - The x,y,z axis
- * @param {?THREE.Vector3} point - The queried scene point
- */
-Scene.activateClipper = function(vector, axis, point = null) {
-    ATON.enableClipPlanes();
-    Scene.updateClipper(vector, point);
-    Scene.dragClipper(AppState.clipping.helper, axis);
-}
-
-/**
- * 
- * @param {THREE.Vector3} vector 
- * @param {THREE.Vector3} point 
- */
-Scene.updateClipper = function(vector, point) {
-    // Useless guard...
-    if (vector) {
-        // Normal of the clipping plane along the axis facing down
-        const normal = new THREE.Vector3(...vector).normalize();
-        const plane = AppState.clipping.plane ?? ATON.addClipPlane(normal, point);
-        // Add a visible plane helper for the clipping plane
-        const visiblePlane = AppState.clipping.helper ?? Scene.createClippingPlaneMesh(AppState.clipping.boundingSphere);
-
-        if (!AppState.clipping.helper) {
-            AppState.root.add(visiblePlane);
-            AppState.clipping.helper = visiblePlane;
-        } 
-
-        visiblePlane.position.copy(point);
-        visiblePlane.lookAt(point.clone().add(normal));
-
-        plane.setFromNormalAndCoplanarPoint(normal, point);
-        AppState.clipping.plane = plane;
-    }
-}
-
-/**
- * 
- * @param {THREE.Vector3} vector - An object with x,y,z coordinates
- */
-Scene.changeLightDirection = function(vector) {
-    ATON.setMainLightDirection(vector);
-}
-
-/**
- * 
- * @param {Boolean} isEnabled 
- */
-Scene.toggleAmbientOcclusion = function(isEnabled) {
-    ATON.FX.togglePass(ATON.FX.PASS_AO, isEnabled);
-    console.log('Ambient occlusion', isEnabled ? 'ON' : 'OFF');
-}
-
-Scene.init = function() {
     ATON.realize();
     ATON.UI.addBasicEvents();
     ATON.UI.init();
     // All assets for this app are stored here
     ATON.setPathCollection('/a/scaenae/assets/');
     // Initial light direction
-    ATON.setMainLightDirection(new THREE.Vector3(0.2,-0.3,-0.7));
+    ATON.setMainLightDirection(new THREE.Vector3(...config.scene.initLightDir));
-    ATON.toggleShadows(true);
+    ATON.toggleShadows(config.scene.shadows);
     ATON.setExposure(config.scene.initialExposure);
-    // Open settings side panel when clicking on settings btn
-    Scene.UI.toggleSettingsPanel('settings');
-    Scene.UI.toggleContentMenu('menu');
 
     AppState.camera = ATON.Nav._camera;
     AppState.renderer = ATON._renderer;
+    AppState.shadows = config.scene.shadows;
+    AppState.lightDirection = ATON.getMainLightDirection();
+    AppState.exposure = config.scene.initialExposure;
 
     ATON.Nav.setUserControl(true);
-}
+    // Avoid semantic occlusion
-/**
+    ATON._bQuerySemOcclusion = false;
- * Reset clipping state after disabling from UI
- * @todo DragControls errors!!
- */
-Scene.resetClipping = function () {
-    AppState.clipping.enabled = false;
-    ATON.disableClipPlanes();
-    AppState.clipping.controls.deactivate();
-    // Manually remove event listeners from DragControls!!
-    AppState.renderer.domElement.removeEventListener( 'pointermove', AppState.clipping.controls.onPointerMove );
-    AppState.renderer.domElement.removeEventListener( 'pointerdown', AppState.clipping.controls.onPointerDown );
-    AppState.renderer.domElement.removeEventListener( 'pointerup', AppState.clipping.controls.onPointerCancel );
-    AppState.renderer.domElement.removeEventListener( 'pointerleave', AppState.clipping.controls.onPointerCancel )
-    AppState.clipping.controls = null;
-    AppState.clipping.helper.removeFromParent();
-    AppState.root.remove(AppState.clipping.helper);
-    AppState.clipping.helper = null;
-    AppState.clipping.plane = null;
-    AppState.clipping.vector = null;
-    // Ensure nav controls are reactivated!
-    ATON.Nav.setUserControl(true);
 }
 /**
  * @param {Object} marker - The marker object from config
+ * @param {Object[]} nodes - The flat list of nodes for this scene
  */
-Scene.openScene = function(marker) {
+export function openScene (marker, nodes) {
-    Scene.init();
+    init();
-    Scene.UI.toggleClipperBar('#clipper', '#clipper-bar');
+    // Filter nodes with models first
-
+    nodes = nodes.filter(n => n.model);
     // Load 3D models and create nodes
-    Scene.loadNodes(marker.nodes);
+    loadNodes(nodes);
 
     ATON.setMainPanorama(marker.pano);
     // TODO: hardcoded...
-    AppState.initialRotation = new THREE.Vector3(0, 1.5, 0);
+    AppState.initialRotation = new THREE.Vector3(...config.scene.initRotation);
-    //Scene.showEdges(mainNode);
 
     ATON.setAutoLP(config.scene.autoLP);
     AppState.lightProbe = config.scene.autoLP;
-    Scene.toggleAmbientOcclusion(true);
+    toggleAmbientOcclusion(config.scene.ambientOcclusion);
-    AppState.ambientOcclusion = true;
+    AppState.ambientOcclusion = config.scene.ambientOcclusion;
     AppState.root = ATON.getRootScene();
 }
 
 /**
  * 
- * @param {Array} nodes 
+ * @param {Object[]} nodes 
  */
-Scene.loadNodes = function (nodes) {
+function loadNodes(nodes) {
     nodes.forEach(n => {
         let node = ATON.createSceneNode(n.label);
         node.load(n.model);
-        node.setRotation(0, 1.5, 0);
+        node.setRotation(...config.scene.initRotation);
+
+        /*
+        node.setMaterial(new THREE.MeshPhongMaterial({
+            transparent: false,
+            color: n.color ?? '#fff',
+        }));
+        */
+
+        // Apply any transparency before attaching to scene
+        if (n.opacity !== undefined && n.opacity !== null) {
+            node.setMaterial(new THREE.MeshPhongMaterial({
+                transparent: true,
+                opacity: n.opacity,
+                color: '#fff'
+            }));
+        }
+
+        // Disable a node for picking (shadows, light probe etc.)
+        if (n.isInvisible) node.hide();
+
         node.attachToRoot();
 
         if (n.isMain) {
@@ -269,8 +107,45 @@ Scene.loadNodes = function (nodes) {
             AppState.clipping.boundingSphere = node.getBound();
         }
 
-        AppState.nodes.push({id: n.label, active: true});
+        if (n.isSemantic) {
-    });
+            createSemanticNode(n.model, n.label);
-}
+            AppState.semanticNodes.set(n.label, n.content);
+            //ATON.getSemanticRoot().attach(semNode);
+        }
 
-export default Scene;
+        AppState.nodes.push({
+            id: n.label,
+            active: n.isInvisible ? false: true,
+            isSemantic: n.isSemantic
+        });
+    });
+    
+    if (!AppState.clipping.boundingSphere) {
+        console.error("No bounding sphere computed, clipping will fail. Ensure one node has 'isMain: true'.");
+    }
+}
+/**
+ * Creates a semantic annotation from a model
+ * @param {string} model The model's path to load
+ * @param {string} id The original scene node ID (3D object)
+ * @returns {ATON.SceneNode}
+ */
+function createSemanticNode(model, id) {
+    // Default/highlight materials for semantic node
+    let matSemDef = new THREE.MeshPhongMaterial({
+        color: '#ecee66',
+        transparent: true,
+        opacity: 0.3,
+    });
+    let matSemHL  = ATON.MatHub.materials.semanticShapeHL;
+
+    const semNode = ATON.createSemanticNode(id)
+        .setCloneOnLoadHit(false)
+        .load(model)
+        .setDefaultAndHighlightMaterials(matSemDef, matSemHL)
+        .attachToRoot();
+    
+    semNode.setRotation(...config.scene.initRotation);
+
+    return semNode;
+}

js/state.js

@@ -1,6 +1,17 @@
 /**
  * @namespace AppState
  */
+
+/**
+ * @typedef {Object} NormalizedSceneNode
+ * @property {String} label Required
+ * @property {String} id
+ * @property {String} model
+ * @property {Boolean} isMain
+ * @property {Number|null} opacity
+ * @property {Boolean} active
+ */
+
 let AppState = {
     // The Leaflet map object
     map : null,
@@ -8,11 +19,22 @@ let AppState = {
     root: null,
     // {id: String, active: Boolean}
     nodes: [],
+    /**
+     * @type {NormalizedSceneNode[]} normalizedNodes
+     */
+    normalizedNodes: [],
+    treeNodes: {},
+    semanticNodes: new Map,
     mainNodeId: null,
     currentScene: null,
     sceneHasAudio: false,
     layersMenuBuilt: false,
     initialRotation: null,
+    lightDirection: [],
+    /**
+     * @type {Number}
+     */
+    exposure: null,
     camera: null,
     renderer: null,
     ambientOcclusion : true,

js/ui.js

@@ -1,297 +0,0 @@
-import { config } from "../config.js";
-import Scene from "./scene.js";
-import AppState from "./state.js";
-/**
- * @namespace UI
- */
-const UI = {};
-
-UI.domParser = new DOMParser;
-
-UI.contentMenuTabs = `
-<!-- Nav tabs -->
-    <ul class="nav nav-pills" id="content-tabs" role="tablist">
-        <li class="nav-item" role="presentation">
-            <button class="nav-link active" id="media-tab" data-bs-toggle="tab" data-bs-target="#media" type="button" role="tab" aria-controls="media" aria-selected="true">
-                <i class="bi bi-music-note-list me-1"></i> Media
-            </button>
-        </li>
-        <li class="nav-item" role="presentation">
-            <button class="nav-link" id="layer-tab" data-bs-toggle="tab" data-bs-target="#layer" type="button" role="tab" aria-controls="layer" aria-selected="false">
-                <i class="bi bi-stack me-1"></i> Layer
-            </button>
-        </li>
-    </ul>
-
-    <!-- Tab panes -->
-    <div class="tab-content">
-        <div class="tab-pane active p-3" id="media" role="tabpanel" aria-labelledby="media-tab" tabindex="0"></div>
-        <div class="tab-pane p-3" id="layer" role="tabpanel" aria-labelledby="layer-tab" tabindex="0"></div>
-    </div>
-`;
-
-UI.audioExample = `
-    <button type="button" id="audio-example" class="text-left btn aton-btn fs-6 mx-2" data-bs-toggle="modal" data-bs-target="#audio1">
-        <i class="bi bi-play-btn me-2"></i> Esempio audio (<em>Che fiero costume</em>)
-    </button>
-`;
-
-/**
- * 
- * @param {String} triggerSelector - Usually, the close modal trigger element(s) selector
- */
-UI.pauseAudio = function(triggerSelector) {
-    // What if more than one audio element is playing?
-    const audio = document.querySelector('audio');
-
-    if (audio) {
-        document.querySelectorAll(triggerSelector).forEach(el => {
-            el.addEventListener('click', () => audio.pause());
-        });
-        document.querySelector('.modal').addEventListener('blur', () => {
-            audio.pause();
-        });
-    }
-}
-/**
- * Resets the UI state (essentially hides the clipper toolbar if visible...)
- * @todo Other elements to reset?? Restore inital lighting conditions and viewpoint...
- */
-UI.reset = function() {
-    document.querySelector('#clipper-bar')?.classList.add('d-none');
-    document.querySelector('#clipper')?.classList.remove('border', 'border-2', 'border-white');
-}
-
-/**
- * 
- * @param {HTMLElement} target 
- * @param {NodeListOf<HTMLButtonElement>} btns 
- * @param {String} axis - One of 'x', 'y', 'z'
- */
-UI.showClipping = function(target, btns, axis) {
-    if (axis) {
-        Scene.addClippingPlane(axis, -1);
-        target.classList.add('border', 'border-2', 'border-warning');
-        btns.forEach(btn => {
-            if (btn.id !== target.id) {
-                btn.classList.remove('border', 'border-2', 'border-warning');
-            }
-        });
-    }
-}
-/**
- * @todo Get clipping button from state? Review logic!! 
- * @param {String} triggerSelector 
- * @param {String} targetSelector The selector for the target toolbar to be displayed
- */
-UI.toggleClipperBar = function(triggerSelector, targetSelector) {
-    const trigger = document.querySelector(triggerSelector);
-    const toolbar = document.querySelector(targetSelector);
-    const btns = toolbar.querySelectorAll('button');
-    const clipTargets = {
-        clipX: {axis: 'x'},
-        clipY: {axis: 'y'},
-        clipZ: {axis: 'z'},
-    };
-
-    if (!AppState.clipping.listeners.button) {
-        trigger.addEventListener(
-            'click',
-            () => {
-                toolbar.classList.toggle('d-none');
-                const aoCurrentState = AppState.ambientOcclusion;
-
-                if (!toolbar.classList.contains('d-none')) {
-                    AppState.clipping.enabled = true;
-                    Scene.toggleAmbientOcclusion(false);
-
-                    btns.forEach(btn => {
-                        btn.classList.remove('border', 'border-2', 'border-warning');
-                    });
-
-                    trigger.className += ' border border-2 border-white';
-                    toolbar.addEventListener('click', event => {
-                        UI.showClipping(event.target, btns, clipTargets[event.target.id]?.axis);
-                    });
-                } else {
-                    Scene.resetClipping();
-                    let noBorder = trigger.className.replace(/ border.*$/g, '');
-                    trigger.className = noBorder;
-                    Scene.toggleAmbientOcclusion(aoCurrentState);
-                }
-            }
-        );
-        AppState.clipping.listeners.button = true;
-    }
-}
-/**
- * A left side settings panel
- * @param {String} triggerId - The settings button id
- */
-UI.toggleSettingsPanel = function(triggerId) {
-    const btn = document.querySelector(`#${triggerId}`);
-    const lightHeading = document.createElement('h2');
-    lightHeading.className = 'fs-5 ms-2 mb-3 mt-3';
-    lightHeading.innerHTML = '<i class="bi bi-lightbulb me-1"></i> Direzione luce';
-    const envHeading = document.createElement('h2');
-    envHeading.className = 'fs-5 ms-2 mb-3 mt-3';
-    envHeading.innerHTML = '<i class="bi bi-brightness-high me-1"></i> Ambiente';
-
-    btn.addEventListener('click', () => {
-        ATON.UI.setSidePanelLeft();
-        ATON.UI.showSidePanel({header: '<i class="bi bi-gear-fill me-1"></i> Impostazioni'});
-        ATON.UI.elSidePanel.appendChild(lightHeading);
-
-        const lightSliderX = this.createLightSlider('x', 'Asse X', [-2, 2], 0.1);
-        const lightSliderY = this.createLightSlider('y', 'Asse Y', [-2, 2], 0.1);
-        const lightSliderZ = this.createLightSlider('z', 'Asse Z', [-2, 2], 0.1);
-
-        ATON.UI.elSidePanel.appendChild(lightSliderX);
-        ATON.UI.elSidePanel.appendChild(lightSliderY);
-        ATON.UI.elSidePanel.appendChild(lightSliderZ);
-
-        ATON.UI.elSidePanel.appendChild(envHeading);
-
-        const ambientOcclSwitch = document.createElement('div');
-        ambientOcclSwitch.className = 'form-check form-switch ms-4 mt-2';
-        ambientOcclSwitch.innerHTML = `
-            <input class="form-check-input" type="checkbox" role="switch" id="aoSwitch" title="Abilita / disabilita ambient occlusion">
-            <label class="form-check-label" for="aoSwitch"><em>Ambient occlusion</em> <i class="bi bi-info-circle ms-2 c-hand"></i></label>
-        `;
-
-        const shadowsSwitch = document.createElement('div');
-        shadowsSwitch.className = 'form-check form-switch ms-4 mt-2';
-        shadowsSwitch.innerHTML = `
-            <input class="form-check-input" type="checkbox" role="switch" id="shadowsSwitch" title="Abilita / disabilita ombre">
-            <label class="form-check-label" for="shadowsSwitch">Ombre <i class="bi bi-info-circle ms-2 c-hand" title=""></i></label>
-        `;
-
-        const lightProbeSwitch = document.createElement('div');
-        lightProbeSwitch.className = 'form-check form-switch ms-4 mt-2';
-        lightProbeSwitch.innerHTML = `
-            <input class="form-check-input" type="checkbox" role="switch" id="lpSwitch" title="Abilita / disabilita mappa HDRi">
-            <label class="form-check-label" for="lpSwitch">Mappa HDRi <em>(light probe)</em> <i class="bi bi-info-circle ms-2 c-hand"></i></label>
-        `;
-
-        shadowsSwitch.querySelector('input[type="checkbox"').checked = AppState.shadows;
-        ambientOcclSwitch.querySelector('input[type="checkbox"').checked = AppState.ambientOcclusion;
-        lightProbeSwitch.querySelector('input[type="checkbox"').checked = AppState.lightProbe;
-
-        ATON.UI.elSidePanel.appendChild(ambientOcclSwitch);
-        ATON.UI.elSidePanel.appendChild(shadowsSwitch);
-        ATON.UI.elSidePanel.appendChild(lightProbeSwitch);
-
-        // TODO: move somewhere else...
-        document.querySelector('#aoSwitch').addEventListener(
-            'change',
-            event => {
-                Scene.toggleAmbientOcclusion(event.target.checked);
-                AppState.ambientOcclusion = event.target.checked;
-            }
-        );
-        document.querySelector('#shadowsSwitch').addEventListener(
-            'change',
-            event => {
-                const checked = event.target.checked;
-                ATON.toggleShadows(checked);
-                AppState.shadows = checked;
-            }
-        );
-        // Not working properly?
-        document.querySelector('#lpSwitch').addEventListener(
-            'change',
-            event => {
-                const checked = event.target.checked;
-                ATON.setAutoLP(checked);
-                //if (!checked) ATON.clearLightProbes();
-                AppState.lightProbe = checked;
-                if (checked) ATON.updateLightProbes();
-                console.log('Light probe: ', checked);
-            }
-        );
-    });
-}
-/**
- * 
- * @param {String} direction - The axis direction, one of 'x','y','z'
- * @param {String} label - The slider label
- * @param {Number[]} range - The slider's range
- * @param {Number} step - The slider's step
- */
-UI.createLightSlider = function(direction, label, range, step) {
-    const currentVal = ATON.getMainLightDirection()[direction];
-    const lightSlider = ATON.UI.createSlider({
-        range,
-        label,
-        value: Number.parseFloat(currentVal).toPrecision(1),
-        oninput: val => {
-            const lightDir = ATON.getMainLightDirection();
-            // Keep existing direction values for the other axes
-            lightDir[direction] = Number.parseFloat(val);
-            Scene.changeLightDirection(lightDir);
-        },
-    });
-
-    lightSlider.classList.add('ms-4');
-    lightSlider.querySelector('input').step = step;
-
-    return lightSlider;
-}
-/**
- * Right-side main menu panel
- * @param {String} triggerId - The menu button id
- */
-UI.toggleContentMenu = function(triggerId) {
-    const btn = document.querySelector(`#${triggerId}`);
-
-    btn.addEventListener('click', () => {
-        ATON.UI.setSidePanelRight();
-        ATON.UI.showSidePanel({header: 'Contenuti'});
-        // Append tabs, then tab panes
-        const tabs = this.domParser.parseFromString(UI.contentMenuTabs, 'text/html');
-        ATON.UI.elSidePanel.appendChild(tabs.querySelector('#content-tabs'));
-        ATON.UI.elSidePanel.appendChild(tabs.querySelector('.tab-content'));
-        this.buildLayersMenu(AppState.nodes, ATON.UI.elSidePanel.querySelector('#layer'));
-
-        // This is just an example, at the moment... to be revised with config -> markers (scenes) -> menu
-        if (AppState.sceneHasAudio) {
-            let btn = this.domParser.parseFromString(UI.audioExample, 'text/html');
-            const audio = btn.querySelector('#audio-example');
-            ATON.UI.elSidePanel.querySelector('#media').appendChild(audio);
-        }
-    });
-}
-/**
- * @todo Don't rebuild it every time the side panel is shown...
- * @param {Array} nodes The scenes nodes (IDs and status)
- * @param {HTMLElement} sidePanel ATON's side panel element
- */
-UI.buildLayersMenu = function(nodes, sidePanel) {
-    for(let node of nodes) {
-        const checkboxStr = `
-            <div class="form-check form-switch ms-4 mt-2">
-                <input class="form-check-input" type="checkbox" ${node.active ? 'checked' : ''} role="switch" title="Mostra / nascondi layer">
-                <label class="form-check-label" for="aoSwitch">${node.id}</label>
-            </div>
-        `;
-
-        let element = this.domParser.parseFromString(checkboxStr, 'text/html');
-        element = element.querySelector('div.form-check');
-
-        sidePanel.appendChild(element);
-        // Will this ever work??
-        element.addEventListener('change', event => toggleNode(node.id, event.target.checked));
-    }
-
-    /**
-     * This is terrible...
-     * @param {String} id 
-     * @param {Boolean} status 
-     */
-    const toggleNode = (id, status) => {
-        ATON.getSceneNode(id).toggle(status);
-        AppState.nodes.find(n => n.id === id).active = status;
-    }
-}
-
-export default UI;

js/utils/aton.js

@@ -0,0 +1,38 @@
+// Global ATON
+
+import AppState from "../state.js";
+
+/**
+ * @module AtonUtils
+ */
+/**
+ * Initializes required ATON events for interactions
+ * with semantic nodes
+ */
+export function initAtonEvents() {
+    // General hover/leave events handling for all semantic nodes.
+    ATON.on("SemanticNodeHover", (semid) => {
+        let node = ATON.getSemanticNode(semid);
+        if (node) node.highlight();
+    });
+
+    ATON.on("SemanticNodeLeave", (semid) => {
+        let node = ATON.getSemanticNode(semid);
+        if (node) node.restoreDefaultMaterial();
+    });
+
+    // Triggers on mouse click / tap events
+    ATON.on("Tap", (e) => {
+        let node = ATON.getHoveredSemanticNode();
+        if (node) {
+            // Retrieve semantic node from AppState to trigger a modal with its content
+            const content = AppState.semanticNodes.get(node.nid);
+            
+            // Triggers a modal to show the content (listened by Stimulus)
+            const event = new Event('semantic-modal-show');
+            event.content = content;
+
+            document.dispatchEvent(event);
+        }
+    });
+}

js/utils/clipping.js

@@ -0,0 +1,157 @@
+// Global ATON and THREE
+
+import AppState from "../state.js";
+
+/**
+ * @module Clipping
+ */
+
+/**
+ * 
+ * @param {THREE.Sphere} boundingSphere - The bounding sphere for the main node
+ * @returns {THREE.Mesh}
+ */
+function createClippingPlaneMesh (boundingSphere) {
+    const planeSize = boundingSphere.radius * 1.5;
+    const mesh = new THREE.Mesh(
+        new THREE.PlaneGeometry(planeSize, planeSize),
+        new THREE.MeshBasicMaterial({ color: 0xffff00, opacity: 0.05, side: THREE.DoubleSide, transparent: true })
+    );
+
+    mesh.castShadow = false;
+    mesh.receiveShadow = false;
+
+    return mesh;
+}
+
+/**
+ * 
+ * @param {THREE.Mesh} planeMesh 
+ * @param {THREE.ArrowHelper} arrowHelper 
+ * @param {String} axis 
+ */
+function dragClipper (planeMesh, axis) {
+    const controls = new THREE.DragControls(
+        [planeMesh],
+        ATON.Nav._camera,
+        ATON._renderer.domElement,
+    ); 
+
+    const startPosition = new THREE.Vector3();
+    // Only move along the selected axis (exlude the others)
+    const excludedAxes = ['x', 'y', 'z'].filter(a => a != axis);
+
+    if (AppState.clipping.enabled && AppState.clipping.vector) {
+        controls.addEventListener('dragstart', function (event) {
+            startPosition.copy(event.object.position);
+            ATON.Nav.setUserControl(false);
+        });
+
+        controls.addEventListener('drag', function(event) {
+            const point = event.object.position;
+            updateClipper(AppState.clipping.vector, point);
+            for (const a of excludedAxes) {
+                event.object.position[a] = startPosition[a];
+            }
+        });
+
+        controls.addEventListener('dragend', function (event) {
+            ATON.Nav.setUserControl(true);
+        });
+
+        AppState.clipping.controls = controls;
+    }
+}
+
+/**
+ * @param {String} axis - The axis along which the plane's normal should be directed,
+ *                        one of 'x', 'y', 'z'
+ * @param {Number} orientation - Positive (1) or negative (-1) orientation on the axis
+ */
+export function addClippingPlane (axis, orientation = -1) {
+    axis = axis.toLowerCase();
+    const bound = AppState.clipping.boundingSphere;
+
+    if (!bound) return;
+
+    const vector = [
+        axis === 'x' ? orientation : 0,
+        axis === 'y' ? orientation : 0,
+        axis === 'z' ? orientation : 0,
+    ];
+
+    AppState.clipping.vector = vector;
+
+    // First, add a default clipping plane
+    // at a default point (calculated...)
+    const defaultPoint = bound.center.clone();
+    activateClipper(vector, axis, defaultPoint);
+}
+
+/**
+ * @todo WIP!
+ * Activate clipping plane
+ * @param {Number[]} vector - The vector array to direct the plane
+ * @param {String} axis - The x,y,z axis
+ * @param {?THREE.Vector3} point - The queried scene point
+ */
+function activateClipper (vector, axis, point = null) {
+    ATON.enableClipPlanes();
+    updateClipper(vector, point);
+    dragClipper(AppState.clipping.helper, axis);
+}
+
+/**
+ * 
+ * @param {THREE.Vector3} vector 
+ * @param {THREE.Vector3} point 
+ */
+function updateClipper (vector, point) {
+    // Useless guard...
+    if (vector) {
+        // Normal of the clipping plane along the axis facing down
+        const normal = new THREE.Vector3(...vector).normalize();
+        const plane = AppState.clipping.plane ?? ATON.addClipPlane(normal, point);
+        // Add a visible plane helper for the clipping plane
+        const visiblePlane = AppState.clipping.helper ?? createClippingPlaneMesh(AppState.clipping.boundingSphere);
+
+        if (!AppState.clipping.helper) {
+            AppState.root.add(visiblePlane);
+            AppState.clipping.helper = visiblePlane;
+        } 
+
+        visiblePlane.position.copy(point);
+        visiblePlane.lookAt(point.clone().add(normal));
+
+        plane.setFromNormalAndCoplanarPoint(normal, point);
+        AppState.clipping.plane = plane;
+    }
+}
+/**
+ * Reset clipping state after disabling from UI
+ * @todo DragControls errors!!
+ */
+export function resetClipping () {
+    AppState.clipping.enabled = false;
+    ATON.disableClipPlanes();
+
+    if (AppState.clipping.controls) {
+        AppState.clipping.controls.deactivate();
+        // Manually remove event listeners from DragControls!!
+        AppState.renderer.domElement.removeEventListener( 'pointermove', AppState.clipping.controls.onPointerMove );
+        AppState.renderer.domElement.removeEventListener( 'pointerdown', AppState.clipping.controls.onPointerDown );
+        AppState.renderer.domElement.removeEventListener( 'pointerup', AppState.clipping.controls.onPointerCancel );
+        AppState.renderer.domElement.removeEventListener( 'pointerleave', AppState.clipping.controls.onPointerCancel )
+        AppState.clipping.controls = null;
+    }
+
+    if (AppState.clipping.helper) {
+        AppState.clipping.helper.removeFromParent();
+        AppState.root.remove(AppState.clipping.helper);
+        AppState.clipping.helper = null;
+    }
+    AppState.clipping.plane = null;
+    AppState.clipping.vector = null;
+    // Ensure nav controls are reactivated!
+    ATON.Nav.setUserControl(true);
+}

js/utils/environment.js

@@ -0,0 +1,82 @@
+/** @import { Vector3 } from 'three' */
+
+// Global ATON and THREE
+
+import AppState from "../state.js";
+
+/**
+ * @module Environment
+ */
+
+/**
+ * @param {Vector3} vector - An object with x,y,z coordinates
+ */
+export function changeLightDirection(vector) {
+    ATON.setMainLightDirection(vector);
+}
+
+/**
+ * 
+ * @param {Boolean} isEnabled 
+ */
+export function toggleAmbientOcclusion(isEnabled) {
+    ATON.FX.togglePass(ATON.FX.PASS_AO, isEnabled);
+    console.log('Ambient occlusion', isEnabled ? 'ON' : 'OFF');
+}
+/**
+ * Slider to change light direction, based on ATON.UI
+ * @param {String} direction - The axis direction, one of 'x','y','z'
+ * @param {String} label - The slider label
+ * @param {[number, number]} range - The slider's range
+ * @param {Number} step - The slider's step
+ */
+export function createLightSlider(direction, label, range, step) {
+    const currentVal = AppState.lightDirection[direction];
+
+    const lightSlider = ATON.UI.createSlider({
+        range,
+        label,
+        value: Number.parseFloat(currentVal).toPrecision(2),
+        oninput: val => {
+            const lightDir = AppState.lightDirection;
+
+            // Keep existing direction values for the other axes
+            lightDir[direction] = Number.parseFloat(val);
+            changeLightDirection(lightDir);
+            AppState.lightDirection = lightDir;
+        },
+    });
+
+    lightSlider.classList.add('ms-1');
+    const input = lightSlider.querySelector('input');
+    if (input) input.step = step;
+
+    return lightSlider;
+}
+/**
+ * Slider to change the env exposure level, based on ATON.UI
+ * @param {String} label - The slider label
+ * @param {[number, number]} range - The slider's range
+ * @param {Number} step - The slider's step
+ */
+export function createExposureSlider(label, range, step = 0.05) {
+    const currentVal = String(AppState.exposure);
+
+    const exposureSlider = ATON.UI.createSlider({
+        range,
+        label,
+        value: Number.parseFloat(currentVal).toPrecision(1),
+        oninput: val => {
+            ATON.setExposure(val);
+            AppState.exposure = val;
+
+            console.debug('Current exposure:', ATON.getExposure());
+        },
+    });
+
+    exposureSlider.classList.add('ms-1');
+    let input = exposureSlider.querySelector('input');
+    if (input) input.step = step;
+
+    return exposureSlider;
+}

js/utils/nodeUtils.js

@@ -0,0 +1,76 @@
+/**
+ * @module nodeUtils
+ * Utilities to process scene nodes.
+ */
+
+/**
+ * @typedef {Object} SceneNode
+ * @property {String} label Required
+ * @property {String} model
+ * @property {Boolean} isMain
+ * @property {Number|null} opacity
+ * @property {SceneNode[]|null} children
+ */
+
+/**
+ * @typedef {Object} NormalizedSceneNode
+ * @property {String} label Required
+ * @property {String} id
+ * @property {String} model
+ * @property {Boolean} isMain
+ * @property {Number|null} opacity
+ * @property {Boolean} active
+ */
+
+/**
+ * 
+ * @param {SceneNode} node 
+ * @param {Array} flatList 
+ * @param {Number} depth
+ */
+function traverseTree(node, flatList, depth = 1, inheritedColor = null) {
+    if (!node.label) {
+        console.error("Node missing label:", node);
+        return;
+    }
+
+    const color = node.color ?? inheritedColor;
+
+    const normNode = {
+        ...node,
+        id: node.id ?? node.label,
+        isMain: node.isMain ?? false,
+        active: true,
+        color: color ?? null,
+        depth,
+        children: [],
+    };
+    if (node.model) {
+       normNode.model = node.model; 
+    }
+
+    flatList.push(normNode);
+
+    if (node.children && Array.isArray(node.children)) {
+        for(const child of node.children) {
+            normNode.children.push(
+                traverseTree(child, flatList, depth + 1, color)
+            );
+        }
+    }
+
+    return normNode;
+}
+
+/**
+ * Create a flat list of nodes from
+ * the nested structure in config
+ * @param {Array} nodes
+ * @returns {{flat: NormalizedSceneNode[], tree: NormalizedSceneNode[]}} A flat list of nodes
+**/
+export function normalizeNodes (nodes) {
+    let flatList = [];
+    const normNode = traverseTree(nodes, flatList);
+
+    return {flat: flatList, tree: normNode.children};
+}

js/utils/stimulus.js

@@ -0,0 +1,18 @@
+import { Application } from '@hotwired/stimulus';
+import SettingController from '../controllers/settings_controller.js';
+import ToolbarController from '../controllers/toolbar_controller.js';
+import ClipperController from '../controllers/clipper_controller.js';
+import MenuController from '../controllers/menu_controller.js';
+import ModalController from '../controllers/modal_controller.js';
+
+/**
+ * Initialize Stimulus controllers
+ */
+export function initStimulus() {
+    window.Stimulus = Application.start();
+    Stimulus.register("settings", SettingController);
+    Stimulus.register("toolbar", ToolbarController);
+    Stimulus.register("clipper", ClipperController);
+    Stimulus.register("menu", MenuController);
+    Stimulus.register("modal", ModalController);
+}

jsdoc.json

@@ -0,0 +1,20 @@
+{
+    "source": {
+        "include": ["js/"]
+    },
+
+    "opts": {
+        "plugins": ["plugins/markdown"],
+        "markdown": {
+        "tags": ["module", "namespace"]
+        },
+        "encoding": "utf8",
+        "destination": "docs/",
+        "recurse": true,
+        "verbose": true,
+        "theme_opts": {
+            "theme": "light",
+            "title": "SCAENAE - ATON-based Web App"
+        }
+    }
+}

package.json

@@ -6,7 +6,9 @@
   "author": "Nicolò P. <nicolo.paraciani@cnr.it>",
   "license": "MIT",
   "dependencies": {
+    "@hotwired/stimulus": "^3.2.2",
     "leaflet": "^1.9.4",
     "three": "0.147"
-  }
+  },
+  "devDependencies": {}
 }

scenes/salvador/index.html

@@ -46,6 +46,13 @@
     <script type="text/javascript" src="../../vendor/three/examples/js/controls/DragControls.js"></script>
     <script type="text/javascript" src="/dist/ATON.min.js"></script>
 
+    <script type="importmap">
+        {
+            "imports": {
+                "@hotwired/stimulus": "../../vendor/@hotwired/stimulus/dist/stimulus.js"
+            }
+        }
+    </script>
 	<!-- Main js entry -->
 	<script type="module" src="./index.js"></script>
 </head>

scenes/salvador/index.js

@@ -1,9 +1,13 @@
-import Scene from "../../js/scene.js";
+import { openScene } from "../../js/scene.js";
 import { config } from "../../config.js";
 import AppState from "../../js/state.js";
+import { normalizeNodes } from "../../js/utils/nodeUtils.js";
+import { initStimulus } from "../../js/utils/stimulus.js";
+
+initStimulus();
 
 AppState.currentScene = 'salvador';
-AppState.sceneHasAudio = true;
+const marker = config.markers.find(m => m.id === 'salvador');
+AppState.normalizedNodes = normalizeNodes(marker.nodes).flat;
 
-Scene.openScene(config.markers.find(m => m.id === 'salvador'));
+openScene(marker, AppState.normalizedNodes);
-Scene.UI.pauseAudio('[data-bs-dismiss="modal"]');

scenes/ssgp/index.html

@@ -46,19 +46,30 @@
     <script type="text/javascript" src="../../vendor/three/examples/js/controls/DragControls.js"></script>
     <script type="text/javascript" src="/dist/ATON.min.js"></script>
 
+     <script type="importmap">
+        {
+            "imports": {
+                "@hotwired/stimulus": "../../vendor/@hotwired/stimulus/dist/stimulus.js"
+            }
+        }
+    </script>
+
 	<!-- Main js entry -->
 	<script type="module" src="./index.js"></script>
 </head>
 
-<body data-bs-theme="light">
+<body data-bs-theme="light" data-controller="menu modal" data-action="semantic-modal-show@document->modal#showSemanticModal">
-    <div id="toolbar" class="aton-toolbar-top w-100">
+    <div id="toolbar" class="aton-toolbar-top w-100"
+        data-controller="toolbar clipper" data-clipper-enabled-value="false">
         <a class="btn aton-btn fs-5" href="/a/scaenae" id="back" title="Torna alla mappa">
             <i class="bi bi-map-fill"></i>
         </a>
-        <a class="btn aton-btn fs-5" id="settings" title="Impostazioni">
+        <a class="btn aton-btn fs-5" title="Impostazioni" data-toolbar-target="settings"
+            data-action="toolbar#toggleSettings">
             <i class="bi bi-gear-fill"></i>
         </a>
-        <a class="btn aton-btn fs-5" id="clipper" title="Attiva / disattiva sezionamento">
+        <a class="btn aton-btn fs-5" title="Attiva / disattiva sezionamento"
+            data-clipper-target="trigger" data-action="clipper#toggleClipper">
             <i class="bi bi-scissors"></i>
         </a>
         <div class="d-none w-25
@@ -68,20 +79,99 @@
             px-4 pt-2 pb-2 bg-opacity-50
             rounded-bottom-3
             mt-4 text-dark text-center"
-        id="clipper-bar">
+        id="clipper-bar"
-            <span class="pt-5 pb-2 d-block fw-bold">Sezionamento</span>
+        data-clipper-target="clipper">
-            <button class="btn aton-btn d-inline px-4 py-4 me-5" id="clipX" title="Sezione X"></button>
+            <span class="pt-5 pb-2 d-block fw-bold">Sezione</span>
-            <button class="btn aton-btn d-inline px-4 py-4 me-5" id="clipY" title="Sezione Y"></button>
+            <button class="btn aton-btn d-inline px-4 py-4 me-5" id="clipX"
-            <button class="btn aton-btn d-inline px-4 py-4" id="clipZ" title="Sezione Z"></button>
+                data-clipper-target="axis" data-clipper-axis-param="x" data-action="clipper#clip" title="Sezione X"></button>
+            <button class="btn aton-btn d-inline px-4 py-4 me-5" id="clipY"
+                data-clipper-target="axis" data-clipper-axis-param="y" data-action="clipper#clip" title="Sezione Y"></button>
+            <button class="btn aton-btn d-inline px-4 py-4" id="clipZ"
+                data-clipper-target="axis" data-clipper-axis-param="z" data-action="clipper#clip" title="Sezione Z"></button>
         </div>
-        <a class="btn aton-btn fs-5 float-end" id="menu" title="Menu">
+        <a class="btn aton-btn fs-5 float-end" id="menu" title="Menu"
+            data-menu-target="trigger" data-action="menu#toggleMenu">
             <i class="bi bi-list"></i>
         </a>
     </div>
 
+    <!-- Settings menu template (except dynamic light sliders) -->
+    <template id="tmpl-settings">
+        <div data-controller="settings">
+            <details class="w-max-content">
+                <summary class="fs-5 ms-3 mb-3 mt-3">
+                    <i class="bi bi-lightbulb me-1"></i> Illuminazione
+                </summary>
+                <h3 class="fs-6 p-2 ms-4 mb-1 mt-3 border border-1 rounded bg-info-subtle">
+                    Direzione (x, y, z)
+                </h3>
+                <div class="border border-1 rounded ms-4" data-sliders-container></div>
+                <h3 class="fs-6 p-2 ms-4 mb-1 mt-3 border border-1 rounded bg-info-subtle">
+                    Intensità <span class="d-inline app-tooltip" data-tip="Le modifiche di intensità hanno effetto solo se Ambient Occlusion non è attivo" tabindex="1"><i class="bi bi-info-circle ms-1"></i></span>
+                </h3>
+                <div class="ms-4 border border-1 rounded" data-slider-exposure-container></div>
+            </details>
+            <details>
+                <summary class="fs-5 ms-3 mb-3 mt-3">
+                    <i class="bi bi-brightness-high me-1"></i> Ambiente
+                </summary>
+                <div class="form-check form-switch ms-4 mt-4">
+                    <input class="form-check-input" type="checkbox" role="switch"
+                        data-settings-target="ao" data-action="change->settings#toggleAO">
+                    <label class="form-check-label" for="aoSwitch">Ambient occlusion</label>
+                </div>
+                <div class="form-check form-switch ms-4 mt-2">
+                    <input class="form-check-input" type="checkbox" role="switch"
+                        data-settings-target="shadows" data-action="change->settings#toggleShadows">
+                    <label class="form-check-label" for="shadowsSwitch">
+                        Ombre <span class="d-inline app-tooltip" data-tip="Attivare le ombre può rallentare l'applicazione" tabindex="2"><i class="bi bi-info-circle ms-1"></i></span>
+                    </label>
+                </div>
+            </details>
+        </div>
+    </template>
 
-    <!-- TODO CSS-only popover -->
+    <template id="tmpl-menu-tabs">
-    <div class="card d-none" id="shadows-popover" popover>Disabilitare le ombre può migliorare le prestazioni</div>
+        <!-- Nav tabs -->
+        <ul class="nav nav-pills" id="content-tabs" role="tablist">
+            <li class="nav-item" role="presentation">
+                <button class="nav-link active" id="layer-tab" data-bs-toggle="tab" data-bs-target="#layer" type="button" role="tab" aria-controls="layer" aria-selected="false">
+                    <i class="bi bi-boxes me-1"></i> Elementi 3D
+                </button>
+            </li>
+            <li class="nav-item" role="presentation">
+                <button class="nav-link" id="content-tab" data-bs-toggle="tab" data-bs-target="#content" type="button" role="tab" aria-controls="media" aria-selected="true">
+                    <i class="bi bi-diagram-3 me-1"></i> Contenuti
+                </button>
+            </li>
+        </ul>
+        <!-- Tab panes -->
+        <div class="tab-content ps-2 ms-2 overflow-y-auto">
+            <div class="tab-pane active ps-3 pt-0 mt-4 ms-0" data-menu-target="layers" id="layer" role="tabpanel" aria-labelledby="layer-tab" tabindex="0"></div>
+            <div class="tab-pane pt-3" data-menu-target="ontology" id="content" role="tabpanel" aria-labelledby="media-tab" tabindex="0">
+                <!-- Temporary -->
+                <ul class="list-group me-4 ms-0">
+                    <li class="list-group-item pt-2 pb-2" id="ontology-list"> </li>
+                </ul>
+            </div>
+        </div>
+    </template>
+
+    <!-- TODO Make it a template -->
+   <div class="modal" id="semanticModal" tabindex="-1" data-modal-target="modal">
+        <div class="modal-dialog modal-dialog-centered modal-dialog-scrollable modal-lg">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title"></h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Chiudi"></button>
+                </div>
+                <div class="modal-body"></div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Chiudi</button>
+                </div>
+            </div>
+        </div>
+    </div> 
 
     <div class="aton-poweredby" >
         <a href="https://aton.ispc.cnr.it/site/" target="_blank"><img src="/res/aton-logo.png"></a>

scenes/ssgp/index.js

@@ -1,6 +1,20 @@
-import Scene from "../../js/scene.js";
+import { openScene } from "../../js/scene.js";
 import { config } from "../../config.js";
 import AppState from "../../js/state.js";
+import { normalizeNodes } from "../../js/utils/nodeUtils.js";
+import { initStimulus } from "../../js/utils/stimulus.js";
+import { initAtonEvents } from "../../js/utils/aton.js";
+
+initStimulus();
 
 AppState.currentScene = 'ssgp';
-Scene.openScene(config.markers.find(m => m.id === 'ssgp'));
+const marker = config.markers.find(m => m.id === 'ssgp');
+const {flat, tree} = normalizeNodes(marker.nodes);
+AppState.normalizedNodes = flat;
+AppState.treeNodes = tree;
+
+// TODO: add Map object for lookup optimization
+
+openScene(marker, AppState.normalizedNodes);
+
+initAtonEvents();

scenes/ssgp/ontology.json

@@ -0,0 +1,230 @@
+{
+  "ontology": "Baroque Theatre Ontology (BT)",
+  "generatedOn": "2026-01-29",
+  "note": "Only bt: classes and bt: subclass relations; excludes Core; no CIDOC/BOT equivalences included.",
+  "domains": {
+    "TheatreArchitecture": [
+      {
+        "id": "bt:ArchitecturalComponent",
+        "label": "ArchitecturalComponent",
+        "children": [
+          {
+            "id": "bt:ArchitecturalWings",
+            "label": "ArchitecturalWings",
+            "children": []
+          },
+          {
+            "id": "bt:Gridiron",
+            "label": "Gridiron",
+            "children": []
+          },
+          {
+            "id": "bt:Proscenium",
+            "label": "Proscenium",
+            "children": []
+          },
+          {
+            "id": "bt:StructuralBackdrop",
+            "label": "StructuralBackdrop",
+            "children": []
+          },
+          {
+            "id": "bt:TechnicalGallery",
+            "label": "TechnicalGallery",
+            "children": []
+          },
+          {
+            "id": "bt:Trapdoor",
+            "label": "Trapdoor",
+            "children": []
+          }
+        ]
+      },
+      {
+        "id": "bt:ArchitecturalSpace",
+        "label": "ArchitecturalSpace",
+        "children": [
+          {
+            "id": "bt:Auditorium",
+            "label": "Auditorium",
+            "children": [
+              {
+                "id": "bt:BoxTier",
+                "label": "BoxTier",
+                "children": [
+                  {
+                    "id": "bt:Box",
+                    "label": "Box",
+                    "children": []
+                  }
+                ]
+              },
+              {
+                "id": "bt:Gallery",
+                "label": "Gallery",
+                "children": []
+              },
+              {
+                "id": "bt:Stalls",
+                "label": "Stalls",
+                "children": []
+              }
+            ]
+          },
+          {
+            "id": "bt:BackstageArea",
+            "label": "BackstageArea",
+            "children": []
+          },
+          {
+            "id": "bt:CirculationRoute",
+            "label": "CirculationRoute",
+            "children": []
+          },
+          {
+            "id": "bt:Entrance",
+            "label": "Entrance",
+            "children": []
+          },
+          {
+            "id": "bt:OrchestraPit",
+            "label": "OrchestraPit",
+            "children": []
+          },
+          {
+            "id": "bt:Stage",
+            "label": "Stage",
+            "children": [
+              {
+                "id": "bt:Overstage",
+                "label": "Overstage",
+                "children": []
+              },
+              {
+                "id": "bt:Understage",
+                "label": "Understage",
+                "children": []
+              }
+            ]
+          }
+        ]
+      },
+      {
+        "id": "bt:TheatreBuilding",
+        "label": "TheatreBuilding",
+        "children": []
+      }
+    ],
+    "ScenicApparatus": [
+      {
+        "id": "bt:ScenicApparatus",
+        "label": "ScenicApparatus",
+        "children": [
+          {
+            "id": "bt:Backdrop",
+            "label": "Backdrop",
+            "children": [
+              {
+                "id": "bt:FixedBackdrop",
+                "label": "FixedBackdrop",
+                "children": []
+              },
+              {
+                "id": "bt:MobileBackdrop",
+                "label": "MobileBackdrop",
+                "children": []
+              }
+            ]
+          },
+          {
+            "id": "bt:LightingDevice",
+            "label": "LightingDevice",
+            "children": []
+          },
+          {
+            "id": "bt:ScenicMachine",
+            "label": "ScenicMachine",
+            "children": [
+              {
+                "id": "bt:FlightMechanism",
+                "label": "FlightMechanism",
+                "children": []
+              },
+              {
+                "id": "bt:MovingDevice",
+                "label": "MovingDevice",
+                "children": []
+              }
+            ]
+          },
+          {
+            "id": "bt:ScenicObject",
+            "label": "ScenicObject",
+            "children": []
+          },
+          {
+            "id": "bt:SoundEffectDevice",
+            "label": "SoundEffectDevice",
+            "children": []
+          }
+        ]
+      }
+    ],
+    "PerformativeEvent": [
+      {
+        "id": "bt:PerformativeEvent",
+        "label": "PerformativeEvent",
+        "children": [
+          {
+            "id": "bt:PublicCelebration",
+            "label": "PublicCelebration",
+            "children": []
+          },
+          {
+            "id": "bt:Rehearsal",
+            "label": "Rehearsal",
+            "children": []
+          },
+          {
+            "id": "bt:TheatricalPerformance",
+            "label": "TheatricalPerformance",
+            "children": []
+          }
+        ]
+      }
+    ],
+    "DocumentaryResource": [
+      {
+        "id": "bt:DocumentaryResource",
+        "label": "DocumentaryResource",
+        "children": [
+          {
+            "id": "bt:DigitalModel",
+            "label": "DigitalModel",
+            "children": []
+          },
+          {
+            "id": "bt:IconographicSource",
+            "label": "IconographicSource",
+            "children": []
+          },
+          {
+            "id": "bt:TechnicalDocument",
+            "label": "TechnicalDocument",
+            "children": []
+          },
+          {
+            "id": "bt:TextualSource",
+            "label": "TextualSource",
+            "children": []
+          }
+        ]
+      },
+      {
+        "id": "bt:DocumentationEvent",
+        "label": "DocumentationEvent",
+        "children": []
+      }
+    ]
+  }
+}

yarn.lock

@@ -2,12 +2,17 @@
 # yarn lockfile v1
 
 
+"@hotwired/stimulus@^3.2.2":
+  version "3.2.2"
+  resolved "https://registry.npmjs.org/@hotwired/stimulus/-/stimulus-3.2.2.tgz"
+  integrity sha512-eGeIqNOQpXoPAIP7tC1+1Yc1yl1xnwYqg+3mzqxyrbE5pg5YFBZcA6YoTiByJB6DKAEsiWtl6tjTJS4IYtbB7A==
+
 leaflet@^1.9.4:
   version "1.9.4"
-  resolved "https://registry.yarnpkg.com/leaflet/-/leaflet-1.9.4.tgz#23fae724e282fa25745aff82ca4d394748db7d8d"
+  resolved "https://registry.npmjs.org/leaflet/-/leaflet-1.9.4.tgz"
   integrity sha512-nxS1ynzJOmOlHp+iL3FyWqK89GtNL8U8rvlMOsQdTTssxZwCXh8N2NB3GDQOL+YR3XnWyZAxwQixURb+FA74PA==
 
 three@0.147:
   version "0.147.0"
-  resolved "https://registry.yarnpkg.com/three/-/three-0.147.0.tgz#1974af9e8e0c1efb3a8561334d57c0b6c29a7951"
+  resolved "https://registry.npmjs.org/three/-/three-0.147.0.tgz"
   integrity sha512-LPTOslYQXFkmvceQjFTNnVVli2LaVF6C99Pv34fJypp8NbQLbTlu3KinZ0zURghS5zEehK+VQyvWuPZ/Sm8fzw==