Interrompo brevemente i post di tutorial per introdurre la nuova versione di DxFACE.
Nella procedura di rappresentazione del file TGA ho aggiunto un processo, invisibile all'utente, che seleziona le facce in base alle loro proporzioni in altezza e larghezza, e le ruota ponendole in orizzontale.
Questo passaggio predispone la nuova modalità di carica delle texture, che, dalle prossime versioni del programma, saranno riproporzionate.
In altre parole, una faccia quadrata continuerà ad utilizzare la texture quadra come da template corrente, mentre una faccia allungata richiederà l'impostazione di una texture più ampia (secondo il futuro nuovo template).
Questo accorgimento porterà a una minore deformazione delle texture, con un apprezzabile miglioramento della grafica.

Update Vers.18
Implementato il riconoscimento di facce con lati allungati in proporzione maggiore del 50%, che generano la moltiplicazione automatica proporzionata da 2 a 6 volte della faccia di mesh e la relativa carica delle texture affiancate, (vedi numerazione multipla).
Sei volte è il massimo ottenibile nella mesh Sculpty, essendo l'ultima colonna inutilizzata nella modalità piana, e la prima da escludere per impossibilità a gestire lo smoothing sul primo lato.
Nel template viene introdotta un secondo bordo di cornice grigia, a definizione dell'area destinata a ricevere i pixel o le texture che andranno ad inerire con quelli della faccia per generare lo smoothing dei bordi. Se pixel e texture della cornice saranno gli stessi della faccia, lo smoothing non sarà quindi aapparentemente applicato, e i bordi della faccia appariranno netti. Nell'immagine, qui sopra, ove il contenuto della cornice grigia è costituito dai pixel neri del template, è invece di conseguenza visibile un bordino perimetrale nero sfumato su ogni faccia

Update vers.19a
Migliorie all'engine e nuova versione 0.0.2 del Plugin per SketchUp.

Ora convertiamo il primo oggetto in una Sculpty.
In Google SketchUp il disegno è finito, accertiamoci che effettivamente saranno salvate 32 facce e che quindi l'oggetto sia valido, altrimenti dovremo modificarlo.
(Menu File ---> "Valid 3DFACEs Count")

Now we convert the first object into a Sculpty. The SketchUp drawing is finished and we must ensure that 32 faces will saved and then the object is valid, otherwise we will have to change it.
(File Menu ---> "Valid 3Dfaces Count").

Nel Menu File scegliamo "Export to DxFACE" e diamogli un nome. A file salvato riceveremo la notifica di validità (Ready). E' comunque consigliabile mantenere SketchUp sempre aperto sul modello, in modo da poter intervenire facilmente con variazioni se non dovesse poi piacerci nel file TGA compilato.

In the File Menu we choose "Export to DxFACE" and we give it a name. We will receive the notification of validity (Ready). It is always advisable to keep SketchUp running, so you can easily edit the object if you do not like the shape compiled as TGA file.

Ora apriamo l'eseguibile DxFACE.exe e carichiamo il file DXF tramite il tasto "Open DXF". Il file viene convertito immediatamente. Se ricevessimo la notifica (Fixed), che vediamo qui sotto, non preoccupiamoci. Significa che l'oggetto disegnato con SketchUp aveva dimensioni maggiori di quanto consentito per le Sculpties di SL, e il programma ha effettuato anche un resize, portandolo alla giusta scala e sfruttando al meglio il range dimensionale consentito. Significa quindi che stiamo per creare la Sculpty alla miglior risoluzione possibile.

Now we run the executable DxFACE.exe and we have to load the DXF file via button "Open DXF". The file is converted immediately. If we receive notification (Fixed, see below), do not worry. It means that the object was drawn with SketchUp larger than allowed by Sculpty shapes, and the program has also made a resize, bringing the drawing to the right scale and making the best possible size range. Therefore it means that the Sculpty will created at the best possible resolution.

Dopo l'installazione del Plugin per Google SketchUp apriamo il programma per verificare se tutto è andato a buon fine. Al Menu Plugins dovremmo trovare una info di questo genere (vedi immagine qui sotto). Cliccando sul menu dovrebbe aprirsi una finestra informativa con il numero di versione installata.

After installing the SketchUp Plugin run the program to check it. The Plugins Menu now has a command that opens an information box about the plugin's version.

Nel Menu File dovrebbe comparire la nuova voce "Valid 3DFACEs Count". Esegue il conteggio delle facce che potranno essere utilizzate dalla Sculpty. Ci sarà utile per sapere in qualunque momento quando il nostro oggetto, che dovrà avere 32 facce, sarà pronto per essere esportato. In un cubo le facce saranno ovviamente 6, o 5, se per "risparmiare", avremo cancellato la faccia nascosta alla base. Ma in presenza di fori delle superficie o di forme complesse non sarà più possibile valutare visivamente il numero delle spezzettature dei poligoni, e per conoscerlo dovremo affidarci a questa utilità.

The File Menu has now the item "Valid 3DFACEs Count". This command calculates how many faces will be used in the Sculpty. It is useful to know at any time when our object, which will have 32 faces, will be ready to be exported. The faces of a cube are of course 6, or 5, if economising we erased the hidden bottom. But in the presence of surface holes or complex shapes you can not visually assess the number of polygons, and we will to need this utility.

Sempre nel Menu File avremo poi il comando "Export to DxFACE", da usare a lavoro ultimato per esportare il file DXF con cui compilare la Sculpty .

"Export in DxFACE" of File Menu exports the DXF file required to compile the Sculpty when the drawing is done.

Riprendo a pubblicare anche su questo blog per dedicarlo interamente alla grafica, fino ad ora ospitata insieme ad altre cose sul mio blog principale imitidicthulhu.
Questo primo post della nuova serie si riferisce all'ultimo tool a cui sto lavorando: DxFACE, dedicato all'importazione in Second Life di oggetti tridimensionali, creati con qualsiasi installazione CAD o con SketchUp, il famoso programma free di modellazione di Google.

DxFACE è scaricabile qui.
Nei prossimi post ne illustrerò caratteristiche, potenzialità e metodi d'uso.
Per ora ricordo che il programma nasce integrandosi con il mio piccolo viewer tridimensionale 3DLite, scaricabile qui, dalla mia pagina per SecondTGA.

DxFACE è capace di interpretare fino a 32 facce tridimensionali, leggendole da file DXF. Nel pacchetto troverete il plugin DxFACE.rb, tramite il quale Google SketchUp, nella versione free, sarà abilitato a salvare i vostri modelli nel formato DXF occorrente, tipico dei programmi CAD.
Il plugin DxFACE.rb dovrà essere estratto e spostato dalla cartella di DxFACE.
Il suo posto sarà nella cartella Plugins di SketchUp, normalmente collocata in C:\Programmi\Google\Google SketchUp 6\

Qui sotto l'esempio di Sculpty unica, realizzata al volo con 32 facce in formato DXF, e salvata per Second Life. La texture caricata sulle facce è fornita nel pacchetto come BMP, ed è un template utile a differenziare le facce, con numeri e colori, per la fase di editazione delle bitmap di skin.

DxFACE is a free importer for three-dimensional objects in Second Life, created with any CAD installation or in SketchUp, the popular free modeling program from Google. DxFACE can be downloaded here. In the next posts I will explain the characteristics, potentials and methods of use. For now remember that the program is allowed to use my small three-dimensional viewer 3DLite, downloadable here by my page for SecondTGA. DxFACE is capable of interpreting three-dimensional faces up to 32, reading from DXF files. In the package you will find the plugin DxFACE.rb, written for Google SketchUp 6 free version, that enables to save your models in the DXF format required. You have to extract the DxFACE.rb plugin and to move it from the DxFACE folder to the SketchUp Plugins folder, usually located in C:\Program Files\Google\Google SketchUp 6\. Below the example of a single Sculpty, created with 32 faces into the required DXF format, and saved in TGA for Second Life. The texture loaded on the faces is provided in the DxFACE's package, such as BMP, and it is a useful template to differentiate faces, numbers and colors while you have to edit the skin for the Sculpty.

Nella precedente parte (2) di Primi passi sul 3D di Second Life abbiammo visto come un file targa (tga), grafico, venga utilizzato come veicolo di vettori tridimensionali.
L'esempio di file che avevo generato riempiva la matrice sempre e soltanto con la medesima coordinata, essendo anche il mio primo test di scrittura per file tga.
Ora vediamo di migliorarlo, per renderci meglio conto di come le coordinate x,y,z devono essere trascritte allo scopo di funzionare poi su SL.
Si è detto che il file tga deve contenere una matrice di punti (pixel) di 64 elementi per lato, ovvero 64 x 64 in totale, che formano una sorta di rete quadrata. In questa griglia ho inserito nuove coordinate, "stirando" i punti sull'ascissa X, in modo che si distribuiscano formando un rombo. Questo rombo sarà un aquilone, il primo semplicissimo oggetto che importeremo in Second Life.

Qui sopra vediamo il file tga generato.
La routine di scrittura del nuovo file eccola qua; la trascrivo per completezza ma non è necessario comprenderla a fondo per seguire il ragionamento generale: era utile a me per generare i punti dell'aquilone senza calcolarli a mano uno per uno. Piccola annotazione: i programmi orientati al 3D DEVONO fare uso del floating point durante i calcoli, anche se potrà succedere che in ultimo vadano a generare files contenenti solo numeri interi, come nel nostro caso. Qui ho dichiarato indistintamente TUTTE le variabili in doppia precisione solo per praticità, lo so che non tutte ne hanno necessità. Il tempo richiesto nella compilazione del file targa è brevissimo, e una volta tanto non perdo tempo ad ottimizzare.

SUB FaceWrite
TGAfile.Open("Aquilone.tga",65535)
TGAfile.WriteUDT(MyTGA)
DIM U As Double, V As Double, Inc As Double
DIM Stretch As Double, Ptr As Double, MapStep As Double
FOR V=0 TO 31 'write Tz, Tx, Ty
Inc=Inc+4
MapStep=V/16
Ptr=V*2
Ptr=64-Ptr
FOR U=0 to 63
Stretch=MapStep*U
TGAfile.WriteBinStr(chr$(Inc)+chr$(Ptr+Stretch)+chr$(0),3)
NEXT
NEXT
FOR V=31 TO 0 step -1 'write Tz, Tx, Ty
Inc=Inc+2
MapStep=V/16
Ptr=V*2
Ptr=64-Ptr
FOR U=0 to 63
Stretch=MapStep*U
TGAfile.WriteBinStr(chr$(Inc)+chr$(Ptr + Stretch)+chr$(0),3)
NEXT
NEXT
TGAfile.Close
END SUB
[source updated 25-6]

Ora non resta che uplodare la figura in Second Life (beh si paga ma non certo a me, lol, Second Life costa 10 Linden Dollars per upload). Dopo l'upolad la procedura è semplice.

Crea ----> Un cubo, per esempio
Edit ----> Da cubo a Sculpted Prim
e poi, via via, dimensioni, colore, posizionamento etc etc

Ma questo non è oggetto del mio studio.
Proseguirò con la carica di una bitmap decorativa sull'aquilone, ma alla prossima.
[continua]

PS: chi vuole testarlo su Second Life può scaricare il file tga qui

Abbiamo visto nella parte (01) di Primi passi sul 3D di Second Life come le Sculpted Prims accettino i file di tipo TGA come descrittori di forme, e ne abbiamo visto la struttura.
Dal momento che i file TGA che dovremo inviare a Second Life non sono comuni file grafici, ma contengono in realtà le coordinate x,y,z delle forme, se vorremo generarli dovremo disporre di un parser, un programma che si incarichi di leggere una forma e di compilarla con i vettori distribuiti così come richiesto dal file TGA.

Il codice che segue è il minimo che occorra per generare un file TGA.
L'header, che abbiamo già precedentente analizzato, è inserito in una struct prima di essere scritto nel file. Una struct ci permetterà facilmente di apportare modifiche nel caso volessimo riutilizzare il codice anche per altre applicazioni che non siano Second Life, alle quali questo tipo di header potrebbe non bastare.
Questa è una buona regola da seguire sempre. Mai buttare giù due righe "che fungano" e basta, ma scriverle sempre nel modo più corretto, completo e versatile per usi futuri. La riusabilità del codice è importantissima perchè ottimizza il lavoro.
Dopo l'header, per ora, mi sono accontentato di disegnare una campitura uniforme di grigio, ma, per testare la correttezza del codice e verificarlo, ho posizionato un pixel bianco al centro (o meglio alla 32esima riga di pixel delle 64 righieste).
Ecco il codice. E' scritto nel mio linguaggio preferito, RapidQ, un basic-like semplice rapido e versatile, ma si può adattare facilmente a tutti i linguaggi.
Non ci sono commenti nel codice, è abbastanza autoesplicante e potrebbe essere studiato e capito anche da una new-entry della programmazione.

$TYPECHECK ON
DefStr Title : Title="TGAwriter"
DefStr CopyR : CopyR="©07 Soldatino"
DefStr Versn : Versn=" 01.00"
Application.Title=Title

TYPE TGA
identsize As String * 1
colourmaptype As String * 1
imagetype As String * 1
colourmapstart As Short
colourmaplength As Short
colourmapbits As String * 1
xstart As Short
ystart As Short
width As Short
height As Short
bits As String * 1
descriptor As String * 1
END TYPE

DIM MyTGA As TGA, N% As Long

MyTGA.identsize=Chr$(0)
MyTGA.colourmaptype=Chr$(0)
MyTGA.imagetype=Chr$(&h2)
MyTGA.colourmapstart=0
MyTGA.colourmaplength=0
MyTGA.colourmapbits=Chr$(&h20)
MyTGA.xstart=0
MyTGA.ystart=0
MyTGA.width=Chr$(&h40)
MyTGA.height=Chr$(&h40)
MyTGA.bits=Chr$(&h18)
MyTGA.descriptor=Chr$(0)

DIM TGAfile AS QFileStream
Declare SUB FileWrite

SUB FileWrite
TGAfile.Open("PrimoTGA.tga",65535)
TGAfile.WriteUDT(MyTGA)
FOR N%=0 TO 2047
TGAfile.WriteBinStr("mmm",3)
NEXT
TGAfile.WriteBinStr(chr$(&hff)+chr$(&hff)+chr$(&hff),3)
FOR N%=0 TO 2046
TGAfile.WriteBinStr("mmm",3)
NEXT
TGAfile.Close
END SUB

Create Form As QForm
Caption=Title+" "+Versn+" "+CopyR
Create Button As QButton
Caption="OkTGA"
OnClick=FileWrite
END CREATE
END CREATE

Form.ShowModal

Qui sopra vediamo l'immagine generata, l'ho convertita in gif per evitare problemi coi browser. A proposito, mi scuso perchè il codice non è indentato, come invece è assolutamente consigliabile fare. Purtroppo l'editor di blogger fa del suo meglio per creare problemi, e si mangia le spaziature. Anche ricorrendo ai codici spazio html, noiosi da inserire, alla prima riedizione del testo li fa svanire. Poi si dice di web2, web3, usabilità, camp e twitter e cazzi e stramazzi vari. Non fatemi parlare per favore. Qui sul web serve ancora l'asilo.

[ continua ]

Premessa
Riprendo questo blog sperimentale per postare passo a passo quanto sto iniziando ad apprendere circa la codifica delle interfacce al database degli oggetti tridimensionali di Second Life.
Lo studio sarà svolto in modo pedestre (deve essermi utile come pro memoria ai fini della programmazione), e sarà costituito da una serie di appunti sviluppati in sequenza, man mano che procedo nell'approfondimento.
Altri aspetti non squisitamente tecnici saranno invece eventualmente svolti sul mio blog primario http://imitidicthulhu.blogspot.com/
Non ho pretese didattiche, ma se ci saranno quesiti ove possibile sarò lieto di rispondere.

1) Le Sculpted Prims
Recentemente Second Life ha implementato nel suo engine 3D le Sculpted Prims.
Le Prims sono mappe codificate come un insieme di punti nello spazio alle coordinate x, y e z.
In pratica si tratta di Mesh (reti), così come abitualmente chiamate nella programmazione 3D. L'introduzione delle Prims apre interessanti sviluppi alla creazione degli oggetti del mondo virtuale di SL. Proviamo infatti ad immaginare la maggior ricchezza di dettaglio e la complessità di un oggetto rappresentato su una singola matrice, o array tridimensionale, rispetto a quanto si può creare, pur utilizzando una gran quantità di primitive (piano, sfera, cubo), sommate, sottratte, scalate e deformate lungo certi assi.

2) La codifica TGA
Per rappresentare le immagini bidimensionali Second Life utilizza il formato grafico TGA, sia per le textures che per altre immagini. Il file TGA (senza soffermarcisi troppo) è un formato grafico simile al bmp, ma più versatile. Può essere di tipo compresso o descrittivo, a vari piani di profondità di colore e così via. I pixel vengono rappresentati in codifica RGB inversa, ovvero, per ogni pixel avremo i valori Blue, Green e Red del colore rappresentato, che, relativamente alla descrizione di una immagine, andranno a costituire un array.
Ma ecco qui la pensata dei programmatori di Second Life.
Vista la somiglianza degli array tridimensionali (x,y,z) con quelli di colore (r,g,b), hanno avuto un'idea per niente sciocca. Invece di inventarsi un nuovo formato di file per la codifica degli array vettoriali tridimensionali, hanno pensato bene di utilizzare la struttura e il formato del file TGA.
Ecco allora che, per rappresentare un oggetto, dovremo passare i dati della rete che lo rappresenta con un comune file TGA.
C'è però da dire che il file di tipo TGA, come accennato prima, possiede una certa varietà di sottoformati. Quindi, piuttosto che spendere tempo in ricerche sulla letteratura da poco già sviluppata sull'argomento, un po' caotica, con continui rimandi e in sostanza orientata all'utente piuttosto che al programmatore, sono andato a investigare il formato che Second Life utilizza, facendogli salvare un'immagine in formato 64 x 64 pixel, quello richiesto dalle Sculpted Prims.

3) Il TGA di Second Life
Header = 18 bytes
Contiene vari elementi informativi, ma possiamo trascurarli, per ora, perchè saranno sempre gli stessi: 64 x 64, origine a zero, colore a 24 bit (ossia distribuito sui 3 bytes b,g,r)
Descrizione dell'immagine = 12.288 bytes
Corrispondono a 64 linee (a partire dall'ultima in basso a risalire) di 64 pixel da sinistra a destra cadauna, resi a 24 bit, quindi da 3 bytes ciascuno.
Totale lunghezza del file = fissa a 12.306 bytes.

[alla prossima]