Ok grazie, il linguaggio è [obj-c] e posto un po' di codice. Questa è la versione originale dell'autore della classe, la mia differisce solo nell'esporre come proprietà le altezze delle onde in modo da farle interagire con il motore fisico (box2d) e nel rendeering di una texture al posto di un poligono trasparente. Anche la mia versione funziona perfettamente, quindi posto l'originale perché è più pulita e comprensibile:
codice:
//
// Waves1DNode.h
// Waves1D
//
// Created by Scott Lembcke on 12/10/11.
// Copyright Howling Moon Software 2011. All rights reserved.
//
#import "cocos2d.h"
@interface Waves1DNode : CCNode {
CGRect _bounds;
float _diffusion;
float _damping;
int _count;
// Heightfields that the simulation vertlet integrates between.
float *_h1, *_h2;
}
// 'bounds' are the rectangle to draw for the water. The top of the bounds is the rest height for the water, it wil wave above and below it.
// 'count' is the number of slices to simulate. One per 10-20 pixels is usually sufficient.
// 'damping' is how fast the water settles back to rest. 1.0 is never (bad), 0.0 is immediately (also bad). 0.99 is a decent damping amount.
// 'diffusion' is how fast the waves spread to neighbors. Values outside of 0.6 - 0.9 can become unstable.
-(id)initWithBounds:(CGRect)bounds count:(int)count damping:(float)damping diffusion:(float)diffusion;
-(void)makeSplashAt:(float)x;
@end
codice:
//
// Waves1DNode.m
// Waves1D
//
// Created by Scott Lembcke on 12/10/11.
// Copyright Howling Moon Software 2011. All rights reserved.
//
#import "Waves1DNode.h"
@implementation Waves1DNode
-(id)initWithBounds:(CGRect)bounds count:(int)count damping:(float)damping diffusion:(float)diffusion;
{
if((self = [super init])){
_bounds = bounds;
_count = count;
_damping = damping;
_diffusion = diffusion;
_h1 = calloc(_count, sizeof(float));
_h2 = calloc(_count, sizeof(float));
}
return self;
}
- (void) dealloc
{
free(_h1);
free(_h2);
[super dealloc];
}
-(void)vertlet {
for(int i=0; i<_count; i++) _h1[i] = 2.0*_h2[i] - _h1[i];
float *temp = _h2;
_h2 = _h1;
_h1 = temp;
}
static inline float
diffuse(float diff, float damp, float prev, float curr, float next){
return (curr*diff + ((prev + next)*0.5f)*(1.0f - diff))*damp;
}
-(void)diffuse {
float prev = _h2[0];
float curr = _h2[0];
float next = _h2[1];
_h2[0] = diffuse(_diffusion, _damping, prev, curr, next);
for(int i=1; i<(_count - 1); ++i){
prev = curr;
curr = next;
next = _h2[i + 1];
_h2[i] = diffuse(_diffusion, _damping, prev, curr, next);
}
prev = curr;
curr = next;
_h2[_count - 1] = diffuse(_diffusion, _damping, prev, curr, next);
}
-(float)dx{return _bounds.size.width/(GLfloat)(_count - 1);}
- (void)draw {
// It would be better to run these on a fixed timestep.
// As an GFX only effect it doesn't really matter though.
[self vertlet];
[self diffuse];
GLfloat dx = [self dx];
GLfloat top = _bounds.size.height;
// Build a vertex array and render it.
struct Vertex{GLfloat x,y;};
struct Vertex verts[_count*2];
for(int i=0; i<_count; i++){
GLfloat x = i*dx;
verts[2*i + 0] = (struct Vertex){x, 0};
verts[2*i + 1] = (struct Vertex){x, top + _h2[i]};
}
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
GLfloat r = 105.0f/255.0f;
GLfloat g = 193.0f/255.0f;
GLfloat b = 212.0f/255.0f;
GLfloat a = 0.3f;
glColor4f(r*a, g*a, b*a, a);
glVertexPointer(2, GL_FLOAT, 0, verts);
glPushMatrix(); {
glScalef(CC_CONTENT_SCALE_FACTOR(), CC_CONTENT_SCALE_FACTOR(), 1.0);
glTranslatef(_bounds.origin.x, _bounds.origin.y, 0.0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, _count*2);
} glPopMatrix();
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
-(void)makeSplashAt:(float)x;
{
// Changing the values of heightfield in h2 will make the waves move.
// Here I only change one column, but you get the idea.
// Change a bunch of the heights using a nice smoothing function for a better effect.
int index = MAX(0, MIN((int)(x/[self dx]), _count - 1));
_h2[index] += CCRANDOM_MINUS1_1()*20.0;
}
@end
/**
-Ideas to make it better:
* Add clamping to avoid giant, crappy looking waves.
* Make it run on a fixed timestep.
* Add texturing to give the surface a nice (and anti-aliased) look.
* Fancier makeSplash method that does more than a single point.
*/
Per realizzare l'acqua che scorre(scrolla in 2d sullo schermo) ho usato il solito trucchetto dei due elementi che si inseguono rimpiazzandosi come nell'immagine qua sotto:
Le mie 2 acque si inseguono sostituendosi l'una all'altra e passandosi le altezze del primo e dell'ultimo vertice al fine di creare una continuità fra le onde la dove le acque si uniscono :Mosè:
Non sono soddisfatto perché si nota sempre una piccola cresta aggiuntiva sulle onde che passano in prossimità del punto di giunzione delle acque e oltretutto trovo dispendioso avere due acque al posto di una che resta fissa sullo schermo e che accetta come parametro la velocità di scorrimento.
Quindi ho provato a modificare la classe in modo che gli elementi dell'array delle altezze scalassero verso l'inizio o la fine dello stesso a seconda della direzione di scorrimento dell'acqua. Funziona nel senso che fa scorrere le onde nella direzione giusta ma è ovvio che non ne posso controllare la velocità perché questa è data solo dallo scalare di posizione degli elementi del vettore e che quindi non è possibile fare interpolazioni perché non ci sono posizioni intermedie(il piano d'acqua è costituito da un numero di punti limitato così come l'array che li contiene)
A me servirebbe di riuscire a interpolare i valori della formula in modo che questi tendano a propagarsi in direzione dell'inizio o della fine dell'array in base a una velocità variabile...
Edit: in realtà non necessito di consigli scritti in objective-c, va benissimo pseudo codice o anche solo una mezza idea! ;)
Rispondi quotando
