public override void draw()
{
base.draw();
BlendState blendState = CCApplication.sharedApplication().GraphicsDevice.BlendState;
BlendState alphaBlend = BlendState.AlphaBlend;
if (base.IsBlendAdditive)
{
alphaBlend = BlendState.Additive;
}
CCApplication.sharedApplication().spriteBatch.Begin(SpriteSortMode.Deferred, alphaBlend);
for (int i = 0; i < base.ParticleCount; i++)
{
CCParticle particle = base.m_pParticles[i];
CCPoint obPoint = CCPointExtension.ccpAdd(CCAffineTransform.CCPointApplyAffineTransform(new CCPoint(), base.nodeToWorldTransform()), new CCPoint(this.m_pQuads[i].bl.vertices.x, this.m_pQuads[i].bl.vertices.y));
obPoint = CCDirector.sharedDirector().convertToUI(obPoint);
Vector2 position = new Vector2(obPoint.x, obPoint.y);
Color color = new Color(particle.color.r, particle.color.g, particle.color.b, particle.color.a);
float scale = 1f;
if (this.Texture.getTexture2D().Width > this.Texture.getTexture2D().Height)
{
scale = particle.size / ((float)this.Texture.getTexture2D().Height);
}
else
{
scale = particle.size / ((float)this.Texture.getTexture2D().Width);
}
float rotation = particle.rotation;
Vector2 origin = new Vector2((float)(this.Texture.getTexture2D().Width / 2), (float)(this.Texture.getTexture2D().Height / 2));
Rectangle?sourceRectangle = null;
CCApplication.sharedApplication().spriteBatch.Draw(this.Texture.getTexture2D(), position, sourceRectangle, color, rotation, origin, scale, SpriteEffects.None, 0f);
}
CCApplication.sharedApplication().spriteBatch.End();
CCApplication.sharedApplication().GraphicsDevice.BlendState = blendState;
}
public override CCFiniteTimeAction reverse()
{
ccBezierConfig _ccBezierConfig = new ccBezierConfig();
_ccBezierConfig.endPosition = CCPointExtension.ccpNeg(this.m_sConfig.endPosition);
_ccBezierConfig.controlPoint_1 = CCPointExtension.ccpAdd(this.m_sConfig.controlPoint_2, CCPointExtension.ccpNeg(this.m_sConfig.endPosition));
_ccBezierConfig.controlPoint_2 = CCPointExtension.ccpAdd(this.m_sConfig.controlPoint_1, CCPointExtension.ccpNeg(this.m_sConfig.endPosition));
return(CCBezierBy.actionWithDuration(this.m_fDuration, _ccBezierConfig));
}
public override CCFiniteTimeAction reverse()
{
ccBezierConfig r;
r.endPosition = CCPointExtension.ccpNeg(m_sConfig.endPosition);
r.controlPoint_1 = CCPointExtension.ccpAdd(m_sConfig.controlPoint_2, CCPointExtension.ccpNeg(m_sConfig.endPosition));
r.controlPoint_2 = CCPointExtension.ccpAdd(m_sConfig.controlPoint_1, CCPointExtension.ccpNeg(m_sConfig.endPosition));
CCBezierBy action = CCBezierBy.actionWithDuration(m_fDuration, r);
return(action);
}
public CCPoint convertToWorldSpaceAR(CCPoint nodePoint)
{
CCPoint tAnchorPointInPixels;
if (CCDirector.sharedDirector().ContentScaleFactor == 1f)
{
tAnchorPointInPixels = this.m_tAnchorPointInPixels;
}
else
{
tAnchorPointInPixels = CCPointExtension.ccpMult(this.m_tAnchorPointInPixels, 1f / CCDirector.sharedDirector().ContentScaleFactor);
}
CCPoint point2 = CCPointExtension.ccpAdd(nodePoint, tAnchorPointInPixels);
return(this.convertToWorldSpace(point2));
}
/// <summary>
/// Converts a local Point to world space coordinates.The result is in Points.
/// treating the returned/received node point as anchor relative.
/// </summary>
public CCPoint ConvertToWorldSpaceAR(CCPoint nodePoint)
{
CCPoint anchorInPoints;
if (Director.SharedDirector.ContentScaleFactor == 1)
{
anchorInPoints = AnchorPointInPixels;
}
else
{
anchorInPoints = CCPointExtension.ccpMult(AnchorPointInPixels, 1 / Director.SharedDirector.ContentScaleFactor);
}
CCPoint pt = CCPointExtension.ccpAdd(nodePoint, anchorInPoints);
return(ConvertToWorldSpace(pt));
}
public override void update(float dt)
{
if (this.m_pTarget != null)
{
float single = 0f;
float controlPoint1 = this.m_sConfig.controlPoint_1.x;
float controlPoint2 = this.m_sConfig.controlPoint_2.x;
float mSConfig = this.m_sConfig.endPosition.x;
float single1 = 0f;
float controlPoint11 = this.m_sConfig.controlPoint_1.y;
float controlPoint21 = this.m_sConfig.controlPoint_2.y;
float mSConfig1 = this.m_sConfig.endPosition.y;
float single2 = this.bezierat(single, controlPoint1, controlPoint2, mSConfig, dt);
float single3 = this.bezierat(single1, controlPoint11, controlPoint21, mSConfig1, dt);
this.m_pTarget.position = CCPointExtension.ccpAdd(this.m_startPosition, CCPointExtension.ccp(single2, single3));
}
}
public override void update(float dt)
{
if (m_pTarget != null)
{
float xa = 0;
float xb = m_sConfig.controlPoint_1.x;
float xc = m_sConfig.controlPoint_2.x;
float xd = m_sConfig.endPosition.x;
float ya = 0;
float yb = m_sConfig.controlPoint_1.y;
float yc = m_sConfig.controlPoint_2.y;
float yd = m_sConfig.endPosition.y;
float x = bezierat(xa, xb, xc, xd, dt);
float y = bezierat(ya, yb, yc, yd, dt);
m_pTarget.position = CCPointExtension.ccpAdd(m_startPosition, CCPointExtension.ccp(x, y));
}
}
public override void draw()
{
base.draw();
BlendState oldBlendState = Application.SharedApplication.GraphicsDevice.BlendState;
BlendState eBlendState = BlendState.AlphaBlend;
if (this.IsBlendAdditive)
{
eBlendState = BlendState.Additive;
}
Application.SharedApplication.SpriteBatch.Begin(SpriteSortMode.Deferred, eBlendState);
for (int i = 0; i < this.ParticleCount; i++)
{
CCParticle particle = m_pParticles[i];
CCPoint uiPoint = CCAffineTransform.CCPointApplyAffineTransform(new CCPoint(), this.nodeToWorldTransform());
uiPoint = CCPointExtension.ccpAdd(uiPoint, new CCPoint(m_pQuads[i].bl.vertices.x, m_pQuads[i].bl.vertices.y));
uiPoint = Director.SharedDirector.ConvertToUI(uiPoint);
Vector2 vecPosition = new Vector2(uiPoint.X, uiPoint.Y);
Color color = new Color(particle.color.r,
particle.color.g,
particle.color.b,
particle.color.a);
float scale = 1.0f;
if (Texture.Texture2D.Width > Texture.Texture2D.Height)
{
scale = particle.size / Texture.Texture2D.Height;
}
else
{
scale = particle.size / Texture.Texture2D.Width;
}
float rotation = particle.rotation;
Vector2 origin = new Vector2(Texture.Texture2D.Width / 2, Texture.Texture2D.Height / 2);
Application.SharedApplication.SpriteBatch.Draw(this.Texture.Texture2D, vecPosition, null, color, rotation, origin, scale, SpriteEffects.None, 0);
//CCPoint uiPoint = CCAffineTransform.CCPointApplyAffineTransform(new CCPoint(), this.nodeToWorldTransform());
//uiPoint.x += m_pQuads[i].bl.vertices.x;
//uiPoint.y += m_pQuads[i].bl.vertices.y;
//uiPoint = CCDirector.sharedDirector().convertToUI(uiPoint);
//Vector2 vecPosition = new Vector2(uiPoint.x, uiPoint.y);
//Color color = new Color(m_pQuads[i].bl.colors.r,
// m_pQuads[i].bl.colors.g,
// m_pQuads[i].bl.colors.b,
// m_pQuads[i].bl.colors.a);
//Vector2 origin = new Vector2(Texture.Texture2D.Width/2, Texture.Texture2D.Height/2);
//Application.SharedApplication.SpriteBatch.Draw(this.Texture.Texture2D, vecPosition, null, color, 0, origin, 1.0f, SpriteEffects.None, 0);
}
Application.SharedApplication.SpriteBatch.End();
Application.SharedApplication.GraphicsDevice.BlendState = oldBlendState;
// // 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: -
// glBindTexture(GL_TEXTURE_2D, m_pTexture->getName());
// #define kQuadSize sizeof(m_pQuads[0].bl)
// int offset = (int) m_pQuads;
// // vertex
// int diff = offsetof( ccV2F_C4B_T2F, vertices);
// glVertexPointer(2,GL_FLOAT, kQuadSize, (GLvoid*) (offset+diff) );
// // color
// diff = offsetof( ccV2F_C4B_T2F, colors);
// glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (GLvoid*)(offset + diff));
// // tex coords
// diff = offsetof( ccV2F_C4B_T2F, texCoords);
// glTexCoordPointer(2, GL_FLOAT, kQuadSize, (GLvoid*)(offset + diff));
// bool newBlend = (m_tBlendFunc.src != CC_BLEND_SRC || m_tBlendFunc.dst != CC_BLEND_DST) ? true : false;
// if( newBlend )
// {
// glBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );
// }
// CCAssert( m_uParticleIdx == m_uParticleCount, "Abnormal error in particle quad");
// glDrawElements(GL_TRIANGLES, (GLsizei)(m_uParticleIdx*6), GL_UNSIGNED_SHORT, m_pIndices);
// // restore blend state
// if( newBlend )
// glBlendFunc( CC_BLEND_SRC, CC_BLEND_DST );
//#if CC_USES_VBO
// glBindBuffer(GL_ARRAY_BUFFER, 0);
//#endif
}
public override void update(float dt)
{
if (this.m_bIsActive && (this.m_fEmissionRate != 0f))
{
float num = 1f / this.m_fEmissionRate;
this.m_fEmitCounter += dt;
while ((this.m_uParticleCount < this.m_uTotalParticles) && (this.m_fEmitCounter > num))
{
this.addParticle();
this.m_fEmitCounter -= num;
}
this.m_fElapsed += dt;
if ((this.m_fDuration != -1f) && (this.m_fDuration < this.m_fElapsed))
{
this.stopSystem();
}
}
this.m_uParticleIdx = 0;
CCPoint tPosition = new CCPoint(0f, 0f);
if (this.m_ePositionType == eParticlePositionType.kCCPositionTypeFree)
{
tPosition = base.convertToWorldSpace(new CCPoint(0f, 0f));
tPosition.x *= CCDirector.sharedDirector().ContentScaleFactor;
tPosition.y *= CCDirector.sharedDirector().ContentScaleFactor;
}
else if (this.m_ePositionType == eParticlePositionType.kCCPositionTypeRelative)
{
tPosition = base.m_tPosition;
tPosition.x *= CCDirector.sharedDirector().ContentScaleFactor;
tPosition.y *= CCDirector.sharedDirector().ContentScaleFactor;
}
while (this.m_uParticleIdx < this.m_uParticleCount)
{
CCParticle particle = this.m_pParticles[this.m_uParticleIdx];
particle.timeToLive -= dt;
if (particle.timeToLive > 0f)
{
CCPoint pos;
if (this.m_nEmitterMode == 0)
{
CCPoint v = new CCPoint(0f, 0f);
if ((particle.pos.x != 0f) || (particle.pos.y != 0f))
{
v = CCPointExtension.ccpNormalize(particle.pos);
}
CCPoint point4 = v;
v = CCPointExtension.ccpMult(v, particle.modeA.radialAccel);
float x = point4.x;
point4.x = -point4.y;
point4.y = x;
point4 = CCPointExtension.ccpMult(point4, particle.modeA.tangentialAccel);
CCPoint point2 = CCPointExtension.ccpMult(CCPointExtension.ccpAdd(CCPointExtension.ccpAdd(v, point4), this.modeA.gravity), dt);
particle.modeA.dir = CCPointExtension.ccpAdd(particle.modeA.dir, point2);
point2 = CCPointExtension.ccpMult(particle.modeA.dir, dt);
particle.pos = CCPointExtension.ccpAdd(particle.pos, point2);
}
else
{
particle.modeB.angle += particle.modeB.degreesPerSecond * dt;
particle.modeB.radius += particle.modeB.deltaRadius * dt;
particle.pos.x = -((float)Math.Cos((double)particle.modeB.angle)) * particle.modeB.radius;
particle.pos.y = -((float)Math.Sin((double)particle.modeB.angle)) * particle.modeB.radius;
}
particle.color.r += particle.deltaColor.r * dt;
particle.color.g += particle.deltaColor.g * dt;
particle.color.b += particle.deltaColor.b * dt;
particle.color.a += particle.deltaColor.a * dt;
particle.size += particle.deltaSize * dt;
particle.size = (0f > particle.size) ? 0f : particle.size;
particle.rotation += particle.deltaRotation * dt;
if ((this.m_ePositionType == eParticlePositionType.kCCPositionTypeFree) || (this.m_ePositionType == eParticlePositionType.kCCPositionTypeRelative))
{
CCPoint point6 = CCPointExtension.ccpSub(tPosition, particle.startPos);
pos = CCPointExtension.ccpSub(particle.pos, point6);
}
else
{
pos = particle.pos;
}
this.updateQuadWithParticle(particle, pos);
this.m_uParticleIdx++;
}
else
{
if (this.m_uParticleIdx != (this.m_uParticleCount - 1))
{
this.m_pParticles[this.m_uParticleIdx].copy(this.m_pParticles[(int)((IntPtr)(this.m_uParticleCount - 1))]);
}
this.m_uParticleCount--;
if ((this.m_uParticleCount == 0) && this.m_bIsAutoRemoveOnFinish)
{
base.unscheduleUpdate();
base.m_pParent.removeChild(this, true);
return;
}
}
}
this.postStep();
}
protected void updateRadial()
{
float single = Math.Max(this.m_pSprite.quad.br.texCoords.u, this.m_pSprite.quad.bl.texCoords.u);
float single1 = Math.Min(this.m_pSprite.quad.br.texCoords.u, this.m_pSprite.quad.bl.texCoords.u);
float single2 = Math.Max(this.m_pSprite.quad.tl.texCoords.v, this.m_pSprite.quad.bl.texCoords.v);
float single3 = Math.Min(this.m_pSprite.quad.tl.texCoords.v, this.m_pSprite.quad.bl.texCoords.v);
CCPoint cCPoint = new CCPoint(single, single2);
CCPoint cCPoint1 = new CCPoint(single1, single3);
CCPoint cCPoint2 = CCPointExtension.ccpAdd(cCPoint1, CCPointExtension.ccpCompMult(this.m_tAnchorPoint, CCPointExtension.ccpSub(cCPoint, cCPoint1)));
float mFPercentage = this.m_fPercentage / 100f;
float single4 = 6.28318548f * (this.m_eType == CCProgressTimerType.kCCProgressTimerTypeRadialCW ? mFPercentage : 1f - mFPercentage);
CCPoint cCPoint3 = new CCPoint(cCPoint2.x, cCPoint1.y);
CCPoint cCPoint4 = CCPointExtension.ccpRotateByAngle(cCPoint3, cCPoint2, single4);
int num = 0;
CCPoint cCPoint5 = new CCPoint();
if (mFPercentage == 0f)
{
cCPoint5 = cCPoint3;
num = 0;
}
else if (mFPercentage != 1f)
{
float single5 = float.MaxValue;
for (int i = 0; i <= 4; i++)
{
int num1 = (i + 3) % 4;
CCPoint cCPoint6 = CCPointExtension.ccpAdd(cCPoint1, CCPointExtension.ccpCompMult(this.boundaryTexCoord(i % 4), CCPointExtension.ccpSub(cCPoint, cCPoint1)));
CCPoint cCPoint7 = CCPointExtension.ccpAdd(cCPoint1, CCPointExtension.ccpCompMult(this.boundaryTexCoord(num1), CCPointExtension.ccpSub(cCPoint, cCPoint1)));
if (i == 0)
{
cCPoint7 = CCPointExtension.ccpLerp(cCPoint6, cCPoint7, 0.5f);
}
else if (i == 4)
{
cCPoint6 = CCPointExtension.ccpLerp(cCPoint6, cCPoint7, 0.5f);
}
float single6 = 0f;
float single7 = 0f;
if (CCPointExtension.ccpLineIntersect(cCPoint6, cCPoint7, cCPoint2, cCPoint4, ref single6, ref single7) && (i != 0 && i != 4 || 0f <= single6 && single6 <= 1f) && single7 >= 0f && single7 < single5)
{
single5 = single7;
num = i;
}
}
cCPoint5 = CCPointExtension.ccpAdd(cCPoint2, CCPointExtension.ccpMult(CCPointExtension.ccpSub(cCPoint4, cCPoint2), single5));
}
else
{
cCPoint5 = cCPoint3;
num = 4;
}
bool flag = true;
if (this.m_nVertexDataCount != num + 3)
{
flag = false;
if (this.m_pVertexData != null)
{
this.m_pVertexData = null;
this.m_nVertexDataCount = 0;
}
}
if (this.m_pVertexData == null)
{
this.m_nVertexDataCount = num + 3;
this.m_pVertexData = new ccV2F_C4B_T2F[this.m_nVertexDataCount];
for (int j = 0; j < this.m_nVertexDataCount; j++)
{
this.m_pVertexData[j] = new ccV2F_C4B_T2F();
}
this.updateColor();
}
if (!flag)
{
this.m_pVertexData[0].texCoords = new ccTex2F(cCPoint2.x, cCPoint2.y);
this.m_pVertexData[0].vertices = this.vertexFromTexCoord(cCPoint2);
this.m_pVertexData[1].texCoords = new ccTex2F(cCPoint2.x, cCPoint1.y);
this.m_pVertexData[1].vertices = this.vertexFromTexCoord(new CCPoint(cCPoint2.x, cCPoint1.y));
for (int k = 0; k < num; k++)
{
CCPoint cCPoint8 = CCPointExtension.ccpAdd(cCPoint1, CCPointExtension.ccpCompMult(this.boundaryTexCoord(k), CCPointExtension.ccpSub(cCPoint, cCPoint1)));
this.m_pVertexData[k + 2].texCoords = new ccTex2F(cCPoint8.x, cCPoint8.y);
this.m_pVertexData[k + 2].vertices = this.vertexFromTexCoord(cCPoint8);
}
if (this.m_pSprite.IsFlipX || this.m_pSprite.IsFlipY)
{
for (int l = 0; l < this.m_nVertexDataCount - 1; l++)
{
if (this.m_pSprite.IsFlipX)
{
this.m_pVertexData[l].texCoords.u = cCPoint1.x + cCPoint.x - this.m_pVertexData[l].texCoords.u;
}
if (this.m_pSprite.IsFlipY)
{
this.m_pVertexData[l].texCoords.v = cCPoint1.y + cCPoint.y - this.m_pVertexData[l].texCoords.v;
}
}
}
}
this.m_pVertexData[this.m_nVertexDataCount - 1].texCoords = new ccTex2F(cCPoint5.x, cCPoint5.y);
this.m_pVertexData[this.m_nVertexDataCount - 1].vertices = this.vertexFromTexCoord(cCPoint5);
if (this.m_pSprite.IsFlipX || this.m_pSprite.IsFlipY)
{
if (this.m_pSprite.IsFlipX)
{
this.m_pVertexData[this.m_nVertexDataCount - 1].texCoords.u = cCPoint1.x + cCPoint.x - this.m_pVertexData[this.m_nVertexDataCount - 1].texCoords.u;
}
if (this.m_pSprite.IsFlipY)
{
this.m_pVertexData[this.m_nVertexDataCount - 1].texCoords.v = cCPoint1.y + cCPoint.y - this.m_pVertexData[this.m_nVertexDataCount - 1].texCoords.v;
}
}
}
public static CCPoint ccpMidpoint(CCPoint v1, CCPoint v2)
{
return(CCPointExtension.ccpMult(CCPointExtension.ccpAdd(v1, v2), 0.5f));
}
public static CCPoint ccpLerp(CCPoint a, CCPoint b, float alpha)
{
return(CCPointExtension.ccpAdd(CCPointExtension.ccpMult(a, 1f - alpha), CCPointExtension.ccpMult(b, alpha)));
}
/// <summary>
/// Update does the work of mapping the texture onto the triangles
// It now doesn't occur the cost of free/alloc data every update cycle.
// It also only changes the percentage point but no other points if they have not
// been modified.
//
// It now deals with flipped texture. If you run into this problem, just use the
// sprite property and enable the methods flipX, flipY.
/// </summary>
protected void updateRadial()
{
// Texture Max is the actual max coordinates to deal with non-power of 2 textures
float fXMax = Math.Max(m_pSprite.quad.br.texCoords.u, m_pSprite.quad.bl.texCoords.u);
float fXMin = Math.Min(m_pSprite.quad.br.texCoords.u, m_pSprite.quad.bl.texCoords.u);
float fYMax = Math.Max(m_pSprite.quad.tl.texCoords.v, m_pSprite.quad.bl.texCoords.v);
float fYMin = Math.Min(m_pSprite.quad.tl.texCoords.v, m_pSprite.quad.bl.texCoords.v);
CCPoint tMax = new CCPoint(fXMax, fYMax);
CCPoint tMin = new CCPoint(fXMin, fYMin);
// Grab the midpoint
CCPoint midpoint = CCPointExtension.ccpAdd(tMin, CCPointExtension.ccpCompMult(m_tAnchorPoint, CCPointExtension.ccpSub(tMax, tMin)));
float alpha = m_fPercentage / 100.0f;
// Otherwise we can get the angle from the alpha
float angle = 2.0f * ((float)Math.PI) * (m_eType == CCProgressTimerType.kCCProgressTimerTypeRadialCW ? alpha : 1.0f - alpha);
// We find the vector to do a hit detection based on the percentage
// We know the first vector is the one @ 12 o'clock (top,mid) so we rotate
// from that by the progress angle around the midpoint pivot
CCPoint topMid = new CCPoint(midpoint.x, tMin.y);
CCPoint percentagePt = CCPointExtension.ccpRotateByAngle(topMid, midpoint, angle);
int index = 0;
CCPoint hit = new CCPoint();
if (alpha == 0.0f)
{
// More efficient since we don't always need to check intersection
// If the alpha is zero then the hit point is top mid and the index is 0.
hit = topMid;
index = 0;
}
else
if (alpha == 1.0f)
{
// More efficient since we don't always need to check intersection
// If the alpha is one then the hit point is top mid and the index is 4.
hit = topMid;
index = 4;
}
else
{
// We run a for loop checking the edges of the texture to find the
// intersection point
// We loop through five points since the top is split in half
float min_t = float.MaxValue;
for (int i = 0; i <= kProgressTextureCoordsCount; ++i)
{
int pIndex = (i + (kProgressTextureCoordsCount - 1)) % kProgressTextureCoordsCount;
CCPoint edgePtA = CCPointExtension.ccpAdd(tMin, CCPointExtension.ccpCompMult(boundaryTexCoord(i % kProgressTextureCoordsCount), CCPointExtension.ccpSub(tMax, tMin)));
CCPoint edgePtB = CCPointExtension.ccpAdd(tMin, CCPointExtension.ccpCompMult(boundaryTexCoord(pIndex), CCPointExtension.ccpSub(tMax, tMin)));
// Remember that the top edge is split in half for the 12 o'clock position
// Let's deal with that here by finding the correct endpoints
if (i == 0)
{
edgePtB = CCPointExtension.ccpLerp(edgePtA, edgePtB, 0.5f);
}
else
if (i == 4)
{
edgePtA = CCPointExtension.ccpLerp(edgePtA, edgePtB, 0.5f);
}
// s and t are returned by ccpLineIntersect
float s = 0;
float t = 0;
if (CCPointExtension.ccpLineIntersect(edgePtA, edgePtB, midpoint, percentagePt, ref s, ref t))
{
// Since our hit test is on rays we have to deal with the top edge
// being in split in half so we have to test as a segment
if (i == 0 || i == 4)
{
// s represents the point between edgePtA--edgePtB
if (!(0.0f <= s && s <= 1.0f))
{
continue;
}
}
// As long as our t isn't negative we are at least finding a
// correct hitpoint from midpoint to percentagePt.
if (t >= 0.0f)
{
// Because the percentage line and all the texture edges are
// rays we should only account for the shortest intersection
if (t < min_t)
{
min_t = t;
index = i;
}
}
}
}
// Now that we have the minimum magnitude we can use that to find our intersection
hit = CCPointExtension.ccpAdd(midpoint, CCPointExtension.ccpMult(CCPointExtension.ccpSub(percentagePt, midpoint), min_t));
}
// The size of the vertex data is the index from the hitpoint
// the 3 is for the midpoint, 12 o'clock point and hitpoint position.
bool sameIndexCount = true;
if (m_nVertexDataCount != index + 3)
{
sameIndexCount = false;
if (m_pVertexData != null)
{
m_pVertexData = null;
m_nVertexDataCount = 0;
}
}
if (m_pVertexData == null)
{
m_nVertexDataCount = index + 3;
m_pVertexData = new ccV2F_C4B_T2F[m_nVertexDataCount];
for (int i = 0; i < m_nVertexDataCount; i++)
{
m_pVertexData[i] = new ccV2F_C4B_T2F();
}
Debug.Assert(m_pVertexData != null);
updateColor();
}
if (!sameIndexCount)
{
// First we populate the array with the midpoint, then all
// vertices/texcoords/colors of the 12 'o clock start and edges and the hitpoint
m_pVertexData[0].texCoords = new ccTex2F(midpoint.x, midpoint.y);
m_pVertexData[0].vertices = vertexFromTexCoord(midpoint);
m_pVertexData[1].texCoords = new ccTex2F(midpoint.x, tMin.y);
m_pVertexData[1].vertices = vertexFromTexCoord(new CCPoint(midpoint.x, tMin.y));
for (int i = 0; i < index; ++i)
{
CCPoint texCoords = CCPointExtension.ccpAdd(tMin, CCPointExtension.ccpCompMult(boundaryTexCoord(i), CCPointExtension.ccpSub(tMax, tMin)));
m_pVertexData[i + 2].texCoords = new ccTex2F(texCoords.x, texCoords.y);
m_pVertexData[i + 2].vertices = vertexFromTexCoord(texCoords);
}
// Flip the texture coordinates if set
if (m_pSprite.IsFlipX || m_pSprite.IsFlipY)
{
for (int i = 0; i < m_nVertexDataCount - 1; ++i)
{
if (m_pSprite.IsFlipX)
{
m_pVertexData[i].texCoords.u = tMin.x + tMax.x - m_pVertexData[i].texCoords.u;
}
if (m_pSprite.IsFlipY)
{
m_pVertexData[i].texCoords.v = tMin.y + tMax.y - m_pVertexData[i].texCoords.v;
}
}
}
}
// hitpoint will go last
m_pVertexData[m_nVertexDataCount - 1].texCoords = new ccTex2F(hit.x, hit.y);
m_pVertexData[m_nVertexDataCount - 1].vertices = vertexFromTexCoord(hit);
if (m_pSprite.IsFlipX || m_pSprite.IsFlipY)
{
if (m_pSprite.IsFlipX)
{
m_pVertexData[m_nVertexDataCount - 1].texCoords.u = tMin.x + tMax.x - m_pVertexData[m_nVertexDataCount - 1].texCoords.u;
}
if (m_pSprite.IsFlipY)
{
m_pVertexData[m_nVertexDataCount - 1].texCoords.v = tMin.y + tMax.y - m_pVertexData[m_nVertexDataCount - 1].texCoords.v;
}
}
}
