Polpetta Games

Di seguito alcune considerazioni piu’ specifiche sul codice, unity e l’organizzazione del lavoro. Stile, convenzioni indentazione Legenda: Da non fare assolutamente Forse, ma meglio persarci bene Ok Pattern and practices Variabili pubbliche (escluse readonly e const) Iteratori a frame time (sono piu’ lenti e allocano, usate i for a frame time, possibilmente) Over-Engineering (Unity e’ un framework ad altissimo livello. E’ molto raro che vi troviate a scrivere architetture complesse di componenti, almeno in una prima fase. Se sentite la necessita’ di usare tante classi da subito e strutture complesse, con buona probabilita’ esiste una soluzione piu’ semplice, magari gia’ implementata nel framework) Statement e modificatori esotici : GOTO, ref & out parameters, tutte cose che rompono incapsulamento e OOP. Evitare! Reflection: macigno sulle performance, inutile nel 99% dei casi (salvo che scriviate un IDE o un sistema di IoC). Vietatissima [De]Alloc

Models Import Settings Negli import settings dei modelli ci sono diverse flag, ovviamente le opzioni variano da modello a modello. L’idea di massima e’ selezionare solo quelle che ci interessano ed evitare di importare qualsiasi cosa non necessaria. Di seguito alcuni esempi: Qui la doc: http://docs.unity3d.com/Manual/FBXImporter-Model.html Read/Write enable : NO a meno che non serva modificare la mesh a runtime.. Import blendshapes: NO Import Materials: NO unity importa i materiali nella stessa cartella dei modelli e genera disordine. Inoltre spesso non e’ in grado di scegliere shader e texture correttamente. Tanto vale farseli a mano cosi siamo sicuri di non sbagliare. Generate Colliders: NO Generate LM UVS: DIPENDE SE STATICI CON LIGHTMAP Optimize Mesh: SI Normals: meglio importarle se il modello le ha, altrimenti farle generare.. di norma servono sempre. Tangents: se le ha importarle altrimenti generarle SOLO SE si usano Bumpmap o simili Rig->

Rasterization -  HSR descrivere il problema ed elencare le strategie e quindi gli algoritmi La computazione avviene in aritmetica intera, e le operazioni sono “per pixel” (pixel bound). Non tutti i poligoni sopravvissuti, però, devono essere disegnati. Alcuni possono non essere visibili dall’osservatore perché nascosti (totalmente o parzialmente) da altri poligoni. • Problema: dati un insieme di poligoni in 3D ed un punto di vista, si vogliono disegnare solo i poligoni visibili (o porzioni di essi). Ogni poligono si assume essere piatto ed opaco. • Vi sono essenzialmente due approcci: – object-precision: l’algoritmo lavora sui poligoni stabilendo relazioni di occlusione reciproca. Il costo `e quadratico nel numero dei poligoni. Però la precisione `e elevata (precisione macchina). – image-precision: l’algoritmo stabilisce occlusioni a livello del pixel. `E più veloce ma la precisione `e limitata. • La rimozione delle superfici nascoste (Hidden Surface Removal, HSR) viene an

┌───┬───┐ ╔═══╦═══╗ │      │      │ ║      ║      ║ ├───┼───┤ ╠═══╬═══╣ │      │      │ ║      ║      ║ └───┴───┘ ╚═══╩═══╝ Ecco la tabella di riferimento con i codici più usati per realizzare le cornici

Ecco un piccolo elenco degli strumenti che utilizzo di solito: CMake Gimp Git Inkscape LibreOffice LyX Notepad++ Skype TortoiseGit WinMerge Visual Studio E voi cosa usate?

//Distanza tra due punti -------------------------------------------------------------- double Distance(Vect2d p1, Vect2d p2) {   double dx = p2.x - p1.x;   double dy = p2.y - p1.y;   return sqrt((double)dx*dx + dy*dy); }; //Distanza tra un punto e un segmento -------------------------------------------------------------- double DistanceToLine(Vect2d lineP1, Vect2d lineP2, Vect2d point) {   double normalLength = _hypot(lineP2.x - lineP1.x, lineP2.y - lineP1.y);    double distance = (double)((point.x - lineP1.x) * (lineP2.y - lineP1.y) - (point.y - lineP1.y) * (lineP2.x - lineP1.x)) / normalLength;   return abs(distance); }

double   Distance ( Vect2d   p1 ,  Vect2d   p2 ) {    double   dx  =  p2 . x  -  p1 . x ;    double   dy  =  p2 . y  -  p1 . y ;    return   sqrt (( double )  dx * dx  +  dy * dy ); }

   Vect2d   LineP1 ,  LineP2 ;    double   m_MarginLeft = -1000 ,   double   m_MarginRight = 1000 ;    Vect2d   newLineP1 ,  newLineP2 ,  delta ;    delta . x  =   LineP2 . x  -  LineP1 . x ;    delta . y  =   LineP2 . y  -  LineP1 . y ;    double   ratio  =  delta . y  /  delta . x ;    newLineP1 . x  =  m_MarginLeft ;    newLineP1 . y  =  LineP1 . y  - (( LineP1 . x  -  m_MarginLeft ) *  ratio );    newLineP2 . x  =  m_MarginRight ;    newLineP2 . y  =  LineP2 . y  + (( m_MarginRight  -  LineP2 . x ) *  ratio );