Additive Coloring Solution? Thoughts?

cocos2d for iPhone » Programming » cocos2d support (graphics engine)

Additive Coloring Solution? Thoughts?

(46 posts) (15 voices)

Started 8 months ago by Par
Latest reply from Harrison Xi

Tags:

« Previous 12

Par
Member

@Birkemose,
Thanks! I had no idea how the whole setColor thing was being GL_PREVIOUS but this helps make sense of it. Also thanks for explaining ADD_SIGNED because I couldn't figure out what the + 0.5 meant until reading your post.

Sadly though, I'm pretty sure GL_ADD cannot produce what I am after. I'm trying to push the texture towards a specific color. In the end it could be adding or subtracting needed on a per pixel basis. In other words, if I am trying to tint a texture blue and that texture is a black and white checkerboard... I want both the black and the white to move closer to blue.

Posted 8 months ago #
Birkemose
Moderator

The method I described, will certainly tint an image towards a certain color, ADDING luminance to the image. I thought that was what you were after?

More advanced color manipulation is possible, but it would probably include two texture stages.
Search the net for Apples glImageProcessing example. It pretty much shows what is possible using more than one stage.

Posted 8 months ago #
Par
Member

@Birkemose
I agree, it definitely tints towards. The problem is the luminance. Depending on the sprite it will overpower too quickly and you never truly see the color you are tinting towards. Interestingly I've found a way to add a color to the darks and lights of an image using GL_BLEND but each has to be done seperately. Not really what I am after but could be a solid enough solution to prevent me needing two texture stages or two sprites. At this point, I'm merely experimenting to see what is possible. Thanks for all the help!! I'm definitely going to check out that glImageProcessing.

Posted 8 months ago #
Birkemose
Moderator

@Par
I really think add will do the trick, but you have to change the tint color to produce the desired effect, also transparency isnt part of the equation ( the light cyan image is transparent ). You seem focused on using the light cyan image as a tint reference. Any reason why it has to be light cyan? Isnt the end product what matters?
Or am I missing something?

Using GL_ADD_SIGNED, you can tint to pretty much any luminance level you need. glColor4f( 1, 1, 0.5, 1 ) will tint a bright yellow, while ( 0.5, 0.5, 0, 1 ) will tint a much darker yellow.

Posted 8 months ago #
psykano
Member

@Par I really admire your perseverance in getting it to look exactly how you want. I've been following this thread closely and while I can't contribute much in terms of an OpenGL code discussion I'm still finding it interesting.

Posted 8 months ago #
Par
Member
@Birkemose
You're right, I could use ADD_SIGNED and get it to produce the color I need (at least very close) because ADD_SIGNED can be used to substract as well. And I agree the end product is all that matters. So could this be the solution, absolutely. But the solution won't be the same for every sprite depending on the colors that make it up.

Here's the thing, I'm not really looking for a solution to turn the floating island blue green. I'm looking for one to turn any sprite any color slowly and programmatically (like Adobe Flash tinting). The graphic is an example of how I want it to behave. If I add cyan at 50%, I want the island to change by 50% toward the color cyan.

BTW, you've helped me out tremendously! Everything you linked to has been perfect in helping me figure out how everything works. I still don't fully understand what I am doing but I'm definitely miles ahead of where I was 4 days ago. And I'm about 95% sure I found the solution with GL_INTERPOLATE. In all my tests this has worked great. I can move a sprite from normal to whatever solid color I want gradually based on the opacity of the tinting.
```
float tinting[4] = { 0.0f, 1.0f, 1.0f, 0.5f };
	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, tinting);		

	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_INTERPOLATE);
	glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);
	glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_CONSTANT);
	glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB,         GL_CONSTANT);
	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB,	  GL_ONE_MINUS_SRC_ALPHA);
	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_SUBTRACT);
	glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE); //default
	glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PREVIOUS); //default
	glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
```
The reason I need to use GL_CONSTANT(set by CL_TEXTURE_ENV_COLOR) here is because I want to be able to change the opacity of the overlaying tint color. If I use GL_PREVIOUS(setColor/glColor4f) it will change the opacity of the sprite and the overlaying tint at the same time.

I can make this work on a sprite variably but I have no idea how to send those tint values variably into a BatchNode.
Currently I'm overriding drawNumberOfQuads in CCTextureAtlas to modify color in a BatchNode. Is there another/better way? Or is this it. I'm not really sure how to pass data down to this level. I know it will have to be in the quads_ var and I'll probably have to modify the ccV3F_C4B_T2F struct but I'm confused past that.

Trying to figure this out:
```
NSUInteger offset = (NSUInteger)quads_;

	// vertex
	NSUInteger diff = offsetof( ccV3F_C4B_T2F, vertices);
	glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (GLvoid*)(offset + diff));
```
Particularly this part.
```
(GLvoid*)(offset + diff)
```
@psykano
Thanks! Hopefully I'm making enough sense that someone with the same issues in the future will be able to figure out what to do.
Posted 8 months ago #
Birkemose
Moderator

@Par
You lost me a bit in what you are trying to obtain, but I think psykano put it very well, that it is an interesting subject.
Please keep us updated on your progress.

Posted 8 months ago #
GoldenJoe
Member

Did you ever find a solution? This is pretty interesting.

Posted 6 months ago #

plugboy
Member

This is a really useful post for me to solve a similar problem! Thank you guys!

I found a solution to set the sprite's tint values variably in a batchnode at last after several nights of study and tests.

Now I can change my sprite to any opaque color as well as any other color tint, no matter it is an individual sprite or a sprite in a batchnode.

What I've done is subclassing ccsprite and ccspritebatchnode and override the draw method to have the following code, the key is to use GL_PRIMARY_COLOR in the interpolation of the RGB value:

glActiveTexture( GL_TEXTURE0 );
    glEnable( GL_TEXTURE_2D );

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    // The vertex color set by setColorA will cover the sprite's texture
    // GL_PREVIOUS equals the vertex color
    // GL_TEXTURE equals the sprite's texture
    // We will use the vertex's color's primary color to control the blending
    // The vertex color's alpha value can be set by the new colorA property

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_PRIMARY_COLOR); // primary color is the actual vertex colors
    // the vertex color with alpha value will control how much the set color will affect the sprite

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

Then in my subclassed ccsprite, I add a property similar to the original color property, but will accept a cccolor4B value:

@synthesize colorA;

-(id) init
{
	if( (self=[super init]) ) {

        self.colorA = ccc4(255, 255, 255, 0);

	}

	return self;
}

- (void)setColorA:(ccColor4B)color4
{

    // Set the colorA ivar
    colorA = color4;

    // Set the color_ also
    ccColor3B color3 = {color4.r, color4.g, color4.b};

    // color_ = colorUnmodified_ = color3;
    self.color = color3;

	if( opacityModifyRGB_ ){
		color_.r = color3.r * opacity_/255;
		color_.g = color3.g * opacity_/255;
		color_.b = color3.b * opacity_/255;

        // change the alpha also
        colorA.a = color4.a * opacity_/255;
	}

	//[self updateColor];

}

-(void) updateColor
{
	// Set the vertex colors alpha value to the new colorA.a property
    ccColor4B color4 = {color_.r, color_.g, color_.b, self.colorA.a};

	quad_.bl.colors = color4;
	quad_.br.colors = color4;
	quad_.tl.colors = color4;
	quad_.tr.colors = color4;

	// renders using Sprite Manager
	if( usesBatchNode_ ) {
		if( atlasIndex_ != CCSpriteIndexNotInitialized)
			[textureAtlas_ updateQuad:&quad_ atIndex:atlasIndex_];
		else
			// no need to set it recursively
			// update dirty_, don't update recursiveDirty_
			dirty_ = YES;
	}
	// self render
	// do nothing
}

Then you can set the colorA property of your sprite to get different tinting effect, for example:
yourSprite.colorA = ccc4(255, 255, 0, 255); ------> change the sprite to a opaque yellow
yourSprite.colorA = ccc4(255, 255, 0, 100); ------> get a yellowish tint
yourSprite.colorA = ccc4(255, 255, 255, 100); ----> brighten your sprite
yourSprite.colorA = ccc4(0,0,0,200); ------------> darken your sprite

I am not sure if this is the perfect solution but this works for me currently. Hope you will find it useful.

Posted 4 months ago #

plugboy
Member

After some more tests I found that although the tinting works great now, I can't correctly set the sprite's opacity anymore.
action like fade in and fade out don't work anymore too.... I am not sure if I can fix this.

Posted 4 months ago #
araker
Moderator
@plugboy, this is interesting code, thanks for sharing. I have a few remarks though..

I don't understand why you need a extra color property. You can achieve the same with setColor and setOpacity.

When a color has a premultiplied alpha it means that the RGB values change along with the opacity. The alpha (opacity) doesn't need to be multiplied.

So this line isn't necessary..
```
// change the alpha also
        colorA.a = color4.a * opacity_/255;
```
Fading uses setOpacity, which doesn't work anymore in your code because updateColor takes the alpha value of colorA instead of the opacity_ property.

I think it's better to only override the draw method and leave the color/opacity modifiers as they are.
Posted 4 months ago #

plugboy
Member

@araker, thanks for the sharing! I added the extra property because I would like to see if I can use the alpha value in this ccc4 color to set the opacity of the tint while the original opacity value will be used to set the overall opacity of the sprite.

I tried to drop the updateColor override and yes the tinting can be achieved by setColor and the opacity of the sprite (with just some minor color difference). But I found that I still can't change the opacity of the sprite anymore, although the updateColor method now is using the opacity_ value of the sprite.

Test

I think this is caused by the gltexenv setting in my draw method instead. Maybe I need to combine the alpha in another way but I just can't figure it out. I am really new to opengl. I think my code now set the alpha value to fully opaque no matter what the sprite's opacity setting is. I need to set the alpha back to the sprite's opacity without affecting the tinting. Below is the full code of my draw method in my subclassed ccsprite and ccspritebatchnode:

ccSprite:

-(void) draw
{
	//[super draw];

    NSAssert(!usesBatchNode_, @"If CCSprite is being rendered by CCSpriteBatchNode, CCSprite#draw SHOULD NOT be called");

	// 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_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY
	// Unneeded states: -

	BOOL newBlend = NO;
	if( blendFunc_.src != CC_BLEND_SRC || blendFunc_.dst != CC_BLEND_DST ) {
		newBlend = YES;
		glBlendFunc( blendFunc_.src, blendFunc_.dst );
	}

#define kQuadSize sizeof(quad_.bl)

	//set blend function...
	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //you can force it here or set it on the sprite

	//the magic

    // Using texture unit 0
    glActiveTexture( GL_TEXTURE0 );
	glEnable( GL_TEXTURE_2D );

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    // The vertex color set by setColor will cover the sprite's texture
    // GL_PREVIOUS equals the vertex color
    // GL_TEXTURE equals the sprite's texture
    // We will use the vertex's color's primary color to control the blending
    // The vertex color's alpha value can be set by the new colorA property

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_PRIMARY_COLOR); // primary color is the actual vertex colors
    // the vertex color including the added alpha value will control how much the set color will affect the sprite

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);

    glBindTexture(GL_TEXTURE_2D, [texture_ name]);

    // The address of the quad array
	long offset = (long)&quad_;

	// vertex
	NSInteger diff = offsetof( ccV3F_C4B_T2F, vertices);
	glVertexPointer(3, GL_FLOAT, kQuadSize, (void*) (offset + diff) );

	// color
	diff = offsetof( ccV3F_C4B_T2F, colors);
	glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (void*)(offset + diff));

	// tex coords
	diff = offsetof( ccV3F_C4B_T2F, texCoords);
	glTexCoordPointer(2, GL_FLOAT, kQuadSize, (void*)(offset + diff));

	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

	if( newBlend )
		glBlendFunc(CC_BLEND_SRC, CC_BLEND_DST);

#if CC_SPRITE_DEBUG_DRAW
	CGSize s = [self contentSize];
	CGPoint vertices[4]={
		ccp(0,0),ccp(s.width,0),
		ccp(s.width,s.height),ccp(0,s.height),
	};
	ccDrawPoly(vertices, 4, YES);
#endif // CC_TEXTURENODE_DEBUG_DRAW

    //go back to default
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

}

CCSpriteBatchNode:

-(void) draw
{
	//[super draw];

	// Optimization: Fast Dispatch
	if( textureAtlas_.totalQuads == 0 )
		return;	

	//CCSprite *child;
    MyCCSprite *child;

	ccArray *array = descendants_->data;

	NSUInteger i = array->num;
	id *arr = array->arr;

	if( i > 0 ) {

		while (i-- > 0) {
			child = *arr++;

			// fast dispatch
			child->updateMethod(child, selUpdate);

#if CC_SPRITEBATCHNODE_DEBUG_DRAW
			//Issue #528
			CGRect rect = [child boundingBox];
			CGPoint vertices[4]={
				ccp(rect.origin.x,rect.origin.y),
				ccp(rect.origin.x+rect.size.width,rect.origin.y),
				ccp(rect.origin.x+rect.size.width,rect.origin.y+rect.size.height),
				ccp(rect.origin.x,rect.origin.y+rect.size.height),
			};

			ccDrawPoly(vertices, 4, YES);

#endif // CC_SPRITEBATCHNODE_DEBUG_DRAW
		}
	}

    //the magic

    // Using texture unit 0
    glActiveTexture( GL_TEXTURE0 );
	glEnable( GL_TEXTURE_2D );

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    // The vertex color set by setColor will cover the sprite's texture
    // GL_PREVIOUS equals the vertex color
    // GL_TEXTURE equals the sprite's texture
    // We will use the vertex's color's primary color to control the blending
    // The vertex color's alpha value can be set by the new colorA property

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_PRIMARY_COLOR); // primary color is the actual vertex colors
    // the vertex color including the added alpha value will control how much the set color will affect the sprite

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);

	BOOL newBlend = blendFunc_.src != CC_BLEND_SRC || blendFunc_.dst != CC_BLEND_DST;
	if( newBlend )
		glBlendFunc( blendFunc_.src, blendFunc_.dst );

	[textureAtlas_ drawQuads];

	if( newBlend )
		glBlendFunc(CC_BLEND_SRC, CC_BLEND_DST);

    //go back to default
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

}

Posted 4 months ago #

araker
Moderator

I haven't played much with the texture environment settings. Reading the specs, it seems odd that you use 3 arguments in the RGB part. When operand 0 is the vertex color and operand 1 is the texture color, why do you need the primary color as well for operand 2? It seems you don't need operand 2 at all.

In the alpha part GL_REPLACE takes the alpha from operand 0, that is the alpha from the texture. The opacity_ is the alpha from the vertex color, so if you want to use the vertex alpha GL_PREVIOUS should be operand 0 instead of GL_TEXTURE. Now, like you suspected, the opacity isn't used at all.

Posted 4 months ago #
Par
Member

@plugboy, The last post I have here pretty much describes the solution, the only thing you really need is a way to change the tinting amount. You could change setColor to take alpha as well but instead I chose to simply create a colorOpacity variable. I've had issues with getting the alpha to work as well when it comes to additive combining the textures. I haven't spent a lot of time trying to solve that issue because I don't need it yet. However, the code I'm using for tinting allows you to fade sprites in and out no problem.

If you are having problems with setOpacity not working though, it's likely because the way you are combining the textures, at least from my experience.

Here check out the article I just wrote on it, should solve your problem: http://digitallybold.com/314/cocos2d-additive-sprite-color-tinting

Hope this helps.

Posted 4 months ago #

Harrison Xi
Member

Hi @Par & @plugboy,

I tried to use glTexEnvi in cocos2d-iphone, but it did not work. Did I miss something? Here are my codes, could you help to take a look?

@implementation CCSpriteTint

@synthesize colorOpacity = colorOpacity_;

-(void) draw
{
	CC_PROFILER_START_CATEGORY(kCCProfilerCategorySprite, @"CCSprite - draw");

	NSAssert(!batchNode_, @"If CCSprite is being rendered by CCSpriteBatchNode, CCSprite#draw SHOULD NOT be called");

	CC_NODE_DRAW_SETUP();

	// set blend func
	ccGLBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

	// enable
	glActiveTexture( GL_TEXTURE0 );
	glEnable( GL_TEXTURE_2D );

	ccGLBindTexture2D( [texture_ name] );

	// set color
	float tinting[4] = { color_.r/255.0f, color_.g/255.0f, color_.b/255.0f, colorOpacity_/255.0f };
	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, tinting);

	// texEnvi
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
	glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_ADD);
	glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS); // color
	glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE); // texture

	//
	// Attributes
	//

	ccGLEnableVertexAttribs( kCCVertexAttribFlag_PosColorTex );

#define kQuadSize sizeof(quad_.bl)
	long offset = (long)&quad_;

	// vertex
	NSInteger diff = offsetof( ccV3F_C4B_T2F, vertices);
	glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, kQuadSize, (void*) (offset + diff));

	// texCoods
	diff = offsetof( ccV3F_C4B_T2F, texCoords);
	glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, (void*)(offset + diff));

	// color
	diff = offsetof( ccV3F_C4B_T2F, colors);
	glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (void*)(offset + diff));

	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

	CHECK_GL_ERROR_DEBUG();

#if CC_SPRITE_DEBUG_DRAW == 1
	// draw bounding box
	CGPoint vertices[4]={
		ccp(quad_.tl.vertices.x,quad_.tl.vertices.y),
		ccp(quad_.bl.vertices.x,quad_.bl.vertices.y),
		ccp(quad_.br.vertices.x,quad_.br.vertices.y),
		ccp(quad_.tr.vertices.x,quad_.tr.vertices.y),
	};
	ccDrawPoly(vertices, 4, YES);
#elif CC_SPRITE_DEBUG_DRAW == 2
	// draw texture box
	CGSize s = self.textureRect.size;
	CGPoint offsetPix = self.offsetPosition;
	CGPoint vertices[4] = {
		ccp(offsetPix.x,offsetPix.y), ccp(offsetPix.x+s.width,offsetPix.y),
		ccp(offsetPix.x+s.width,offsetPix.y+s.height), ccp(offsetPix.x,offsetPix.y+s.height)
	};
	ccDrawPoly(vertices, 4, YES);
#endif // CC_SPRITE_DEBUG_DRAW

	// reset
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glBlendFunc( CC_BLEND_SRC, CC_BLEND_DST );

	CC_PROFILER_STOP_CATEGORY(kCCProfilerCategorySprite, @"CCSprite - draw");
}

@end

Posted 3 months ago #

Harrison Xi
Member

Shader Program can help me to implement the effect I want. :)

Posted 3 months ago #

RSS feed for this topic

« Previous 12

Reply

You must log in to post.