3ds Max A Proposito Di Facce E Vertici...

[Michele71 2504]

Ciao a tutti.

Eccomi di nuovo con una domanda banale ma non tanto.

Leggendo la discussione "Assegnare Ad Una Faccia Di Una Editablepoly Una Texture", mi è venuta la curiosità di creare una piccola utility da usare nell'aggiornamento (in corso) del mio script "Virtual GI". Essa riguarda la conoscenza in tempo reale di quante luci andranno a posizionarsi sui vertici della sfera di base durante la creazione e il loro "peso" in megabyte.

Ora prendendo spunto dal tread citato sopra (interessantissimo) ho creato questo piccolo script che mi permette di conoscre i vertici di un oggetto POLY o MESH:

rollout t "Test"

(

listbox li "" items:(for o in objects collect o.name)

label l ""

on li selected nameIndex do

(

select (getNodeByName li.items[nameIndex])

Obj = selection[1]

for i=1 to obj.numVerts do

(

l.text = ( "Numb Verts = " + obj.numVerts as string)

)

)

)

createdialog t

Il problema è:

Come posso conoscere i vertici durante la creazione di un oggetto ancora NON modificato in Poly o Mesh?

Esso deve essere simile (se non uguale) alla "Show Statistics (7)" della finestra di lavoro in Max. Dato che non ho trovato nulla di simile nell'help di MaxScript

Come posso pesare la memoria di una o più luci?

Se avete provato il mio script "Virtual GI v.03b", noterete che durante la creazione della sfera di riferimento per la costruzione delle luci sui vertici, essi vengono espressi in Segmenti e NON in quantita di vertici presenti. Quello che provo a fare è secondo quanti segmenti inserisco nella scena, io conosco quante luci vengono posizionate sopra i vertici e quanto pesa il tutto.

Spero in un vostro aiuto!

Un abbraccio a tutti da Michele

[johnwhile 2]

sinceramente non capisco cosa tu voglia fare ma comunque una soluzione per utilizzare comunque l'opzione .numVerts anche se non è un oggetto editablemesh potrebbe essere creare un oggetto temporaneo non visibile.

PS: perchè hai messo un ciclo for per scrivere nel label N volte il numero N di vertici ?

rollout test "Test"

(

	listbox li "list" pos:[8,8] width:160 height:12 items:(for obj in geometry collect obj.name)

	label l "label" pos:[8,192] width:160 height:16


	on li selected idx do

	(

		obj = getNodeByName li.items[idx]

		theMesh = snapshotasmesh obj

		l.text ="Num Verts = " + theMesh.numVerts as string

		delete theMesh

	)

)CreateDialog test 176 216[/php]

[coren 15]

se ti interessano solo i vertici puoi usare anche 'getPolygonCount <node>' che ti restituisce il numero di poligoni ed il numero id vertici.

per il discorso di quello che vuoi fare non ho capito molto bene...

Devi calcolare il peso in memoria durante il render? il peso in memoria sull'harddisk una volta che salvi il file?

Sinceramente non so se è possibile fare queste cose.

Se usi come tipo di ombra la shadow map al limite puoi sommare le dimensioni delle varie shadowmap e quindi calcolare molto approssimativamente la memoria usata per le ombre.. ma non so quanto potrebbe essere veritiera la cosa.

Magari posta qualche esempio.

fammi sapere

ciao

[Michele71 2504]

PS: perchè hai messo un ciclo for per scrivere nel label N volte il numero N di vertici ?

E' stato un residuo del mio script in fase di studio... In realtà non riuscivo a capire come calcolare il totale dei vertici (o facce) di un oggetto e mi è sembrato un "compromesso" allora, invece di utilizzare print per visualizzare il risultato nel Listener ho utilizzato un loop che mi contasse tutti i vertici e li scrivesse in un Label...

Comunque, grazie johnwhile per il suggerimento (giusto) che mi hai dato. Non ho mimimamente pensato di utilizzare "snapshotasmesh" per il mio scopo. ed è sicuramente molto più lineare.

Vale anche DURANTE la cosrtruzione di un oggetto? (Label che scrive i vertici in tempo reale durante la costruzione (nel mio caso) di una sfera)

[Michele71 2504]

...per il discorso di quello che vuoi fare non ho capito molto bene...

Devi calcolare il peso in memoria durante il render?

Si, in realtà vorrei sapere se c'è un modo di sapere quanto pesa una luce (o più luci) in termini di megabyte preventivamente durante la fase di Rendering.

Una luce quanta memoria costa?

E più luci?

Questo per visualizzare in tempo reale la quantità necessaria di memoria da utilizzare per l'illuminazione di una scena. Spero di essermi spiegato.

Grazie per il suggerimento (getPolygonCount). Ragazzi, da autodidatta è tutto più difficile...

[johnwhile 2]

non conosco niente di grafica 3d ma credo non si tratti di memoria utilizzata ma di tempo impiegato per il calcolo di tutti i raggi luminosi, anche perchè durante il rendering max ti dice quanta memoria utilizza e ho notato che è sempre la stessa.

Se utilizzi lo stesso numero di luci il tempo che impiega è dovuto a certi paramentri come definizione dell'ombra, effetto skylight (effetto ambiente), quantità di raggi luminosi ecc... tutte cose che non hanno relazione con la Ram utilizzata ma con la velocità del processore.

Forse la cosa che si avvicina di più a quello che vuoi dire tu è il calcolo di quanto tempo più o meno completa il rendering, in effetti max te lo dice più o meno una proiezione del tempo che impiegherà quando devi fare i video ma è una stima che fà vedendo quanto tempo impiega a fotogramma e moltiplicandolo per i fotogrammi totali.

Modificato May 20, 2010 da johnwhile

[Michele71 2504]

...ma credo non si tratti di memoria utilizzata ma di tempo impiegato per il calcolo di tutti i raggi luminosi, anche perchè durante il rendering max ti dice quanta memoria utilizza e ho notato che è sempre la stessa...

Humm...Effettivamente ho notato anche io questa cosa... In effetti il tempo di rendering aumenta con i parametri delle luci impostati in differenti modi, ma io pensavo che le luci base (senza alcuna modifica) abbiano, per cosi dire, un "peso specifico" in termini di mb.

Sto facendo delle ricerche sul web per vedere se avallare questa mia ipotesi.

Grazie johnwhile per la tua gentilezza e partecipazione alle mie discussioni sul tema MaxScript!

[Michele71 2504]

Scusatemi per il doppio post, ma sul mio sito di riferimento a riguardo MaxScript (ScriptSpot) ho trovato qualcosa di interessante

Infatti come affermava johnwhile nell'ultima risposta, è possibile calcolare la memoria utilizzata dai campioni delle ombre delle luci.

Riferendomi allo script "E-lights" di Alexandre OLIVEIRA (basato sul codice originario di E-light 1.02 da Ronnie Olsthoorn) ho trovato questa interessante funzione:

-----------------------------------------------------

fn FnTotalNumberOfLights =

(

if GeosphereHemisphereChecked then

(

LightsCount = ((20 * GeosphereSegmentsValue^2 + 5 * GeosphereSegmentsValue + 1.00)/LightsStepValue)

LightsCount += 0.99

)

else

(

LightsCount = ((10 * GeosphereSegmentsValue^2 + 2.00)/LightsStepValue)

LightsCount += 0.99

)

LightsMemory = (LightsCount * 4.0 * LightsMapsizeValue^2 / 1024000) + 0.5

)

--"Total memory required for shadows:" + (LightsCount*4*LightsMapsizeValue^2/1024000 as string)------------------------------------------------

Come dicevo, questa funzione permette di rilevare quante luci sono presenti nella scena e SOPRATUTTO il "peso" o la memoria utilizzata per le ombre

Cosa ne pensate?

Si può fare di meglio?

[johnwhile 2]

ho la vaga senzazione che lui abbia preso soltanto una serie di "campioni", abbia fatto partire il rendering e per ogniuno abbia preso nota della "quantità di memoria" o qualsiasi cosa intenda con "memory used".

Se noti l'equazione "20 * GeosphereSegmentsValue^2 + 5 * GeosphereSegmentsValue + 1.00" è tipo esponenziale (ax²+bx+c) come nel caso di else. Suppongo fortemente che sia una stima fatta su varie prove (quanto scommetti che l'ha fatta con excel ?), quindi dipende totalmente dal proprio pc, non ha nessuna utilità pratica, se ad esempio cambi qualcosa o adirittura usi magari un plugin per fare il rendering con algoritmi diversi allora cambia tutto.

L'unica cosa che puoi dedurre è che la "memoria" aumenta circa di 20 o 10 * GeosphereSegmentsValue al quadrato, quindi sale moltissimo.

Poi quel 1024000 penso abbia voluto convertirlo che ne sò, in Mb da byte ? che poi sarebbe 1024*1024 non 1024000, comunque non ho idea di come ha fatto, non c'è un ciclo for o while, forse ha fatto un ciclo alla funzione dato che il contatore si trova all'interno della funzione (LightsCount += 0.99).

Secondo me puoi cestinare questa cosa, oppure ci posti il link di dove hai trovato questa cosa così vediamo se ha scritto qualche spiegazione.

Modificato May 21, 2010 da johnwhile

[Michele71 2504]

Quindi secondo il tuo parere johnwhile, non c'è un modo sicuro di calcolare questi valori (oltre a sapere il numero delle luci presenti sopra ogni vertice)?

[johnwhile 2]

Non sono un esperto di grafica, anzi io utilizzo Max e MaxScript solo per lavorare con poligoni, so però che i "grafici" utilizzano spesso una semisfera di geosphere e ci mettono le luci in ciascun vertice per simulare l'effetto reale dell'ambiente, forse dovresti chiedere a loro, in questo sito ho visto da alcuni render che c'è gente molto esperta.

Quindi suppongo che Alexandre abbia solo fatto una stima variando la quantità di vertici e quindi di luci della semisfera per vedere come aumenta la pesantezza di colcolo ( io non parlerei di memoria, la CPU e Ram sono due cose diverse ) è giustamente ha notato che aumenta in maniera esponenziale.

Poi non capisco a cosa serve sapere questo, tanto tu non fai il rendering in base al tempo che ci impiega ma in base al risultato che vuoi ottentere, sia se comporta ore che minuti...

Quasi sempre io ad esempio preferisco non mettere skylight o il plugin "AdvanceLight" (tutte cose presenti in max) durante il rendering ma vario un pò l'effetto ambiente e altre cosuccie che mi fanno ottentere un risultato simile ma con notevole risparmi di tempo (Per quello che devo fare io, chi fà rendering avanzati è costretto ad usare tutto)

Modificato May 21, 2010 da johnwhile

[sefiroths 3]

....penso che johnwhile abbia ragione. ti faccio un esempio che mi è capitato con autocad, non so se c'entri del tutto ma è interessante:

un file autocad di 500 Kbyte che contiene solo polyline rettangolari inchioda del tutto autocad, la visualizza ma va a scatti...provato sulla mia pelle.

puoi fare questa prova: è verosimile che un file costituito da una sola luce occupi in memoria quanto sul disco fisso (la luce la immagino come una struttura con determinati parametri), quindi potremmo dedurre quanto occupa una luce. attenzione però, luci copie, non instance perchè condividono parametri facendo risparmiare memoria. ho fatto questa con luci omni senza cambiare parametri...prova che sembra avvalorare la mia tesi:

1) 1 file vuoto di max occupa 160Kb

2) 1 file con una luce omni occupa 164Kb

3) 1 file con 2luci omni occupa 168Kb

4) 1 file con 3 luci omni occupa 172Kb

5) 1 file con 3 luci omni di cui una con parametri cambiati a caso occupa 172Kb

da quì posso dedurre che una luce occupi 4Kb indipendentemente dai parametri, ciò vuol dire che max salva tutto su disco, anche parametri non di default, e fra reali e interi dei parametri 4K mi sembra accettabile

per le ombre poi se ne parla...bisogna vedere l'equazione che usa e quanti giri fa' per calcolarsela...

Modificato May 21, 2010 da sefiroths

[Michele71 2504]

Si sefiroths, in effetti il tuo ragionamento sembra filare liscio. Io non ho pensato di fare una prova del genere ma è molto interessante il tuo ragionamento.

Comunque, la mia curiosità era solamente per creare un piccolo tool di visualizzazione in tempo reale (per le luci ci siamo) quando creiamo delle luci sui vertici della sfera. Pensavo che era possibile, ma le variabili sono moooltissime

Grazie per le vostre delucidazioni!

[johnwhile 2]

A Proposito Di Facce E Vertici.... a me servirebbe una cosa un pò speciale:

Devo creare una mesh temporanea che è l'unione di un gruppo di oggetti presenti nella scena.

So che per unire due mesh basta fare "+" e per creare un oggetto temporaneo si può usare snapshotasmesh.

Io vorrei un oggetto temporaneo semplice, solo facce,vertici e coordinate uvw, non mi interessano tutte le proprietà di Editable_Mesh.

L'idea è questa ma l'operatore somma non và:

theMesh = triMesh

for i=1 to geometry.count do theMesh = theMesh + geometry[i]

delete theMesh[/php]

[johnwhile 2]

Mi correggo, l'operatore unione non và bene, mi crea delle cose impreviste e mi modifica l'oggetto:

theMesh = copy geometry[1] for i=2 to (geometry.count-1) do ( 	theMesh + geometry[i] )

[johnwhile 2]

Questa cosa invece funziona (mi tocca creare tutti quei copy e una lista temporanea) solo che mi sembra appesantisca la scena e la velocità dello script... forse con undo off ma non so...

MeshArray = for obj in geometry collect obj

theMesh = convertToMesh (copy MeshArray[1])

for i=2 to MeshArray.count do

(

	attach theMesh (copy MeshArray[i])

)

[coren 15]

oltre all'undo off usa anche 'disableRedraw' e 'suspendEditing'

Ricorda a fine script di riabilitarli entrambi e tieni presente che se lo script durante l'esecuzione dà errore poi ti ritroverai con le viewport che non rispondono e il command panel che non si aggiorna,però ti basta riabilitare il tutto dal listener e sei a posto.

Si potrebbe usare il try catch, solo che anche quello rallenta l'esecuzione dello script.

ma se ti serve memorizzare solo vertici, facce e uvw perchè non crearti una struct apposita?

l'unica cosa che devi tenere presente quando unisci le varie informazioni è di modificare gli indici delle facce e delle facce degli uvw.

ciao

[johnwhile 2]

oltre all'undo off usa anche 'disableRedraw' e 'suspendEditing'

Ricorda a fine script di riabilitarli entrambi e tieni presente che se lo script durante l'esecuzione dà errore poi ti ritroverai con le viewport che non rispondono e il command panel che non si aggiorna,però ti basta riabilitare il tutto dal listener e sei a posto.

Si potrebbe usare il try catch, solo che anche quello rallenta l'esecuzione dello script.

ma se ti serve memorizzare solo vertici, facce e uvw perchè non crearti una struct apposita?

l'unica cosa che devi tenere presente quando unisci le varie informazioni è di modificare gli indici delle facce e delle facce degli uvw.

ciao

Nion posso permettermi che un utente alle prime armi con lo script si ritrovi un programma "disabilitato" nel caso vada in errore, cosa che sarà molto frequente.

Per l'unione degli oggetti in realtà è un tentativo (ne ho fatti a milioni) per capire come il gioco comprime la lista vertici, qualcosa sono riuscito a fare solo che è molto lento.

Quello che suppongo faccia il gioco è prendere un numero di oggetti predefiniti (cioè definisco io quali e quanti sono), Poi crea una lista di facce per ogni oggetto, una lista vertici unica, e una lista uv unica.

Praticamente alla lista vertici vengono aggiunti solo un vertice che ha in comunune con altri vertici stesse coordinate uv e stesse coordinate 3d, perchè sarebbe una ripetizione, ma questo comporta un riarrangiamento degli indici delle facce.

Se vuoi ti dò lo script con solo l'alghoritmo, il file .max con gli oggetti dentro, e il risultato secondo il gioco.