Tra le diverse caratteristiche eccone alcune molto importanti :

Photo Viewer – Emula l’applicazione nativa di Apple foto, con la possibilita’ inoltre di caricare immagini dalla rete.

Messaggio Composer – Emula il sistema di messaggi di Apple mail. Include configurazione messaggio, campi e l’auto-completamento parole.

Web Image Views - Facile utilizzo di immagini scaricate da URL.

Internet-Aware Table View Controllers - Uso di dati di una tabella da Internet.

Two Enhanced Text Fields, HTTP Disk Cache URL-Based Navigation e molte altre…

Sir Lodux…

fonti melablog

Box2d è un simulatore di corpi rigidi in 2D sviluppato in C++. E’ molto utile perché permette in poche righe di creare un motore fisico e quindi al posto di crearsi tutte quelle routine per l’animazione degli oggetti lasciamo ad Dott. Isaac Newton di farlo per noi attraverso le regole della Fisica

Caratteristiche del motore fisico:

Collision

• Continuous collision detection.
• Contact callbacks: add, persist, remove.
• Convex polyons and circles.
• Multiple shapes per body
• One-shot contact manifolds
• Incremental sweep-and-prune broadphase
• Efficient pair management
• Fast broadphase AABB queries
• Collision groups and categories

continua…

Physics

• Continuous physics with time of impact island solver.
• Persistent body-joint-contact graph
• Island solution and sleep management
• Contact, friction, and restitution
• Stable stacking with a linear-time solver
• Revolute, prismatic, distance, pulley, gear, and mouse joints
• Joint limits, motors, and friction
• Momentum decoupled position correction
• Fairly accurate reaction forces/impulses

System

• Small block and stack allocators
• Centralized tuning parameters
• Highly portable C++ with no use of STL containers

Testbed

• OpenGL with Freeglut
• Graphical user interface with GLUI
• Easily switch between tests using GUI
• Test framework for easily adding new tests
• Mouse picking and the bomb!
• VC8 project files

In particolare il TestBed ha anche un progetto per Xcode così da poter provare su Macosx
i vari esempi (sono tanti e tutti documentatissimi).

Dicevamo che è scritto in C++, in particolare la maggior parte delle funzioni e dei tipi iniziano con il prefisso b2.

E’ facilmente integrabile in qualunque progetto per Iphone, vediamo brevemente quali sono i passi da compiere per crearsi un progetto che abbia un motore Box2d al suo interno.

1) Scaricarsi il codice sorgente di Box2d da http://sourceforge.net/projects/box2d

Attualmente la versione è la 2.0.1  (13 Aprile 2008)

2) Scompattare il tutto su una cartella

3) Creare o aprirsi un progetto Xcode (magari uno che abbia una vista OpenGLEs)

4) Copiare (anche tramite drag & drop) la cartella Source dentro il nostro progetto Xcode

5) Nella propria view includere l’header di Box2d

#include “Box2D.h”

6) Rinominare il file della view in .mm (per mischiare C++ e objective C)

7) Inizialiare un mondo prima di procedere con l’attivazione della vista OpenGLES

Qualcosa di simile:

Da qualche parte definisco le variabili:

[sourcecode language='c++']
b2AABB worldAABB;
b2World *m_world;
[/sourcecode]

E poi l’init del mondo è :

[sourcecode language='c++']
// inizializzo le coordinate del mondo
worldAABB.lowerBound.Set(-100.0f, -100.0f);
worldAABB.upperBound.Set(100.0f, 100.0f);

// Definisco il vettore di gravità
b2Vec2 gravity(0, -9.81f);

// Do we want to let bodies sleep?
bool doSleep = true;

// Costruisco il mondo
m_world= new b2World(worldAABB, gravity, doSleep);

// Definisco il corpo ground (terreno)
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, -15.0f);

// Call the body factory which allocates memory for the ground body
// from a pool and creates the ground box shape (also from a pool).
// The body is also added to the world.
b2Body* groundBody = m_world->CreateBody(&groundBodyDef);

// Define the ground box shape.
b2PolygonDef groundShapeDef;

// The extents are the half-widths of the box.
groundShapeDef.SetAsBox(50.0f, 10.0f);

// Add the ground shape to the ground body.
groundBody->CreateShape(&groundShapeDef);
[/sourcecode]

8 ) Nel main loop (se vogliamo la DrawView della nostra vista OpenGLES) faccio avanzare
la fisica del mondo:

[sourcecode language='c++']
float32 timeStep = 1.0f / 60.0f;
int32 iterations = 10;

// Instruct the world to perform a single step of simulation. It is
// generally best to keep the time step and iterations fixed.
m_world->Step(timeStep, iteration);
[/sourcecode]

(timeStep può essere benissimo animationInterval che usiamo per la view)

9) a questo punto si possono creare oggetti e usando una draw adatta disegnarli per vedere cosa
succede, per esempio se mi creo un cerchio in questo modo:

[sourcecode language='c++']
posX e posY sono la posizione del cerchio
m_body è un oggetto (body) inizializzato così: b2Body *m_body;
m_world è il nostro mondo creato in precedenza
ang è l’angolo di rotazione (in radianti)

// Define the dynamic body. We set its position and call the body
b2BodyDef bodyDef;

bodyDef.position.Set(posX, posY);
bodyDef.angle = ang; // the body’s angle in radians.
//bodyDef.linearDamping = 0.0f;
//bodyDef.angularDamping = 0.01f;
//bodyDef.isBullet = false;
bodyDef.angularDamping = 0.02f;

m_body = m_world->CreateBody(&bodyDef);

// Define box shape for our dynamic body.
b2CircleDef circleDef;

// Set the box density to be non-zero, so it will be dynamic.
circleDef.density = 1.0f;

// Override the default friction.
circleDef.friction = 0.3f;

// Add the shape to the body.
m_body->CreateShape(&circleDef);

// Now tell the dynamic body to compute it’s mass properties base
// on its shape.
m_body->SetMassFromShapes();
[/sourcecode]

Se vedete il codice al body va associato uno shape che sarà poi la forma che permette di controllarne la fisica, le collisioni e molto altro.
Se poi vogliamo disegnare questo oggetto procediamo in opengles a disegnare uno Sprite (c’e’ l’esempio dell’SDK che puo’ tornare utile) con la posizione corretta che prendiamo in questo modo:

[sourcecode language='c++']
// Vettore posizione del body:

b2Vec2 position = m_body->GetPosition();

// X sarà position.x e Y sarà position.y

// Angolo di rotazione del body

float32 angle = m_body->GetAngle();
[/sourcecode]

Una volta presi questi parametri il disegno dell’oggetto è semplicemente tuto codice openGLES:

[sourcecode language='c++']
glPushMatrix();

glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, spriteTexture);

if(m_isBlend) {
// Set a blending function to use
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
// Enable blending
glEnable(GL_BLEND);
}

glTranslatef(position.x, position.y, 0.0f);
glRotatef(angle*(180/b2_pi), 0.0, 0.0, 1.0f);

glVertexPointer(2, GL_FLOAT, 0, m_vertices);
glEnableClientState(GL_VERTEX_ARRAY);

// va tolto il colore se è textured!!! SI MA LO FACCIO SU SETTEXTURE
glColor4f(m_color_r, m_color_g, m_color_b, 1.0);

glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

if(m_isBlend) {
glDisable(GL_BLEND);
}

if(m_isTextured) {
glDisable(GL_TEXTURE_2D);
}

glPopMatrix();
[/sourcecode]

Per voi BugMan e un caloroso ringraziamento da Sir. Lodux !

LINGUAGGIO DI PROGRAMMAZIONE:

Molto semplicemente, se si conosce gia’ qualcosa di C / C ++ conviene utilizzare direttamente questo linguaggio ed impararsi i costrutti e i fondamenti di Objective-C.
Objective-C deve essere necessariamente utilizzato per poter comunicare direttamente con le API del dispositivo e gestire il suo HW (ad esempio per poter creare una view che contiene una finestra OpenGL ES, oppure per poter gestire il touch (o il multitouch), l’accellerometro, … ).

Se non si conosce nessun linguaggio tanto vale imparare l’objective-c da 0.

Quali sono i vantaggi e gli svantaggi di una scelta (C/C++) piuttosto che l’altra (Objective-C) ?

Principalmente la portabilita’. Se scrivo un codice C++, utilizzando le librerie standard il gioco che scrivero’ sara’ molto facile da portare su altre piattaforme (anche su PC stesso) senza troppe modifiche. Per quanto riguarda i dispositivi mobili, windows CE (o mobile), il vecchio Symbian, o anche le stesse Qt (ora passate a Nokia) utilizzano estensivamente e in maniera completa il C++. Android di Google e’ l’unico sistema di API che attualemente utilizza Java e per cui il porting richiede la riscrittura di buona parte di codice.

Conoscendo solo l’Objective-C, per poter fare il porting (trasferire cioe’ l’applicazione da un dispositivo ad un altro) probabilmente ci sara’ molto piu’ lavoro da fare.

Ma non e’ che scrivere in Objective-C porta vantaggi nelle performance dell’applicazione ?

Assolutamente No. Il compilatore GCC e’ in grado di compilare allo stesso modo (ed anche in modo promiscuo) cocice C/C++ ed Objective-C. Molti sviluppatori non hanno trovato nessun calo dal punto di vista delle performance.

E’ possibile “mischiare” codice C++ ed Objective-C ?

Si ! Ed e’ quello che attualmente facciamo noi nel nostro gioco, se si conoscono e si utilizzano entrambi i linguaggi si puo’ prendere il meglio dall’uno e dall’altro e farli convivere tranquillamente.
Ad esempio il codice del nostro gioco che legge i livelli (che sono semplicemente file XML) utilizza il parser presente in Cocoa (la NSXMLParser ) fornendo metodi e comunicando con oggetti C++.

CONCLUSIONI:

Questi i nostri consigli:

Se si conosce gia’ il C++ incominciare ad imparare, quando serve e necessario, Objective-C (le basi sono comunque obbligatorie).

Se si hanno necessita’ e si pensa in futuro di riscrivere il codice per altri dispositivi pensare al C++ come linguaggio “primario”.

Se non si conosce nessun linguaggio e si vuole sviluppare solo per iPod /iPhone (ed al massimo Mac) imparare da 0 e per bene Objective-C.

OpenGL ES:

Se si vuole fare un gioco (sia 2D che 3D) penso la cosa migliore sia imparare ed utilizzare OpenGL ES.
OpenGL ES e’ un API (Application Programming Interface) di basso livello dedicata alla grafica tridimensionale e non solo.
E’ vero che per sviluppare una semplice applicazione 2D probabilmente anche le librerie messe a disposizione da Cocoa (nell’SDK di iPhone) potrebbero essere sufficienti, credo sia comunque meglio imparare OpenGL ES in quanto permette poi di poter sviluppare anche applicazioni 3D e sopratutto (cosa piu’ importante) comunicano a basso livello direttamente con il sottosistema grafico (scheda grafica + GPU).

Ci sono alcuni semplici esempi di utilizzo, basilare di OpenGL ES per una semplice applicazione 2D o 3D che possono essere “studiati”.

FISICA (physics engine):

Un buon gioco ha oramai anche un buon motore fisico alle spalle per gestire collisioni, interazioni tra oggetti, gravita’ , frizione, etc. etc.
Su iPhone vengono attualmente utilizzate due librerie:

* Box2D (nel prossimo articolo)
* Chipmunk (molto piu’ semplice e snella)

LIBRERIE AD ALTO LIVELLO:

Se volete utilizzare delle librerie (o motori grafici) di alto livello per sviluppare (evitando di dover imparare i concetti di basso livello) potete provare benissimo
Cocos2D (per il 2D) (che e’ scritta in Objective-C) o altre librerie gia’ esistenti per il 3D (simili).

AUDIO:

Per l’audio conviene utilizzare le librerie e le API messe a disposizione da Apple nell’SDK.
Ecco… per voi PiXy…! e un grazie da iPhone and Go.

In un mio articolo precedente abbiamo visto come utilizzare la funzione shouldAutorotateToInterfaceOrientation impostando il valore di Return a YES permettendo cosi di gestire nel nostro applicativo la funzione di orientamento nel caso in cui il nostro utilizzatore muove l’iPhone nel sistema “portrait” o “landscape”.

Adesso cercheremo di entrare più nel dettaglio di queste funzioni per adattare (resize) la nostra applicazione e capire le impostazioni che dobbiamo utilizzare.

Innanzi tutto bisogna sapere che ci sono 4 tipi diversi di orientamento :

- UIInterfaceOrientationPortrait

- UIInterfaceOrientationPortraitUpsideDown

- UIInterfaceOrientationLandscapeLeft

- UIInterfaceOrientationLandscapeRight

Quando noi indichiamo nella nostra funzione semplicemente YES, attiviamo tutti e quattro i sistemi se vogliamo ad esempio invece attivare solo l’orientamento verticale (portrait) e quello orizzontale (landscape) sia destro che sinistro, dovremmo indicare la seguente procedura:

[sourcecode language='c++']
- (BOOL)shouldAutorotateToInterfaceOrientation;
(UIInterfaceOrientation)interfaceOrientation {
return (interfaceOrientation == UIInterfaceOrientationPortrait ||
interfaceOrientation == UIInterfaceOrientationLandscapeLeft ||
interfaceOrientation == UIInterfaceOrientationLandscapeRight);
}
[/sourcecode]

fino a qui la procedura che ci e’ stata messa a disposizione da Apple e’ veramente molto semplice ora verifichiamo il tutto utilizzando però la parte grafica della nostra applicazione.

Disegnamo l’interfaccia utilizzando gli attributi di Autoresize.

Clicca qui per vedere il video incorporato.

Per voi Sir. Lodux !

In verità il video doveva essere fatto in un unica parte…. ma ho avuto una “svista” quindi l’ho dovuto integrare in due parti separate !..

Un salutone Sir. Lodux !

iPhoneandGo.it - iphoneandgo@gmail.com

Questo video tutorial iphone vuole dare una spiegazione dopo aver visto il sitema su come gestire la tastiera digitale che l’iphone ci mette a disposizione automaticamente quando si utilizzano componenti come ad esempio Text Field.

Per finire nella seconda parte vedremo come ricavare e assegnare il valore di variazione in una slider e lo assegneremo ad una variabile assegnata ad una Label.
La durata di questo video e’ all’incirca di 25 minuti, se troverete difficoltà nel download, nella qualità, nell’audio vi sarei grato se me lo potrete riferire per cercare di “settare” tutte queste opzione in modo da creare un video sempre più vicino agli standard.

Utilizzo della Slider: prima parte from Stefano Lo Duca – iPhone on Vimeo.

Per voi Sir. Lodux. !

iPhoneandGo.it - iphoneandgo@gmail.com

]]> http://www.iphoneandgo.it/2008/12/30/tutorial-video-sulla-scomparsa-della-tastiera-iphone-e-uso-della-slider-1a-parte/feed/ 15 http://www.iphoneandgo.it/2008/12/25/video-tutorial-iphone-due-pulsanti-un-testo-lsdk-per-iphone/ http://www.iphoneandgo.it/2008/12/25/video-tutorial-iphone-due-pulsanti-un-testo-lsdk-per-iphone/#comments Thu, 25 Dec 2008 07:36:17 +0000 Stefano Lo Duca http://www.iphoneandgo.it/?p=1451 Vi premetto che questo e’ il mio primo Video Tutorial. Spero quindi che possiate comprendere le difficoltà di un primo approccio come questo. Tutto avevo pensato tranne che dare una spiegazione orale davanti ad un computer su concetti tecnici fosse così difficile.

Il tutorial si basa sullo sviluppo di un’applicazione molto semplice: dato due pulsanti (primo, secondo) alla pressione di ognuno di essi verrà generato un testo (Label) che indicherà quale dei due pulsanti e’ stato premuto.

Il video non vuole essere un articolo esaustivo su tutto il codice, procedure che andremo a scrivere ma un’introduzione agli elementi basilari che compongono l’Xcode e quindi la generazione di un applicativo iPhone.

A tutti quelli che hanno suggerimenti tecnici sulla realizzazione degli screenshot e consigli su un’equilibrata realizzazione pesantezza(MB)/qualità ne sarò grato.

Sir. Lodux !

iPhoneandGo.it - iphoneandgo@gmail.com

Come prima cosa da sapere e’ che Objective-C è un linguaggio OOP. OOP significa Object-oriented Program, che significa linguaggio orientato agli oggetti.

(Fonte: www.html.it) L’idea principale che sta dietro la Programmazione ad Oggetti risiede, in buona parte, nel mondo reale. Come spesso accade, gli esempi pratici forniscono una comprensione più chiara ed immediata della teoria e, pertanto, si userà tale approccio per fissare bene in mente i concetti basilari del mondo OOP.

Si prenda in considerazione un comune masterizzatore, come quelli ormai diffusi nella stragrande maggioranza dei moderni PC. Di tale oggetto si conoscono le sue caratteristiche ma quasi nessuno (se non coloro che lo hanno progettato e assemblato) è a conoscenza dei componenti elettronici e dei sofisticati meccanismi che ne regolano il corretto funzionamento, ne’ a qualcuno salterebbe in mente di smontare un masterizzatore prima di acquistarlo per vedere come è fatto all’interno (supposto che il negoziante sia disposto ad accettare una tale richiesta, decisamente fuori dal comune!).

Il concetto che sta dietro alla programmazione ad oggetti nasce dallo stesso principio: ciò che importa non è l’implementazione interna del codice (che corrisponde ai componenti elettronici, nel caso del masterizzatore) ma, piuttosto, le caratteristiche e le azioni che un componente software è in grado di svolgere e che mette a disposizione (espone) all’esterno.

Dunque, con riferimento a quanto gia detto in precedenza, un programma che segue il paradigma OOP è costituito da un numero variabile di tali componenti, che ora denominiamo oggetti, i quali interagiscono tra di essi attraverso lo scambio di messaggi.

Proseguendo nell’esempio del masterizzatore e supponendo di voler implementare un oggetto software che ne gestisca le funzionalità, potremmo iniziare a definirne le caratteristiche. Ad esempio:

• Marca
• Velocità di scrittura su supporti CD-R
• Velocità di scrittura su supporti CD-RW
• Velocità di lettura
• Interfaccia
• Dimensione del buffer dati

Mentre, per quanto riguarda le azioni potremmo considerare le seguenti:

• Scrivi su CD
• Scrivi su DVD
• Leggi CD
• Espelli CD

In parole molto semplici, potremmo dire che le azioni altro non sono che “le cose che un oggetto è in grado di fare” mentre le sue caratteristiche rappresentano i dati che le azioni stesse possono utilizzare per eseguire le operazioni che da esse ci si aspetta.

In OOP, le caratteristiche di un oggetto vengono denominate proprietà e le azioni sono dette metodi. Questi sono due concetti fondamentali ed è molto importante che siano ben chiari prima di introdurre nuove definizioni.

Per maggiori dettagli sui concetti della programmazione ad oggetti vi consiglio di visitare questa guida dalla quale ho preso parte dell’articolo : Guida alla programmazione ad oggetti.

Objective-C è definito come un piccolo ma potente linguaggio che nasce dal linguaggio standard C. Per chi quindi vuole imparare questo linguaggio e di conseguenza programmare per iPhone deve conoscere cos’e’ una programmazione ad oggetti e preferibilmente deve aver famigliarizzato con la programmazione in C, C++ o Java.

I programmi per Mac OS X sono scritti in Objective-C. Objective-C e’ una tecnologia che risale ancora agli anni 80′.

Sir. Lodux !

iPhoneandGo.it - iphoneandgo@gmail.com