feat: integrate Draco compression for 3D models in backoffice

- Added support for uploading and compressing GLB models using Draco in the backoffice. - Implemented commands for importing and re-compressing 3D models. - Updated model resource to handle 3D model uploads and validations. - Introduced a new script for compressing GLB files with Draco. - Modified Vite configuration to remove GLB files from the build output. - Updated package dependencies to include GLTF-transform libraries for handling 3D models. - Added tests to ensure proper functionality of 3D model handling and compression.
2026-11-01 10:35:50 +01:00
parent 24f9e59654
commit 1208187a17
32 changed files with 895 additions and 52 deletions
@@ -63,3 +63,7 @@ AWS_BUCKET=
 AWS_USE_PATH_STYLE_ENDPOINT=false

 VITE_APP_NAME="${APP_NAME}"
+
+# Modelli 3D: Node per la compressione Draco (percorso completo se PHP-FPM non lo trova nel PATH).
+# NODE_BINARY=/opt/plesk/node/22/bin/node
+# MODELLI_3D_MAX_MB=200
@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Modello;
+use App\Support\Configuratore\Modelli3d;
+use App\Support\Configuratore\Modello3dNonValido;
+use Illuminate\Console\Command;
+use Illuminate\Support\Number;
+
+/**
+ * Migrazione una tantum: associa ai modelli i .glb che prima stavano nel frontend
+ * (src/assets/models/<sistema>/<file_modello>), comprimendoli come un caricamento dal backoffice.
+ * I modelli che hanno già un modello 3D sono saltati (salvo --forza).
+ */
+class ImportaModelli3d extends Command
+{
+    protected $signature = 'modelli3d:importa
+        {cartella? : Cartella con le sottocartelle per sistema (default: ../src/assets/models)}
+        {--forza : Sostituisce anche i modelli 3D già caricati}';
+
+    protected $description = 'Importa i modelli 3D (.glb) dalla cartella del configuratore e li comprime con Draco';
+
+    public function handle(Modelli3d $modelli3d): int
+    {
+        $cartella = rtrim($this->argument('cartella') ?? base_path('../src/assets/models'), '/');
+        if (! is_dir($cartella)) {
+            $this->error("Cartella non trovata: {$cartella}");
+
+            return self::FAILURE;
+        }
+
+        $importati = 0;
+        $errori = 0;
+
+        $modelli = Modello::with('sistema')->whereNotNull('file_modello')->orderBy('sistema_id')->orderBy('ordine')->get();
+        foreach ($modelli as $modello) {
+            $etichetta = "{$modello->sistema->codice}/{$modello->codice}";
+
+            if ($modello->modello_3d_draco && ! $this->option('forza')) {
+                $this->line("  {$etichetta}: già presente, saltato");
+
+                continue;
+            }
+
+            $file = "{$cartella}/{$modello->sistema->codice}/{$modello->file_modello}";
+            if (! is_file($file)) {
+                $this->warn("  {$etichetta}: {$modello->file_modello} non trovato");
+
+                continue;
+            }
+
+            try {
+                $modelli3d->carica($modello, $file, $modello->file_modello);
+                $importati++;
+                $this->info(sprintf('  %s: %s → %s', $etichetta,
+                    Number::fileSize($modello->modello_3d_dimensione, precision: 1),
+                    Number::fileSize($modello->modello_3d_draco_dimensione, precision: 1)));
+            } catch (Modello3dNonValido $e) {
+                $errori++;
+                $this->error("  {$etichetta}: {$e->getMessage()}");
+            }
+        }
+
+        $this->newLine();
+        $this->info("Importati {$importati} modelli 3D".($errori ? ", {$errori} errori" : '').'.');
+
+        return $errori ? self::FAILURE : self::SUCCESS;
+    }
+}
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Modello;
+use App\Support\Configuratore\Modelli3d;
+use App\Support\Configuratore\Modello3dNonValido;
+use Illuminate\Console\Command;
+
+/** Rigenera le copie Draco dagli originali, ad esempio dopo un cambio di scripts/comprimi-glb.mjs. */
+class RicomprimiModelli3d extends Command
+{
+    protected $signature = 'modelli3d:ricomprimi {codice?* : Codici dei modelli (default: tutti)}';
+
+    protected $description = 'Ricomprime con Draco i modelli 3D a partire dagli originali archiviati';
+
+    public function handle(Modelli3d $modelli3d): int
+    {
+        $errori = 0;
+
+        $modelli = Modello::with('sistema')
+            ->whereNotNull('modello_3d')
+            ->when($this->argument('codice'), fn ($q, $codici) => $q->whereIn('codice', $codici))
+            ->get();
+
+        foreach ($modelli as $modello) {
+            try {
+                $modelli3d->ricomprimi($modello);
+                $this->info("  {$modello->sistema->codice}/{$modello->codice}: ricompresso");
+            } catch (Modello3dNonValido $e) {
+                $errori++;
+                $this->error("  {$modello->sistema->codice}/{$modello->codice}: {$e->getMessage()}");
+            }
+        }
+
+        return $errori ? self::FAILURE : self::SUCCESS;
+    }
+}
@@ -8,6 +8,9 @@ use App\Filament\Resources\ModelloResource\RelationManagers\FinitureRelationMana
 use App\Filament\Resources\ModelloResource\RelationManagers\ListinoRelationManager;
 use App\Filament\Resources\ModelloResource\RelationManagers\OpzioniRelationManager;
 use App\Models\Modello;
+use App\Support\Configuratore\Modelli3d;
+use App\Support\Configuratore\Modello3dNonValido;
+use Closure;
 use Filament\Forms;
 use Filament\Forms\Form;
 use Filament\Forms\Get;
@@ -15,6 +18,8 @@ use Filament\Resources\Resource;
 use Filament\Tables;
 use Filament\Tables\Table;
 use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Number;
 use Illuminate\Validation\Rules\Unique;


@@ -89,7 +94,7 @@ class ModelloResource extends Resource
                                ->default(0),
                            Forms\Components\Toggle::make('attivo')
                                ->label('Visibile nel configuratore')
-                                ->helperText('Richiede la configurazione 3D.')
+                                ->helperText('Richiede la configurazione 3D (con il modello .glb).')
                                ->default(true)
                                ->live(),
                        ]),
@@ -103,10 +108,41 @@ class ModelloResource extends Resource
                        ->label('Cartella dati')
                        ->helperText('src/assets/data/modelli/<sistema>/<cartella>/')
                        ->required(fn (Get $get) => (bool) $get('attivo')),
-                    Forms\Components\TextInput::make('file_modello')
-                        ->label('File modello 3D')
-                        ->helperText('src/assets/models/<sistema>/<file>.glb')
-                        ->required(fn (Get $get) => (bool) $get('attivo')),
+                    Forms\Components\Placeholder::make('modello_3d_attuale')
+                        ->key('modello_3d_attuale')
+                        ->label('Modello 3D attuale')
+                        ->visible(fn (?Modello $record) => (bool) $record?->modello_3d_draco)
+                        ->content(fn (Modello $record) => self::descriviModello3d($record))
+                        ->hintActions([
+                            Forms\Components\Actions\Action::make('scarica_originale')
+                                ->label('Originale')
+                                ->icon('heroicon-m-arrow-down-tray')
+                                ->visible(fn (?Modello $record) => (bool) $record?->modello_3d)
+                                ->action(fn (Modello $record) => Storage::disk('local')->download(
+                                    $record->modello_3d,
+                                    $record->modello_3d_nome ?: basename($record->modello_3d),
+                                )),
+                            Forms\Components\Actions\Action::make('scarica_draco')
+                                ->label('Compresso')
+                                ->icon('heroicon-m-arrow-down-tray')
+                                ->url(fn (Modello $record) => $record->modello_3d_url, shouldOpenInNewTab: true),
+                        ])
+                        ->columnSpanFull(),
+                    Forms\Components\FileUpload::make('modello_3d_upload')
+                        ->label(fn (?Modello $record) => $record?->modello_3d_draco ? 'Sostituisci modello 3D' : 'Modello 3D (.glb)')
+                        ->helperText('File .glb non compresso. Al salvataggio viene compresso con Draco per il configuratore; l\'originale resta archiviato nel backoffice.')
+                        // Il file lo gestisce Modelli3d (vedi Pages\Concerns\CaricaModello3d), non Filament.
+                        ->storeFiles(false)
+                        ->maxSize(fn () => config('configuratore.modelli_3d.max_mb') * 1024)
+                        ->required(fn (Get $get, ?Modello $record) => (bool) $get('attivo') && ! $record?->modello_3d_draco)
+                        ->rule(fn () => function (string $attribute, mixed $file, Closure $fail) {
+                            try {
+                                app(Modelli3d::class)->verificaGlb($file->getRealPath());
+                            } catch (Modello3dNonValido $e) {
+                                $fail($e->getMessage());
+                            }
+                        })
+                        ->columnSpanFull(),
                    Forms\Components\Select::make('categoria')
                        ->label('Categoria')
                        ->options(Modello::CATEGORIE)
@@ -161,6 +197,14 @@ class ModelloResource extends Resource
                    ->badge()
                    ->formatStateUsing(fn (?string $state) => Modello::CATEGORIE[$state] ?? $state)
                    ->placeholder('—'),
+                Tables\Columns\IconColumn::make('modello_3d_draco')
+                    ->label('3D')
+                    ->boolean()
+                    ->getStateUsing(fn (Modello $record) => (bool) $record->modello_3d_draco)
+                    ->falseColor('danger')
+                    ->tooltip(fn (Modello $record) => $record->modello_3d_draco
+                        ? $record->modello_3d_nome
+                        : 'Senza modello 3D: non compare nel configuratore'),
                Tables\Columns\TextColumn::make('listino_count')
                    ->label('Listino')
                    ->counts('listino')
@@ -174,7 +218,7 @@ class ModelloResource extends Resource
                    ->sortable(),
                Tables\Columns\ToggleColumn::make('attivo')
                    ->label('Attivo')
-                    ->disabled(fn (Modello $record) => ! $record->attivo && (! $record->cartella || ! $record->file_modello)),
+                    ->disabled(fn (Modello $record) => ! $record->attivo && (! $record->cartella || ! $record->modello_3d_draco)),
            ])
            ->filters([
                Tables\Filters\SelectFilter::make('sistema')->label('Sistema')->relationship('sistema', 'nome'),
@@ -201,6 +245,19 @@ class ModelloResource extends Resource
            ]);
    }

+    /** Es. "finestra_2_ante.glb — 10,8 MB → 0,3 MB con Draco (-97%), caricato il 01/11/2026 10:00". */
+    private static function descriviModello3d(Modello $record): string
+    {
+        $mb = fn (?int $byte) => Number::fileSize((int) $byte, precision: 1);
+        $riduzione = $record->modello_3d_dimensione
+            ? ' (-'.round(100 - $record->modello_3d_draco_dimensione * 100 / $record->modello_3d_dimensione).'%)'
+            : '';
+
+        return ($record->modello_3d_nome ?: basename((string) $record->modello_3d_draco))
+            .' — '.$mb($record->modello_3d_dimensione).' → '.$mb($record->modello_3d_draco_dimensione).' con Draco'.$riduzione
+            .($record->modello_3d_aggiornato_at ? ', caricato il '.$record->modello_3d_aggiornato_at->format('d/m/Y H:i') : '');
+    }
+
    public static function getRelations(): array
    {
        return [
@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Filament\Resources\ModelloResource\Pages\Concerns;
+
+use App\Models\Modello;
+use App\Support\Configuratore\Modelli3d;
+use App\Support\Configuratore\Modello3dNonValido;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
+use Livewire\Features\SupportFileUploads\TemporaryUploadedFile;
+
+/**
+ * Il campo "Modello 3D" non è una colonna: il file caricato passa da Modelli3d, che salva
+ * l'originale e la copia compressa con Draco. Se la compressione fallisce, il salvataggio
+ * viene annullato (transazione) e l'errore compare sul campo.
+ */
+trait CaricaModello3d
+{
+    protected function handleRecordCreation(array $data): Model
+    {
+        $file = Arr::pull($data, 'modello_3d_upload');
+
+        return DB::transaction(function () use ($data, $file) {
+            $record = parent::handleRecordCreation($data);
+            $this->caricaModello3d($record, $file);
+
+            return $record;
+        });
+    }
+
+    protected function handleRecordUpdate(Model $record, array $data): Model
+    {
+        $file = Arr::pull($data, 'modello_3d_upload');
+
+        return DB::transaction(function () use ($record, $data, $file) {
+            $record = parent::handleRecordUpdate($record, $data);
+            $this->caricaModello3d($record, $file);
+
+            return $record;
+        });
+    }
+
+    private function caricaModello3d(Model $record, mixed $file): void
+    {
+        $file = is_array($file) ? Arr::first($file) : $file;
+        if (! $file instanceof TemporaryUploadedFile || ! $record instanceof Modello) {
+            return;
+        }
+
+        try {
+            app(Modelli3d::class)->carica($record, $file->getRealPath(), $file->getClientOriginalName());
+        } catch (Modello3dNonValido $e) {
+            throw ValidationException::withMessages(['data.modello_3d_upload' => $e->getMessage()]);
+        }
+
+        $file->delete();
+    }
+}
@@ -3,10 +3,13 @@
 namespace App\Filament\Resources\ModelloResource\Pages;

 use App\Filament\Resources\ModelloResource;
+use App\Filament\Resources\ModelloResource\Pages\Concerns\CaricaModello3d;
 use Filament\Resources\Pages\CreateRecord;

 class CreateModello extends CreateRecord
 {
+    use CaricaModello3d;
+
    protected static string $resource = ModelloResource::class;

    protected function getRedirectUrl(): string
@@ -3,11 +3,14 @@
 namespace App\Filament\Resources\ModelloResource\Pages;

 use App\Filament\Resources\ModelloResource;
+use App\Filament\Resources\ModelloResource\Pages\Concerns\CaricaModello3d;
 use Filament\Actions;
 use Filament\Resources\Pages\EditRecord;

 class EditModello extends EditRecord
 {
+    use CaricaModello3d;
+
    protected static string $resource = ModelloResource::class;

    protected function getHeaderActions(): array
@@ -122,7 +122,8 @@ class CatalogoController extends Controller
            'descrizione' => $modello->descrizione,
            'icona' => $modello->icona_url,
            'cartella' => $modello->cartella,
-            'modello' => $modello->file_modello,
+            // Modello 3D compresso con Draco, caricato dal backoffice.
+            'modello_url' => $modello->modello_3d_url,
            'categoria' => $modello->categoria,
            'cartella_texture' => $modello->cartella_texture,
            'moduli' => $modello->moduli ?? [],
@@ -4,6 +4,7 @@ namespace App\Http\Controllers\Api;

 use App\Http\Controllers\Controller;
 use App\Support\Configuratore\Media;
+use App\Support\Configuratore\Modelli3d;
 use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Str;
 use Symfony\Component\HttpFoundation\BinaryFileResponse;
@@ -12,7 +13,7 @@ class MediaController extends Controller
 {
    /**
     * GET /api/media/{percorso}
-     * Immagini del configuratore dal disco public, con gli header CORS dell'API (necessari
+     * Immagini e modelli 3D (compressi) del configuratore dal disco public, con gli header CORS dell'API (necessari
     * alle texture WebGL caricate da un'altra origine).
     */
    public function __invoke(string $percorso): BinaryFileResponse
@@ -26,8 +27,11 @@ class MediaController extends Controller
            404
        );

+        // I modelli 3D hanno l'hash del contenuto nel nome: un nuovo caricamento cambia URL.
+        $modello3d = Str::startsWith($percorso, Modelli3d::CARTELLA_DRACO.'/');
+
        return response()->file($disco->path($percorso), [
-            'Cache-Control' => 'public, max-age=86400',
-        ]);
+            'Cache-Control' => $modello3d ? 'public, max-age=31536000, immutable' : 'public, max-age=86400',
+        ] + ($modello3d ? ['Content-Type' => 'model/gltf-binary'] : []));
    }
 }
@@ -2,6 +2,8 @@

 namespace App\Models;

+use App\Support\Configuratore\Media;
+use App\Support\Configuratore\Modelli3d;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
@@ -46,6 +48,9 @@ class Modello extends Model
        'attivo' => 'boolean',
        'moduli' => 'array',
        'listino_aggiornato_at' => 'datetime',
+        'modello_3d_dimensione' => 'integer',
+        'modello_3d_draco_dimensione' => 'integer',
+        'modello_3d_aggiornato_at' => 'datetime',
    ];

    public function sistema(): BelongsTo
@@ -97,10 +102,19 @@ class Modello extends Model
        return $query->where('attivo', true)->orderBy('ordine')->orderBy('id');
    }

-    /** Modelli mostrati nel configuratore: attivi e con un listino (senza prezzi non si possono vendere). */
+    /**
+     * Modelli mostrati nel configuratore: attivi, con un listino (senza prezzi non si possono
+     * vendere) e con il modello 3D caricato.
+     */
    public function scopeNelConfiguratore(Builder $query): Builder
    {
-        return $query->attivi()->whereHas('listino');
+        return $query->attivi()->whereNotNull('modello_3d_draco')->whereHas('listino');
+    }
+
+    /** URL del modello 3D compresso (Draco) letto dal configuratore. */
+    public function getModello3dUrlAttribute(): ?string
+    {
+        return Media::url($this->modello_3d_draco);
    }

    public function getIconaUrlAttribute(): ?string
@@ -150,6 +164,7 @@ class Modello extends Model
            if ($modello->icona) {
                Storage::disk('public')->delete($modello->icona);
            }
+            app(Modelli3d::class)->elimina($modello);
        });
    }
 }
@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Support\Configuratore;
+
+use Illuminate\Support\Facades\Process;
+use Illuminate\Support\Str;
+use Throwable;
+
+/**
+ * Comprime un .glb con Draco tramite lo script Node scripts/comprimi-glb.mjs (stesse opzioni
+ * di quantizzazione usate prima in build dal configuratore).
+ */
+class CompressoreGlb
+{
+    public function comprimi(string $sorgente, string $destinazione): void
+    {
+        $config = config('configuratore.modelli_3d');
+
+        if (! is_file($config['script'])) {
+            throw new Modello3dNonValido("Script di compressione non trovato: {$config['script']}.");
+        }
+
+        try {
+            $risultato = Process::timeout($config['timeout'])
+                ->run([$config['node'], $config['script'], $sorgente, $destinazione]);
+        } catch (Throwable $e) {
+            // Es. Node non trovato (NODE_BINARY) o timeout.
+            throw new Modello3dNonValido('Compressione Draco non avviata: '.$e->getMessage(), previous: $e);
+        }
+
+        if ($risultato->failed() || ! is_file($destinazione) || filesize($destinazione) === 0) {
+            $errore = trim($risultato->errorOutput()) ?: trim($risultato->output());
+
+            throw new Modello3dNonValido('Compressione Draco non riuscita: '.(Str::limit($errore, 300) ?: 'errore sconosciuto').'.');
+        }
+    }
+}
@@ -9,7 +9,7 @@ namespace App\Support\Configuratore;
 class Media
 {
    /** Cartelle del disco public servite dalla rotta media. */
-    public const CARTELLE = ['configuratore/', 'modelli/'];
+    public const CARTELLE = ['configuratore/', 'modelli/', Modelli3d::CARTELLA_DRACO.'/'];

    public static function url(?string $percorso): ?string
    {
@@ -0,0 +1,158 @@
+<?php
+
+namespace App\Support\Configuratore;
+
+use App\Models\Modello;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Str;
+
+/**
+ * Modelli 3D dei prodotti, caricati dal backoffice e associati al codice del modello.
+ *
+ * Di ogni .glb si tengono due copie:
+ *  - l'originale non compresso, sul disco privato (`local`), conservato per sviluppi futuri
+ *    (es. ricompressione con altre opzioni, altri formati);
+ *  - la copia compressa con Draco, sul disco `public`, l'unica servita al configuratore
+ *    (rotta API media, con CORS). Il nome contiene un hash del contenuto, così il browser può
+ *    tenerla in cache a lungo e ogni nuovo caricamento cambia URL.
+ */
+class Modelli3d
+{
+    public const CARTELLA_ORIGINALI = 'modelli-3d/originali';
+
+    public const CARTELLA_DRACO = 'modelli-3d/draco';
+
+    public function __construct(private CompressoreGlb $compressore) {}
+
+    /**
+     * Associa al modello il .glb in $sorgente: lo comprime e salva le due copie. Se il file non è
+     * valido lancia Modello3dNonValido senza toccare il modello né i file precedenti.
+     */
+    public function carica(Modello $modello, string $sorgente, ?string $nomeOriginale = null): void
+    {
+        $this->verificaGlb($sorgente);
+
+        $compresso = $this->comprimi($sorgente);
+
+        try {
+            $base = $this->nomeBase($modello);
+            $hash = substr(hash_file('sha256', $compresso), 0, 12);
+            $originale = self::CARTELLA_ORIGINALI."/{$base}-{$hash}.glb";
+            $draco = self::CARTELLA_DRACO."/{$base}-{$hash}.glb";
+
+            $this->scrivi('local', $originale, $sorgente);
+            $this->scrivi('public', $draco, $compresso);
+
+            $this->aggiorna($modello, [
+                'modello_3d' => $originale,
+                'modello_3d_draco' => $draco,
+                'modello_3d_nome' => $nomeOriginale ?: basename($sorgente),
+                'modello_3d_dimensione' => filesize($sorgente),
+                'modello_3d_draco_dimensione' => filesize($compresso),
+            ]);
+        } finally {
+            @unlink($compresso);
+        }
+    }
+
+    /** Rigenera la copia compressa dall'originale (es. dopo un cambio delle opzioni Draco). */
+    public function ricomprimi(Modello $modello): void
+    {
+        if (! $modello->modello_3d || ! Storage::disk('local')->exists($modello->modello_3d)) {
+            throw new Modello3dNonValido("Il modello {$modello->codice} non ha un originale da ricomprimere.");
+        }
+
+        $compresso = $this->comprimi(Storage::disk('local')->path($modello->modello_3d));
+
+        try {
+            $hash = substr(hash_file('sha256', $compresso), 0, 12);
+            $draco = self::CARTELLA_DRACO."/{$this->nomeBase($modello)}-{$hash}.glb";
+            $this->scrivi('public', $draco, $compresso);
+
+            $this->aggiorna($modello, [
+                'modello_3d_draco' => $draco,
+                'modello_3d_draco_dimensione' => filesize($compresso),
+            ]);
+        } finally {
+            @unlink($compresso);
+        }
+    }
+
+    /** Elimina i file del modello 3D (chiamato quando il modello viene cancellato). */
+    public function elimina(Modello $modello): void
+    {
+        $this->eliminaFile($modello->modello_3d, $modello->modello_3d_draco);
+    }
+
+    /** Controlla l'intestazione GLB (magic "glTF", versione 2) prima di avviare la compressione. */
+    public function verificaGlb(string $percorso): void
+    {
+        $intestazione = is_file($percorso) ? (string) file_get_contents($percorso, length: 12) : '';
+
+        if (strlen($intestazione) < 12 || substr($intestazione, 0, 4) !== 'glTF') {
+            throw new Modello3dNonValido('Il file non è un modello glTF binario (.glb).');
+        }
+
+        if (unpack('V', substr($intestazione, 4, 4))[1] !== 2) {
+            throw new Modello3dNonValido('Il file .glb deve essere in formato glTF 2.0.');
+        }
+    }
+
+    private function comprimi(string $sorgente): string
+    {
+        // tempnam crea il file: lo si sostituisce con uno con estensione .glb.
+        $temporaneo = tempnam(sys_get_temp_dir(), 'draco');
+        @unlink($temporaneo);
+        $destinazione = $temporaneo.'.glb';
+
+        try {
+            $this->compressore->comprimi($sorgente, $destinazione);
+        } catch (\Throwable $e) {
+            @unlink($destinazione);
+            throw $e;
+        }
+
+        return $destinazione;
+    }
+
+    /** Salva i nuovi percorsi ed elimina i file sostituiti. */
+    private function aggiorna(Modello $modello, array $valori): void
+    {
+        $vecchi = [$modello->modello_3d, $modello->modello_3d_draco];
+
+        $modello->forceFill($valori + ['modello_3d_aggiornato_at' => now()])->save();
+
+        $this->eliminaFile(...array_diff(array_filter($vecchi), [$modello->modello_3d, $modello->modello_3d_draco]));
+    }
+
+    private function eliminaFile(?string ...$percorsi): void
+    {
+        foreach (array_filter($percorsi) as $percorso) {
+            $disco = str_starts_with($percorso, self::CARTELLA_ORIGINALI) ? 'local' : 'public';
+            Storage::disk($disco)->delete($percorso);
+        }
+    }
+
+    private function scrivi(string $disco, string $percorso, string $file): void
+    {
+        $stream = fopen($file, 'rb');
+
+        try {
+            if (! Storage::disk($disco)->writeStream($percorso, $stream)) {
+                throw new Modello3dNonValido("Impossibile salvare il file {$percorso}.");
+            }
+        } finally {
+            if (is_resource($stream)) {
+                fclose($stream);
+            }
+        }
+    }
+
+    /** Es. "pvc/finestra_2_ante": sistema e codice del modello, per riconoscere i file a colpo d'occhio. */
+    private function nomeBase(Modello $modello): string
+    {
+        $sistema = Str::slug($modello->sistema?->codice ?? 'sistema');
+
+        return $sistema.'/'.Str::slug($modello->codice, '_');
+    }
+}
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Support\Configuratore;
+
+use RuntimeException;
+
+/** File .glb non leggibile o non comprimibile: il messaggio è mostrato all'utente del backoffice. */
+class Modello3dNonValido extends RuntimeException {}
@@ -0,0 +1,19 @@
+<?php
+
+return [
+    // Modelli 3D caricati dal backoffice (vedi App\Support\Configuratore\Modelli3d).
+    'modelli_3d' => [
+        // Dimensione massima del .glb non compresso caricabile (MB).
+        'max_mb' => (int) env('MODELLI_3D_MAX_MB', 200),
+
+        // La compressione Draco la fa uno script Node (le librerie Draco esistono solo in JS/C++).
+        // In produzione PHP-FPM spesso non ha Node nel PATH: indicare il percorso completo,
+        // es. NODE_BINARY=/opt/plesk/node/22/bin/node
+        'node' => env('NODE_BINARY', 'node'),
+
+        // Script di compressione; usa le dipendenze installate da build.sh nella root del repository.
+        'script' => env('MODELLI_3D_SCRIPT', base_path('../scripts/comprimi-glb.mjs')),
+
+        'timeout' => (int) env('MODELLI_3D_TIMEOUT', 300),
+    ],
+];
@@ -0,0 +1,21 @@
+<?php
+
+// Solo le chiavi personalizzate: il resto arriva dal config di Livewire (mergeConfigFrom è
+// superficiale, quindi il blocco temporary_file_upload va ripetuto per intero).
+return [
+    'temporary_file_upload' => [
+        'disk' => null,
+        // I modelli 3D (.glb) non compressi superano il limite predefinito di 12 MB: il limite
+        // del singolo campo resta quello impostato in Filament (maxSize).
+        'rules' => ['required', 'file', 'max:'.((int) env('MODELLI_3D_MAX_MB', 200) * 1024)],
+        'directory' => null,
+        'middleware' => null,
+        'preview_mimes' => [
+            'png', 'gif', 'bmp', 'svg', 'wav', 'mp4',
+            'mov', 'avi', 'wmv', 'mp3', 'm4a',
+            'jpg', 'jpeg', 'mpga', 'webp', 'wma',
+        ],
+        'max_upload_time' => 15,
+        'cleanup' => true,
+    ],
+];
@@ -0,0 +1,34 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * Modello 3D caricato dal backoffice: l'originale non compresso (disco privato, conservato per
+ * sviluppi futuri) e la copia compressa con Draco servita al configuratore (disco public).
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('modelli', function (Blueprint $table) {
+            $table->string('modello_3d')->nullable()->after('file_modello');
+            $table->string('modello_3d_draco')->nullable()->after('modello_3d');
+            $table->string('modello_3d_nome')->nullable()->after('modello_3d_draco');
+            $table->unsignedBigInteger('modello_3d_dimensione')->nullable()->after('modello_3d_nome');
+            $table->unsignedBigInteger('modello_3d_draco_dimensione')->nullable()->after('modello_3d_dimensione');
+            $table->timestamp('modello_3d_aggiornato_at')->nullable()->after('modello_3d_draco_dimensione');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('modelli', function (Blueprint $table) {
+            $table->dropColumn([
+                'modello_3d', 'modello_3d_draco', 'modello_3d_nome',
+                'modello_3d_dimensione', 'modello_3d_draco_dimensione', 'modello_3d_aggiornato_at',
+            ]);
+        });
+    }
+};
@@ -26,7 +26,7 @@ class CatalogoAdminTest extends TestCase

        Storage::fake('public');
        $this->seed(CatalogoSeeder::class);
-        $this->actingAs(User::factory()->create());
+        $this->actingAs(User::factory()->create(['is_superadmin' => true]));
    }

    public function test_le_pagine_admin_del_catalogo_si_aprono(): void
@@ -94,7 +94,7 @@ class CatalogoAdminTest extends TestCase
        Livewire::test(CreateModello::class)
            ->fillForm(['sistema_id' => $sistema, 'codice' => 'nuovo', 'nome' => 'Nuovo', 'attivo' => true])
            ->call('create')
-            ->assertHasFormErrors(['cartella' => 'required', 'file_modello' => 'required', 'categoria' => 'required']);
+            ->assertHasFormErrors(['cartella' => 'required', 'modello_3d_upload' => 'required', 'categoria' => 'required']);

        Livewire::test(CreateModello::class)
            ->fillForm(['sistema_id' => $sistema, 'codice' => 'finestra_1_anta', 'nome' => 'Doppione', 'attivo' => false])
@@ -53,6 +53,9 @@ class CatalogoApiTest extends TestCase
        // Senza listino il bilico non compare nel configuratore.
        Modello::where('codice', '!=', 'bilico')->each(fn (Modello $m) => ListinoPrezzo::create(['modello_id' => $m->id, 'larghezza' => 1000, 'altezza' => 1000, 'prezzo' => 100]));
        Sistema::create(['codice' => 'legno', 'nome' => 'Legno', 'attivo' => false]);
+        $this->conModelli3d();
+        // Senza modello 3D la finestra a 2 ante non compare nel configuratore.
+        Modello::where('codice', 'finestra_2_ante')->update(['modello_3d_draco' => null]);

        $response = $this->getJson('/api/sistemi')->assertOk();

@@ -60,12 +63,13 @@ class CatalogoApiTest extends TestCase
        $response->assertJsonPath('0.codice', 'pvc');

        $modelli = collect($response->json('0.modelli'));
-        $this->assertSame(25, $modelli->count());
+        $this->assertSame(24, $modelli->count());
        $this->assertNotContains('bilico', $modelli->pluck('id'));
+        $this->assertNotContains('finestra_2_ante', $modelli->pluck('id'));
        $this->assertSame('finestra_1_anta', $modelli->first()['id']);
        $this->assertNotContains('scorrevole_hst_4_ante', $modelli->pluck('id'));
        $this->assertStringEndsWith('/storage/modelli/icone/pvc/finestra_1_anta.jpg', $modelli->first()['icona']);
-        $this->assertSame('finestra_1_anta.glb', $modelli->first()['modello']);
+        $this->assertStringEndsWith('/api/media/modelli-3d/draco/test.glb', $modelli->first()['modello_url']);
    }

    public function test_configurazione_di_un_modello_senza_listino_restituisce_404(): void
@@ -37,7 +37,7 @@ class ConfiguratoreAdminTest extends TestCase

        Storage::fake('public');
        $this->seed([CatalogoSeeder::class, ConfiguratoreSeeder::class, ProfiliExtraSeeder::class, NuoveOpzioniSeeder::class]);
-        $this->actingAs(User::factory()->create());
+        $this->actingAs(User::factory()->create(['is_superadmin' => true]));
    }

    public function test_le_pagine_del_configuratore_si_aprono(): void
@@ -30,6 +30,7 @@ class ConfiguratorePrezzoTest extends TestCase

        Storage::fake('public');
        $this->seed([CatalogoSeeder::class, ConfiguratoreSeeder::class, ProfiliExtraSeeder::class, NuoveOpzioniSeeder::class]);
+        $this->conModelli3d();
    }

    /** Listino 1000-1400 x 1200-1400 mm: la cella 1200 x 1400 vale BASE. */
@@ -33,7 +33,7 @@ class ImportazioneListiniTest extends TestCase
        Storage::fake('public');
        $this->seed(CatalogoSeeder::class);
        $this->pvc = Sistema::where('codice', 'pvc')->firstOrFail();
-        $this->actingAs(User::factory()->create());
+        $this->actingAs(User::factory()->create(['is_superadmin' => true]));
    }

    /** Due tabelle nel formato del listino, separate da una riga vuota. */
@@ -220,6 +220,7 @@ class ImportazioneListiniTest extends TestCase
    {
        $finestra = Modello::where('codice', 'finestra_1_anta')->firstOrFail();
        ListinoImporter::importa($this->pvc, ListinoExcelParser::parseRighe($this->righe()), ['finestra_1_anta' => $finestra->id]);
+        $this->conModelli3d();

        $this->getJson('/api/sistemi/pvc/modelli/finestra_1_anta/listino')
            ->assertOk()
@@ -0,0 +1,186 @@
+<?php
+
+namespace Tests\Feature;
+
+use App\Filament\Resources\ModelloResource\Pages\EditModello;
+use App\Models\ListinoPrezzo;
+use App\Models\Modello;
+use App\Models\User;
+use App\Support\Configuratore\CompressoreGlb;
+use App\Support\Configuratore\Modelli3d;
+use Database\Seeders\CatalogoSeeder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Storage;
+use Livewire\Livewire;
+use Tests\TestCase;
+
+class Modelli3dTest extends TestCase
+{
+    use RefreshDatabase;
+
+    private Modello $finestra;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        Storage::fake('public');
+        Storage::fake('local');
+        $this->seed(CatalogoSeeder::class);
+        $this->actingAs(User::factory()->create(['is_superadmin' => true]));
+
+        $this->finestra = Modello::where('codice', 'finestra_1_anta')->firstOrFail();
+        ListinoPrezzo::create(['modello_id' => $this->finestra->id, 'larghezza' => 1000, 'altezza' => 1000, 'prezzo' => 100]);
+
+        // Niente Node nei test: la "compressione" tiene i primi 16 byte del file.
+        $this->app->instance(CompressoreGlb::class, new class extends CompressoreGlb
+        {
+            public function comprimi(string $sorgente, string $destinazione): void
+            {
+                file_put_contents($destinazione, substr(file_get_contents($sorgente), 0, 16));
+            }
+        });
+    }
+
+    /** Intestazione GLB valida (magic, versione 2, lunghezza) seguita da $corpo. */
+    private function glb(string $corpo = 'geometria di prova'): string
+    {
+        return 'glTF'.pack('V', 2).pack('V', 12 + strlen($corpo)).$corpo;
+    }
+
+    private function carica(UploadedFile $file)
+    {
+        return Livewire::test(EditModello::class, ['record' => $this->finestra->getRouteKey()])
+            ->fillForm(['modello_3d_upload' => $file])
+            ->call('save');
+    }
+
+    public function test_il_caricamento_salva_originale_e_copia_draco(): void
+    {
+        $this->carica(UploadedFile::fake()->createWithContent('finestra.glb', $this->glb()))
+            ->assertHasNoFormErrors();
+
+        $this->finestra->refresh();
+        $this->assertSame('finestra.glb', $this->finestra->modello_3d_nome);
+        $this->assertStringStartsWith('modelli-3d/originali/pvc/finestra_1_anta-', $this->finestra->modello_3d);
+        $this->assertStringStartsWith('modelli-3d/draco/pvc/finestra_1_anta-', $this->finestra->modello_3d_draco);
+        $this->assertSame($this->glb(), Storage::disk('local')->get($this->finestra->modello_3d));
+        $this->assertSame(substr($this->glb(), 0, 16), Storage::disk('public')->get($this->finestra->modello_3d_draco));
+        $this->assertSame(strlen($this->glb()), $this->finestra->modello_3d_dimensione);
+        $this->assertSame(16, $this->finestra->modello_3d_draco_dimensione);
+
+        // La scheda mostra il modello attuale con le dimensioni prima/dopo.
+        Livewire::test(EditModello::class, ['record' => $this->finestra->getRouteKey()])
+            ->assertOk()
+            ->assertSee('finestra.glb')
+            ->assertSee('con Draco')
+            ->assertSee('Sostituisci modello 3D')
+            // callFormComponentAction() cerca la chiave sotto "data.", che un Placeholder non ha.
+            // Senza modale, il mount esegue subito l'azione.
+            ->call('mountFormComponentAction', 'modello_3d_attuale', 'scarica_originale')
+            ->assertFileDownloaded('finestra.glb');
+
+        // L'originale non è sul disco pubblico.
+        Storage::disk('public')->assertMissing($this->finestra->modello_3d);
+
+        // Il configuratore riceve l'URL della copia Draco, servita con CORS e cache lunga.
+        $modello = collect($this->getJson('/api/sistemi')->json('0.modelli'))->firstWhere('id', 'finestra_1_anta');
+        $this->assertSame($this->finestra->modello_3d_url, $modello['modello_url']);
+
+        $this->get($modello['modello_url'])
+            ->assertOk()
+            ->assertHeader('Content-Type', 'model/gltf-binary')
+            ->assertHeader('Cache-Control', 'immutable, max-age=31536000, public');
+    }
+
+    public function test_un_file_non_glb_e_rifiutato_senza_toccare_il_modello(): void
+    {
+        $this->carica(UploadedFile::fake()->createWithContent('finestra.glb', 'non sono un glb'))
+            ->assertHasFormErrors(['modello_3d_upload']);
+
+        $this->assertNull($this->finestra->refresh()->modello_3d);
+        $this->assertEmpty(Storage::disk('local')->allFiles('modelli-3d'));
+    }
+
+    public function test_una_compressione_fallita_annulla_il_salvataggio(): void
+    {
+        $this->app->instance(CompressoreGlb::class, new class extends CompressoreGlb
+        {
+            public function comprimi(string $sorgente, string $destinazione): void
+            {
+                throw new \App\Support\Configuratore\Modello3dNonValido('Compressione Draco non riuscita: test.');
+            }
+        });
+
+        Livewire::test(EditModello::class, ['record' => $this->finestra->getRouteKey()])
+            ->fillForm(['nome' => 'Nome cambiato', 'modello_3d_upload' => UploadedFile::fake()->createWithContent('f.glb', $this->glb())])
+            ->call('save')
+            ->assertHasFormErrors(['modello_3d_upload']);
+
+        $this->finestra->refresh();
+        $this->assertNull($this->finestra->modello_3d);
+        $this->assertNotSame('Nome cambiato', $this->finestra->nome);
+    }
+
+    public function test_sostituzione_ed_eliminazione_rimuovono_i_file_precedenti(): void
+    {
+        $servizio = app(Modelli3d::class);
+        $sorgente = tempnam(sys_get_temp_dir(), 'glb');
+
+        file_put_contents($sorgente, $this->glb('primo'));
+        $servizio->carica($this->finestra, $sorgente);
+        [$originale, $draco] = [$this->finestra->modello_3d, $this->finestra->modello_3d_draco];
+
+        file_put_contents($sorgente, $this->glb('secondo, diverso nei primi byte'));
+        $servizio->carica($this->finestra, $sorgente);
+        unlink($sorgente);
+
+        Storage::disk('local')->assertMissing($originale);
+        Storage::disk('public')->assertMissing($draco);
+        Storage::disk('local')->assertExists($this->finestra->modello_3d);
+
+        $this->finestra->delete();
+        Storage::disk('local')->assertMissing($this->finestra->modello_3d);
+        Storage::disk('public')->assertMissing($this->finestra->modello_3d_draco);
+    }
+
+    public function test_senza_modello_3d_il_modello_non_e_nel_configuratore(): void
+    {
+        $this->getJson('/api/sistemi/pvc/modelli/finestra_1_anta/configurazione')->assertNotFound();
+    }
+
+    public function test_il_comando_importa_i_glb_del_configuratore(): void
+    {
+        $cartella = sys_get_temp_dir().'/modelli-'.uniqid();
+        File::ensureDirectoryExists("{$cartella}/pvc");
+        file_put_contents("{$cartella}/pvc/finestra_1_anta.glb", $this->glb());
+
+        $this->artisan('modelli3d:importa', ['cartella' => $cartella])->assertSuccessful();
+        File::deleteDirectory($cartella);
+
+        $this->finestra->refresh();
+        $this->assertSame('finestra_1_anta.glb', $this->finestra->modello_3d_nome);
+        Storage::disk('public')->assertExists($this->finestra->modello_3d_draco);
+    }
+
+    public function test_compressione_draco_reale_con_node(): void
+    {
+        $script = config('configuratore.modelli_3d.script');
+        $celino = base_path('../src/assets/models/pvc/celino.glb');
+        if (! is_dir(dirname($script, 2).'/node_modules/@gltf-transform/core') || ! is_file($celino)) {
+            $this->markTestSkipped('Dipendenze Node o modello di prova non installati.');
+        }
+
+        $this->app->forgetInstance(CompressoreGlb::class);
+        $this->app->offsetUnset(CompressoreGlb::class);
+
+        app(Modelli3d::class)->carica($this->finestra, $celino);
+
+        $draco = Storage::disk('public')->get($this->finestra->modello_3d_draco);
+        $this->assertStringStartsWith('glTF', $draco);
+        $this->assertStringContainsString('KHR_draco_mesh_compression', $draco);
+        $this->assertLessThan(filesize($celino), strlen($draco));
+    }
+}
@@ -2,9 +2,14 @@

 namespace Tests;

+use App\Models\Modello;
 use Illuminate\Foundation\Testing\TestCase as BaseTestCase;

 abstract class TestCase extends BaseTestCase
 {
-    //
+    /** Il configuratore mostra solo i modelli con il 3D caricato: ne assegna uno finto a tutti. */
+    protected function conModelli3d(): void
+    {
+        Modello::query()->whereNull('modello_3d_draco')->update(['modello_3d_draco' => 'modelli-3d/draco/test.glb']);
+    }
 }