Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

384 lines (335 sloc) 10.35 kb
/*
* cocos2d for iPhone: http://www.cocos2d-iphone.org
*
* Copyright (c) 2008, 2009 Jason Booth
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/*
* A ribbon is a dynamically generated list of polygons drawn as a single or series
* of triangle strips. The primary use of Ribbon is as the drawing class of Motion Streak,
* but it is quite useful on it's own. When manually drawing a ribbon, you can call addPointAt
* and pass in the parameters for the next location in the ribbon. The system will automatically
* generate new polygons, texture them accourding to your texture width, etc, etc.
*
* Ribbon data is stored in a RibbonSegment class. This class statically allocates enough verticies and
* texture coordinates for 50 locations (100 verts or 48 triangles). The ribbon class will allocate
* new segments when they are needed, and reuse old ones if available. The idea is to avoid constantly
* allocating new memory and prefer a more static method. However, since there is no way to determine
* the maximum size of some ribbons (motion streaks), a truely static allocation is not possible.
*
*/
#import "CCRibbon.h"
#import "CCTextureCache.h"
#import "Support/CGPointExtension.h"
#import "ccMacros.h"
//
// Ribbon
//
@implementation CCRibbon
@synthesize blendFunc=blendFunc_;
@synthesize color=color_;
@synthesize textureLength = textureLength_;
+(id)ribbonWithWidth:(float)w image:(NSString*)path length:(float)l color:(ccColor4B)color fade:(float)fade
{
self = [[[self alloc] initWithWidth:w image:path length:l color:color fade:fade] autorelease];
return self;
}
-(id)initWithWidth:(float)w image:(NSString*)path length:(float)l color:(ccColor4B)color fade:(float)fade
{
self = [super init];
if (self)
{
segments_ = [[NSMutableArray alloc] init];
deletedSegments_ = [[NSMutableArray alloc] init];
/* 1 initial segment */
CCRibbonSegment* seg = [[CCRibbonSegment alloc] init];
[segments_ addObject:seg];
[seg release];
textureLength_ = l;
color_ = color;
fadeTime_ = fade;
lastLocation_ = CGPointZero;
lastWidth_ = w/2;
texVPos_ = 0.0f;
curTime_ = 0;
pastFirstPoint_ = NO;
/* XXX:
Ribbon, by default uses this blend function, which might not be correct
if you are using premultiplied alpha images,
but 99% you might want to use this blending function regarding of the texture
*/
blendFunc_.src = GL_SRC_ALPHA;
blendFunc_.dst = GL_ONE_MINUS_SRC_ALPHA;
self.texture = [[CCTextureCache sharedTextureCache] addImage:path];
/* default texture parameter */
ccTexParams params = { GL_LINEAR, GL_LINEAR, GL_REPEAT, GL_REPEAT };
[texture_ setTexParameters:&params];
}
return self;
}
-(void)dealloc
{
[segments_ release];
[deletedSegments_ release];
[texture_ release];
[super dealloc];
}
// rotates a point around 0, 0
-(CGPoint)rotatePoint:(CGPoint)vec rotation:(float)a
{
float xtemp = (vec.x * cosf(a)) - (vec.y * sinf(a));
vec.y = (vec.x * sinf(a)) + (vec.y * cosf(a));
vec.x = xtemp;
return vec;
}
-(void)update:(ccTime)delta
{
curTime_+= delta;
delta_ = delta;
}
-(float)sideOfLine:(CGPoint)p l1:(CGPoint)l1 l2:(CGPoint)l2
{
CGPoint vp = ccpPerp(ccpSub(l1, l2));
CGPoint vx = ccpSub(p, l1);
return ccpDot(vx, vp);
}
// adds a new segment to the ribbon
-(void)addPointAt:(CGPoint)location width:(float)w
{
location.x *= CC_CONTENT_SCALE_FACTOR();
location.y *= CC_CONTENT_SCALE_FACTOR();
w = w*0.5f;
// if this is the first point added, cache it and return
if (!pastFirstPoint_)
{
lastWidth_ = w;
lastLocation_ = location;
pastFirstPoint_ = YES;
return;
}
CGPoint sub = ccpSub(lastLocation_, location);
float r = ccpToAngle(sub) + (float)M_PI_2;
CGPoint p1 = ccpAdd([self rotatePoint:ccp(-w, 0) rotation:r], location);
CGPoint p2 = ccpAdd([self rotatePoint:ccp(w, 0) rotation:r], location);
float len = sqrtf(powf(lastLocation_.x - location.x, 2) + powf(lastLocation_.y - location.y, 2));
float tend = texVPos_ + len/textureLength_;
CCRibbonSegment* seg;
// grab last segment
seg = [segments_ lastObject];
// lets kill old segments
for (CCRibbonSegment* seg2 in segments_)
{
if (seg2 != seg && seg2->finished)
{
[deletedSegments_ addObject:seg2];
}
}
[segments_ removeObjectsInArray:deletedSegments_];
// is the segment full?
if (seg->end >= 50)
[segments_ removeObjectsInArray:deletedSegments_];
// grab last segment and append to it if it's not full
seg = [segments_ lastObject];
// is the segment full?
if (seg->end >= 50)
{
CCRibbonSegment* newSeg;
// grab it from the cache if we can
if ([deletedSegments_ count] > 0)
{
newSeg = [deletedSegments_ objectAtIndex:0];
[newSeg retain]; // will be released later
[deletedSegments_ removeObject:newSeg];
[newSeg reset];
}
else
{
newSeg = [[CCRibbonSegment alloc] init]; // will be released later
}
newSeg->creationTime[0] = seg->creationTime[seg->end - 1];
int v = (seg->end-1)*6;
int c = (seg->end-1)*4;
newSeg->verts[0] = seg->verts[v];
newSeg->verts[1] = seg->verts[v+1];
newSeg->verts[2] = seg->verts[v+2];
newSeg->verts[3] = seg->verts[v+3];
newSeg->verts[4] = seg->verts[v+4];
newSeg->verts[5] = seg->verts[v+5];
newSeg->coords[0] = seg->coords[c];
newSeg->coords[1] = seg->coords[c+1];
newSeg->coords[2] = seg->coords[c+2];
newSeg->coords[3] = seg->coords[c+3];
newSeg->end++;
seg = newSeg;
[segments_ addObject:seg];
[newSeg release]; // it was retained before
}
if (seg->end == 0)
{
// first edge has to get rotation from the first real polygon
CGPoint lp1 = ccpAdd([self rotatePoint:ccp(-lastWidth_, 0) rotation:r], lastLocation_);
CGPoint lp2 = ccpAdd([self rotatePoint:ccp(+lastWidth_, 0) rotation:r], lastLocation_);
seg->creationTime[0] = curTime_ - delta_;
seg->verts[0] = lp1.x;
seg->verts[1] = lp1.y;
seg->verts[2] = 0.0f;
seg->verts[3] = lp2.x;
seg->verts[4] = lp2.y;
seg->verts[5] = 0.0f;
seg->coords[0] = 0.0f;
seg->coords[1] = texVPos_;
seg->coords[2] = 1.0f;
seg->coords[3] = texVPos_;
seg->end++;
}
int v = seg->end*6;
int c = seg->end*4;
// add new vertex
seg->creationTime[seg->end] = curTime_;
seg->verts[v] = p1.x;
seg->verts[v+1] = p1.y;
seg->verts[v+2] = 0.0f;
seg->verts[v+3] = p2.x;
seg->verts[v+4] = p2.y;
seg->verts[v+5] = 0.0f;
seg->coords[c] = 0.0f;
seg->coords[c+1] = tend;
seg->coords[c+2] = 1.0f;
seg->coords[c+3] = tend;
texVPos_ = tend;
lastLocation_ = location;
lastPoint1_ = p1;
lastPoint2_ = p2;
lastWidth_ = w;
seg->end++;
}
-(void) draw
{
[super draw];
if ([segments_ count] > 0)
{
// Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY
// Needed states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_TEXTURE_COORD_ARRAY
// Unneeded states: GL_COLOR_ARRAY
glDisableClientState(GL_COLOR_ARRAY);
glBindTexture(GL_TEXTURE_2D, [texture_ name]);
BOOL newBlend = blendFunc_.src != CC_BLEND_SRC || blendFunc_.dst != CC_BLEND_DST;
if( newBlend )
glBlendFunc( blendFunc_.src, blendFunc_.dst );
for (CCRibbonSegment* seg in segments_)
[seg draw:curTime_ fadeTime:fadeTime_ color:color_];
if( newBlend )
glBlendFunc(CC_BLEND_SRC, CC_BLEND_DST);
// restore default GL state
glEnableClientState( GL_COLOR_ARRAY );
}
}
#pragma mark Ribbon - CocosNodeTexture protocol
-(void) setTexture:(CCTexture2D*) texture
{
[texture_ release];
texture_ = [texture retain];
[self setContentSizeInPixels: texture.contentSizeInPixels];
/* XXX Don't update blending function in Ribbons */
}
-(CCTexture2D*) texture
{
return texture_;
}
@end
#pragma mark -
#pragma mark RibbonSegment
@implementation CCRibbonSegment
-(id)init
{
self = [super init];
if (self)
{
[self reset];
}
return self;
}
- (NSString*) description
{
return [NSString stringWithFormat:@"<%@ = %08X | end = %i, begin = %i>", [self class], self, end, begin];
}
- (void) dealloc
{
CCLOGINFO(@"cocos2d: deallocing %@", self);
[super dealloc];
}
-(void)reset
{
end = 0;
begin = 0;
finished = NO;
}
-(void)draw:(float)curTime fadeTime:(float)fadeTime color:(ccColor4B)color
{
GLubyte r = color.r;
GLubyte g = color.g;
GLubyte b = color.b;
GLubyte a = color.a;
if (begin < 50)
{
// the motion streak class will call update and cause time to change, thus, if curTime_ != 0
// we have to generate alpha for the ribbon each frame.
if (curTime == 0)
{
// no alpha over time, so just set the color
glColor4ub(r,g,b,a);
}
else
{
// generate alpha/color for each point
glEnableClientState(GL_COLOR_ARRAY);
uint i = begin;
for (; i < end; ++i)
{
int idx = i*8;
colors[idx] = r;
colors[idx+1] = g;
colors[idx+2] = b;
colors[idx+4] = r;
colors[idx+5] = g;
colors[idx+6] = b;
float alive = ((curTime - creationTime[i]) / fadeTime);
if (alive > 1)
{
begin++;
colors[idx+3] = 0;
colors[idx+7] = 0;
}
else
{
colors[idx+3] = (GLubyte)(255.f - (alive * 255.f));
colors[idx+7] = colors[idx+3];
}
}
glColorPointer(4, GL_UNSIGNED_BYTE, 0, &colors[begin*8]);
}
glVertexPointer(3, GL_FLOAT, 0, &verts[begin*6]);
glTexCoordPointer(2, GL_FLOAT, 0, &coords[begin*4]);
glDrawArrays(GL_TRIANGLE_STRIP, 0, (end - begin) * 2);
}
else
finished = YES;
}
@end
Jump to Line
Something went wrong with that request. Please try again.