dubbio! x-box VS play2



Non mi concedi neppure di dormire!




O forse perche' ridevo troppo mentre leggevo
E' piu' meno il discorso "La PS2 e' figa perche' e' difficile da programmare" che va a braccetto con "prima di scopare mi tiro una martellata sulle palle altrimenti e' troppo facile"

Cazzate. E l'avro' scritto ormai 100 volte. L'importante e' una console FACILE DA PROGRAMMARE che metta a disposizione la potenza dell'hw al programmatore con un paradigma consolidato e semplice da usare (D3D e OGL), di modo che il programmatore possa concentrarsi sugli effetti e non debba perdere tempo prezioso anche per spedire un solo poligono all'hw, programmando DMA, inutilmente complicati (e poco potenti) coprocessori geometrici e primitivi GS. Il programmatore deve concentrarsi sui contenuti, non litigare con l'hw.

In questo la PS2 e' stato un ovvio passo indietro: una console (al tempo) potente e molto complicata da programmare. Tanto e' vero che le nuove console hanno paradigmi molto piu' semplici e risultano quindi piu' potenti: il GC ad esempio sarebbe programmabile da un bambino per quanto e' semplice e questo e' un pregio!

Concludo: non invidiarmi, faccio un lavoro come un altro e quando, come ieri, resto a lavorare fino all'una di notte c'e' poco da invidiare.


Questione di punti di vista.
secondo te il programmatore deve concentrarsi sugli effetti
( tra l' altro implicitamente mi dai ragione quando scrivo che ...
)
ed è quello che grosso modo TUTTI i coder 3d sono capaci di fare.....specie con API come quelle D3D che ti semplificano notevolmente la vita( gia' OpenGL è ad un livello piu' basso e molte cose devi "costruirtele" da solo ).....dove invece l'esperienza,la competenza e il talento fanno la differenza e' nel creare qualcosa per cui NON ESISTE un API equivalente.....è questo che intendo io per stimolo per il programmatore....che poi cio ' si riduca come dici tu in uno spreco di tempo, se il programmatore è pigro,non ha voglia o tempo di impegnarsi e vada a scapito del gioco...bè ....è un punto di vista anche quello.
Vi sono giochi dove questo sforzo che tu ritieni inutile è stato fatto.....ed i risultati sono sotto gli occhi di tutti...Devil May CRY, GT3 , e jax & Dexter ...giusto per citarne 3 ...sono indiscutibilmente capolavori di fluidita' e giocabilita' ...oltre ad essere uno spettacolo per gli occhi..........e NON VI E' ALCUNA CONTROPROVA che sarebbe possibile otenere la stessa fluidita' in una pari conversione dei suddetti per x-Box impiegando esclusivamente l' API che l' SDK Microsoft mette a disposizione.
Se puoi vuoi farci credere al marketing fai pure.
Per converso molti giochi X-Box che hanno richiesto tempi di sviluppo pari o solo leggermente inferiori ( PGotham,FIFA 2003,quello di snowboard di cui non ricordo il titolo,the thing( graficamente pvero persino su PS2),Blade II ) rilevano pecche nella fluidita' e stabilita' del comparto grafico che non sono accettabili se confrontate con i migliori titoli della rivale.

Con questo non voglio mica dire che su X-Box non sia possibile ottenere un motore fluido e stabile.( la codemasters vi è riuscita col discreto Colin Mc Rae rally 3 nulla di eccezionale graficamente ma inchiodato a 60 FPS fissi sparati come GT3 ) ma in quel caso è necessario rimboccarsi le maniche e scrivere tanto codice aggiuntivo come su PS2 per cui la tanto decantata facilita' di programmazione va a farsi fottere.

In definitiva si puo' affermare che l' unico svantaggio che SONY offre agli sviluppatori è la mancanza di un SDK User-friendly e intuitivo ma esso è trascurabile in quanto il livello estremo raggiunto dalle ultime produzioni rende datati e inutili gli engine che fanno affidamento esclusivo su di esso.
Non per nulla il kit di sviluppo fornito da SONY per la PS1 , notevolmente piu' ricco di tool e librerie e piu' facile da usare dello scarno SDK(gia' chiamarlo SDK è uno scandalo) della ps2, è stato sempre meno di aiuto mano mano che lo standard dei giochi PS2 si innalzava.....fino ad arrivare alle ultime produzioni PS1 dove le grandi case hanno quasi esclusivamente impiegato i PROPRI tool di sviluppo e le proprie librerie.
Inoltre chi sviluppa su PS2 è ripagato dall' avere un serbatoio di utenti infinitamente piu' esteso.

Questo unicamente per quanto riguarda la grafica.
Se poi ci addentriamo nei meandri dell' implementazione dell' intelligenza artificiale e della fisica del gioco dell' ottimizzazione dei caricamenti, delle routine per gestire i livelli di pressione dei joypad analogici ecc...ecc...bè li' il discorso è ancora piu' relativo e varia da software house a software house con differenze anche tra team interni alla stessa casa ( vedi KONAMI ) ribadisco solo che la PS2 ha gia' dato prova in tutti i titoli di reggere benssimo i calcoli in tempo reale di routine grafiche e di supporto al gameplay.




Non ti preoccupare. Tutti i programmatori in scadenza di progetto fanno l' una di notte e anche di piu'.
Specie poi se lavori lontano da casa....che anche se torni dove alloggi non sai che cazzo fare.
Ti invidio eccome, fidati.
Sicuramente non ti manca la testardaggine



Questione di punti di vista sto gran par de balle. Se per fare la stessa cosa (e meglio) su un altro hw impiego un quinto del tempo, getto il primo nelle fasce ed ho 4/5 del tempo per dedicarmi a migliorare quell'effetto oppure ad implementare altro.

Si vede che non hai mai scritto due righe di codice con una rendering API in vita tua...



Puttanate. Qui non stiamo parlando di tecniche esotiche per fare chissa' quali mirabolanti cose con la PS2. Qui stiamo dicendo che con la PS2 anche cose SEMPLICISSIME quali disegnare un poligono o mettere una texture in memoria video, richiedono una quantita' di lavoro spropositata, per l'appunto perche' l'hw e' VECCHIO ed oggi GRAZIE AL PROGRESSO esistono paradigmi di programmazione piu' efficienti e piu' potenti.

L'API dell'xbox e' un sottilissimo strato di software praticamente a contatto con l'hw ed espone TUTTE le caratteristiche dell'hw stesso. Paradossalmente e' piu' difficile sfruttare appieno una macchina di nuova generazione come il GC o l'xbox di quanto lo sia con la PS2, non perche' siano difficili da programmare (sono molto semplici), ma perche' le possibilita' offerte sono DI GRAN LUNGA piu' numerose, perche' l'hw e' piu' potente ed espone molte piu' caratteristiche.

Con una PS2 puoi rasterizzare un poligono con una texture e scegliere un'operazione di blending.
Con il GC puoi blittare un poligono con fino a 8 texture, con texture dependent read e parecchie operazioni di blending
Con l'xbox puoi scrivere direttamente i pixel shader e programmare l'unita' di blending con fino a 4 texture per passata.

Poi puoi pestare i piedini per terra, piagnucolare, insultare Microsoft quanto ti pare, ma questo non cambia la realta' delle cose: tutti i giochi multipiattaforma sono visivamente migliori su xbox e gc (grazie anche solo alle texture a dettaglio piu' alto SENZA scomodare le unita' di rastering), si programmano nella meta' del tempo e costano meno agli sviluppatori.

Questo, nonostante i tuoi piagnistei, e' la controprova che la PS2 e' hw ormai vecchio: e sarebbe strano non fosse cosi'.



Preferisco che tu non legga quello che dice Tom Forsyth (3d programmer della Shiny) riguardo allo sviluppo di Blade II su PS2 e xbox nei forum privati. Pensa che si lamentava della pesantezza dei thread su PS2 che li ha costretti a limitare notevolmente il livello di dettaglio sia della geometria sia delle texture rispetto alla versione XBOX. Ma non credo che tu arriverai mai a leggere (e comunque capire) anche solo una parola di quello che scrive Tom Forsyth su un forum privato per sviluppatori. Beata ignoranza.



Ma se non sai neanche di che cosa stai parlando. Hai mai scritto un motore 3d in vita tua? Sai come si ottiene la fluidita'? Smettila di parlare da fanatico.



In definitiva si puo' solo affermare che non sai neppure lontanamente di che cosa stai parlando...



Ed al decimo post ne hai finalmente imbroccata una giusta. Io credevo in te, sapevo che non potevi sparare solo fesserie.



Ma che cosa stai dicendo? Parli di cose che non hai mai visto in vita tua! E come se io mi mettessi tutto d'un tratto a parlare di uncinetto senza aver mai visto un puntocroce.

Che cosa vuol dire "routine grafiche al supporto del gameplay"? E' un pezzo d'hw! E' solo un pezzo d'hw!




Tranquillo che qui di cose da fare la sera ce ne sono pure troppe
Quanto adoro le studentesse inglesi


Se vuoi posso postare screenshot di demo che ho scritto da solo, compresa la realizzazione dei modelli in 3d studio...se mi dai la mail posso anche inviarti il workspace di VC++ 6.0. ( se sei capace di compilarlo )
Tu cosa hai fatto da solo ? Oltre lo sparare cazzate e fare lo sborone nei forum...per quello non hai bisogno d' aiuto.



guarda che ormai hai rotto ...abbiamo capito che ps2 ti fa schifo e che non sai programmarla...ma almeno evita di dire che chi lo sa fare perde tempo a fare cose semplici che ti probabilmente non sarai MAI in grado di avvicinare.



Ma figurati cosa me ne frega se Mafiasoft vuol far passare un bidone di PC pompato per una macchina da gioco rivoluzionaria....sta gia' perdendo tanti
di quei miliardi che non ha alcun bisogno ne che io gliela tiri ulteriormente ne dei miei insulti...per quanto riguardo il sig. Forsyth non ho il piacere di
conoscerlo ma Blade II ( sia su X-Box che Ps2 ) è una tale cagata che dimostra appieno tutta l' incapacita' sua e del suo team...inoltre non credo proprio
che qualsiasi argomentazione che incontri la tua comprensione sfugga alla mia...invece di provocare col solito infantile "sei ignorante" discuti di qualche argomento concreto di programmazione...o sei buono a parlare solo per dar fiato ai polmoni?



Dunque...per quanto riguarda la fluidita'.....io lo so ma voglio che me lo spieghi prima tu...per morire di fronte alle puttanate che scriverai...( gia' mi
sembra di leggerle...shader potentissimi ecc...ecc...) ti do un suggerimento ...MicroKernel linux VS kernel-clone di winzozzCE non in tempo reale...dai
forse se cerchi su google ci arrivi...
Ho scritto un piccolo motore 3D per la gestione delle telecamere uno studio virtuale....ma che te lo dico a fare...tu al contrario sei un buffone che si riempie la bocca di grandi parole ma conta pochi fatti...ora puoi replicare che hai scritto il motore di metal gear ma
per usare le tue parole....





Se ti vedessi...non mi stupirei.



Il solo ritenere le cessissime inglesi arrapanti ti pone a pieno titolo nella categoria dei NERD.
Saluti.
se non ti rispondo è perchè sto uscendo.
salutami le ( bellissime ) inglesi ))
CHE LOL TUTTO Cio' , mangiavo poppycorn mentre leggevo {giuro} l'importane xo' è flammare di meno e tornare di piu' IT


Francamente non me ne potrebbe fregare di meno di quello che hai fatto

Almeno le mie cazzate sono supportate da fatti e dati tecnici e non da cieca fede nella provvidenza di mamma Sony

Non per altro e' il mio lavoro, quindi probabilmente saro' capace a compilare



Tu che cosa sai delle mie capacita' con la PS2 da permetterti di giudicare il mio lavoro? Vedo che di fronte all'evidenza dei fatti, ti stai innervosendo e passi al personale.
Qui non stiamo decidendo se Fek e' un buon programmatore o meno: altri hanno il compito di giudicare il mio lavoro, non certo tu.
Qui si sta cercando di sgomberare il campo da falsa informazione fatta da chi e' TIFOSO di una console e spara dati senza sapere di che cosa sta parlando, per cercare di propugnare tesi false.




Il fatto di perdere miliardi non inficia le caratteristiche tecniche della macchina. Il tuo odio nei confronti della M$ inficia (pesantemente) il tuo giudizio sulla macchina, al contrario. Sei acciecato dall'odio: Sony, Microsoft e Nintendo sono aziende che devono fare profitto e ognuna e' meritevole quanto le altre. Questo se ci capisci qualcosa di economia, altrimenti ti metti la sciarpetta di una delle tre e inizi a fare il tifo come allo stadio. Fan boy...



Shiny... MDK e MDK2... dal punto di vista tecnico uno dei migliori team di sviluppo in circolazione. Che ignoranza abissale, ma che ci parlo a fare?



Sto parlando da due pagine di programmazione, ma glissi sistematicamente su tutto quello che non capisci. Ma visto che vuoi parlare con piu' precisione di programmazione (3D), dimostra a noi tutti che non sei un ignorante in materia e dimmi come tradurresti questo effetto su PS2:



VERTEX_SHADER BumpmapVS14

; Input:
; v0 = vertex position
; v1 = vertex normal
; v5 = vertex tangent
; v6 = vertex binormal
;
; c0 = world matrix
; c4 = viewer position
; c5 = light position
; c6 = light color
; c7 = light range, 1.0, 0.0, 1.0
; c90 = 0.5, 0.5, 0.5, 0.5

vs.1.1

m4x4 oPos, v0, c0 ; transform position by world matrix

mov oT0, v3
mov oT1, v3

sub r1, v0, c5 ; compute L and normalise it
dp3 r1.w, r1, r1
rsq r1.w, r1.w
mov r3, r1.w
mul r1, r1, r1.w

mul r3.w, r3.w, c7.x ; compute light distance factor
rcp r3.w, r3.w
sub r3.w, c7.w, r3.w
mul oT2, c6, r3.w ; light colour * attenuation

dp3 r8.x, v5, -r1 ; transform L into tangent space
dp3 r8.y, v6, -r1
dp3 r8.z, v1, -r1

mad oD0.xyz, r8.xyz, c90.xxx, c90.xxx ; scale and bias
mov oD0.w, r8.z

END_VERTEX_SHADER

PIXEL_SHADER BumpmapPS14

ps.1.4

def c0, 0.0, 0.0, 1.0, 1.0
def c5, 1.0, 1.0, 1.0, 1.0
def c6, 0.0, 0.0, 0.0, 0.0

texld r0, t0 ; fetch base map
texld r1, t1 ; fetch normal map

texcrd r2.rgb, t2 ; get lightcolor * attenuation

dp3 r4, v0_bx2, v0_bx2 ; normalise L
mad r4, v0_bias, 1-r0, v0_bx2

dp3 r4, r1_bx2, r4 ; L.N

mul r4.rgb, r4, r2 ; light colour * attenuation
+ mov_x4 r5.a, v0.a ; 8 * max(L.z, 0)

mul r0.rgb, r0, r4
+ cmp r1.a, 1-r5.a, r5.a, c5.a ; min(8 * max(L.z, 0), 1)

mul r0, r0, r1.a

; dp3 r1, r0, c5
; mov r0.a, r1.b

END_PIXEL_SHADER


A te la parola... Vediamo che cosa e' in grado di partorire questo hw rivoluzionario




Rilassati. Sei molto agitato. Insultare me non rendera' il tuo amato gioiello tecnologico piu' potente.
(Linux non ha un kernel real-time, dio che ignoranza )



Rilassati. Sei molto agitato. Insultare me non rendera' il tuo amato gioiello tecnologico piu' potente.




Rilassati. Sei molto agitato. Insultare me non rendera' il tuo amato gioiello tecnologico piu' potente.
Starà studiando
Allora non lo rivedremo per un po'
bah.....ma non vi scocciate a scornarvi cosi'?
Comunque fek...mi spiace ma ha ragione erprincipe( che cazzo di nick !!) ...sei troppo sfegatato...e oltretutto che quesiti gli poni scusa? Mica lui ti ha detto che programma su ps2? E poi non mi sembra che spari cazzate....sui link che uppa c'è scritto esattamente quello che dice....tu invece scrivi scrivi e citi a dx esx ma che fonti hai?
non preoccuparti...non ho bisogno che tu mi difenda....(sara' bello il tuo di nick..)
e ad ogni modo non gli rispondo solo perchè è un montato che provoca....infatti non gli ho mai detto che sviluppo su ps2 ed è normale che io non sappia tradurre quell' effetto non avendo mai scritto 1 riga di codice su play in vita mia ( mai detto il contrario ) ....come è normale che lui non sappia cosa significa questo :

__________________________________________________

void ConvertToTeleviser702x576x32Dou(DWORD *Telev,DWORD *Buf1,DWORD *Buf2)
{
static int Righe,ContDest,ContOrg,ParDis,MemSi,MemSi2,BaseP;
static char regis[110];

__asm FSAVE regis;

//PER SPOSTAMENTO BITS
__asm mov edi,Telev;
__asm clc;
__asm add edi, 38592; //INIZIA DA RIGA 12 colonna 48 (3200*12+48*4)
__asm mov esi, Buf1;
__asm mov ecx, 0; //CONTROLLA SE FINE BIT NUMERO DI BITS
__asm mov eax, NUMRIGHE;
__asm mov BaseP,ebp;
__asm mov ebp, Buf2;
__asm xor ecx,ecx;
__asm xor edx,edx;

RIPETIRIG:
__asm mov ebx, 43; //CONTATORE BITS DI RIGA DIVISO 4

RIPETIBIT:
__asm movq mm0,QWORD PTR [ebp+edx];//CARICA KEY (8 BIT)
__asm movq mm1,QWORD PTR [ebp+edx+8];//CARICA KEY (8 BIT)

//BYTE 1
__asm movq mm2,mm0;
__asm psllq mm2,56;
__asm psrlq mm2,32;

//BYTE 2
__asm movq mm7,mm0;
__asm psrlq mm7,8;
__asm psllq mm7,56;
__asm por mm2,mm7;

//BYTE 3
__asm movq mm3,mm0;
__asm psrlq mm3,16;
__asm psllq mm3,56;
__asm psrlq mm3,32;

//BYTE 4
__asm movq mm7,mm0;
__asm psrlq mm7,24;
__asm psllq mm7,56;
__asm por mm3,mm7;

//BYTE 5
__asm movq mm4,mm0;
__asm psllq mm4,24;
__asm psrlq mm4,56;
__asm psllq mm4,24;

//BYTE 6
__asm movq mm7,mm0;
__asm psrlq mm7,40;
__asm psllq mm7,56;
__asm por mm4,mm7;

//BYTE 7
__asm movq mm5,mm0;
__asm psllq mm5,8;
__asm psrlq mm5,56;
__asm psllq mm5,24;

//BYTE 8
__asm movq mm7,mm0;
__asm psrlq mm7,56;
__asm psllq mm7,56;
__asm por mm5,mm7;

//BYTE 9
__asm movq mm6,mm1;
__asm psllq mm6,56;
__asm psrlq mm6,32;

//BYTE 10
__asm movq mm7,mm1;
__asm psrlq mm7,8;
__asm psllq mm7,56;
__asm por mm6,mm7;

//BYTE 11
__asm movq mm7,mm1;
__asm psllq mm7,40;
__asm psrlq mm7,56;
__asm psllq mm7,24;

//BYTE 12
__asm movq mm0,mm1;
__asm psrlq mm0,24;
__asm psllq mm0,56;
__asm por mm7,mm0;

//CARICA TUTTI I BIT DI MASCHERA
__asm por mm2,QWORD PTR [esi+ecx];//CARICA ORIGINE (2 BIT) //BIT 1 -2
__asm movq QWORD PTR [edi+ecx],mm2;//SPOSTA IN DESTINAZIONE //BIT 1 - 2

//BYTE 13
__asm movq mm2,mm1;
__asm psllq mm2,24;
__asm psrlq mm2,56;
__asm psllq mm2,24;

__asm por mm3,QWORD PTR [esi+ecx+8];//CARICA ORIGINE (2 BIT) //BIT 3 -4
__asm movq QWORD PTR [edi+ecx+8],mm3;//SPOSTA IN DESTINAZIONE //BIT 3 -4

__asm por mm4,QWORD PTR [esi+ecx+16];//CARICA ORIGINE (2 BIT) //BIT 5 -6
__asm movq QWORD PTR [edi+ecx+16],mm4;//SPOSTA IN DESTINAZIONE //BIT 5 -6

__asm por mm5,QWORD PTR [esi+ecx+24];//CARICA ORIGINE (2 BIT) //BIT 7 -8
__asm movq QWORD PTR [edi+ecx+24],mm5;//SPOSTA IN DESTINAZIONE //BIT 7 -8

//BYTE 15
__asm movq mm3,mm1;
__asm psllq mm3,8;
__asm psrlq mm3,56;
__asm psllq mm3,24;

__asm por mm6,QWORD PTR [esi+ecx+32];//CARICA ORIGINE (2 BIT) //BIT 9 -10
__asm movq QWORD PTR [edi+ecx+32],mm6;//SPOSTA IN DESTINAZIONE //BIT 9 -10

__asm por mm7,QWORD PTR [esi+ecx+40];//CARICA ORIGINE (2 BIT) //BIT 11 - 12
__asm movq QWORD PTR [edi+ecx+40],mm7;//SPOSTA IN DESTINAZIONE //BIT 11 - 12

//BYTE 14
__asm movq mm7,mm1;
__asm psrlq mm7,40;
__asm psllq mm7,56;
__asm por mm2,mm7;

//BYTE 16
__asm movq mm7,mm1;
__asm psrlq mm7,56;
__asm psllq mm7,56;
__asm por mm3,mm7;

__asm por mm2,QWORD PTR [esi+ecx+48];//CARICA ORIGINE (2 BIT) //BIT 13 -14
__asm movq QWORD PTR [edi+ecx+48],mm2;//SPOSTA IN DESTINAZIONE //BIT 13 -14

__asm por mm3,QWORD PTR [esi+ecx+56];//CARICA ORIGINE (2 BIT) //BIT 15 - 16
__asm movq QWORD PTR [edi+ecx+56],mm3;//SPOSTA IN DESTINAZIONE //BIT 15 - 16

__asm clc;
__asm add ecx,64;
__asm clc;
__asm add edx,16;
__asm dec ebx;
__asm jnz RIPETIBIT;

__asm movq mm0,QWORD PTR [ebp+edx];//CARICA KEY (8 BIT)
__asm movq mm1,QWORD PTR [ebp+edx+8];//CARICA KEY (8 BIT)

//BYTE 1
__asm movq mm2,mm0;
__asm psllq mm2,56;
__asm psrlq mm2,32;

//BYTE 2
__asm movq mm7,mm0;
__asm psrlq mm7,8;
__asm psllq mm7,56;
__asm por mm2,mm7;

//BYTE 3
__asm movq mm3,mm0;
__asm psrlq mm3,16;
__asm psllq mm3,56;
__asm psrlq mm3,32;

//BYTE 4
__asm movq mm7,mm0;
__asm psrlq mm7,24;
__asm psllq mm7,56;
__asm por mm3,mm7;

//BYTE 5
__asm movq mm4,mm0;
__asm psllq mm4,24;
__asm psrlq mm4,56;
__asm psllq mm4,24;

//BYTE 6
__asm movq mm7,mm0;
__asm psrlq mm7,40;
__asm psllq mm7,56;
__asm por mm4,mm7;

//BYTE 7
__asm movq mm5,mm0;
__asm psllq mm5,8;
__asm psrlq mm5,56;
__asm psllq mm5,24;

//BYTE 8
__asm movq mm7,mm0;
__asm psrlq mm7,56;
__asm psllq mm7,56;
__asm por mm5,mm7;

//BYTE 9
__asm movq mm6,mm1;
__asm psllq mm6,56;
__asm psrlq mm6,32;

//BYTE 10
__asm movq mm7,mm1;
__asm psrlq mm7,8;
__asm psllq mm7,56;
__asm por mm6,mm7;

//BYTE 11
__asm movq mm7,mm1;
__asm psllq mm7,40;
__asm psrlq mm7,56;
__asm psllq mm7,24;

//BYTE 12
__asm movq mm0,mm1;
__asm psrlq mm0,24;
__asm psllq mm0,56;
__asm por mm7,mm0;

//CARICA TUTTI I BIT DI MASCHERA
__asm por mm2,QWORD PTR [esi+ecx];//CARICA ORIGINE (2 BIT) //BIT 1 -2
__asm movq QWORD PTR [edi+ecx],mm2;//SPOSTA IN DESTINAZIONE //BIT 1 - 2

//BYTE 13
__asm movq mm2,mm1;
__asm psllq mm2,24;
__asm psrlq mm2,56;
__asm psllq mm2,24;

__asm por mm3,QWORD PTR [esi+ecx+8];//CARICA ORIGINE (2 BIT) //BIT 3 -4
__asm movq QWORD PTR [edi+ecx+8],mm3;//SPOSTA IN DESTINAZIONE //BIT 3 -4

__asm por mm4,QWORD PTR [esi+ecx+16];//CARICA ORIGINE (2 BIT) //BIT 5 -6
__asm movq QWORD PTR [edi+ecx+16],mm4;//SPOSTA IN DESTINAZIONE //BIT 5 -6

__asm por mm5,QWORD PTR [esi+ecx+24];//CARICA ORIGINE (2 BIT) //BIT 7 -8
__asm movq QWORD PTR [edi+ecx+24],mm5;//SPOSTA IN DESTINAZIONE //BIT 7 -8

__asm por mm6,QWORD PTR [esi+ecx+32];//CARICA ORIGINE (2 BIT) //BIT 9 -10
__asm movq QWORD PTR [edi+ecx+32],mm6;//SPOSTA IN DESTINAZIONE //BIT 9 -10

__asm por mm7,QWORD PTR [esi+ecx+40];//CARICA ORIGINE (2 BIT) //BIT 11 - 12
__asm movq QWORD PTR [edi+ecx+40],mm7;//SPOSTA IN DESTINAZIONE //BIT 11 - 12

//BYTE 14
__asm movq mm7,mm1;
__asm psrlq mm7,40;
__asm psllq mm7,56;
__asm por mm2,mm7;

__asm por mm2,QWORD PTR [esi+ecx+48];//CARICA ORIGINE (2 BIT) //BIT 13 -14
__asm movq QWORD PTR [edi+ecx+48],mm2;//SPOSTA IN DESTINAZIONE //BIT 13 -14

__asm clc;
__asm add ecx,64;
__asm clc;
__asm add edx,16;

__asm clc;
__asm add edi,384;
__asm dec eax;
__asm jnz RIPETIRIG;

__asm mov ebp,BaseP;

__asm EMMS
__asm FRSTOR regis;
}

________________________________________________
.....e calcola che non ho neppure MAI detto di occuparmi di programmazione 3d in ambito lavorativo.....
......immagino cosa potrebbe accadere se spostassi la discussione sulla programmazione di sistema.....si autobannerebbe dal forum.


Tu non rispondi perche' non sai che cosa rispondere. Ampiamente dimostrato, quindi, che in campo 3d tu parli senza sapere di che cosa stai parlando, perche' avessi anche solo una minima conoscenza in questo campo, avresti immediatamente notato che il codice riportato e' un pixel shader in versione 1.4, mentre l'NV25 dell'xbox supporta i pixel sahder in versione 1.3. Quindi quello shader NON e' eseguibile su xbox e avresti dovuto sgamarlo immediatamente
Inutile dire che e' semplice da tradurre in 1.3 con qualche modifica.

La tua ignoranza in materia e' solo seconda alla tua arroganza e la tua maleducazione.



E' codice MMX per fare un qualche tipo di conversione, ma visto che commenti poco il codice, non e' semplice capire che cosa. D'altronde, io ho detto che sei ignorante nella programmazione 3d, non nel tuo campo e visto che questo e' un forum sulle console e si stava facendo una discussione (incivile da parte tua) sulle caratteristiche hw di xbox e ps2 in campo grafico, sei andato bellamente OT, non sei stato in grado di rispondere alla mia domanda, hai finalmente dimostrato che sei un'ignorante in materia...

Nonche' la tua maleducazione nell'iniziare ad insultarmi quando ormai tutte le tue convinzioni sono state abbondantemente dimostrate false.

Permettimi un bell'



PS. Ottimizza quel codice che e' pieno di AGI
1) la tua domanda era "come tradurresti questo effetto su PS2:?"
(..segue stupido codice di vertex shader copiato dagli esempi....)
la mia rispostza è stata: "Non ho idea...non avendo mai scritto 1 riga di codice su play2 in vita mia." PUNTO.

Le tue considerazioni su cosa avrei dovuto o non dovuto sgamare sono solo l' ennesimo infantile tentativo di innescare una nuova sterile polemica.E l' ennesimo tuo tentativo di voler dimostrare al mondo che SAI di 3d ( se lo dici tu nessuno lo mette in dubbio).

2) Quel codice è scritto proprio in quel modo per evitare i jump del processore e quindi ottimizzare l' utilizzo della cache...in quel modo si riesce ad eseguire N istruzioni MMX in parallelo....giusto per farti capire che è il MASSIMO dell' ottimizzazione e tu, che DOVRESTI ESSERE UN CULTORE DELL' ARCHITETTURA PENTIUM ,oltre a non avermi saputo spiegare cosa fa quella funzione....ti permetti di dire..."ottimizza quel codice...e' pieno di AGI" quando dovresti ben sapere che durante i jump il processore va a pallino nell' utilizzo della cache.

Ti consiglio di porre fine a questa inutilmente lunga e polemica discussione e di moderare i toni.
Io lo sto gia' facendo.
Saluti.


L'ho scritto io, ignorante
E' nient'altro che il cuore degli shader di Doom3: un diffuse+specular+attenuation per pixel.
Non sono ignorante come te in materia, che devo copiare gli esempi: conosco quel pezzo di codice riga per riga.

E quindi, se non hai mai scritto codice su PS2, come puoi essere cosi' arrogante da parlare di qualcosa che non conosci? Come puoi parlare di supremazia di un pezzo di hw su un altro se NON LI CONOSCI?

Ti dico io come si traduce in PS2: con 20/25 passate. Auguri a farlo girare a 5 fps.

Ti ho detto che sei ignorante in materia o me ne sono dimenticato?



Qui l'unico che insulta e innesca polemiche sei tu. Ti ricordo che hai aperto la tua brillante avventura su questo forum con un "questo spara solo cazzate...". Tipica frase che NON vuole innescare polemiche



Quanto sei ignorante anche nel tuo campo. Se il jump e' predetto dalla branch prediction unit, la pipeline non e' svuotata e il processore puo' continuare a decodificare le istruzioni nel flusso. Ti ha detto male anche questa volta: ho scritto parecchio assembly in vita mia.
Ti consiglio di imparare a scrivere loop interlacciati: il tuo codice ne gioverebbe parecchio.



Qui l'unico che ha solo insultato sei stato tu. Io non mi sono mai permesso di fare illazioni sul tuo lavoro (del quale non mi frega nulla) o di chiamarti "nerd" o di darti del "pallone gonfiato" o di insultarti in qualunque modo. Ti ho solo fatto notare la tua ignoranza in materia di 3d, dimostrata dal fatto che non sei stato in grado di rispondere alle mie domande o di controbattere alcunche' di tecnico.




Se lo dici tu....scommetto che qui ci credono tutti.



HAHAHAHAHHA!!!!!......
....se avessi letto con attenzione il codice ( cosa che rimproveri agli altri di non fare....) avresti notato che l' utilizzo dei registri è ALTERNATO.
Se conoscessi BENE il pentium ( ma non lo consci ) sapresti che la Jump prediction unit non fa proprio i miracoli ma gia' 2 livelli di jump bastano a mandarla in crisi.
D' altrondew questa mia affermazione nasce dall' osservazione della REALTA' e non dalla pura teoria ( magari universitaria ) in quanto quel codice prima era scritto ESATTAMENTE come dici tu ed è stato necessario riscriverlo in questo modo in quanto andava in crisi la jpu.
Il risultato è stato un incremento di prestazioni nella copia del frame buffer della scheda utilizzata nel nostro virtual set(utilizzato in ambito professionale televisivo...non per farci giocare i bambini ) da 4 a 33 FPS.

Se tu sapessi,invece ,sottolineo, di sparare cazzate....cosa si intende per INTERLACCIAMENTO di istruzioni e come funziona una pipeline non avresti detto cosi'.



Gia'.

eh gia'....



[/QUOTE]

P.S.: Il mio mio collega mi dice che sei un coglione.


Frega nulla che ci credano o no. Mi basta sapere di essere in grado di scrivere quella roba.



Programmi ancora sui Pentium I? Sei avanzato allora



Hai letto il titolo del forum? Console... Sei giusto vagamente OT. Non credo che a nessuno freghi una sega qui di quello che scrivi (per altro piuttosto malamente)...



Go download "32 bit cpu optimisation" by Intel, u n00b




Se lo dice il tuo collega
Continua pure a insultare. Dimostri solo ulteriormente la tua pochezza
Dimenticavo:

(e non copiarmi gli smilini...)