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
@@ -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 {}